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.
# Éléments de politique JSON IAM : Condition
L'élément `Condition` (ou *bloc* `Condition`) vous permet de spécifier des conditions lorsqu'une politique est appliquée. L’élément `Condition` est facultatif. Dans l'élément `Condition`, vous créez des expressions dans lesquelles vous utilisez des [opérateurs de condition](reference_policies_elements_condition_operators.md) (égal, inférieur à, etc.) pour faire correspondre les clés et valeurs de contexte de la politique avec les clés et valeurs du contexte de la demande. Pour de plus amples informations sur le contexte de la demande, veuillez consulter [Composants d’une requête](intro-structure.md#intro-structure-request).
```
"Condition" : { "{condition-operator}" : { "{condition-key}" : "{condition-value}" }}
```
La clé de contexte que vous spécifiez dans une condition de politique peut être une [clé de contexte de condition globale](reference_policies_condition-keys.md) ou une clé de contexte spécifique au service. Les clés de contexte de condition globale possèdent le préfixe `aws:`. Les clés de contexte spécifiques au service possèdent le préfixe du service. Par exemple, Amazon EC2 vous permet d'écrire une condition à l'aide de la clé de contexte `ec2:InstanceType`, qui est propre à ce service. Pour connaître les clés de contexte IAM spécifiques au service ayant le préfixe `iam:`, veuillez consulter la rubrique [Clés de contexte IAM et de AWS STS condition](reference_policies_iam-condition-keys.md).
Les *noms* de clé de contexte ne sont pas sensibles à la casse. Par exemple, inclure la clé de contexte `aws:SourceIP` revient à tester `AWS:SourceIp`. La sensibilité à la casse des *valeurs* des clés de contexte dépend de l'[opérateur de condition](reference_policies_elements_condition_operators.md) que vous utilisez. Par exemple, la condition suivante inclut l'opérateur `StringEquals` pour garantir que seules les demandes effectuées par `john` correspondent. Les utilisateurs nommés `John` se voient refuser l'accès.
```
"Condition" : { "StringEquals" : { "aws:username" : "john" }}
```
La condition suivante utilise l'opérateur [`StringEqualsIgnoreCase`](reference_policies_elements_condition_operators.md#Conditions_String) pour la correspondance avec les utilisateurs nommés `john` ou `John`.
```
"Condition" : { "StringEqualsIgnoreCase" : { "aws:username" : "john" }}
```
Certaines clés de contexte prennent en charge des paires clé-valeur qui vous permettent de spécifier une partie du nom de clé. Les exemples incluent la clé de [`aws:RequestTag/tag-key`](reference_policies_condition-keys.md#condition-keys-requesttag)contexte AWS KMS [https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-encryption-context](https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-encryption-context), la clé de contexte et la clé de [`ResourceTag/tag-key`](reference_policies_condition-keys.md#condition-keys-resourcetag)contexte prises en charge par plusieurs services.
+ Si vous utilisez la clé de contexte `ResourceTag/tag-key` pour un service comme [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policy-structure.html#amazon-ec2-keys), vous devez spécifier un nom de clé pour `tag-key`.
+ **Les noms de clé ne sont pas sensibles à la casse.** Cela signifie que si vous spécifiez `"aws:ResourceTag/TagKey1": "Value1"` dans l'élément de condition de votre politique, la condition correspond à une clé de balise de ressource nommée `TagKey1` ou `tagkey1`, mais pas aux deux.
+ AWS les services qui prennent en charge ces attributs peuvent vous permettre de créer plusieurs noms de clés qui ne diffèrent qu'au cas par cas. Par exemple, vous pouvez baliser une instance Amazon EC2 avec les interfaces `ec2=test1` et `EC2=test2`. Lorsque vous utilisez une condition comme `"aws:ResourceTag/EC2": "test1"` pour autoriser l'accès à cette ressource, le nom de clé correspond aux deux balises, mais une seule valeur correspond. Cela peut entraîner des échecs de condition inattendus.
**Important**
En tant que bonne pratique, assurez-vous que les membres de votre compte suivent une convention de dénomination cohérente pour les attributs avec paire clé-valeur. Les exemples incluent les balises ou les contextes de chiffrement AWS KMS . Vous pouvez l'appliquer en utilisant la clé de [`aws:TagKeys`](reference_policies_condition-keys.md#condition-keys-tagkeys)contexte pour le balisage ou [https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-encryption-context-keys](https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-encryption-context-keys)pour le contexte de AWS KMS chiffrement.
+ Pour obtenir une liste de tous les opérateurs de condition et une description de leur fonctionnement, veuillez consulter la rubrique [Opérateurs de condition](reference_policies_elements_condition_operators.md).
+ Sauf indication contraire, toutes les clés de contexte peuvent comporter plusieurs valeurs. Pour savoir comment traiter des clés de contexte qui ont plusieurs valeurs, veuillez consulter la rubrique [Définir les opérateurs pour les clés de contexte à valeurs multiples](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
+ Pour obtenir la liste de l'ensemble des clés de contexte disponibles dans le monde entier, veuillez consulter la rubrique [AWS clés contextuelles de condition globale](reference_policies_condition-keys.md).
+ Pour les clés de contexte de condition définies par chaque service, voir [Actions, ressources et clés de condition pour les AWS services](reference_policies_actions-resources-contextkeys.html).
## Contexte de la demande
Lorsqu'un [principal](https://docs.aws.amazon.com/glossary/latest/reference/glos-chap.html?icmpid=docs_homepage_addtlrcs#principal) fait une [demande](intro-structure.md#intro-structure-request) à AWS, AWS rassemble les informations de la demande dans un contexte de demande. Le contexte de la demande comprend des informations sur le principal, les ressources, les actions et d’autres propriétés environnementales. L’évaluation de la politique fait correspondre les propriétés de la politique aux propriétés envoyées dans la demande afin d’évaluer et d’autoriser les actions que vous pouvez effectuer dans AWS.
Vous pouvez utiliser l'élément `Condition` d'une politique JSON pour tester des clés de contexte spécifiques par rapport au contexte de la demande. Par exemple, vous pouvez créer une politique qui utilise la clé de CurrentTime contexte [aws :](reference_policies_condition-keys.md#condition-keys-currenttime) pour [permettre à un utilisateur d'effectuer des actions dans un intervalle de dates spécifique uniquement](reference_policies_examples_aws-dates.md).
L’exemple suivant montre une représentation du contexte de la demande lorsque Martha Rivera envoie une demande pour désactiver son dispositif MFA.
```
Principal: AROA123456789EXAMPLE
Action: iam:DeactivateMFADevice
Resource: arn:aws:iam::user/martha
Context:
– aws:UserId=AROA123456789EXAMPLE:martha
– aws:PrincipalAccount=1123456789012
– aws:PrincipalOrgId=o-example
– aws:PrincipalARN=arn:aws:iam::1123456789012:assumed-role/TestAR
– aws:MultiFactorAuthPresent=true
– aws:MultiFactorAuthAge=2800
– aws:CurrentTime=...
– aws:EpochTime=...
– aws:SourceIp=...
```
Le contexte de la demande est mis en correspondance avec une politique qui autorise les utilisateurs à supprimer leur propre dispositif authentification multifactorielle (MFA), mais uniquement s’ils se sont connectés à l’aide de la MFA au cours de la dernière heure (3 600 secondes).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "AllowRemoveMfaOnlyIfRecentMfa",
"Effect": "Allow",
"Action": [
"iam:DeactivateMFADevice"
],
"Resource": "arn:aws:iam::*:user/${aws:username}",
"Condition": {
"NumericLessThanEquals": {"aws:MultiFactorAuthAge": "3600"}
}
}
}
```
------
Dans cet exemple, la politique correspond au contexte de la demande : l’action est la même, la ressource correspond au caractère générique « \$1 » et la valeur pour `aws:MultiFactorAuthAge` est 2 800, qui est inférieure à 3 600. La politique autorise donc cette demande d’autorisation.
AWS évalue chaque clé de contexte de la politique et renvoie une valeur *vraie* ou *fausse*. L'absence de clé de contexte dans la demande est considérée comme une absence de correspondance.
Le contexte de la demande peut renvoyer les valeurs suivantes :
+ **True** : si le demandeur s'est connecté avec MFA au cours de la dernière heure ou moins, la condition renvoie la valeur *true*.
+ **False** : si le demandeur s'est connecté avec MFA il y a plus d'une heure, la condition renvoie la valeur *false*.
+ **Absence : si le demandeur a fait une demande à l'aide de ses clés d'accès utilisateur IAM dans l' AWS API AWS CLI or, la clé n'est pas présente**. Dans ce cas, la clé est manquante et il n'y a pas de correspondance.
**Note**
Dans certains cas, lorsque la valeur de la clé de condition n’est pas présente, la condition peut toujours retourner vraie. Par exemple, si vous ajoutez le qualificateur `ForAllValues`, la demande renvoie vrai si la clé de contexte ne figure pas dans la demande. Pour éviter que des clés de contexte manquantes ou des clés de contexte contenant des valeurs vides ne soient considérées comme vraies, vous pouvez inclure l’[opérateur de condition Null](reference_policies_elements_condition_operators.md#Conditions_Null) dans votre politique avec une valeur `false` pour vérifier si la clé de contexte existe et si sa valeur n’est pas nulle.
## Bloc Condition
L'exemple suivant illustre le format de base d'un élément `Condition` :
```
"Condition": {"StringLike": {"s3:prefix": ["jane/*"]}}
```
Une valeur de la demande est représentée par une clé de contexte. Dans ce cas, il s'agit de `s3:prefix`. La valeur clé de contexte est comparée à une valeur que vous spécifiez comme valeur littérale, par exemple `jane/*`. Le type de comparaison à effectuer est spécifié par l'[opérateur de condition](reference_policies_elements_condition_operators.md) (ici, `StringLike`). Vous pouvez créer des conditions qui comparent des chaînes, des dates, des numéros et autres à l'aide d'opérateurs de comparaison booléens standard comme est égal à, supérieur à ou inférieur à. Lorsque vous utilisez des [opérateurs de chaîne](reference_policies_elements_condition_operators.md#Conditions_String) ou des [opérateurs ARN](reference_policies_elements_condition_operators.md#Conditions_ARN), vous pouvez également utiliser une [variable de politique](reference_policies_variables.md) dans la valeur de clé de contexte. L'exemple suivant inclut la variable `aws:username`.
```
"Condition": {"StringLike": {"s3:prefix": ["${aws:username}/*"]}}
```
Dans certains cas, les clés de contexte peuvent contenir plusieurs valeurs. Par exemple, une demande à Amazon DynamoDB peut retourner ou mettre à jour plusieurs attributs d'une table. Une politique d'accès aux tables DynamoDB peut inclure la clé de contexte `dynamodb:Attributes`, qui contient tous les attributs spécifiés dans la demande. Vous pouvez tester les divers attributs de la demande par rapport à une liste d'attributs autorisés dans une politique à l'aide d'opérateurs de définition dans l'élément `Condition`. Pour de plus amples informations, veuillez consulter [Définir les opérateurs pour les clés de contexte à valeurs multiples](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
Lorsque la politique est évaluée lors d'une demande, AWS remplace la clé par la valeur correspondante de la demande. (Dans cet exemple, AWS utiliserait la date et l'heure de la demande.) L'évaluation de la condition retourne True ou False, ce qui est pris en compte pour déterminer si la politique dans sa totalité autorise ou refuse la demande.
### Plusieurs valeurs dans un élément Condition
Un élément `Condition` peut contenir plusieurs opérateurs de condition, et chaque opérateur de condition peut également inclure plusieurs paires clé-valeur de contexte. L'illustration suivante décrit ce scénario.
![\[diagrammes de deux blocs de l’opérateur à conditions. Le premier bloc inclut deux espaces réservés aux clés contextuelles, chacun contenant plusieurs valeurs. Le second bloc de conditions inclut une clé de contexte à valeurs multiples.\]](http://docs.aws.amazon.com/fr_fr/IAM/latest/UserGuide/images/AccessPolicyLanguage_Condition_Block.diagram.png)
Pour de plus amples informations, veuillez consulter [Définir les opérateurs pour les clés de contexte à valeurs multiples](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
# Éléments de politique JSON IAM : Opérateurs de condition
Utilisez les opérateurs de condition de l'élément `Condition` pour faire correspondre la clé de condition et la valeur de la politique avec les valeurs du contexte de la demande. Pour en savoir plus sur l'élément `Condition`, consultez [Éléments de politique JSON IAM : Condition](reference_policies_elements_condition.md).
L'opérateur de condition que vous pouvez utiliser dans une politique dépend de la clé de condition que vous choisissez. Vous pouvez choisir une clé de condition globale ou une clé de condition spécifique au service. Pour savoir quel opérateur de condition vous pouvez utiliser pour une clé de condition globale, veuillez consulter [AWS clés contextuelles de condition globale](reference_policies_condition-keys.md). Pour savoir quel opérateur de condition vous pouvez utiliser pour une clé de condition spécifique à un service, consultez [Actions, ressources et clés de condition pour les AWS services](reference_policies_actions-resources-contextkeys.html) et choisissez le service que vous souhaitez consulter.
**Important**
Si la clé que vous spécifiez dans une condition de stratégie n'est pas présente dans le contexte de la requête, les valeurs ne correspondent pas et la condition est *fausse*. Si la condition de stratégie requiert qu'il n'y ait *aucune* correspondance de clé, tels que `StringNotLike` ou `ArnNotLike` et la touche de droite n'est pas présente, la condition est *vraie*. Cette logique s'applique à tous les opérateurs de condition sauf[... IfExists](#Conditions_IfExists)et [Contrôle nul](#Conditions_Null). Ces opérateurs testent si la clé est présente (existe) dans le contexte de demande.
Les opérateurs de condition peuvent être regroupés dans les catégories suivantes :
+ [String](#Conditions_String)
+ [Numérique](#Conditions_Numeric)
+ [Date et heure](#Conditions_Date)
+ [Booléen](#Conditions_Boolean)
+ [Binaire](#Conditions_BinaryEquals)
+ [Adresse IP](#Conditions_IPAddress)
+ [Amazon Resource Name (ARN)](#Conditions_ARN) (disponible uniquement pour certains services.)
+ [... IfExists](#Conditions_IfExists)(vérifie si la valeur clé existe dans le cadre d'une autre vérification)
+ [Null check](#Conditions_Null) (vérifie si la valeur de clé existe en tant que vérification autonome)
## Opérateurs de condition de chaîne
Les opérateurs de condition de chaîne permettent de créer des éléments `Condition` qui limitent l'accès après comparaison d'une clé à une valeur de chaîne.
+ **Variables de politiques** – [Prises en charge](reference_policies_variables.md)
+ **Caractères génériques** – [Pris en charge](#Conditions_String-wildcard)
****
| Opérateur de condition | Description |
| --- | --- |
| `StringEquals` | Correspondance exacte, respect de la casse |
| `StringNotEquals` | Correspondance négative |
| `StringEqualsIgnoreCase` | Correspondance exacte, non respect de la casse |
| `StringNotEqualsIgnoreCase` | Correspondance négative, non respect de la casse |
| `StringLike` | Correspondance avec respect de la casse. Les valeurs peuvent inclure un caractère générique (\$1) correspondant à plusieurs caractères et un caractère générique (?) correspondant à un seul caractère n'importe où dans la chaîne. Vous devez spécifier des caractères génériques pour obtenir des correspondances de chaînes partielles. Si une clé contient plusieurs valeurs, `StringLike` peut être qualifié avec les opérateurs d'ensemble `ForAllValues:StringLike` et `ForAnyValue:StringLike`. Pour de plus amples informations, veuillez consulter [Définir les opérateurs pour les clés de contexte à valeurs multiples](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys). |
| `StringNotLike` | Correspondance avec non respect de la casse. Les valeurs peuvent inclure un caractère générique (\$1) correspondant à plusieurs caractères ou un caractère générique (?) correspondant à un seul caractère n'importe où dans la chaîne. |
**Example opérateur de condition de chaîne**
Par exemple, l'instruction suivante contient un élément `Condition` qui utilise la clé [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltag](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltag) pour spécifier que le principal qui fait la requête doit être balisé avec la catégorie de tâche `iamuser-admin` .
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "iam:*AccessKey*",
"Resource": "arn:aws:iam::111122223333:user/*",
"Condition": {
"StringEquals": {
"aws:PrincipalTag/job-category": "iamuser-admin"
}
}
}
}
```
Si la clé que vous spécifiez dans une condition de politique n'est pas présente dans le contexte de demande, les valeurs ne correspondent pas. Dans cet exemple, la clé `aws:PrincipalTag/job-category` est présente dans le contexte de demande si le principal utilise un utilisateur IAM avec des balises attachées. Elle est également incluse pour un principal utilisant un rôle IAM avec des balises ou des balises de session attachées. Si un utilisateur sans la balise tente d'afficher ou de modifier une clé d'accès, la condition renvoie `false` et la demande est implicitement refusée par cette instruction.
Le tableau suivant montre comment cette politique est AWS évaluée en fonction des valeurs des clés de condition figurant dans votre demande.
| Condition de politique | Contexte de la demande | Résultat |
| --- | --- | --- |
| "StringEquals": {
"aws:PrincipalTag/job-category": "iamuser-admin"
} | aws:PrincipalTag/job-category:
– iamuser-admin
| Correspondance |
| "StringEquals": {
"aws:PrincipalTag/job-category": "iamuser-admin"
} | aws:PrincipalTag/job-category:
– dev-ops
| Aucune correspondance |
| "StringEquals": {
"aws:PrincipalTag/job-category": "iamuser-admin"
} | Aucun `aws:PrincipalTag/job-category` dans le contexte de la demande. | Aucune correspondance |
**Example utilisation d’une variable de politique avec une chaîne d’opérateur de condition**
L'exemple suivant utilise l'opérateur de condition `StringLike` pour établir une correspondance entre une chaîne et une [variable de politique](reference_policies_variables.md) afin de créer une politique qui permet à un utilisateur IAM de se servir de la console Amazon S3 pour gérer son propre « répertoire de base » dans un compartiment Amazon S3. La politique autorise les actions spécifiées dans un compartiment S3 si l'élément `s3:prefix` correspond à l'un des modèles spécifiés.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListAllMyBuckets",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::*"
},
{
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket",
"Condition": {
"StringLike": {
"s3:prefix": [
"",
"home/",
"home/${aws:username}/"
]
}
}
},
{
"Effect": "Allow",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/home/${aws:username}",
"arn:aws:s3:::amzn-s3-demo-bucket/home/${aws:username}/*"
]
}
]
}
```
Le tableau suivant montre comment cette politique AWS est évaluée pour différents utilisateurs en fonction de la [aws:username](reference_policies_condition-keys.md#condition-keys-username) valeur dans le contexte de la demande.
| Condition de politique | Contexte de la requête | Résultat |
| --- | --- | --- |
| "StringLike": {
"s3:prefix": [
"home/",
"home/${aws:username}/"
]
} | aws:username:
– martha_rivera
| "StringLike": {
"s3:prefix": [
"home/",
"home/martha_rivera/"
]
} |
| "StringLike": {
"s3:prefix": [
"home/",
"home/${aws:username}/"
]
} | aws:username:
– nikki_wolf
| "StringLike": {
"s3:prefix": [
"home/",
"home/nikki_wolf/"
]
} |
| "StringLike": {
"s3:prefix": [
"home/",
"home/${aws:username}/"
]
} | Aucun `aws:username` dans le contexte de la demande. | Aucune correspondance |
Pour consulter un exemple de politique qui montre comment utiliser l’élément `Condition` pour limiter l’accès à des ressources en fonction d’un ID d’application et d’un ID utilisateur pour la fédération OIDC consultez [Amazon S3 : permet aux utilisateurs Amazon Cognito d'accéder aux objets dans leur compartiment](reference_policies_examples_s3_cognito-bucket.md).
### Opérateurs de condition de chaîne à valeurs multiples
Si une clé dans la demande contient plusieurs valeurs, les opérateurs de chaîne peuvent être qualifiés avec les opérateurs d’ensemble `ForAllValues` et `ForAnyValue`. Pour plus d’informations sur la logique d’évaluation de plusieurs clés ou valeurs de contexte, consultez [Définir les opérateurs pour les clés de contexte à valeurs multiples](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
| Opérateur de condition | Description |
| --- | --- |
| `ForAllValues:StringEquals` `ForAllValues:StringEqualsIgnoreCase` | Toutes les valeurs de la clé de condition dans la demande doivent correspondre à au moins une des valeurs de votre politique. |
| `ForAnyValue:StringEquals` `ForAnyValue:StringEqualsIgnoreCase` | Au moins une valeur clé de condition dans la demande doit correspondre à l’une des valeurs de votre politique. |
| `ForAllValues:StringNotEquals` `ForAllValues:StringNotEqualsIgnoreCase` | Correspondance négative. Aucune des valeurs de la clé de contexte dans la demande ne correspond à l’une des valeurs de clé de contexte dans votre politique. |
| `ForAnyValue:StringNotEquals` `ForAnyValue:StringNotEqualsIgnoreCase` | Correspondance négative. Au moins une valeur de clé de contexte dans la demande ne doit PAS correspondre à l’une des valeurs de la clé de contexte dans votre politique. |
| `ForAllValues:StringLike` | Toutes les valeurs de la clé de condition dans la demande doivent correspondre à au moins une des valeurs de votre politique. |
| `ForAnyValue:StringLike` | Au moins une valeur clé de condition dans la demande doit correspondre à l’une des valeurs de votre politique. |
| `ForAllValues:StringNotLike` | Correspondance négative. Aucune des valeurs de la clé de contexte dans la demande ne correspond à l’une des valeurs de clé de contexte dans votre politique. |
| `ForAnyValue:StringNotLike` | Correspondance négative. Au moins une valeur de clé de contexte dans la demande ne doit PAS correspondre à l’une des valeurs de la clé de contexte dans votre politique. |
**Example utilisation de `ForAnyValue` avec une chaîne d’opérateur de condition**
Cet exemple montre comment vous pouvez créer une politique basée sur l'identité qui autorise l'utilisation de l'action `CreateTags` d'Amazon EC2 pour attacher des balises à une instance. Lorsque vous utilisez `StringEqualsIgnoreCase`, vous pouvez attacher des balises uniquement si la balise contient la clé `environment` et les valeurs `preprod` ou `storage`. Lorsque vous ajoutez `IgnoreCase` à l’opérateur, vous autorisez toute valeur de balise existante en majuscules, telle que `preprod`, `Preprod` et `PreProd`, à être résolue en vrai.
Lorsque vous ajoutez le modificateur `ForAnyValue` avec la clé de condition [aws:TagKeys](reference_policies_condition-keys.md#condition-keys-tagkeys), au moins une valeur de clé de balise dans la demande doit correspondre à la valeur `environment`. La comparaison `ForAnyValue` est sensible à la casse, ce qui empêche les utilisateurs d’utiliser une casse incorrecte pour la clé de balise, par exemple en utilisant `Environment` au lieu de `environment`.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "ec2:CreateTags",
"Resource": "arn:aws:ec2:*:*:instance/*",
"Condition": {
"StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
}
}
}
}
```
Le tableau suivant montre comment cette politique est AWS évaluée en fonction des valeurs des clés de condition figurant dans votre demande.
| Condition de politique | Contexte de la requête | Résultat |
| --- | --- | --- |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– environment
aws:RequestTag/environment:
– preprod
| Correspondance |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– environment
– costcenter
aws:RequestTag/environment:
– PreProd
| Correspondance |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– Environment
aws:RequestTag/Environment:
– preprod
| Aucune correspondance |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– costcenter
aws:RequestTag/environment:
– preprod
| Aucune correspondance |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | Aucun `aws:TagKeys` dans le contexte de la demande. aws:RequestTag/environment:
– storage
| Aucune correspondance |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– environment
Aucun `aws:RequestTag/environment` dans le contexte de la demande. | Aucune correspondance |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | Aucun `aws:TagKeys` dans le contexte de la demande. Aucun `aws:RequestTag/environment` dans le contexte de la demande. | Aucune correspondance |
### Correspondance des caractères génériques
Les opérateurs de condition de chaîne réalisent une correspondance sans modèle qui n'applique pas de format prédéfini. Les opérateurs de condition ARN et de condition de date constituent un sous-ensemble d'opérateurs de chaîne qui appliquent une structure à la valeur de la clé de condition.
Nous vous recommandons d’utiliser des opérateurs de condition qui correspondent aux valeurs auxquelles vous comparez les clés. Par exemple, vous devez utiliser [Opérateurs de condition de chaîne](#Conditions_String) lorsque vous comparez des clés à des valeurs de chaîne. De même, vous devez utiliser [Opérateurs de condition d'Amazon Resource Name (ARN)](#Conditions_ARN) lorsque vous comparez des clés à des valeurs d’ARN.
**Example**
Cet exemple montre comment créer une limite autour des ressources de votre organisation. La condition de cette politique refuse l'accès aux actions Amazon S3 sauf si la ressource à laquelle vous accédez se trouve dans un ensemble spécifique d'unités organisationnelles (OUs) dans AWS Organizations. Un chemin AWS Organizations est une représentation textuelle de la structure d’une entité d’organisation.
La condition exige que `aws:ResourceOrgPaths` contienne l’un des chemins d’UO répertoriés. Comme `aws:ResourceOrgPaths` il s'agit d'une condition à valeurs multiples, la politique utilise `ForAllValues:StringNotLike` l'opérateur pour comparer les valeurs de `aws:ResourceOrgPaths` à la liste de OUs la politique.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyS3AccessOutsideMyBoundary",
"Effect": "Deny",
"Action": [
"s3:*"
],
"Resource": "*",
"Condition": {
"ForAllValues:StringNotLike": {
"aws:ResourceOrgPaths": [
"o-acorg/r-acroot/ou-acroot-mediaou/",
"o-acorg/r-acroot/ou-acroot-sportsou/*"
]
}
}
}
]
}
```
Le tableau suivant montre comment cette politique est AWS évaluée en fonction des valeurs des clés de condition figurant dans votre demande.
| Condition de politique | Contexte de la requête | Résultat |
| --- | --- | --- |
| "ForAllValues:StringNotLike": {
"aws:ResourceOrgPaths": [
"o-acorg/r-acroot/ou-acroot-mediaou/",
"o-acorg/r-acroot/ou-acroot-sportsou/*"
]
} | aws:ResourceOrgPaths:
– o-acorg/r-acroot/ou-acroot-sportsou/costcenter/
| Correspondance |
| "ForAllValues:StringNotLike": {
"aws:ResourceOrgPaths": [
"o-acorg/r-acroot/ou-acroot-mediaou/",
"o-acorg/r-acroot/ou-acroot-sportsou/*"
]
} | aws:ResourceOrgPaths:
– o-acorg/r-acroot/ou-acroot-mediaou/costcenter/
| Aucune correspondance |
| "ForAllValues:StringNotLike": {
"aws:ResourceOrgPaths": [
"o-acorg/r-acroot/ou-acroot-mediaou/",
"o-acorg/r-acroot/ou-acroot-sportsou/*"
]
} | Aucun `aws:ResourceOrgPaths:` dans la demande. | Aucune correspondance |
## Opérateurs de condition numériques
Les opérateurs de condition numériques permettent de créer des éléments `Condition` qui limitent l'accès après comparaison d'une clé à un entier ou une valeur décimale.
+ **Variables de politiques** – Non prises en charge
+ **Caractères génériques** – Non pris en charge
****
| Opérateur de condition | Description |
| --- | --- |
| `NumericEquals` | Correspondance |
| `NumericNotEquals` | Correspondance négative |
| `NumericLessThan` | Correspondance « Inférieur à » |
| `NumericLessThanEquals` | Correspondance « Inférieur ou égal à » |
| `NumericGreaterThan` | Correspondance « Supérieur à » |
| `NumericGreaterThanEquals` | Correspondance « Supérieur ou égal à » |
Par exemple, l'instruction suivante contient un élément `Condition` qui utilise l'opérateur de condition `NumericLessThanEquals` avec la clé `s3:max-keys` pour spécifier que le demandeur peut répertorier *jusqu'à* 10 objets dans `amzn-s3-demo-bucket` à la fois.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket",
"Condition": {"NumericLessThanEquals": {"s3:max-keys": "10"}}
}
}
```
------
Si la clé que vous spécifiez dans une condition de politique n'est pas présente dans le contexte de demande, les valeurs ne correspondent pas. Dans cet exemple, la clé `s3:max-keys` est toujours présente dans la demande lorsque vous effectuez l'opération `ListBucket`. Si cette politique autorisait toutes les opérations Amazon S3, seules les opérations incluant la clé de contexte `max-keys` avec une valeur inférieure ou égale à 10 seraient autorisées.
## Opérateurs de condition de date
Les opérateurs de conditions de date vous permettent de créer `Condition` des éléments qui limitent l'accès en comparant une clé à une date/time valeur. Vous pouvez utiliser ces opérateurs de condition avec la clé [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-currenttime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-currenttime) ou [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-epochtime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-epochtime). Vous devez spécifier date/time des valeurs avec l'une des [implémentations du W3C des formats de date ISO 8601 ou en utilisant l'](http://www.w3.org/TR/NOTE-datetime)heure Epoch (UNIX).
+ **Variables de politiques** – Non prises en charge
+ **Caractères génériques** – Non pris en charge
****
| Opérateur de condition | Description |
| --- | --- |
| `DateEquals` | Correspondance à une date spécifique |
| `DateNotEquals` | Correspondance négative |
| `DateLessThan` | Correspondance avant une date et heure spécifiques |
| `DateLessThanEquals` | Correspondance à ou avant une date et heure spécifiques |
| `DateGreaterThan` | Correspondance après une date et heure spécifiques |
| `DateGreaterThanEquals` | Correspondance à ou après une date et heure spécifiques |
Par exemple, l’instruction suivante contient un élément `Condition` qui utilise l’opérateur de condition `DateGreaterThan` avec la clé [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tokenissuetime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tokenissuetime). Cette condition spécifie que les informations d'identification de sécurité temporaires utilisées pour effectuer la demande ont été publiées en 2020. Cette politique peut être mise à jour par programme tous les jours pour s'assurer que les membres du compte utilisent de nouvelles informations d'identification.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "iam:*AccessKey*",
"Resource": "arn:aws:iam::111122223333:user/*",
"Condition": {
"DateGreaterThan": {
"aws:TokenIssueTime": "2020-01-01T00:00:01Z"
}
}
}
}
```
------
Si la clé que vous spécifiez dans une condition de politique n'est pas présente dans le contexte de demande, les valeurs ne correspondent pas. La clé `aws:TokenIssueTime` n'est présente dans le contexte de demande que lorsque le principal utilise des informations d'identification temporaires pour effectuer la demande. La clé n'est pas présente dans AWS CLI les demandes AWS d'API ou de AWS SDK effectuées à l'aide de clés d'accès. Dans cet exemple, si un utilisateur IAM tente d'afficher ou de modifier une clé d'accès, la demande est refusée.
## Opérateurs de condition booléens
Les opérateurs de condition booléens permettent de créer des éléments `Condition` qui limitent l’accès après comparaison d’une clé à `true` ou `false`.
Si une clé contient plusieurs valeurs, les opérateurs booléens peuvent être qualifiés avec les opérateurs d’ensemble `ForAllValues` et `ForAnyValue`. Pour plus d’informations sur la logique d’évaluation de plusieurs clés ou valeurs de contexte, consultez [Définir les opérateurs pour les clés de contexte à valeurs multiples](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
+ **Variables de politiques** – [Prises en charge](reference_policies_variables.md)
+ **Caractères génériques** – Non pris en charge
****
| Opérateur de condition | Description |
| --- | --- |
| `Bool` | Correspondance booléenne |
| `ForAllValues:Bool` | À utiliser avec le type de données Array of Bool. Toutes les valeurs booléennes dans les valeurs clés du contexte doivent correspondre aux valeurs booléennes de votre politique. Pour empêcher les opérateurs `ForAllValues` d’évaluer les clés de contexte manquantes ou les clés de contexte avec des valeurs vides comme Autorisé, vous pouvez inclure l’[opérateur de condition Null](#Conditions_Null) dans votre politique. |
| `ForAnyValue:Bool` | À utiliser avec le type de données Array of Bool. Au moins l’une des valeurs booléennes dans les valeurs clés du contexte doit correspondre aux valeurs booléennes de votre politique. |
**Example opérateur de condition booléens**
L politique basée sur l’identité suivante utilise l’opérateur de condition `Bool` avec la clé [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-securetransport](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-securetransport) pour refuser la réplication d’objets et de balises d’objets vers le compartiment de destination et son contenu si la demande n’est pas effectuée via SSL.
Cette politique ne permet aucune action. Utilisez cette stratégie conjointement à d'autres stratégies qui autorisent des actions spécifiques.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "BooleanExample",
"Action": "s3:ReplicateObject",
"Effect": "Deny",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
],
"Condition": {
"Bool": {
"aws:SecureTransport": "false"
}
}
}
]
}
```
Le tableau suivant montre comment cette politique est AWS évaluée en fonction des valeurs des clés de condition figurant dans votre demande.
| Condition de politique | Contexte de la requête | Résultat |
| --- | --- | --- |
| "Bool": {
"aws:SecureTransport": "false"
} | aws:SecureTransport:
– false
| Correspondance |
| "Bool": {
"aws:SecureTransport": "false"
} | aws:SecureTransport:
– true
| Aucune correspondance |
| "Bool": {
"aws:SecureTransport": "false"
} | Aucun `aws:SecureTransport` dans le contexte de la demande. | Aucune correspondance |
## Opérateurs de condition binaires
L’opérateur de condition `BinaryEquals` vous permet de créer des éléments `Condition` qui analysent les valeurs de clé qui utilisent un format binaire. Il compare la valeur de la clé spécifiée, octet par octet, à une représentation encodée au format [Base64](https://en.wikipedia.org/wiki/Base64) de la valeur binaire dans la politique. Si la clé que vous spécifiez dans une condition de politique n'est pas présente dans le contexte de demande, les valeurs ne correspondent pas.
+ **Variables de politiques** – Non prises en charge
+ **Caractères génériques** – Non pris en charge
```
"Condition" : {
"BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
}
}
```
| Condition de politique | Contexte de la requête | Résultat |
| --- | --- | --- |
| "BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
} | key:
– QmluYXJ5VmFsdWVJbkJhc2U2NA==
| Correspondance |
| "BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
} | key:
– ASIAIOSFODNN7EXAMPLE
| Aucune correspondance |
| "BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
} | Aucun `key` dans le contexte de la demande. | Aucune correspondance |
## Opérateurs de condition d'adresse IP
Les opérateurs de condition d'adresse IP vous permettent de créer `Condition` des éléments qui limitent l'accès en comparant une clé à une IPv6 adresse IPv4 ou à une plage d'adresses IP. Vous utilisez ces opérateurs avec la clé [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceip](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceip). La valeur doit être au format CIDR standard (par exemple, 203.0.113.0/24 ou 2001 : : 1234:5678 : :/64). DB8 Si vous spécifiez une adresse IP sans préfixe de routage associé, IAM utilise la valeur de préfixe par défaut `/32`.
Certains AWS services sont compatibles IPv6, en utilisant : : pour représenter une plage de 0. Pour savoir si un service est compatible IPv6, consultez sa documentation.
+ **Variables de politiques** – Non prises en charge
+ **Caractères génériques** – Non pris en charge
****
| Opérateur de condition | Description |
| --- | --- |
| `IpAddress` | Adresse IP ou plage d'adresses IP spécifiée |
| `NotIpAddress` | Toutes les adresses IP à l'exception de l'adresse IP ou de la plage d'adresse IP spécifiée |
**Example Opérateur de condition d’adresse IP**
L’instruction suivante utilise l’opérateur de condition `IpAddress` avec la clé `aws:SourceIp` pour spécifier que la demande doit provenir d’une adresse IP comprise dans la plage 203.0.113.0 à 203.0.113.255.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "iam:*AccessKey*",
"Resource": "arn:aws:iam::111122223333:user/*",
"Condition": {
"IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
}
}
}
}
```
La clé de condition `aws:SourceIp` est résolue à l'aide de l'adresse IP d'où provient la demande. Si la demande provient d'une instance Amazon EC2, `aws:SourceIp` correspond à l'adresse IP publique de l'instance.
Si la clé que vous spécifiez dans une condition de politique n'est pas présente dans le contexte de demande, les valeurs ne correspondent pas. La clé `aws:SourceIp` figure toujours dans le contexte de demande, sauf lorsque le demandeur utilise un point de terminaison VPC pour effectuer la demande. Dans ce cas, la condition renvoie `false` et la demande est implicitement refusée par cette instruction.
Le tableau suivant montre comment cette politique est AWS évaluée en fonction des valeurs des clés de condition figurant dans votre demande.
| Condition de politique | Contexte de la requête | Résultat |
| --- | --- | --- |
| "IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
} | aws:SourceIp:
– 203.0.113.1
| Correspondance |
| "IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
} | aws:SourceIp:
– 198.51.100.1
| Aucune correspondance |
L'exemple suivant montre comment combiner IPv4 les IPv6 adresses afin de couvrir toutes les adresses IP valides de votre organisation. Nous vous recommandons de mettre à jour les politiques de votre organisation en fonction de vos plages d' IPv6 adresses, en plus des IPv4 plages dont vous disposez déjà, afin de vous assurer que les politiques continuent de fonctionner pendant votre transition IPv6.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "someservice:*",
"Resource": "*",
"Condition": {
"IpAddress": {
"aws:SourceIp": [
"203.0.113.0/24",
"2001:DB8:1234:5678::/64"
]
}
}
}
}
```
La clé de condition `aws:SourceIp` fonctionne uniquement dans une politique JSON si vous appelez l'API que vous testez directement en tant qu'utilisateur. En revanche, si vous utilisez un service pour appeler le service cible en votre nom, ce service voit l'adresse IP du service appelant plutôt que celle de l'utilisateur d'origine. Par exemple, cela peut se produire si vous utilisez AWS CloudFormation pour appeler Amazon EC2 en vue de créer automatiquement des instances. Actuellement, il n'est pas possible de transmettre l'adresse IP d'origine au service cible via un service appelant à des fins d'évaluation dans une politique JSON. Pour ces types d'appels d'API de service, vous ne devez pas utiliser la clé de condition `aws:SourceIp`.
## Opérateurs de condition d'Amazon Resource Name (ARN)
Les opérateurs de condition d'Amazon Resource Name (ARN) permettent de créer des éléments `Condition` qui limitent l'accès après comparaison d'une clé à un ARN. L'ARN est considéré comme étant une chaîne.
+ **Variables de politiques** – [Prises en charge](reference_policies_variables.md)
+ **Caractères génériques** – [Pris en charge](reference_policies_elements_resource.md#reference_policies_elements_resource_wildcards)
****
| Opérateur de condition | Description |
| --- | --- |
| `ArnEquals`, `ArnLike` | Correspondance à l'ARN avec respect de la casse. Chacun des six composants de l'ARN, séparés par deux points, est vérifié séparément et chacun peut inclure un caractère générique correspondant à plusieurs caractères (\$1) ou un caractère générique correspondant à un caractère (?). Les opérateurs de condition `ArnEquals` et `ArnLike` se comportent de manière identique. |
| `ArnNotEquals`, `ArnNotLike` | Correspondance négative à l'ARN. Les opérateurs de condition `ArnNotEquals` et `ArnNotLike` se comportent de manière identique. |
**Example Opérateur de condition de l’ARN**
L'exemple de politique basée sur les ressources suivant montre une politique attachée à une file d'attente Amazon SQS à laquelle vous souhaitez envoyer des messages SNS. Elle donne l'autorisation à Amazon SNS d'envoyer des messages à une ou plusieurs files d'attente de votre choix, mais uniquement si le service envoie le message pour le compte d'une ou plusieurs rubriques Amazon SNS spécifiques. Vous spécifiez la file d'attente dans le champ `Resource`, tandis que la rubrique Amazon SNS est la valeur de la clé `SourceArn`.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Principal": {
"Service": "sns.amazonaws.com"
},
"Action": "SQS:SendMessage",
"Resource": "arn:aws:sqs:us-east-1:123456789012:QUEUE-ID",
"Condition": {
"ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-east-1:123456789012:TOPIC-ID"
}
}
}
}
```
La clé [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) figure dans le contexte de demande uniquement si une ressource déclenche un service pour appeler un autre service au nom du propriétaire de la ressource. Si un utilisateur IAM tente d'effectuer cette opération directement, la condition renvoie `false` et la demande est implicitement refusée par cette instruction.
Le tableau suivant montre comment cette politique est AWS évaluée en fonction des valeurs des clés de condition figurant dans votre demande.
| Condition de politique | Contexte de la requête | Résultat |
| --- | --- | --- |
| "ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"
} | aws:SourceArn:
– arn:aws:sns:us-west-2:123456789012:TOPIC-ID
| Correspondance |
| "ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"
} | aws:SourceArn:
– arn:aws:sns:us-west-2:777788889999:TOPIC-ID
| Aucune correspondance |
| "ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"
} | Aucun `aws:SourceArn` dans le contexte de la demande. | Aucune correspondance |
### Opérateurs de condition d’ARN à valeurs multiples
Si une clé dans la demande contient plusieurs valeurs, les opérateurs d’ARN peuvent être qualifiés avec les opérateurs d’ensemble `ForAllValues` et `ForAnyValue`. Pour plus d’informations sur la logique d’évaluation de plusieurs clés ou valeurs de contexte, consultez [Définir les opérateurs pour les clés de contexte à valeurs multiples](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
| Opérateur de condition | Description |
| --- | --- |
| `ForAllValues:ArnEquals` `ForAllValues:ArnLike` | Tous les éléments contenus ARNs dans le contexte de la demande doivent correspondre à au moins un des modèles d'ARN de votre politique. |
| `ForAnyValue:ArnEquals` `ForAnyValue:ArnLike` | Au moins un ARN du contexte de la demande doit correspondre à un des modèles ARN de votre politique. |
| `ForAllValues:ArnNotEquals` `ForAllValues:ArnNotLike` | Correspondance négative. Aucun des éléments contenus ARNs dans le contexte de la demande ne peut correspondre aux modèles d'ARN de chaîne de votre politique. |
| `ForAnyValue:ArnNotEquals` `ForAnyValue:ArnNotLike` | Correspondance négative. Au moins un ARN dans le contexte de la demande ne doit PAS correspondre à l’un des modèles ARN de votre politique. |
**Example utilisation de `ForAllValues` avec un d’opérateur de condition d’ARN**
L'exemple suivant permet `ForAllValues:ArnLike` de créer ou de mettre à jour une source de livraison logique pour les CloudWatch journaux Amazon Logs. Le bloc de condition inclut la clé de condition [https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazoncloudwatchlogs.html#amazoncloudwatchlogs-policy-keys](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazoncloudwatchlogs.html#amazoncloudwatchlogs-policy-keys)pour filtrer la ressource générant le journal ARNs transmise dans la demande. À l'aide de cet opérateur de condition, tous les éléments de la demande doivent correspondre à au moins un ARN de la politique. ARNs
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": "logs:PutDeliverySource",
"Resource": "arn:aws:logs:us-east-1:123456789012:delivery-source:*",
"Condition": {
"ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws:cloudfront::123456789012:distribution/*",
"arn:aws:cloudfront::123456789012:distribution/support*"
]
}
}
}
]
}
```
Le tableau suivant montre comment cette politique est AWS évaluée en fonction des valeurs des clés de condition figurant dans votre demande.
| Condition de politique | Contexte de la requête | Résultat |
| --- | --- | --- |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | logs:LogGeneratingResourceArns:
– arn:aws::cloudfront:123456789012:distribution/costcenter
| Correspondance |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | logs:LogGeneratingResourceArns:
– arn:aws::cloudfront:123456789012:distribution/costcenter
– arn:aws::cloudfront:123456789012:distribution/support2025
| Correspondance |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | logs:LogGeneratingResourceArns:
– arn:aws::cloudfront:123456789012:distribution/costcenter
– arn:aws::cloudfront:123456789012:distribution/admin
| Aucune correspondance |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | logs:LogGeneratingResourceArns:
– arn:aws::cloudfront:777788889999:distribution/costcenter
| Aucune correspondance |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | Aucun `logs:LogGeneratingResourceArns` dans le contexte de la demande. | Correspondance |
Le qualificateur `ForAllValues` renvoie la valeur true si la demande ne comprend pas de clés de contexte ou si la valeur de clé de contexte aboutit à un jeu de données nul, tel qu’une chaîne vide. Pour éviter que des clés de contexte manquantes ou des clés de contexte contenant des valeurs vides ne soient considérées comme vraies, vous pouvez inclure l’[opérateur de condition Null](#Conditions_Null) dans votre politique avec une valeur `false` pour vérifier si la clé de contexte existe et si sa valeur n’est pas nulle.
## ... IfExists opérateurs de conditions
Vous pouvez ajouter `IfExists` à la fin de n'importe quel nom d'opérateur de condition, à l'exception de la condition `Null`, par exemple,`StringLikeIfExists`. Ceci équivaut à spécifier que « Si la clé de condition est présente dans le contexte de la requête, la clé doit être traitée comme spécifié dans la politique. Si la clé n'est pas présente, la condition évalue l'élément de condition comme vrai. » Les autres éléments de condition dans l'instruction peuvent toujours se traduire par une absence de correspondance, mais pas par une clé manquante lors de la vérification avec `...IfExists`. Si vous utilisez un élément `"Effect": "Deny"` avec un opérateur de condition négatif tel que `StringNotEqualsIfExists`, la demande est toujours refusée, même si la clé de condition n’est pas présente.
**Exemple d'utilisation de `IfExists`**
De nombreuses clés de condition contiennent des informations se rapportant à un type spécifique de ressources et elles ne sont présentes que lorsque vous accédez à ce type de ressources. Ces clés de condition n'existent pas pour les autres types de ressources. Le fait que l'instruction ne s'applique qu'à un type spécifique de ressources ne pose pas problème. Toutefois, dans certains scénarios, une même instruction peut s'appliquer à plusieurs types de ressources, par exemple lorsque l'instruction de politique référence les actions de plusieurs services ou lorsqu'une action donnée d'un service accède à différents types de ressources dans un même service. Dans ce cas, l'inclusion d'une clé de condition applicable uniquement à une des ressources dans l'instruction de politique peut provoquer l'échec de l'élément `Condition` et de ce fait, l'élément `"Effect"` ne s'applique pas.
Prenons l'exemple de politique suivant :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "THISPOLICYDOESNOTWORK",
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": "*",
"Condition": {"StringLike": {"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]}}
}
}
```
------
L'*intention* de la politique précédente est de permettre à l'utilisateur de lancer n'importe quelle instance de type `t1`, `t2` ou `m3`. Toutefois, le lancement d'une instance requiert non seulement l'accès à l'instance proprement dite, mais également à de nombreuses ressources telles que des images, des paires de clés, des groupes de sécurité, etc. L'ensemble de l'instruction est évalué par rapport à chaque ressource requise pour le lancement de l'instance. Ces ressources supplémentaires n'ont pas la clé de condition `ec2:InstanceType` et, par conséquent, la vérification `StringLike` échoue et l'utilisateur n'est autorisé à lancer *aucun* type d'instance.
Pour éviter ce problème, utilisez l'opérateur de condition `StringLikeIfExists` à la place. De cette façon, le test n'est effectué que si la clé de condition existe. Cela peut être interprété comme suit : « Si la ressource en cours de vérification est dotée d'une clé de condition `ec2:InstanceType`, l'action peut uniquement être autorisée si la valeur de la clé commence par `t1.`, `t2.` ou `m3.`. Si la ressource en cours de vérification n'est pas dotée de cette clé de condition, peu importe. » L'astérisque (\$1) figurant dans les valeurs des clés de condition, lorsqu'il est utilisé avec l'opérateur de condition `StringLikeIfExists`, est interprété comme un caractère générique pour obtenir des correspondances de chaînes partielles. L'instruction `DescribeActions` inclut les actions requises pour afficher l'instance dans la console.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "RunInstance",
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": "*",
"Condition": {
"StringLikeIfExists": {
"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]
}
}
},
{
"Sid": "DescribeActions",
"Effect": "Allow",
"Action": [
"ec2:DescribeImages",
"ec2:DescribeInstances",
"ec2:DescribeVpcs",
"ec2:DescribeKeyPairs",
"ec2:DescribeSubnets",
"ec2:DescribeSecurityGroups"
],
"Resource": "*"
}
]
}
```
------
Le tableau suivant montre comment cette politique est AWS évaluée en fonction des valeurs des clés de condition figurant dans votre demande.
| Condition de politique | Contexte de la requête | Résultat |
| --- | --- | --- |
| "StringLikeIfExists": {
"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]
} | ec2:InstanceType:
– t1.micro
| Correspondance |
| "StringLikeIfExists": {
"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]
} | ec2:InstanceType:
– m2.micro
| Aucune correspondance |
| "StringLikeIfExists": {
"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]
} | Aucun `ec2:InstanceType` dans le contexte de la demande. | Correspondance |
## Opérateur de condition pour vérifier l'existence de clés de condition
Utilisez un opérateur de condition `Null` pour vérifier si une clé de condition est absente au moment de l'autorisation. Dans l'instruction de politique, utilisez `true` (la clé n'existe pas ; elle est nulle) ou `false` (la clé existe et sa valeur n'est pas nulle).
Vous ne pouvez pas utiliser une [variable de politique](reference_policies_variables.md) avec l'opérateur de condition `Null`.
Par exemple, vous pouvez utiliser cet opérateur de condition pour déterminer si un utilisateur utilise des informations d’identification temporaires ou ses propres informations d’identification pour effectuer une demande. S'il utilise des informations d'identification temporaires, la clé `aws:TokenIssueTime` existe et elle est dotée d'une valeur. L’exemple suivant illustre une condition qui spécifie que l’utilisateur doit avoir recours à des informations d’identification temporaires (la clé ne peut pas être absente) pour exécuter l’API Amazon EC2.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":{
"Action":"ec2:*",
"Effect":"Allow",
"Resource":"*",
"Condition":{"Null":{"aws:TokenIssueTime":"false"}}
}
}
```
------
# Conditions avec plusieurs clés ou valeurs de contexte
Vous pouvez utiliser l'élément `Condition` d'une politique pour tester plusieurs clés ou plusieurs valeurs de contexte pour une seule clé de contexte dans une demande. Lorsque vous faites une demande AWS, par programmation ou par le biais du AWS Management Console, votre demande inclut des informations sur votre principal, votre fonctionnement, vos balises, etc. Vous pouvez utiliser des clés de contexte pour tester les valeurs des clés de contexte correspondantes dans la demande, avec les clés de contexte spécifiées dans la condition de politique. Pour en savoir plus sur les informations et les données incluses dans une demande, consultez [Contexte de la demande](reference_policies_elements_condition.md#AccessPolicyLanguage_RequestContext).
**Topics**
+ [Logique d'évaluation pour plusieurs clés ou valeurs de contexte](#reference_policies_multiple-conditions-eval)
+ [Logique d'évaluation des opérateurs de condition de correspondance négative](#reference_policies_multiple-conditions-negated-matching-eval)
## Logique d'évaluation pour plusieurs clés ou valeurs de contexte
Un élément `Condition` peut contenir plusieurs opérateurs de condition, et chaque opérateur de condition peut également inclure plusieurs paires clé-valeur de contexte. La plupart des clés de contexte prennent en charge l'utilisation de plusieurs valeurs, sauf indication contraire.
+ Si votre instruction de politique dispose de plusieurs [opérateurs de condition](reference_policies_elements_condition_operators.md), ils sont évalués à l'aide d'un opérateur logique `AND`.
+ Si votre instruction de politique dispose de plusieurs clés de contexte attachées à un même opérateur de condition, celles-ci sont évaluées à l'aide d'un opérateur logique `AND`.
+ Si un même opérateur de condition comprend plusieurs valeurs pour une clé de contexte, ces valeurs sont évaluées à l'aide d'un opérateur logique `OR`.
+ Si un même opérateur de condition de correspondance négative comprend plusieurs valeurs pour une clé de contexte, ces valeurs sont évaluées à l'aide d'un opérateur logique `NOR`.
Toutes les clés de contexte d'un bloc d'éléments de condition doivent être résolues sur true (vrai) pour invoquer l'effet `Allow` ou `Deny` souhaité. La figure suivante illustre la logique d'évaluation d'une condition comportant plusieurs opérateurs de condition et des paires clé-valeur de contexte.
![\[Bloc de conditions illustrant l'application des opérateurs AND et OR à plusieurs valeurs et clés de contexte\]](http://docs.aws.amazon.com/fr_fr/IAM/latest/UserGuide/images/AccessPolicyLanguage_Condition_Block_AND_2.diagram.png)
Par exemple, la politique de compartiment S3 suivante illustre la manière dont la figure précédente est représentée dans une politique. Le bloc de conditions comprend les opérateurs de condition `StringEquals` et `ArnLike`, et les clés de contexte `aws:PrincipalTag` et `aws:PrincipalArn`. Afin d'invoquer l'effet `Allow` ou `Deny` souhaité, toutes les clés de contexte du bloc de conditions doivent être résolues sur true (vrai). L'utilisateur qui fait la demande doit disposer des deux clés de balise du principal, *department* et *role*, qui incluent l'une des valeurs de clés de balise spécifiées dans la politique. De plus, l'ARN principal de l'utilisateur qui fait la demande doit correspondre à l'une des valeurs `aws:PrincipalArn` spécifiées dans la politique pour être évalué comme true (vrai).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ExamplePolicy",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::222222222222:root"
},
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket",
"Condition": {
"StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
}
}
}
]
}
```
------
Le tableau suivant montre comment cette politique est AWS évaluée en fonction des valeurs des clés de condition figurant dans votre demande.
| Condition de politique | Contexte de la demande | Résultat |
| --- | --- | --- |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | aws:PrincipalTag/department: legal
aws:PrincipalTag/role: audit
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Mary
| **Match** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | aws:PrincipalTag/department: hr
aws:PrincipalTag/role: audit
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Nikki
| **Aucune correspondance** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | aws:PrincipalTag/department: hr
aws:PrincipalTag/role: payroll
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Mary
| **Aucune correspondance** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | Aucun `aws:PrincipalTag/role` dans le contexte de la demande. aws:PrincipalTag/department: hr
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Mary
| **Aucune correspondance** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | Aucun `aws:PrincipalTag` dans le contexte de la demande. aws:PrincipalArn:
arn:aws:iam::222222222222:user/Mary
| **Aucune correspondance** |
## Logique d'évaluation des opérateurs de condition de correspondance négative
Certains [opérateurs de condition](reference_policies_elements_condition_operators.md), tels que `StringNotEquals` ou `ArnNotLike`, utilisent la correspondance négative pour comparer les paires clé-valeur de contexte de votre politique aux paires clé-valeur de contexte d'une demande. Lorsque plusieurs valeurs sont spécifiées pour une même clé de contexte dans une politique avec des opérateurs de condition de correspondance négative, les autorisations effectives fonctionnent comme un opérateur logique `NOR`. Dans le cas d'une correspondance négative, un opérateur logique `NOR` ou `NOT OR` renvoie la valeur true (vrai) uniquement si toutes les valeurs sont évaluées comme false (fausses).
La figure suivante illustre la logique d'évaluation d'une condition comportant plusieurs opérateurs de condition et des paires clé-valeur de contexte. La figure inclut un opérateur de condition de correspondance négative pour la clé de contexte 3.
![\[Bloc de conditions illustrant l'application des opérateurs AND et OR à plusieurs valeurs et clés de contexte lorsqu'un opérateur de condition de correspondance négative est utilisé\]](http://docs.aws.amazon.com/fr_fr/IAM/latest/UserGuide/images/AccessPolicyLanguage_Condition_Block_AND_Negated_NOR_2.diagram.png)
Par exemple, la politique de compartiment S3 suivante illustre la manière dont la figure précédente est représentée dans une politique. Le bloc de conditions comprend les opérateurs de condition `StringEquals` et `ArnNotLike`, et les clés de contexte `aws:PrincipalTag` et `aws:PrincipalArn`. Afin d'invoquer l'effet `Allow` ou `Deny` souhaité, toutes les clés de contexte du bloc de conditions doivent être résolues sur true (vrai). L'utilisateur qui fait la demande doit disposer des deux clés de balise du principal, *department* et *role*, qui incluent l'une des valeurs de clés de balise spécifiées dans la politique. Puisque l'opérateur de condition `ArnNotLike` utilise la correspondance négative, l'ARN principal de l'utilisateur qui fait la demande ne doit pas correspondre à l'une des valeurs `aws:PrincipalArn` spécifiées dans la politique pour être évalué comme true (vrai).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ExamplePolicy",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::222222222222:root"
},
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket",
"Condition": {
"StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnNotLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
}
}
}
]
}
```
------
Le tableau suivant montre comment cette politique est AWS évaluée en fonction des valeurs des clés de condition figurant dans votre demande.
| Condition de politique | Contexte de la demande | Résultat |
| --- | --- | --- |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnNotLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | aws:PrincipalTag/department: legal
aws:PrincipalTag/role: audit
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Nikki
| **Match** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnNotLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | aws:PrincipalTag/department: hr
aws:PrincipalTag/role: audit
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Mary
| **Aucune correspondance** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnNotLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | aws:PrincipalTag/department: hr
aws:PrincipalTag/role: payroll
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Nikki
| **Aucune correspondance** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnNotLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | >Aucun `aws:PrincipalTag/role` dans le contexte de la demande. aws:PrincipalTag/department: hr
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Nikki
| **Aucune correspondance** |
| "StringEquals": {
"aws:PrincipalTag/department": [
"finance",
"hr",
"legal"
],
"aws:PrincipalTag/role": [
"audit",
"security"
]
},
"ArnNotLike": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:user/Ana",
"arn:aws:iam::222222222222:user/Mary"
]
} | Aucun `aws:PrincipalTag` dans le contexte de la demande. aws:PrincipalArn:
arn:aws:iam::222222222222:user/Nikki
| **Aucune correspondance** |
# Clés de contexte à valeur unique ou à valeurs multiples
La différence entre les clés de contexte à valeur unique et à valeurs multiples réside dans le nombre de valeurs dans le [contexte de la requête](intro-structure.md#intro-structure-request), et non du nombre de valeurs dans la condition de la politique.
+ Les clés de contexte de condition à *valeur unique* ont au plus une valeur dans le contexte de la demande. Par exemple, lorsque vous balisez des ressources AWS, chaque balise de ressource est stockée sous forme de paire clé-valeur. Comme une clé de balise de ressource ne peut avoir qu’une seule valeur de balise, [aws:ResourceTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-resourcetag) est une clé de contexte à valeur unique. N'utilisez pas d'opérateur d'ensemble de conditions avec une clé de contexte à valeur unique.
+ Les clés de contexte de condition *à valeurs multiples* peuvent comporter plusieurs valeurs dans le contexte de la demande. Par exemple, lorsque vous balisez des ressources AWS, vous pouvez inclure plusieurs paires clé-valeur de balise dans une seule demande. Ainsi, [aws:TagKeys](reference_policies_condition-keys.md#condition-keys-tagkeys) est une clé de contexte à valeurs multiples. Les clés de contexte à valeurs multiples nécessitent un opérateur d'ensemble de conditions.
Par exemple, une demande peut provenir d'un seul point de terminaison d'un VPC au maximum. [aws:SourceVpce](reference_policies_condition-keys.md#condition-keys-sourcevpce) est donc une clé de contexte à valeur unique. Étant donné qu'un service peut avoir plus d'un nom de principal de service qui appartient au service, [aws:PrincipalServiceNamesList](reference_policies_condition-keys.md#condition-keys-principalservicenameslist) est une clé de contexte à valeurs multiples.
**Important**
La différence entre les clés de contexte à valeur unique et à valeurs multiples dépend du nombre de valeurs dans le contexte de la demande, et non du nombre de valeurs dans la condition de la politique.
## Points clés
+ Les classifications *À valeur unique* et *À valeurs multiples* sont incluses dans la description de chaque clé de contexte de condition, dans le *Type de valeur* de la rubrique [AWS clés contextuelles de condition globale](reference_policies_condition-keys.md).
+ Les clés de contexte à valeurs multiples dans la [référence d’autorisation de service](https://docs.aws.amazon.com/service-authorization/latest/reference/reference_policies_actions-resources-contextkeys.html) utilisent un préfixe `ArrayOf` suivi du type d’opérateur de condition, tel que `ArrayOfString` ou `ArrayOfARN`, indiquant que la demande peut inclure plusieurs valeurs pour une clé de contexte de condition.
+ Vous pouvez utiliser n’importe quelle clé de contexte à valeur unique disponible en tant que variable de politique, mais vous ne pouvez pas utiliser une clé de contexte à valeurs multiples en tant que variable de politique. Pour de plus amples informations sur les variables de politique, veuillez consulter [Éléments des politiques IAM : variables et balises](reference_policies_variables.md).
+ Lors de l’utilisation de clés de contexte comprenant des paires clé-valeur, il est important de noter que même s’il peut y avoir plusieurs valeurs de clé de balise, chacun `tag-key` ne peut avoir qu’une seule valeur.
+ [aws:PrincipalTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-principaltag), [aws:RequestTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-requesttag) et [aws:ResourceTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-resourcetag) sont des clés de contexte à valeur unique.
+ [aws:TagKeys](reference_policies_condition-keys.md#condition-keys-tagkeys) définit les clés de balise autorisées dans une demande, mais n’inclut pas les valeurs des clés de balise. Comme vous pouvez inclure plusieurs paires clé-valeur dans une demande, `aws:TagKeys` est une clé de contexte à valeurs multiples.
+ Les clés de contexte à valeurs multiples nécessitent un opérateur d'ensemble de conditions. N'utilisez pas d'opérateurs d'ensemble de conditions `ForAllValues` ou `ForAnyValue` avec des clés de contexte à valeur unique. L'utilisation d'opérateurs d'ensembles de conditions avec des clés de contexte à valeur unique peut entraîner des politiques trop permissives.
## Définir les opérateurs pour les clés de contexte à valeurs multiples
Pour comparer votre clé de contexte de condition à un [contexte de demande](intro-structure.md#intro-structure-request) à valeurs multiples, vous devez utiliser les opérateurs d'ensemble `ForAllValues` ou `ForAnyValue`. Ces opérateurs d'ensembles sont utilisés pour comparer deux ensembles de valeurs, tels que l'ensemble de balises dans une demande et l'ensemble de balises dans une condition de politique.
Ces qualificatifs `ForAllValues` et `ForAnyValue` ajoutent une fonctionnalité d’opération d’ensemble à l’opérateur de condition afin que vous puissiez tester les clés de contexte avec plusieurs valeurs par rapport à plusieurs valeurs de clé de contexte dans une condition de politique. En outre, si vous incluez une clé de contexte à valeurs multiples dans votre politique avec un caractère générique ou une variable, vous devez également utiliser l'[opérateur de condition](reference_policies_elements_condition_operators.md#Conditions_String) `StringLike`. Les valeurs de clé de condition multiples doivent être placées entre crochets, comme dans un [tableau](reference_policies_grammar.md#policies-grammar-json), par exemple, `"Key2":["Value2A", "Value2B"]`.
### ForAllValues
Le qualificateur `ForAllValues` vérifie si la valeur de chaque membre du contexte de la demande correspond à l’opérateur de condition qui suit le qualificateur. La condition renvoie la valeur `true` si chaque valeur de clé de contexte de la demande correspond à une valeur de clé de contexte de la politique. Il renvoie également `true` s’il n’y a aucune clé de contexte dans la demande.
**Important**
Faites preuve de vigilance si vous utilisez `ForAllValues` avec un effet `Allow`, car cela peut être trop permissif si la présence de clés de contexte manquantes dans le contexte de la demande est inattendue. Vous devez toujours inclure l’opérateur de condition [`Null`](reference_policies_elements_condition_operators.md#Conditions_Null) dans votre politique avec une valeur `false` pour vérifier si la clé de contexte existe et si sa valeur n’est pas nulle. Pour obtenir un exemple, consultez [Contrôle de l'accès en fonction des clés de balise](access_tags.md#access_tags_control-tag-keys).
#### Exemple d'opérateur ForAllValues d'ensemble
Dans l'exemple suivant, ForAllValues est utilisé avec aws : TagKeys pour permettre aux utilisateurs de supprimer des balises spécifiques attribuées à une instance EC2. Cette politique permet aux utilisateurs de supprimer uniquement les balises `environment` et `cost-center`. Vous pouvez les supprimer séparément ou ensemble. Les clés de balise dans la demande doivent correspondre exactement aux clés spécifiées dans la politique.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:DeleteTags",
"Resource": "arn:aws:ec2:us-east-1:111122223333:instance/*",
"Condition": {
"ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
}
}
}
]
}
```
------
Le tableau suivant montre comment cette politique est AWS évaluée en fonction des valeurs des clés de condition figurant dans votre demande.
| Condition de politique | Contexte de la demande | Résultat |
| --- | --- | --- |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– environment
| **Match** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– cost-center
| **Match** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– environment
– cost-center
| **Match** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– environment
– dept
| **Aucune correspondance** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | Aucun `aws:TagKeys` dans le contexte de la demande. | **Aucune correspondance** |
Notez que dans le dernier exemple, le résultat est « Aucune correspondance » car la vérification de la condition Null empêche la correspondance lorsque la clé de contexte est manquante. Une bonne pratique consiste à éviter les politiques trop permissives.
### ForAnyValue
Le qualificateur `ForAnyValue` teste si au moins un membre de l’ensemble des valeurs de clé de contexte de la demande correspond à au moins un membre de l’ensemble des valeurs de clé de contexte de votre condition de politique. La condition renvoie la valeur `true` si l’une des valeurs de clé de contexte de la demande correspond à l’une des valeurs de clé de contexte de la politique. Si aucune clé de contexte correspondante n’est trouvée ou si la clé n’existe pas, la condition renvoie `false`.
**Important**
Lorsque vous utilisez `ForAnyValue` avec un effet `Deny`, si la clé de contexte n’est pas présente dans la demande, la politique est évaluée comme **Aucune correspondance**. Pour garantir un comportement cohérent, ajoutez une vérification de condition [`Null`](reference_policies_elements_condition_operators.md#Conditions_Null) explicite dans votre politique afin de vérifier si la clé de contexte existe. Pour en savoir plus, consultez [Opérateur de condition pour vérifier l'existence de clés de condition](reference_policies_elements_condition_operators.md#Conditions_Null).
#### Exemple d'opérateur ForAnyValue d'ensemble
Dans l'exemple suivant, ForAnyValue est utilisé avec aws : TagKeys pour permettre aux utilisateurs de supprimer des balises spécifiques attribuées à une instance EC2. Cette politique permet aux utilisateurs de supprimer les balises pour une instance si les clés de balise spécifiées dans la demande incluent `environment` ou `cost-center`. La demande peut inclure des clés de balise supplémentaires en plus de celles spécifiées dans la politique, mais doit inclure au moins une des clés spécifiées pour correspondre à la condition.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:DeleteTags",
"Resource": "arn:aws:ec2:us-east-1:111122223333:instance/*",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
}
}
}
]
}
```
------
Le tableau suivant montre comment cette politique est AWS évaluée en fonction des valeurs des clés de condition figurant dans votre demande.
| Condition de politique | Contexte de la demande | Résultat |
| --- | --- | --- |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– environment
| **Match** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– cost-center
| **Match** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– environment
– cost-center
| **Match** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– environment
– dept
| **Match** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– dept
| **Aucune correspondance** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | Aucun `aws:TagKeys` dans le contexte de la demande. | **Aucune correspondance** |
# Exemples de politiques de conditions
Dans les politiques IAM, vous pouvez spécifier plusieurs valeurs pour les clés de contexte à valeur unique et à valeurs multiples à des fins de comparaison avec le contexte de la demande. L'ensemble suivant d'exemples de politiques montre les conditions de politique avec plusieurs clés et valeurs de contexte.
**Note**
Si vous souhaitez envoyer une politique à inclure dans ce guide de référence, utilisez le bouton **Commentaire** situé au bas de cette page. Pour accéder à des exemples de politiques IAM basées sur l'identité, veuillez consulter la rubrique [Exemples de politiques basées sur l'identité IAM](access_policies_examples.md).
## Exemples de politiques de conditions : clés de contexte à valeur unique
+ Plusieurs blocs de conditions avec des clés de contexte à valeur unique. ([Voir cet exemple](reference_policies_condition_examples-single-valued-context-keys.md#reference_policies_condition_examples-single-valued-context-keys-1).)
+ Un bloc de conditions avec plusieurs clés et valeurs de contexte à valeur unique. ([Voir cet exemple](reference_policies_condition_examples-single-valued-context-keys.md#reference_policies_condition_examples-single-valued-context-keys-2).)
## Exemples de politiques de conditions : clés de contexte à valeurs multiples.
+ Politique de refus avec opérateur d'ensemble de conditions `ForAllValues`. ([Voir cet exemple](reference_policies_condition_examples-multi-valued-context-keys.md#reference_policies_condition_examples-multi-valued-context-keys-1).)
+ Politique de refus avec opérateur d'ensemble de conditions `ForAnyValue`. ([Voir cet exemple](reference_policies_condition_examples-multi-valued-context-keys.md#reference_policies_condition_examples-multi-valued-context-keys-2).)
# Exemples de clés de contexte à valeurs multiples
L'ensemble suivant d'exemples de politiques montre comment créer des conditions de politique à l'aide de clés de contexte à valeurs multiples.
## Exemple : politique de refus avec opérateur de jeu de conditions ForAllValues
Les exemples suivants montrent comment utiliser une politique basée sur l’identité pour interdire l’utilisation d’actions de balisage IAM lorsque des préfixes de clé de balise spécifiques sont inclus dans la demande. Les valeurs pour [`aws:TagKeys`](reference_policies_condition-keys.md#condition-keys-tagkeys) incluent un caractère générique (\$1) pour la correspondance partielle des chaînes. La politique inclut l'opérateur d'ensemble `ForAllValues` avec la clé de contexte `aws:TagKeys`, car la clé de contexte de la demande peut inclure plusieurs valeurs. Afin que la clé de contexte `aws:TagKeys` corresponde, chaque valeur du contexte de la demande doit correspondre à au moins une valeur de la politique.
L’opérateur d’ensemble `ForAllValues` renvoie également vrai s’il n’y a aucune clé de contexte dans la demande.
Vous pouvez éviter que des clés de contexte manquantes ou des clés de contexte contenant des valeurs vides ne soient considérées comme vraies en incluant l’opérateur de condition `Null` dans votre politique avec une valeur `false` pour vérifier si la clé de contexte de la demande existe et si sa valeur n’est pas nulle. Pour de plus amples informations, veuillez consulter [Opérateur de condition pour vérifier l'existence de clés de condition](reference_policies_elements_condition_operators.md#Conditions_Null).
**Important**
Cette politique ne permet aucune action. Utilisez cette stratégie conjointement à d'autres stratégies qui autorisent des actions spécifiques.
**Example Refuser une seule valeur de condition de politique pour une clé de contexte à valeurs multiples**
Dans l’exemple suivant, la politique refuse les demandes dont les valeurs pour `aws:TagKeys` dans la demande n’incluent pas le préfixe **key1**. Le contexte de demande peut comporter plusieurs valeurs, mais en raison de l’opérateur d’ensemble de conditions `ForAllValues`, toutes les valeurs de clé de balise du contexte de demande doivent commencer par le préfixe **key1**.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyRestrictedTags",
"Effect": "Deny",
"Action": [
"iam:Tag*",
"iam:UnTag*"
],
"Resource": [
"*"
],
"Condition": {
"ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
}
}
}
]
}
```
Le tableau suivant montre comment cette politique est AWS évaluée en fonction des valeurs des clés de condition figurant dans votre demande. Pour une instruction Refuser, Correspondance est refusée et Aucune correspondance n’est pas refusée, elle peut donc être autorisée par une autre instruction.
| Condition de politique | Contexte de la demande | Résultat |
| --- | --- | --- |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | aws:TagKeys:
– key1:legal
| **Aucune correspondance** Peut être autorisé par une autre instruction. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | aws:TagKeys:
– key1:hr
– key1:personnel
| **Aucune correspondance** Peut être autorisé par une autre instruction. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | aws:TagKeys:
– key2:audit
| **Match** |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | Aucun `aws:TagKeys` dans le contexte de la demande. | **Match** |
**Example Refuser plusieurs valeurs de condition de politique pour une clé de contexte à valeurs multiples**
Dans l’exemple suivant, la politique refuse les demandes dont les valeurs pour `aws:TagKeys` dans la demande n’incluent pas le préfixe **key1** ou **key2**. Le contexte de demande peut comporter plusieurs valeurs, mais en raison de l’opérateur d’ensemble de conditions `ForAllValues`, toutes les valeurs de clé de balise du contexte de demande doivent commencer par le préfixe **key1** ou **key2**.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyRestrictedTags",
"Effect": "Deny",
"Action": [
"iam:Tag*",
"iam:UnTag*"
],
"Resource": [
"*"
],
"Condition": {
"ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
}
}
}
]
}
```
Le tableau suivant montre comment cette politique est AWS évaluée en fonction des valeurs des clés de condition figurant dans votre demande. Pour une instruction Refuser, Correspondance est refusée et Aucune correspondance n’est pas refusée, elle peut donc être autorisée par une autre instruction.
| Condition de politique | Contexte de la demande | Résultat |
| --- | --- | --- |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key1:legal
| **Aucune correspondance** Peut être autorisé par une autre instruction. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key1:hr
– key1:personnel
| **Aucune correspondance** Peut être autorisé par une autre instruction. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key1:hr
– key2:audit
| **Aucune correspondance** Peut être autorisé par une autre instruction. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key3:legal
| **Match** |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | Aucun `aws:TagKeys` dans le contexte de la demande. | **Match** |
## Exemple : politique de refus avec opérateur de jeu de conditions ForAnyValue
L'exemple de politique basée sur l'identité suivant interdit la création d'instantanés de volumes d'instance EC2 si des instantanés sont balisés à l'aide de l'une des clés de balise spécifiées dans la politique, `environment` ou `webserver`. La politique inclut l'opérateur d'ensemble `ForAnyValue` avec la clé de contexte `aws:TagKeys`, car la clé de contexte de la demande peut inclure plusieurs valeurs. Si votre demande de balisage inclut l'une des valeurs de clés de balise spécifiées dans la politique, la clé de contexte `aws:TagKeys` renvoie la valeur true en invoquant l'effet de la politique de refus.
**Important**
Cette politique ne permet aucune action. Utilisez cette stratégie conjointement à d'autres stratégies qui autorisent des actions spécifiques.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"ec2:CreateSnapshot",
"ec2:CreateSnapshots"
],
"Resource": "arn:aws:ec2:us-west-2::snapshot/*",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
}
}
}
]
}
```
------
Le tableau suivant montre comment cette politique est AWS évaluée en fonction des valeurs des clés de condition figurant dans votre demande. Pour une instruction Refuser, Correspondance est refusée et Aucune correspondance n’est pas refusée, elle peut donc être autorisée par une autre instruction.
| Condition de politique | Contexte de la demande | Résultat |
| --- | --- | --- |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | aws:TagKeys:
– webserver
| **Match** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | aws:TagKeys:
– environment
– webserver
– test
| **Match** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | aws:TagKeys:
– environment
– test
| **Aucune correspondance** Peut être autorisé par une autre instruction. |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | Aucun `aws:TagKeys` dans le contexte de la demande. | **Aucune correspondance** Peut être autorisé par une autre instruction. |
# Exemples de stratégies de clé de contexte à valeur unique
L'ensemble suivant d'exemples de politiques montre comment créer des conditions de politique à l'aide de clés de contexte à valeur unique.
## Exemple : plusieurs blocs de conditions avec des clés de contexte à valeur unique
Lorsqu'un bloc de conditions comporte plusieurs conditions, chacune associée à une seule clé de contexte, toutes les clés de contexte doivent aboutir à la valeur true pour que l'effet `Allow` ou `Deny` souhaité soit invoqué. Lorsque vous utilisez des opérateurs de condition de correspondance négative, la logique d'évaluation de la valeur de la condition est inversée.
L'exemple suivant permet aux utilisateurs de créer des volumes EC2 et d'appliquer des balises à des volumes pendant la création de volume. Le contexte de la demande doit inclure une valeur pour la clé de contexte `aws:RequestTag/project` et la valeur de la clé de contexte `aws:ResourceTag/environment` peut être n'importe quoi, sauf la production.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:CreateVolume",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "ec2:CreateTags",
"Resource": "arn:aws:ec2:us-east-1:123456789012:volume/*",
"Condition": {
"StringLike": {
"aws:RequestTag/project": "*"
}
}
},
{
"Effect": "Allow",
"Action": "ec2:CreateTags",
"Resource": "arn:aws:ec2:us-east-1:123456789012:*/*",
"Condition": {
"StringNotEquals": {
"aws:ResourceTag/environment": "production"
}
}
}
]
}
```
------
Le contexte de demande doit inclure une valeur de balise de projet et ne peut pas être créé pour qu'une ressource de production puisse invoquer l'effet `Allow`. Le volume EC2 suivant a été créé avec succès, car le nom du projet est `Feature3` avec une balise de ressource `QA`.
```
aws ec2 create-volume \
--availability-zone us-east-1a \
--volume-type gp2 \
--size 80 \
--tag-specifications 'ResourceType=volume,Tags=[{Key=project,Value=Feature3},{Key=environment,Value=QA}]'
```
## Exemple : un bloc de conditions avec plusieurs clés et valeurs de contexte à valeur unique
Lorsqu'un bloc de conditions contient plusieurs clés de contexte et que chaque clé de contexte possède plusieurs valeurs, chaque clé de contexte doit aboutir à true pour au moins une valeur de clé afin que l'effet `Allow` ou `Deny` souhaité soit invoqué. Lorsque vous utilisez des opérateurs de condition de correspondance négative, la logique d'évaluation de la valeur de clé de contexte est inversée.
L'exemple suivant permet aux utilisateurs de démarrer et d'exécuter des tâches sur des clusters Amazon Elastic Container Service.
+ Le contexte de la demande doit inclure `production` **OR** `prod-backup` pour la clé de contexte `aws:RequestTag/environment`**AND**.
+ La clé de contexte `ecs:cluster` garantit que les tâches sont exécutées sur les clusters ECS d'ARN `default1` **OR** `default2`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ecs:RunTask",
"ecs:StartTask"
],
"Resource": [
"*"
],
"Condition": {
"StringEquals": {
"aws:RequestTag/environment": [
"production",
"prod-backup"
]
},
"ArnEquals": {
"ecs:cluster": [
"arn:aws:ecs:us-east-1:111122223333:cluster/default1",
"arn:aws:ecs:us-east-1:111122223333:cluster/default2"
]
}
}
}
]
}
```
------
Le tableau suivant montre comment cette politique est AWS évaluée en fonction des valeurs des clés de condition figurant dans votre demande.
| Condition de politique | Contexte de la requête | Résultat |
| --- | --- | --- |
| "StringEquals": {
"aws:RequestTag/environment": [
"production",
"prod-backup"
]
},
"ArnEquals": {
"ecs:cluster": [
"arn:aws:ecs:us-east-1:111122223333:cluster/default1",
"arn:aws:ecs:us-east-1:111122223333:cluster/default2"
]
} | aws:RequestTag: environment:production
ecs:cluster:
arn:aws:ecs:us-east-1:111122223333:cluster/default1
| Correspondance |
| "StringEquals": {
"aws:RequestTag/environment": [
"production",
"prod-backup"
]
},
"ArnEquals": {
"ecs:cluster": [
"arn:aws:ecs:us-east-1:111122223333:cluster/default1",
"arn:aws:ecs:us-east-1:111122223333:cluster/default2"
]
} | aws:RequestTag: environment:prod-backup
ecs:cluster:
arn:aws:ecs:us-east-1:111122223333:cluster/default2
| Correspondance |
| "StringEquals": {
"aws:RequestTag/environment": [
"production",
"prod-backup"
]
},
"ArnEquals": {
"ecs:cluster": [
"arn:aws:ecs:us-east-1:111122223333:cluster/default1",
"arn:aws:ecs:us-east-1:111122223333:cluster/default2"
]
} | aws:RequestTag: webserver:production
ecs:cluster:
arn:aws:ecs:us-east-1:111122223333:cluster/default2
| Aucune correspondance |
| "StringEquals": {
"aws:RequestTag/environment": [
"production",
"prod-backup"
]
},
"ArnEquals": {
"ecs:cluster": [
"arn:aws:ecs:us-east-1:111122223333:cluster/default1",
"arn:aws:ecs:us-east-1:111122223333:cluster/default2"
]
} | Aucun `aws:RequestTag` dans le contexte de la demande. ecs:cluster
arn:aws:ecs:us-east-1:111122223333:cluster/default2
| Aucune correspondance |