Create Access Control List

Create a new access control list for your client.

POST https://{tenantDomain}/api/v2/network-acls

C#

C#

using Auth0.ManagementApi;
using System.Threading.Tasks;

public partial class Examples
{
    public async Task Example() {
        var client = new ManagementClient(
            token: "<token>"
        );

        await client.NetworkAcls.CreateAsync(
            new CreateNetworkAclRequestContent {
                Description = "description",
                Active = true,
                Rule = new NetworkAclRule {
                    Action = new NetworkAclAction(),
                    Scope = NetworkAclRuleScopeEnum.Management
                }
            }
        );
    }

}

package example

import (
    context "context"

    management "github.com/auth0/go-auth0/management/management"
    client "github.com/auth0/go-auth0/management/management/client"
    option "github.com/auth0/go-auth0/management/management/option"
)

func do() {
    client := client.NewClient(
        option.WithToken(
            "<token>",
        ),
    )
    request := &management.CreateNetworkAclRequestContent{
        Description: "description",
        Active: true,
        Priority: 1.1,
        Rule: &management.NetworkAclRule{
            Action: &management.NetworkAclAction{},
            Scope: management.NetworkAclRuleScopeEnumManagement,
        },
    }
    client.NetworkAcls.Create(
        context.TODO(),
        request,
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.resources.networkacls.requests.CreateNetworkAclRequestContent;
import com.auth0.client.mgmt.types.NetworkAclAction;
import com.auth0.client.mgmt.types.NetworkAclRule;
import com.auth0.client.mgmt.types.NetworkAclRuleScopeEnum;

public class Example {
    public static void main(String[] args) {
        ManagementApi client = ManagementApi
            .builder()
            .token("<token>")
            .build();

        client.networkAcls().create(
            CreateNetworkAclRequestContent
                .builder()
                .description("description")
                .active(true)
                .rule(
                    NetworkAclRule
                        .builder()
                        .action(
                            NetworkAclAction
                                .builder()
                                .build()
                        )
                        .scope(NetworkAclRuleScopeEnum.MANAGEMENT)
                        .build()
                )
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Management;
use Auth0\SDK\API\Management\NetworkAcls\Requests\CreateNetworkAclRequestContent;
use Auth0\SDK\API\Management\Types\NetworkAclRule;
use Auth0\SDK\API\Management\Types\NetworkAclAction;
use Auth0\SDK\API\Management\Types\NetworkAclRuleScopeEnum;

$client = new Management(
    token: '<token>',
);
$client->networkAcls->create(
    new CreateNetworkAclRequestContent([
        'description' => 'description',
        'active' => true,
        'rule' => new NetworkAclRule([
            'action' => new NetworkAclAction([]),
            'scope' => NetworkAclRuleScopeEnum::Management->value,
        ]),
    ]),
);

from auth0.management import ManagementClient, NetworkAclRule, NetworkAclAction

client = ManagementClient(
    token="<token>",
)

client.network_acls.create(
    description="description",
    active=True,
    rule=NetworkAclRule(
        action=NetworkAclAction(),
        scope="management",
    ),
)

require "auth0"

client = Auth0::Management.new(token: "<token>")

client.network_acls.create(
  description: "description",
  active: true,
  rule: {
    action: {},
    scope: "management"
  }
)

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        token: "<token>",
    });
    await client.networkAcls.create({
        description: "description",
        active: true,
        priority: 1.1,
        rule: {
            action: {},
            scope: "management",
        },
    });
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        token: "<token>",
    });
    await client.networkAcls.create({
        description: "description",
        active: true,
        priority: 1.1,
        rule: {
            action: {},
            scope: "management",
        },
    });
}
main();

curl --request POST \
  --url https://{tenantDomain}/api/v2/network-acls \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "description": "<string>",
  "active": true,
  "rule": {
    "action": {
      "block": true,
      "allow": true,
      "log": true,
      "redirect": true,
      "redirect_uri": "<string>"
    },
    "match": {
      "asns": [
        123
      ],
      "geo_country_codes": [
        "<string>"
      ],
      "geo_subdivision_codes": [
        "<string>"
      ],
      "ipv4_cidrs": [
        "127.0.0.1"
      ],
      "ipv6_cidrs": [
        "2606:4700:3108::ac42:2835"
      ],
      "ja3_fingerprints": [
        "<string>"
      ],
      "ja4_fingerprints": [
        "<string>"
      ],
      "user_agents": [
        "<string>"
      ],
      "hostnames": [
        "<string>"
      ],
      "connecting_ipv4_cidrs": [
        "127.0.0.1"
      ],
      "connecting_ipv6_cidrs": [
        "2606:4700:3108::ac42:2835"
      ]
    },
    "not_match": {
      "asns": [
        123
      ],
      "geo_country_codes": [
        "<string>"
      ],
      "geo_subdivision_codes": [
        "<string>"
      ],
      "ipv4_cidrs": [
        "127.0.0.1"
      ],
      "ipv6_cidrs": [
        "2606:4700:3108::ac42:2835"
      ],
      "ja3_fingerprints": [
        "<string>"
      ],
      "ja4_fingerprints": [
        "<string>"
      ],
      "user_agents": [
        "<string>"
      ],
      "hostnames": [
        "<string>"
      ],
      "connecting_ipv4_cidrs": [
        "127.0.0.1"
      ],
      "connecting_ipv6_cidrs": [
        "2606:4700:3108::ac42:2835"
      ]
    }
  },
  "priority": 50
}
'

Autorisations

bearerAuthoAuth2ClientCredentials

Authorization · string · header · requis

Bearer authentication header of the form Bearer <token>, where <token> is your auth token.

Corps

application/jsonapplication/x-www-form-urlencoded

description · string · requis

Maximum string length: 255

active · boolean · requis

Indicates whether or not this access control list is actively being used

rule · object · requis

Show child attributes

priority · number · défaut: 50

Indicates the order in which the ACL will be evaluated relative to other ACL rules.

Plage requise: 1 <= x <= 100

Réponse

201

Network ACL successfully created.