# Elementos de política JSON do IAM: operadores de condição
<a name="reference_policies_elements_condition_operators"></a>

<a name="topiclist"></a>

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
<a name="Conditions_String"></a>

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 | 
| --- | --- | --- | 
|  <pre>"StringEquals": {<br />  "aws:PrincipalTag/job-category": "iamuser-admin"<br />}</pre>  | <pre>aws:PrincipalTag/job-category:<br />  – iamuser-admin</pre>  |  correspondência | 
|  <pre>"StringEquals": {<br />  "aws:PrincipalTag/job-category": "iamuser-admin"<br />}</pre>  | <pre>aws:PrincipalTag/job-category:<br />  – dev-ops</pre>  | Nenhuma correspondência | 
|  <pre>"StringEquals": {<br />  "aws:PrincipalTag/job-category": "iamuser-admin"<br />}</pre>  |  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 | 
| --- | --- | --- | 
|  <pre>"StringLike": {<br />  "s3:prefix": [<br />    "home/",<br />    "home/${aws:username}/"<br />  ]<br />}</pre>  | <pre>aws:username:<br />  – martha_rivera</pre>  | <pre>"StringLike": {<br />  "s3:prefix": [<br />    "home/",<br />    "home/martha_rivera/"<br />  ]<br />}</pre>  | 
|  <pre>"StringLike": {<br />  "s3:prefix": [<br />    "home/",<br />    "home/${aws:username}/"<br />  ]<br />}</pre>  |  <pre>aws:username:<br />  – nikki_wolf</pre>  |  <pre>"StringLike": {<br />  "s3:prefix": [<br />    "home/",<br />    "home/nikki_wolf/"<br />  ]<br />}</pre>  | 
|  <pre>"StringLike": {<br />  "s3:prefix": [<br />    "home/",<br />    "home/${aws:username}/"<br />  ]<br />}</pre>  |  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
<a name="conditions_string_multivalued"></a>

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 | 
| --- | --- | --- | 
|  <pre>"StringEqualsIgnoreCase": {<br />  "aws:RequestTag/environment": [<br />    "preprod",<br />    "storage"<br />  ]<br />},<br />"ForAnyValue:StringEquals": {<br />  "aws:TagKeys": "environment"<br />}</pre>  | <pre>aws:TagKeys:<br />  – environment<br />aws:RequestTag/environment:<br />  – preprod</pre>  | correspondência  | 
|  <pre>"StringEqualsIgnoreCase": {<br />  "aws:RequestTag/environment": [<br />    "preprod",<br />    "storage"<br />  ]<br />},<br />"ForAnyValue:StringEquals": {<br />  "aws:TagKeys": "environment"<br />}</pre>  | <pre>aws:TagKeys:<br />  – environment<br />  – costcenter<br />aws:RequestTag/environment:<br />  – PreProd</pre>  | correspondência  | 
|  <pre>"StringEqualsIgnoreCase": {<br />  "aws:RequestTag/environment": [<br />    "preprod",<br />    "storage"<br />  ]<br />},<br />"ForAnyValue:StringEquals": {<br />  "aws:TagKeys": "environment"<br />}</pre>  | <pre>aws:TagKeys:<br />  – Environment<br />aws:RequestTag/Environment:<br />  – preprod</pre>  | Nenhuma correspondência  | 
|  <pre>"StringEqualsIgnoreCase": {<br />  "aws:RequestTag/environment": [<br />    "preprod",<br />    "storage"<br />  ]<br />},<br />"ForAnyValue:StringEquals": {<br />  "aws:TagKeys": "environment"<br />}</pre>  | <pre>aws:TagKeys:<br />  – costcenter<br />aws:RequestTag/environment:<br />  – preprod</pre>  | Nenhuma correspondência  | 
|  <pre>"StringEqualsIgnoreCase": {<br />  "aws:RequestTag/environment": [<br />    "preprod",<br />    "storage"<br />  ]<br />},<br />"ForAnyValue:StringEquals": {<br />  "aws:TagKeys": "environment"<br />}</pre>  |  Nenhum `aws:TagKeys` no contexto da solicitação. <pre>aws:RequestTag/environment:<br />  – storage</pre>  | Nenhuma correspondência  | 
|  <pre>"StringEqualsIgnoreCase": {<br />  "aws:RequestTag/environment": [<br />    "preprod",<br />    "storage"<br />  ]<br />},<br />"ForAnyValue:StringEquals": {<br />  "aws:TagKeys": "environment"<br />}</pre>  | <pre>aws:TagKeys:<br />  – environment</pre> Nenhum `aws:RequestTag/environment` no contexto da solicitação.  | Nenhuma correspondência  | 
|  <pre>"StringEqualsIgnoreCase": {<br />  "aws:RequestTag/environment": [<br />    "preprod",<br />    "storage"<br />  ]<br />},<br />"ForAnyValue:StringEquals": {<br />  "aws:TagKeys": "environment"<br />}</pre>  |  Nenhum `aws:TagKeys` no contexto da solicitação. Nenhum `aws:RequestTag/environment` no contexto da solicitação.  | Nenhuma correspondência  | 

### Correspondência de curinga
<a name="Conditions_String-wildcard"></a>

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 | 
| --- | --- | --- | 
|  <pre>"ForAllValues:StringNotLike": {<br />  "aws:ResourceOrgPaths": [<br />    "o-acorg/r-acroot/ou-acroot-mediaou/",<br />    "o-acorg/r-acroot/ou-acroot-sportsou/*"<br />  ] <br />}</pre>  | <pre>aws:ResourceOrgPaths:<br />  – o-acorg/r-acroot/ou-acroot-sportsou/costcenter/</pre>  | correspondência | 
|  <pre>"ForAllValues:StringNotLike": {<br />  "aws:ResourceOrgPaths": [<br />    "o-acorg/r-acroot/ou-acroot-mediaou/",<br />    "o-acorg/r-acroot/ou-acroot-sportsou/*"<br />  ] <br />}</pre>  | <pre>aws:ResourceOrgPaths:<br />  – o-acorg/r-acroot/ou-acroot-mediaou/costcenter/</pre>  | Nenhuma correspondência | 
|  <pre>"ForAllValues:StringNotLike": {<br />  "aws:ResourceOrgPaths": [<br />    "o-acorg/r-acroot/ou-acroot-mediaou/",<br />    "o-acorg/r-acroot/ou-acroot-sportsou/*"<br />  ] <br />}</pre>  |  Nenhum `aws:ResourceOrgPaths:` na solicitação.  | No match (Nenhuma correspondência) | 

## Operadores de condição numéricos
<a name="Conditions_Numeric"></a>

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
<a name="Conditions_Date"></a>

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
<a name="Conditions_Boolean"></a>

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 | 
| --- | --- | --- | 
|  <pre>"Bool": {<br />  "aws:SecureTransport": "false"<br />}</pre>  | <pre>aws:SecureTransport:<br />  – false</pre>  | correspondência | 
|  <pre>"Bool": {<br />  "aws:SecureTransport": "false"<br />}</pre>  | <pre>aws:SecureTransport:<br />  – true</pre>  | Nenhuma correspondência | 
|  <pre>"Bool": {<br />  "aws:SecureTransport": "false"<br />}</pre>  |  Nenhum `aws:SecureTransport` no contexto da solicitação.  | Nenhuma correspondência | 

## Operadores de condição binários
<a name="Conditions_BinaryEquals"></a>

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 | 
| --- | --- | --- | 
|  <pre>"BinaryEquals": {<br />  "key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="<br />}</pre>  | <pre>key:<br />  – QmluYXJ5VmFsdWVJbkJhc2U2NA==</pre>  | correspondência | 
|  <pre>"BinaryEquals": {<br />  "key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="<br />}</pre>  | <pre>key:<br />  – ASIAIOSFODNN7EXAMPLE</pre>  | Nenhuma correspondência | 
|  <pre>"BinaryEquals": {<br />  "key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="<br />}</pre>  |  Nenhum `key` no contexto da solicitação.  | Nenhuma correspondência | 

## Operadores de condição de endereço IP
<a name="Conditions_IPAddress"></a>

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 | 
| --- | --- | --- | 
|  <pre>"IpAddress": {<br />  "aws:SourceIp": "203.0.113.0/24"<br />}</pre>  | <pre>aws:SourceIp:<br />  – 203.0.113.1</pre>  | correspondência | 
|  <pre>"IpAddress": {<br />  "aws:SourceIp": "203.0.113.0/24"<br />}</pre>  | <pre>aws:SourceIp:<br />  – 198.51.100.1</pre>  | 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)
<a name="Conditions_ARN"></a>

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 | 
| --- | --- | --- | 
|  <pre>"ArnEquals": {<br />  "aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"<br />}</pre>  | <pre>aws:SourceArn:<br />  – arn:aws:sns:us-west-2:123456789012:TOPIC-ID</pre>  | correspondência | 
|  <pre>"ArnEquals": {<br />  "aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"<br />}</pre>  | <pre>aws:SourceArn:<br />  – arn:aws:sns:us-west-2:777788889999:TOPIC-ID</pre>  | Nenhuma correspondência | 
|  <pre>"ArnEquals": {<br />  "aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"<br />}</pre>  |  Nenhum `aws:SourceArn` no contexto da solicitação.  | Nenhuma correspondência | 

### Operadores de condição ARN com vários valores
<a name="conditions_arn_multivalued"></a>

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 | 
| --- | --- | --- | 
|  <pre>"ForAllValues:ArnLike": {<br />  "logs:LogGeneratingResourceArns": [<br />    "arn:aws::cloudfront:123456789012:distribution/*",<br />    "arn:aws::cloudfront:123456789012:distribution/support*"<br />  ]<br />}</pre>  | <pre>logs:LogGeneratingResourceArns:<br />  – arn:aws::cloudfront:123456789012:distribution/costcenter</pre>  | correspondência | 
|  <pre>"ForAllValues:ArnLike": {<br />  "logs:LogGeneratingResourceArns": [<br />    "arn:aws::cloudfront:123456789012:distribution/*",<br />    "arn:aws::cloudfront:123456789012:distribution/support*"<br />  ]<br />}</pre>  | <pre>logs:LogGeneratingResourceArns:<br />  – arn:aws::cloudfront:123456789012:distribution/costcenter<br />  – arn:aws::cloudfront:123456789012:distribution/support2025</pre>  | correspondência | 
|  <pre>"ForAllValues:ArnLike": {<br />  "logs:LogGeneratingResourceArns": [<br />    "arn:aws::cloudfront:123456789012:distribution/*",<br />    "arn:aws::cloudfront:123456789012:distribution/support*"<br />  ]<br />}</pre>  | <pre>logs:LogGeneratingResourceArns:<br />  – arn:aws::cloudfront:123456789012:distribution/costcenter<br />  – arn:aws::cloudfront:123456789012:distribution/admin</pre>  | Nenhuma correspondência | 
|  <pre>"ForAllValues:ArnLike": {<br />  "logs:LogGeneratingResourceArns": [<br />    "arn:aws::cloudfront:123456789012:distribution/*",<br />    "arn:aws::cloudfront:123456789012:distribution/support*"<br />  ]<br />}</pre>  | <pre>logs:LogGeneratingResourceArns:<br />  – arn:aws::cloudfront:777788889999:distribution/costcenter</pre>  | Nenhuma correspondência | 
|  <pre>"ForAllValues:ArnLike": {<br />  "logs:LogGeneratingResourceArns": [<br />    "arn:aws::cloudfront:123456789012:distribution/*",<br />    "arn:aws::cloudfront:123456789012:distribution/support*"<br />  ]<br />}</pre>  |  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
<a name="Conditions_IfExists"></a>

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 | 
| --- | --- | --- | 
|  <pre>"StringLikeIfExists": {<br />  "ec2:InstanceType": [<br />    "t1.*",<br />    "t2.*",<br />    "m3.*"<br />  ]<br />}</pre>  | <pre>ec2:InstanceType:<br />  – t1.micro</pre>  | correspondência | 
|  <pre>"StringLikeIfExists": {<br />  "ec2:InstanceType": [<br />    "t1.*",<br />    "t2.*",<br />    "m3.*"<br />  ]<br />}</pre>  | <pre>ec2:InstanceType:<br />  – m2.micro</pre>  | Nenhuma correspondência | 
|  <pre>"StringLikeIfExists": {<br />  "ec2:InstanceType": [<br />    "t1.*",<br />    "t2.*",<br />    "m3.*"<br />  ]<br />}</pre>  |  Nenhum `ec2:InstanceType` no contexto da solicitação.  | correspondência | 

## Operador de condição para verificar a existência de chaves de condição
<a name="Conditions_Null"></a>

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"}}
  }
}
```

------