> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Exemples de code pour des cas d’utilisation courants de l’ACL du locataire
> Implémentez des cas d’utilisation courants de l’ACL du locataire à l’aide de ces exemples de code pour les requêtes vers la Management API, les SDK et CLI Auth0, ainsi que le Terraform Provider d’Auth0.
## Bloquer une requête
Cet exemple de règle ACL du locataire bloque le trafic entrant provenant d’un code de pays de géolocalisation donné.
Pour créer cette règle ACL du locataire avec la Management API :
1. [Obtenez un jeton d’accès pour la Management API](/fr-CA/docs/secure/tokens/access-tokens/management-api-access-tokens/get-management-api-access-tokens-for-production) avec le scope `create:network_acls`.
2. Appelez le [point de terminaison de création d’une liste de contrôle d’accès](https://auth0.com/docs/api/management/v2/network-acls/post-network-acls) de la Management API avec le corps suivant :
```json expandable theme={null}
{
"description": "Example of blocking a request",
"active": true,
"priority": 2,
"rule": {
"action": {
"block": true
},
"match": {
"geo_country_codes": [
"{geoCountryCode}"
]
},
"scope": "authentication"
}
}{
"description": "Example of blocking a request",
"active": true,
"priority": 2,
"rule": {
"action": {
"block": true
},
"match": {
"geo_country_codes": [
"{geoCountryCode}"
]
},
"scope": "authentication"
}
}
```
```go expandable theme={null}
package main
import (
"context"
"log"
"github.com/auth0/go-auth0"
"github.com/auth0/go-auth0/management"
)
func main() {
mgmt, err := management.New("{yourDomain}", management.WithClientCredentials("{yourClientId}", "{yourClientSecret}"))
if err != nil {
log.Fatal(err)
}
networkACL := &management.NetworkACL{
Description: auth0.String("Example of blocking a request"),
Active: auth0.Bool(true),
Priority: auth0.Int(2),
Rule: &management.NetworkACLRule{
Action: &management.NetworkACLRuleAction{
Block: auth0.Bool(true),
},
Match: &management.NetworkACLRuleMatch{
GeoCountryCodes: &[]string{"{geoCountryCode}"},
},
Scope: auth0.String("authentication"),
},
}
err = mgmt.NetworkACL.Create(context.Background(), networkACL)
if err != nil {
log.Fatal(err)
}
log.Println("Network ACL has been created")
}
```
```js theme={null}
const createNetworkAclPayload: Management.CreateNetworkAclRequestContent = {
description: "Example of blocking a request",
active: true,
priority: 2,
rule: {
action: {
block: true,
},
match: {
geo_country_codes: ["{geoCountryCode}"],
},
scope: "authentication",
},
};
const createNetworkAcl = await client.networkAcls.create(createNetworkAclPayload);
```
```terraform theme={null}
resource "auth0_network_acl" "example_blocking_request_acl" {
description = "Example of blocking a request"
active = true
priority = 2
rule {
action {
block = true
}
match {
geo_country_codes = ["{geoCountryCode}"]
}
scope = "authentication"
}
}
```
```yaml theme={null}
networkACLs:
- description: Example of blocking a request
active: true
priority: 2
rule:
action:
block: true
match:
geo_country_codes:
- {geoCountryCode}
scope: authentication
```
```bash wrap theme={null}
auth0 network-acl create \
--description "Example of blocking a request" \
--active true \
--priority 2 \
--rule '{"action":{"block":true},"match":{"geo_country_codes":["{geoCountryCode}"]},"scope":"authentication"}'
```
Voici un exemple de page de blocage :
## Autoriser une requête
Cet exemple de règle ACL du locataire autorise le trafic uniquement pour un code de pays de géolocalisation précis.
Pour créer cette règle ACL du locataire avec la Management API :
1. [Obtenez un jeton d’accès pour la Management API](/fr-CA/docs/secure/tokens/access-tokens/management-api-access-tokens/get-management-api-access-tokens-for-production) avec le scope `create:network_acls`.
2. Appelez le [point de terminaison de création d’une liste de contrôle d’accès](https://auth0.com/docs/api/management/v2/network-acls/post-network-acls) de la Management API avec le corps suivant :
```json theme={null}
{
"description": "Example of allowing a request",
"active": true,
"priority": 2,
"rule": {
"action": {
"allow": true
},
"match": {
"geo_country_codes": [
"{geoCountryCode}"
]
},
"scope": "authentication"
}
}
```
```go expandable theme={null}
package main
import (
"context"
"log"
"github.com/auth0/go-auth0"
"github.com/auth0/go-auth0/management"
)
func main() {
mgmt, err := management.New("{yourDomain}", management.WithClientCredentials("{yourClientId}", "{yourClientSecret}"))
if err != nil {
log.Fatal(err)
}
networkACL := &management.NetworkACL{
Description: auth0.String("Example of allowing a request"),
Active: auth0.Bool(true),
Priority: auth0.Int(2),
Rule: &management.NetworkACLRule{
Action: &management.NetworkACLRuleAction{
Allow: auth0.Bool(true),
},
Match: &management.NetworkACLRuleMatch{
GeoCountryCodes: &[]string{"{geoCountryCode}"},
},
Scope: auth0.String("authentication"),
},
}
err = mgmt.NetworkACL.Create(context.Background(), networkACL)
if err != nil {
log.Fatal(err)
}
log.Println("Network ACL has been created")
}
```
```js theme={null}
const createNetworkAclPayload: Management.CreateNetworkAclRequestContent = {
description: "Example of allowing a request",
active: true,
priority: 2,
rule: {
action: {
allow: true,
},
match: {
geo_country_codes: ["{geoCountryCode}"],
},
scope: "authentication",
},
};
const createNetworkAcl = await client.networkAcls.create(createNetworkAclPayload);
```
```terraform theme={null}
resource "auth0_network_acl" "example_allowing_request_acl" {
description = "Example of allowing a request"
active = true
priority = 2
rule {
action {
allow = true
}
match {
geo_country_codes = ["{geoCountryCode}"]
}
scope = "authentication"
}
}
```
```yaml theme={null}
networkACLs:
- description: Example of allowing a request
active: true
priority: 2
rule:
action:
allow: true
match:
geo_country_codes:
- {geoCountryCode}
scope: authentication
```
```bash wrap theme={null}
auth0 network-acl create \
--description "Example of allowing a request" \
--active true \
--priority 2 \
--rule '{"action":{"allow":true},"match":{"geo_country_codes":["{geoCountryCode}"]},"scope":"authentication"}'
```
## Rediriger une requête
Cet exemple de règle ACL du locataire redirige tout le trafic associé à un code de pays de géolocalisation précis.
Pour créer cette règle ACL du locataire avec la Management API :
1. [Obtenez un jeton d’accès de la Management API](/fr-CA/docs/secure/tokens/access-tokens/management-api-access-tokens/get-management-api-access-tokens-for-production) avec le scope `create:network_acls`.
2. Appelez le point de terminaison [point de terminaison de création d’une liste de contrôle d’accès](https://auth0.com/docs/api/management/v2/network-acls/post-network-acls) de la Management API avec le corps suivant :
```json theme={null}
{
"description": "Example of redirecting a request",
"active": true,
"priority": 2,
"rule": {
"action": {
"redirect": true,
"redirect_uri": "REDIRECT_URI"
},
"match": {
"geo_country_codes": [
"{geoCountryCode}"
]
},
"scope": "authentication"
}
}
```
```go expandable theme={null}
package main
import (
"context"
"log"
"github.com/auth0/go-auth0"
"github.com/auth0/go-auth0/management"
)
func main() {
mgmt, err := management.New("{yourDomain}", management.WithClientCredentials("{yourClientId}", "{yourClientSecret}"))
if err != nil {
log.Fatal(err)
}
networkACL := &management.NetworkACL{
Description: auth0.String("Example of redirecting a request"),
Active: auth0.Bool(true),
Priority: auth0.Int(2),
Rule: &management.NetworkACLRule{
Action: &management.NetworkACLRuleAction{
Redirect: auth0.Bool(true),
RedirectURI: auth0.String("REDIRECT_URI"),
},
Match: &management.NetworkACLRuleMatch{
GeoCountryCodes: &[]string{"{geoCountryCode}"},
},
Scope: auth0.String("authentication"),
},
}
err = mgmt.NetworkACL.Create(context.Background(), networkACL)
if err != nil {
log.Fatal(err)
}
log.Println("Network ACL has been created")
}
```
```js theme={null}
const createNetworkAclPayload: Management.CreateNetworkAclRequestContent = {
description: "Example of a complex comparison",
active: true,
priority: 1,
rule: {
action: {
block: true,
},
match: {
geo_country_codes: ["{geoCountryCode}"],
},
not_match: {
geo_subdivision_codes: ["{geoSubdivisionCode}"],
},
scope: "authentication",
},
};
const createNetworkAcl = await client.networkAcls.create(createNetworkAclPayload);
```
```terraform theme={null}
resource "auth0_network_acl" "example_complex_comparison_acl" {
description = "Example of a complex comparison"
active = true
priority = 1
rule {
action {
block = true
}
match {
geo_country_codes = ["{geoCountryCode}"]
}
not_match {
geo_subdivision_codes = ["{geoSubdivisionCode}"]
}
scope = "authentication"
}
}
```
```yaml theme={null}
networkACLs:
- description: Example of a complex comparison
active: true
priority: 1
rule:
action:
block: true
match:
geo_country_codes:
- {geoCountryCode}
not_match:
geo_subdivision_codes:
- {geoSubdivisionCode}
scope: authentication
```
```bash wrap theme={null}
auth0 network-acl create \
--description "Example of a complex comparison"
--active true \
--priority 1 \
--rule '{"action":{"block":true},"match":{"geo_country_codes":["{geoCountryCode}"]},"not_match":{"geo_subdivision_codes":["{geoSubdivisionCode}"]},"scope":"authentication"}'
```
## Comparaisons complexes
Vous pouvez combiner les opérateurs `match` et `not_match` dans une seule règle ACL du locataire afin d’appliquer des politiques d’accès granulaires.
Cet exemple de règle ACL du locataire évalue les signaux `geo_country_code` et `geo_subdivision_code` afin de bloquer tout le trafic provenant d’un pays donné, sauf celui provenant d’un état, d’une région ou d’une province précise dans ce pays.
Pour créer cette règle ACL du locataire avec la Management API :
1. [Obtenez un jeton d’accès à la Management API](/fr-CA/docs/secure/tokens/access-tokens/management-api-access-tokens/get-management-api-access-tokens-for-production) avec le scope `create:network_acls`.
2. Appelez le [point de terminaison de création d’une liste de contrôle d’accès](https://auth0.com/docs/api/management/v2/network-acls/post-network-acls) de la Management API avec le corps suivant :
```json theme={null}
{
"description": "Example of a complex comparison",
"active": true,
"priority": 1,
"rule": {
"action": {
"block": true
},
"match": {
"geo_country_codes": [
"{geoCountryCode}"
]
},
"not_match": {
"geo_subdivision_codes": [
"{geoSubdivisionCode}"
]
},
"scope": "authentication"
}
}
```
```go expandable theme={null}
package main
import (
"context"
"log"
"github.com/auth0/go-auth0"
"github.com/auth0/go-auth0/management"
)
func main() {
mgmt, err := management.New("{yourDomain}", management.WithClientCredentials("{yourClientId}", "{yourClientSecret}"))
if err != nil {
log.Fatal(err)
}
networkACL := &management.NetworkACL{
Description: auth0.String("Example of a complex comparison"),
Active: auth0.Bool(true),
Priority: auth0.Int(1),
Rule: &management.NetworkACLRule{
Action: &management.NetworkACLRuleAction{
Block: auth0.Bool(true),
},
Match: &management.NetworkACLRuleMatch{
GeoCountryCodes: &[]string{"{geoCountryCode}"},
},
NotMatch: &management.NetworkACLRuleMatch{
GeoSubdivisionCodes: &[]string{"{geoSubdivisionCode}"},
},
Scope: auth0.String("authentication"),
},
}
err = mgmt.NetworkACL.Create(context.Background(), networkACL)
if err != nil {
log.Fatal(err)
}
log.Println("Network ACL has been created")
}
```
```js theme={null}
const createNetworkAclPayload: Management.CreateNetworkAclRequestContent = {
description: "Example of a complex comparison",
active: true,
priority: 1,
rule: {
action: {
block: true,
},
match: {
geo_country_codes: ["{geoCountryCode}"],
},
not_match: {
geo_subdivision_codes: ["{geoSubdivisionCode}"],
},
scope: "authentication",
},
};
const createNetworkAcl = await client.networkAcls.create(createNetworkAclPayload);
```
```terraform theme={null}
resource "auth0_network_acl" "example_complex_comparison_acl" {
description = "Example of a complex comparison"
active = true
priority = 1
rule {
action {
block = true
}
match {
geo_country_codes = ["{geoCountryCode}"]
}
not_match {
geo_subdivision_codes = ["{geoSubdivisionCode}"]
}
scope = "authentication"
}
}
```
```yaml theme={null}
networkACLs:
- description: Example of a complex comparison
active: true
priority: 1
rule:
action:
block: true
match:
geo_country_codes:
- {geoCountryCode}
not_match:
geo_subdivision_codes:
- {geoSubdivisionCode}
scope: authentication
```
```bash wrap theme={null}
auth0 network-acl create \
--description "Example of a complex comparison" \
--active true \
--priority 1 \
--rule '{"action":{"block":true},"match":{"geo_country_codes":["{geoCountryCode}"]},"not_match":{"geo_subdivision_codes":["{geoSubdivisionCode}"]},"scope":"authentication"}'
```
## Forcer le trafic à passer par une infrastructure précise
Vous pouvez combiner les signaux `hostnames` et `connecting_ipv4_cidrs` pour acheminer les requêtes vers votre locataire exclusivement par l’intermédiaire de votre infrastructure autorisée, comme un proxy inverse ou un VPN.
Cet exemple de règle ACL du locataire bloque l’accès à vos domaines canoniques et personnalisés, sauf si la requête provient d’un ensemble précis d’adresses IP qui se connectent directement au réseau périphérique d’Auth0. Cela empêche les utilisateurs de contourner vos contrôles de sécurité en accédant directement aux noms d’hôte de votre locataire depuis l’Internet public.
Pour créer cette règle ACL du locataire avec la Management API :
1. [Obtenez un jeton d’accès de la Management API](/fr-CA/docs/secure/tokens/access-tokens/management-api-access-tokens/get-management-api-access-tokens-for-production) avec le scope `create:network_acls`.
2. Appelez le point de terminaison [point de terminaison de création d’une liste de contrôle d’accès](https://auth0.com/docs/api/management/v2/network-acls/post-network-acls) de la Management API avec le corps suivant :
```json theme={null}
{
"description": "Restrict access to specific proxy IPs for custom and canonical domains",
"active": true,
"priority": 10,
"rule": {
"action": {
"block": true
},
"match": {
"hostnames": ["auth.example.com", "my-tenant.us.auth0.com"]
},
"not_match": {
"connecting_ipv4_cidrs": [
"192.0.2.0/24",
"203.0.113.5/32"
]
},
"scope": "tenant"
}
}
```