Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Politiques relatives aux autorisations vérifiées par Amazon
<a name="policies"></a>

Une *politique* est une déclaration qui permet ou interdit à un *mandant* d'effectuer une ou plusieurs *actions* sur une *ressource*. Chaque politique est évaluée indépendamment des autres politiques. Pour plus d'informations sur la manière dont les politiques Cedar sont structurées et évaluées, consultez la section [Validation des politiques Cedar par rapport au schéma](https://docs.cedarpolicy.com/policies/validation.html) dans le Guide de référence du langage de politique Cedar.

Vous pouvez éventuellement attribuer un nom de stratégie à une stratégie. Les noms des politiques doivent être uniques pour toutes les politiques du magasin de politiques et être préfixés par`name/`. Vous pouvez utiliser un nom de stratégie à la place de l'ID de stratégie dans les opérations du plan de contrôle qui acceptent un `policyId` paramètre. L'exemple suivant utilise un nom de stratégie pour récupérer une politique avec`GetPolicy`.

```
$ aws verifiedpermissions get-policy \
    --policy-id name/example-policy \
    --policy-store-id PSEXAMPLEabcdefg111111
```

**Important**  
Lorsque vous rédigez des politiques Cedar qui font référence à des principes, à des ressources et à des actions, vous pouvez définir les identifiants uniques utilisés pour chacun de ces éléments. Nous vous recommandons vivement de suivre les meilleures pratiques suivantes :  
**Utilisez des identificateurs uniques universels (UUIDs) pour tous les identifiants principaux et de ressources.**  
Par exemple, si un utilisateur `jane` quitte l'entreprise et que vous autorisez ensuite quelqu'un d'autre à utiliser le nom`jane`, ce nouvel utilisateur a automatiquement accès à tout ce qui est accordé par les politiques qui font toujours référence`User::"jane"`. Cedar ne fait pas la distinction entre le nouvel utilisateur et l'ancien. Cela s'applique à la fois aux identificateurs principaux et aux identificateurs de ressources. Utilisez toujours des identifiants dont l'unicité est garantie et qui ne sont jamais réutilisés afin de ne pas autoriser l'accès par inadvertance en raison de la présence d'un ancien identifiant dans une politique.  
Lorsque vous utilisez un UUID pour une entité, nous vous recommandons de le suivre avec le spécificateur//comment et le nom « convivial » de votre entité. Cela permet de faciliter la compréhension de vos politiques. Par exemple : principal == Rôle : « a1b2c3d4-e5f6-a1b2-c3d4- »,//administrateurs EXAMPLE11111
**N'incluez pas d'informations d'identification personnelle, confidentielles ou sensibles dans l'identifiant unique de vos mandants ou de vos ressources.** Ces identifiants sont inclus dans les entrées de journal partagées dans les AWS CloudTrail sentiers.

**Topics**
+ [Création de politiques statiques relatives aux autorisations vérifiées par Amazon](policies-create.md)
+ [Modification des politiques statiques d'Amazon Verified Permissions](policies-edit.md)
+ [Ajouter du contexte](context.md)
+ [Utilisation du banc de test Amazon Verified Permissions](test-bench.md)
+ [Exemples de politiques relatives aux autorisations vérifiées par Amazon](policies-examples.md)

# Création de politiques statiques relatives aux autorisations vérifiées par Amazon
<a name="policies-create"></a>

Vous pouvez créer une politique statique pour les principaux afin de leur permettre ou de leur interdire d'effectuer des actions spécifiques sur des ressources spécifiques pour votre application. Une politique statique inclut des valeurs spécifiques pour `principal` et `resource` et est prête à être utilisée dans les décisions d'autorisation. 

------
#### [ AWS Management Console ]

**Pour créer une politique statique**

1. Ouvrez la [console des autorisations vérifiées](https://console.aws.amazon.com/verifiedpermissions/). Choisissez votre magasin de polices.

1. Dans le panneau de navigation de gauche, sélectionnez **Policies** (Politiques).

1. Choisissez **Create policy**, puis **Create static policy**.
**Note**  
Si vous souhaitez utiliser une déclaration de politique, passez à l'**étape 8** et collez-la dans la section **Politique** de la page suivante.

1. Dans la section **Effet de la politique**, choisissez si la politique **autorisera** ou **interdira** lorsqu'une demande correspond à la politique. Si vous choisissez **Autoriser**, la politique autorise les principaux à effectuer les actions sur les ressources. À l'inverse, si vous **choisissez Interdire**, la politique n'autorise pas les principaux à effectuer les actions sur les ressources.

1. Dans le **champ Champ d'application des principes**, choisissez le champ d'application des principes auxquels la politique s'appliquera.
   + Choisissez **Spécific principal** pour appliquer la politique à un principal spécifique. Spécifiez le type d'entité et l'identifiant du principal qui sera autorisé ou interdit à effectuer les actions spécifiées dans la politique.
   + Choisissez **Groupe de directeurs** pour appliquer la politique à un groupe de directeurs. Tapez le nom du groupe principal dans le champ **Groupe de principaux.**
   + Choisissez **Tous les principaux pour** appliquer la politique à tous les principaux de votre magasin de polices.

1. Dans le **champ Champ d'application des ressources**, choisissez l'étendue des ressources auxquelles la politique s'appliquera.
   + Choisissez **Ressources spécifiques** pour appliquer la politique à une ressource spécifique. Spécifiez le type d'entité et l'identifiant de la ressource à laquelle la politique doit s'appliquer.
   + Choisissez **Groupe de ressources** pour appliquer la politique à un groupe de ressources. Tapez le nom du groupe de ressources dans le champ **Groupe de ressources**.
   + Choisissez **Toutes les ressources** pour appliquer la politique à toutes les ressources de votre magasin de politiques.

1. Dans la section **Champ d'application des actions**, choisissez l'étendue des ressources auxquelles la politique s'appliquera.
   + Choisissez **un ensemble d'actions spécifique** pour appliquer la politique à un ensemble d'actions. Cochez les cases à côté des actions pour appliquer la politique.
   + Choisissez **Toutes les actions** pour appliquer la politique à toutes les actions de votre magasin de politiques.

1. Choisissez **Suivant**.

1. Dans la section **Politique**, passez en revue votre politique Cedar. Vous pouvez choisir **Format pour formater** la syntaxe de votre politique avec l'espacement et l'indentation recommandés. Pour plus d'informations, voir [Construction de politiques de base dans Cedar](https://docs.cedarpolicy.com/policies/syntax-policy.html) dans le Guide de référence du langage politique de Cedar.

1. Dans la section **Détails**, saisissez une description facultative de la politique.

1. Choisissez **Create Policy** (Créer une politique).

------
#### [ AWS CLI ]

**Pour créer une politique statique**  
Vous pouvez créer une politique statique à l'aide de l'[CreatePolicy](https://docs.aws.amazon.com/verifiedpermissions/latest/apireference/API_CreatePolicy.html)opération. L'exemple suivant crée une politique statique simple.

```
$ aws verifiedpermissions create-policy \
    --definition "{ \"static\": { \"Description\": \"MyTestPolicy\", \"Statement\": \"permit(principal,action,resource) when {principal.owner == resource.owner};\"}}" \
    --policy-store-id PSEXAMPLEabcdefg111111
{
"Arn": "arn:aws:verifiedpermissions::123456789012:policy/PSEXAMPLEabcdefg111111/SPEXAMPLEabcdefg111111",
    "createdDate": "2023-05-16T20:33:01.730817+00:00",
    "lastUpdatedDate": "2023-05-16T20:33:01.730817+00:00",
    "policyId": "SPEXAMPLEabcdefg111111",
    "policyStoreId": "PSEXAMPLEabcdefg111111",
    "policyType": "STATIC"
}
```

**Pour créer une stratégie avec un nom de stratégie**  
Vous pouvez éventuellement spécifier un nom de stratégie lors de la création d'une stratégie. Le nom doit être unique pour toutes les politiques du magasin de politiques et être préfixé par`name/`. Vous pouvez utiliser le nom à la place de l'ID de politique.

```
$ aws verifiedpermissions create-policy \
    --definition "{ \"static\": { \"Statement\": \"permit(principal, action, resource in Album::\\\"public_folder\\\");\"}}" \
    --policy-store-id PSEXAMPLEabcdefg111111 \
    --name name/example-policy
{
    "createdDate": "2023-06-12T20:33:37.382907+00:00",
    "lastUpdatedDate": "2023-06-12T20:33:37.382907+00:00",
    "policyId": "SPEXAMPLEabcdefg111111",
    "policyStoreId": "PSEXAMPLEabcdefg111111",
    "policyType": "STATIC",
    "resource": {
        "entityId": "public_folder",
        "entityType": "Album"
    }
}
```

**Note**  
Si vous spécifiez un nom déjà associé à une autre politique dans le magasin de politiques, vous recevez un `ConflictException` message d'erreur.

------

# Modification des politiques statiques d'Amazon Verified Permissions
<a name="policies-edit"></a>

Vous pouvez modifier une politique statique existante dans votre magasin de politiques. Vous pouvez uniquement mettre à jour les politiques statiques directement. Pour modifier une politique liée à un modèle, vous devez mettre à jour le modèle de stratégie. Pour de plus amples informations, veuillez consulter [Modification des modèles de politique d'autorisations Amazon Verified](policy-templates-edit.md).

Vous pouvez modifier les éléments suivants d'une politique statique :
+ Le `action` référencé par la politique.
+ Une clause conditionnelle, telle que `when` et`unless`.

Vous ne pouvez pas modifier les éléments suivants d'une politique statique. Pour modifier l'un de ces éléments, vous devez supprimer et recréer la politique.
+ Une politique allant d'une politique statique à une politique liée à un modèle.
+ L'effet d'une politique statique depuis `permit` ou`forbid`.
+ Le `principal` référencé par une politique statique.
+ Le `resource` référencé par une politique statique.

------
#### [ AWS Management Console ]

**Pour modifier une politique statique**

1. Ouvrez la [console des autorisations vérifiées](https://console.aws.amazon.com/verifiedpermissions/). Choisissez votre magasin de polices.

1. Dans le panneau de navigation de gauche, sélectionnez **Policies** (Politiques).

1. Cliquez sur le bouton radio situé à côté de la politique statique à modifier, puis sélectionnez **Modifier**.

1. Dans la section **Corps de la politique**, mettez à jour la clause `action` or condition de votre politique statique. Vous ne pouvez pas mettre à jour l'effet de la politique`principal`, ou `resource` de la politique.

1. Choisissez **Mettre à jour une politique**.
**Note**  
Si la [validation des politiques](policy-validation-mode.md) est activée dans le magasin de politiques, la mise à jour d'une politique statique amène Verified Permissions à valider la politique par rapport au schéma du magasin de politiques. Si la politique statique mise à jour n'est pas validée, l'opération échoue et la mise à jour n'est pas enregistrée.

------
#### [ AWS CLI ]

**Pour modifier une politique statique**  
Vous pouvez modifier une politique statique à l'aide de l'[UpdatePolicy](https://docs.aws.amazon.com/verifiedpermissions/latest/apireference/API_UpdatePolicy.html)opération. L'exemple suivant modifie une politique statique simple. 

L'exemple utilise le fichier `definition.txt` pour contenir la définition de la politique.

```
{
    "static": {
        "description":  "Grant everyone of janeFriends UserGroup access to the vacationFolder Album",
        "statement": "permit(principal in UserGroup::\"janeFriends\", action, resource in Album::\"vacationFolder\" );"
    }
}
```

La commande suivante fait référence à ce fichier.

```
$ aws verifiedpermissions create-policy \
    --definition file://definition.txt \
    --policy-store-id PSEXAMPLEabcdefg111111

{
    "createdDate": "2023-06-12T20:33:37.382907+00:00",
    "lastUpdatedDate": "2023-06-12T20:33:37.382907+00:00",
    "policyId": "SPEXAMPLEabcdefg111111",
    "policyStoreId": "PSEXAMPLEabcdefg111111",
    "policyType": "STATIC",
    "principal": {
        "entityId": "janeFriends",
        "entityType": "UserGroup"
    },
    "resource": {
        "entityId": "vacationFolder",
        "entityType": "Album"
    }
}
```

**Pour mettre à jour le nom d'une politique**  
Vous pouvez définir ou mettre à jour le nom d'une politique lors de la mise à jour d'une politique. Le nom doit être unique pour toutes les politiques du magasin de politiques et être préfixé par`name/`. Si vous n'incluez pas le champ du nom dans la demande de mise à jour, le nom existant reste inchangé. Pour supprimer un nom, définissez-le sur une chaîne vide.

```
$ aws verifiedpermissions update-policy \
    --policy-id SPEXAMPLEabcdefg111111 \
    --policy-store-id PSEXAMPLEabcdefg111111 \
    --definition file://definition.txt \
    --name name/example-policy
{
    "createdDate": "2023-06-12T20:33:37.382907+00:00",
    "lastUpdatedDate": "2023-06-12T20:47:42.804511+00:00",
    "policyId": "SPEXAMPLEabcdefg111111",
    "policyStoreId": "PSEXAMPLEabcdefg111111",
    "policyType": "STATIC",
    "principal": {
        "entityId": "janeFriends",
        "entityType": "UserGroup"
    },
    "resource": {
        "entityId": "vacationFolder",
        "entityType": "Album"
    }
}
```

------

# Ajouter du contexte
<a name="context"></a>

Le *contexte* est l'information pertinente pour les décisions politiques, mais qui ne fait pas partie de l'identité de votre principal, de votre action ou de votre ressource. Les demandes de jetons d'accès sont contextuelles. Vous souhaiterez peut-être autoriser une action uniquement à partir d'un ensemble d'adresses IP sources, ou uniquement si votre utilisateur s'est connecté à l'aide de l'authentification MFA. Votre application a accès à ces données de session contextuelles et doit les renseigner pour répondre aux demandes d'autorisation. Les données contextuelles d'une demande d'autorisation Verified Permissions doivent être au format JSON dans un élément. `contextMap`

Les exemples illustrant ce contenu proviennent d'un [exemple de magasin de politiques](policy-stores-create.md). Pour suivre, créez le magasin **DigitalPetStore**d'exemples de règles dans votre environnement de test.

L'objet de contexte suivant déclare un type de données Cedar pour chaque type de données pour une application en fonction de l'exemple de magasin **DigitalPetStore**de politiques.

```
"context": {
  "contextMap": {
    "AccountCodes": {
      "set": [
        {
          "long": 111122223333
        },
        {
          "long": 444455556666
        },
        {
          "long": 123456789012
        }
      ]
    },
    "approvedBy": {
    "entityIdentifier": {
      "entityId": "Bob",
      "entityType": "DigitalPetStore::User"
    }
    },
    "MfaAuthorized": {
      "boolean": true
    },
    "NetworkInfo": {
      "record": {
        "IPAddress": {
          "string": "192.0.2.178"
        },
        "Country": {
          "string": "United States of America"
        },
        "SSL": {
          "boolean": true
        }
    }
    },
    "RequestedOrderCount": {
      "long": 4
    },
    "UserAgent": {
      "string": "My UserAgent 1.12"
    }
  }
}
```Types de données dans le contexte des autorisations

**Booléen**  
Un binaire `true` ou une `false` valeur. Dans l'exemple, la valeur booléenne de `true` for `MfaAuthenticated` indique que le client a effectué une authentification multifactorielle avant de demander à consulter sa commande.

**Définir**  
Un ensemble d'éléments contextuels. Les membres de l'ensemble peuvent être tous du même type, comme dans cet exemple, ou de types différents, y compris un ensemble imbriqué. Dans l'exemple, le client est associé à 3 comptes différents.

**String**  
Séquence de lettres, de chiffres ou de symboles entourée de `"` caractères. Dans l'exemple, la `UserAgent` chaîne représente le navigateur que le client a utilisé pour demander à consulter sa commande.

**Long**  
Un entier. Dans l'exemple, cela `RequestedOrderCount` indique que cette demande fait partie d'un lot résultant du fait que le client a demandé à consulter quatre de ses commandes passées.

**Enregistrer**  
Une collection d'attributs. Vous devez déclarer ces attributs dans le contexte de la demande. Un magasin de politiques doté d'un schéma doit inclure cette entité et ses attributs dans le schéma. Dans l'exemple, l'`NetworkInfo`enregistrement contient des informations sur l'adresse IP d'origine de l'utilisateur, la géolocalisation de cette adresse IP telle que déterminée par le client et le chiffrement en cours de transit.

**EntityIdentifier**  
Référence à une entité et à des attributs déclarés dans l'`entities`élément de la demande. Dans l'exemple, la commande de l'utilisateur a été approuvée par l'employé`Bob`.

Pour tester cet exemple de contexte dans l'exemple d'**DigitalPetStore**application, vous devez mettre à jour votre demande`entities`, le schéma de votre magasin de politiques et la politique statique avec la description **Customer Role - Get Order**.

## Modifier DigitalPetStore pour accepter le contexte d'autorisation
<a name="authorization-context-example"></a>

Au départ, **DigitalPetStore**ce n'est pas un magasin de politiques très complexe. Il n'inclut aucune politique ou attribut de contexte préconfiguré pour prendre en charge le contexte que nous avons présenté. Pour évaluer un exemple de demande d'autorisation avec ces informations contextuelles, apportez les modifications suivantes à votre magasin de politiques et à votre demande d'autorisation. Pour des exemples de contexte avec des informations de jeton d'accès comme contexte, consultez les sections [Cartographie des jetons Amazon Cognito d'accès](cognito-map-token-to-schema.md#cognito-map-access-token) et [Cartographie des jetons d'accès OIDC](oidc-map-token-to-schema.md#oidc-map-access-token).

------
#### [ Schema ]

Appliquez les mises à jour suivantes au schéma de votre magasin de politiques pour prendre en charge les nouveaux attributs de contexte. Mettez `GetOrder` à jour `actions` comme suit.

```
"GetOrder": {
  "memberOf": [],
  "appliesTo": {
    "resourceTypes": [
      "Order"
    ],
    "context": {
      "type": "Record",
      "attributes": {
        "AccountCodes": {
          "type": "Set",
          "required": true,
          "element": {
            "type": "Long"
          }
        },
        "approvedBy": {
          "name": "User",
          "required": true,
          "type": "Entity"
        },
        "MfaAuthorized": {
          "type": "Boolean",
          "required": true
        },
        "NetworkInfo": {
          "type": "NetworkInfo",
          "required": true
        },
        "RequestedOrderCount": {
          "type": "Long",
          "required": true
        },
        "UserAgent": {
          "required": true,
          "type": "String"
        }
      }
    },
    "principalTypes": [
      "User"
    ]
  }
}
```

Pour référencer le type de `record` données nommé `NetworkInfo` dans le contexte de votre demande, créez une construction [CommonType](https://docs.cedarpolicy.com/schema/schema.html#schema-commonTypes) dans votre schéma en ajoutant ce qui suit à votre schéma auparavant`actions`. Une `commonType` construction est un ensemble partagé d'attributs que vous pouvez appliquer à différentes entités.

```
"commonTypes": {
  "NetworkInfo": {
    "attributes": {
      "IPAddress": {
        "type": "String",
        "required": true
      },
      "SSL": {
        "required": true,
        "type": "Boolean"
      },
      "Country": {
        "required": true,
        "type": "String"
      }
    },
    "type": "Record"
  }
},
```

------
#### [ Policy ]

La politique suivante définit les conditions qui doivent être remplies par chacun des éléments de contexte fournis. Il s'appuie sur la politique statique existante avec la description **Customer Role - Get Order**. Au départ, cette politique exige uniquement que le principal qui fait une demande soit le propriétaire de la ressource.

```
permit (
    principal in DigitalPetStore::Role::"Customer",
    action in [DigitalPetStore::Action::"GetOrder"],
    resource
) when {
    principal == resource.owner &&
    context.AccountCodes.contains(111122223333) &&
    context.approvedBy in DigitalPetStore::Role::"Employee" &&
    context.MfaAuthorized == true &&
    context.NetworkInfo.Country like "*United States*" &&
    context.NetworkInfo.IPAddress like "192.0.2.*" &&
    context.NetworkInfo.SSL == true &&
    context.RequestedOrderCount <= 4 &&
    context.UserAgent like "*My UserAgent*"
};
```

Nous avons maintenant exigé que la demande de récupération d'une commande réponde aux conditions contextuelles supplémentaires que nous avons ajoutées à la demande.

1. L'utilisateur doit s'être connecté à l'aide de la MFA.

1. Le navigateur Web de l'utilisateur `User-Agent` doit contenir la chaîne`My UserAgent`.

1. L'utilisateur doit avoir demandé à consulter 4 commandes ou moins.

1. L'un des codes de compte de l'utilisateur doit être`111122223333`.

1. L'adresse IP de l'utilisateur doit provenir des États-Unis d'Amérique, sa session doit être cryptée et son adresse IP doit commencer par. `192.0.2.`

1. Un employé doit avoir approuvé sa commande. Dans l'`entities`élément de la demande d'autorisation, nous déclarerons un utilisateur `Bob` ayant le rôle de`Employee`.

------
#### [ Request body ]

Après avoir configuré votre magasin de politiques avec le schéma et la politique appropriés, vous pouvez présenter cette demande d'autorisation à l'opération de l'API Verified Permissions [IsAuthorized](https://docs.aws.amazon.com/verifiedpermissions/latest/apireference/API_IsAuthorized.html). Notez que le `entities` segment contient une définition de`Bob`, un utilisateur avec un rôle de`Employee`.

```
{
  "principal": {
    "entityType": "DigitalPetStore::User",
    "entityId": "Alice"
  },
  "action": {
    "actionType": "DigitalPetStore::Action",
    "actionId": "GetOrder"
  },
  "resource": {
    "entityType": "DigitalPetStore::Order",
    "entityId": "1234"
  },
  "context": {
    "contextMap": {
      "AccountCodes": {
        "set": [
          {"long": 111122223333},
          {"long": 444455556666},
          {"long": 123456789012}
        ]
      },
      "approvedBy": {
        "entityIdentifier": {
          "entityId": "Bob",
          "entityType": "DigitalPetStore::User"
        }
      },
      "MfaAuthorized": {
        "boolean": true
      },
      "NetworkInfo": {
        "record": {
          "Country": {"string": "United States of America"},
          "IPAddress": {"string": "192.0.2.178"},
          "SSL": {"boolean": true}
        }
      },
      "RequestedOrderCount":{
        "long": 4
      },
      "UserAgent": {
        "string": "My UserAgent 1.12"
      }
    }
  },
  "entities": {
    "entityList": [
      {
        "identifier": {
          "entityType": "DigitalPetStore::User",
          "entityId": "Alice"
        },
        "attributes": {
          "memberId": {
            "string": "801b87f2-1a5c-40b3-b580-eacad506d4e6"
          }
        },
        "parents": [
          {
            "entityType": "DigitalPetStore::Role",
            "entityId": "Customer"
          }
        ]
      },
      {
        "identifier": {
          "entityType": "DigitalPetStore::User",
          "entityId": "Bob"
        },
        "attributes": {
          "memberId": {
            "string": "49d9b81e-735d-429c-989d-93bec0bcfd8b"
          }
        },
        "parents": [
          {
            "entityType": "DigitalPetStore::Role",
            "entityId": "Employee"
          }
        ]
      },
      {
        "identifier": {
          "entityType": "DigitalPetStore::Order",
          "entityId": "1234"
        },
        "attributes": {
          "owner": {
            "entityIdentifier": {
              "entityType": "DigitalPetStore::User",
              "entityId": "Alice"
            }
          }
        },
        "parents": []
      }
     ]
   },
   "policyStoreId": "PSEXAMPLEabcdefg111111"
}
```

------

# Utilisation du banc de test Amazon Verified Permissions
<a name="test-bench"></a>

Utilisez le banc de test des autorisations vérifiées pour tester et résoudre les problèmes liés aux politiques d'autorisations vérifiées en exécutant des [demandes d'autorisation](terminology.md#term-authorization-request) par rapport à celles-ci. Le banc de test utilise les paramètres que vous spécifiez pour déterminer si les politiques Cedar de votre magasin de politiques autoriseraient la demande. Vous pouvez passer du **mode visuel au mode** **JSON** lorsque vous testez les demandes d'autorisation. Pour plus d'informations sur la manière dont les politiques de Cedar sont structurées et évaluées, voir [Construction de base des politiques dans Cedar dans](https://docs.cedarpolicy.com/policies/syntax-policy.html) le Guide de référence sur le langage des politiques de Cedar.

**Note**  
Lorsque vous faites une demande d'autorisation à l'aide d'autorisations vérifiées, vous pouvez fournir la liste des principaux et des ressources dans le cadre de la demande dans la section **Entités supplémentaires**. Toutefois, vous ne pouvez pas inclure les détails relatifs aux actions. Ils doivent être spécifiés dans le schéma ou déduits de la demande. Vous ne pouvez pas placer d'action dans la section **Entités supplémentaires**.

Pour une présentation visuelle et une démonstration du banc de test, consultez [Amazon Verified Permissions - Policy Creation and Testing (Primer Series \$13)](https://www.youtube.com/watch?v=Gi3joEySMPQ) sur la AWS YouTube chaîne.

------
#### [ Visual mode ]

**Note**  
Vous devez avoir défini un schéma dans votre magasin de politiques pour utiliser le **mode visuel** du banc de test.

**Pour tester les politiques en mode visuel**

1. Ouvrez la [console des autorisations vérifiées](https://console.aws.amazon.com/verifiedpermissions/). Choisissez votre magasin de polices.

1. Dans le volet de navigation de gauche, choisissez **Test bench**.

1. Choisissez le **mode visuel**.

1. Dans la section **Principal**, choisissez le **Principal exécutant l'action** parmi les principaux types de votre schéma. Entrez un identifiant pour le principal dans la zone de texte.

1. (Facultatif) Choisissez **Ajouter un parent** pour ajouter des entités parents pour le principal spécifié. Pour supprimer un parent qui a été ajouté au principal, choisissez **Supprimer** à côté du nom du parent.

1. Spécifiez la **valeur d'attribut** pour chaque attribut du principal spécifié. Le banc de test utilise les valeurs d'attribut spécifiées dans la demande d'autorisation simulée.

1. Dans la section **Ressource**, choisissez la **ressource sur laquelle le principal agit**. Entrez un identifiant pour la ressource dans la zone de texte.

1. (Facultatif) Choisissez **Ajouter un parent** pour ajouter des entités parents pour la ressource spécifiée. Pour supprimer un parent qui a été ajouté à la ressource, choisissez **Supprimer** à côté du nom du parent.

1. Spécifiez la **valeur d'attribut** pour chaque attribut de la ressource spécifiée. Le banc de test utilise les valeurs d'attribut spécifiées dans la demande d'autorisation simulée.

1. Dans la section **Action**, choisissez l'**action entreprise par le principal** dans la liste des actions valides pour le principal et la ressource spécifiés.

1. Spécifiez la **valeur d'attribut** pour chaque attribut de l'action spécifiée. Le banc de test utilise les valeurs d'attribut spécifiées dans la demande d'autorisation simulée.

1. (Facultatif) Dans la section **Entités supplémentaires**, choisissez **Ajouter une entité** pour ajouter des entités à évaluer en vue de la décision d'autorisation.

1. Choisissez l'**identifiant de l'entité** dans la liste déroulante et saisissez l'identifiant de l'entité.

1. (Facultatif) Choisissez **Ajouter un parent** pour ajouter des entités parents pour l'entité spécifiée. Pour supprimer un parent qui a été ajouté à l'entité, choisissez **Supprimer** à côté du nom du parent.

1. Spécifiez la **valeur d'attribut** pour chaque attribut de l'entité spécifiée. Le banc de test utilise les valeurs d'attribut spécifiées dans la demande d'autorisation simulée.

1. Choisissez **Confirmer** pour ajouter l'entité au banc de test.

1. Choisissez **Exécuter une demande d'autorisation** pour simuler la demande d'autorisation pour les politiques Cedar dans votre magasin de polices. Le banc de test affiche la décision d'accepter ou de refuser la demande ainsi que des informations sur les politiques satisfaites ou les erreurs rencontrées lors de l'évaluation.

------
#### [ JSON mode ]

**Pour tester les politiques en mode JSON**

1. Ouvrez la [console des autorisations vérifiées](https://console.aws.amazon.com/verifiedpermissions/). Choisissez votre magasin de polices.

1. Dans le volet de navigation de gauche, choisissez **Test bench**.

1. Choisissez le **mode JSON**.

1. Dans la section **Détails de la demande**, si vous avez défini un schéma, choisissez le **principal agissant** parmi les principaux types de votre schéma. Entrez un identifiant pour le principal dans la zone de texte.

   Si aucun schéma n'est défini, tapez le principal dans la zone de texte **Principal prenant une action**.

1. Si un schéma est défini, choisissez la **ressource** parmi les types de ressources de votre schéma. Entrez un identifiant pour la ressource dans la zone de texte.

   Si aucun schéma n'est défini, tapez la ressource dans la zone de texte **Ressource**.

1. Si un schéma est défini, choisissez l'**action** dans la liste des actions valides pour le principal et la ressource spécifiés.

   Si aucun schéma n'est défini, tapez l'action dans la zone de texte **Action**.

1. Entrez le contexte de la demande à simuler dans le champ **Contexte**. Le contexte de la demande est une information supplémentaire qui peut être utilisée pour les décisions d'autorisation.

1. Dans le champ **Entités**, entrez la hiérarchie des entités et leurs attributs à évaluer pour la décision d'autorisation.

1. Choisissez **Exécuter une demande d'autorisation** pour simuler la demande d'autorisation pour les politiques Cedar dans votre magasin de polices. Le banc de test affiche la décision d'accepter ou de refuser la demande ainsi que des informations sur les politiques satisfaites ou les erreurs rencontrées lors de l'évaluation.

------

# Exemples de politiques relatives aux autorisations vérifiées par Amazon
<a name="policies-examples"></a>

Certains des exemples de politiques inclus ici sont des exemples de politiques de base de Cedar, tandis que d'autres sont spécifiques aux autorisations vérifiées. Les principaux renvoient au guide de référence du langage politique de Cedar et y sont inclus. Pour plus d'informations sur la syntaxe des politiques Cedar, consultez la section [Construction de base des politiques dans Cedar](https://docs.cedarpolicy.com/policies/syntax-policy.html) dans le Guide de référence du langage de politique Cedar.

**Exemples de politiques**
+ [Permet l'accès à des entités individuelles](https://docs.cedarpolicy.com/policies/policy-examples.html#allow-acces-indivuals)
+ [Permet l'accès à des groupes d'entités](https://docs.cedarpolicy.com/policies/policy-examples.html#allow-acces-groups)
+ [Permet l'accès à n'importe quelle entité](https://docs.cedarpolicy.com/policies/policy-examples.html#allow-any)
+ [Autorise l'accès aux attributs d'une entité (ABAC)](https://docs.cedarpolicy.com/policies/policy-examples.html#allow-abac)
+ [Refuse l'accès](https://docs.cedarpolicy.com/policies/policy-examples.html#deny-access)
+ [Utilise la notation entre crochets pour référencer les attributs des jetons](#policies-examples-brackets)
+ [Utilise la notation par points pour référencer les attributs](#policies-examples-dot)
+ [Reflète les attributs des jetons d' Amazon Cognito identification](#policies-examples-cognito-id)
+ [Reflète les attributs du jeton d'identification OIDC](#policies-examples-oidc-id)
+ [Reflète les attributs des jetons d' Amazon Cognito accès](#policies-examples-cognito-access)
+ [Reflète les attributs du jeton d'accès OIDC](#policies-examples-oidc-access)

## Utilise la notation entre crochets pour référencer les attributs des jetons
<a name="policies-examples-brackets"></a>

L'exemple suivant montre comment créer une politique qui utilise la notation entre crochets pour référencer les attributs des jetons.

Pour plus d'informations sur l'utilisation des attributs de jeton dans les politiques des autorisations vérifiées, consultez les sections [Mappage Amazon Cognito des jetons sur le schéma](cognito-map-token-to-schema.md) et [Mappage des jetons OIDC sur le schéma](oidc-map-token-to-schema.md).

```
permit (
    principal in MyCorp::UserGroup::"us-west-2_EXAMPLE|MyUserGroup",
    action,
    resource
) when {
    principal["cognito:username"] == "alice" &&
    principal["custom:employmentStoreCode"] == "petstore-dallas" &&
    principal has email && principal.email == "alice@example.com" &&
    context["ip-address"] like "192.0.2.*"
};
```

## Utilise la notation par points pour référencer les attributs
<a name="policies-examples-dot"></a>

L'exemple suivant montre comment créer une politique qui utilise la notation par points pour référencer les attributs.

Pour plus d'informations sur l'utilisation des attributs de jeton dans les politiques des autorisations vérifiées, consultez les sections [Mappage Amazon Cognito des jetons sur le schéma](cognito-map-token-to-schema.md) et [Mappage des jetons OIDC sur le schéma](oidc-map-token-to-schema.md).

```
permit(principal, action, resource)
when {
    principal.cognito.username == "alice" &&
    principal.custom.employmentStoreCode == "petstore-dallas" &&
    principal.tenant == "x11app-tenant-1" &&
    principal has email && principal.email == "alice@example.com"
};
```

## Reflète les attributs des jetons d' Amazon Cognito identification
<a name="policies-examples-cognito-id"></a>

L'exemple suivant montre comment créer une politique qui fait référence aux attributs des jetons d'identification à partir de Amazon Cognito.

Pour plus d'informations sur l'utilisation des attributs de jeton dans les politiques des autorisations vérifiées, consultez les sections [Mappage Amazon Cognito des jetons sur le schéma](cognito-map-token-to-schema.md) et [Mappage des jetons OIDC sur le schéma](oidc-map-token-to-schema.md).

```
permit (
    principal in MyCorp::UserGroup::"us-west-2_EXAMPLE|MyUserGroup",
    action,
    resource
) when {
    principal["cognito:username"] == "alice" &&
    principal["custom:employmentStoreCode"] == "petstore-dallas" &&
    principal.tenant == "x11app-tenant-1" &&
    principal has email && principal.email == "alice@example.com"
};
```

## Reflète les attributs du jeton d'identification OIDC
<a name="policies-examples-oidc-id"></a>

L'exemple suivant montre comment créer une politique faisant référence aux attributs de jeton d'identification d'un fournisseur OIDC.

Pour plus d'informations sur l'utilisation des attributs de jeton dans les politiques des autorisations vérifiées, consultez les sections [Mappage Amazon Cognito des jetons sur le schéma](cognito-map-token-to-schema.md) et [Mappage des jetons OIDC sur le schéma](oidc-map-token-to-schema.md).

```
permit (
    principal in MyCorp::UserGroup::"MyOIDCProvider|MyUserGroup",
    action,
    resource
) when {
    principal.email_verified == true && principal.email == "alice@example.com" &&
    principal.phone_number_verified == true && principal.phone_number like "+1206*"
};
```

## Reflète les attributs des jetons d' Amazon Cognito accès
<a name="policies-examples-cognito-access"></a>

L'exemple suivant montre comment créer une politique faisant référence aux attributs des jetons d'accès à partir de Amazon Cognito.

Pour plus d'informations sur l'utilisation des attributs de jeton dans les politiques des autorisations vérifiées, consultez les sections [Mappage Amazon Cognito des jetons sur le schéma](cognito-map-token-to-schema.md) et [Mappage des jetons OIDC sur le schéma](oidc-map-token-to-schema.md).

```
permit(principal, action in [MyApplication::Action::"Read", MyApplication::Action::"GetStoreInventory"], resource)
when { 
    context.token.client_id == "52n97d5afhfiu1c4di1k5m8f60" &&
    context.token.scope.contains("MyAPI/mydata.write")
};
```

## Reflète les attributs du jeton d'accès OIDC
<a name="policies-examples-oidc-access"></a>

L'exemple suivant montre comment créer une politique faisant référence aux attributs des jetons d'accès d'un fournisseur OIDC.

Pour plus d'informations sur l'utilisation des attributs de jeton dans les politiques des autorisations vérifiées, consultez les sections [Mappage Amazon Cognito des jetons sur le schéma](cognito-map-token-to-schema.md) et [Mappage des jetons OIDC sur le schéma](oidc-map-token-to-schema.md).

```
permit(
    principal, 
    action in [MyApplication::Action::"Read", MyApplication::Action::"GetStoreInventory"],
    resource
)
when { 
    context.token.client_id == "52n97d5afhfiu1c4di1k5m8f60" &&
    context.token.scope.contains("MyAPI-read")
};
```