# Elementos de política JSON do IAM: Condition
O elemento `Condition` (ou *bloco* `Condition`) permite que você especifique as condições sob as quais uma política está em vigor. O elemento `Condition` é opcional. No elemento `Condition`, crie expressões em que você usa [operadores de condição](reference_policies_elements_condition_operators.md) (equal, less than, entre outros) para fazer a correspondência de chaves e valores de contexto na política com os valores e chaves no contexto da solicitação. Para saber mais sobre o contexto da solicitação, consulte [Componentes de uma solicitação](intro-structure.md#intro-structure-request).
```
"Condition" : { "{condition-operator}" : { "{condition-key}" : "{condition-value}" }}
```
A chave de contexto especificada em uma política de condição pode ser uma [chave de contexto de condição global](reference_policies_condition-keys.md) ou uma chave de contexto específica do serviço. As chaves de contexto de condição globais têm o prefixo `aws:`. As chaves de contexto específicas de serviços têm o prefixo do serviço. Por exemplo, o Amazon EC2 permite que você escreva uma condição usando a chave de contexto `ec2:InstanceType`, que é exclusiva para esse serviço. Para visualizar as chaves de contexto do IAM específicas do serviço com o prefixo `iam:`, consulte [Chaves de contexto de condição do IAM e do AWS STS](reference_policies_iam-condition-keys.md).
Os *nomes* de chave de contexto não diferenciam maiúsculas de minúsculas. Por exemplo, incluir a chave de contexto `aws:SourceIP` é equivalente a testar o elemento `AWS:SourceIp`. A diferenciação de maiúsculas e minúsculas nos *valores* da chave de contexto depende do [operador de condição](reference_policies_elements_condition_operators.md) que você usa. Por exemplo, a condição a seguir inclui o operador `StringEquals` para garantir que apenas solicitações feitas por `john` sejam aceitas. Os usuários chamados `John` não têm permissão de acesso.
```
"Condition" : { "StringEquals" : { "aws:username" : "john" }}
```
A seguinte condição usa o operador [`StringEqualsIgnoreCase`](reference_policies_elements_condition_operators.md#Conditions_String) para corresponder usuários chamados `john` ou `John`.
```
"Condition" : { "StringEqualsIgnoreCase" : { "aws:username" : "john" }}
```
Algumas chaves de contexto são compatíveis com pares de chave-valor que permitem especificar parte do nome da chave. Os exemplos incluem a chave de contexto [`aws:RequestTag/tag-key`](reference_policies_condition-keys.md#condition-keys-requesttag), a [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) do AWS KMS e a chave de contexto [`ResourceTag/tag-key`](reference_policies_condition-keys.md#condition-keys-resourcetag) compatível com múltiplos serviços.
+ Se você usar a chave de contexto `ResourceTag/tag-key` para um serviço, como o [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policy-structure.html#amazon-ec2-keys), será necessário especificar um nome de chave para `tag-key`.
+ **Os nomes de chave não diferenciam maiúsculas de minúsculas.** Isso significa que, se você especificar `"aws:ResourceTag/TagKey1": "Value1"` no elemento de condição da política, a condição corresponderá a uma chave de tag de recurso chamada `TagKey1` ou `tagkey1`, mas não ambas.
+ Os serviços da AWS compatíveis com esses atributos podem permitir que você crie vários nomes de chave que diferem apenas por maiúsculas e minúsculas. Por exemplo, é possível etiquetar uma instância do Amazon EC2 com `ec2=test1` e `EC2=test2`. Quando você usa uma condição, como `"aws:ResourceTag/EC2": "test1"`, para permitir o acesso a esse recurso, o nome da chave corresponde a ambas as tags, mas apenas um valor é correspondente. Isso pode resultar em falhas de condição inesperadas.
**Importante**
Como prática recomendada, certifique-se de que os membros de sua conta sigam uma convenção de nomenclatura consistente ao nomear atributos de par de chave-valor. Os exemplos incluem tags ou contextos de criptografia do AWS KMS. Você pode aplicar isso usando a chave de contexto [`aws:TagKeys`](reference_policies_condition-keys.md#condition-keys-tagkeys) para a marcação, ou a [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) para o contexto de criptografia do AWS KMS.
+ Para obter uma lista de todos os operadores de condição e uma descrição de como eles funcionam, consulte [Operadores de condição](reference_policies_elements_condition_operators.md).
+ A menos que especificado de outra forma, todas as chaves de contexto podem ter múltiplos valores. Para obter uma descrição de como lidar com chaves de contexto com múltiplos valores, consulte [Operadores de conjunto para chaves de contexto de vários valores](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
+ Para obter uma lista de todas as chaves de contexto disponíveis globalmente, consulte [AWSChaves de contexto de condições globais da](reference_policies_condition-keys.md).
+ Para as chaves de contexto de condição definidas por cada serviço, consulte [Ações, recursos e chaves de condição dos serviços da AWS](reference_policies_actions-resources-contextkeys.html).
## O contexto da solicitação
Quando um [principal](https://docs.aws.amazon.com/glossary/latest/reference/glos-chap.html?icmpid=docs_homepage_addtlrcs#principal) faz uma [solicitação](intro-structure.md#intro-structure-request) à AWS, a AWS reúne as informações da solicitação em um contexto de solicitação. O contexto da solicitação inclui informações sobre a entidade principal, os recursos, as ações e outras propriedades ambientais. A avaliação da política compara as propriedades da política com as propriedades enviadas na solicitação para avaliar e autorizar ações que você pode realizar na AWS.
É possível usar o elemento `Condition` de uma política JSON para testar chaves de contexto específicas em relação ao contexto da solicitação. Por exemplo, é possível criar uma política que use a chave de contexto [aws:CurrentTime](reference_policies_condition-keys.md#condition-keys-currenttime) para [permitir que um usuário execute ações somente durante um intervalo de datas](reference_policies_examples_aws-dates.md).
O exemplo a seguir mostra uma representação do contexto da solicitação quando Martha Rivera envia uma solicitação para desativar o seu dispositivo de 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=...
```
O contexto da solicitação é comparado a uma política que permite que os usuários removam seu próprio dispositivo de autenticação multifator (MFA), mas somente se fizeram login usando MFA na última hora (3.600 segundos).
------
#### [ 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"}
}
}
}
```
------
Neste exemplo, a política corresponde ao contexto da solicitação: a ação é a mesma, o recurso corresponde ao caractere curinga “\$1” e o valor para `aws:MultiFactorAuthAge` é 2800, que é menor que 3600, portanto, a política permite essa solicitação de autorização.
A AWS avalia cada chave de contexto na política e retorna um valor *verdadeiro* ou *falso*. Uma chave de contexto que não está na solicitação é considerada uma não correspondência.
O contexto da solicitação pode retornar os seguintes valores:
+ **True** (verdadeiro): se o solicitante tiver feito login usando MFA na última hora ou menos, a condição retornará *true*.
+ **False** (falso): se o solicitante tiver feito login usando MFA há mais de uma hora, a condição retorna *false*.
+ **Not present** (não presente): se o solicitante tiver feito uma solicitação usando suas chaves de acesso do usuário do IAM na AWS CLI ou na API da AWS, a chave não estará presente. Nesse caso, a chave não estará presente e não será correspondente.
**nota**
Em alguns casos, quando o valor da chave de condição não está presente, a condição ainda pode retornar verdadeira. Por exemplo, se você adicionar o qualificador `ForAllValues`, a solicitação retornará verdadeira se a chave de contexto não estiver na solicitação. Para evitar que chaves de contexto ausentes ou chaves de contexto com valores vazios sejam avaliadas como verdadeiras, você pode incluir o [operador de condição Null](reference_policies_elements_condition_operators.md#Conditions_Null) em sua política com um valor `false` para verificar se a chave de contexto existe e se seu valor não for nulo.
## O bloco de condição
O exemplo a seguir mostra o formato básico de um elemento `Condition`:
```
"Condition": {"StringLike": {"s3:prefix": ["jane/*"]}}
```
Um valor da solicitação é representado por uma chave de contexto, neste caso, `s3:prefix`. O valor da chave de contexto é comparado a um valor especificado como um valor literal, como `jane/*`. O tipo de comparação a fazer é especificado pelo [operador de condição](reference_policies_elements_condition_operators.md) (aqui `StringLike`). Você pode criar condições que comparam strings, datas, números etc., usando comparações boolianas típicas, comoigual a, maior que e menor que. Ao usar [operadores de string](reference_policies_elements_condition_operators.md#Conditions_String) ou [operadores de ARN](reference_policies_elements_condition_operators.md#Conditions_ARN), você também pode usar uma [variável de política](reference_policies_variables.md) no valor da chave de contexto. O exemplo a seguir inclui a variável `aws:username`.
```
"Condition": {"StringLike": {"s3:prefix": ["${aws:username}/*"]}}
```
Em algumas circunstâncias, as chaves de contexto podem conter múltiplos valores. Por exemplo, uma solicitação ao Amazon DynamoDB pode solicitar o retorno ou a atualização de vários atributos de uma tabela. Uma política de acesso às tabelas do DynamoDB pode incluir a chave de contexto `dynamodb:Attributes`, que contém todos os atributos listados na solicitação. Você pode testar os múltiplos atributos na solicitação em relação a uma lista de atributos permitidos em uma política usando operadores de conjunto no elemento `Condition`. Para obter mais informações, consulte [Operadores de conjunto para chaves de contexto de vários valores](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
Quando a política é avaliada durante uma solicitação, a AWS substitui a chave pelo valor correspondente da solicitação. (Neste exemplo, a AWS usaria a data e a hora da solicitação.) A condição é avaliada para retornar verdadeiro ou falso, o que, então, é considerado ao avaliar se a política como um todo permite ou nega a solicitação.
### Vários valores em uma condição
Um elemento `Condition` pode conter múltiplos operadores de condição, e cada operador de condição pode conter múltiplos pares de chave-valor de contexto. A figura a seguir ilustra isso.
![\[Dois diagramas de blocos de operador de condição. O primeiro bloco inclui dois espaços reservados para chaves de contexto, cada um com múltiplos valores. O segundo bloco de condição inclui uma chave de contexto com múltiplos valores.\]](http://docs.aws.amazon.com/pt_br/IAM/latest/UserGuide/images/AccessPolicyLanguage_Condition_Block.diagram.png)
Para obter mais informações, consulte [Operadores de conjunto para chaves de contexto de vários valores](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
# Elementos de política JSON do IAM: operadores de condição
Use operadores de condição no elemento `Condition` para corresponder a chave de condição e o valor na política aos valores no contexto da solicitação. Para obter mais informações sobre o elemento `Condition`, consulte [Elementos de política JSON do IAM: Condition](reference_policies_elements_condition.md).
O operador de condição que você pode usar em uma política depende da chave de condição escolhida. É possível escolher uma chave de condição global ou uma chave de condição específica do serviço. Para saber qual operador de condição pode ser usado para uma chave de condição global, consulte [AWSChaves de contexto de condições globais da](reference_policies_condition-keys.md). Para saber qual operador de condição você pode usar para uma chave de condição específica de serviço, consulte [Ações, recursos e chaves de condição para produtos da AWS](reference_policies_actions-resources-contextkeys.html) e escolha o serviço que deseja visualizar.
**Importante**
Se a chave especificada em uma condição de política não estiver presente no contexto de solicitação, os valores não corresponderão e a condição será *falsa*. Se a condição da política exigir que a chave *não* seja correspondida, como `StringNotLike` ou `ArnNotLike`, e a chave certa não estiver presente, a condição será *verdadeira*. Esta lógica se aplica a todos os operadores de condição, exceto [...IfExists](#Conditions_IfExists) e [Null check](#Conditions_Null). Esses operadores testam se a chave está presente (existe) no contexto da solicitação.
Os operadores de condição podem ser agrupados nas seguintes categorias:
+ [String](#Conditions_String)
+ [Numérico](#Conditions_Numeric)
+ [Data e hora](#Conditions_Date)
+ [Booliano](#Conditions_Boolean)
+ [Binário](#Conditions_BinaryEquals)
+ [Endereço IP](#Conditions_IPAddress)
+ [Nome de recurso da Amazon (ARN)](#Conditions_ARN) (disponível apenas para alguns serviços.)
+ [... IfExists](#Conditions_IfExists) (verifica se o valor da chave existe como parte de outra verificação)
+ [Verificação de Null](#Conditions_Null) (verifica se o valor da chave existe como uma verificação independente)
## Operadores de condição de strings
Operadores de condição de string permitem que você construa elementos `Condition` que restringem o acesso com base na comparação de uma chave a um valor de string.
+ **Variáveis de política**: [compatíveis](reference_policies_variables.md)
+ **Curingas**: [compatíveis](#Conditions_String-wildcard)
****
| Operador de condição | Descrição |
| --- | --- |
| `StringEquals` | Correspondência exata, distinção entre letras maiúsculas e minúsculas |
| `StringNotEquals` | Correspondência negativa |
| `StringEqualsIgnoreCase` | Correspondência exata, sem distinção entre letras maiúsculas e minúsculas |
| `StringNotEqualsIgnoreCase` | Correspondência negativa, sem distinção entre letras maiúsculas e minúsculas |
| `StringLike` | Correspondência com distinção entre letras maiúsculas e minúsculas. Os valores podem incluir uma correspondência com vários caracteres curinga (\$1) e uma correspondência com um único caractere curinga (?) em qualquer ponto da string. Você deve especificar curingas para obter correspondências parciais de strings. Se uma chave contiver vários valores, `StringLike` poderá ser qualificado com os operadores de conjunto `ForAllValues:StringLike` e `ForAnyValue:StringLike`. Para obter mais informações, consulte [Operadores de conjunto para chaves de contexto de vários valores](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys). |
| `StringNotLike` | Correspondência negativa com distinção entre letras maiúsculas e minúsculas. Os valores podem incluir uma correspondência com vários caracteres curinga (\$1) ou uma correspondência com um único caractere curinga (?) em qualquer ponto da string. |
**Example operador de condição string**
Por exemplo, a declaração a seguir contém um elemento `Condition` que usa a chave [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) para especificar que a entidade principal que está fazendo a solicitação deve ser marcada com a categoria de trabalho `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"
}
}
}
}
```
Se a chave especificada em uma condição de política não estiver presente no contexto de solicitação, os valores não corresponderão. Nesse exemplo, a chave `aws:PrincipalTag/job-category` estará presente no contexto da solicitação se a entidade de segurança estiver usando um usuário do IAM com etiquetas anexadas. Ela também será incluída para um principal usando uma função do IAM com tags anexadas ou tags de sessão. Se um usuário sem a tag tentar visualizar ou editar uma chave de acesso, a condição retornará `false` e a solicitação será implicitamente negada por essa declaração.
A tabela a seguir mostra como a AWS avalia essa política com base nos valores de chave de condição da solicitação.
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "StringEquals": {
"aws:PrincipalTag/job-category": "iamuser-admin"
} | aws:PrincipalTag/job-category:
– iamuser-admin
| correspondência |
| "StringEquals": {
"aws:PrincipalTag/job-category": "iamuser-admin"
} | aws:PrincipalTag/job-category:
– dev-ops
| Nenhuma correspondência |
| "StringEquals": {
"aws:PrincipalTag/job-category": "iamuser-admin"
} | Nenhuma `aws:PrincipalTag/job-category` no contexto da solicitação. | Nenhuma correspondência |
**Example usar uma variável de política com um operador de condição string**
O exemplo a seguir usa o operador de condição `StringLike` para realizar correspondência de string com uma [variável de política](reference_policies_variables.md) para criar uma política que permite a um usuário do IAM usar o console do Amazon S3 para gerenciar seu próprio “diretório base” em um bucket do Amazon S3. A política permite as ações especificadas em um bucket do S3, desde que o `s3:prefix` corresponda a qualquer um dos padrões especificados.
****
```
{
"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}/*"
]
}
]
}
```
A tabela a seguir mostra como a AWS avalia essa política para diferentes usuários com base no valor [aws:username](reference_policies_condition-keys.md#condition-keys-username) no contexto da solicitação.
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "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}/"
]
} | Nenhum `aws:username` no contexto da solicitação. | Nenhuma correspondência |
Para obter um exemplo de uma política que mostra como usar o elemento `Condition` para restringir o acesso a recursos com base em um ID de aplicação e um ID de usuário para a federação de OIDC, consulte [Amazon S3: permite que usuários do Amazon Cognito acessem objetos em seus buckets](reference_policies_examples_s3_cognito-bucket.md).
### Operadores de condição string com vários valores
Se uma chave da solicitação contiver vários valores, os operadores string poderão ser qualificados com os operadores de conjunto `ForAllValues` e `ForAnyValue`. Para obter mais informações sobre a lógica de avaliação de várias chaves ou valores de contexto, consulte [Operadores de conjunto para chaves de contexto de vários valores](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
| Operador de condição | Descrição |
| --- | --- |
| `ForAllValues:StringEquals` `ForAllValues:StringEqualsIgnoreCase` | Todos os valores da chave de condição da solicitação devem corresponder a pelo menos um valor da política. |
| `ForAnyValue:StringEquals` `ForAnyValue:StringEqualsIgnoreCase` | Pelo menos um valor de chave de condição da solicitação deve corresponder a um valor da política. |
| `ForAllValues:StringNotEquals` `ForAllValues:StringNotEqualsIgnoreCase` | Correspondência negada. Nenhum valor da chave de contexto da solicitação pode corresponder a algum valor de chave de contexto da política. |
| `ForAnyValue:StringNotEquals` `ForAnyValue:StringNotEqualsIgnoreCase` | Correspondência negada. Pelo menos um valor de chave de contexto da solicitação NÃO deve corresponder a nenhum valor da chave de contexto da política. |
| `ForAllValues:StringLike` | Todos os valores da chave de condição da solicitação devem corresponder a pelo menos um valor da política. |
| `ForAnyValue:StringLike` | Pelo menos um valor de chave de condição da solicitação deve corresponder a um valor da política. |
| `ForAllValues:StringNotLike` | Correspondência negada. Nenhum valor da chave de contexto da solicitação pode corresponder a algum valor de chave de contexto da política. |
| `ForAnyValue:StringNotLike` | Correspondência negada. Pelo menos um valor de chave de contexto da solicitação NÃO deve corresponder a nenhum valor da chave de contexto da política. |
**Example usando `ForAnyValue` com um operador de condição string**
Este exemplo mostra como você pode criar uma política baseada em identidade que permita usar a ação `CreateTags` do Amazon EC2 para anexar tags a uma instância. Quando você usa `StringEqualsIgnoreCase`, somente pode anexar uma tag se ela contiver a chave `environment` com os valores `preprod` ou `storage`. Quando você acrescenta `IgnoreCase` ao operador, permite que qualquer capitalização de valor de tag existente, como `preprod`, `Preprod` e `PreProd`, seja resolvida como verdadeira.
Quando você adiciona o modificador `ForAnyValue` com a chave de condição [aws:TagKeys](reference_policies_condition-keys.md#condition-keys-tagkeys), pelo menos um valor de chave de tag da solicitação deve corresponder ao valor `environment`. A comparação `ForAnyValue` diferencia maiúsculas de minúsculas, o que impede que os usuários usem maiúsculas e minúsculas incorretamente na chave da tag, por exemplo, usar `Environment` em vez 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"
}
}
}
}
```
A tabela a seguir mostra como a AWS avalia essa política com base nos valores de chave de condição da solicitação.
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– environment
aws:RequestTag/environment:
– preprod
| correspondência |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– environment
– costcenter
aws:RequestTag/environment:
– PreProd
| correspondência |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– Environment
aws:RequestTag/Environment:
– preprod
| Nenhuma correspondência |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– costcenter
aws:RequestTag/environment:
– preprod
| Nenhuma correspondência |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | Nenhum `aws:TagKeys` no contexto da solicitação. aws:RequestTag/environment:
– storage
| Nenhuma correspondência |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | aws:TagKeys:
– environment
Nenhum `aws:RequestTag/environment` no contexto da solicitação. | Nenhuma correspondência |
| "StringEqualsIgnoreCase": {
"aws:RequestTag/environment": [
"preprod",
"storage"
]
},
"ForAnyValue:StringEquals": {
"aws:TagKeys": "environment"
} | Nenhum `aws:TagKeys` no contexto da solicitação. Nenhum `aws:RequestTag/environment` no contexto da solicitação. | Nenhuma correspondência |
### Correspondência de curinga
Os operadores de condição de string realizam uma correspondência sem padrões que não impõe um formato predefinido. Os operadores de condição ARN e Date são um subconjunto de operadores de string que impõem uma estrutura no valor da chave de condição.
Recomendamos usar operadores de condição que correspondam aos valores com os quais você está comparando as chaves. Por exemplo, você deve usar [Operadores de condição de strings](#Conditions_String) ao comparar chaves com valores de string. Da mesma forma, você deve usar [Operadores de condição de nome do recurso da Amazon (ARN)](#Conditions_ARN) ao comparar chaves com valores de ARN.
**Example**
Este exemplo mostra como é possível criar uma barreira em torno dos recursos de sua organização. A condição dessa política nega acesso às ações do Amazon S3, a menos que o recurso sendo acessado esteja em um conjunto específico de unidades organizacionais (UOs) em AWS Organizations. Um caminho do AWS Organizations é uma representação textual da estrutura da entidade da organização.
A condição exige que `aws:ResourceOrgPaths` contenha algum dos caminhos de UO listados. Como `aws:ResourceOrgPaths` é uma condição com vários valores, a política usa o operador `ForAllValues:StringNotLike` para comparar os valores de `aws:ResourceOrgPaths` com a lista de UOs da política.
****
```
{
"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/*"
]
}
}
}
]
}
```
A tabela a seguir mostra como a AWS avalia essa política com base nos valores de chave de condição da solicitação.
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "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/
| correspondência |
| "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/
| Nenhuma correspondência |
| "ForAllValues:StringNotLike": {
"aws:ResourceOrgPaths": [
"o-acorg/r-acroot/ou-acroot-mediaou/",
"o-acorg/r-acroot/ou-acroot-sportsou/*"
]
} | Nenhum `aws:ResourceOrgPaths:` na solicitação. | No match (Nenhuma correspondência) |
## Operadores de condição numéricos
Operadores de condição numéricos permitem que você construa elementos `Condition` que restringem o acesso com base na comparação de uma chave a um número inteiro ou valor decimal.
+ **Variáveis de política**: não compatíveis
+ **Curingas**: não compatíveis
****
| Operador de condição | Descrição |
| --- | --- |
| `NumericEquals` | Matching |
| `NumericNotEquals` | Correspondência negativa |
| `NumericLessThan` | Correspondência "menor que" |
| `NumericLessThanEquals` | Correspondência "menor ou igual a" |
| `NumericGreaterThan` | Correspondência "maior que" |
| `NumericGreaterThanEquals` | Correspondência "maior ou igual a" |
Por exemplo, a seguinte instrução contém um elemento `Condition` que usa o operador de condição `NumericLessThanEquals` com a chave `s3:max-keys` para especificar que o solicitante pode listar *até* 10 objetos no `amzn-s3-demo-bucket` por vez.
------
#### [ 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"}}
}
}
```
------
Se a chave especificada em uma condição de política não estiver presente no contexto de solicitação, os valores não corresponderão. Neste exemplo, a chave `s3:max-keys` está sempre presente na solicitação ao realizar a operação `ListBucket`. Se essa política permitisse todas as operações do Amazon S3, somente as operações que incluíssem a chave de contexto `max-keys` com um valor inferior ou igual a 10 seriam permitidas.
## Operadores de condição de data
Operadores de condição de data permitem que você construa elementos `Condition` que restringem o acesso com base na comparação de uma chave a um valor de data/hora. Você pode usar esses operadores de condição com a chave [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 a chave [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). Você deve especificar os valores de data e hora com uma das [implementações W3C dos formatos de hora ISO 8601](http://www.w3.org/TR/NOTE-datetime) ou em data e hora epoch (UNIX).
+ **Variáveis de política**: não compatíveis
+ **Curingas**: não compatíveis
****
| Operador de condição | Descrição |
| --- | --- |
| `DateEquals` | Correspondência de uma data específica |
| `DateNotEquals` | Correspondência negativa |
| `DateLessThan` | Correspondência antes de uma data e hora específicas |
| `DateLessThanEquals` | Correspondência antes ou em uma data e hora específicas |
| `DateGreaterThan` | Correspondência após uma data e hora específicas |
| `DateGreaterThanEquals` | Correspondência após ou em uma data e hora específicas |
Por exemplo, a instrução a seguir contém um elemento `Condition` que usa o operador de condição `DateGreaterThan` com a chave [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). Esta condição especifica que as credenciais de segurança temporárias usadas para fazer a solicitação foram emitidas em 2020. Esta política pode ser atualizada de forma programática todos os dias para garantir que os membros da conta usem credenciais novas.
------
#### [ 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"
}
}
}
}
```
------
Se a chave especificada em uma condição de política não estiver presente no contexto de solicitação, os valores não corresponderão. A chave `aws:TokenIssueTime` está presente no contexto da solicitação somente quando o principal usar as credenciais temporárias para realizar a solicitação. A chave não está presente em solicitações da AWS CLI, da API da AWS ou do AWS SDK que são feitas usando chaves de acesso. Neste exemplo, se um usuário do IAM tentar visualizar ou editar uma chave de acesso, a solicitação será negada.
## Operadores de condição booliana
Condições boolianas permitem que você crie elementos `Condition` que restrinjam o acesso com base na comparação de uma chave com `true` ou `false`.
Se uma chave contiver vários valores, os operadores boolianos podem ser qualificados com os operadores de conjunto `ForAllValues` e `ForAnyValue`. Para obter mais informações sobre a lógica de avaliação de várias chaves ou valores de contexto, consulte [Operadores de conjunto para chaves de contexto de vários valores](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
+ **Variáveis de política**: [compatíveis](reference_policies_variables.md)
+ **Curingas**: não compatíveis
****
| Operador de condição | Descrição |
| --- | --- |
| `Bool` | Correspondência booliana |
| `ForAllValues:Bool` | Use com o tipo de dados de matriz booliana. Todos os valores boolianos nos valores de chave de contexto devem corresponder aos valores boolianos da política. Para evitar que operadores `ForAllValues` avaliem chaves de contexto ausentes ou com valores vazios como Permitidas, você pode incluir o [operador de condição Null](#Conditions_Null). |
| `ForAnyValue:Bool` | Use com o tipo de dados de matriz booliana. Pelo menos um valor booliano nos valores de chave de contexto deve corresponder aos valores booleanos da política. |
**Example operador de condição booliano**
A política baseada em identidades a seguir usará o operador de condição `Bool` com a chave [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) para negar a replicação de objetos e tags de objetos no bucket de destino e seu conteúdo se a solicitação não for por SSL.
Esta política não permite qualquer ação. Use essa política em combinação com outras políticas que permitam ações específicas.
****
```
{
"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"
}
}
}
]
}
```
A tabela a seguir mostra como a AWS avalia essa política com base nos valores de chave de condição da solicitação.
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "Bool": {
"aws:SecureTransport": "false"
} | aws:SecureTransport:
– false
| correspondência |
| "Bool": {
"aws:SecureTransport": "false"
} | aws:SecureTransport:
– true
| Nenhuma correspondência |
| "Bool": {
"aws:SecureTransport": "false"
} | Nenhum `aws:SecureTransport` no contexto da solicitação. | Nenhuma correspondência |
## Operadores de condição binários
O operador de condição `BinaryEquals` permite que você crie elementos `Condition` que testam valores de chave no formato binário. Ele compara o valor da chave especificada byte por byte à uma representação [base-64](https://en.wikipedia.org/wiki/Base64) codificada do valor binário na política. Se a chave especificada em uma condição de política não estiver presente no contexto de solicitação, os valores não corresponderão.
+ **Variáveis de política**: não compatíveis
+ **Curingas**: não compatíveis
```
"Condition" : {
"BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
}
}
```
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
} | key:
– QmluYXJ5VmFsdWVJbkJhc2U2NA==
| correspondência |
| "BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
} | key:
– ASIAIOSFODNN7EXAMPLE
| Nenhuma correspondência |
| "BinaryEquals": {
"key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
} | Nenhum `key` no contexto da solicitação. | Nenhuma correspondência |
## Operadores de condição de endereço IP
Operadores de condição de endereço IP permitem que você construa elementos `Condition` que restringem o acesso com base na comparação de uma chave a um endereço IPv4 ou IPv6 ou a intervalo de endereços IP. Você pode usá-los com a chave [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). O valor deve ser no formato CIDR padrão (por exemplo, 203.0.113.0/24 ou 2001: DB8:1234:5678::/64). Se você especificar um endereço IP, sem o prefixo de roteamento associado, o IAM usará o valor do prefixo padrão `/32`.
Alguns serviços da AWS oferecem suporte a IPv6, usando :: para representar um intervalo de 0s. Para saber se um serviço oferece suporte a IPv6, consulte a documentação do serviço.
+ **Variáveis de política**: não compatíveis
+ **Curingas**: não compatíveis
****
| Operador de condição | Descrição |
| --- | --- |
| `IpAddress` | O endereço IP ou intervalo especificado |
| `NotIpAddress` | Todos os endereços IP, exceto o endereço IP ou intervalo especificado |
**Example Operador de condição endereço IP**
A instrução a seguir usa o operador de condição `IpAddress` com a chave `aws:SourceIp` para especificar que a solicitação deve ser originada no intervalo de IP 203.0.113.0 a 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"
}
}
}
}
```
A chave de condição `aws:SourceIp` resulta no endereço IP onde a solicitação foi gerada. Se as solicitações for proveniente de uma instância do Amazon EC2, o `aws:SourceIp` será avaliado para o endereço IP público da instância.
Se a chave especificada em uma condição de política não estiver presente no contexto de solicitação, os valores não corresponderão. A chave `aws:SourceIp` está sempre presente no contexto da solicitação, exceto quando o solicitante usar um VPC endpoint para fazer a solicitação. Nesse caso, a condição retornará `false` e a solicitação será negada implicitamente por essa declaração.
A tabela a seguir mostra como a AWS avalia essa política com base nos valores de chave de condição da solicitação.
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
} | aws:SourceIp:
– 203.0.113.1
| correspondência |
| "IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
} | aws:SourceIp:
– 198.51.100.1
| Nenhuma correspondência |
O exemplo a seguir mostra como combinar endereços IPv4 e IPv6 para cobrir todos os endereços IP válidos da sua organização. Recomendamos atualizar seus intervalos de endereço IPv6, além dos intervalos IPv4 que você já possui, nas políticas de sua organização para garantir que as políticas continuarão a funcionar à medida que você fizer a transição para o 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"
]
}
}
}
}
```
A chave de condição `aws:SourceIp` só funcionará em uma política JSON se você estiver chamando a API testada diretamente como um usuário. Se você usar um serviço para chamar o serviço de destino em seu nome, o serviço de destino vê o endereço IP do serviço de chamada, em vez do endereço IP do usuário-fonte. Isso pode acontecer, por exemplo, se você usar o AWS CloudFormation para chamar o Amazon EC2 para criar instâncias para você. Atualmente, não há como passar o endereço IP de origem através de um serviço de chamada ao serviço de destino para avaliação em uma política JSON. Para esses tipos de chamadas de serviço de API, não use a chave de condição `aws:SourceIp`.
## Operadores de condição de nome do recurso da Amazon (ARN)
Operadores de condição do nome de recurso da Amazon (ARN) permitem que você construa elementos `Condition` que restringem o acesso com base na comparação de uma chave a um ARN. O ARN é considerado uma string.
+ **Variáveis de política**: [compatíveis](reference_policies_variables.md)
+ **Curingas**: [compatíveis](reference_policies_elements_resource.md#reference_policies_elements_resource_wildcards)
****
| Operador de condição | Descrição |
| --- | --- |
| `ArnEquals`, `ArnLike` | Correspondência do ARN com distinção entre letras maiúsculas e minúsculas. Cada um dos seis componentes do ARN delimitados por dois pontos é verificado separadamente e cada um pode incluir de múltiplos caracteres curingas (\$1) ou um único caractere curinga (?). Os operadores de condição `ArnEquals` e `ArnLike` têm comportamento semelhante. |
| `ArnNotEquals`, `ArnNotLike` | Correspondência negativa para ARN. Os operadores de condição `ArnNotEquals` e `ArnNotLike` têm comportamento semelhante. |
**Example Operador de condição ARN**
O exemplo de política baseada em recurso a seguir mostra uma política anexada a uma fila do Amazon SQS para a qual você deseja enviar mensagens do SNS. Ela fornece ao Amazon SNS permissão para enviar mensagens para a fila (ou as filas) de sua escolha, mas apenas se o serviço estiver enviando as mensagens em nome de um determinado tópico (ou tópicos) do Amazon SNS. Você especifica a fila no campo `Resource` e o tópico do Amazon SNS como o valor para a chave `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"
}
}
}
}
```
A chave [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) estará presente no contexto da solicitação somente se um recurso acionar um serviço para chamar outro serviço em nome do proprietário do recurso. Se um usuário do IAM tentar realizar essa operação diretamente, a condição retornará `false` e a solicitação será negada implicitamente por esta instrução.
A tabela a seguir mostra como a AWS avalia essa política com base nos valores de chave de condição da solicitação.
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"
} | aws:SourceArn:
– arn:aws:sns:us-west-2:123456789012:TOPIC-ID
| correspondência |
| "ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"
} | aws:SourceArn:
– arn:aws:sns:us-west-2:777788889999:TOPIC-ID
| Nenhuma correspondência |
| "ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"
} | Nenhum `aws:SourceArn` no contexto da solicitação. | Nenhuma correspondência |
### Operadores de condição ARN com vários valores
Se uma chave da solicitação contiver vários valores, os operadores ARN podem ser qualificados com os operadores de conjunto `ForAllValues` e `ForAnyValue`. Para obter mais informações sobre a lógica de avaliação de várias chaves ou valores de contexto, consulte [Operadores de conjunto para chaves de contexto de vários valores](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
| Operador de condição | Descrição |
| --- | --- |
| `ForAllValues:ArnEquals` `ForAllValues:ArnLike` | Todos os ARNs no contexto da solicitação devem corresponder a pelo menos um padrão de ARN da política. |
| `ForAnyValue:ArnEquals` `ForAnyValue:ArnLike` | Pelo menos um ARN no contexto da solicitação deve corresponder a um padrão de ARN da política. |
| `ForAllValues:ArnNotEquals` `ForAllValues:ArnNotLike` | Correspondência negada. Nenhum ARN no contexto da solicitação pode corresponder a algum padrão de ARN de string da política. |
| `ForAnyValue:ArnNotEquals` `ForAnyValue:ArnNotLike` | Correspondência negada. Pelo menos um ARN no contexto da solicitação NÃO deve corresponder a nenhum padrão de ARN da política. |
**Example usando `ForAllValues` com um operador de condição ARN**
O exemplo a seguir usa `ForAllValues:ArnLike` para criar ou atualizar uma origem de entrega lógica para os logs do Amazon CloudWatch Logs. O bloco de condição inclui a chave de condição [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) para filtrar o log que gera os ARNs passados na solicitação. Usando esse operador de condição, todos os ARNs da solicitação devem corresponder a pelo menos um ARN da política.
****
```
{
"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*"
]
}
}
}
]
}
```
A tabela a seguir mostra como a AWS avalia essa política com base nos valores de chave de condição da solicitação.
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | logs:LogGeneratingResourceArns:
– arn:aws::cloudfront:123456789012:distribution/costcenter
| correspondência |
| "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
| correspondência |
| "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
| Nenhuma correspondência |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | logs:LogGeneratingResourceArns:
– arn:aws::cloudfront:777788889999:distribution/costcenter
| Nenhuma correspondência |
| "ForAllValues:ArnLike": {
"logs:LogGeneratingResourceArns": [
"arn:aws::cloudfront:123456789012:distribution/*",
"arn:aws::cloudfront:123456789012:distribution/support*"
]
} | Nenhum `logs:LogGeneratingResourceArns` no contexto da solicitação. | correspondência |
O qualificador `ForAllValues` retornará true se não houver chaves de contexto da solicitação ou se o valor da chave de contexto for resolvido para um conjunto de dados nulo, como uma string vazia. Para evitar que chaves de contexto ausentes ou chaves de contexto com valores vazios sejam avaliadas como verdadeiras, você pode incluir o [operador de condição Null](#Conditions_Null) em sua política com um valor `false` para verificar se a chave de contexto existe e se seu valor não for nulo.
## Operadores de condição ...IfExists
Você pode adicionar `IfExists` ao final de qualquer nome de operador de condição, exceto a condição `Null`, por exemplo, `StringLikeIfExists`. Isso é feito para dizer "Se a chave de condição estiver presente no contexto da solicitação, processar a chave conforme especificado na política. Se a chave não estiver presente, avalie o elemento da condição como verdadeiro." Outros elementos de condição na instrução ainda podem resultar em um nonmatch, mas não em uma chave ausente quando marcada com `...IfExists`. Se você estiver usando um elemento `"Effect": "Deny"` com um operador de condição negada como `StringNotEqualsIfExists`, a solicitação ainda será negada mesmo se a chave de condição estiver ausente.
**Exemplo usando `IfExists`**
Muitas chaves de condição descrevem informações sobre determinado tipo de recurso e existem apenas ao acessar aquele tipo de recurso. Essas chaves de condição não estão presentes em outros tipos de recursos. Isso não causa problemas quando a declaração de política se aplica a apenas um tipo de recurso. No entanto, há casos em que uma única instrução pode se aplicar a vários tipos de recursos, tal como quando a declaração de política se refere a ações de múltiplos serviços ou quando dada ação de um serviço acessa diversos tipos de recursos dentro do mesmo serviço. Em tais casos, a inclusão de uma chave de condição que se aplica a apenas um dos recursos na declaração de política pode fazer com que o elemento `Condition` na declaração de política falhe de forma que o `"Effect"` da instrução não se aplica.
Por exemplo, considere o exemplo de política:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "THISPOLICYDOESNOTWORK",
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": "*",
"Condition": {"StringLike": {"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]}}
}
}
```
------
O *objetivo* da política anterior é permitir que o usuário execute qualquer instância do tipo `t1`, `t2` ou `m3`. No entanto, iniciar uma instância na prática requer acesso a muitos recursos, além da própria instância; por exemplo, imagens, pares de chaves, grupos de segurança, entre outros. A instrução completa é avaliada em relação a cada recurso necessário para executar a instância. Esses recursos adicionais não têm a `ec2:InstanceType` chave de condição, de modo que a verificação `StringLike` falha e o usuário não é concedido a capacidade de executar *qualquer* tipo de instância.
Para resolver isso, use o operador de condição `StringLikeIfExists`. Dessa forma, o teste só acontece se a chave de condição existir. Você pode ler a política a seguir como: “Se o recurso que está sendo verificado tiver uma chave de condição ‘`ec2:InstanceType`‘, permita a ação apenas se o valor de chave começar com `t1.`, `t2.` ou `m3.`. Se o recurso que está sendo verificado não tiver essa chave de condição, não se preocupe com isso." O asterisco (\$1) nos valores da chave de condição, quando usado com o operador de condição `StringLikeIfExists`, é interpretado como um curinga para obter correspondências parciais de strings. A instrução `DescribeActions` inclui as ações necessárias para visualizar a instância no 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": "*"
}
]
}
```
------
A tabela a seguir mostra como a AWS avalia essa política com base nos valores de chave de condição da solicitação.
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "StringLikeIfExists": {
"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]
} | ec2:InstanceType:
– t1.micro
| correspondência |
| "StringLikeIfExists": {
"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]
} | ec2:InstanceType:
– m2.micro
| Nenhuma correspondência |
| "StringLikeIfExists": {
"ec2:InstanceType": [
"t1.*",
"t2.*",
"m3.*"
]
} | Nenhum `ec2:InstanceType` no contexto da solicitação. | correspondência |
## Operador de condição para verificar a existência de chaves de condição
Use um operador de condição `Null` para verificar se uma chave de condição não está presente no momento da autorização. Na instrução de política, use `true` (a chave não existe, é nulo) ou `false` (a chave existe e seu valor não é nulo).
Você não pode usar uma [variável de política](reference_policies_variables.md) com o operador de condição `Null`.
Por exemplo, é possível usar esse operador de condição para determinar se um usuário está usando credenciais temporárias ou suas próprias credenciais para fazer uma solicitação. Se o usuário estiver usando credenciais temporárias, a chave `aws:TokenIssueTime` existe e tem um valor. O exemplo a seguir mostra uma condição que afirma que o usuário deve usar credenciais temporárias (a chave não pode estar ausente) para que o usuário use a API do Amazon EC2.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":{
"Action":"ec2:*",
"Effect":"Allow",
"Resource":"*",
"Condition":{"Null":{"aws:TokenIssueTime":"false"}}
}
}
```
------
# Condições com múltiplas chaves ou valores de contexto
Você pode usar o elemento `Condition` de uma política para testar múltiplas chaves de contexto ou múltiplos valores para uma única chave de contexto em uma solicitação. Quando você faz uma solicitação para a AWS, de forma programada ou pelo Console de gerenciamento da AWS, ela inclui informações sobre o seu principal, operação, tags e muito mais. Use chaves de contexto para testar os valores das correspondentes na solicitação, com as chaves de contexto especificadas na condição da política. Para obter mais sobre informações e saber mais sobre os dados incluídos em uma solicitação, consulte [O contexto da solicitação](reference_policies_elements_condition.md#AccessPolicyLanguage_RequestContext).
**Topics**
+ [Lógica de avaliação para múltiplas chaves de contexto ou valores](#reference_policies_multiple-conditions-eval)
+ [Lógica de avaliação para os operadores de conjuntos de condições com correspondência negada](#reference_policies_multiple-conditions-negated-matching-eval)
## Lógica de avaliação para múltiplas chaves de contexto ou valores
Um elemento `Condition` pode conter múltiplos operadores de condição, e cada operador de condição pode conter múltiplos pares de chave-valor de contexto. A maioria das chaves de contexto oferece suporte ao uso de múltiplos valores, a menos que especificado de outra forma.
+ Se a instrução de política tiver múltiplos [operadores de condição](reference_policies_elements_condition_operators.md), os operadores de condição serão avaliados usando uma lógica `AND`.
+ Se sua instrução de política tiver múltiplas chaves de contexto anexadas a um único operador de condição, as chaves de contexto serão avaliadas usando um `AND` lógico.
+ Se um único operador de condição incluir múltiplos valores para uma chave de contexto, esses valores serão avaliados usando um `OR` lógico.
+ Se um único operador de condição com correspondência negada incluir múltiplos valores para uma chave de contexto, esses valores serão avaliados usando um `NOR` lógico.
Todas as chaves de contexto de um bloco de elementos de condição devem ser resolvidas como verdadeiro para invocar o efeito `Allow` ou `Deny` desejado. A figura a seguir ilustra a lógica de avaliação de uma condição com múltiplos operadores de condição e pares de chave-valor de contexto.
![\[Bloco condicional demonstrando como AND e OR são aplicados a múltiplos valores e chaves de contexto\]](http://docs.aws.amazon.com/pt_br/IAM/latest/UserGuide/images/AccessPolicyLanguage_Condition_Block_AND_2.diagram.png)
Por exemplo, a política de bucket do S3 a seguir ilustra como a figura anterior é representada em uma política. O bloco de condições inclui os operadores condicionais `StringEquals` e `ArnLike` e as chaves de contexto `aws:PrincipalTag` e `aws:PrincipalArn`. Para invocar o efeito `Allow` ou `Deny` desejado, todas as chaves de contexto de um bloco de condições devem ser resolvidas como verdadeiro. O usuário que faz a solicitação deve ter ambas as chaves de tag da entidade principal, *departamento* e *função*, que incluem um dos valores de chave de tag especificados na política. Além disso, o ARN da entidade principal do usuário que faz a solicitação deve corresponder a um dos valores `aws:PrincipalArn` especificados na política a serem avaliados como verdadeiro.
------
#### [ 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"
]
}
}
}
]
}
```
------
A tabela a seguir mostra como a AWS avalia essa política com base nos valores de chave de condição da solicitação.
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "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
| **correspondência** |
| "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
| **Nenhuma correspondência** |
| "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
| **Nenhuma correspondência** |
| "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"
]
} | Nenhum `aws:PrincipalTag/role` no contexto da solicitação. aws:PrincipalTag/department: hr
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Mary
| **Nenhuma correspondência** |
| "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"
]
} | Nenhum `aws:PrincipalTag` no contexto da solicitação. aws:PrincipalArn:
arn:aws:iam::222222222222:user/Mary
| **Nenhuma correspondência** |
## Lógica de avaliação para os operadores de conjuntos de condições com correspondência negada
Alguns [operadores de condição,](reference_policies_elements_condition_operators.md) como `StringNotEquals` ou `ArnNotLike`, usam a correspondência negada para comparar os pares de chave-valor de contexto em sua política com os pares de chave-valor de contexto em uma solicitação. Quando múltiplos valores são especificados para uma chave de contexto única em uma política com operadores de condição de correspondência negados, as permissões efetivas funcionam como um `NOR` lógico. Na correspondência negada, um `NOR` ou `NOT OR` lógico retornará verdadeiro somente se todos os valores forem avaliados como falsos.
A figura a seguir ilustra a lógica de avaliação de uma condição com múltiplos operadores de condição e pares de chave-valor de contexto. A figura contém um operador de condição de correspondência negado para a chave de contexto 3.
![\[Bloco de condição mostrando como AND e OR são aplicados a múltiplas chaves e valores de contexto quando se utiliza um operador de condição de correspondência negado\]](http://docs.aws.amazon.com/pt_br/IAM/latest/UserGuide/images/AccessPolicyLanguage_Condition_Block_AND_Negated_NOR_2.diagram.png)
Por exemplo, a política de bucket do S3 a seguir ilustra como a figura anterior é representada em uma política. O bloco de condições inclui os operadores condicionais `StringEquals` e `ArnNotLike` e as chaves de contexto `aws:PrincipalTag` e `aws:PrincipalArn`. Para invocar o efeito `Allow` ou `Deny` desejado, todas as chaves de contexto de um bloco de condições devem ser resolvidas como verdadeiro. O usuário que faz a solicitação deve ter ambas as chaves de tag da entidade principal, *departamento* e *função*, que incluem um dos valores de chave de tag especificados na política. Como o operador de condição `ArnNotLike` usa correspondência negada, o ARN da entidade principal do usuário que faz a solicitação não deve corresponder a nenhum dos valores `aws:PrincipalArn` especificados na política a serem avaliados como verdadeiros.
------
#### [ 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"
]
}
}
}
]
}
```
------
A tabela a seguir mostra como a AWS avalia essa política com base nos valores de chave de condição da solicitação.
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "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
| **correspondência** |
| "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
| **Nenhuma correspondência** |
| "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
| **Nenhuma correspondência** |
| "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"
]
} | >Nenhum `aws:PrincipalTag/role` no contexto da solicitação. aws:PrincipalTag/department: hr
aws:PrincipalArn:
arn:aws:iam::222222222222:user/Nikki
| **Nenhuma correspondência** |
| "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"
]
} | Nenhum `aws:PrincipalTag` no contexto da solicitação. aws:PrincipalArn:
arn:aws:iam::222222222222:user/Nikki
| **Nenhuma correspondência** |
# Chaves de contexto de valor único vs. de múltiplos valores
A diferença entre as chaves de contexto de valor único e as de múltiplos valores depende do número de valores do [contexto da solicitação](intro-structure.md#intro-structure-request), e não do número de valores na condição da política.
+ Chaves de contexto de condição de *valor único* têm no máximo um valor no contexto de autorização. Por exemplo, quando você marca recursos na AWS, cada tag de recurso é armazenada como um par de chave-valor. Como uma chave de tag de recurso só pode ter um único valor de tag, [aws:ResourceTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-resourcetag) é uma chave de contexto de valor único. Não use um operador de conjunto de condição com uma chave de condição de valor único.
+ As chaves de contexto de condição de *múltiplos valores * podem ter múltiplos valores no contexto da solicitação. Por exemplo, ao marcar recursos na AWS, você pode incluir vários pares de chave-valor de tag em uma única solicitação. Portanto, [aws:TagKeys](reference_policies_condition-keys.md#condition-keys-tagkeys) é uma chave de contexto de valores múltiplos. As chaves de contexto de múltiplos valores exigem um operador de conjunto de condições.
Por exemplo, uma solicitação pode ser originada em até um endpoint da VPC. Logo, [aws:SourceVpce](reference_policies_condition-keys.md#condition-keys-sourcevpce) é uma chave de contexto de valor único. Como um serviço pode ter mais de um nome de entidade principal de serviço pertencente ao serviço, [aws:PrincipalServiceNamesList](reference_policies_condition-keys.md#condition-keys-principalservicenameslist) é uma chave de contexto de múltiplos valores.
**Importante**
A diferença entre as chaves de contexto de valor único e as de múltiplos valores depende do número de valores do contexto da solicitação, não do número de valores na condição da política.
## Principais pontos
+ As classificações *Valor único* e *Valores múltiplos* constam na descrição de cada chave de contexto de condição como *Tipo de valor* no tópico [AWSChaves de contexto de condições globais da](reference_policies_condition-keys.md).
+ As chaves de contexto de vários valores presentes na [referência de autorização de serviço](https://docs.aws.amazon.com/service-authorization/latest/reference/reference_policies_actions-resources-contextkeys.html) são representadas por um prefixo `ArrayOf` seguido pelo tipo da categoria do operador de condição, como `ArrayOfString` ou `ArrayOfARN`, o que indica que a solicitação pode conter vários valores para uma chave de contexto de condição.
+ É possível usar qualquer chave de contexto de valor único disponível como variável de política, mas não é possível fazer isso com uma chave de contexto de múltiplos valores. Para obter mais informações sobre variáveis de política, consulte [Elementos de política do IAM: variáveis e etiquetas](reference_policies_variables.md).
+ Ao usar chaves de contexto que incluem pares de chave-valor, é importante observar que, embora possa haver vários valores de tag-chave, cada `tag-key` pode ter apenas um valor.
+ As chaves de contexto [aws:PrincipalTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-principaltag), [aws:RequestTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-requesttag) e [aws:ResourceTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-resourcetag) são classificadas como de valor único.
+ A chave [aws:TagKeys](reference_policies_condition-keys.md#condition-keys-tagkeys) define quais chaves de etiquetas são permitidas em uma solicitação, mas não inclui os valores dessas chaves de etiquetas. Como é possível incluir vários pares de chave-valor de etiquetas em uma solicitação, `aws:TagKeys` é uma chave de contexto de vários valores.
+ As chaves de contexto de múltiplos valores exigem um operador de conjunto de condições. Não use operadores de conjuntos de condição `ForAllValues` ou `ForAnyValue` com chaves de condição de valor único. O uso de operadores de conjunto de condições com chaves de contexto de valor único pode levar a políticas excessivamente permissivas.
## Operadores de conjunto para chaves de contexto de vários valores
Para comparar sua chave de contexto de condição com uma chave de [contexto de solicitação](intro-structure.md#intro-structure-request) com múltiplos valores de chave, você deve usar os operadores de conjunto `ForAllValues` ou `ForAnyValue`. Esses operadores de conjuntos são usados para comparar dois conjuntos de valores, como o conjunto de etiquetas em uma solicitação e o conjunto de etiquetas em uma condição de política.
Os qualificadores `ForAllValues` e `ForAnyValue` adicionam a funcionalidade de operação de conjunto ao operador da condição, permitindo que você teste chaves de contexto da solicitação em relação a múltiplos valores de chave de contexto em uma condição de política. Além disso, se você incluir uma chave de contexto de string de múltiplos valores na política com um curinga ou uma variável, também deverá usar o [operador de condição](reference_policies_elements_condition_operators.md#Conditions_String) `StringLike`. Os diferentes valores de chaves de condição devem ser colocados entre colchetes, como em uma [matriz](reference_policies_grammar.md#policies-grammar-json), por exemplo `"Key2":["Value2A", "Value2B"]`.
### ForAllValues
O qualificador `ForAllValues` realiza testes para verificar se o valor de cada elemento no contexto da solicitação corresponde ao operador de condição que o segue. A condição retornará `true` se todos os valores das chaves de contexto presentes na solicitação corresponderem aos valores para as chaves de contexto definidos na política. Além disso, a condição retornará `true` se não houver chaves de contexto presentes na solicitação.
**Importante**
Tenha cuidado ao usar `ForAllValues` em políticas com efeito `Allow`, pois isso pode resultar em permissões excessivas se a ausência de chaves de contexto no contexto da solicitação não for prevista. Sempre inclua o operador de condição [`Null`](reference_policies_elements_condition_operators.md#Conditions_Null) com um valor `false` em sua política para verificar se a chave de contexto existe e se seu valor não é nulo. Para ver um exemplo, consulte [Controlar o acesso com base em chaves de tag](access_tags.md#access_tags_control-tag-keys).
#### Exemplo do operador de conjunto ForAllValues
No exemplo apresentado a seguir, o operador ForAllValues é usado com aws:TagKeys para permitir que os usuários excluam etiquetas específicas atribuídas a uma instância do EC2. Esta política permite a exclusão apenas das etiquetas `environment` e `cost-center` por parte dos usuários. Essas etiquetas podem ser excluídas separada ou simultaneamente. As chaves de etiquetas presentes na solicitação devem corresponder exatamente às chaves especificadas na política.
------
#### [ 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"
}
}
}
]
}
```
------
A tabela a seguir mostra como a AWS avalia essa política com base nos valores de chave de condição da solicitação.
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– environment
| **correspondência** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– cost-center
| **correspondência** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– environment
– cost-center
| **correspondência** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | aws:TagKeys:
– environment
– dept
| **Nenhuma correspondência** |
| "ForAllValues:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
},
"Null": {
"aws:TagKeys": "false"
} | Nenhum `aws:TagKeys` no contexto da solicitação. | **Nenhuma correspondência** |
Vale destacar que, no exemplo anterior, o resultado é “Nenhuma correspondência” devido à verificação da condição “Null”, que bloqueia a correspondência quando a chave de contexto não está presente. Essa é uma prática recomendada para evitar políticas excessivamente permissivas.
### ForAnyValue
O qualificador `ForAnyValue` realiza testes para verificar se ao menos um dos valores presentes no conjunto de chaves de contexto da solicitação corresponde a algum dos valores de chaves de contexto definidos na condição da política. A condição retornará `true` se algum valor de chave de contexto presente na solicitação corresponder a um valor para as chaves de contexto definido na política. Se não houver correspondência entre as chaves de contexto ou se a chave não existir, a condição retornará `false`.
**Importante**
Ao usar `ForAnyValue` com o efeito `Deny`, se a chave de contexto não estiver presente na solicitação, a política será avaliada como **Nenhuma correspondência**. Para garantir um comportamento consistente, adicione uma verificação explícita da condição [`Null`](reference_policies_elements_condition_operators.md#Conditions_Null) em sua política para confirmar se a chave de contexto existe. Para obter detalhes, consulte [Operador de condição para verificar a existência de chaves de condição](reference_policies_elements_condition_operators.md#Conditions_Null).
#### Exemplo do operador de conjunto ForAnyValue
No exemplo apresentado a seguir, o operador ForAnyValue é usado com aws:TagKeys para permitir que os usuários excluam etiquetas específicas atribuídas a uma instância do EC2. Esta política permite a exclusão de etiquetas, por parte dos usuários, se as chaves de etiquetas especificadas na solicitação incluírem `environment` ou `cost-center`. A solicitação pode conter chaves de etiquetas adicionais, mas deve incluir, no mínimo, uma das chaves especificadas para que a condição seja satisfeita.
------
#### [ 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"
]
}
}
}
]
}
```
------
A tabela a seguir mostra como a AWS avalia essa política com base nos valores de chave de condição da solicitação.
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– environment
| **correspondência** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– cost-center
| **correspondência** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– environment
– cost-center
| **correspondência** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– environment
– dept
| **correspondência** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | aws:TagKeys:
– dept
| **Nenhuma correspondência** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": [
"environment",
"cost-center"
]
} | Nenhum `aws:TagKeys` no contexto da solicitação. | **Nenhuma correspondência** |
# Exemplos de políticas de condições
Nas políticas do IAM, é possível especificar múltiplos valores para chaves de contexto de valor único e de múltiplos valores para comparação com o contexto da solicitação. O conjunto de exemplos de políticas a seguir demonstra condições de política com múltiplos valores e chaves de contexto.
**nota**
Se você quiser enviar uma política para ser incluída neste guia de referência, use o botão **Feedback** na parte inferior desta página. Para obter exemplos de políticas baseadas em identidade do IAM, consulte [Exemplos de políticas baseadas em identidade do IAM](access_policies_examples.md).
## Exemplos de políticas de condição: chaves de contexto de valor único
+ Vários blocos de condição com chaves de contexto de valor único. ([Visualizar este exemplo](reference_policies_condition_examples-single-valued-context-keys.md#reference_policies_condition_examples-single-valued-context-keys-1).)
+ Um bloco de condição com múltiplos valores e chaves de contexto de valor único. ([Visualizar este exemplo](reference_policies_condition_examples-single-valued-context-keys.md#reference_policies_condition_examples-single-valued-context-keys-2).)
## Exemplos de políticas de condição: chaves de contexto de múltiplos valores
+ Política de negação com operador de conjunto de condições `ForAllValues`. ([Visualizar este exemplo](reference_policies_condition_examples-multi-valued-context-keys.md#reference_policies_condition_examples-multi-valued-context-keys-1).)
+ Política de negação com operador de conjunto de condições `ForAnyValue`. ([Visualizar este exemplo](reference_policies_condition_examples-multi-valued-context-keys.md#reference_policies_condition_examples-multi-valued-context-keys-2).)
# Exemplos de chave de contexto de múltiplos valores
O conjunto de exemplos de políticas a seguir demonstra como criar condições de política com chaves de contexto de múltiplos valores.
## Exemplo: política de negação com operador de conjunto de condições ForAllValues
Os exemplos a seguir mostram como usar uma política baseada em identidade para negar o uso de ações de marcação do IAM quando prefixos de chave de marcação específicos são incluídos na solicitação. Os valores para [`aws:TagKeys`](reference_policies_condition-keys.md#condition-keys-tagkeys) inclua um curinga (\$1) para correspondência parcial de string. A política inclui o operador de conjunto `ForAllValues` com chave de contexto `aws:TagKeys` porque a chave de contexto da solicitação pode conter múltiplos valores. Para a chave de contexto `aws:TagKeys` ser correspondente, cada valor na solicitação de contexto deve corresponder a pelo menos um valor na política.
O operador de conjunto `ForAllValues` também retornará verdadeiro se não houver chaves de contexto na solicitação.
Você pode evitar que chaves de contexto ausentes ou chaves de contexto com valores vazios sejam avaliadas como verdadeiro, ao incluir o operador de condição `Null` em sua política com um valor `false` para verificar se a chave de contexto da solicitação existe e se seu valor não é nulo. Para obter mais informações, consulte [Operador de condição para verificar a existência de chaves de condição](reference_policies_elements_condition_operators.md#Conditions_Null).
**Importante**
Esta política não permite qualquer ação. Use essa política em combinação com outras políticas que permitam ações específicas.
**Example Negar um único valor de condição de política para uma chave de contexto de vários valores**
No exemplo a seguir, a política nega solicitações onde os valores para `aws:TagKeys` na solicitação não incluam o prefixo **key1**. O contexto da solicitação pode ter vários valores, mas devido ao operador do conjunto de condição `ForAllValues`, todos os valores da chave de tag no contexto da solicitação devem começar com o prefixo **key1**.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyRestrictedTags",
"Effect": "Deny",
"Action": [
"iam:Tag*",
"iam:UnTag*"
],
"Resource": [
"*"
],
"Condition": {
"ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
}
}
}
]
}
```
A tabela a seguir mostra como a AWS avalia essa política com base nos valores de chave de condição da solicitação. Para uma Declaração de negação, a Correspondência é Negada e Nenhuma correspondência é Não negada, portanto, isso pode ser permitido por outra declaração.
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | aws:TagKeys:
– key1:legal
| **Nenhuma correspondência** Pode ser permitido por outra declaração. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | aws:TagKeys:
– key1:hr
– key1:personnel
| **Nenhuma correspondência** Pode ser permitido por outra declaração. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | aws:TagKeys:
– key2:audit
| **correspondência** |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": "key1*"
} | Nenhum `aws:TagKeys` no contexto da solicitação. | **correspondência** |
**Example Negar vários valores de condição de política para uma chave de contexto de vários valores**
No exemplo a seguir, a política nega solicitações onde os valores para `aws:TagKeys` na solicitação não incluam o prefixo **key1** ou **key2**. O contexto da solicitação pode ter vários valores, mas devido ao operador do conjunto de condição `ForAllValues`, todos os valores da chave de tag no contexto da solicitação devem começar com o prefixo **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*"
]
}
}
}
]
}
```
A tabela a seguir mostra como a AWS avalia essa política com base nos valores de chave de condição da solicitação. Para uma Declaração de negação, a Correspondência é Negada e Nenhuma correspondência é Não negada, portanto, isso pode ser permitido por outra declaração.
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key1:legal
| **Nenhuma correspondência** Pode ser permitido por outra declaração. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key1:hr
– key1:personnel
| **Nenhuma correspondência** Pode ser permitido por outra declaração. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key1:hr
– key2:audit
| **Nenhuma correspondência** Pode ser permitido por outra declaração. |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | aws:TagKeys:
– key3:legal
| **correspondência** |
| "ForAllValues:StringNotLike": {
"aws:TagKeys": [
"key1*",
"key2*"
]
} | Nenhum `aws:TagKeys` no contexto da solicitação. | **correspondência** |
## Exemplo: política de negação com operador de conjunto de condições ForAnyValue
O exemplo de política baseada em identidade a seguir negará a criação de snapshots de volumes de instâncias do EC2 se algum snapshot estiver marcado com uma das chaves de etiqueta especificadas na política, `environment` ou `webserver`. A política inclui o operador de conjunto `ForAnyValue` com chave de contexto `aws:TagKeys` porque a chave de contexto da solicitação pode conter múltiplos valores. Se sua solicitação de marcação incluir qualquer chave-valor de etiqueta especificado na política, a chave de contexto `aws:TagKeys` retornará como verdadeiro, invocando o efeito da política de negação.
**Importante**
Esta política não permite qualquer ação. Use essa política em combinação com outras políticas que permitam ações específicas.
------
#### [ 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"
}
}
}
]
}
```
------
A tabela a seguir mostra como a AWS avalia essa política com base nos valores de chave de condição da solicitação. Para uma Declaração de negação, a Correspondência é Negada e Nenhuma correspondência é Não negada, portanto, isso pode ser permitido por outra declaração.
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | aws:TagKeys:
– webserver
| **correspondência** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | aws:TagKeys:
– environment
– webserver
– test
| **correspondência** |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | aws:TagKeys:
– environment
– test
| **Nenhuma correspondência** Pode ser permitido por outra declaração. |
| "ForAnyValue:StringEquals": {
"aws:TagKeys": "webserver"
} | Nenhum `aws:TagKeys` no contexto da solicitação. | **Nenhuma correspondência** Pode ser permitido por outra declaração. |
# Exemplos de políticas de chave de contexto de valor único
O conjunto de exemplos de políticas a seguir demonstra como criar condições de política com chaves de contexto de valor único.
## Exemplo: múltiplos blocos de condição com chaves de contexto de valor único
Quando um bloco de condição tem várias condições, cada uma com uma única chave de contexto, todas as chaves de contexto devem ser resolvidas como verdadeiras para o efeito desejado `Allow` ou `Deny` a ser invocado. Quando você usa operadores de condição de correspondência negados, inverte-se a lógica de avaliação do valor da condição.
O exemplo a seguir permite que os usuários criem volumes do EC2 e apliquem qualquer etiqueta aos volumes durante a criação do volume. O contexto da solicitação deve incluir um valor para a chave de contexto `aws:RequestTag/project`, e o valor da chave de contexto `aws:ResourceTag/environment` pode ser qualquer coisa, exceto produção.
------
#### [ 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"
}
}
}
]
}
```
------
O contexto da solicitação deve incluir o par etiqueta-valor do projeto e não pode ser criado para que um recurso de produção invoque o efeito `Allow`. O volume do EC2 a seguir foi criado com êxito porque o nome do projeto é `Feature3` com uma etiqueta de recurso `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}]'
```
## Exemplo: um bloco de condição com múltiplos valores e chaves de contexto de valor único
Quando um bloco de condição contém múltiplas chaves de contexto e cada chave de contexto tem múltiplos valores, cada chave de contexto deve ser resolvida como verdadeiro para pelo menos um valor de chave para o efeito desejado `Allow` ou `Deny` a ser invocado. Quando você usa operadores de condição de correspondência negados, inverte-se a lógica de avaliação do valor da chave de contexto.
Com o exemplo a seguir, os usuários podem iniciar e executar tarefas nos clusters do Amazon Elastic Container Service.
+ O contexto da solicitação deve incluir `production` **OR** `prod-backup` para a chave de contexto `aws:RequestTag/environment` **AND**.
+ A chave de contexto `ecs:cluster` garante que as tarefas sejam executadas em qualquer um dos clusters ARN `default1` **OR** `default2` do ECS.
------
#### [ 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"
]
}
}
}
]
}
```
------
A tabela a seguir mostra como a AWS avalia essa política com base nos valores de chave de condição da solicitação.
| Condição da política | Contexto da solicitação | Resultado |
| --- | --- | --- |
| "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
| correspondência |
| "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
| correspondência |
| "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
| Nenhuma correspondência |
| "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"
]
} | Nenhum `aws:RequestTag` no contexto da solicitação. ecs:cluster
arn:aws:ecs:us-east-1:111122223333:cluster/default2
| Nenhuma correspondência |