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.
# Contrôlez l'accès aux services VPC Lattice à l'aide de politiques d'authentification
Les politiques d'authentification VPC Lattice sont des documents de politique IAM que vous attachez à des réseaux de services ou à des services pour contrôler si un principal spécifié a accès à un groupe de services ou à un service spécifique. Vous pouvez associer une politique d’authentification à chaque réseau de services ou à chaque service dont vous souhaitez contrôler l’accès.
**Note**
La politique d'authentification du réseau de service ne s'applique pas aux configurations de ressources du réseau de service.
Les politiques d'authentification sont différentes des politiques basées sur l'identité IAM. Les politiques basées sur l'identité IAM sont associées aux utilisateurs, groupes ou rôles IAM et définissent les actions que ces identités peuvent effectuer sur quelles ressources. Les politiques d'authentification sont associées aux services et aux réseaux de services. Pour que l'autorisation réussisse, les politiques d'authentification et les politiques basées sur l'identité doivent comporter des instructions d'autorisation explicites. Pour de plus amples informations, veuillez consulter [Comment fonctionne l'autorisation](#auth-policies-evaluation-logic).
Vous pouvez utiliser la console AWS CLI et pour afficher, ajouter, mettre à jour ou supprimer des politiques d'authentification sur les services et les réseaux de services. Lorsque vous ajoutez, mettez à jour ou supprimez une politique d'authentification, la préparation peut prendre quelques minutes. Lorsque vous utilisez le AWS CLI, assurez-vous que vous vous trouvez dans la bonne région. Vous pouvez soit modifier la région par défaut de votre profil, soit utiliser le `--region` paramètre avec la commande.
**Topics**
+ [Éléments communs d'une politique d'authentification](#auth-policies-common-elements)
+ [Format de ressource pour les politiques d'authentification](#auth-policies-resource-format)
+ [Clés de condition pouvant être utilisées dans les politiques d'authentification](#auth-policies-condition-keys)
+ [Balises de ressources](#resource-tags)
+ [Balises principales](#principal-tags)
+ [Principaux anonymes (non authentifiés)](#anonymous-unauthenticated-principals)
+ [Exemples de politiques d'authentification](#example-auth-policies)
+ [Comment fonctionne l'autorisation](#auth-policies-evaluation-logic)
Pour commencer à utiliser les politiques d'authentification, suivez la procédure de création d'une politique d'authentification qui s'applique à un réseau de services. Pour des autorisations plus restrictives que vous ne souhaitez pas appliquer à d'autres services, vous pouvez éventuellement définir des politiques d'authentification pour des services individuels.
## Gérez l'accès à un réseau de services à l'aide de politiques d'authentification
Les AWS CLI tâches suivantes vous montrent comment gérer l'accès à un réseau de services à l'aide de politiques d'authentification. Pour obtenir des instructions relatives à l'utilisation de la console, reportez-vous à[Réseaux de service en VPC Lattice](service-networks.md).
**Topics**
+ [Ajouter une politique d'authentification à un réseau de service](#add-service-network-auth-policy)
+ [Modifier le type d'authentification d'un réseau de services](#change-service-network-auth-type)
+ [Supprimer une politique d'authentification d'un réseau de service](#remove-service-network-auth-policy)
### Ajouter une politique d'authentification à un réseau de service
Suivez les étapes décrites dans cette section pour utiliser le AWS CLI pour :
+ Activez le contrôle d'accès sur un réseau de service à l'aide d'IAM.
+ Ajoutez une politique d'authentification au réseau de service. Si vous n'ajoutez pas de politique d'authentification, tout le trafic recevra un message d'erreur de refus d'accès.
**Pour activer le contrôle d'accès et ajouter une politique d'authentification à un nouveau réseau de service**
1. Pour activer le contrôle d'accès sur un réseau de service afin qu'il puisse utiliser une politique d'authentification, utilisez la **create-service-network** commande avec l'`--auth-type`option et la valeur de`AWS_IAM`.
```
aws vpc-lattice create-service-network --name {{Name}} --auth-type AWS_IAM [--tags {{TagSpecification}}]
```
Si elle aboutit, la commande renvoie un résultat semblable au suivant :
```
{
"arn": "{{arn}}",
"authType": "AWS_IAM",
"id": "sn-0123456789abcdef0",
"name": "Name"
}
```
1. Utilisez la **put-auth-policy** commande en spécifiant l'ID du réseau de service sur lequel vous souhaitez ajouter la politique d'authentification et la politique d'authentification que vous souhaitez ajouter.
Par exemple, utilisez la commande suivante pour créer une politique d'authentification pour le réseau de service avec l'ID{{`sn-0123456789abcdef0`}}.
```
aws vpc-lattice put-auth-policy --resource-identifier {{sn-0123456789abcdef0}} --policy {{file://policy.json}}
```
Utilisez JSON pour créer une définition de politique. Pour de plus amples informations, veuillez consulter [Éléments communs d'une politique d'authentification](#auth-policies-common-elements).
Si elle aboutit, la commande renvoie un résultat semblable au suivant :
```
{
"policy": "{{policy}}",
"state": "Active"
}
```
**Pour activer le contrôle d'accès et ajouter une politique d'authentification à un réseau de service existant**
1. Pour activer le contrôle d'accès sur un réseau de service afin qu'il puisse utiliser une politique d'authentification, utilisez la **update-service-network** commande avec l'`--auth-type`option et la valeur de`AWS_IAM`.
```
aws vpc-lattice update-service-network --service-network-identifier {{sn-0123456789abcdef0}} --auth-type AWS_IAM
```
Si elle aboutit, la commande renvoie un résultat semblable au suivant :
```
{
"arn": "{{arn}}",
"authType": "AWS_IAM",
"id": "sn-0123456789abcdef0",
"name": "Name"
}
```
1. Utilisez la **put-auth-policy** commande en spécifiant l'ID du réseau de service sur lequel vous souhaitez ajouter la politique d'authentification et la politique d'authentification que vous souhaitez ajouter.
```
aws vpc-lattice put-auth-policy --resource-identifier {{sn-0123456789abcdef0}} --policy {{file://policy.json}}
```
Utilisez JSON pour créer une définition de politique. Pour de plus amples informations, veuillez consulter [Éléments communs d'une politique d'authentification](#auth-policies-common-elements).
Si elle aboutit, la commande renvoie un résultat semblable au suivant :
```
{
"policy": "{{policy}}",
"state": "Active"
}
```
### Modifier le type d'authentification d'un réseau de services
**Pour désactiver la politique d'authentification pour un réseau de service**
Utilisez la **update-service-network** commande avec l'`--auth-type`option et la valeur de`NONE`.
```
aws vpc-lattice update-service-network --service-network-identifier {{sn-0123456789abcdef0}} --auth-type NONE
```
Si vous devez réactiver la politique d'authentification ultérieurement, exécutez cette commande avec l'`--auth-type`option `AWS_IAM` spécifiée.
### Supprimer une politique d'authentification d'un réseau de service
**Pour supprimer une politique d'authentification d'un réseau de service**
Utilisez la commande **delete-auth-policy**.
```
aws vpc-lattice delete-auth-policy --resource-identifier {{sn-0123456789abcdef0}}
```
La demande échoue si vous supprimez une politique d'authentification avant de changer le type d'authentification d'un réseau de service en. `NONE`
## Gérer l'accès à un service à l'aide de politiques d'authentification
Les AWS CLI tâches suivantes vous montrent comment gérer l'accès à un service à l'aide de politiques d'authentification. Pour obtenir des instructions relatives à l'utilisation de la console, reportez-vous à[Services en VPC Lattice](services.md).
**Topics**
+ [Ajouter une politique d'authentification à un service](#add-service-auth-policy)
+ [Modifier le type d'authentification d'un service](#change-service-auth-type)
+ [Supprimer une politique d'authentification d'un service](#remove-service-auth-policy)
### Ajouter une politique d'authentification à un service
Procédez comme suit pour utiliser le AWS CLI pour :
+ Activez le contrôle d'accès sur un service à l'aide d'IAM.
+ Ajoutez une politique d'authentification au service. Si vous n'ajoutez pas de politique d'authentification, tout le trafic recevra un message d'erreur de refus d'accès.
**Pour activer le contrôle d'accès et ajouter une politique d'authentification à un nouveau service**
1. Pour activer le contrôle d'accès sur un service afin qu'il puisse utiliser une politique d'authentification, utilisez la **create-service** commande avec l'`--auth-type`option et la valeur de`AWS_IAM`.
```
aws vpc-lattice create-service --name {{Name}} --auth-type AWS_IAM [--tags {{TagSpecification}}]
```
Si elle aboutit, la commande renvoie un résultat semblable au suivant :
```
{
"arn": "{{arn}}",
"authType": "AWS_IAM",
"dnsEntry": {
...
},
"id": "svc-0123456789abcdef0",
"name": "Name",
"status": "CREATE_IN_PROGRESS"
}
```
1. Utilisez la **put-auth-policy** commande en spécifiant l'ID du service dans lequel vous souhaitez ajouter la politique d'authentification et la politique d'authentification que vous souhaitez ajouter.
Par exemple, utilisez la commande suivante pour créer une politique d'authentification pour le service avec l'ID{{svc-0123456789abcdef0}}.
```
aws vpc-lattice put-auth-policy --resource-identifier {{svc-0123456789abcdef0}} --policy {{file://policy.json}}
```
Utilisez JSON pour créer une définition de politique. Pour de plus amples informations, veuillez consulter [Éléments communs d'une politique d'authentification](#auth-policies-common-elements).
Si elle aboutit, la commande renvoie un résultat semblable au suivant :
```
{
"policy": "{{policy}}",
"state": "Active"
}
```
**Pour activer le contrôle d'accès et ajouter une politique d'authentification à un service existant**
1. Pour activer le contrôle d'accès sur un service afin qu'il puisse utiliser une politique d'authentification, utilisez la **update-service** commande avec l'`--auth-type`option et la valeur de`AWS_IAM`.
```
aws vpc-lattice update-service --service-identifier {{svc-0123456789abcdef0}} --auth-type AWS_IAM
```
Si elle aboutit, la commande renvoie un résultat semblable au suivant :
```
{
"arn": "{{arn}}",
"authType": "AWS_IAM",
"id": "svc-0123456789abcdef0",
"name": "Name"
}
```
1. Utilisez la **put-auth-policy** commande en spécifiant l'ID du service dans lequel vous souhaitez ajouter la politique d'authentification et la politique d'authentification que vous souhaitez ajouter.
```
aws vpc-lattice put-auth-policy --resource-identifier {{svc-0123456789abcdef0}} --policy {{file://policy.json}}
```
Utilisez JSON pour créer une définition de politique. Pour de plus amples informations, veuillez consulter [Éléments communs d'une politique d'authentification](#auth-policies-common-elements).
Si elle aboutit, la commande renvoie un résultat semblable au suivant :
```
{
"policy": "{{policy}}",
"state": "Active"
}
```
### Modifier le type d'authentification d'un service
**Pour désactiver la politique d'authentification d'un service**
Utilisez la **update-service** commande avec l'`--auth-type`option et la valeur de`NONE`.
```
aws vpc-lattice update-service --service-identifier {{svc-0123456789abcdef0}} --auth-type NONE
```
Si vous devez réactiver la politique d'authentification ultérieurement, exécutez cette commande avec l'`--auth-type`option `AWS_IAM` spécifiée.
### Supprimer une politique d'authentification d'un service
**Pour supprimer une politique d'authentification d'un service**
Utilisez la commande **delete-auth-policy**.
```
aws vpc-lattice delete-auth-policy --resource-identifier {{svc-0123456789abcdef0}}
```
La demande échoue si vous supprimez une politique d'authentification avant de changer le type d'authentification du service en. `NONE`
Si vous activez les politiques d'authentification qui nécessitent des demandes authentifiées adressées à un service, toutes les demandes adressées à ce service doivent contenir une signature de demande valide calculée à l'aide de la version 4 de signature (SigV4). Pour de plus amples informations, veuillez consulter [Demandes authentifiées SigV4 pour Amazon VPC Lattice](sigv4-authenticated-requests.md).
## Éléments communs d'une politique d'authentification
Les politiques d'authentification VPC Lattice sont spécifiées à l'aide de la même syntaxe que les politiques IAM. Pour plus d'informations, consultez [Identity-basedles politiques et les politiques basées sur les ressources](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html) dans le guide de l'utilisateur *IAM*.
Une politique d'authentification contient les éléments suivants :
+ **Principal** : personne ou application autorisée à accéder aux actions et aux ressources de la déclaration. Dans une politique d'authentification, le principal est l'entité IAM destinataire de cette autorisation. Le principal est authentifié en tant qu'entité IAM pour envoyer des demandes à une ressource spécifique, ou à un groupe de ressources, comme dans le cas des services d'un réseau de services.
Vous devez spécifier un principal dans une politique basée sur les ressources. Les principaux peuvent inclure des comptes, des utilisateurs, des rôles, des utilisateurs fédérés ou AWS des services. Pour plus d'informations, voir [Éléments de politique AWS JSON : Principal](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html) dans le *guide de l'utilisateur IAM*.
+ **Effet** : effet lorsque le principal spécifié demande l'action spécifique. Il peut correspondre à `Allow` ou `Deny`. Par défaut, lorsque vous activez le contrôle d'accès sur un service ou un réseau de services à l'aide d'IAM, les principaux ne sont pas autorisés à envoyer des demandes au service ou au réseau de services.
+ **Actions** : action d'API spécifique pour laquelle vous accordez ou refusez l'autorisation. VPC Lattice prend en charge les actions qui utilisent le préfixe. `vpc-lattice-svcs` Pour plus d'informations, consultez la section [Actions définies par Amazon VPC Lattice Services](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonvpclatticeservices.html#amazonvpclatticeservices-actions-as-permissions) dans le *Service* Authorization Reference.
+ **Ressources** : services concernés par l'action.
+ **État** — Les conditions sont facultatives. Vous pouvez les utiliser pour contrôler le moment où votre politique est en vigueur. Pour plus d'informations, consultez la section [Clés de condition pour Amazon VPC Lattice Services](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonvpclatticeservices.html#amazonvpclatticeservices-policy-keys) dans la référence d'autorisation des *services*.
Lorsque vous créez et gérez des politiques d'authentification, vous souhaiterez peut-être utiliser le générateur de [politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-generator).
**Exigence**
La politique au format JSON ne doit pas contenir de nouvelles lignes ou de lignes vides.
## Format de ressource pour les politiques d'authentification
Vous pouvez restreindre l'accès à des ressources spécifiques en créant une politique d'authentification qui utilise un schéma correspondant avec un `/` modèle et en codant l'`Resource`élément, comme indiqué dans les exemples suivants.
| Protocole | Exemples |
| --- | --- |
| HTTP | [See the AWS documentation website for more details](http://docs.aws.amazon.com/fr_fr/vpc-lattice/latest/ug/auth-policies.html) |
| gRPC | [See the AWS documentation website for more details](http://docs.aws.amazon.com/fr_fr/vpc-lattice/latest/ug/auth-policies.html) |
Utilisez le format de ressource Amazon Resource Name (ARN) suivant pour `` :
```
arn:aws:vpc-lattice:{{region}}:{{account-id}}:service/{{service-id}}
```
Par exemple :
```
"Resource": "arn:aws:vpc-lattice:us-west-2:123456789012:service/svc-0123456789abcdef0"
```
## Clés de condition pouvant être utilisées dans les politiques d'authentification
L'accès peut également être contrôlé par des clés de condition dans l'élément **Condition** des politiques d'authentification. Ces clés de condition sont présentes à des fins d'évaluation en fonction du protocole et du fait que la demande soit signée avec [Signature Version 4 (SigV4)](sigv4-authenticated-requests.md) ou anonyme. Les clés de condition sont sensibles à la casse.
AWS fournit des clés de condition globales que vous pouvez utiliser pour contrôler l'accès, telles que `aws:PrincipalOrgID` et`aws:SourceIp`. Pour consulter la liste des clés de condition AWS globales, voir les clés de [contexte de condition AWS globales](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) dans le *guide de l'utilisateur IAM*.
Le tableau suivant répertorie les clés de condition du réseau VPC. Pour plus d'informations, consultez la section [Clés de condition pour Amazon VPC Lattice Services](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonvpclatticeservices.html#amazonvpclatticeservices-policy-keys) dans la référence d'autorisation des *services*.
| Clés de condition | Description | Exemple | Disponible pour les appelants anonymes (non authentifiés) ? | Disponible pour le gRPC ? |
| --- | --- | --- | --- | --- |
| vpc-lattice-svcs:Port | Filtre l'accès par le port de service auquel la demande est envoyée | 80 | Oui | Oui |
| vpc-lattice-svcs:RequestMethod | Filtre l'accès en fonction de la méthode de la requête | GET | Oui | Publiez toujours |
| vpc-lattice-svcs:RequestPath | Filtre l'accès en fonction de la partie chemin de l'URL de demande | /path | Oui | Oui |
| vpc-lattice-svcs:RequestHeader/{{header-name}}: {{value}} | Filtre l'accès en fonction d'une paire nom-valeur dans les en-têtes de la demande | content-type: application/json | Oui | Oui |
| vpc-lattice-svcs:RequestQueryString/{{key-name}}: {{value}} | Filtre l'accès en fonction des paires clé-valeur de la chaîne de requête dans l'URL de la demande | quux: [corge, grault] | Oui | Non |
| vpc-lattice-svcs:ServiceNetworkArn | Filtre l'accès par l'ARN du réseau de service du service qui reçoit la demande | arn:aws:vpc-lattice:us-west-2:123456789012:servicenetwork/sn-0123456789abcdef0 | Oui | Oui |
| vpc-lattice-svcs:ServiceArn | Filtre l'accès par l'ARN du service qui reçoit la demande | arn:aws:vpc-lattice:us-west-2:123456789012:service/svc-0123456789abcdef0 | Oui | Oui |
| vpc-lattice-svcs:SourceVpc | Filtre l'accès en fonction du VPC d'où provient la requête | vpc-1a2b3c4d | Oui | Oui |
| vpc-lattice-svcs:SourceVpcOwnerAccount | Filtre l'accès en fonction du compte propriétaire du VPC d'où provient la requête | 123456789012 | Oui | Oui |
## Balises de ressources
Une *balise* est une étiquette de métadonnées que vous attribuez ou que vous AWS attribuez à une AWS ressource. Chaque balise se compose de deux parties :
+ Une *clé de balise* (par exemple, `CostCenter`, `Environment` ou `Project`). Les clés de balises sont sensibles à la casse.
+ Un champ facultatif appelé *valeur de balise* (par exemple, `111122223333` ou `Production`). Si la valeur de balise est identique à l’utilisation d’une chaîne vide. Tout comme les clés de balises, les valeurs de balises sont sensibles à la casse.
Pour plus d'informations sur le balisage, voir [Contrôle de l'accès aux AWS ressources à l'aide](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) de balises
Vous pouvez utiliser des balises dans vos politiques d'authentification à l'aide de la clé de contexte de condition `aws:ResourceTag/key` AWS globale.
L'exemple de politique suivant accorde l'accès aux services dotés de cette balise`Environment=Gamma`. Cette politique vous permet de faire référence à des services sans avoir à coder en dur les ARN ou les identifiants des services.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowGammaAccess",
"Effect": "Allow",
"Principal": "*",
"Action": "vpc-lattice-svcs:Invoke",
"Resource": "arn:aws:vpc-lattice:us-west-2:123456789012:service/svc-0124446789abcdef0/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Environment": "Gamma",
}
}
}
]
}
```
## Balises principales
Vous pouvez contrôler l'accès à vos services et ressources en fonction des balises associées à l'identité de l'appelant. VPC Lattice prend en charge le contrôle d'accès en fonction des balises principales de l'utilisateur, du rôle ou des balises de session à l'aide des variables. `aws:PrincipalTag/context` Pour plus d'informations, consultez la section [Contrôle de l'accès pour les principaux IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_iam-tags.html#access_iam-tags_control-principals).
L'exemple de politique suivant accorde l'accès uniquement aux identités dotées du tag`Team=Payments`. Cette politique vous permet de contrôler l'accès sans coder en dur les identifiants de compte ou les ARN des rôles.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowPaymentsTeam",
"Effect": "Allow",
"Principal": "*",
"Action": "vpc-lattice-svcs:Invoke",
"Resource": "arn:aws:vpc-lattice:us-west-2:123456789012:service/svc-0123456789abcdef0/*",
"Condition": {
"StringEquals": {
"aws:PrincipalTag/Team": "Payments",
}
}
}
]
}
```
## Principaux anonymes (non authentifiés)
Les principaux anonymes sont des appelants qui ne signent pas leurs AWS demandes avec [Signature Version 4 (SigV4)](sigv4-authenticated-requests.md) et qui se trouvent au sein d'un VPC connecté au réseau de service. Les principaux anonymes peuvent envoyer des demandes non authentifiées aux services du réseau de services si une politique d'authentification le permet.
## Exemples de politiques d'authentification
Voici des exemples de politiques d'authentification qui exigent que les demandes soient effectuées par des principaux authentifiés.
Tous les exemples utilisent la `us-west-2` région et contiennent des identifiants de compte fictifs.
**Exemple 1 : Restreindre l'accès aux services d'une personne spécifique AWS organization**
L'exemple de politique d'authentification suivant accorde des autorisations à toute demande authentifiée pour accéder à tous les services du réseau de services auquel s'applique la politique. Cependant, la demande doit émaner de directeurs appartenant à l' AWS organisation spécifiée dans la condition.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": "vpc-lattice-svcs:Invoke",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:PrincipalOrgID": [
"{{o-123456example}}"
]
}
}
}
]
}
```
------
**Exemple 2 : Restreindre l'accès à un service par un rôle IAM spécifique**
L'exemple de politique d'authentification suivant accorde des autorisations à toute demande authentifiée utilisant le rôle IAM `rates-client` pour effectuer des requêtes HTTP GET sur le service spécifié dans l'élément. `Resource` La ressource contenue dans l'`Resource`élément est identique au service auquel la politique est attachée.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::{{123456789012}}:role/rates-client"
]
},
"Action": "vpc-lattice-svcs:Invoke",
"Resource": [
"arn:aws:vpc-lattice:us-west-2:{{123456789012}}:service/{{svc-0123456789abcdef0}}/*"
],
"Condition": {
"StringEquals": {
"vpc-lattice-svcs:RequestMethod": "GET"
}
}
}
]
}
```
------
**Exemple 3 : Restreindre l'accès aux services par des personnes authentifiées dans un VPC spécifique**
L'exemple de politique d'authentification suivant autorise uniquement les demandes authentifiées provenant des principaux du VPC dont l'ID de VPC est. `{{vpc-1a2b3c4d}}`
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": "vpc-lattice-svcs:Invoke",
"Resource": "*",
"Condition": {
"StringNotEquals": {
"aws:PrincipalType": "Anonymous"
},
"StringEquals": {
"vpc-lattice-svcs:SourceVpc": "{{vpc-1a2b3c4d}}"
}
}
}
]
}
```
------
## Comment fonctionne l'autorisation
Lorsqu'un service VPC Lattice reçoit une demande, le code d' AWS application évalue ensemble toutes les politiques d'autorisation pertinentes afin de déterminer s'il convient d'autoriser ou de refuser la demande. Il évalue toutes les politiques basées sur l'identité IAM et les politiques d'authentification applicables dans le contexte de la demande lors de l'autorisation. Par défaut, toutes les demandes sont implicitement refusées lorsque le type d'authentification est défini comme tel. `AWS_IAM` Une autorisation explicite émanant de toutes les politiques pertinentes remplace la valeur par défaut.
L'autorisation inclut :
+ Collecte de toutes les politiques basées sur l'identité IAM et des politiques d'authentification pertinentes.
+ Évaluation de l'ensemble de politiques qui en résulte :
+ Vérifier que le demandeur (tel qu'un utilisateur ou un rôle IAM) est autorisé à effectuer l'opération depuis le compte auquel appartient le demandeur. S'il n'existe aucune instruction d'autorisation explicite, AWS cela n'autorise pas la demande.
+ Vérifier que la demande est autorisée par la politique d'authentification du réseau de service. Si une politique d'authentification est activée, mais qu'il n'existe aucune instruction d'autorisation explicite, AWS cela n'autorise pas la demande. S'il existe une instruction d'autorisation explicite, ou si le type d'authentification est le cas`NONE`, le code continue.
+ Vérifier que la demande est autorisée par la politique d'authentification du service. Si une politique d'authentification est activée, mais qu'il n'existe aucune instruction d'autorisation explicite, AWS cela n'autorise pas la demande. S'il existe une instruction d'autorisation explicite, ou si le type d'authentification est le cas`NONE`, le code d'application renvoie la décision finale **Allow**.
+ Un refus explicite dans n'importe quelle stratégie remplace toutes les autorisations.
Le schéma montre le flux de travail d'autorisation. Lorsqu'une demande est faite, les politiques pertinentes autorisent ou refusent à la demande l'accès à un service donné.
