# Referência de elemento de política JSON do IAM
Documentos de política JSON são compostos de elementos. Os elementos são listados aqui na ordem geral em que são usados em uma política. A ordem dos elementos não importa, por exemplo, o elemento `Resource` pode vir antes do elemento `Action`. Não é necessário especificar todos os elementos `Condition` da política. Para saber mais sobre a estrutura e a finalidade gerais de um documento de política JSON, consulte [Visão geral das políticas de JSON](access_policies.md#access_policies-json).
Alguns elementos de política JSON são mutuamente exclusivos. Isso significa que você não pode criar uma política que usa ambos. Por exemplo, você não pode usar `Action` e `NotAction` na mesma instrução de política. Outros pares que são mutuamente exclusivos incluem `Principal`/`NotPrincipal` e `Resource`/`NotResource`.
Os detalhes do que entra em uma política variam para cada serviço, dependendo de quais ações o serviço disponibiliza, que tipos de recursos ele contém e assim por diante. Quando você estiver gravando políticas para um serviço específico, é útil ver exemplos de políticas para esse serviço. Para obter uma lista de todos os serviços compatíveis com o IAM e links para a documentação desses serviços que discute o IAM e políticas, consulte [AWSServiços da que funcionam com o IAM](reference_aws-services-that-work-with-iam.md).
Quando você cria ou edita uma política JSON, o IAM pode executar a validação de políticas para ajudar você a criar uma política eficaz. O IAM identifica erros de sintaxe JSON, enquanto o IAM Access Analyzer fornece verificações de políticas adicionais com recomendações para ajudar você a refinar ainda mais suas políticas. Para saber mais sobre validação de política, consulte [Validação de política do IAM](access_policies_policy-validator.md). Para saber mais sobre as verificações de política do IAM Access Analyzer e as recomendações práticas, consulte [Validação de política do IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html).
**Topics**
+ [Version](reference_policies_elements_version.md)
+ [Id](reference_policies_elements_id.md)
+ [Statement](reference_policies_elements_statement.md)
+ [Sid](reference_policies_elements_sid.md)
+ [Effect](reference_policies_elements_effect.md)
+ [Principal](reference_policies_elements_principal.md)
+ [NotPrincipal](reference_policies_elements_notprincipal.md)
+ [Action](reference_policies_elements_action.md)
+ [NotAction](reference_policies_elements_notaction.md)
+ [Resource](reference_policies_elements_resource.md)
+ [NotResource](reference_policies_elements_notresource.md)
+ [Condition](reference_policies_elements_condition.md)
+ [Variáveis e tags](reference_policies_variables.md)
+ [Tipos de dados compatíveis](reference_policies_elements_datatypes.md)
# Elementos de política JSON do IAM: Version
**Nota de desambiguação**
O elemento de política JSON `Version` é diferente de uma *versão de política*. O elemento de política `Version` é usado em uma política e define a versão da linguagem da política. A versão da política, por outro lado, é criada quando você faz alterações em uma política gerenciada pelo cliente no IAM. A política alterada não substitui a política existente. Em vez disso, o IAM cria uma nova versão da política gerenciada. Se você estava procurando informações sobre o suporte a várias versões disponível para políticas gerenciadas, consulte [Versionamento de políticas do IAM](access_policies_managed-versioning.md).
O elemento de política `Version` especifica as regras de sintaxe de linguagem que devem ser usadas para processar uma política. Para usar todos os recursos de política disponíveis, inclua o elemento `Version` a seguir **fora** do elemento `Statement` em todas as suas políticas.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:ListAllMyBuckets",
"Resource": "*"
}
]
}
```
------
O IAM oferece suporte aos seguintes valores do elemento `Version`:
+ `2012-10-17`. Esta é a versão atual da linguagem da política e você deve sempre incluir um elemento `Version` e defini-lo como `2012-10-17`. Caso contrário, você não poderá usar recursos, como variáveis de [política](reference_policies_variables.md), que foram introduzidos com esta versão.
+ `2008-10-17`. Esta é uma versão anterior da linguagem da política. Talvez você veja essa versão em antigas políticas existentes. Não use essa versão para as políticas novas ou quando você atualizar alguma política existente. Recursos mais recentes, como variáveis de política, não funcionarão com a sua política. Por exemplo, as variáveis como `${aws:username}` não serão reconhecidas como variáveis e serão tratadas como strings literais na política.
# Elementos de política JSON do IAM: Id
O elemento `Id` especifica um identificador opcional para a política. O ID é usado de forma diferente em diferentes serviços. O ID é permitido em políticas baseadas em recursos, mas não em políticas baseadas em identidades.
Para serviços que permitem que você defina um elemento `ID`, recomendamos que você use um UUID (GUID) para o valor ou que incorpore um UUID como parte do ID para garantir a exclusividade.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "cd3ad3d9-2776-4ef1-a904-4c229d1642ee",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:ListAllMyBuckets",
"Resource": "*"
}
]
}
```
------
**nota**
Alguns produtos da AWS (por exemplo, Amazon SQS ou Amazon SNS) podem exigir este elemento e possuem requisitos de exclusividade para ele. Para obter informações específicas do serviço sobre a gravação de políticas, consulte a documentação para o serviço com o qual você está trabalhando.
# Elementos de política JSON do IAM: Statement
O elemento `Statement` é o principal elemento de uma política. Este elemento é obrigatório. O elemento `Statement` pode conter uma única instrução ou uma matriz de instruções individuais. Cada bloco de instrução individual deve ser colocado entre chaves \$1 \$1. Para várias instruções, a matriz deve estar entre colchetes [ ].
```
"Statement": [{...},{...},{...}]
```
O exemplo a seguir mostra uma política que contém uma matriz de três instruções dentro de um único elemento `Statement`. (A política permite que você acesse sua própria “pasta base” no console do Amazon S3.) A política inclui a variável `aws:username`, que é substituída durante a avaliação da política pelo nome de usuário da solicitação. Para obter mais informações, consulte [Introdução](reference_policies_variables.md#policy-vars-intro).
------
#### [ JSON ]
****
```
{
"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}/*"
]
}
]
}
```
------
# Elementos de política JSON do IAM: Sid
É possível fornecer um `Sid` (ID de instrução) como identificador opcional para a instrução da política. Você pode atribuir um valor `Sid` a cada instrução em uma matriz de instruções. Você pode usar o valor `Sid` como uma descrição para a instrução de política. Em serviços que permitem que você especifique um elemento `ID`, como o SQS e o SNS, o valor `Sid` é apenas um subID do ID do documento de política. No IAM, o valor `Sid` deve ser exclusivo em uma política JSON.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ExampleStatementID",
"Effect": "Allow",
"Action": "s3:ListAllMyBuckets",
"Resource": "*"
}
]
}
```
------
O elemento `Sid` é compatível com letras maiúsculas ASCII (A-Z), letras minúsculas (a-z) e números (0-9).
O IAM não expõe o `Sid` na API do IAM. Você não pode recuperar uma instrução específica com base neste ID.
**nota**
Alguns produtos da AWS (por exemplo, Amazon SQS ou Amazon SNS) podem exigir este elemento e possuem requisitos de exclusividade para ele. Para obter informações específicas do serviço sobre a gravação de políticas, consulte a documentação do serviço com o qual você está trabalhando.
# Elementos de política JSON do IAM: Effect
O elemento `Effect` é obrigatório e especifica se a instrução resulta em uma permissão ou uma negação explícita. Os valores válidos para `Effect` são `Allow` e `Deny`. O valor `Effect` diferencia maiúsculas de minúsculas.
```
"Effect":"Allow"
```
Por padrão, o acesso aos recursos é negado. Para permitir o acesso a um recurso, você deve definir o elemento `Effect` como `Allow`. Para substituir uma permissão (por exemplo, para substituir uma permissão que está em vigor), você define o elemento `Effect` como `Deny`. Para obter mais informações, consulte [Lógica da avaliação de política](reference_policies_evaluation-logic.md).
# Elementos da política JSON da AWS: Principal
Use o elemento `Principal` em uma política JSON baseada em recursos para especificar a entidade principal cujo acesso a um recurso é permitido ou negado.
Você pode usar o elemento `Principal` em [políticas baseadas em recursos](access_policies_identity-vs-resource.md). Vários serviços suportam políticas baseadas em recursos, inclusive o IAM. O tipo de política do IAM baseada em recursos é uma política de confiança em função. Nas funções do IAM, use o elemento `Principal` na política de confiança em função para especificar quem pode assumir a função. Para o acesso entre contas, você deve especificar o identificador de 12 dígitos da conta confiável. Para saber se as entidades de contas fora de sua zona de confiança (organização confiável ou conta) têm acesso para assumir as suas funções, consulte [O que é o IAM Access Analyzer?](https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html).
**nota**
Depois de criar a função, você pode alterar a conta para "\$1" a fim de permitir que todas as pessoas assumam a função. Se você fizer isso, recomendamos que você limite quem pode acessar a função através de outros meios, tal como um elemento `Condition` que limita o acesso somente a determinados endereços IP. Não deixe a função acessível a todos\$1
Outros exemplos de recursos que dão suporte a políticas baseadas em recursos incluem um bucket do Amazon S3 ou uma AWS KMS key.
Você não pode usar o elemento `Principal` em uma política baseada em identidade. As políticas baseadas em identidade são políticas de permissões que você anexa a identidades do IAM (usuários, grupos ou funções). Nesses casos, a entidade principal é implicitamente a identidade à qual a política está anexada.
**Topics**
+ [Como especificar uma entidade principal](#Principal_specifying)
+ [Entidades principais da Conta da AWS](#principal-accounts)
+ [Entidades de segurança de função do IAM](#principal-roles)
+ [Entidades principais da sessão de função](#principal-role-session)
+ [Entidades principais federadas OIDC](#principal-federated-web-identity)
+ [Entidades principais federadas SAML](#principal-saml)
+ [Entidades principais de usuário do IAM](#principal-users)
+ [Entidades principais do Centro de identidade do IAM](#principal-identity-users)
+ [Entidades principais federadas do AWS STS](#sts-session-principals)
+ [AWSResponsáveis pelos serviços da](#principal-services)
+ [Entidades principais de serviço da AWS nas regiões de aceitação](#principal-services-in-opt-in-regions)
+ [Todas as entidades principais](#principal-anonymous)
+ [Mais informações](#Principal_more-info)
## Como especificar uma entidade principal
Você especifica uma entidade principal no elemento `Principal` de uma política baseada em recursos ou em chaves de condição que dão suporte a entidades principais.
Você pode especificar qualquer um dos seguintes principais em uma política:
+ Conta da AWS e usuário raiz
+ Perfis do IAM
+ Sessões de função
+ Usuários do IAM
+ Entidades principais federadas
+ AWSServiços da
+ Todas as entidades principais
Não é possível identificar um grupo de usuários como entidade principal em uma política (como uma política baseada em recursos) porque os grupos são relacionados com permissões, não autenticação, e as entidades principais são entidades autenticadas do IAM.
Você pode especificar mais de uma entidade de segurança para cada um dos tipos de entidade de segurança nas seções a seguir usando uma matriz. As matrizes podem levar um ou mais valores. Ao especificar mais de uma entidade principal em um elemento, você concede permissões para cada entidade principal. Isso é um `OR` lógico e não um `AND` lógico, porque você autentica como uma entidade principal por vez. Se incluir mais de um valor, use colchetes (`[` e `]`) e delimite com vírgulas cada entrada da matriz. A política de exemplo a seguir define permissões para a conta 123456789012 ou para a conta 555555555555.
```
"Principal" : {
"AWS": [
"123456789012",
"555555555555"
]
}
```
**nota**
Não é possível usar um curinga para fazer a correspondência de parte de um nome de entidade principal ou ARN.
## Entidades principais da Conta da AWS
Você pode especificar identificadores de Conta da AWS no elemento `Principal` de uma política baseada em recursos ou em chaves de condição que oferecem suporte a entidades principais. Isso delega autoridade para a conta. Quando você permite o acesso a uma conta diferente, um administrador nessa conta deve então conceder acesso a uma identidade (usuário ou função do IAM) nessa conta. Ao especificar uma Conta da AWS, você pode usar o ARN da conta (arn:aws:iam::*account-ID*:root), ou uma forma abreviada que consiste no prefixo `"AWS":` seguido pelo ID da conta.
Por exemplo, dado um ID da conta de `123456789012`, você pode usar um dos seguintes métodos para especificar essa conta no elemento `Principal`:
```
"Principal": { "AWS": "arn:aws:iam::123456789012:root" }
```
```
"Principal": { "AWS": "123456789012" }
```
O ARN da conta e o ID da conta abreviado têm comportamento semelhante. Ambos delegam permissões à conta. O uso do ARN da conta no elemento `Principal` não limita permissões apenas para o usuário raiz da conta.
**nota**
Quando você salva uma política baseada em recursos que inclui o ID abreviado da conta, o serviço pode convertê-lo no ARN da entidade principal. Isso não altera a funcionalidade da política.
Alguns serviços da AWS são compatíveis com opções adicionais para especificar uma conta do principal. Por exemplo, o Amazon S3 permite que você especifique um [ID de usuário canônico](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html#FindingCanonicalId) usando o seguinte formato:
```
"Principal": { "CanonicalUser": "79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be" }
```
Você também pode especificar mais de uma Conta da AWS (ou ID de usuário canônico) como uma entidade principal usando uma matriz. Por exemplo, você pode especificar uma entidade principal em uma política de bucket usando todos os três métodos.
```
"Principal": {
"AWS": [
"arn:aws:iam::123456789012:root",
"999999999999"
],
"CanonicalUser": "79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be"
}
```
## Entidades de segurança de função do IAM
Você pode especificar ARNs de entidades principais de funções do IAM no elemento `Principal` de uma política baseada em recursos ou em chaves de condição que suportam entidades principais. As funções do IAM são identidades. No IAM, identidades são recursos aos quais você pode atribuir permissões. Funções confiam em outra identidade autenticada para assumir a respectiva função. Isso inclui uma entidade principal na AWS ou um usuário de um provedor de identidade externo (IdP). Quando uma entidade principal ou uma identidade assume uma função, ela recebe credenciais de segurança temporárias com as permissões da função assumida. Quando elas usam essas credenciais de sessão para executar operações na AWS, elas se tornam uma *entidade principal da sessão de função*.
Quando você especifica uma entidade principal de função em uma política baseada em recursos, as permissões efetivas para a entidade principal são limitadas por qualquer tipo de política que limite as permissões para a função. Isso inclui políticas de sessão e limites de permissões. Para mais informações sobre como as permissões efetivas de uma sessão de função são avaliadas, consulte [Lógica da avaliação de política](reference_policies_evaluation-logic.md).
Para especificar o ARN da função no elemento `Principal`, use o seguinte formato:
```
"Principal": { "AWS": "arn:aws:iam::AWS-account-ID:role/role-name" }
```
**Importante**
Se o seu elemento `Principal` em uma política de confiança de perfil contiver um ARN que aponte para uma um perfil do IAM específico, esse ARN será transformado no ID exclusivo da entidade principal do perfil quando você salvar a política. Isso ajuda a reduzir o risco de alguém elevar seus privilégios ao remover e recriar a função. Normalmente, você não vê esse ID no console, porque o IAM utiliza uma transformação reversa de volta para o ARN de função quando a política de confiança é exibida. No entanto, se você excluir a função, a relação é interrompida. A política não se aplica mais, mesmo se você recriar a função, pois a nova função possui um novo ID principal que não corresponde ao ID armazenado na política de confiança. Quando isso acontece, o ID da entidade principal aparece nas políticas baseadas em recursos porque a AWS não pode mais mapeá-lo de volta para um ARN válido. O resultado final é que, se você excluir e recriar um perfil referenciado no elemento `Principal` de uma política de confiança, deverá editar o perfil na política para substituir o ID da entidade principal pelo ARN correto. O ARN se transforma novamente no novo ID da entidade principal da função quando você salva a política. Para obter mais informações, consulte [Understanding AWS's Handling of Deleted IAM roles in Policies](https://repost.aws/articles/ARSqFcxvd7R9u-gcFD9nmA5g/understanding-aws-s-handling-of-deleted-iam-roles-in-policies).
Como alternativa, você pode especificar a entidade principal da função como a entidade principal em uma política baseada em recurso ou [criar uma política de permissão ampla](#principal-anonymous) que use a chave de condição `aws:PrincipalArn`. Quando você usa essa chave, a entidade principal de sessão de função recebe as permissões com base no ARN da função assumida e não no ARN da sessão resultante. Como a AWS não converte ARNs da chave de condição em IDs, as permissões concedidas ao ARN da função persistirão se você excluir a função e criar uma nova função com o mesmo nome. Tipos de políticas baseadas em identidade, como limites de permissões ou políticas de sessão, não limitam as permissões concedidas usando a chave de condição `aws:PrincipalArn` com um curinga (\$1) no elemento `Principal`, a menos que as políticas baseadas em identidade contenham uma negação explícita.
## Entidades principais da sessão de função
Você pode especificar sessões de função no elemento `Principal` de uma política baseada em recursos ou em chaves de condição que suportam entidades principais. Quando uma entidade principal ou uma identidade assume uma função, ela recebe credenciais de segurança temporárias com as permissões da função assumida. Quando elas usam essas credenciais de sessão para executar operações na AWS, elas se tornam uma *entidade principal da sessão de função*.
O formato que você usa para uma entidade principal da sessão de função depende da operação AWS STS que foi usada para assumir a função.
**Importante**
A AWS recomenda usar [entidades principais de perfil do IAM](#principal-roles) em suas políticas, em vez de entidades principais de sessão de perfil, sempre que possível. Use instruções `Condition` e chaves de condição para reduzir ainda mais o acesso quando necessário.
Para especificar o ARN da entidade principal da sessão de perfil assumida no elemento `Principal`, use o seguinte formato:
```
"Principal": { "AWS": "arn:aws:sts::AWS-account-ID:assumed-role/role-name/role-session-name" }
```
Além disso, os administradores podem projetar um processo para controlar como as sessões de função são emitidas. Por exemplo, eles podem fornecer uma solução de um clique para seus usuários que cria um nome de sessão previsível. Se o administrador fizer isso, você poderá usar as entidades principais da sessão de função em suas políticas ou chaves de condição. Caso contrário, você pode especificar o ARN do perfil como a entidade principal na chave de condição do `aws:PrincipalArn`. O modo como você especifica a função como entidade principal pode alterar as permissões efetivas para a sessão resultante. Para obter mais informações, consulte [Entidades de segurança de função do IAM](#principal-roles).
## Entidades principais federadas OIDC
Uma entidade principal federada do OIDC é a entidade principal usada ao chamar a API `AssumeRoleWithWebIdentity` do AWS STS com um token web JSON (JWT) de um IDP compatível com o OIDC, também conhecido como OpenID Provider (OP), para solicitar credenciais temporárias da AWS. Uma entidade principal federada do OIDC pode representar um IDP do OIDC em sua conta da AWS, ou os 4 provedores de identidade integrados: Login with Amazon, Google, Facebook, e [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/role-based-access-control.html).
Usuários, workloads ou sistemas que receberam um JWT de seu IDP do OIDC podem chamar `AssumeRoleWithWebIdentity` usando o JWT para solicitar credenciais de segurança temporárias da AWS para um perfil do IAM configurado para confiar no IDP do OIDC que emitiu o JWT. O JWT pode ser um token de identificação, token de acesso ou um token JWT entregue por qualquer outro método, desde que atenda aos [requisitos listados pelo AWS STS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html#manage-oidc-provider-prerequisites). Para obter mais informações, consulte [Cenários comuns](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_federation_common_scenarios.html) e [Solicitar credenciais por meio de um provedor OIDC](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_assumerolewithwebidentity).
Use este tipo de entidade principal na política de confiança de seu perfil para permitir ou negar permissões de chamada `AssumeRoleWIthWebIdentity` usando um IDP do OIDC que existe ne sua Conta da AWS ou em um dos quatro IDPs integrados. Para especificar o ARN da entidade principal federada ao OIDC no elemento `Principal` de uma política de confiança de perfil, use um dos quatro formatos a seguir para os IDPs OIDC integrados:
```
"Principal": { "Federated": "cognito-identity.amazonaws.com" }
```
```
"Principal": { "Federated": "www.amazon.com" }
```
```
"Principal": { "Federated": "graph.facebook.com" }
```
```
"Principal": { "Federated": "accounts.google.com" }
```
Ao usar um provedor OIDC que você adiciona à sua conta, como o GitHub, você especifica o ARN do provedor na política de confiança da sua função. Essa configuração a você escrever políticas do IAM que controlam o acesso especificamente para usuários autenticados por meio de seu provedor de identidade personalizado.
```
"Principal": { "Federated": "arn:aws:iam::AWS-account-ID:oidc-provider/full-OIDC-identity-provider-URL" }
```
Por exemplo, se GitHub for o provedor de identidade da Web confiável, o ARN da sessão do perfil do OIDC no elemento da `Principal` de uma política de confiança de perfil usará o seguinte formato:
```
"Principal": { "Federated": "arn:aws:iam::AWS-account-ID:oidc-provider/tokens.actions.githubusercontent.com" }
```
Consulte [Configurar o OpenID Connect na Amazon Web Services](https://docs.github.com/en/actions/security-for-github-actions/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services) para obter mais informações.
As entidades principais federadas do OIDC não oferecem suporte a outros tipos de políticas além das políticas de confiança de funções.
## Entidades principais federadas SAML
Uma *entidade principal federada do SAML* é a entidade principal usada ao chamar a API `AssumeRoleWithSAML` do AWS STS para solicitar credenciais temporárias da AWS usando uma declaração do SAML. Você pode usar seu provedor de identidades (IdP) SAML para se conectar e assumir um perfil do IAM usando essa operação. Semelhante a `AssumeRoleWithWebIdentity`, `AssumeRoleWithSAML` não exige credenciais da AWS para autenticação. Em vez disso, primeiro, os usuários se autenticam com seu provedor de identidade SAML e fazem a chamada de API `AssumeRoleWithSAML` usando sua declaração SAML ou são redirecionados para a página de login/SAML da AWS para entrar no Console de gerenciamento da AWS. Para mais informações sobre quais entidades principais podem assumir uma função usando essa operação, consulte [Compare credenciais do AWS STS](id_credentials_sts-comparison.md).
Use este tipo de entidade principal em sua política de confiança de perfil para permitir ou negar permissões com base no provedor de identidade SAML confiável. Para especificar o ARN da sessão de perfil de identidade SAML no elemento `Principal` de uma política de confiança de perfil, use o seguinte formato:
```
"Principal": { "Federated": "arn:aws:iam::AWS-account-ID:saml-provider/provider-name" }
```
## Entidades principais de usuário do IAM
Você pode especificar usuários do IAM no elemento `Principal` de uma política baseada em recursos ou em chaves de condições que suportam entidades principais.
**nota**
Em um elemento `Principal`, a parte do nome de usuário do [*nome do recurso da Amazon* (ARN)](reference_identifiers.md#identifiers-arns) diferencia maiúsculas e minúsculas.
```
"Principal": { "AWS": "arn:aws:iam::AWS-account-ID:user/user-name" }
```
```
"Principal": {
"AWS": [
"arn:aws:iam::AWS-account-ID:user/user-name-1",
"arn:aws:iam::AWS-account-ID:user/user-name-2"
]
}
```
Ao especificar usuários em um elemento `Principal`, você não pode usar um curinga (`*`) para se referir a "todos os usuários". Entidades principais sempre devem nomear usuários específicos.
**Importante**
Se o seu elemento `Principal` em uma política de confiança de função contiver um ARN que aponte para um usuário específico do IAM, o IAM transformará o ARN no ID exclusivo da entidade principal do usuário quando você salvar a política. Isso ajuda a reduzir o risco de alguém elevar seus privilégios ao remover e recriar o usuário. Normalmente, você não vê esse ID no console, pois há também uma transformação reversa de volta para o ARN do usuário quando a política de confiança é exibida. No entanto, se você excluir o usuário, a relação é interrompida. A política não se aplica mais, mesmo se você recriar o usuário. Isso porque o novo usuário tem um novo ID principal que não corresponde ao ID armazenado na política de confiança. Quando isso acontece, o ID da entidade principal aparece nas políticas baseadas em recursos porque a AWS não pode mais mapeá-lo de volta para um ARN válido. Como resultado, se você excluir e recriar um usuário mencionado no elemento `Principal` de uma política de confiança, você deve editar a função para substituir o agora incorreto ID da entidade principal pelo ARN correto. O IAM transformará novamente o ARN no novo ID da entidade principal do usuário quando você salvar a política.
## Entidades principais do Centro de identidade do IAM
No Centro de identidade do IAM, a entidade principal em uma política baseada em recursos deve ser definida como a entidade principal da Conta da AWS. Para especificar o acesso, faça referência ao ARN do perfil do conjunto de permissões no bloco de condições. Para obter detalhes, consulte [Referencing permission sets in resource policies, Amazon EKS, and AWS KMS](https://docs.aws.amazon.com/singlesignon/latest/userguide/referencingpermissionsets.html) no *Guia do usuário do Centro de identidade do IAM*.
## Entidades principais federadas do AWS STS
Você pode especificar *sessões de usuário federado* no elemento `Principal` de uma política baseada em recursos ou em chaves de condição que suportam entidades principais.
**Importante**
A AWS recomenda que você limite o uso de sessões do usuário federado do AWS STS. Em vez disso, use os [perfis do IAM](IAM/latest/UserGuide/tutorial_cross-account-with-roles.html).
Uma entidade principal de usuário federado do AWS STS é criado por meio da operação chamada `GetFederationToken` com credenciais do IAM de longa duração. As permissões do usuário federado são a interseção da entidade principal que chamou `GetFederationToken` e das políticas de sessão passadas como parâmetros para a API `GetFederationToken`.
Na AWS, um Usuário raiz da conta da AWS ou usuários do IAM podem fazer autenticação usando chaves de acesso de longo prazo. Para mais informações sobre quais entidades principais podem fazer a federação usando essa operação, consulte [Compare credenciais do AWS STS](id_credentials_sts-comparison.md).
+ **Usuário federado do IAM**: um usuário do IAM se federa usando a operação `GetFederationToken`, que resulta em uma sessão de usuário federado para esse usuário do IAM.
+ **Usuário-raiz federado**: um usuário-raiz se federa usando a operação `GetFederationToken`, o que resulta em uma sessão de usuário federado para esse usuário-raiz.
Quando um usuário do IAM ou usuário raiz solicita credenciais temporárias do AWS STS usando essa operação, ele inicia uma sessão temporária de usuário federado. O ARN dessa sessão é baseado na identidade original que foi federada.
Para especificar o ARN da sessão de usuário federado no elemento `Principal`, use o seguinte formato:
```
"Principal": { "AWS": "arn:aws:sts::AWS-account-ID:federated-user/user-name" }
```
## AWSResponsáveis pelos serviços da
Você pode especificar serviços da AWS no elemento `Principal` de uma política baseada em recursos ou em chaves de condição que suportam entidades principais. Uma *entidade principal de serviço* é um identificador para um serviço.
As funções do IAM que podem ser assumidas por um produto da AWS são chamadas de *[funções de serviço](id_roles.md#iam-term-service-role)*. As funções de serviço devem incluir uma política de confiança. *Políticas de confiança* são políticas baseadas em recursos anexadas a uma função que define quais entidades principais podem assumir a função. Algumas funções de serviço têm políticas de confiança predefinidas. No entanto, em alguns casos, você deve especificar o escopo principal do serviço na política de confiança. A entidade principal do serviço em uma política do IAM não pode ser `"Service": "*"`.
**Importante**
O identificador de uma entidade principal de serviço inclui o nome do serviço e geralmente está no seguinte formato:
`service-name.amazonaws.com`
O escopo principal do serviço é definido pelo serviço. É possível encontrar a entidade principal de serviço de alguns serviços abrindo [AWSServiços da que funcionam com o IAM](reference_aws-services-that-work-with-iam.md), verificando se o serviço tem um **Sim** na coluna **Perfil vinculado ao serviço** e abrindo o link de **Sim** para visualizar a documentação do perfil vinculado a esse serviço. Localize a seção **Service-Linked Role Permissions (Permissões da função vinculada ao serviço)** desse serviço para visualizar o principal do serviço.
O exemplo a seguir mostra uma política que pode ser anexada a uma função do serviço. A política permite que dois serviços, o Amazon ECS eo Elastic Load Balancing, assumam a função. Os serviços podem então realizar qualquer tarefa concedida pela política de permissões atribuída à função (não exibida). Para especificar vários principais de serviço, você não especifica dois elementos `Service`; pode ter apenas um. Em vez disso, você usa uma variedade de principais de serviços múltiplas como o valor de um único elemento `Service`.
```
"Principal": {
"Service": [
"ecs.amazonaws.com",
"elasticloadbalancing.amazonaws.com"
]
}
```
## Entidades principais de serviço da AWS nas regiões de aceitação
Você pode lançar recursos em várias regiões da AWS e em algumas dessas regiões pelas quais você deve optar. Para obter uma lista completa das regiões pelas quais você deve optar, consulte [Como gerenciar regiões da AWS](https://docs.aws.amazon.com/general/latest/gr/rande-manage.html) no * guia Referência geral da AWS*.
Quando um serviço da AWS em uma região de aceitação faz uma solicitação dentro da mesma região, o formato do nome da entidade principal do serviço é identificado como a versão não regionalizada desse nome:
`service-name.amazonaws.com`
Quando um serviço da AWS em uma região de aceitação faz uma solicitação entre regiões para outra região, o formato do nome da entidade principal do serviço é identificado como a versão regionalizada desse nome:
`service-name.{region}.amazonaws.com`
Por exemplo, você tem um tópico do Amazon SNS localizado na região `ap-southeast-1` e um bucket do Amazon S3 localizado na região de aceitação `ap-east-1`. Você deseja configurar as notificações do bucket do S3 para publicar mensagens no tópico do SNS. Para permitir que o serviço S3 publique mensagens no tópico do SNS, você deve conceder à entidade principal do serviço S3 a permissão `sns:Publish` por meio da política de acesso baseada em recursos do tópico.
Se você especificar a versão não regionalizada da entidade principal do serviço S3, `s3.amazonaws.com`, na política de acesso do tópico, a solicitação `sns:Publish` do bucket para o tópico falhará. O exemplo a seguir especifica a entidade principal do serviço S3 não regionalizado no elemento de política `Principal` da política de acesso a tópicos do SNS.
```
"Principal": { "Service": "s3.amazonaws.com" }
```
Como o bucket está localizado em uma região de aceitação e a solicitação é feita fora dessa mesma região, a entidade principal do serviço S3 aparece como o nome da entidade principal do serviço regionalizado, `s3.ap-east-1.amazonaws.com`. Você deve usar o nome da entidade principal do serviço regionalizado quando um serviço da AWS em uma região de aceitação fizer uma solicitação para outra região. Depois de especificar o nome da entidade principal do serviço regionalizado, se o bucket fizer uma solicitação `sns:Publish` ao tópico do SNS localizado em outra região, a solicitação será bem-sucedida. O exemplo a seguir especifica a entidade principal do serviço regionalizado S3 no elemento de política `Principal` da política de acesso a tópicos do SNS.
```
"Principal": { "Service": "s3.ap-east-1.amazonaws.com" }
```
Políticas de recursos ou listas de permissões baseadas em entidades principais de serviços para solicitações entre regiões de uma região de aceitação para outra região só serão bem-sucedidas se você especificar o nome da entidade principal do serviço regionalizado.
**nota**
Para políticas de confiança de perfis do IAM, recomendamos usar o nome da entidade principal do serviço não regionalizado. Os recursos do IAM são globais e, portanto, o mesmo perfil pode ser usado em qualquer região.
## Todas as entidades principais
É possível usar um curinga (\$1) para especificar todas as entidades principais no elemento `Principal` de uma política baseada em recursos ou em chaves de condições compatíveis com entidades principais. [Políticas baseadas em recursos](access_policies.md#policies_resource-based) *concedem* permissões e [chaves de condições](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) são usadas para limitar as condições de uma instrução de política.
**Importante**
É muito recomendável que você não use um caractere curinga (\$1) no elemento `Principal` de uma política baseada em recursos com um efeito `Allow`, a menos que pretenda conceder acesso público ou anônimo. Caso contrário, especifique entidades principais, serviços ou contas da AWS no elemento `Principal` e depois restrinja ainda mais o acesso no elemento `Condition`. Isso é especialmente verdadeiro para políticas de confiança do perfil do IAM, porque permitem que outras entidades principais se tornem uma entidade principal em sua conta.
Para políticas baseadas em recursos, usar um caractere curinga (\$1) com um efeito `Allow` concede acesso a todos os usuários, incluindo usuários anônimos (acesso público). Para usuários do IAM e entidades principais de função dentro da sua conta, nenhuma outra permissão é necessária. Para entidades principais em outras contas, elas também devem ter permissões baseadas em identidade em suas contas que lhes permitam acessar seu recurso. Isso é chamado de [acesso entre contas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html).
Para usuários anônimos, os seguintes elementos são equivalentes:
```
"Principal": "*"
```
```
"Principal" : { "AWS" : "*" }
```
Não é possível usar um curinga para fazer a correspondência de parte de um nome de entidade principal ou ARN.
O exemplo a seguir mostra uma política baseada em recurso que pode ser usada em vez de [Elementos da política JSON da AWS: NotPrincipal](reference_policies_elements_notprincipal.md) para negar explicitamente todas as entidades principais *exceto* as especificadas no elemento `Condition`. Essa política deve ser [adicionada a um bucket do Amazon S3](https://docs.aws.amazon.com//AmazonS3/latest/userguide/add-bucket-policy.html).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "UsePrincipalArnInsteadOfNotPrincipalWithDeny",
"Effect": "Deny",
"Action": "s3:*",
"Principal": "*",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket"
],
"Condition": {
"ArnNotEquals": {
"aws:PrincipalArn": "arn:aws:iam::444455556666:user/user-name"
}
}
}
]
}
```
------
## Mais informações
Para saber mais, consulte:
+ [Exemplos de políticas de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html) no *Guia do usuário do Amazon Simple Storage Service*
+ [Exemplos de políticas do Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/UsingIAMwithSNS.html#ExamplePolicies_SNS) no *Guia do desenvolvedor do Amazon Simple Notification Service*
+ [Exemplos de políticas do Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSExamples.html) no *Guia do desenvolvedor do Amazon Simple Queue Service*
+ [Políticas de chaves](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) no *Guia do desenvolvedor do AWS Key Management Service*
+ [Identificadores de conta](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html) no *Referência geral da AWS*
+ [Federação OIDC](id_roles_providers_oidc.md)
# Elementos da política JSON da AWS: NotPrincipal
O elemento `NotPrincipal` usa `"Effect":"Deny"` para negar acesso a todas as entidades principais, ***exceto*** a entidade principal especificada no elemento `NotPrincipal`. Uma entidade principal pode ser um usuário do IAM, uma entidade principal de usuário federado do AWS STS, um perfil do IAM, uma sessão de perfil assumido, uma Conta da AWS, um serviço da AWS ou outro tipo de entidade principal. Para obter mais informações, sobre entidades principais, consulte [Elementos da política JSON da AWS: Principal](reference_policies_elements_principal.md).
`NotPrincipal` deve ser usado com `"Effect":"Deny"`. O uso de `"Effect":"Allow"` não é compatível.
**Importante**
Não recomendamos o uso de `NotPrincipal` para novas políticas baseadas em recursos como parte de sua estratégia de segurança e autorização. Quando você usa `NotPrincipal`, pode ser difícil solucionar os problemas causados por vários tipos de política. Em vez disso, recomendamos usar a chave de contexto `aws:PrincipalArn` com operadores de condição de ARN.
## Principais pontos
+ O elemento `NotPrincipal` é aceito em políticas baseadas em recursos para alguns serviços da AWS, incluindo endpoints da VPC. As políticas baseadas em recursos são políticas que você incorpora diretamente em um recurso. Não é possível usar o elemento `NotPrincipal` em uma política baseada em identidade do IAM ou em uma política de perfil do IAM de confiança.
+ Não use declarações de política baseadas em recursos que incluam um elemento de política `NotPrincipal` com um efeito `Deny` para usuários ou perfis do IAM que tenham uma política de limite de permissões anexada. O elemento `NotPrincipal` com um efeito `Deny` sempre negará qualquer entidade principal do IAM que tenha uma política de limite de permissões anexada, independentemente dos valores especificados no elemento `NotPrincipal`. Isso faz com que alguns usuários ou perfis do IAM que, de outra forma, teriam acesso ao recurso, percam o acesso. Recomendamos alterar suas declarações de política baseadas em recursos para usar o operador de condição [`ArnNotEquals`](reference_policies_elements_condition_operators.md#Conditions_ARN) com a chave de contexto [`aws:PrincipalArn`](reference_policies_condition-keys.md#condition-keys-principalarn) para limitar o acesso, em vez do elemento `NotPrincipal`. Para obter mais informações sobre esses limites de permissões, consulte [Limites de permissões para entidades do IAM](access_policies_boundaries.md).
+ Ao usar `NotPrincipal`, você também deve especificar o ARN da entidade principal não negada. Caso contrário, a política pode negar o acesso à conta por completo contendo o principal. Dependendo do serviço que você incluir em sua política, a AWS pode validar primeiro a conta e, em seguida, o usuário. Se um usuário de função assumida (alguém que esteja usando uma função) está sendo avaliado, AWS pode validar primeiro a conta, em seguida, a função e, por fim, o usuário de função assumida. O usuário de função assumida é identificado pelo nome de sessão da função, especificado quando ele assumiu a função. Portanto, é recomendável incluir explicitamente o ARN para uma conta de usuário, ou incluir o ARN para a função e o ARN para a conta que contém essa função.
+ O elemento `NotPrincipal` não é compatível com políticas de controle de serviços (SCP) e políticas de controle de recursos (RCP).
## Alternativas ao elemento `NotPrincipal`
Ao gerenciar o controle de acesso em AWS, pode haver cenários em que talvez seja necessário negar explicitamente o acesso de todas as entidades principais a um recurso, exceto uma ou mais entidades principais que você especificar. A AWS recomenda o uso de uma instrução Deny com chaves de contexto de condição global para um controle mais preciso e uma solução de problemas mais fácil. Os exemplos a seguir mostram abordagens alternativas usando operadores de condição, como `StringNotEquals` ou `ArnNotEquals`, para negar acesso a todas as entidades principais, exceto aquelas especificadas no elemento Condition.
## Exemplo de cenário usando um perfil do IAM
É possível usar uma política baseada em recursos com uma instrução Deny para impedir que todos os perfis do IAM, exceto aqueles especificados no elemento Condition, acessem ou manipulem seus recursos. Essa abordagem segue o princípio de segurança da AWS em que uma negação explícita sempre tem precedência sobre qualquer declaração de permissão e ajuda a manter o princípio de privilégio mínimo em sua infraestrutura da AWS.
Em vez de usar `NotPrincipal`, recomendamos usar uma instrução Deny com chaves de contexto de condição globais e o operador de condição como [`ArnNotEquals`](reference_policies_elements_condition_operators.md#Conditions_ARN) para permitir explicitamente que um perfil do IAM acesse seus recursos. O exemplo a seguir usa [aws:PrincipalArn](reference_policies_condition-keys.md#condition-keys-principalarn) para permitir explicitamente que o perfil `read-only-role` acesse buckets do Amazon S3 na pasta `Bucket_Account_Audit`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyCrossAuditAccess",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::Bucket_Account_Audit",
"arn:aws:s3:::Bucket_Account_Audit/*"
],
"Condition": {
"ArnNotEquals": {
"aws:PrincipalArn": "arn:aws:iam::444455556666:role/read-only-role"
}
}
}
]
}
```
------
## Exemplo de cenário usando uma entidade principal de serviço
É possível usar uma instrução Deny para impedir que todas as entidades principais de serviço, exceto aquelas especificados no elemento `Condition`, acessem ou manipulem seus recursos. Essa abordagem é particularmente útil quando você precisa implementar controles de acesso refinados ou estabelecer limites de segurança entre diferentes serviços e aplicações em seu ambiente da AWS.
Em vez de usar `NotPrincipal`, recomendamos usar uma instrução Deny com chaves de contexto de condição globais e o operador de condição [`StringNotEquals`](reference_policies_elements_condition_operators.md#Conditions_String) para permitir explicitamente que uma entidade principal de serviço acesse seus recursos. O exemplo a seguir usa `aws:PrincipalServiceName` para permitir explicitamente que a entidade principal de serviço AWS CodeBuild acesse buckets do Amazon S3 na pasta `BUCKETNAME`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyNotCodeBuildAccess",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::BUCKETNAME",
"arn:aws:s3:::BUCKETNAME/*"
],
"Condition": {
"StringNotEqualsIfExists": {
"aws:PrincipalServiceName": "codebuild.amazonaws.com"
}
}
}
]
}
```
------
# Elementos de política JSON do IAM: Action
O elemento `Action` descreve a ação ou ações específicas que serão permitidas ou negadas. As instruções devem incluir um elemento `Action` ou `NotAction`. Cada serviço da AWS tem seu próprio conjunto de ações que descrevem as tarefas que você pode executar com aquele serviço. Por exemplo, a lista de ações do Amazon S3 está disponível em [Especificação de permissões em uma política](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-with-s3-actions.html) no *Guia do usuário do Amazon Simple Storage Service*, a lista de ações do Amazon EC2 está disponível em [Referência de API do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/query-apis.html) e a lista de ações do AWS Identity and Access Management está disponível em [Referência de API do IAM](https://docs.aws.amazon.com/IAM/latest/APIReference/API_Operations.html). Para encontrar a lista de ações para outros serviços, consulte a [documentação](https://aws.amazon.com/documentation) de referência de APIs do serviço.
A AWS também fornece informações de referência sobre o serviço no formato JSON para agilizar a automação dos fluxos de trabalho de gerenciamento de políticas. Com as informações de referência do serviço, você pode acessar, em arquivos legíveis por máquina, as ações, recursos e chaves de condições disponíveis nos Serviços da AWS. Para obter mais informações, consulte [Simplified AWS service (Serviço da AWS) information for programmatic access](https://docs.aws.amazon.com/service-authorization/latest/reference/service-reference.html) na Service Authorization Reference.
Você especifica um valor usando um namespace de serviço, como um prefixo de ação (`iam`, `ec2` `sqs`, `sns`, `s3` etc.) seguido pelo nome da ação para permitir ou negar. O nome deve corresponder a uma ação compatível com o serviço. O prefixo e o nome da ação não diferenciam entre letras maiúsculas e minúsculas. Por exemplo, `iam:ListAccessKeys` é o mesmo que `IAM:listaccesskeys`. Os exemplos a seguir mostram elementos `Action` para diferentes serviços.
**Ação do Amazon SQS**
```
"Action": "sqs:SendMessage"
```
**Ação do Amazon EC**
```
"Action": "ec2:StartInstances"
```
**Ação do IAM**
```
"Action": "iam:ChangePassword"
```
**Ação do Amazon S**
```
"Action": "s3:GetObject"
```
Você pode especificar vários valores para o elemento `Action`.
```
"Action": [ "sqs:SendMessage", "sqs:ReceiveMessage", "ec2:StartInstances", "iam:ChangePassword", "s3:GetObject" ]
```
Você pode usar curingas de correspondência de vários caracteres (`*`) e curingas de correspondência de caractere único (`?`) para conceder acesso a todas as ações que o produto específico da AWS oferece. Por exemplo, o seguinte elemento `Action` se aplica a todas as ações do S3.
```
"Action": "s3:*"
```
Você também pode usar curingas (`*` ou `?`) como parte do nome da ação. Por exemplo, o elemento `Action` a seguir se aplica a todas as ações do IAM que incluem a string `AccessKey`, incluindo `CreateAccessKey`, `DeleteAccessKey`, `ListAccessKeys` e `UpdateAccessKey`.
```
"Action": "iam:*AccessKey*"
```
Alguns serviços permitem que você limite as ações que estão disponíveis. Por exemplo, o Amazon SQS permite que você disponibilize apenas um subconjunto de todas as ações possíveis do Amazon SQS. Neste caso, o curinga `*` não permite o controle completo da fila; ele permite apenas o subconjunto de ações que você compartilhou. Para obter mais informações, consulte [Noções básicas sobre permissões ](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/acp-overview.html#PermissionTypes) no *Guia do desenvolvedor do Amazon Simple Queue Service*.
# Elementos de política JSON do IAM: NotAction
`NotAction` é um elemento de política avançado que explicitamente corresponde a tudo *exceto* a lista especificada de ações. O uso de `NotAction` pode resultar em uma política mais curta ao listar apenas algumas ações que não devem corresponder, em vez de incluir uma longa lista de ações para correspondência. As ações especificadas em `NotAction` não são afetadas por `Allow` ou `Deny` em uma instrução de política. Isso, por sua vez, significa que todas as ações ou serviços aplicáveis que não são listados são permitidos se você usar o efeito `Allow`. Além disso, essas ações ou serviços não listados são negados se você usar o efeito `Deny`. Ao usar `NotAction` com o elemento `Resource`, você fornece escopo para a política. Isso é como a AWS determina quais ações ou serviços são aplicáveis. Para obter mais informações, consulte o seguinte exemplo de política.
**NotAction com permitir**
Você pode usar o elemento `NotAction` em uma instrução com `"Effect": "Allow"` para fornecer acesso a todas as ações em um serviço da AWS, exceto para as ações especificadas em `NotAction`. Você pode usá-lo com o elemento `Resource` para fornecer escopo para a política, limitando as ações permitidas para as ações que podem ser realizadas no recurso especificado.
O exemplo a seguir permite que os usuários acessem todas as ações do Amazon S3 que podem ser executadas em qualquer recurso do S3, *exceto* a exclusão de um bucket. Essa política também não permite ações em outros serviços, pois outras ações de serviço não são aplicáveis aos recursos do S3.
```
"Effect": "Allow",
"NotAction": "s3:DeleteBucket",
"Resource": "arn:aws:s3:::*",
```
Às vezes, você pode querer permitir o acesso a um grande número de ações. O uso do elemento `NotAction` efetivamente reverte a instrução, resultando em uma lista de ações mais curta. Por exemplo, como há muitos produtos da AWS, você pode criar uma política que permita ao usuário fazer tudo, exceto acessar ações do IAM.
O exemplo a seguir permite aos usuários acessar todas as ações em todos os produtos da AWS, exceto o IAM.
```
"Effect": "Allow",
"NotAction": "iam:*",
"Resource": "*"
```
Tenha cuidado ao usar o elemento `NotAction` e `"Effect": "Allow"` na mesma instrução ou em outra instrução dentro de uma política. `NotAction` corresponde a todos os serviços e ações que não são explicitamente listados ou aplicáveis para o recurso especificado e pode resultar em concessão de mais permissões aos usuários do que o desejado.
**NotAction com Deny**
Você pode usar o elemento `NotAction` em uma instrução com `"Effect": "Deny"` para negar acesso a todos os recursos listados, exceto para as ações especificadas no elemento `NotAction`. Essa combinação não permite os itens listados, mas explicitamente nega as ações não listadas em vez disso. Você ainda deve habilitar as ações que você deseja permitir.
O exemplo condicional a seguir nega acesso a ações que não são do IAM se o usuário não estiver conectado usando a MFA. Se o usuário estiver conectado com MFA, o teste de `"Condition"` falhará e a instrução `"Deny"` final não terá efeito. Observe, no entanto, que isso não concederia ao usuário acesso a qualquer ação, e apenas negaria explicitamente todas as outras ações, exceto as ações do IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "DenyAllUsersNotUsingMFA",
"Effect": "Deny",
"NotAction": "iam:*",
"Resource": "*",
"Condition": {"BoolIfExists": {"aws:MultiFactorAuthPresent": "false"}}
}]
}
```
------
Para obter um exemplo de política que nega o acesso a ações fora de regiões específicas, exceto ações de serviços específicos, consulte [AWS: nega acesso à AWS com base na região solicitada](reference_policies_examples_aws_deny-requested-region.md).
# Elementos de política JSON do IAM: Resource
O elemento `Resource` em uma declaração de política do IAM define o objeto ou objetos aos quais a declaração se aplica. As instruções devem incluir um elemento `Resource` ou `NotResource`.
Você especifica um recurso usando um nome do recurso da Amazon (ARN). O formato do ARN depende do AWS service (Serviço da AWS) e do recurso específico ao qual você está se referindo. Embora o formato do ARN varie, você sempre usará um ARN para identificar um recurso. Para obter mais informações sobre o formato de ARNs, consulte [ARNs do IAM](reference_identifiers.md#identifiers-arns). Para obter informações sobre como especificar um recurso, consulte a documentação do serviço para o qual deseja escrever uma instrução.
**nota**
Alguns Serviços da AWS não permitem que você especifique ações para recursos individuais. Nesses casos, todas as ações listadas no elemento `Action` ou `NotAction` se aplicam a todos os recursos desse serviço. Quando for esse o caso, você usará o caractere curinga (`*`) no elemento `Resource`.
O exemplo a seguir se refere a uma fila específica do Amazon SQS.
```
"Resource": "arn:aws:sqs:us-east-2:account-ID-without-hyphens:queue1"
```
O exemplo a seguir faz referência ao usuário do IAM chamado `Bob` em uma Conta da AWS.
**nota**
Em um elemento `Resource`, o nome de usuário do IAM diferencia letras maiúsculas de minúsculas.
```
"Resource": "arn:aws:iam::account-ID-without-hyphens:user/Bob"
```
## Uso de caracteres curinga em ARNs de recursos
Você pode usar caracteres curinga (`*` e `?`) dentro dos segmentos individuais de um ARN (as partes separadas por dois pontos) para representar:
+ Qualquer combinação de caracteres (`*`)
+ Qualquer caractere único (`?`)
Você pode usar vários caracteres `*` ou `?` em cada segmento. Se o curinga `*` for o último caractere de um segmento de ARN de um recurso, ele poderá expandir a busca de correspondência para além dos limites de dois-pontos. Recomendamos que você use curingas (`*` e `?`) dentro dos segmentos de ARN separados por dois pontos.
**nota**
Você não pode usar um caractere curinga no segmento do serviço que identifica o produto da AWS. Para obter mais informações sobre ARN, consulte [Identifique recursos da AWS com nomes do recurso da Amazon (ARNs)](reference-arns.md)
O exemplo a seguir se refere a todos os usuários do IAM cujo caminho é `/accounting`.
```
"Resource": "arn:aws:iam::account-ID-without-hyphens:user/accounting/*"
```
O exemplo a seguir se refere a todos os itens dentro de um bucket do Amazon S3 específico.
```
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
```
O caractere asterisco (`*`) pode ser expandido para substituir tudo dentro de um segmento, incluindo caracteres como uma barra (`/`) que pode parecer um delimitador dentro de um determinado namespace de serviço. Por exemplo, considere o ARN do Amazon S3 a seguir, pois a mesma lógica de expansão de curinga se aplica a todos os serviços.
```
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*/test/*"
```
Os caracteres curinga no ARN se aplicam a todos os objetos a seguir no bucket, não apenas ao primeiro objeto listado.
```
amzn-s3-demo-bucket/1/test/object.jpg
amzn-s3-demo-bucket/1/2/test/object.jpg
amzn-s3-demo-bucket/1/2/test/3/object.jpg
amzn-s3-demo-bucket/1/2/3/test/4/object.jpg
amzn-s3-demo-bucket/1///test///object.jpg
amzn-s3-demo-bucket/1/test/.jpg
amzn-s3-demo-bucket//test/object.jpg
amzn-s3-demo-bucket/1/test/
```
Considere os dois últimos objetos na lista anterior. Um nome de objeto do Amazon S3 pode começar ou terminar com o caractere de barra (`/`) delimitador convencional. Embora `/` funcione como um delimitador, não há significado específico quando esse caractere é usado em um ARN de recurso. Ele é tratado da mesma forma que qualquer outro caractere válido. O ARN não corresponderá aos seguintes objetos:
```
amzn-s3-demo-bucket/1-test/object.jpg
amzn-s3-demo-bucket/test/object.jpg
amzn-s3-demo-bucket/1/2/test.jpg
```
## Especificação de vários recursos
Você pode especificar vários recursos no elemento `Resource` usando uma matriz de ARNs. O exemplo a seguir se refere a duas tabelas do DynamoDB.
```
"Resource": [
"arn:aws:dynamodb:us-east-2:account-ID-without-hyphens:table/books_table",
"arn:aws:dynamodb:us-east-2:account-ID-without-hyphens:table/magazines_table"
]
```
## Uso de variáveis de política em ARNs de recursos
No elemento `Resource`, você pode usar [variáveis de política](reference_policies_variables.md) JSON na parte do ARN que identifica o recurso específico, ou seja, na parte final do ARN. Por exemplo, você pode usar a chave `{aws:username}` como parte de um ARN de recurso para indicar que o nome do usuário atual deve ser incluído como parte do nome do recurso. O exemplo a seguir mostra como você pode usar a chave `{aws:username}` em um elemento `Resource`. A política permite o acesso a uma tabela do Amazon DynamoDB que corresponde ao nome do usuário atual.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "dynamodb:*",
"Resource": "arn:aws:dynamodb:us-east-2:111122223333:table/${aws:username}"
}
}
```
------
Para obter mais informações sobre variáveis de política JSON, consulte [Elementos de política do IAM: variáveis e etiquetas](reference_policies_variables.md).
# Elementos de política JSON do IAM: NotResource
`NotResource` é um elemento de política avançado que corresponde explicitamente a cada recurso, exceto aqueles especificados. O uso de `NotResource` pode resultar em uma política mais curta ao listar somente alguns recursos que não devem corresponder, em vez de incluir uma longa lista de recursos para correspondência. Isso é especialmente útil para políticas aplicáveis em um único serviço da AWS.
Por exemplo, imagine que você tenha um grupo chamado `HRPayroll`. Os membros de `HRPayroll` não devem ter permissão para acessar os recursos do Amazon S3, exceto a pasta `Payroll` no bucket `HRBucket`. A seguinte política nega explicitamente o acesso a todos os recursos do Amazon S3, exceto os recursos listados. Observe, no entanto, que essa política não concede ao usuário acesso a qualquer recurso.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Deny",
"Action": "s3:*",
"NotResource": [
"arn:aws:s3:::HRBucket/Payroll",
"arn:aws:s3:::HRBucket/Payroll/*"
]
}
}
```
------
Normalmente, para negar explicitamente o acesso a um recurso, você deve escrever uma política que utilize `"Effect":"Deny"` e que inclua um elemento `Resource` listando cada pasta individualmente. Entretanto, nesse caso, cada vez que você adiciona uma pasta ao `HRBucket`, ou adiciona um recurso ao Amazon S3 que não deve ser acessado, você deve adicionar o nome desses itens à lista no elemento `Resource`. Se você usar um elemento `NotResource` em vez disso, os usuários terão o acesso a novas pastas automaticamente negado, a menos que você adicione os nomes das pastas no elemento `NotResource`.
Ao usar `NotResource`, você deve ter em mente que os recursos especificados neste elemento são os *únicos* recursos que não são limitados. Isso, por sua vez, limita todos os recursos que seriam aplicáveis à ação. No exemplo acima, a política afeta apenas as ações do Amazon S3 e, portanto, apenas os recursos do Amazon S3. Se o elemento `Action` também incluísse ações do Amazon EC2, a política negaria acesso a nenhum recurso do EC2 não especificados no elemento `NotResource`. Para saber quais ações em um serviço permitem especificar o ARN de um recurso, consulte [Ações, recursos e chaves de condição de serviços da AWS](reference_policies_actions-resources-contextkeys.html).
## NotResource com outros elementos
**Nunca** use os elementos `"Effect": "Allow"`, `"Action": "*"` e `"NotResource": "arn:aws:s3:::HRBucket"` juntos. Essa instrução é muito perigosa porque permite todas as ações na AWS em todos os recursos, exceto no bucket `HRBucket` do S3. Isso permitiria até mesmo que o usuário adicionasse uma política para si mesmo que permitisse o acesso ao `HRBucket`. Não faça isso.
Tenha cuidado ao usar o elemento `NotResource` e `"Effect": "Allow"` na mesma instrução ou em outra instrução em uma política. O `NotResource` permite todos os serviços e recursos que não são explicitamente listados e pode resultar na concessão de mais permissões aos usuários do que o desejado. O uso do elemento `NotResource` e `"Effect": "Deny"` na mesma instrução nega os serviços e recursos que não são explicitamente listados.
# 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 |
# Elementos de política do IAM: variáveis e etiquetas
Use variáveis de política do AWS Identity and Access Management (IAM) como espaços reservados quando você não souber o valor exato de um recurso ou uma chave de condição ao escrever a política.
**nota**
Se a AWS não puder resolver uma variável, isso poderá invalidar toda a instrução. Por exemplo, se você usar a variável `aws:TokenIssueTime`, a variável será resolvida como um valor somente quando o solicitante tiver sido autenticado com credenciais temporárias (uma função do IAM). Para evitar que as variáveis provoquem instruções inválidas, use o operador de condição [...IfExists.](reference_policies_elements_condition_operators.md#Conditions_IfExists)
**Topics**
+ [Introdução](#policy-vars-intro)
+ [Usar variáveis em políticas](#policy-vars-using-variables)
+ [Tags como variáveis de política](#policy-vars-tags)
+ [Onde você pode usar variáveis de política](#policy-vars-wheretouse)
+ [Variáveis de política sem valor](#policy-vars-no-value)
+ [Solicitar informações que você pode usar para variáveis de política](#policy-vars-infotouse)
+ [Especificação de valores padrão](#policy-vars-default-values)
+ [Para obter mais informações](#policy-vars-formoreinfo)
## Introdução
Nas políticas do IAM, muitas ações permitem que você forneça um nome para os recursos específicos cujo acesso deseja controlar. For exemplo, a política a seguir permite que o usuário liste, leia e grave objetos no bucket do S3 `amzn-s3-demo-bucket` para projetos de `marketing`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:ListBucket"],
"Resource": ["arn:aws:s3:::amzn-s3-demo-bucket"],
"Condition": {"StringLike": {"s3:prefix": ["marketing/*"]}}
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject"
],
"Resource": ["arn:aws:s3:::amzn-s3-demo-bucket/marketing/*"]
}
]
}
```
------
Em alguns casos, talvez você saiba o nome exato do recurso ao elaborar a política. Talvez você queira generalizar a política para que ele funcione para muitos usuários sem a necessidade de fazer uma cópia exclusiva da política para cada usuário. Em vez de criar uma política específica para cada usuário, recomendamos criar uma única política de grupo que funcione para qualquer usuário desse grupo.
## Usar variáveis em políticas
É possível definir valores dinâmicos dentro das políticas usando *variáveis de política* que definem espaços reservados em uma política.
As variáveis são marcadas usando um prefixo **`$`** seguido por um par de chaves (**`{ }`**) que incluem o nome da variável do valor da solicitação.
Quando a política for avaliada, suas variáveis serão substituídas por valores provenientes das chaves de contexto condicionais passadas na solicitação. As variáveis podem ser usadas em [políticas baseadas em identidade, políticas de recursos, políticas de controle de serviços, políticas de sessão](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) e [políticas de endpoint da VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html). As políticas baseadas em identidade usadas como limites de permissões também são compatíveis com variáveis de política.
As chaves de contexto de condição globais podem ser usadas como variáveis em solicitações entre serviços da AWS. As chaves de condição específicas do serviço também podem ser usadas como variáveis ao interagir com recursos da AWS, mas só estão disponíveis quando as solicitações são baseadas em recursos compatíveis com elas. Para obter uma lista das chaves de contexto disponíveis para cada serviço e recurso da AWS, consulte a [https://docs.aws.amazon.com/service-authorization/latest/reference/reference.html](https://docs.aws.amazon.com/service-authorization/latest/reference/reference.html). Em certas circunstâncias, não é possível preencher chaves de contexto de condição globais com um valor. Para saber mais, consulte [Chaves de contexto de condição globais da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html).
**Importante**
Os nomes das chaves não diferenciam maiúsculas de minúsculas. Por exemplo, `aws:CurrentTime` equivale a `AWS:currenttime`.
É possível usar qualquer chave de condição de valor único disponível como uma variável. Você não pode usar uma chave de condição de valores múltiplos como uma variável.
O exemplo a seguir mostra uma política para um perfil ou usuário do IAM que substitui um nome do recurso específico por uma variável de política. Você pode reutilizar essa política aproveitando a chave de condição `aws:PrincipalTag`. Quando esta política é avaliada, `${aws:PrincipalTag/team}` permitirá ações somente se o nome do bucket terminar com o nome da equipe da tag `team` da entidade principal.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:ListBucket"],
"Resource": ["arn:aws:s3:::amzn-s3-demo-bucket"],
"Condition": {"StringLike": {"s3:prefix": ["${aws:PrincipalTag/team}/*"]}}
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject"
],
"Resource": ["arn:aws:s3:::amzn-s3-demo-bucket/${aws:PrincipalTag/team}/*"]
}
]
}
```
------
A variável é marcada usando um `$` prefixo seguido por um par de chaves (`{ }`). Dentro dos caracteres `${ }`, você pode incluir o nome do valor da solicitação que você deseja usar na política. Os valores que você pode usar serão abordados posteriormente nesta página.
Para obter uma lista desta chave de condição global, consulte [aws:PrincipalTag/*tag-key*](reference_policies_condition-keys.md#condition-keys-principaltag) na lista de chaves condição globais.
**nota**
Para usar variáveis de política, você deve incluir o elemento `Version` em uma instrução, e a versão deve ser definida como uma versão que oferece suporte às variáveis de política. As variáveis foram apresentadas na versão `2012-10-17`. Versões anteriores da linguagem da política não são compatíveis com variáveis de política. Se você não incluir o elemento `Version` e defini-lo como uma data de versão apropriada, variáveis como `${aws:username}` serão tratadas como strings literais na política.
Um elemento de política `Version` é diferente de uma versão de política. O elemento de política `Version` é usado em uma política e define a versão da linguagem da política. Uma versão da política, por outro lado, é criada quando você altera uma política gerenciada pelo cliente no IAM. A política alterada não substitui a política existente. Em vez disso, o IAM cria uma nova versão da política gerenciada. Para saber mais sobre o elemento de política `Version`, consulte [Elementos de política JSON do IAM: Version](reference_policies_elements_version.md). Para saber mais sobre as versões de política, consulte [Versionamento de políticas do IAM](access_policies_managed-versioning.md).
Uma política que permite que uma entidade principal obtenha objetos do caminho /David de um bucket do S3 tem a seguinte aparência:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/David/*"
]
}
]
}
```
------
Se essa política estiver anexada ao usuário `David`, esse usuário terá objetos do seu próprio bucket do S3, mas você teria que criar uma política específica para cada usuário que incluísse o nome do usuário. Você pode anexar cada política aos usuários individuais.
Ao usar uma variável de política, você pode criar políticas que podem ser reutilizadas. A política a seguir permite que um usuário obtenha objetos de um bucket do Amazon S3 se o valor da chave de tag `aws:PrincipalTag` corresponder ao valor da chave de tag `owner` passado na solicitação.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "AllowUnlessOwnedBySomeoneElse",
"Effect": "Allow",
"Action": ["s3:GetObject"],
"Resource": ["*"],
"Condition": {
"StringEquals": {
"s3:ExistingObjectTag/owner": "${aws:PrincipalTag/owner}"
}
}
}
]
}
```
------
Ao usar uma variável de política para um usuário dessa forma, você não precisa ter uma política específica para cada usuário individual. No exemplo a seguir, a política é anexada a um perfil do IAM que é assumido pelos gerentes de produto usando credenciais de segurança temporárias. Quando um usuário faz uma solicitação para adicionar um objeto do Amazon S3, o IAM substituísse o valor da tag `dept` da solicitação atual para a variável `${aws:PrincipalTag}` e avalia a política.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowOnlyDeptS3Prefix",
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/${aws:PrincipalTag/dept}/*"
]
}
]
}
```
------
## Tags como variáveis de política
Em alguns serviços da AWS que você pode anexar os próprios atributos personalizados a recursos criados por esses serviços. Por exemplo, você pode aplicar etiquetas a buckets do Amazon S3 ou a usuários do IAM. Essas tags são pares de chave-valor. Você define o nome da chave de tag e o valor associado ao nome dessa chave. Por exemplo, convém criar uma tag com uma chave **department** e um valor **Human Resources**. Para obter mais informações sobre como etiquetar entidades do IAM, consulte [Tags para recursos do AWS Identity and Access Management](id_tags.md). Para obter informações sobre como marcar recursos criados por outros serviços da AWS, consulte a documentação desse serviço. Para obter informações sobre como usar o Tag Editor, consulte [Trabalhar com o Tag Editor](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/tag-editor.html) no *Console de gerenciamento da AWS Guia do usuário*.
Você pode etiquetar recursos do IAM para simplificar a descoberta, a organização e o monitoramento de seus recursos do IAM. Você também pode etiquetar as identidades do IAM para controlar o acesso a recursos ou etiquetar a si mesmo. Para saber mais sobre como usar tags para controlar o acesso, consulte [Controle de acesso para usuários e funções do IAM usando etiquetas](access_iam-tags.md).
## Onde você pode usar variáveis de política
É possível usar variáveis de política no elemento `Resource` e em comparações de string no elemento `Condition`.
### Elemento de recursos
É possível usar uma variável de política no elemento `Resource`, mas somente na parte de recurso do ARN. Essa parte do ARN aparece após o quinto sinal de dois pontos (:). Não é possível usar uma variável para substituir partes do ARN antes do quinto sinal de dois pontos, como o serviço ou a conta. Para obter mais informações sobre o formato do ARN, consulte [ARNs do IAM](reference_identifiers.md#identifiers-arns).
Para substituir parte de um ARN com um valor de tag, coloque o prefixo e o nome da chave com `${ }`. Por exemplo, o elemento de Recurso a seguir se refere apenas a um bucket com o mesmo nome do valor na tag do usuário de solicitação.
`"Resource": ["arn:aws::s3:::amzn-s3-demo-bucket/${aws:PrincipalTag/department}"]`
Muitos recursos da AWS usam ARNs que contêm um nome criado pelo usuário. A política do IAM a seguir garante que somente os usuários pretendidos com valores de tag access-project, access-application e access-environment correspondentes possam modificar seus recursos. Além disso, usando [correspondências curingas \$1](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_resource.html), eles podem permitir sufixos de nomes de recursos personalizados.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowAccessBasedOnArnMatching",
"Effect": "Allow",
"Action": [
"sns:CreateTopic",
"sns:DeleteTopic"],
"Resource": ["arn:aws:sns:*:*:${aws:PrincipalTag/access-project}-${aws:PrincipalTag/access-application}-${aws:PrincipalTag/access-environment}-*"
]
}
]
}
```
------
### Elemento de condição
É possível usar uma variável de política para valores `Condition` em qualquer condição que envolva os operadores de string ou os operadores de ARN. Os operadores de string incluem `StringEquals`, `StringLike` e `StringNotLike`. Os operadores de ARN incluem `ArnEquals` e `ArnLike`. Não é possível usar uma variável de política com outros operadores, como os operadores `Numeric`, `Date`, `Boolean`, `Binary`, `IP Address` ou `Null`. Para obter mais informações sobre operadores de condição, consulte [Elementos de política JSON do IAM: operadores de condição](reference_policies_elements_condition_operators.md).
Ao fazer referência a uma tag em uma expressão do elemento `Condition`, use o prefixo relevante e o nome da chave de condição. Em seguida, use o valor que você deseja testar no valor da condição.
Por exemplo, o exemplo de política a seguir permite acesso total aos usuários, mas apenas se a tag `costCenter` estiver anexada ao usuário. A tag também deve ter um valor de `12345` ou `67890`. Se a tag não tiver valor, ou qualquer outro valor, a solicitação falhará.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:*user*"
],
"Resource": "*",
"Condition": {
"StringLike": {
"iam:ResourceTag/costCenter": [ "12345", "67890" ]
}
}
}
]
}
```
------
## Variáveis de política sem valor
Quando as variáveis de política fazem referência a uma chave de contexto de condição que não tem valor ou não está presente em um contexto de autorização para uma solicitação, o valor é efetivamente nulo. Não há valor igual ou semelhante. As chaves de contexto de condição podem não estar presentes no contexto de autorização quando:
+ Você está usando chaves de contexto de condição específicas do serviço em solicitações a recursos que não oferecem suporte a essa chave de condição.
+ As etiquetas em entidades principais, sessões, recursos ou solicitações do IAM não estão presentes.
+ Outras circunstâncias, conforme listadas para cada chave de contexto de condição global em [AWSChaves de contexto de condições globais da](reference_policies_condition-keys.md).
Quando você usa uma variável sem valor no elemento de condição de uma política do IAM, [Elementos de política JSON do IAM: operadores de condição](reference_policies_elements_condition_operators.md) como `StringEquals` ou `StringLike` não tem correspondência, e a instrução de política não entra em vigor.
Operadores de condição invertida como `StringNotEquals` ou `StringNotLike` correspondem a um valor nulo, pois o valor da chave de condição que serve de base para o teste não é igual ou semelhante ao valor efetivamente nulo.
Neste exemplo, `aws:principaltag/Team` deve ser igual a `s3:ExistingObjectTag/Team` para permitir o acesso. O acesso é explicitamente negado quando não `aws:principaltag/Team` está definido. Se uma variável sem valor no contexto de autorização for usada como parte do elemento `Resource` ou `NotResource` de uma política, o recurso que inclui uma variável de política sem valor não corresponderá a nenhum recurso.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Condition": {
"StringNotEquals": {
"s3:ExistingObjectTag/Team": "${aws:PrincipalTag/Team}"
}
}
}
]
}
```
------
## Solicitar informações que você pode usar para variáveis de política
É possível usar o elemento `Condition` de uma política JSON para comparar chaves no [contexto da solicitação](reference_policies_evaluation-logic_policy-eval-reqcontext.md) com os valores de chave especificados na política. Quando você usa uma variável de política, a AWS substitui um valor da chave de contexto de solicitação no lugar da variável na política.
### Valores de chave de principal
Os valores de `aws:username`, `aws:userid` e `aws:PrincipalType` dependem do tipo de principal que iniciou a solicitação. Por exemplo, a solicitação pode ser feita usando as credenciais de um usuário do IAM, um perfil do IAM ou o Usuário raiz da conta da AWS. A seguinte lista mostra valores para essas chaves de diferentes tipos de entidades principais.
****
| Entidade principal | `aws:username` | `aws:userid` | `aws:PrincipalType` |
| --- | --- | --- | --- |
| Usuário raiz da conta da AWS | (não está presente) | ID da Conta da AWS | Account |
| IAM user (Usuário do IAM) | IAM-user-name | [ID exclusivo](reference_identifiers.md#identifiers-unique-ids) | User |
| Entidade principal de usuário federado do AWS STS | (não está presente) | conta:caller-specified-name | FederatedUser |
| Entidade principal federada OIDC Para obter informações sobre as chaves de política que estão disponíveis ao usar federação de identidades da web, consulte [Chaves disponíveis para federação OIDC da AWS](reference_policies_iam-condition-keys.md#condition-keys-wif). | (não está presente) | *role-id*:*caller-specified-role-name* em que `role-id` é o [id exclusivo da função](reference_identifiers.md#identifiers-unique-ids) e caller-specified-role-name é especificado pelo [parâmetro RoleSessionName](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AssumeRole.html#API_AssumeRoleWithWebIdentity_RequestParameters) passado para a solicitação AssumeRoleWithWebIdentity. | AssumedRole |
| Entidade principal federada SAML Para obter informações sobre as chaves de política que estão disponíveis ao usar a federação SAML, consulte [Identificar exclusivamente os usuários na federação baseada em SAML](id_roles_providers_saml.md#CreatingSAML-userid). | (não está presente) | *role-id*:*caller-specified-role-name* em que `role-id` corrresponde ao [id exclusivo da função](reference_identifiers.md#identifiers-unique-ids) e o nome da função especificado pelo autor da chamada é especificado pelo elemento de atributo com o [atributo Name](id_roles_providers_create_saml_assertions.md) definido como https://aws.amazon.com/SAML/attributes/RoleSessionName. | AssumedRole |
| Função assumida | (não está presente) | *role-id*:*caller-specified-role-name* em que `role-id` é o [id exclusivo da função](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-unique-ids) e caller-specified-role-name é especificado pelo [parâmetro RoleSessionName](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html#API_AssumeRole_RequestParameters) passado para a solicitação AssumeRole. | AssumedRole |
| Função atribuída a uma instância do Amazon EC2 | (não está presente) | *role-id*:*ec2-instance-id* em que `role-id` é o [id exclusivo da função](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-unique-ids) e o ec2-instance-id é o [identificador exclusivo da instância do EC2](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html). | AssumedRole |
| Autor da chamada anônimo (somente Amazon SQS, Amazon SNS e Amazon S3) | (não está presente) | anonymous | Anonymous |
Para os itens nesta tabela, observe o seguinte:
+ *not present (não está presente)* significa que o valor não está nas informações da solicitação atual, e que qualquer tentativa de correspondê-lo falhará e fará com que a instrução seja invalidada.
+ *role-id* é um identificador exclusivo atribuído a cada função na criação. É possível exibir o ID da função com o comando da AWS CLI: `aws iam get-role --role-name rolename`
+ *caller-specified-name* e *caller-specified-role-name* são nomes que são passados pelo processo de chamada (como um aplicativo ou serviço) ao fazer uma chamada para obter credenciais temporárias.
+ *ec2-instance-id* é um valor atribuído à instância quando ela é iniciada e aparece na página **Instances** (Instâncias) do console do Amazon EC2. Também é possível exibir o ID da instância executando o comando da AWS CLI: `aws ec2 describe-instances`
### Informações disponíveis em solicitações para entidades principais federadas
Entidades principais federadas são usuários que são autenticados usando um sistema diferente do IAM. Por exemplo, uma empresa pode ter uma aplicação para uso interno que faz chamadas para a AWS. Pode ser impraticável fornecer uma identidade do IAM para cada usuário corporativo que use o aplicativo. Em vez disso, a empresa pode usar um aplicativo proxy (camada intermediária) que tem uma única identidade do IAM ou a empresa pode usar um provedor de identidade (IdP) SAML. O aplicativo proxy ou IdP SAML autentica usuários individuais usando a rede corporativa. Um aplicativo proxy pode usar sua identidade do IAM para obter credenciais de segurança temporárias para usuários individuais. Um IdP SAML pode, efetivamente, trocar informações de identidade por credenciais de segurança temporárias da AWS. As credenciais de segurança temporárias podem ser usadas para acessar os recursos da AWS.
Da mesma forma, você pode criar uma aplicação para um dispositivo móvel no qual ela precise acessar os recursos da AWS. Nesse caso, você pode usar a *federação OIDC*, em que a aplicação autentica o usuário usando um provedor de identidades conhecido, como Login with Amazon, Amazon Cognito, Facebook ou Google. A aplicação pode então usar as informações de autenticação do usuário desses provedores para obter credenciais de segurança temporárias para acessar recursos da AWS.
A maneira recomendada de usar a federação OIDC é aproveitando as vantagens oferecidas pelo Amazon Cognito e os SDKs móveis da AWS. Para saber mais, consulte:
+ [Guia do usuário do Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-identity.html)
+ [Cenários comuns para credenciais temporárias](id_credentials_temp.md#sts-introduction)
### Caracteres especiais
Há algumas variáveis de políticas predefinidas especiais com valores fixos que permitem representar caracteres que, de outra forma, têm um significado especial. Se esses caracteres especiais fizerem parte da string, você estiver tentando estabelecer uma correspondência e os inseriu literalmente, eles seriam mal-interpretados. Por exemplo, inserir um asterisco \$1 na string seria interpretado como curinga, fazendo correspondência com qualquer caractere, em vez de como um \$1 literal. Nesses casos, você pode usar as seguintes variáveis de política predefinidas:
+ **\$1\$1\$1\$1** - use quando precisar um asterisco (\$1).
+ **\$1\$1?\$1** - use quando precisar de um ponto de interrogação (?).
+ **\$1\$1\$1\$1** - use quando precisar de um caractere de cifrão (\$1).
Essas variáveis de política predefinidas podem ser usadas em qualquer string onde é possível usar variáveis de política normais.
## Especificação de valores padrão
Para adicionar um valor padrão a uma variável, coloque o valor padrão entre aspas simples (`' '`) e separe o texto da variável e o valor padrão com uma vírgula e espaço (`, `).
Por exemplo, se uma entidade principal estiver marcada com um `team=yellow`, é possível acessar o bucket do Amazon S3 da `ExampleCorp's` nomeado como `amzn-s3-demo-bucket-yellow`. Uma política com esse recurso permite que os membros da equipe acessem o bucket da própria equipe, mas não os de outras equipes. Para usuários sem etiquetas de equipe, ele define um valor padrão de `company-wide` para o nome do bucket. Esses usuários podem acessar somente o bucket `amzn-s3-demo-bucket-company-wide`, onde podem visualizar informações gerais, como instruções para ingressar em uma equipe.
```
"Resource":"arn:aws:s3:::amzn-s3-demo-bucket-${aws:PrincipalTag/team, 'company-wide'}"
```
## Para obter mais informações
Para obter mais informações sobre políticas, consulte o seguinte:
+ [Políticas e permissões no AWS Identity and Access Management](access_policies.md)
+ [Exemplos de políticas baseadas em identidade do IAM](access_policies_examples.md)
+ [Referência de elemento de política JSON do IAM](reference_policies_elements.md)
+ [Lógica da avaliação de política](reference_policies_evaluation-logic.md)
+ [Federação OIDC](id_roles_providers_oidc.md)
# Elementos de política JSON do IAM: tipos de dados compatíveis
Esta seção lista os tipos de dados compatíveis quando você especifica valores em políticas JSON. A linguagem da política não é compatível com todos os tipos para cada elemento de política; para obter informações sobre cada elemento, consulte as seções anteriores.
+ Strings
+ Números (Inteiros e floats)
+ Booleano
+ Null
+ Listas
+ Mapas
+ Estruturas (que são apenas mapas aninhados)
A tabela a seguir mapeia cada tipo de dado à serialização. Observe que todas as políticas devem estar em UTF-8. Para obter informações sobre os tipos de dados JSON, consulte [RFC 4627](https://datatracker.ietf.org/doc/html/rfc4627).
****
| Tipo | JSON |
| --- | --- |
| String | String |
| Inteiro | Número |
| Float | Número |
| Booleano | verdadeiro falso |
| Null | nulo |
| Data | String aderindo ao [perfil W3C da ISO 8601](http://www.w3.org/TR/NOTE-datetime) |
| IpAddress | String aderindo a [RFC 4632](https://datatracker.ietf.org/doc/html/rfc4632) |
| Lista | Array |
| Objeto | Objeto |