# Identity and Access Management para o Amazon EC2
O AWS Identity and Access Management (IAM) é um serviço da AWS service (Serviço da AWS) que ajuda um administrador a controlar com segurança o acesso aos recursos da AWS. Os administradores do IAM controlam quem pode ser *autenticado* (conectado) e *autorizado* (tem permissões) a usar os recursos do Amazon EC2. O IAM é um AWS service (Serviço da AWS) que pode ser usado sem custo adicional.
As credenciais de segurança identificam você para os serviços na AWS e concedem acesso aos recursos da AWS, como os recursos do Amazon EC2. É possível usar os recursos do Amazon EC2 e do IAM para permitir que outros usuários, serviços e aplicações usem seus recursos do Amazon EC2 sem compartilhar suas credenciais de segurança. É possível usar o IAM para controlar como outros usuários usam recursos na Conta da AWS, e pode usar grupos de segurança para controlar o acesso às instâncias do Amazon EC2. É possível optar por permitir uso completo ou limitado dos recursos do Amazon EC2.
Caso seja um desenvolvedor, será possível usar os perfis do IAM para gerenciar as credenciais de segurança necessárias para as aplicações que você executa nas instâncias do EC2. Depois de anexar um perfil do IAM à sua instância, as aplicações em execução na instância podem recuperar as credenciais do serviço de metadados de instância (IMDS).
Para conhecer as práticas recomendadas de proteção dos recursos da AWS usando o IAM, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*.
**Topics**
+ [
# Políticas baseadas em identidade do Amazon EC2
](iam-policies-for-amazon-ec2.md)
+ [
# Exemplo de políticas para controlar o acesso à API do Amazon EC2
](ExamplePolicies_EC2.md)
+ [
# Exemplo de políticas para controlar o acesso ao console do Amazon EC2
](iam-policies-ec2-console.md)
+ [
# Políticas gerenciadas pela AWS para o Amazon EC2
](security-iam-awsmanpol.md)
+ [
# Funções do IAM para Amazon EC2
](iam-roles-for-amazon-ec2.md)
# Políticas baseadas em identidade do Amazon EC2
Por padrão, os usuários não têm permissão para criar ou modificar recursos do Amazon EC2 ou para executar tarefas usando a API do Amazon EC2, o colsole do Amazon EC2 ou a CLI. Para permitir que os usuários criem ou modifiquem recursos e realizem tarefas, você precisa criar políticas do IAM que concedam aos usuários do permissão para usar os recursos específicos e as ações de API de que precisam e, então, anexar essas políticas aos usuários ou grupos, ou perfis do IAM que exijam essas permissões.
Quando você anexa uma política a um usuário, um grupo de usuários ou um perfil, isso concede ou nega aos usuários permissão para realizar as tarefas especificadas nos recursos especificados. Para obter mais informações gerais sobre as políticas do IAM, consulte [Permissões e políticas no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) no *Guia do usuário do IAM*. Para obter mais informações sobre o gerenciamento e a criação de políticas do IAM;, consulte [Gerenciamento de políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html).
Uma política do IAM deve conceder ou negar permissões para usar uma ou mais ações do Amazon EC2. Ela também deve especificar os recursos que podem ser usados com a ação, que podem ser todos os recursos ou, em alguns casos, recursos específicos. A política também pode incluir condições que você aplica ao recurso.
Para começar a usar, você pode verificar se as políticas gerenciadas pela AWS para o Amazon EC2 atendem às suas necessidades. Caso contrário, você pode criar suas próprias políticas personalizadas. Para obter mais informações, consulte [Políticas gerenciadas pela AWS para o Amazon EC2](security-iam-awsmanpol.md).
**Topics**
+ [
## Sintaxe da política
](#policy-syntax)
+ [
## Ações do Amazon EC2
](#UsingWithEC2_Actions)
+ [
## Permissões no nível do recurso com suporte para ações de API do Amazon EC2
](#ec2-supported-iam-actions-resources)
+ [
## Nomes de recurso da Amazon (ARNs) para o Amazon EC2
](#EC2_ARN_Format)
+ [
## Chaves de condição do Amazon EC2
](#amazon-ec2-keys)
+ [
## Controlar o acesso usando acesso baseado em atributos
](#control-access-with-tags)
+ [
## Conceder permissões a usuários, grupos e perfis
](#granting-iam-permissions)
+ [
## Verificar se os usuários têm as permissões necessárias
](#check-required-permissions)
## Sintaxe da política
A política do IAM é um documento JSON que consiste em uma ou mais declarações. Cada instrução é estruturada da maneira a seguir.
```
{
"Statement":[{
"Effect":"effect",
"Action":"action",
"Resource":"arn",
"Condition":{
"condition":{
"key":"value"
}
}
}
]
}
```
Existem vários elementos que compõem uma instrução:
+ **Efeito:** o *efeito* pode ser `Allow` ou `Deny`. Por padrão, os usuários não têm permissão para usar recursos e ações da API. Por isso, todas as solicitações são negadas. Uma permissão explícita substitui o padrão. Uma negação explícita substitui todas as permissões.
+ **Action**: a *ação* é a ação de API específica para a qual você está concedendo ou negando permissão. Para conhecer como especificar *ação*, consulte [Ações do Amazon EC2](#UsingWithEC2_Actions).
+ **Resource**: o recurso afetado pela ação. Algumas ações de API do Amazon EC2 permitem incluir recursos específicos na política que podem ser criados ou modificados pela ação. Você especifica um recurso usando um nome de recurso da Amazon (ARN) ou usando o caractere curinga (\$1) para indicar que a instrução se aplica a todos os recursos. Para obter mais informações, consulte [Permissões no nível do recurso com suporte para ações de API do Amazon EC2](#ec2-supported-iam-actions-resources).
+ **Condition**: condições são opcionais. Elas podem ser usadas para controlar quando a política está em vigor. Para obter mais informações sobre como especificar condições para o Amazon EC2, consulte [Chaves de condição do Amazon EC2](#amazon-ec2-keys).
Para obter mais informações sobre requisitos de políticas, consulte a [Referência de política JSON do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html) no *Guia do usuário do IAM*. Para obter um exemplo de declarações de políticas do IAM para o Amazon EC2, consulte [Exemplo de políticas para controlar o acesso à API do Amazon EC2](ExamplePolicies_EC2.md).
## Ações do Amazon EC2
Em uma declaração de política do IAM, é possível especificar qualquer ação de API de qualquer serviço que dê suporte ao IAM. Para o Amazon EC2, use o seguinte prefixo com o nome da ação da API: `ec2:`. Por exemplo: `ec2:RunInstances` e `ec2:CreateImage`.
Para especificar várias ações em uma única declaração, separe-as com vírgulas, conforme o seguinte:
```
"Action": ["ec2:action1", "ec2:action2"]
```
Também é possível especificar várias ações usando caracteres curinga. Por exemplo, é possível especificar todas as ações cujo nome começa com a palavra "Describe" da seguinte forma:
```
"Action": "ec2:Describe*"
```
**nota**
No momento, as ações de API do Amazon EC2 não são compatíveis com permissões em nível de recurso. Para obter mais informações sobre permissões no nível do recurso para o Amazon EC2, consulte [Políticas baseadas em identidade do Amazon EC2](#iam-policies-for-amazon-ec2).
Para especificar todas as ações de API do Amazon EC2, use o curinga "\$1" da seguinte maneira:
```
"Action": "ec2:*"
```
Para obter uma lista de ações de Amazon EC2, consulte [Ações definidas pelo Amazon EC2](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonec2.html#amazonec2-actions-as-permissions) na *Referência de autorização do serviço*.
## Permissões no nível do recurso com suporte para ações de API do Amazon EC2
*Permissões no nível do recurso* se referem à capacidade de especificar em quais recursos os usuários têm permissão para realizar ações. O Amazon EC2 tem suporte parcial para permissões no nível do recurso. Isso significa que, para determinadas ações do Amazon EC2, é possível controlar quando os usuários têm permissão para usar essas ações com base em condições que precisam ser concluídas, ou em recursos específicos que os usuários têm permissão para usar. Por exemplo, é possível conceder aos usuários permissões para ativar instâncias, mas apenas de um tipo específico, e usando uma AMI específica.
Para especificar um recurso em uma declaração de política do IAM, use o respectivo nome de recurso da Amazon (ARN). Para obter mais informações sobre como especificar o valor do ARN, consulte [Nomes de recurso da Amazon (ARNs) para o Amazon EC2](#EC2_ARN_Format). Se uma ação de API não oferecer suporte a ARNs individuais, você deverá usar um curinga (\$1) para especificar que todos os recursos podem ser afetados pela ação.
Para visualizar tabelas que identificam quais ações de API do Amazon EC2 oferecem suporte a permissões no nível do recurso e os ARNs e chaves de condição que é possível usar em uma política, consulte [Ações, recursos e chaves de condição do Amazon EC2](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonec2.html) .
Lembre-se de que é possível aplicar permissões em nível de recurso baseadas em tags às políticas do IAM que você usa para a maioria das ações da API do Amazon EC2. Isso oferece a você mais controle sobre quais recursos o usuário pode criar, modificar ou usar. Para obter mais informações, consulte [Conceder permissão para marcar recursos do Amazon EC2 durante a criação](supported-iam-actions-tagging.md).
## Nomes de recurso da Amazon (ARNs) para o Amazon EC2
Cada declaração de política do IAM se aplica aos recursos que você especifica usando os ARNs.
Um ARN tem a seguinte sintaxe geral:
```
arn:aws:[service]:[region]:[account-id]:resourceType/resourcePath
```
*service*
O serviço (por exemplo, `ec2`).
*region*
A região do recurso (por exemplo, `us-east-1`).
*account-id*
O ID da conta da AWS, sem hifens (por exemplo, `123456789012`).
*resourceType*
O tipo de recurso (por exemplo, `instance`).
*resourcePath*
Um caminho que identifica o recurso. É possível usar o curinga \$1 nos caminhos.
Por exemplo, é possível indicar uma instância específica (`i-1234567890abcdef0`) na declaração usando o ARN da maneira a seguir.
```
"Resource": "arn:aws:ec2:us-east-1:123456789012:instance/i-1234567890abcdef0"
```
É possível especificar todas as instâncias pertencentes a uma conta específica usando o caractere curinga \$1 da maneira a seguir.
```
"Resource": "arn:aws:ec2:us-east-1:123456789012:instance/*"
```
Também é possível especificar todos os recursos do Amazon EC2 pertencentes a uma conta específica usando o caractere curinga \$1 da maneira a seguir.
```
"Resource": "arn:aws:ec2:us-east-1:123456789012:*"
```
Para especificar todos os recursos ou caso uma ação de API específica não dê suporte a ARNs, use o curinga \$1 no elemento `Resource` da maneira a seguir.
```
"Resource": "*"
```
Muitas ações da API do Amazon EC2 envolvem vários recursos. Por exemplo, `AttachVolume` anexa um volume do Amazon EBS a uma instância, portanto, um usuário precisa ter permissões para usar o volume e a instância. Para especificar vários recursos em uma única instrução, separe seus ARNs com vírgulas, como se segue.
```
"Resource": ["arn1", "arn2"]
```
Para obter uma lista de ARNs para recursos do Amazon EC2, consulte [Tipos de recursos definidos pelo Amazon EC2](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonec2.html#amazonec2-resources-for-iam-policies).
## Chaves de condição do Amazon EC2
Ema uma instrução de política, também é possível especificar condições que controlam quando ela entrará em vigor. Cada condição contém um ou mais pares de chave-valor. As chaves de condição não diferenciam maiúsculas de minúsculas. Definimos chaves de condição global da AWS, além de chaves de condição específicas do serviço adicionais.
Para obter uma lista de chaves de condição específicas do serviço para o Amazon EC2, consulte [Condition keys for Amazon EC2 (Chaves de condição para o Amazon EC2)](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonec2.html#amazonec2-policy-keys). O Amazon EC2 também implementa as chaves de condição globais da AWS. Para obter mais informações, consulte [Informações disponíveis em todas as solicitações](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html#policy-vars-infoallreqs) no *Guia do usuário do IAM*.
Todas as ações do Amazon EC2 oferecem suporte às chaves de condição `aws:RequestedRegion` e `ec2:Region`. Para obter mais informações, consulte [Exemplo: restringir acesso a uma região específica](ExamplePolicies_EC2.md#iam-example-region).
Para usar uma chave de condição em sua política do IAM, use a instrução `Condition`. Por exemplo, a política a seguir concede aos usuários permissão para adicionar e remover regras de entrada e saída para qualquer grupo de segurança. Ela usa a chave de condição `ec2:Vpc` para especificar que essas ações só podem ser executadas em grupos de segurança em uma VPC específica.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[{
"Effect":"Allow",
"Action": [
"ec2:AuthorizeSecurityGroupIngress",
"ec2:AuthorizeSecurityGroupEgress",
"ec2:RevokeSecurityGroupIngress",
"ec2:RevokeSecurityGroupEgress"],
"Resource": "arn:aws:ec2:us-east-1:111122223333:security-group/*",
"Condition": {
"StringEquals": {
"ec2:Vpc": "arn:aws:ec2:us-east-1:111122223333:vpc/vpc-11223344556677889"
}
}
}
]
}
```
------
Caso você especifique várias condições ou várias chaves em uma única condição, avaliamos essas condições usando uma operação AND lógica. Caso você especifique uma única condição com vários valores para uma chave, avaliamos a condição usando uma operação OR lógica. Para que as permissões sejam concedidas, todas as condições devem ser atendidas.
Também é possível usar espaços reservados quando especifica as condições. Para obter mais informações, consulte [Elementos de política do IAM: variáveis e tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html) no *Guia do usuário do IAM*.
**Importante**
Muitas chaves de condição são específicas a um recurso, e algumas ações da API usam vários recursos. Se você gravar uma política com uma chave de condição, use o elemento `Resource` da declaração para especificar o recurso ao qual a chave de condição se aplica. Caso contrário, as políticas podem impedir que os usuários executem a ação, porque a verificação da condição falha para os recursos aos quais a chave de condição não se aplica. Se você não quiser especificar um recurso, ou se escreveu o elemento `Action` da política para incluir várias ações da API, será necessário usar o tipo de condição `...IfExists` para garantir que a chave de condição seja ignorada pelos recursos que não a usam. Para obter mais informações, consulte [Condições ...IfExists](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#Conditions_IfExists) no *Guia do usuário do IAM*.
**Topics**
+ [
### ec2:AttributeChave da condição
](#attribute-key)
+ [
### ec2:ResourceIDChaves de condição do
](#imageId-key)
+ [
### ec2:SourceInstanceARNChave da condição
](#SourceInstanceARN)
### ec2:AttributeChave da condição
A chave de condição `ec2:Attribute` pode ser usada para condições que filtram o acesso por um atributo de um recurso.
A chave de condição é compatível somente com propriedades de um tipo de dados primitivos (como strings ou inteiros) ou objetos **[AttributeValue](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AttributeValue.html)** complexos que contêm apenas uma propriedade **Value** (como os objetos **Description** ou **ImdsSupport** da ação [ModifyImageAttribute](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyImageAttribute.html) da API). A chave de condição não pode ser usada com objetos complexos que contêm várias propriedades, como o objeto **LaunchPermission** da ação[ModifyImageAttribute](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyImageAttribute.html) da API.
Por exemplo, a política a seguir usa a chave de condição `ec2:Attribute/Description` para filtrar o acesso pelo objeto complexo **Descrição** da ação da API **ModifyImageAttribute**. A chave de condição permite somente solicitações que modifiquem a descrição de uma imagem para `Production` ou `Development`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:ModifyImageAttribute",
"Resource": "arn:aws:ec2:us-east-1::image/ami-*",
"Condition": {
"StringEquals": {
"ec2:Attribute/Description": [
"Production",
"Development"
]
}
}
}
]
}
```
------
A política a seguir usa a chave de condição `ec2:Attribute` para filtrar o acesso pela propriedade primitiva **Atributo** da ação da API **ModifyImageAttribute**. A chave de condição recusa todas as solicitações que tentam modificar a descrição de uma imagem.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "ec2:ModifyImageAttribute",
"Resource": "arn:aws:ec2:us-east-1::image/ami-*",
"Condition": {
"StringEquals": {
"ec2:Attribute": "Description"
}
}
}
]
}
```
------
### ec2:ResourceIDChaves de condição do
Quando as chaves de condição `ec2:ResourceID` a seguir forem usadas com as ações de API especificadas, o valor da chave de condição será usado para especificar o recurso resultante criado pela ação da API. As chaves de condição `ec2:ResourceID` não podem ser usadas para especificar um recurso de origem especificado na solicitação da API. Se você usar uma das chaves de condição `ec2:ResourceID` a seguir com uma API especificada, será necessário especificar sempre o curinga (`*`). Se você especificar um valor diferente, a condição sempre será resolvida para `*` em runtime. Por exemplo, para usar a chave de condição `ec2:ImageId` com a API **CopyImage**, será necessário especificar a chave de condição da seguinte forma:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:CopyImage",
"Resource": "arn:aws:ec2:us-east-1::image/ami-*",
"Condition": {
"StringEquals": {
"ec2:ImageID": "*"
}
}
}
]
}
```
------
Recomendamos evitar usar estas chaves de condição com estas ações de API:
+ `ec2:DhcpOptionsID` – `CreateDhcpOptions`
+ `ec2:ImageID` – `CopyImage`, `CreateImage`, `ImportImage` e `RegisterImage`
+ `ec2:InstanceID` – `RunInstances` e `ImportInstance`
+ `ec2:InternetGatewayID` – `CreateInternetGateway`
+ `ec2:NetworkAclID` – `CreateNetworkAcl`
+ `ec2:NetworkInterfaceID` – `CreateNetworkInterface`
+ `ec2:PlacementGroupName` – `CreatePlacementGroup`
+ `ec2:RouteTableID` – `CreateRouteTable`
+ `ec2:SecurityGroupID` – `CreateSecurityGroup`
+ `ec2:SnapshotID` – `CopySnapshot`, `CreateSnapshot`, `CreateSnapshots` e `ImportSnapshots`
+ `ec2:SubnetID` – `CreateSubnet`
+ `ec2:VolumeID` – `CreateVolume` e `ImportVolume`
+ `ec2:VpcID` – `CreateVpc`
+ `ec2:VpcPeeringConnectionID` – `CreateVpcPeeringConnection`
Para filtrar o acesso com base em IDs de recursos específicos, recomendamos usar o elemento de política `Resource` conforme descrito a seguir.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:CopyImage",
"Resource": "arn:aws:ec2:us-east-1::image/ami-01234567890abcdef"
}
]
}
```
------
### ec2:SourceInstanceARNChave da condição
Use `ec2:SourceInstanceARN` para especificar o ARN da instância a partir da qual uma solicitação é feita. Essa é uma [chave de condição global da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html), o que significa que é possíve usá-la com outros serviços além do Amazon EC2. Para ver um exemplo de política, consulte [Exemplo: permitir que uma instância específica visualize recursos em outros serviços da AWS](ExamplePolicies_EC2.md#iam-example-source-instance).
## Controlar o acesso usando acesso baseado em atributos
Ao criar uma política do IAM que conceda permissão aos usuários para usar recursos do EC2, é possível incluir informações de tag no elemento `Condition` da política para controlar o acesso com base em tags. Isso é conhecido como controle de acesso baseado em atributo (ABAC). O ABAC oferece um controle melhor sobre quais recursos um usuário pode modificar, usar ou excluir. Para obter mais informações, consulte [O que é ABAC para a AWS?](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html)
Por exemplo, é possível criar uma política que permite que os usuários encerrem uma instância, mas nega a ação se a instância tiver a tag `environment=production`. Para fazer isso, use a chave de condição `aws:ResourceTag` para permitir ou negar acesso ao recurso com base nas tags anexadas ao recurso.
```
"StringEquals": { "aws:ResourceTag/environment": "production" }
```
Para saber se uma ação de API do Amazon EC2 oferece suporte ao controle de acesso usando a chave de condição `aws:ResourceTag`, consulte [Ações, recursos e chaves de condição para Amazon EC2](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonec2.html) . Como as ações de `Describe` não oferecem suporte a permissões em nível de recurso, especifique-as em uma declaração separada sem condições.
Para obter exemplos de políticas do IAM, consulte [Exemplo de políticas para controlar o acesso à API do Amazon EC2](ExamplePolicies_EC2.md).
Se você permitir ou negar aos usuários o acesso a recursos com base em tags, considere negar explicitamente aos usuários a capacidade de adicionar essas tags ou removê-las dos mesmos recursos. Caso contrário, é possível que um usuário contorne suas restrições e obtenha acesso a um recurso modificando as tags.
## Conceder permissões a usuários, grupos e perfis
Para conceder acesso, adicione as permissões aos seus usuários, grupos ou perfis:
+ Usuários e grupos no Centro de Identidade do AWS IAM:
Crie um conjunto de permissões. Siga as instruções em [Criação de um conjunto de permissões](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) no *Guia do usuário do Centro de Identidade do AWS IAM*.
+ Usuários gerenciados no IAM com provedor de identidades:
Crie um perfil para a federação de identidades. Siga as instruções em [Criando um perfil para um provedor de identidades de terceiros (federação)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) no *Guia do Usuário do IAM*.
+ Usuários do IAM:
+ Crie um perfil que seu usuário possa assumir. Siga as instruções em [Criação de um perfil para um usuário do IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) no *Guia do usuário do IAM*.
+ (Não recomendado) Vincule uma política diretamente a um usuário ou adicione um usuário a um grupo de usuários. Siga as instruções em [Adição de permissões a um usuário (console)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) no *Guia do usuário do IAM*.
## Verificar se os usuários têm as permissões necessárias
Depois que você tiver criado uma política do IAM, recomendaremos verificar se ela concede aos usuários as permissões para usar as ações de API e os recursos específicos de que eles precisam antes de colocar a política em produção.
Primeiro, crie um usuário para fins de teste e anexe a política do IAM que você criou ao usuário de teste. Em seguia, faça uma solicitação como o usuário de teste.
Se a ação do Amazon EC2 que você estiver testando criar ou modificar um recurso, será necessário fazer a solicitação usando o parâmetro `DryRun` (ou executar o comando da AWS CLI com a opção `--dry-run`). Nesse caso, a chamada conclui a verificação da autorização, mas não conclui a operação. Por exemplo, é possível verificar se o usuário pode encerrar uma determinada instância sem efetivamente encerrá-la. Caso o usuário de teste tenha as permissões obrigatórias, a solicitação retorna `DryRunOperation`. Do contrário, ela retorna `UnauthorizedOperation`.
Caso a política não conceda ao usuário as permissões que você esperava ou caso ela seja muito permissiva, é possível ajustar a política conforme necessário e testá-la novamente até obter os resultados desejados.
**Importante**
Pode levar alguns minutos para que as alterações de política sejam propagadas até entrarem em vigor. Por isso, recomendamos que você aguarde cinco minutos antes de testar as atualizações da política.
Caso uma verificação de autorização falhe, a solicitação retorna uma mensagem codificada com informações de diagnóstico. É possível decodificar a mensagem usando a ação `DecodeAuthorizationMessage`. Para obter mais informações, consulte [DecodeAuthorizationMessage](https://docs.aws.amazon.com/STS/latest/APIReference/API_DecodeAuthorizationMessage.html) na *Referência de API do AWS Security Token Service* e [decode-authorization-message](https://docs.aws.amazon.com/cli/latest/reference/sts/decode-authorization-message.html).
# Exemplo de políticas para controlar o acesso à API do Amazon EC2
É possível usar as políticas do IAM para conceder aos usuários as permissões necessárias para que eles trabalhem com o Amazon EC2. Para obter instruções detalhadas, consulte [Criação de políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) no *Guia do usuário do IAM*.
Os exemplos a seguir mostram declarações de políticas que você pode usar para conceder aos usuários as permissões para o uso do Amazon EC2. Essas políticas são criadas para solicitações feitas com a AWS CLI ou com o AWS SDK. Nos exemplos a seguir, substitua cada *espaço reservado* por suas próprias informações.
**Topics**
+ [Acesso somente leitura](#iam-example-read-only)
+ [Restringir acesso a uma região específica](#iam-example-region)
+ [Trabalhar com instâncias](#iam-example-instances)
+ [Executar instâncias (RunInstances)](#iam-example-runinstances)
+ [
## Trabalhar com Instâncias spot
](#iam-example-spot-instances)
+ [Trabalhar com Instâncias reservadas](#iam-example-reservedinstances)
+ [Marcar recursos](#iam-example-taggingresources)
+ [Trabalhar com funções do IAM](#iam-example-iam-roles)
+ [Trabalhar com tabelas de rotas](#iam-example-route-tables)
+ [Permitir que uma instância específica visualize recursos em outros serviços da AWS](#iam-example-source-instance)
+ [Trabalhar com modelos de execução](#iam-example-launch-templates)
+ [Trabalhar com metadados de instância](#iam-example-instance-metadata)
+ [
## Trabalhar com volumes e snapshots do Amazon EBS
](#iam-example-ebs)
Para obter exemplos de políticas para trabalhar no console do Amazon EC2, consulte [Exemplo de políticas para controlar o acesso ao console do Amazon EC2](iam-policies-ec2-console.md).
## Exemplo: acesso somente leitura
A política a seguir concede aos usuários permissões para utilizar todas as ações da API do Amazon EC2 cujos nomes começam com `Describe`. O elemento `Resource` usa um caractere curinga para indicar que os usuários podem especificar todos os recursos com essas ações da API. O caractere curinga \$1 também é necessário em casos onde a ação da API não é compatível com as permissões em nível de recurso. Para obter mais informações sobre quais ARNs é possível usar com quais ações de API do Amazon EC2, consulte [Ações, recursos e chaves de condição do Amazon EC2 no ](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonec2.html).
Os usuários não têm permissão para executar nenhuma ação nos recursos (a menos que outra declaração conceda a eles permissão para fazer isso) porque, por padrão, a permissão para usar ações da API é negada para os usuários.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:Describe*",
"Resource": "*"
}
]
}
```
------
## Exemplo: restringir acesso a uma região específica
A política a seguir nega permissão aos usuários para uso de todas as ações da API do Amazon EC2 a menos que a região seja a Europa (Frankfurt). Ela usa a chave de condição global `aws:RequestedRegion`, que é compatível com todas as ações da API do Amazon EC2.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "ec2:*",
"Resource": "*",
"Condition": {
"StringNotEquals": {
"aws:RequestedRegion": "eu-central-1"
}
}
}
]
}
```
------
Como alternativa, é possível usar a chave de condição `ec2:Region`, que é específica ao Amazon EC2 e é compatível com todas as ações da API do Amazon EC2.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "ec2:*",
"Resource": "*",
"Condition": {
"StringNotEquals": {
"ec2:Region": "eu-central-1"
}
}
}
]
}
```
------
## Trabalhar com instâncias
**Topics**
+ [
### Exemplo: descrever, executar, interromper, iniciar e encerrar todas as instâncias
](#iam-example-instances-all)
+ [
### Exemplo: descrever todas as instâncias e interromper, iniciar e encerrar somente instâncias específicas
](#iam-example-instances-specific)
### Exemplo: descrever, executar, interromper, iniciar e encerrar todas as instâncias
A política a seguir concede aos usuários permissões para utilizar as ações da API especificadas no elemento `Action`. O elemento `Resource` usa um caractere curinga \$1 para indicar que os usuários podem especificar todos os recursos com essas ações da API. O caractere curinga \$1 também é necessário em casos onde a ação da API não é compatível com as permissões em nível de recurso. Para obter mais informações sobre quais ARNs é possível usar com quais ações de API do Amazon EC2, consulte [Ações, recursos e chaves de condição do Amazon EC2 no ](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonec2.html).
Os usuários não têm permissão para usar qualquer outra ação da API (a menos que outra declaração conceda a eles permissão para fazer isso) porque, por padrão, a permissão para usar ações da API são negadas para os usuários.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeInstances",
"ec2:DescribeImages",
"ec2:DescribeKeyPairs",
"ec2:DescribeSecurityGroups",
"ec2:DescribeAvailabilityZones",
"ec2:RunInstances",
"ec2:TerminateInstances",
"ec2:StopInstances",
"ec2:StartInstances"
],
"Resource": "*"
}
]
}
```
------
### Exemplo: descrever todas as instâncias e interromper, iniciar e encerrar somente instâncias específicas
A política a seguir permite que os usuários descrevam todas as instâncias, iniciem e parem somente as instâncias i-1234567890abcdef0 e i-0598c7d356eba48d7 e encerrem somente instâncias na região `us-east-1` com a tag de recurso "`purpose=test`".
A primeira declaração usa um caractere curinga \$1 para o elemento `Resource` para indicar que os usuários podem especificar todos os recursos com a ação. Nesse caso, os usuários podem listar todas as instâncias. O caractere curinga \$1 também é necessário em casos onde a ação da API não é compatível com permissões em nível de recurso (nesse caso, `ec2:DescribeInstances`). Para obter mais informações sobre quais ARNs é possível usar com quais ações de API do Amazon EC2, consulte [Ações, recursos e chaves de condição do Amazon EC2 no ](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonec2.html).
A segunda declaração usa permissões em nível de recurso para as ações `StopInstances` e `StartInstances`. As instâncias específicas são indicadas por seus ARNs no elemento `Resource`.
A terceira declaração permite que os usuários encerrem todas as instâncias em na região `us-east-1` que pertencem à conta da AWS especificada, mas somente quando a instância tiver a tag `"purpose=test"`. O elemento `Condition` qualifica quando a declaração de política está em vigor.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:DescribeInstances",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ec2:StopInstances",
"ec2:StartInstances"
],
"Resource": [
"arn:aws:ec2:us-east-1:111122223333:instance/i-1234567890abcdef0",
"arn:aws:ec2:us-east-1:111122223333:instance/i-0598c7d356eba48d7"
]
},
{
"Effect": "Allow",
"Action": "ec2:TerminateInstances",
"Resource": "arn:aws:ec2:us-east-1:111122223333:instance/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/purpose": "test"
}
}
}
]
}
```
------
## Executar instâncias (RunInstances)
A ação da API [RunInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html) inicia uma ou mais Instâncias on-demand ou uma ou mais Instâncias spot. `RunInstances` requer uma AMI e cria uma instância. Os usuários podem especificar um par de chaves e um grupo de segurança na solicitação. A inicialização em uma VPC requer uma sub-rede, e cria uma interface de rede. A inicialização de uma AMI baseada no Amazon EBS cria um volume. Portanto, o usuário deve ter permissões para usar esses recursos do Amazon EC2. É possível criar um declaração de política que exija que os usuários especifiquem um parâmetro opcional em `RunInstances` ou restringir os usuários a valores específicos para um parâmetro.
Para obter mais informações sobre as permissões em nível de recurso que são necessárias para executar uma instância, consulte [Ações, recursos e chaves de condição do Amazon EC2 no ](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonec2.html).
Observe que, por padrão, os usuários não têm permissões para descrever, iniciar, interromper ou encerrar as instâncias resultantes. Uma maneira de conceder aos usuários permissão para gerenciar as instâncias resultantes é criar uma tag específica para cada instância e criar uma declaração que permita que eles gerenciem instâncias com aquela tag. Para obter mais informações, consulte [Trabalhar com instâncias](#iam-example-instances).
**Topics**
+ [
### AMIs
](#iam-example-runinstances-ami)
+ [
### Tipos de instância
](#iam-example-runinstances-instance-type)
+ [
### Sub-redes
](#iam-example-runinstances-subnet)
+ [
### Volumes do EBS
](#iam-example-runinstances-volumes)
+ [
### Tags
](#iam-example-runinstances-tags)
+ [
### Tags em um modelo de execução
](#iam-example-tags-launch-template)
+ [
### GPUs elásticas
](#iam-example-runinstances-egpu)
+ [
### Modelos de execução
](#iam-example-runinstances-launch-templates)
### AMIs
A política a seguir permite que os usuários iniciem instâncias usando apenas as AMIs especificadas, `ami-9e1670f7` e `ami-45cf5c3c`. Os usuários não podem executar uma instância usando outras AMIs (a menos que outra declaração conceda permissão para os usuários fazerem isso).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": [
"arn:aws:ec2:us-east-1::image/ami-9e1670f7",
"arn:aws:ec2:us-east-1::image/ami-45cf5c3c",
"arn:aws:ec2:us-east-1:111122223333:instance/*",
"arn:aws:ec2:us-east-1:111122223333:volume/*",
"arn:aws:ec2:us-east-1:111122223333:key-pair/*",
"arn:aws:ec2:us-east-1:111122223333:security-group/*",
"arn:aws:ec2:us-east-1:111122223333:subnet/*",
"arn:aws:ec2:us-east-1:111122223333:network-interface/*"
]
}
]
}
```
------
Como alternativa, a política a seguir permite que os usuários executem instâncias em todas as AMIs pertencentes à Amazon ou a determinados parceiros confiáveis e verificados. O elemento `Condition` da primeira declaração testa se `ec2:Owner` é `amazon`. Os usuários não podem executar uma instância usando outras AMIs (a menos que outra declaração conceda permissão para os usuários fazerem isso).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": [
"arn:aws:ec2:us-east-1::image/ami-*"
],
"Condition": {
"StringEquals": {
"ec2:Owner": "amazon"
}
}
},
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": [
"arn:aws:ec2:us-east-1:111122223333:instance/*",
"arn:aws:ec2:us-east-1:111122223333:subnet/*",
"arn:aws:ec2:us-east-1:111122223333:volume/*",
"arn:aws:ec2:us-east-1:111122223333:network-interface/*",
"arn:aws:ec2:us-east-1:111122223333:key-pair/*",
"arn:aws:ec2:us-east-1:111122223333:security-group/*"
]
}
]
}
```
------
### Tipos de instância
A política a seguir permite que os usuários executem instâncias usando somente o tipo de instância `t2.micro` ou `t2.small`, o que é possível fazer para controlar os custos. Os usuários não podem executar instâncias maiores porque o elemento `Condition` da primeira declaração testa se `ec2:InstanceType` é `t2.micro` ou `t2.small`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": [
"arn:aws:ec2:us-east-1:111122223333:instance/*"
],
"Condition": {
"StringEquals": {
"ec2:InstanceType": ["t2.micro", "t2.small"]
}
}
},
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": [
"arn:aws:ec2:us-east-1::image/ami-*",
"arn:aws:ec2:us-east-1:111122223333:subnet/*",
"arn:aws:ec2:us-east-1:111122223333:network-interface/*",
"arn:aws:ec2:us-east-1:111122223333:volume/*",
"arn:aws:ec2:us-east-1:111122223333:key-pair/*",
"arn:aws:ec2:us-east-1:111122223333:security-group/*"
]
}
]
}
```
------
Se desejar, é possível criar uma política que negue aos usuários permissões para executar qualquer instância, com exceção dos tipos de instância `t2.micro` e `t2.small`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "ec2:RunInstances",
"Resource": [
"arn:aws:ec2:us-east-1:111122223333:instance/*"
],
"Condition": {
"StringNotEquals": {
"ec2:InstanceType": ["t2.micro", "t2.small"]
}
}
},
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": [
"arn:aws:ec2:us-east-1::image/ami-*",
"arn:aws:ec2:us-east-1:111122223333:network-interface/*",
"arn:aws:ec2:us-east-1:111122223333:instance/*",
"arn:aws:ec2:us-east-1:111122223333:subnet/*",
"arn:aws:ec2:us-east-1:111122223333:volume/*",
"arn:aws:ec2:us-east-1:111122223333:key-pair/*",
"arn:aws:ec2:us-east-1:111122223333:security-group/*"
]
}
]
}
```
------
### Sub-redes
A política a seguir permite que os usuários executem instâncias usando apenas a sub-rede especificada, `subnet-12345678`. O grupo não pode executar instâncias em outra sub-rede (a menos que outra declaração conceda permissão para os usuários fazerem isso).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": [
"arn:aws:ec2:us-east-1:111122223333:subnet/subnet-12345678",
"arn:aws:ec2:us-east-1:111122223333:network-interface/*",
"arn:aws:ec2:us-east-1:111122223333:instance/*",
"arn:aws:ec2:us-east-1:111122223333:volume/*",
"arn:aws:ec2:us-east-1::image/ami-*",
"arn:aws:ec2:us-east-1:111122223333:key-pair/*",
"arn:aws:ec2:us-east-1:111122223333:security-group/*"
]
}
]
}
```
------
Se desejar, é possível criar uma política que negue aos usuários permissões para executar uma instância em qualquer outra sub-rede. A declaração faz isso negando permissão para criar uma interface de rede, exceto quando a sub-rede `subnet-12345678` for especificada. Essa negação substitui qualquer outra política criada para permitir a execução de instâncias em outras sub-redes.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "ec2:RunInstances",
"Resource": [
"arn:aws:ec2:us-east-1:111122223333:network-interface/*"
],
"Condition": {
"ArnNotEquals": {
"ec2:Subnet": "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-12345678"
}
}
},
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": [
"arn:aws:ec2:us-east-1::image/ami-*",
"arn:aws:ec2:us-east-1:111122223333:network-interface/*",
"arn:aws:ec2:us-east-1:111122223333:instance/*",
"arn:aws:ec2:us-east-1:111122223333:subnet/*",
"arn:aws:ec2:us-east-1:111122223333:volume/*",
"arn:aws:ec2:us-east-1:111122223333:key-pair/*",
"arn:aws:ec2:us-east-1:111122223333:security-group/*"
]
}
]
}
```
------
### Volumes do EBS
A política a seguir permite que os usuários executem instâncias somente se os volumes do EBS para a instância estiverem criptografados. O usuário deve executar uma instância em uma AMI criada com snapshots criptografados, para garantir que o volume raiz esteja criptografado. Qualquer volume adicional que o usuário anexe à instância durante a execução também deve estar criptografado.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": [
"arn:aws:ec2:*:*:volume/*"
],
"Condition": {
"Bool": {
"ec2:Encrypted": "true"
}
}
},
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": [
"arn:aws:ec2:*::image/ami-*",
"arn:aws:ec2:*:*:network-interface/*",
"arn:aws:ec2:*:*:instance/*",
"arn:aws:ec2:*:*:subnet/*",
"arn:aws:ec2:*:*:key-pair/*",
"arn:aws:ec2:*:*:security-group/*"
]
}
]
}
```
------
### Tags
**Marque instâncias na criação**
A política a seguir permite que os usuários executem instâncias e as marquem durante a criação. Para ações de criação de recursos que aplicam tags, os usuários devem ter permissões para usar a ação `CreateTags`. A segunda declaração usa a chave de condição `ec2:CreateAction` para permitir que os usuários criem tags somente no contexto de `RunInstances` e somente para instâncias. Os usuários não podem marcar recursos existentes e não podem marcar volumes usando a solicitação `RunInstances`.
Para obter mais informações, consulte [Conceder permissão para marcar recursos do Amazon EC2 durante a criação](supported-iam-actions-tagging.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:RunInstances"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateTags"
],
"Resource": "arn:aws:ec2:us-east-1:111122223333:instance/*",
"Condition": {
"StringEquals": {
"ec2:CreateAction" : "RunInstances"
}
}
}
]
}
```
------
**Marque instâncias e volumes na criação com tags específicas**
As política a seguir inclui a chave de condição `aws:RequestTag` que requer que os usuários marquem todas as instâncias e os volumes criados por `RunInstances` com as tags `environment=production` e `purpose=webserver`. Se os usuários não passarem essas tags específicas ou não especificarem nenhuma tag, haverá talha na solicitação.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:RunInstances"
],
"Resource": [
"arn:aws:ec2:us-east-1::image/*",
"arn:aws:ec2:us-east-1:111122223333:subnet/*",
"arn:aws:ec2:us-east-1:111122223333:network-interface/*",
"arn:aws:ec2:us-east-1:111122223333:security-group/*",
"arn:aws:ec2:us-east-1:111122223333:key-pair/*"
]
},
{
"Effect": "Allow",
"Action": [
"ec2:RunInstances"
],
"Resource": [
"arn:aws:ec2:us-east-1:111122223333:volume/*",
"arn:aws:ec2:us-east-1:111122223333:instance/*"
],
"Condition": {
"StringEquals": {
"aws:RequestTag/environment": "production" ,
"aws:RequestTag/purpose": "webserver"
}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateTags"
],
"Resource": "arn:aws:ec2:us-east-1:111122223333:*/*",
"Condition": {
"StringEquals": {
"ec2:CreateAction" : "RunInstances"
}
}
}
]
}
```
------
**Marque instâncias e volumes na criação com pelo menos uma tag específica**
A política a seguir usa o modificador `ForAnyValue` na condição `aws:TagKeys` para indicar que pelo menos uma tag deve ser especificada na solicitação e deve conter a chave `environment` ou `webserver`. A tag deve ser aplicada a instâncias e a volumes. Qualquer valor de tag pode ser especificado na solicitação.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:RunInstances"
],
"Resource": [
"arn:aws:ec2:us-east-1::image/*",
"arn:aws:ec2:us-east-1:111122223333:subnet/*",
"arn:aws:ec2:us-east-1:111122223333:network-interface/*",
"arn:aws:ec2:us-east-1:111122223333:security-group/*",
"arn:aws:ec2:us-east-1:111122223333:key-pair/*"
]
},
{
"Effect": "Allow",
"Action": [
"ec2:RunInstances"
],
"Resource": [
"arn:aws:ec2:us-east-1:111122223333:volume/*",
"arn:aws:ec2:us-east-1:111122223333:instance/*"
],
"Condition": {
"ForAnyValue:StringEquals": {
"aws:TagKeys": ["environment","webserver"]
}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateTags"
],
"Resource": "arn:aws:ec2:us-east-1:111122223333:*/*",
"Condition": {
"StringEquals": {
"ec2:CreateAction" : "RunInstances"
}
}
}
]
}
```
------
**Se forem marcadas na criação, as instâncias deverão ser marcadas com uma tag específica**
Na política a seguir, os usuários não precisam especificar tags na solicitação, mas se o fizerem, a tag deverá ser `purpose=test`. Nenhuma outra tag é permitida. Os usuários podem aplicar as tags a qualquer recurso marcável na solicitação `RunInstances`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:RunInstances"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateTags"
],
"Resource": "arn:aws:ec2:us-east-1:111122223333:*/*",
"Condition": {
"StringEquals": {
"aws:RequestTag/purpose": "test",
"ec2:CreateAction" : "RunInstances"
},
"ForAllValues:StringEquals": {
"aws:TagKeys": "purpose"
}
}
}
]
}
```
------
Para não permitir que ninguém adicione tags na criação para RunInstances
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowRun",
"Effect": "Allow",
"Action": [
"ec2:RunInstances"
],
"Resource": [
"arn:aws:ec2:us-east-1::image/*",
"arn:aws:ec2:us-east-1:*:subnet/*",
"arn:aws:ec2:us-east-1:*:network-interface/*",
"arn:aws:ec2:us-east-1:*:security-group/*",
"arn:aws:ec2:us-east-1:*:key-pair/*",
"arn:aws:ec2:us-east-1:*:volume/*",
"arn:aws:ec2:us-east-1:*:instance/*",
"arn:aws:ec2:us-east-1:*:spot-instances-request/*"
]
},
{
"Effect": "Deny",
"Action": "ec2:CreateTags",
"Resource": "*"
}
]
}
```
------
Permitir apenas tags específicas para spot-instances-request. A inconsistência surpresa número 2 entra em jogo aqui. Em circunstâncias normais, não especificar tag alguma resultará em Não autenticado. No caso de spot-instances-request, esta política não será avaliada se não houver tags spot-instances-request, portanto, uma solicitação Spot on Run sem tag será bem-sucedida.
### Tags em um modelo de execução
No exemplo a seguir, os usuários poderão executar instâncias, mas apenas se usarem um modelo de execução específico (`lt-09477bcd97b0d310e`). A chave de condição `ec2:IsLaunchTemplateResource` impede que os usuários substituam alguns recursos especificados no modelo de execução. A segunda parte da instrução permite que os usuários marquem instâncias durante a criação; essa parte da instrução será necessária se as tags forem especificadas para a instância no modelo de execução.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": "*",
"Condition": {
"ArnLike": {
"ec2:LaunchTemplate": "arn:aws:ec2:us-east-1:111122223333:launch-template/lt-09477bcd97b0d310e"
},
"Bool": {
"ec2:IsLaunchTemplateResource": "true"
}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateTags"
],
"Resource": "arn:aws:ec2:us-east-1:111122223333:instance/*",
"Condition": {
"StringEquals": {
"ec2:CreateAction" : "RunInstances"
}
}
}
]
}
```
------
### GPUs elásticas
Na política a seguir, os usuários podem executar uma instância e especificar uma GPU elástica para anexar à instância. Os usuários podem executar instâncias em qualquer região, mas só podem anexar uma GPU elástica durante uma execução na região `us-east-2`.
A chave de condição `ec2:ElasticGpuType` garante que as instâncias usem o tipo de GPU elástico `eg1.medium` ou `eg1.large`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:RunInstances"
],
"Resource": [
"arn:aws:ec2:*:111122223333:elastic-gpu/*"
],
"Condition": {
"StringEquals": {
"ec2:Region": "us-east-2",
"ec2:ElasticGpuType": [
"eg1.medium",
"eg1.large"
]
}
}
},
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": [
"arn:aws:ec2:*::image/ami-*",
"arn:aws:ec2:*:111122223333:network-interface/*",
"arn:aws:ec2:*:111122223333:instance/*",
"arn:aws:ec2:*:111122223333:subnet/*",
"arn:aws:ec2:*:111122223333:volume/*",
"arn:aws:ec2:*:111122223333:key-pair/*",
"arn:aws:ec2:*:111122223333:security-group/*"
]
}
]
}
```
------
### Modelos de execução
No exemplo a seguir, os usuários poderão executar instâncias, mas apenas se usarem um modelo de execução específico (`lt-09477bcd97b0d310e`). Os usuários podem substituir quaisquer parâmetros no modelo de execução especificando os parâmetros na ação `RunInstances`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": "*",
"Condition": {
"ArnLike": {
"ec2:LaunchTemplate": "arn:aws:ec2:us-east-1:111122223333:launch-template/lt-09477bcd97b0d310e"
}
}
}
]
}
```
------
Neste exemplo, os usuários poderão executar instâncias apenas se usarem um modelo de execução. A política usa a chave de condição `ec2:IsLaunchTemplateResource` para impedir que os usuários substituam os ARNs pré-existentes no modelo de execução.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": "*",
"Condition": {
"ArnLike": {
"ec2:LaunchTemplate": "arn:aws:ec2:us-east-1:111122223333:launch-template/*"
},
"Bool": {
"ec2:IsLaunchTemplateResource": "true"
}
}
}
]
}
```
------
No exemplo a seguir, a política permitirá que o usuário execute instâncias, mas apenas se usarem um modelo de execução. Os usuários não podem substituir os parâmetros de interface de rede e sub-rede na solicitação; esses parâmetros só podem ser especificados no modelo de execução. A primeira parte da instrução usa o elemento [NotResource](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_notresource.html) para permitir todos os outros recursos, exceto interfaces de rede e sub-redes. A segunda parte da instrução permite recursos de interface de rede e sub-rede, mas somente se eles forem originários do modelo de execução.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"NotResource": ["arn:aws:ec2:us-east-1:111122223333:subnet/*",
"arn:aws:ec2:us-east-1:111122223333:network-interface/*" ],
"Condition": {
"ArnLike": {
"ec2:LaunchTemplate": "arn:aws:ec2:us-east-1:111122223333:launch-template/*"
}
}
},
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": ["arn:aws:ec2:us-east-1:111122223333:subnet/*",
"arn:aws:ec2:us-east-1:111122223333:network-interface/*" ],
"Condition": {
"ArnLike": {
"ec2:LaunchTemplate": "arn:aws:ec2:us-east-1:111122223333:launch-template/*"
},
"Bool": {
"ec2:IsLaunchTemplateResource": "true"
}
}
}
]
}
```
------
O exemplo a seguir permitirá que os usuários executem instâncias somente se usarem um modelo de execução, e somente se o modelo de execução tiver a tag `Purpose=Webservers`. Os usuários não podem substituir nenhum dos parâmetros do modelo de execução na ação `RunInstances`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"NotResource": "arn:aws:ec2:us-east-1:111122223333:launch-template/*",
"Condition": {
"ArnLike": {
"ec2:LaunchTemplate": "arn:aws:ec2:us-east-1:111122223333:launch-template/*"
},
"Bool": {
"ec2:IsLaunchTemplateResource": "true"
}
}
},
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": "arn:aws:ec2:us-east-1:111122223333:launch-template/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Purpose": "Webservers"
}
}
}
]
}
```
------
## Trabalhar com Instâncias spot
É possível usar a ação RunInstances para criar solicitações de instância spot e marcar solicitações de instância spot na criação. O recurso a ser especificado para RunInstances é `spot-instances-request`.
O recurso `spot-instances-request` é avaliado na política do IAM da seguinte forma:
+ Se você não marcar uma solicitação de instância spot na criação, o Amazon EC2 não avaliará o recurso `spot-instances-request` na instrução RunInstances.
+ Se você marcar uma solicitação de instância spot na criação, o Amazon EC2 avaliará o recurso `spot-instances-request` na instrução RunInstances.
Portanto, para o recurso `spot-instances-request`, as seguintes regras se aplicam à diretiva do IAM:
+ Caso você use RunInstances para criar uma solicitação de instância spot e não pretenda marcar a solicitação de instância spot na criação, não será necessário permitir explicitamente o recurso `spot-instances-request`. A chamada terá êxito.
+ Caso use RunInstances para criar uma solicitação de instância spot e pretenda marcar a solicitação de instância spot na criação, será necessário incluir o recurso `spot-instances-request` na instrução de permissão RunInstances, caso contrário, a chamada falhará.
+ Caso você use RunInstances para criar uma solicitação de instância spot e pretenda marcar a solicitação de instância spot na criação, especifique o recurso `spot-instances-request` ou um curinga `*` na instrução de permissão CreateTags, caso contrário, a chamada falhará.
É possível solicitar Instâncias spot usando RunInstances ou RequestSpotInstances. Os exemplos de políticas do IAM a seguir se aplicam somente ao solicitar Instâncias spot usando RunInstances.
**Exemplo: solicitar Instâncias spot usando RunInstances**
A política a seguir permite que os usuários solicitem Instâncias spot usando a ação RunInstances. O recurso `spot-instances-request`, que é criado por RunInstances, solicita Instâncias spot.
**nota**
Para usar RunInstances a fim de criar solicitações de instância spot, é possível omitir `spot-instances-request` da lista `Resource` caso pretenda marcar as solicitações de instância spot na criação. Isso ocorre porque o Amazon EC2 não avalia o recurso `spot-instances-request` na instrução RunInstances se a solicitação de instância spot não estiver marcada na criação.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowRun",
"Effect": "Allow",
"Action": [
"ec2:RunInstances"
],
"Resource": [
"arn:aws:ec2:us-east-1::image/*",
"arn:aws:ec2:us-east-1:*:subnet/*",
"arn:aws:ec2:us-east-1:*:network-interface/*",
"arn:aws:ec2:us-east-1:*:security-group/*",
"arn:aws:ec2:us-east-1:*:key-pair/*",
"arn:aws:ec2:us-east-1:*:volume/*",
"arn:aws:ec2:us-east-1:*:instance/*",
"arn:aws:ec2:us-east-1:*:spot-instances-request/*"
]
}
]
}
```
------
**Atenção**
**NÃO COMPATÍVEL – Exemplo: negar permissão aos usuários para solicitar Instâncias spot usando RunInstances**
A política a seguir não é compatível com o recurso `spot-instances-request`.
A política a seguir destina-se a conceder permissão aos usuários para iniciar Instâncias on-demand, mas negar a permissão de solicitação Instâncias spot. O recurso `spot-instances-request`, criado por RunInstances, é o recurso que solicita Instâncias spot. A segunda instrução destina-se a negar a ação RunInstances para o recurso `spot-instances-request`. No entanto, esta condição não é compatível porque o Amazon EC2 não avalia o recurso `spot-instances-request` na instrução RunInstances se a solicitação de instância spot não estiver marcada na criação.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowRun",
"Effect": "Allow",
"Action": [
"ec2:RunInstances"
],
"Resource": [
"arn:aws:ec2:us-east-1::image/*",
"arn:aws:ec2:us-east-1:*:subnet/*",
"arn:aws:ec2:us-east-1:*:network-interface/*",
"arn:aws:ec2:us-east-1:*:security-group/*",
"arn:aws:ec2:us-east-1:*:key-pair/*",
"arn:aws:ec2:us-east-1:*:volume/*",
"arn:aws:ec2:us-east-1:*:instance/*"
]
},
{
"Sid": "DenySpotInstancesRequestsNOTSUPPORTEDDONOTUSE",
"Effect": "Deny",
"Action": "ec2:RunInstances",
"Resource": "arn:aws:ec2:us-east-1:*:spot-instances-request/*"
}
]
}
```
**Exemplo: marcar solicitações de instância spot na criação**
A política a seguir permite que os usuários marquem todos os recursos criados durante o lançamento da instância. A primeira instrução permite que RunInstances crie os recursos listados. O recurso `spot-instances-request`, criado por RunInstances, é o recurso que solicita Instâncias spot. A segunda instrução fornece um curinga `*` para permitir que todos os recursos sejam marcados quando criados no momento da execução da instância.
**nota**
Se você marcar uma solicitação de instância spot na criação, o Amazon EC2 avaliará o recurso `spot-instances-request` na instrução RunInstances. Portanto, permita explicitamente o recurso `spot-instances-request` para a ação RunInstances, caso contrário, a chamada falhará.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowRun",
"Effect": "Allow",
"Action": [
"ec2:RunInstances"
],
"Resource": [
"arn:aws:ec2:us-east-1::image/*",
"arn:aws:ec2:us-east-1:*:subnet/*",
"arn:aws:ec2:us-east-1:*:network-interface/*",
"arn:aws:ec2:us-east-1:*:security-group/*",
"arn:aws:ec2:us-east-1:*:key-pair/*",
"arn:aws:ec2:us-east-1:*:volume/*",
"arn:aws:ec2:us-east-1:*:instance/*",
"arn:aws:ec2:us-east-1:*:spot-instances-request/*"
]
},
{
"Sid": "TagResources",
"Effect": "Allow",
"Action": "ec2:CreateTags",
"Resource": "*"
}
]
}
```
------
**Exemplo: negar marcações na criação para solicitações de instância spot**
A política a seguir nega aos usuários a permissão para marcar os recursos criados durante a execução da instância.
A primeira instrução permite que RunInstances crie os recursos listados. O recurso `spot-instances-request`, criado por RunInstances, é o recurso que solicita Instâncias spot. A segunda instrução fornece um curinga `*` para evitar que todos os recursos sejam marcados, quando criados, no momento da execução da instância. Se `spot-instances-request` ou qualquer outro recurso estiver marcado na criação, a chamada RunInstances falhará.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowRun",
"Effect": "Allow",
"Action": [
"ec2:RunInstances"
],
"Resource": [
"arn:aws:ec2:us-east-1::image/*",
"arn:aws:ec2:us-east-1:*:subnet/*",
"arn:aws:ec2:us-east-1:*:network-interface/*",
"arn:aws:ec2:us-east-1:*:security-group/*",
"arn:aws:ec2:us-east-1:*:key-pair/*",
"arn:aws:ec2:us-east-1:*:volume/*",
"arn:aws:ec2:us-east-1:*:instance/*",
"arn:aws:ec2:us-east-1:*:spot-instances-request/*"
]
},
{
"Sid": "DenyTagResources",
"Effect": "Deny",
"Action": "ec2:CreateTags",
"Resource": "*"
}
]
}
```
------
**Atenção**
**NÃO COMPATÍVEL – Exemplo: permitir a criação de uma solicitação de instância spot apenas se lhe for atribuída uma etiqueta específica**
A política a seguir não é compatível com o recurso `spot-instances-request`.
A política a seguir destina-se a conceder permissão à RunInstances para criar uma solicitação de instância spot somente se a solicitação for marcada com uma tag específica.
A primeira instrução permite que RunInstances crie os recursos listados.
A segunda instrução destina-se a conceder permissão aos usuários para criar uma solicitação de instância spot somente se a solicitação tiver a etiqueta `environment=production`. Se essa condição for aplicada a outros recursos criados por RunInstances, não especificar nenhuma tag gerará um erro `Unauthenticated`. No entanto, se nenhuma etiqueta for especificada para a solicitação de instância spot, o Amazon EC2 não avaliará o recurso `spot-instances-request` na instrução RunInstances, o que resultará em solicitações de instância spot não marcadas sendo criadas pela RunInstances.
Observe que especificar outra etiqueta, além de `environment=production` gera um erro `Unauthenticated`, pois se um usuário marca uma solicitação de instância spot, o Amazon EC2 avalia o recurso `spot-instances-request` na instrução RunInstances.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowRun",
"Effect": "Allow",
"Action": [
"ec2:RunInstances"
],
"Resource": [
"arn:aws:ec2:us-east-1::image/*",
"arn:aws:ec2:us-east-1:*:subnet/*",
"arn:aws:ec2:us-east-1:*:network-interface/*",
"arn:aws:ec2:us-east-1:*:security-group/*",
"arn:aws:ec2:us-east-1:*:key-pair/*",
"arn:aws:ec2:us-east-1:*:volume/*",
"arn:aws:ec2:us-east-1:*:instance/*"
]
},
{
"Sid": "RequestSpotInstancesOnlyIfTagIsEnvironmentProductionNOTSUPPORTEDDONOTUSE",
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": "arn:aws:ec2:us-east-1:*:spot-instances-request/*",
"Condition": {
"StringEquals": {
"aws:RequestTag/environment": "production"
}
}
},
{
"Sid": "TagResources",
"Effect": "Allow",
"Action": "ec2:CreateTags",
"Resource": "*"
}
]
}
```
**Exemplo: negar a criação de uma solicitação de instância spot se lhe for atribuída uma etiqueta específica**
A política a seguir nega à RunInstances a permissão para criar uma solicitação de instância spot se a solicitação estiver marcada com `environment=production`.
A primeira instrução permite que RunInstances crie os recursos listados.
A segunda instrução nega permissão aos usuários para criar uma solicitação de instância spot se a solicitação tiver a etiqueta `environment=production`. Especificar `environment=production` como tag gerará um erro `Unauthenticated`. Especificar outras tags ou não especificar tags resultará na criação de uma solicitação de instância spot.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowRun",
"Effect": "Allow",
"Action": [
"ec2:RunInstances"
],
"Resource": [
"arn:aws:ec2:us-east-1::image/*",
"arn:aws:ec2:us-east-1:*:subnet/*",
"arn:aws:ec2:us-east-1:*:network-interface/*",
"arn:aws:ec2:us-east-1:*:security-group/*",
"arn:aws:ec2:us-east-1:*:key-pair/*",
"arn:aws:ec2:us-east-1:*:volume/*",
"arn:aws:ec2:us-east-1:*:instance/*",
"arn:aws:ec2:us-east-1:*:spot-instances-request/*"
]
},
{
"Sid": "DenySpotInstancesRequests",
"Effect": "Deny",
"Action": "ec2:RunInstances",
"Resource": "arn:aws:ec2:us-east-1:*:spot-instances-request/*",
"Condition": {
"StringEquals": {
"aws:RequestTag/environment": "production"
}
}
},
{
"Sid": "TagResources",
"Effect": "Allow",
"Action": "ec2:CreateTags",
"Resource": "*"
}
]
}
```
------
## Exemplo: trabalhar com Instâncias reservadas
A política a seguir concede aos usuários permissão para visualizar, modificar e comprar Instâncias reservadas na sua conta.
Não é possível definir permissões em nível de recurso para instâncias reservadas. Essa política significa que os usuários têm acesso a todas as Instâncias reservadas na conta.
O elemento `Resource` usa um caractere curinga \$1 para indicar que os usuários podem especificar todos os recursos com a ação. Nesse caso, os usuários podem listar e modificar todas as Instâncias reservadas na conta. Eles também podem comprar Instâncias reservadas usando as credenciais da conta. O caractere curinga \$1 também é necessário em casos onde a ação da API não é compatível com as permissões em nível de recurso.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeReservedInstances",
"ec2:ModifyReservedInstances",
"ec2:PurchaseReservedInstancesOffering",
"ec2:DescribeAvailabilityZones",
"ec2:DescribeReservedInstancesOfferings"
],
"Resource": "*"
}
]
}
```
------
Para permitir que os usuários exibam e modifiquem as Instâncias reservadas na conta, mas não comprem novas Instâncias reservadas.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeReservedInstances",
"ec2:ModifyReservedInstances",
"ec2:DescribeAvailabilityZones"
],
"Resource": "*"
}
]
}
```
------
## Exemplo: marcar recursos
A política a seguir permite que os usuários usem a ação `CreateTags` para aplicar tags a uma instância somente se a tag contiver a chave `environment` e o valor `production`. Nenhuma outra tag é permitida, e o usuário não pode aplicar tags em nenhum outro tipo de recurso.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CreateTags"
],
"Resource": "arn:aws:ec2:us-east-1:111122223333:instance/*",
"Condition": {
"StringEquals": {
"aws:RequestTag/environment": "production"
}
}
}
]
}
```
------
A política a seguir permite que os usuários marquem qualquer recurso marcável que já tenha uma tag com a chave `owner` e um valor do nome de usuário. Além disso, os usuários devem especificar uma tag com uma chave de `anycompany:environment-type` e um valor de `test` ou de `prod` na solicitação. Os usuários podem especificar tags adicionais na solicitação.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CreateTags"
],
"Resource": "arn:aws:ec2:us-east-1:111122223333:*/*",
"Condition": {
"StringEquals": {
"aws:RequestTag/anycompany:environment-type": ["test","prod"],
"aws:ResourceTag/owner": "${aws:username}"
}
}
}
]
}
```
------
É possível criar uma política do IAM que permite que os usuários excluam tags específicas de um recurso. Por exemplo, a política a seguir permite que os usuários excluam tags de um volume se as chaves das tags especificadas na solicitação forem `environment` ou `cost-center`. Qualquer valor pode ser especificado para a tag, mas a chave da tag deve corresponder a uma das chaves especificadas.
**nota**
Se você excluir um recurso, todas as tags associadas ao recurso também serão excluídas. Os usuários não precisam de permissões para utilizar a ação `ec2:DeleteTags` para excluir um recurso que tenha tags. Eles precisam apenas das permissões para executar a ação de exclusão.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:DeleteTags",
"Resource": "arn:aws:ec2:us-east-1:111122223333:volume/*",
"Condition": {
"ForAllValues:StringEquals": {
"aws:TagKeys": ["environment","cost-center"]
}
}
}
]
}
```
------
Essa política permite que os usuários excluam somente a tag `environment=prod` em qualquer recurso e apenas se o recurso já estiver marcado com a chave do `owner` e com um valor do nome de usuário. Os usuários não podem excluir nenhuma outra tag de um recurso.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DeleteTags"
],
"Resource": "arn:aws:ec2:us-east-1:111122223333:*/*",
"Condition": {
"StringEquals": {
"aws:RequestTag/environment": "prod",
"aws:ResourceTag/owner": "${aws:username}"
},
"ForAllValues:StringEquals": {
"aws:TagKeys": ["environment"]
}
}
}
]
}
```
------
## Exemplo: trabalhar com funções do IAM
A política a seguir permite que os usuários anexem, substituam e desanexem uma função do IAM para instâncias que tenham a tag `department=test`. As substituição ou a desanexação de uma função do IAM requer um ID de associação, portanto, a política também concede aos usuários permissão para usar a ação `ec2:DescribeIamInstanceProfileAssociations`.
Os usuários devem ter permissão para usar a ação `iam:PassRole` para passar o perfil para a instância.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:AssociateIamInstanceProfile",
"ec2:ReplaceIamInstanceProfileAssociation",
"ec2:DisassociateIamInstanceProfile"
],
"Resource": "arn:aws:ec2:us-east-1:111122223333:instance/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/department":"test"
}
}
},
{
"Effect": "Allow",
"Action": "ec2:DescribeIamInstanceProfileAssociations",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::111122223333:role/DevTeam*"
}
]
}
```
------
A política a seguir permite que os usuários anexem ou substituam uma função do IAM para qualquer instância. Os usuários podem anexar ou substituir apenas funções do IAM com nomes que começam com `TestRole-`. Para a ação `iam:PassRole`, especifique o nome da função do IAM e não o perfil da instância (se os nomes forem diferentes). Para obter mais informações, consulte [Perfis de instância](iam-roles-for-amazon-ec2.md#ec2-instance-profile).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:AssociateIamInstanceProfile",
"ec2:ReplaceIamInstanceProfileAssociation"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "ec2:DescribeIamInstanceProfileAssociations",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::111122223333:role/TestRole-*"
}
]
}
```
------
## Exemplo: trabalhar com tabelas de rotas
A política a seguir permite aos usuários adicionar, remover e substituir rotas em tabelas de rotas associadas à VPC `vpc-ec43eb89` somente. Para especificar uma VPC para a chave de condição `ec2:Vpc`, especifique o ARN total da VPC.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DeleteRoute",
"ec2:CreateRoute",
"ec2:ReplaceRoute"
],
"Resource": [
"arn:aws:ec2:us-east-1:111122223333:route-table/*"
],
"Condition": {
"StringEquals": {
"ec2:Vpc": "arn:aws:ec2:us-east-1:111122223333:vpc/vpc-ec43eb89"
}
}
}
]
}
```
------
## Exemplo: permitir que uma instância específica visualize recursos em outros serviços da AWS
O exemplo a seguir é de uma política que é possível anexar a uma função do IAM. A política permite que uma instância exiba recursos em vários serviços da AWS. Ela usa a chave de condição global `ec2:SourceInstanceARN` para especificar que a instância na qual a solicitação é feita deve ser a instância `i-093452212644b0dd6`. Se a mesma função do IAM estiver associada a outra instância, a outra instância não poderá executar nenhuma dessas ações.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeVolumes",
"s3:ListAllMyBuckets",
"dynamodb:ListTables",
"rds:DescribeDBInstances"
],
"Resource": [
"*"
],
"Condition": {
"ArnEquals": {
"ec2:SourceInstanceARN": "arn:aws:ec2:us-east-1:111122223333:instance/i-093452212644b0dd6"
}
}
}
]
}
```
------
## Exemplo: trabalhar com modelos de execução
A política a seguir permite que os usuários criem uma versão de modelo de execução e alterem um modelo de execução, mas somente um modelo de execução específico (`lt-09477bcd97b0d3abc`). Os usuários não podem trabalhar com outros modelos de execução.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ec2:CreateLaunchTemplateVersion",
"ec2:ModifyLaunchTemplate"
],
"Effect": "Allow",
"Resource": "arn:aws:ec2:us-east-1:111122223333:launch-template/lt-09477bcd97b0d3abc"
}
]
}
```
------
A política a seguir permite que os usuários excluam qualquer modelo de execução e versão de modelo de execução, desde que o modelo tenha a tag `Purpose`=`Testing`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ec2:DeleteLaunchTemplate",
"ec2:DeleteLaunchTemplateVersions"
],
"Effect": "Allow",
"Resource": "arn:aws:ec2:us-east-1:111122223333:launch-template/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Purpose": "Testing"
}
}
}
]
}
```
------
## Trabalhar com metadados de instância
As políticas a seguir garantem que os usuários possam recuperar somente [metadados de instância](ec2-instance-metadata.md) usando o Serviço de metadados da instância versão 2 (IMDSv2). É possível combinar as quatro políticas a seguir em uma única política com quatro instruções. Quando combinadas como uma única política, é possível usar a política como uma política de controle de serviços (SCP). Ela pode funcionar tão bem como uma política de *negação* aplicada a uma política existente do IAM (retirando e limitando a permissão existente) ou como uma SCP aplicada globalmente em uma conta, uma unidade organizacional (UO) ou uma organização inteira.
**nota**
As seguintes políticas de opções de metadados de RunInstances devem ser usadas em conjunto com uma política que concede ao principal permissões para executar uma instância com RunInstances. Se o principal também não tiver permissões para RunInstances, não poderá executar uma instância. Para obter mais informações, consulte as políticas em [Trabalhar com instâncias](#iam-example-instances) e [Executar instâncias (RunInstances)](#iam-example-runinstances).
**Importante**
Se você usar grupos do Auto Scaling e precisar exigir o uso do IMDSv2 em todas as novas instâncias, seus grupos do Auto Scaling deverão usar *modelos de execução*.
Quando um grupo do Auto Scaling usa um modelo de execução, as permissões de `ec2:RunInstances` do principal do IAM são verificadas quando um novo grupo do Auto Scaling é criado. Elas também são verificadas quando um grupo existente do Auto Scaling é atualizado para usar um novo modelo de execução ou uma nova versão de um modelo de execução.
As restrições sobre o uso do IMDSv1 em principais do IAM para `RunInstances` são verificadas somente quando um grupo do Auto Scaling que está usando um modelo de inicialização é criado ou atualizado. Para um grupo do Auto Scaling configurado para usar o modelo de execução `Latest` ou `Default`, as permissões não são verificadas quando uma nova versão do modelo de execução é criada. Para que as permissões sejam verificadas, configure o grupo do Auto Scaling para usar uma *versão específica* do modelo de execução.
Desabilite o uso de configurações de execução para todas as contas em sua organização usando SCPs (service control policies - políticas de controle de serviço) ou limites de permissões do IAM para novos principais criados. Para principais existentes do IAM com permissões de grupo do Auto Scaling, atualize suas políticas associadas com essa chave de condição. Para desabilitar o uso de configurações de execução, crie ou modifique a SCP relevante, o limite de permissões ou a política do IAM com a `"autoscaling:LaunchConfigurationName"` chave de condição com o valor especificado como `null`.
Para novos modelos de execução, configure as opções de metadados da instância no modelo de execução. Para modelos de execução existentes, crie uma versão do modelo de execução e configure as opções de metadados da instância na nova versão.
Na política que concede a qualquer principal permissão para usar um modelo de execução, restrinja a associação de `$latest` e `$default` especificando `"autoscaling:LaunchTemplateVersionSpecified": "true"`. Ao restringir o uso a uma versão específica de um modelo de execução, é possível garantir que novas instâncias serão executadas usando a versão na qual as opções de metadados da instância estão configuradas. Para obter mais informações, consulte [LaunchTemplateSpecification](https://docs.aws.amazon.com/autoscaling/ec2/APIReference/API_LaunchTemplateSpecification.html) no *Referência da API do Amazon EC2 Auto Scaling*, especificamente o parâmetro `Version`.
Para um grupo do Auto Scaling que usa uma configuração de execução, substitua a configuração de execução por um modelo de execução. Para obter mais informações, consulte [Migração de seus grupos do Auto Scaling para a execução de modelos](https://docs.aws.amazon.com/autoscaling/ec2/userguide/migrate-to-launch-templates.html) no *Guia do usuário do Amazon EC2 Auto Scaling*.
Para um grupo do Auto Scaling que usa um modelo de execução, certifique-se de que ele usa um novo modelo de execução com as opções de metadados da instância configuradas ou usa uma nova versão do modelo de execução atual com as opções de metadados da instância configuradas. Para obter mais informações, consulte [update-auto-scaling-group](https://docs.aws.amazon.com/cli/latest/reference/autoscaling/update-auto-scaling-group.html).
**Topics**
+ [
### Exigir o uso de IMDSv2
](#iam-example-instance-metadata-requireIMDSv2)
+ [
### Negar a rejeição do IMDSv2
](#iam-example-instance-metadata-denyoptoutIMDSv2)
+ [
### Especificar o limite máximo de saltos
](#iam-example-instance-metadata-maxHopLimit)
+ [
### Limitar quem pode modificar as opções de metadados da instância
](#iam-example-instance-metadata-limit-modify-IMDS-options)
+ [
### Exigir que as credenciais de função sejam recuperadas de IMDSv2
](#iam-example-instance-metadata-require-roles-to-use-IMDSv2-credentials)
### Exigir o uso de IMDSv2
A política a seguir especifica que não é possível chamar a API RunInstances a menos que a instância também esteja optada para exigir o uso de IMDSv2 (indicado por `"ec2:MetadataHttpTokens": "required"`). Se você não especificar que a instância requer IMDSv2, receberá um erro `UnauthorizedOperation` ao chamar a API RunInstances.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "RequireImdsV2",
"Effect": "Deny",
"Action": "ec2:RunInstances",
"Resource": "arn:aws:ec2:*:*:instance/*",
"Condition": {
"StringNotEquals": {
"ec2:MetadataHttpTokens": "required"
}
}
}
]
}
```
------
### Negar a rejeição do IMDSv2
A política a seguir especifica que não é possível chamar a API `ModifyInstanceMetadataOptions` e permitir a opção de IMDSv1 ou IMDSv2. Se você chamar a API `ModifyInstanceMetadataOptions`, o atributo `HttpTokens` deverá ser definido como `required`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "DenyIMDSv1HttpTokensModification",
"Effect": "Deny",
"Action": "ec2:ModifyInstanceMetadataOptions",
"Resource": "arn:aws:ec2:*:*:instance/*",
"Condition": {
"StringNotEquals": {
"ec2:Attribute/HttpTokens": "required"
},
"Null": {
"ec2:Attribute/HttpTokens": false
}
}
}]
}
```
------
### Especificar o limite máximo de saltos
A política a seguir especifica que não é possível chamar a API RunInstances a menos que também especifique um limite de saltos, que não pode ser superior a 3. Se isso não for feito, você receberá um erro `UnauthorizedOperation` ao chamar a API RunInstances.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "MaxImdsHopLimit",
"Effect": "Deny",
"Action": "ec2:RunInstances",
"Resource": "arn:aws:ec2:*:*:instance/*",
"Condition": {
"NumericGreaterThan": {
"ec2:MetadataHttpPutResponseHopLimit": "3"
}
}
}
]
}
```
------
### Limitar quem pode modificar as opções de metadados da instância
A política a seguir permite que apenas usuários com o perfil `ec2-imds-admins` façam alterações. nas opções de metadados da instância. Se qualquer principal diferente da função `ec2-imds-admins` tentar chamar a API ModifyInstanceMetadataOptions, receberá um erro `UnauthorizedOperation`. Essa instrução pode ser usada para controlar o uso da API ModifyInstanceMetadataOptions. No momento, não há controles de acesso refinados (condições) para a API ModifyInstanceMetadataOptions.
### Exigir que as credenciais de função sejam recuperadas de IMDSv2
A política a seguir especifica que, se essa política for aplicada a uma função e a função for assumida pelo serviço do EC2 e as credenciais resultantes forem usadas para assinar uma solicitação, a solicitação deverá ser assinada pelas credenciais de função do EC2 recuperadas do IMDSv2. Caso contrário, todas as suas chamadas de API receberão um erro `UnauthorizedOperation`. Essa instrução/política pode ser aplicada de modo geral porque, se a solicitação não for assinada por credenciais de função do EC2, ela não terá efeito.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "RequireAllEc2RolesToUseV2",
"Effect": "Deny",
"Action": "*",
"Resource": "*",
"Condition": {
"NumericLessThan": {
"ec2:RoleDelivery": "2.0"
}
}
}
]
}
```
------
## Trabalhar com volumes e snapshots do Amazon EBS
Para obter exemplos de políticas para trabalhar com volumes e snapshots do Amazon EBS, consulte [Exemplos de políticas baseadas em identidade para o Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/security_iam_id-based-policy-examples.html).
# Exemplo de políticas para controlar o acesso ao console do Amazon EC2
É possível usar as políticas do IAM para conceder aos usuários as permissões necessárias para que eles trabalhem com o Amazon EC2. Para obter instruções detalhadas, consulte [Criação de políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) no *Guia do usuário do IAM*.
O console usa ações de API adicionais para seus recursos, portanto, essas políticas talvez não funcionem como esperado. Por exemplo, um usuário que tem permissão para usar somente a ação da API `DescribeVolumes` encontrará erros ao tentar visualizar volumes no console. Esta seção demonstra políticas que permitem que os usuários trabalhem com partes específicas do console. Para obter informações adicionais sobre como criar políticas para o console do Amazon EC2, consulte a seguinte postagem do Blog de segurança da AWS: [Granting Users Permission to Work in the Amazon EC2 Console (Conceder permissão aos usuários para trabalhar no console do Amazon EC2)](https://aws.amazon.com/blogs/security/granting-users-permission-to-work-in-the-amazon-ec2-console/).
Os exemplos a seguir mostram declarações de políticas que você pode usar para conceder aos usuários as permissões para o uso do Amazon EC2. Substitua cada *espaço reservado para entrada do usuário* por suas próprias informações. Essas políticas são criadas para solicitações feitas com o Console de gerenciamento da AWS. O console do Amazon EC2 pode chamar várias ações de API para exibir um único recurso, e isso talvez não seja óbvio até que o usuário tente uma tarefa e o console exiba um erro. Para obter mais informações adicionais, consulte a seguinte postagem do Blog de segurança da AWS: [Granting Users Permission to Work in the Amazon EC2 Console](https://aws.amazon.com/blogs/security/granting-users-permission-to-work-in-the-amazon-ec2-console/).
**Topics**
+ [Acesso somente leitura](#ex-read-only)
+ [Use o assistente de início de instância do EC2](#ex-launch-wizard)
+ [Trabalhar com grupos de segurança](#ex-security-groups)
+ [Trabalhar com endereços IP elásticos](#ex-eip)
+ [Trabalhar com Instâncias reservadas](#ex-reservedinstances)
Para obter ajuda para descobrir quais ações de API são necessárias para a execução de tarefas no console, você pode usar um serviço para registrar chamadas, como o AWS CloudTrail. Se sua política não conceder permissão para criar ou modificar um recurso específico, o console exibirá uma mensagem codificada com informações de diagnóstico. É possível decodificar a mensagem usando a ação de API [DecodeAuthorizationMessage](https://docs.aws.amazon.com/STS/latest/APIReference/API_DecodeAuthorizationMessage.html) para AWS STS, ou o comando [decode-authorization-message](https://docs.aws.amazon.com/cli/latest/reference/sts/decode-authorization-message.html) na AWS CLI.
## Exemplo: acesso somente leitura
Para permitir que os usuários visualizem todos os recursos no console do Amazon EC2, é possível usar a mesma política como no exemplo a seguir: [Exemplo: acesso somente leitura](ExamplePolicies_EC2.md#iam-example-read-only). Os usuários não podem executar nenhuma ação nesses recursos ou criar novos recursos, a menos que outra declaração conceda permissão a eles para fazer isso.
**Visualizar instâncias, AMIs e snapshots**
Como alternativa, é possível fornecer acesso somente leitura a um subconjunto de recursos. Para fazer isso, substitua o caractere curinga \$1 na ação de API `ec2:Describe` por ações `ec2:Describe` específicas para cada recurso. A política a seguir permite que os usuários visualizem todas as instâncias, AMIs e snapshots no console do Amazon EC2. A ação `ec2:DescribeTags` permite que os usuários visualizem AMIs públicas. O console requer que as informações de marcação exibam AMIs públicas. No entanto, é possível remover essa ação para permitir que os usuários visualizem somente AMIs privadas.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"ec2:DescribeInstances",
"ec2:DescribeImages",
"ec2:DescribeTags",
"ec2:DescribeSnapshots"
],
"Resource": "*"
}
]
}
```
------
**nota**
As ações da API `ec2:Describe*` do Amazon EC2 não oferecem suporte a permissões em nível de recurso, portanto, não é possível controlar quais recursos individuais os usuários podem visualizar no console. Portanto, o caractere curinga \$1 é necessário no elemento `Resource` da declaração acima. Para obter mais informações sobre quais ARNs é possível usar com quais ações de API do Amazon EC2, consulte [Ações, recursos e chaves de condição do Amazon EC2 no ](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonec2.html).
**Visualizar instâncias e métricas do CloudWatch**
A política a seguir permite que os usuários visualizem instâncias no console do Amazon EC2, bem como alarmes e métricas do CloudWatch na guia **Monitoring (Monitoramento)** da página **Instances (Instâncias)**. O console do Amazon EC2 usa a API do CloudWatch para exibir os alarmes e as métricas, portanto, você deve conceder aos usuários permissão para usar as ações `cloudwatch:DescribeAlarms`, `cloudwatch:DescribeAlarmsForMetric`, `cloudwatch:ListMetrics`, `cloudwatch:GetMetricStatistics` e `cloudwatch:GetMetricData`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"ec2:DescribeInstances",
"ec2:DescribeInstanceTypes",
"cloudwatch:DescribeAlarms",
"cloudwatch:DescribeAlarmsForMetric",
"cloudwatch:ListMetrics",
"cloudwatch:GetMetricStatistics",
"cloudwatch:GetMetricData"
],
"Resource": "*"
}
]
}
```
------
## Exemplo: uso do assistente de início de instância do EC2
O assistente de início de instância do Amazon EC2 é uma tela com opções para configurar e iniciar uma instância. Sua política deve incluir permissão para usar as ações de API que permitem que os usuários trabalhem com as opções do assistente. Se a política não incluir a permissão para usar essas ações, alguns itens do assistente poderão não ser carregados corretamente, e os usuários não poderão concluir uma execução.
**Acesso básico ao assistente de início de instância**
Para concluir uma execução com êxito, os usuários devem receber permissão para usar a ação de API `ec2:RunInstances` e, pelo menos, as seguintes ações de API:
+ `ec2:DescribeImages`: para visualizar e selecionar uma AMI.
+ `ec2:DescribeInstanceTypes`: para visualizar e selecionar um tipo de instância.
+ `ec2:DescribeVpcs`: para ver as opções de rede disponíveis.
+ `ec2:DescribeSubnets`: para visualizar todas as sub-redes disponíveis da VPC escolhida.
+ `ec2:DescribeSecurityGroups` ou `ec2:CreateSecurityGroup`: para visualizar e selecionar um grupo de segurança existente ou criar um.
+ `ec2:DescribeKeyPairs` ou `ec2:CreateKeyPair`: para selecionar um par de chaves ou criar um par.
+ `ec2:AuthorizeSecurityGroupIngress`: para adicionar regras de entrada.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeInstances",
"ec2:DescribeImages",
"ec2:DescribeInstanceTypes",
"ec2:DescribeKeyPairs",
"ec2:DescribeVpcs",
"ec2:DescribeSubnets",
"ec2:DescribeSecurityGroups",
"ec2:CreateSecurityGroup",
"ec2:AuthorizeSecurityGroupIngress",
"ec2:CreateKeyPair"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": "*"
}
]
}
```
------
É possível adicionar ações de API à sua política para fornecer mais opções aos usuários, por exemplo:
+ `ec2:DescribeAvailabilityZones`: para ver e selecionar uma zona de disponibilidade específica.
+ `ec2:DescribeNetworkInterfaces`: para visualizar e selecionar interfaces de rede existentes para a sub-rede selecionada.
+ Para adicionar regras de saída para grupos de segurança da VPC, os usuários devem receber a permissão para usar a ação de API `ec2:AuthorizeSecurityGroupEgress`. Para modificar ou excluir regras existentes, os usuários devem receber permissão para usar a ação de API relevante `ec2:RevokeSecurityGroup*`.
+ `ec2:CreateTags`: para marcar os recursos criados por `RunInstances`. Para obter mais informações, consulte [Conceder permissão para marcar recursos do Amazon EC2 durante a criação](supported-iam-actions-tagging.md). Se os usuários não tiverem permissão para usar essa ação e tentarem aplicar tags na página de marcação do assistente de início de instância, haverá falha na execução.
**Importante**
Especifique um **Name** (Nome) ao iniciar uma instância cria uma etiqueta e exige a ação `ec2:CreateTags`. Tenha cuidado ao conceder aos usuários permissão para usar a ação `ec2:CreateTags`, pois isso limita sua capacidade de usar a chave de condição `aws:ResourceTag` para restringir o uso de outros recursos. Se você conceder aos usuários permissão para usar a ação `ec2:CreateTags`, eles poderão alterar a tag de um recurso para contornar essas restrições. Para obter mais informações, consulte [Controlar o acesso usando acesso baseado em atributos](iam-policies-for-amazon-ec2.md#control-access-with-tags).
+ Para usar parâmetros do Systems Manager ao selecionar uma AMI, você deve adicionar `ssm:DescribeParameters` e `ssm:GetParameters` à sua política. O `ssm:DescribeParameters` concede aos usuários a permissão para visualizar e selecionar parâmetros do Systems Manager. O `ssm:GetParameters` concede aos usuários a permissão para obter os valores dos parâmetros do Systems Manager. Também é possível restringir o acesso a parâmetros específicos do Systems Manager. Para obter mais informações, consulte **Restringir acesso a parâmetros específicos do Systems Manager** posteriormente nesta seção.
Atualmente, as ações da API `Describe*` do Amazon EC2 não oferecem suporte a permissões em nível de recurso, portanto, não é possível restringir quais recursos individuais os usuários podem visualizar no assistente de início de instância. Contudo, é possível aplicar permissões em nível de recurso na ação de API `ec2:RunInstances` para restringir os recursos que os usuários podem usar para executar uma instância. Haverá falha na execução se os usuários selecionarem opções que não estão autorizados a usar.
**Restringir o acesso a um tipo de instância, uma sub-rede e uma região específicos**
A política a seguir permite que os usuários executem instâncias `t2.micro` usando AMIs de propriedade da Amazon e apenas em uma sub-rede específica (`subnet-1a2b3c4d`). Os usuários só podem iniciar na região especificada. Se os usuários selecionarem uma região diferente ou se selecionarem outro tipo de instância, outra AMI ou outra sub-rede no assistente de início de instância, a execução falhará.
A primeira declaração concede aos usuários permissão para visualizar as opções no assistente de início de instância ou criar novas, conforme explicado no exemplo acima. A segunda declaração concede aos usuários permissão para usarem a interface de rede, o volume, o par de chaves, o grupo de segurança e os recursos de sub-rede para a ação `ec2:RunInstances`, que são necessários para executar uma instância em uma VPC. Para obter mais informações sobre como usar a ação `ec2:RunInstances`, consulte [Executar instâncias (RunInstances)](ExamplePolicies_EC2.md#iam-example-runinstances). A terceira e a quarta declaração concedem aos usuários permissão para usarem a instância e os recursos das AMIs respectivamente, mas somente se a instância for uma instância `t2.micro` e somente se a AMI pertencer à Amazon ou a determinados parceiros confiáveis e verificados.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"ec2:DescribeInstances",
"ec2:DescribeImages",
"ec2:DescribeInstanceTypes",
"ec2:DescribeKeyPairs",
"ec2:CreateKeyPair",
"ec2:DescribeVpcs",
"ec2:DescribeSubnets", "ec2:DescribeSecurityGroups",
"ec2:CreateSecurityGroup",
"ec2:AuthorizeSecurityGroupIngress"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action":"ec2:RunInstances",
"Resource": [
"arn:aws:ec2:us-east-2:111122223333:network-interface/*",
"arn:aws:ec2:us-east-2:111122223333:volume/*",
"arn:aws:ec2:us-east-2:111122223333:key-pair/*",
"arn:aws:ec2:us-east-2:111122223333:security-group/*",
"arn:aws:ec2:us-east-2:111122223333:subnet/subnet-1a2b3c4d"
]
},
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": [
"arn:aws:ec2:us-east-2:111122223333:instance/*"
],
"Condition": {
"StringEquals": {
"ec2:InstanceType": "t2.micro"
}
}
},
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": [
"arn:aws:ec2:us-east-2::image/ami-*"
],
"Condition": {
"StringEquals": {
"ec2:Owner": "amazon"
}
}
}
]
}
```
------
**Restringir o acesso a parâmetros específicos do Systems Manager**
A política a seguir concede acesso para usar parâmetros do Systems Manager com um nome específico.
A primeira instrução concede aos usuários permissão para visualizar parâmetros do Systems Manager ao selecionar uma AMI no assistente de início de instância. A segunda instrução concede aos usuários a permissão para usar somente parâmetros denominados `prod-*`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"ssm:DescribeParameters"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ssm:GetParameters"
],
"Resource": "arn:aws:ssm:us-east-2:123456123456:parameter/prod-*"
}
]
}
```
------
## Exemplo: trabalhar com grupos de segurança
**Visualizar grupos de segurança e adicionar e remover regras**
A política a seguir concede aos usuários permissão para visualizar grupos de segurança no console do Amazon EC2, adicionar e remover regras de entrada e de saída, bem como listar e modificar descrições de regras de grupo de segurança existentes que têm a etiqueta `Department=Test`.
Na primeira declaração, a ação `ec2:DescribeTags` permite que os usuários visualizem tags no console, o que facilita a identificação dos grupos de segurança que eles têm permissão para modificar.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"ec2:DescribeSecurityGroups",
"ec2:DescribeSecurityGroupRules",
"ec2:DescribeTags"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ec2:AuthorizeSecurityGroupIngress",
"ec2:RevokeSecurityGroupIngress",
"ec2:AuthorizeSecurityGroupEgress",
"ec2:RevokeSecurityGroupEgress",
"ec2:ModifySecurityGroupRules",
"ec2:UpdateSecurityGroupRuleDescriptionsIngress",
"ec2:UpdateSecurityGroupRuleDescriptionsEgress"
],
"Resource": [
"arn:aws:ec2:us-east-2:111122223333:security-group/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceTag/Department": "Test"
}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:ModifySecurityGroupRules"
],
"Resource": [
"arn:aws:ec2:us-east-2:111122223333:security-group-rule/*"
]
}
]}
```
------
**Trabalhar com a caixa de diálogo Create Security Group (Criar grupo de segurança**
É possível criar uma política que permita que os usuários trabalhem com a caixa de diálogo **Create Security Group** (Criar grupo de segurança) no console do Amazon EC2. Para usar essa caixa de diálogo, os usuários devem receber a permissão para usar pelo menos as seguintes ações de API:
+ `ec2:CreateSecurityGroup`: para criar um novo grupo de segurança.
+ `ec2:DescribeVpcs`: para visualizar uma lista de VPCs existentes na lista **VPC**.
Com essas permissões, os usuários podem criar um novo grupo de segurança com êxito, mas não podem adicionar nenhuma regra a ele. Para trabalhar com regras na caixa de diálogo **Create Security Group** (Criar grupo de segurança), é possível adicionar as seguintes ações de API à sua política:
+ `ec2:AuthorizeSecurityGroupIngress`: para adicionar regras de entrada.
+ `ec2:AuthorizeSecurityGroupEgress`: para adicionar regras de saída aos grupos de segurança da VPC.
+ `ec2:RevokeSecurityGroupIngress`: para modificar ou excluir regras de entrada existentes. Isso é útil para permitir que os usuários usem o recurso **Copy to new** no console. Esse recurso abre a caixa de diálogo **Create Security Group** (Criar grupo de segurança) e preenche-a com as mesmas regras do security group que foi selecionado.
+ `ec2:RevokeSecurityGroupEgress`: para modificar ou excluir regras de saída de grupos de segurança da VPC. Isso é útil para permitir que os usuários modifiquem ou excluam a regra de saída padrão que permite todo o tráfego de saída.
+ `ec2:DeleteSecurityGroup`: para prover quando regras inválidas não podem ser salvas. O console primeiro cria o grupo de segurança e, em seguida, adiciona as regras especificadas. Se as regras forem inválidas, a ação falhará, e o console tentará excluir o grupo de segurança. O usuário permanece na caixa de diálogo **Create Security Group** (Criar grupo de segurança) para que possa corrigir a regra inválida e tentar criar o security group novamente. Essa ação de API não é necessária, mas se um usuário não receber permissão para usá-la e tentar criar um grupo de segurança com regras inválidas, o grupo de segurança será criado sem nenhuma regra, e o usuário deverá adicioná-las posteriormente.
+ `ec2:UpdateSecurityGroupRuleDescriptionsIngress`: para adicionar ou atualizar descrições de regras de grupo de segurança de entrada (inbound).
+ `ec2:UpdateSecurityGroupRuleDescriptionsEgress`: para adicionar ou atualizar descrições de regras de grupo de segurança de saída (outbound).
+ `ec2:ModifySecurityGroupRules`: para modificar as regras do grupo de segurança.
+ `ec2:DescribeSecurityGroupRules`: para listar as regras do grupo de segurança.
A política a seguir concede aos usuários permissão para usar a caixa de diálogo **Create Security Group** (Criar grupo de segurança) e criar regras de entrada e de saída para grupos de segurança associados a uma VPC específica (`vpc-1a2b3c4d`). Os usuários podem criar grupos de segurança para uma VPC, mas não podem adicionar nenhuma regra a eles. Da mesma forma, os usuários não podem adicionar nenhuma regra aos grupos de segurança existentes não associados à VPC `vpc-1a2b3c4d`. Os usuários também recebem permissão para visualizar todos os grupos de segurança no console. Isso facilita aos usuários identificar os grupos de segurança aos quais podem adicionar regras de entrada. Essa política também concede permissão aos usuários para excluir grupos de segurança associados à VPC `vpc-1a2b3c4d`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"ec2:DescribeSecurityGroups",
"ec2:CreateSecurityGroup",
"ec2:DescribeVpcs"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ec2:DeleteSecurityGroup",
"ec2:AuthorizeSecurityGroupIngress",
"ec2:AuthorizeSecurityGroupEgress"
],
"Resource": "arn:aws:ec2:us-east-2:111122223333:security-group/*",
"Condition":{
"ArnEquals": {
"ec2:Vpc": "arn:aws:ec2:us-east-2:111122223333:vpc/vpc-1a2b3c4d"
}
}
}
]
}
```
------
## Exemplo: trabalhar com endereços IP elásticos
Para permitir que os usuários visualizem endereços IP elásticos no console do Amazon EC2, conceda aos usuários permissão para usar a ação `ec2:DescribeAddresses`.
Para permitir que os usuários trabalhem com endereços IP elásticos, é possível adicionar as seguintes ações à política.
+ `ec2:AllocateAddress`: para alocar um endereço IP elástico.
+ `ec2:ReleaseAddress`: para liberar um endereço IP elástico.
+ `ec2:AssociateAddress`: para associar um endereço IP elástico a uma instância ou a uma interface de rede.
+ `ec2:DescribeNetworkInterfaces` e `ec2:DescribeInstances`: para trabalhar com a tela **Associate address**. A tela exibe as instâncias disponíveis ou as interfaces de rede para que você possa associar um endereço IP elástico.
+ `ec2:DisassociateAddress`: para desassociar um endereço IP elástico de uma instância ou de uma interface de rede.
As políticas a seguir permitem que os usuários visualizem, aloquem e associem endereços IP elásticos a instâncias. Os usuários não podem associar endereços IP elásticos a interfaces de rede, desassociar endereços IP elásticos ou liberá-los.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeAddresses",
"ec2:AllocateAddress",
"ec2:DescribeInstances",
"ec2:AssociateAddress"
],
"Resource": "*"
}
]
}
```
------
## Exemplo: trabalhar com Instâncias reservadas
A política a seguir permite que os usuários visualizem e modifiquem instâncias reservadas em sua conta e que adquiram novas instâncias reservadas no Console de gerenciamento da AWS.
Esta política permite que os usuários visualizem todas as Instâncias reservadas, bem como Instâncias on-demand, na conta. Não é possível definir permissões em nível de recurso para Instâncias reservadas individuais.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"ec2:DescribeReservedInstances",
"ec2:ModifyReservedInstances",
"ec2:PurchaseReservedInstancesOffering",
"ec2:DescribeInstances",
"ec2:DescribeInstanceTypes",
"ec2:DescribeAvailabilityZones",
"ec2:DescribeReservedInstancesOfferings"
],
"Resource": "*"
}
]
}
```
------
A ação `ec2:DescribeAvailabilityZones` é necessária para garantir que o console do Amazon EC2 possa exibir informações sobre as zonas de disponibilidade nas quais é possível comprar Instâncias reservadas. A ação `ec2:DescribeInstances` não é necessária, mas garante que o usuário possa visualizar as instâncias na conta e comprar reservas para atender às especificações corretas.
É possível ajustar as ações de API para limitar o acesso do usuário, por exemplo, a remoção de `ec2:DescribeInstances` e de `ec2:DescribeAvailabilityZones` significa que o usuário tem acesso somente leitura.
# Políticas gerenciadas pela AWS para o Amazon EC2
Para adicionar permissões a usuários, grupos e perfis, é mais fácil usar políticas gerenciadas pela AWS do que gravar políticas por conta própria. É necessário tempo e experiência para [criar políticas gerenciadas pelo cliente do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html) que fornecem à sua equipe apenas as permissões de que precisam. Para começar rapidamente, é possível usar nossas políticas gerenciadas pela AWS. Essas políticas abrangem casos de uso comuns e estão disponíveis na sua conta da AWS. Para obter mais informações sobre políticas gerenciadas pela AWS, consulte [Políticas gerenciadas pela AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) no *Guia do usuário do IAM*.
Os serviços da AWS mantêm e atualizam políticas gerenciadas pela AWS. Não é possível alterar as permissões em políticas gerenciadas pela AWS. Os serviços ocasionalmente acrescentam permissões adicionais a uma política gerenciada pela AWS para oferecer suporte a novos recursos. Esse tipo de atualização afeta todas as identidades (usuários, grupos e funções) em que a política está anexada. É mais provável que os serviços atualizem uma política gerenciada pela AWS quando um novo recurso for iniciado ou novas operações se tornarem disponíveis. Os serviços não removem permissões de uma política gerenciada pela AWS, portanto, as atualizações de políticas não suspendem suas permissões existentes.
Além disso, a AWS é compatível com políticas gerenciadas por perfis de trabalho que abrangem vários serviços. Por exemplo, a política **ReadOnlyAccess** política gerenciada pela AWS fornece acesso somente leitura a todos os serviços e recursos da AWS. Quando um serviço executa um novo atributo, a AWS adiciona permissões somente leitura para novas operações e recursos. Para obter uma lista e descrições das políticas de funções de trabalho, consulte [Políticas gerenciadas pela AWS para funções de trabalho](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) no *Guia do usuário do IAM*.
## AWS Política gerenciada da: AmazonEC2FullAccess
É possível anexar a política `AmazonEC2FullAccess` a suas identidades do IAM. Essa política concede permissões que possibilitam acesso total ao Amazon EC2.
Para visualizar as permissões para esta política, consulte [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEC2FullAccess.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEC2FullAccess.html) na *Referência de políticas gerenciadas pela AWS*.
## Política gerenciada da AWS: AmazonEC2ReadOnlyAccess
É possível anexar a política `AmazonEC2ReadOnlyAccess` às identidades do IAM. Esta política concede permissões que oferecem acesso somente leitura ao Amazon EC2.
Para visualizar as permissões para esta política, consulte [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEC2ReadOnlyAccess.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEC2ReadOnlyAccess.html) na *Referência de políticas gerenciadas pela AWS*.
## AWS Política gerenciada da: AmazonEC2ImageReferencesAccessPolicy
É possível anexar a política `AmazonEC2ImageReferencesAccessPolicy` às identidades do IAM. Esta política concede as permissões necessárias para usar a API DescribeImageReferences do EC2, incluindo permissão para visualizar instâncias do EC2, modelos de inicialização, parâmetros do Systems Manager e fórmulas do Image Builder. A política é compatível com o sinalizador `IncludeAllResourceTypes` e continuará funcionando quando a AWS adicionar suporte para novos tipos de recursos, eliminando a necessidade de futuras atualizações de políticas.
Para visualizar as permissões para esta política, consulte [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEC2ImageReferencesAccessPolicy.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEC2ImageReferencesAccessPolicy.html) na *Referência de políticas gerenciadas pela AWS*.
## AWS Política gerenciada da: AWSEC2CapacityReservationFleetRolePolicy
Essa política é anexada ao perfil vinculado a serviço denominado **AWSServiceRoleForEC2CapacityReservationFleet** para permitir que o serviço crie, modifique e cancele reservas de capacidade em uma Frota de reservas de capacidade em seu nome. Para obter mais informações, consulte [Uso de funções vinculadas aos serviços para a frota de reserva de capacidadeUso de perfis vinculados ao serviço do EC2 Capacity Manager](using-service-linked-roles.md).
Para visualizar as permissões para esta política, consulte [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSEC2CapacityReservationFleetRolePolicy.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSEC2CapacityReservationFleetRolePolicy.html) na *Referência de políticas gerenciadas pela AWS*.
## AWS Política gerenciada da: AWSEC2FleetServiceRolePolicy
Esta política é anexada à função vinculada ao serviço de nome **AWSServiceRoleForEC2Fleet** para permitir que o EC2 Fleet solicite, inicie, encerre e aplique tags nas instâncias para você. Para obter mais informações, consulte [Função vinculada ao serviço para Frota do EC2](ec2-fleet-prerequisites.md#ec2-fleet-service-linked-role).
Para visualizar as permissões para esta política, consulte [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSEC2FleetServiceRolePolicy.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSEC2FleetServiceRolePolicy.html) na *Referência de políticas gerenciadas pela AWS*.
## AWS Política gerenciada da: AWSEC2SpotFleetServiceRolePolicy
Esta política é anexada à função vinculada ao serviço de nome **AWSServiceRoleForEC2SpotFleet** para permitir que a frota spot inicie e gerencie instâncias para você. Para obter mais informações, consulte [Função vinculada ao serviço para frota spot](spot-fleet-prerequisites.md#service-linked-roles-spot-fleet-requests).
Para visualizar as permissões para esta política, consulte [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSEC2SpotFleetServiceRolePolicy.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSEC2SpotFleetServiceRolePolicy.html) na *Referência de políticas gerenciadas pela AWS*.
## AWS Política gerenciada da: AWSEC2SpotServiceRolePolicy
Esta política é anexada à função vinculada ao serviço de nome **AWSServiceRoleForEC2Spot** para permitir que o Amazon EC2 inicie e gerencie instâncias spot para você. Para obter mais informações, consulte [Função vinculada ao serviço para solicitações de instâncias spot](service-linked-roles-spot-instance-requests.md).
Para visualizar as permissões para esta política, consulte [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSEC2SpotServiceRolePolicy.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSEC2SpotServiceRolePolicy.html) na *Referência de políticas gerenciadas pela AWS*.
## AWS Política gerenciada da: AWSEC2VssSnapshotPolicy
É possível anexar essa política gerenciada à função do perfil de instância do IAM usada para as instâncias do Windows do Amazon EC2. A política concede permissões que possibilitam que o Amazon EC2 crie e gerencie snapshots do VSS em seu nome.
Para visualizar as permissões para esta política, consulte [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSEC2VssSnapshotPolicy.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSEC2VssSnapshotPolicy.html) na *Referência de políticas gerenciadas pela AWS*.
## AWS Política gerenciada da: DeclarativePoliciesEC2Report
Essa política é anexada ao perfil vinculado a serviço denominado `AWSServiceRoleForDeclarativePoliciesEC2Report` para fornecer acesso a APIs somente leitura necessárias para gerar o relatório de status da conta para políticas declarativas.
Para visualizar as permissões para esta política, consulte [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/DeclarativePoliciesEC2Report.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/DeclarativePoliciesEC2Report.html) na *Referência de políticas gerenciadas pela AWS*.
## AWS Política gerenciada da: EC2FastLaunchFullAccess
É possível anexar a política de `EC2FastLaunchFullAccess` ao perfil de instância ou a outro perfil do IAM. Essa política concede total acesso às ações e às permissões direcionadas do EC2 Fast Launch como se segue.
**Detalhes da permissão**
+ **EC2 Fast Launch**: acesso administrativo é concedido para que o perfil possa habilitar ou desabilitar o EC2 Fast Launch e descrever as imagens do EC2 Fast Launch.
+ **Amazon EC2**: é concedido acesso para as operações RunInstances, CreateTags, Describe e Create and Modify Launch Template do Amazon EC2. Também é concedido acesso para criar recursos de rede e grupos de segurança, autorizar regras de entrada e excluir recursos criados pelo EC2 Fast Launch.
+ **IAM**: acesso é concedido para obter e usar perfis de instância cujo nome contenha `ec2fastlaunch` para criar o perfil vinculada ao serviço EC2FastLaunchServiceRolePolicy.
+ **CloudFormation** – é concedido acesso ao EC2 Fast Launch para descrever e criar pilhas do CloudFormation, e para excluir as pilhas que ele criou.
Para visualizar as permissões para esta política, consulte [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/EC2FastLaunchFullAccess.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/EC2FastLaunchFullAccess.html) na *Referência de políticas gerenciadas pela AWS*.
## AWS Política gerenciada da: AWSEC2CapacityManagerServiceRolePolicy
Esta política é anexada ao perfil vinculado ao serviço **AWSServiceRoleForEC2CapacityManager** para permitir que o EC2 Capacity Manager gerencie recursos de capacidade e se integre ao AWS Organizations para você. Para obter mais informações, consulte [Perfis vinculados ao serviço para o EC2 Capacity Manager](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-service-linked-roles-cm.html).
Para visualizar as permissões para esta política, consulte [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSEC2CapacityManagerServiceRolePolicy.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSEC2CapacityManagerServiceRolePolicy.html) na *Referência de políticas gerenciadas pela AWS*.
## AWS Política gerenciada da: EC2FastLaunchServiceRolePolicy
Esta política é anexada ao perfil vinculado ao serviço denominado **AWSServiceRoleForEC2FastLaunch** para permitir que o Amazon EC2 crie e gerencie um conjunto de snapshots pré-provisionados que reduzem o tempo necessário para iniciar instâncias usando a AMI habilitada para EC2 Fast Launch. Para obter mais informações, consulte [Perfil vinculado ao serviço para o EC2 Fast Launch](slr-windows-fast-launch.md).
Para visualizar as permissões para esta política, consulte [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/EC2FastLaunchServiceRolePolicy.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/EC2FastLaunchServiceRolePolicy.html) na *Referência de políticas gerenciadas pela AWS*.
## AWS Política gerenciada da: Ec2InstanceConnect
É possível anexar a política `Ec2InstanceConnect` às suas identidades do IAM. Esta política concede permissões para que os clientes chamem o EC2 Instance Connect para publicar chaves efêmeras em suas instâncias do EC2 e se conectem via ssh ou pela CLI do EC2 Instance Connect.
Para visualizar as permissões para esta política, consulte [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/EC2InstanceConnect.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/EC2InstanceConnect.html) na *Referência de políticas gerenciadas pela AWS*.
## AWS Política gerenciada da: Ec2InstanceConnectEndpoint
Essa política é anexada a um perfil vinculado a serviço chamado **AWSServiceRoleForEC2InstanceConnect** para permitir que o EC2 Instance Connect Endpoint execute ações em seu nome. Para obter mais informações, consulte [Perfil vinculado ao serviço para o EC2 Instance Connect Endpoint](eice-slr.md).
Para visualizar as permissões para esta política, consulte [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/Ec2InstanceConnectEndpoint.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/Ec2InstanceConnectEndpoint.html) na *Referência de políticas gerenciadas pela AWS*. Para obter uma descrição das atualizações desta política, consulte [Atualizações do Amazon EC2 para políticas gerenciadas pela AWS](#security-iam-awsmanpol-updates).
## Atualizações do Amazon EC2 para políticas gerenciadas pela AWS
Visualize detalhes sobre atualizações em políticas gerenciadas pela AWS para o Amazon EC2 desde que esse serviço começou a rastrear essas alterações.
| Alteração | Descrição | Data |
| --- | --- | --- |
| [AWSEC2CapacityManagerServiceRolePolicy](#security-iam-awsmanpol-AWSEC2CapacityManagerServiceRolePolicy) – Nova política | O Amazon EC2 adicionou essa política para permitir que você gerencie recursos de capacidade e se integre ao AWS Organizations para você. | 15 de outubro de 2025 |
| [AmazonEC2ImageReferencesAccessPolicy](#security-iam-awsmanpol-AmazonEC2ImageReferencesAccessPolicy) – nova política | O Amazon EC2 adicionou essa política para fornecer permissão para verificar todos os tipos de recursos compatíveis com a API DescribeImageReferences do EC2. | 26 de agosto de 2025 |
| [Ec2InstanceConnectEndpoint](#Ec2InstanceConnectEndpoint) – Atualizar política | Para oferecer suporte à modificação dos endpoints de conexão de instâncias existentes, o Amazon EC2 atualizou essa política para adicionar permissões para atribuir e cancelar a atribuição de endereços IPv6 e modificar grupos de segurança em interfaces de rede criadas pelo endpoint de conexão de instância do EC2. O Amazon EC2 também atualizou essa política para substituir o operador de condição Null pelo operador de condição StringLike. | 31 de julho de 2025 |
| [EC2FastLaunchServiceRolePolicy](#security-iam-awsmanpol-EC2FastLaunchServiceRolePolicy) – Atualizar política | Para ajudar a evitar recursos órfãos, o Amazon EC2 atualizou essa política para adicionar permissão para descrever volumes, atributos de volume e interfaces de rede, e para excluir volumes e interfaces de rede criados pelo EC2 Fast Launch. | 17 de julho de 2025 |
| [EC2FastLaunchFullAccess](#security-iam-awsmanpol-EC2FastLaunchFullAccess) – Atualizar política | O Amazon EC2 atualizou essa política para incluir as operações Create and Modify Launch Template, para criar recursos de rede e grupos de segurança, autorizar regras de entrada e excluir recursos criados pelo EC2 Fast Launch. Ela também pode descrever e criar pilhas do CloudFormation, e excluir pilhas criadas pelo EC2 Fast Launch. | 14 de maio de 2025 |
| [EC2FastLaunchServiceRolePolicy](#security-iam-awsmanpol-EC2FastLaunchServiceRolePolicy) – Atualizar política | O Amazon EC2 atualizou essa política para adicionar acesso ao Amazon EventBridge para criar e gerenciar regras de eventos para o EC2 Fast Launch. Além disso, o EC2 Fast Launch agora pode descrever pilhas do CloudFormation, iniciar uma instância a partir de uma AMI associada ao AWS License Manager, obter uma lista das concessões do AWS KMS que ele criou e que podem ser retiradas, e excluir os modelos de inicialização que ele criou. | 14 de maio de 2025 |
| [AWSEC2CapacityReservationFleetRolePolicy](#security-iam-awsmanpol-AWSEC2CapacityReservationFleetRolePolicy): Permissões atualizadas | O Amazon EC2 atualizou a política gerenciada AWSEC2CapacityReservationFleetRolePolicy para utilizar o operador de condição ArnLike em vez do operador de condição StringLike. | 03 de março de 2025 |
| [AmazonEC2ReadOnlyAccess](#security-iam-awsmanpol-AmazonEC2ReadOnlyAccess) – adicionou permissões | O Amazon EC2 adicionou uma permissão que permite recuperar grupos de segurança usando a operação GetSecurityGroupsForVpc. | 27 de dezembro de 2024 |
| [EC2FastLaunchFullAccess](#security-iam-awsmanpol-EC2FastLaunchFullAccess) – nova política | O Amazon EC2 adicionou essa política para realizar ações de API relacionadas ao atributo EC2 Fast Launch em uma instância. A política pode ser anexada ao perfil de instância para uma instância que é iniciada usando uma AMI habilitada para o EC2 Fast Launch. | 14 de maio de 2024 |
| [AWSEC2VssSnapshotPolicy](#security-iam-awsmanpol-AWSEC2VssSnapshotPolicy) – nova política | O Amazon EC2 adicionou a política AWSEC2VssSnapshotPolicy que contém permissões para criar e adicionar tags a images de máquina da Amazon (AMIs) e a snapshots do EBS. | 28 de março de 2024 |
| [Ec2InstanceConnectEndpoint](#Ec2InstanceConnectEndpoint) – nova política | A Amazon EC2 adicionou a política Ec2InstanceConnectEndpoint. Essa política está anexada ao perfil vinculado ao serviço AWSServiceRoleForEC2InstanceConnect, para permitir que o Amazon EC2 execute ações em seu nome quando você criar um endpoint de conexão de instância do EC2. | 24 de janeiro de 2023 |
| [EC2FastLaunchServiceRolePolicy](#security-iam-awsmanpol-EC2FastLaunchServiceRolePolicy) – nova política | O Amazon EC2 adicionou o atributo EC2 Fast Launch para habilitar as AMIs do Windows a executar instâncias mais rapidamente criando um conjunto de snapshots pré-provisionados. | 26 de novembro de 2021 |
| O Amazon EC2 passou a monitorar as alterações | O Amazon EC2 passou a controlar as alterações nas políticas gerenciadas pela AWS. | 1.º de março de 2021 |
# Funções do IAM para Amazon EC2
As aplicações devem assinar suas solicitações de API com as credenciais da AWS. Portanto, se você for um desenvolvedor de aplicações, precisará de uma estratégia para gerenciar credenciais para suas aplicações que executam em instâncias do EC2. Por exemplo, é possível distribuir de maneira segura suas credenciais da AWS para as instâncias, permitindo que as aplicações nessas instâncias usem suas credenciais para assinar solicitações, enquanto protege suas credenciais de outros usuários. Contudo, é um desafio distribuir credenciais para cada instância de maneira segura, especialmente aquelas que a AWS cria em seu nome, como instâncias spot ou instâncias em grupos do Auto Scaling. Você também deve poder atualizar as credenciais em cada instância quando alterna suas credenciais da AWS.
Projetamos funções do IAM para que suas aplicações possam fazer solicitações de API de suas instâncias de maneira segura, sem exigir que você gerencie as credenciais de segurança que as aplicações usam. Em vez de criar e distribuir suas credenciais da AWS, é possível delegar permissão para fazer solicitações de API usando funções do IAM da seguinte forma:
1. Crie uma função do IAM.
1. Defina quais contas ou serviços da AWS podem assumir a função.
1. Defina quais ações e recursos de API a aplicação pode usar depois de assumir a função.
1. Especifique a função quando você executar a instância ou anexe a função a uma instância existente.
1. Faça com que a aplicação recupere um conjunto de credenciais temporárias e use-as.
Por exemplo, é possível usar funções do IAM para conceder permissões a aplicações em execução em suas instâncias que precisam usar um bucket no Amazon S3. É possível especificar permissões para funções do IAM criando uma política em formato JSON. Essas são semelhantes às políticas que você cria para os usuários do . Se você alterar uma função, a alteração será propagada para todas as instâncias.
**nota**
As credenciais do perfil do IAM do Amazon EC2 não estão sujeitas às durações máximas de sessão configuradas no perfil. Para obter mais informações, consulte [Métodos para assumir um perfil](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage-assume.html) no *Manual do usuário do IAM*.
Ao criar funções do IAM, associe políticas do IAM de privilégio mínimo que restringem o acesso às chamadas de API específicas exigidas pela aplicação. Para comunicação Windows para Windows, use grupos e funções bem definidos e bem documentados do Windows para conceder acesso no nível de aplicação entre instâncias do Windows. Grupos e funções permitem que os clientes definam permissões de aplicação de privilégio mínimo e no nível de pasta do NTFS para limitar o acesso a requisitos específicos da aplicação.
Você só pode anexar uma função do IAM a uma instância, mas pode anexar a mesma função a muitas instâncias. Para obter mais informações sobre como criar e usar funções do IAM, consulte [Funções](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) no *Guia do usuário do IAM*.
É possível aplicar permissões em nível de recurso às políticas do IAM para controlar a capacidade de anexar, substituir ou desanexar funções do IAM de uma instância. Para obter mais informações, consulte [Permissões no nível do recurso com suporte para ações de API do Amazon EC2](iam-policies-for-amazon-ec2.md#ec2-supported-iam-actions-resources) e o seguinte exemplo: [Exemplo: trabalhar com funções do IAM](ExamplePolicies_EC2.md#iam-example-iam-roles).
**Topics**
+ [
## Perfis de instância
](#ec2-instance-profile)
+ [
## Permissões para seu caso de uso
](#generate-policy-for-iam-role)
+ [Recuperar credenciais de segurança](instance-metadata-security-credentials.md)
+ [Permissões para anexar um perfil a uma instância](permission-to-pass-iam-roles.md)
+ [Anexar um perfil a uma instância](attach-iam-role.md)
+ [Perfis de identidade da instância](#ec2-instance-identity-roles)
## Perfis de instância
O Amazon EC2 usa um *perfil de instância* como um contêiner para uma função do IAM. Se você criar uma função do IAM usando o console do IAM o console criará automaticamente um perfil de instância e dará a ele o mesmo nome da função correspondente. Se você usar o console do Amazon EC2 para executar uma instância com uma função do IAM ou anexar uma função do IAM a uma instância, deve escolher a função com base em uma lista de nomes de perfis de instância.
Se você usar a AWS CLI, a API ou um AWS SDK para criar uma função, você cria a função e o perfil da instância como ações separadas, com nomes potencialmente diferentes. Se você usar a AWS CLI, a API ou o AWS SDK para iniciar uma instância com uma função do IAM ou para anexar uma função do IAM a uma instância, especifique o nome do perfil da instância.
Um perfil de instância pode conter somente uma função do IAM. É possível incluir um perfil do IAM em vários perfis de instâncias.
Para atualizar as permissões de uma instância, substitua o perfil da instância. Não é recomendável remover um perfil de um perfil de instância, pois existe um atraso de até uma hora antes que essa alteração entre em vigor.
Para obter mais informações, consulte [Usar perfis de instâncias](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html) no *Guia do usuário do IAM*.
## Permissões para seu caso de uso
Quando você cria uma função do IAM pela primeira vez para suas aplicações, às vezes é possível conceder permissões além do que é necessário. Antes de iniciar sua aplicação em seu ambiente de produção, é possível gerar uma política do IAM baseada na atividade de acesso para uma função do IAM. O IAM Access Analyzer revisa seus logs do AWS CloudTrail e gera um modelo de política que contém as permissões que foram usadas pela função no intervalo de datas especificado. É possível usar o modelo para criar uma política gerenciada com permissões refinadas e anexá-la à função do IAM. Dessa forma, você concede apenas as permissões necessárias à interação com os recursos da AWS, de acordo com a especificidade do caso de uso. Isso ajuda você a aderir às melhores práticas de [conceder privilégio mínimo](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege). Para obter mais informações, consulte [Geração de política do IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-generation.html) no *Guia do usuário do IAM*.
# Recuperar credenciais de segurança dos metadados da instância
Uma aplicação na instância recupera as credenciais de segurança fornecidas pela função no item `iam/security-credentials/`*role-name* dos metadados da instância. A aplicação recebe as permissões para as ações e recursos que você definiu para a função por meio das credenciais de segurança associadas à função. Essas credenciais de segurança são temporárias e são alternadas automaticamente. Tornamos novas credenciais disponíveis pelo menos cinco minutos antes da expiração das credenciais antigas.
Para obter mais informações sobre os metadados da instância, consulte [Usar metadados da instância para gerenciar a instância do EC2](ec2-instance-metadata.md).
**Atenção**
Se você usar serviços que usam os metadados da instância com funções do IAM, não exponha suas credenciais quando os serviços criarem chamadas HTTP em seu nome. Os tipos de serviços que podem expor suas credenciais incluem proxies HTTP, serviços de validação HTML/CSS e processadores XML que são compatíveis com a inclusão XML.
Para suas workloads do Amazon EC2, recomendamos recuperar as credenciais da sessão usando o método descrito abaixo. Essas credenciais devem permitir que sua workload faça solicitações da API da AWS sem precisar usar `sts:AssumeRole` para assumir a mesma função que já está associada à instância. A menos que seja necessário passar etiquetas de sessão para controle de acesso por atributo (ABAC) ou passar uma política de sessão para restringir ainda mais as permissões da função, essas chamadas de suposição de função são desnecessárias, pois criam um novo conjunto das mesmas credenciais de sessão de função temporária.
Se sua workload usa uma função para assumir a si mesma, é necessário criar uma política de confiança que permita explicitamente que essa função se assuma sozinha. Se a política de confiança não for criada, o erro `AccessDenied` ocorrerá. Para obter mais informações, consulte [Atualização de uma política de confiança de perfil](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_update-role-trust-policy.html) no *Guia do usuário do IAM*.
------
#### [ IMDSv2 ]
**Linux**
Execute o seguinte comando em sua instância Linux para recuperar as credenciais de segurança de um perfil do IAM.
```
TOKEN=`curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600"` \
&& curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/security-credentials/role-name
```
**Windows**
Execute o seguinte cmdlet em sua instância Windows para recuperar as credenciais de segurança de um perfil do IAM.
```
[string]$token = Invoke-RestMethod `
-Headers @{"X-aws-ec2-metadata-token-ttl-seconds" = "21600"} `
-Method PUT -Uri http://169.254.169.254/latest/api/token
```
```
Invoke-RestMethod `
-Headers @{"X-aws-ec2-metadata-token" = $token} `
-Method GET -Uri http://169.254.169.254/latest/meta-data/iam/security-credentials/role-name
```
------
#### [ IMDSv1 ]
**Linux**
Execute o seguinte comando em sua instância Linux para recuperar as credenciais de segurança de um perfil do IAM.
```
curl http://169.254.169.254/latest/meta-data/iam/security-credentials/role-name
```
**Windows**
Execute o seguinte cmdlet em sua instância Windows para recuperar as credenciais de segurança de um perfil do IAM.
```
Invoke-RestMethod -uri http://169.254.169.254/latest/meta-data/iam/security-credentials/role-name
```
------
O seguinte é um exemplo de saída. Se você não conseguir recuperar as credenciais de segurança, consulte [Não é possível acessar as credenciais de segurança temporárias em minha instância do EC2](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot_iam-ec2.html#troubleshoot_iam-ec2_no-keys) no *Guia do usuário do IAM*.
```
{
"Code" : "Success",
"LastUpdated" : "2012-04-26T16:39:16Z",
"Type" : "AWS-HMAC",
"AccessKeyId" : "ASIAIOSFODNN7EXAMPLE",
"SecretAccessKey" : "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"Token" : "token",
"Expiration" : "2017-05-17T15:09:54Z"
}
```
Para comandos de aplicações, AWS CLI e Tools for Windows PowerShell que são executados na instância, não é necessário obter as credenciais de segurança temporárias explicitamente – os AWS SDKs, a AWS CLI e o Tools for Windows PowerShell obtêm automaticamente as credenciais do serviço de metadados da instância do EC2 e as usam. Para fazer uma chamada fora da instância usando credenciais de segurança temporárias (por exemplo, para testar as políticas do IAM), forneça a chave de acesso, a chave secreta e o token da sessão. Para obter mais informações, consulte [Usar credenciais de segurança temporárias para solicitar acesso aos recursos da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) no *Manual do usuário do IAM*.
# Conceder permissões para anexar um perfil do IAM a uma instância
As identidades em sua Conta da AWS, como usuários do IAM, devem ter permissões específicas para executar uma instância do Amazon EC2 com um perfil do IAM, anexar um perfil do IAM a uma instância, substituir o perfil do IAM por uma instância ou desanexar um perfil do IAM de uma instância. Você deve conceder permissão para usar as seguintes ações de API, conforme necessário:
+ `iam:PassRole`
+ `ec2:AssociateIamInstanceProfile`
+ `ec2:DisassociateIamInstanceProfile`
+ `ec2:ReplaceIamInstanceProfileAssociation`
**nota**
Se você especificar o recurso para `iam:PassRole` como `*`, isso concederá acesso para passar qualquer um dos perfis do IAM para uma instância. Para seguir a prática recomendada de [privilégio mínimo](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege), especifique os ARNs de perfis específicos do IAM com `iam:PassRole`, conforme mostrado no exemplo de política abaixo.
**Exemplo de política para acesso programático**
A política do IAM a seguir concede permissões para executar instâncias com um perfil do IAM, anexar um perfil do IAM a uma instância ou substituir um perfil do IAM por uma instância usando a AWS CLI ou a API do Amazon EC2.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:RunInstances",
"ec2:AssociateIamInstanceProfile",
"ec2:DisassociateIamInstanceProfile",
"ec2:ReplaceIamInstanceProfileAssociation"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::123456789012:role/DevTeam*"
}
]
}
```
------
**Requisito adicional para acesso ao console**
Para conceder permissões para concluir as mesmas tarefas usando o console do Amazon EC2, você também deve incluir a ação da API `iam:ListInstanceProfiles`.
# Anexar uma função do IAM a uma instância
É possível criar uma função do IAM e anexá-la a uma instância durante ou depois da execução. Você também pode substituir ou desanexar perfis do IAM.
**Criar e anexar um perfil do IAM durante a inicialização da instância (recomendado)**
1. Durante a inicialização da instância EC2, expanda os **Detalhes avançados**.
1. Na seção **Perfil de instância do IAM**, escolha **Criar novo perfil do IAM**.
1. Um formulário de criação de perfil em linha é aberto, permitindo que você:
+ Especifique o **Nome do perfil** (por exemplo, `EC2-S3-Access-Role`)
+ Defina permissões selecionando políticas gerenciadas da AWS ou criando políticas personalizadas para sua instância
Por exemplo, para conceder acesso ao S3, selecione a política gerenciada da `AmazonS3ReadOnlyAccess`
+ Revise a política de confiança que permita a `ec2.amazonaws.com` a assumir o perfil
+ Adicione tags opcionais para metadados
1. Selecione **Criar perfil**.
O perfil recém-criado é selecionado automaticamente e será anexado à sua instância por meio de um perfil de instância quando a instância for iniciada.
**nota**
Ao criar um perfil usando o console durante a inicialização da instância, um perfil de instância com o mesmo nome de perfil é criado automaticamente. O perfil de instância é um contêiner que transmite as informações do perfil do IAM para uma instância do EC2 na inicialização.
**Importante**
Você só pode anexar uma função do IAM a uma instância, mas pode anexar a mesma função a muitas instâncias.
Associe as políticas de IAM com privilégios mínimos que restrinjam o acesso às chamadas de API específicas que o aplicativo requer.
Para obter mais informações sobre como criar e usar funções do IAM, consulte [Funções](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) no *Guia do usuário do IAM*.
**Anexar um perfil do IAM existente durante a inicialização da instância**
Para anexar um perfil do IAM a uma instância na inicialização usando o console do Amazon EC2, expanda **Detalhes avançados**. Para **Perfil de instância do IAM**, selecione o perfil do IAM na lista do menu suspenso.
**nota**
Caso tenha criado o perfil do IAM usando o console do IAM, o perfil da instância terá sido criado para você e terá o mesmo nome do perfil. Caso tenha criado o perfil do IAM usando a AWS CLI, a API ou um SDK da AWS, é possível que você tenha dado um nome diferente do perfil para o perfil da instância.
É possível anexar um perfil do IAM a uma instância que está em execução ou interrompida. Se a instância já tiver um perfil do IAM anexado, você deverá substituí-lo pelo novo perfil do IAM.
------
#### [ Console ]
**Como anexar uma função do IAM a uma instância**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, escolha **Instances (Instâncias)**.
1. Selecione a instância.
1. Selecione **Actions** (Ações), **Security** (Segurança), **Modify IAM role** (Modificar perfil do IAM).
1. Para **Perfil do IAM**, selecione o perfil de instância do IAM.
1. Escolha **Atualizar perfil do IAM**.
------
#### [ AWS CLI ]
**Como anexar uma função do IAM a uma instância**
Use o comando [associate-iam-instance-profile](https://docs.aws.amazon.com/cli/latest/reference/ec2/associate-iam-instance-profile.html) para anexar o perfil do IAM à instância. Ao especificar o perfil de instância, você pode usar o nome do recurso da Amazon (ARN) do perfil de instância ou o seu nome.
```
aws ec2 associate-iam-instance-profile \
--instance-id i-1234567890abcdef0 \
--iam-instance-profile Name="TestRole-1"
```
------
#### [ PowerShell ]
**Como anexar uma função do IAM a uma instância**
Use o cmdlet [Register-EC2IamInstanceProfile](https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2IamInstanceProfile.html).
```
Register-EC2IamInstanceProfile `
-InstanceId i-1234567890abcdef0 `
-IamInstanceProfile_Name TestRole-1
```
------
Para substituir o perfil do IAM em uma instância que já tenha um perfil do IAM anexado, essa instância deve estar em execução. Será possível fazer isso se você quiser alterar a função do IAM de uma instância sem desanexar a existente primeiro. Por exemplo, é possível fazer isso para garantir que as ações de API desempenhadas por aplicações executadas na instância não sejam interrompidas.
------
#### [ Console ]
**Como substituir uma função do IAM para uma instância**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, escolha **Instances (Instâncias)**.
1. Selecione a instância.
1. Selecione **Actions** (Ações), **Security** (Segurança), **Modify IAM role** (Modificar perfil do IAM).
1. Para **Perfil do IAM**, selecione o perfil de instância do IAM.
1. Escolha **Atualizar perfil do IAM**.
------
#### [ AWS CLI ]
**Como substituir uma função do IAM para uma instância**
1. Se necessário, use o comando [describe-iam-instance-profile-associations](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-iam-instance-profile-associations.html) para obter o ID da associação.
```
aws ec2 describe-iam-instance-profile-associations \
--filters Name=instance-id,Values=i-1234567890abcdef0 \
--query IamInstanceProfileAssociations.AssociationId
```
1. Use o comando [replace-iam-instance-profile-association](https://docs.aws.amazon.com/cli/latest/reference/ec2/replace-iam-instance-profile-association.html). Especifique o ID de associação do perfil de instância existente e o ARN ou o nome do novo perfil de instância.
```
aws ec2 replace-iam-instance-profile-association \
--association-id iip-assoc-0044d817db6c0a4ba \
--iam-instance-profile Name="TestRole-2"
```
------
#### [ PowerShell ]
**Como substituir uma função do IAM para uma instância**
1. Se necessário, use o cmdlet [Get-EC2IamInstanceProfileAssociation](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2IamInstanceProfileAssociation.html) para obter o ID da associação.
```
(Get-EC2IamInstanceProfileAssociation -Filter @{Name="instance-id"; Values="i-0636508011d8e966a"}).AssociationId
```
1. Use o cmdlet [Set-EC2IamInstanceProfileAssociation](https://docs.aws.amazon.com/powershell/latest/reference/items/Set-EC2IamInstanceProfileAssociation.html). Especifique o ID de associação do perfil de instância existente e o ARN ou o nome do novo perfil de instância.
```
Set-EC2IamInstanceProfileAssociation `
-AssociationId iip-assoc-0044d817db6c0a4ba `
-IamInstanceProfile_Name TestRole-2
```
------
É possível desvincular um perfil do IAM de uma instância que esteja em execução ou interrupção.
------
#### [ Console ]
**Como desanexar uma função do IAM de uma instância**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, escolha **Instances (Instâncias)**.
1. Selecione a instância.
1. Selecione **Actions** (Ações), **Security** (Segurança), **Modify IAM role** (Modificar perfil do IAM).
1. Em **IAM role (Função do IAM)**, selecione **No IAM Role (Nenhuma função do IAM)**.
1. Escolha **Atualizar perfil do IAM**.
1. Quando a confirmação for solicitada, insira **Desanexar** e depois escolha **Desanexar**.
------
#### [ AWS CLI ]
**Como desanexar uma função do IAM de uma instância**
1. Se necessário, use [describe-iam-instance-profile-associations](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-iam-instance-profile-associations.html) para obter o ID de associação do perfil de instância do IAM a ser desanexado.
```
aws ec2 describe-iam-instance-profile-associations \
--filters Name=instance-id,Values=i-1234567890abcdef0 \
--query IamInstanceProfileAssociations.AssociationId
```
1. Use o comando [disassociate-iam-instance-profile](https://docs.aws.amazon.com/cli/latest/reference/ec2/disassociate-iam-instance-profile.html).
```
aws ec2 disassociate-iam-instance-profile --association-id iip-assoc-0044d817db6c0a4ba
```
------
#### [ PowerShell ]
**Como desanexar uma função do IAM de uma instância**
1. Se necessário, use [Get-EC2IamInstanceProfileAssociation](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2IamInstanceProfileAssociation.html) para obter o ID de associação do perfil de instância do IAM a ser desanexado.
```
(Get-EC2IamInstanceProfileAssociation -Filter @{Name="instance-id"; Values="i-0636508011d8e966a"}).AssociationId
```
1. Use o cmdlet [Unregister-EC2IamInstanceProfile](https://docs.aws.amazon.com/powershell/latest/reference/items/Unregister-EC2IamInstanceProfile.html).
```
Unregister-EC2IamInstanceProfile -AssociationId iip-assoc-0044d817db6c0a4ba
```
------
## Perfis de identidade da instância para instâncias do Amazon EC2
Cada instância do Amazon EC2 inicializada tem um *perfil de identidade da instância* que representa sua identidade. Um perfil de identidade de instância é um tipo de perfil do IAM. Serviços da AWS e recursos integrados para usar o perfil de identidade da instância podem usá-lo para identificar a instância com o serviço.
As credenciais do perfil de identidade da instância podem ser acessadas no Serviço de metadados da instância (IMDS) em `/identity-credentials/ec2/security-credentials/ec2-instance`. As credenciais consistem em um par temporário de chave de acesso da AWS e um token de sessão. Eles são usados para assinar solicitações AWS Sigv4 para os serviços da AWS que usam o perfil de identidade da instância. As credenciais estão presentes nos metadados da instância, independentemente de um serviço ou recurso que faça uso dos perfils de identidade da instância estar habilitado na instância.
Os perfis de identidade da instância são criados automaticamente quando uma instância é iniciada, não possuem nenhum documento de política de confiança de perfil e não estão sujeitos a nenhuma política de identidade ou de recursos.
### Serviços com suporte
Os serviços da AWS a seguir usam o perfil de identidade da instância:
+ **Amazon EC2**: o [EC2 Instance Connect](connect-linux-inst-eic.md) usa o perfil de identidade da instância para atualizar as chaves de host de uma instância do Linux.
+ **Amazon GuardDuty**: o [monitoramento de runtime do GuardDuty](https://docs.aws.amazon.com/guardduty/latest/ug/runtime-monitoring.html) usa o perfil de identidade da instância para permitir que o agente de runtime envie telemetria de segurança para o endpoint da VPC do GuardDuty.
+ **AWS Lambda** – As [instâncias gerenciadas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-managed-instances.html) utilizam a função de identidade da instância para ganchos de ciclo de vida, telemetria e distribuição de artefatos.
+ **AWS Security Token Service (AWS STS)**: as credenciais do perfil de identidade da instância podem ser usadas com a ação AWS STS [https://docs.aws.amazon.com/STS/latest/APIReference/API_GetCallerIdentity.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetCallerIdentity.html).
+ **AWS Systems Manager**: ao usar a [Configuração padrão de gerenciamento de host](https://docs.aws.amazon.com/systems-manager/latest/userguide/fleet-manager-default-host-management-configuration.html), o AWS Systems Manager usa a identidade fornecida pelo perfil de identidade da instância para registrar instâncias do EC2. Depois de identificar sua instância, o Systems Manager pode passar seu perfil do IAM `AWSSystemsManagerDefaultEC2InstanceManagementRole` para sua instância.
Os perfis de identidade da instância não podem ser usados com outros serviços ou recursos da AWS, pois eles não têm uma integração com os perfis de identidade da instância.
### ARN de perfil de identidade da instância
O ARN de perfil de identidade da instância assume o seguinte formato:
```
arn:aws-partition:iam::account-number:assumed-role/aws:ec2-instance/instance-id
```
Por exemplo:
```
arn:aws:iam::0123456789012:assumed-role/aws:ec2-instance/i-1234567890abcdef0
```
Para obter mais informações sobre ARNs, consulte [Nome do recurso da Amazon (ARN)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html) no *Guia do usuário do IAM*.