# Perfis do IAM
<a name="id_roles"></a>

Uma *função* do IAM é uma identidade do IAM que você pode criar em sua conta que tem permissões específicas. Uma função do IAM é semelhante a um usuário do IAM no sentido de que é uma identidade da AWS com políticas de permissão que determinam o que a identidade pode e não pode fazer na AWS. No entanto, em vez de ser exclusivamente associada a uma pessoa, o propósito do perfil é ser assumido por qualquer pessoa que precisar dele. Além disso, um perfil não tem credenciais de longo prazo padrão associadas a ele, como senha ou chaves de acesso. Em vez disso, quando você assumir um perfil, ele fornecerá credenciais de segurança temporárias para sua sessão de perfil.

É possível usar funções para delegar acesso a usuários, aplicações ou serviços que normalmente não têm acesso aos seus recursos da AWS. Por exemplo, você pode conceder para os usuários na sua conta da AWS acesso a recursos que normalmente eles não têm ou conceder para os usuários em uma Conta da AWS acesso a recursos em outra conta. Também é possível permitir que uma aplicação móvel use recursos da AWS, mas sem incorporar chaves da AWS na aplicação (onde pode ser difícil atualizá-las e onde os usuários poderão potencialmente extraí-las). Às vezes, você deseja oferecer acesso à AWS a usuários que já têm identidades definidas fora da AWS, como no diretório corporativo. Você também pode conceder acesso à sua conta a terceiros, para que eles possam realizar uma auditoria em seus recursos.

Para esses cenários, você pode delegar acesso aos recursos da AWS usando uma *função do IAM*. Esta seção apresenta funções e as diferentes maneiras de usá-las, quando e como escolher essas abordagens e como criar, gerenciar, alternar para (ou assumir) e excluir funções.

**nota**  
Quando você cria sua Conta da AWS, nenhum perfil é criado por padrão. Conforme você adiciona serviços à sua conta, eles podem adicionar perfis vinculados a serviços para dar suporte a seus casos de uso.  
 Um perfil vinculado a serviço é um tipo de perfil de serviço vinculado a um AWS service (Serviço da AWS). O serviço pode presumir o perfil de executar uma ação em seu nome. Perfis vinculados ao serviço aparecem em sua Conta da AWS e são de propriedade do serviço. Um administrador do IAM pode visualizar, mas não editar as permissões para perfis vinculados ao serviço.   
Para poder excluir esses perfis vinculados a serviços, você deve primeiro excluir os recursos relacionados a eles. Isso protege seus recursos porque você não pode remover por engano as permissões para acessar os recursos.  
Para obter informações sobre quais serviços oferecem suporte a funções vinculadas a serviços, consulte [AWSServiços da que funcionam com o IAM](reference_aws-services-that-work-with-iam.md) e procure os serviços que têm **Sim **na coluna **Função vinculada ao serviço**. Escolha um **Sim** com um link para visualizar a documentação do perfil vinculado para esse serviço.

**Topics**
+ [

## Quando criar um usuário do IAM (em vez de uma função)
](#id_which-to-choose)
+ [

## Termos e conceitos das funções
](#id_roles_terms-and-concepts)
+ [

## Recursos adicionais
](#id_roles_additional-resources)
+ [

# O problema "confused deputy"
](confused-deputy.md)
+ [

# Cenários comuns para perfis do IAM
](id_roles_common-scenarios.md)
+ [

# Criar um perfil do IAM
](id_roles_create.md)
+ [

# Gerenciamento de perfis do IAM
](id_roles_manage.md)
+ [

# Métodos para assumir um perfil
](id_roles_manage-assume.md)

## Quando criar um usuário do IAM (em vez de uma função)
<a name="id_which-to-choose"></a>

Recomendamos usar somente usuários do IAM para casos de uso sem suporte à federação de identidades. Alguns dos casos de uso incluem o seguinte:
+ **Workloads que não podem usar perfis do IAM**: você pode executar a workload de um local que precisa acessar a AWS. Em algumas situações, você não pode usar perfis do IAM para fornecer credenciais temporárias, como para plugins do WordPress. Nessas situações, use as chaves de acesso de longo prazo do usuário do IAM para que essa workload seja autenticada na AWS.
+ **Clientes de terceiros da AWS**: se você estiver usando ferramentas que não oferecem suporte ao acesso com o Centro de Identidade do IAM, como fornecedores ou clientes terceiros da AWS que não estão hospedados na AWS, use as chaves de acesso de longo prazo do usuário do IAM.
+ **Acesso ao AWS CodeCommit**: se você estiver usando o CodeCommit para armazenar seu código, poderá usar um usuário do IAM com chaves SSH ou credenciais específicas de serviço para que o CodeCommit seja autenticado em seus repositórios. Recomendamos fazer isso além de usar um usuário do IAM Identity Center para autenticação padrão. Os usuários do Centro de Identidade do IAM são as pessoas em sua força de trabalho que precisam acessar suas Contas da AWS ou suas aplicações na nuvem. Para dar aos usuários acesso aos seus repositórios do CodeCommit sem configurar os usuários do IAM, você pode configurar o utilitário **git-remote-codecommit**. Para obter mais informações sobre o IAM e o CodeCommit, consulte [Credenciais do IAM para o CodeCommit: credenciais do Git, chaves SSH e chaves de acesso da AWS](id_credentials_ssh-keys.md). Para obter mais informações sobre como configurar o utilitário **git-remote-codecommit**, consulte [Conectar-se a repositórios do AWS CodeCommit credenciais alternadas](https://docs.aws.amazon.com/codecommit/latest/userguide/temporary-access.html#temporary-access-configure-credentials), no *Guia do usuário do AWS CodeCommit*.
+ **Acesso ao Amazon Keyspaces (para Apache Cassandra)**: em uma situação em que não é possível usar usuários no IAM Identity Center, como para fins de teste de compatibilidade com o Cassandra, você pode usar um usuário do IAM com credenciais específicas do serviço para a autenticação com o Amazon Keyspaces. Os usuários do Centro de Identidade do IAM são as pessoas em sua força de trabalho que precisam acessar suas Contas da AWS ou suas aplicações na nuvem. Você também pode se conectar ao Amazon Keyspaces usando credenciais temporárias. Para obter mais informações, consulte [Using temporary credentials to connect to Amazon Keyspaces using an IAM role and the SigV4 plugin](https://docs.aws.amazon.com/keyspaces/latest/devguide/access.credentials.html#temporary.credentials.IAM) (Como usar credenciais temporárias para se conectar ao Amazon Keyspaces usando um perfil do IAM e o plug-in SigV4) no *Guia do desenvolvedor do Amazon Keyspaces (para Apache Cassandra)*.
+ **Acesso de emergência**: em uma situação em que você não consegue acessar seu provedor de identidade e precisa tomar medidas em sua Conta da AWS. Estabelecer usuários do IAM com acesso emergencial pode fazer parte do plano de resiliência. Recomendamos que as credenciais do usuário de emergência sejam rigidamente controladas e protegidas por autenticação multifator (MFA).

## Termos e conceitos das funções
<a name="id_roles_terms-and-concepts"></a>

Veja a seguir alguns termos básicos para começar a usar as funções.

****Perfil****  
Uma identidade do IAM que você pode criar em sua conta que tem permissões específicas. Uma função do IAM tem algumas semelhanças com um usuário do IAM. Funções e usuários são identidades da AWS com políticas de permissão que determinam o que a identidade pode e não pode fazer na AWS. No entanto, em vez de ser exclusivamente associada a uma pessoa, o propósito do perfil é ser assumido por qualquer pessoa que precisar dele. Além disso, um perfil não tem credenciais de longo prazo padrão associadas a ele, como senha ou chaves de acesso. Em vez disso, quando você assumir um perfil, ele fornecerá credenciais de segurança temporárias para sua sessão de perfil.  
Os perfis podem ser usados pelas seguintes entidades:  
+ Um usuário do IAM na mesma Conta da AWS ou em outra Conta da AWS
+ Perfis do IAM na mesma conta
+ Entidades principais de serviço, para uso com serviços e recursos da AWS como:
  + Serviços que permitem executar código em serviços de computação, como Amazon EC2 ou AWS Lambda
  + Atributos que executam ações em seus recursos em seu nome, como a replicação de objetos do Amazon S3
  + Serviços que fornecem credenciais de segurança temporárias para suas aplicações executadas fora da AWS, como IAM Roles Anywhere ou Amazon ECS Anywhere
+ Um usuário externo autenticado por um serviço de provedor de identidades (IdP) compatível com SAML 2.0 ou OpenID Connect

****AWS Perfil de serviço da****  
 O perfil de serviço é um [perfil do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) que um serviço assume para executar ações em seu nome. Um administrador do IAM pode criar, modificar e excluir um perfil de serviço do IAM. Para obter mais informações, consulte [Criação de um perfil para delegar permissões a um AWS service (Serviço da AWS)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) no *Guia do Usuário do IAM*. 

****AWS Função vinculada ao serviço do****  
 Um perfil vinculado a serviço é um tipo de perfil de serviço vinculado a um AWS service (Serviço da AWS). O serviço pode presumir o perfil de executar uma ação em seu nome. Perfis vinculados ao serviço aparecem em sua Conta da AWS e são de propriedade do serviço. Um administrador do IAM pode visualizar, mas não editar as permissões para perfis vinculados ao serviço.   
Se já estiver usando um serviço quando ele começar a oferecer suporte às funções vinculadas ao serviço, você poderá receber um e-mail informando sobre uma nova função na sua conta. Nesse caso, o serviço cria automaticamente a função vinculada ao serviço na sua conta. Você não precisa realizar nenhuma ação para oferecer suporte a essa função, e você não deve excluir manualmente. Para obter mais informações, consulte [Uma nova função apareceu na minha conta da AWS](troubleshoot_roles.md#troubleshoot_roles_new-role-appeared).
Para obter informações sobre quais serviços oferecem suporte a funções vinculadas a serviços, consulte [AWSServiços da que funcionam com o IAM](reference_aws-services-that-work-with-iam.md) e procure os serviços que têm **Sim **na coluna **Função vinculada ao serviço**. Escolha um **Sim** com um link para visualizar a documentação do perfil vinculado para esse serviço. Para obter mais informações, consulte [Criar um perfil vinculado ao serviço](id_roles_create-service-linked-role.md).

****Encadeamento de funções****  
O encadeamento de perfis ocorre quando um perfil é usado para assumir um segundo perfil. Você pode realizar o encadeamento de perfis via Console de gerenciamento da AWS alternando entre os perfis, a AWS CLI ou a API. Por exemplo, suponha que o `RoleA` tenha permissão para assumir o `RoleB`. É possível permitir que o Usuário1 assuma o `RoleA` usando as credenciais de usuário de longo prazo na operação da API AssumeRole. Esta operação retorna as credenciais de curto prazo do `RoleA`. Para iniciar o encadeamento de funções, você pode usar as credenciais de curto prazo do `RoleA` para permitir que o Usuário1 assuma o `RoleB`.  
Ao assumir uma função, você pode passar uma tag de sessão e definir a tag como transitiva. As tags de sessão transitivas são passadas para todas as sessões subsequentes em uma cadeia de funções. Para saber mais sobre tags de sessão, consulte [Passar tags de sessão no AWS STS](id_session-tags.md).  
O encadeamento de perfis limita a sessão de perfil da API do Console de gerenciamento da AWS, AWS CLI ou AWS a um máximo de uma hora. Isso se aplica de forma independente da duração máxima da sessão configurada para perfis individuais. Ao usar a operação de API [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) para assumir uma função, você pode especificar o tempo da sessão da sua função usando o parâmetro `DurationSeconds`. É possível especificar um valor de parâmetro de até 43200 segundos (12 horas), dependendo da [configuração da duração máxima da sessão](id_roles_update-role-settings.md#id_roles_update-session-duration) para seu perfil. No entanto, se você assumir uma função usando o encadeamento e fornecer um valor de parâmetro `DurationSeconds` maior do que uma hora, a operação falhará.  
Para obter mais informações sobre como alternar entre perfis no Console de gerenciamento da AWS, consulte [Mudar de um usuário para um perfil do IAM (console)](id_roles_use_switch-role-console.md).

****Delegação****  
A concessão de permissões a alguém para permitir o acesso a recursos controlados por você. A delegação envolve estabelecer confiança entre duas contas. A primeira é a conta que possui o recurso (a conta de confiança). A segunda é a conta que contém os usuários que precisam acessar o recurso (a conta confiável). As contas confiável e de confiança podem ser qualquer uma das seguintes:  
+ A mesma conta.
+ Contas separadas que estão sob controle da sua organização.
+ Duas contas pertencentes a organizações diferentes.
Para delegar permissão para acessar um recurso, você [cria um perfil do IAM](id_roles_create_for-user.md) na conta de confiança com duas políticas anexadas. A *política de permissões* concede ao usuário da função as permissões necessárias para executar as tarefas pretendidas no recurso. A *política de confiança* especifica quais membros das contas confiáveis têm permissão para assumir a função.  
Ao criar uma política de confiança, você não pode especificar um curinga (\$1) como parte de um ARN no elemento de entidade principal. A política de confiança é anexada à função na conta de confiança e equivale à metade das permissões. A outra metade é uma política de permissões anexada ao usuário na conta confiável que [permite a ele alternar ou assumir a função](id_roles_use_permissions-to-switch.md). Um usuário que assume uma função temporariamente desiste de suas próprias permissões e, em vez disso, assume as permissões da função. Quando o usuário sai ou para de usar a função, as permissões originais do usuário são restauradas. Um parâmetro adicional chamado [ID externo](id_roles_common-scenarios_third-party.md#id_roles_third-party_external-id) ajuda a garantir o uso seguro de funções entre contas que não são controladas pela mesma organização.

****Política de confiança****  
Um [documento de política JSON](reference_policies_grammar.md) no qual você define os principais nos quais você *confia* para assumir a função. Uma política de confiança da função é uma [política com base em recurso](access_policies.md#policies_resource-based) necessária anexada a uma função no IAM. Os [principais](reference_policies_elements_principal.md) que podem ser especificados na política de confiança incluem usuários, funções, contas e serviços. Para obter mais informações, consulte [Como usar políticas de confiança em perfis do IAM](https://aws.amazon.com/blogs//security/how-to-use-trust-policies-with-iam-roles/) no *AWS Security Blog*.

****Função para acesso entre contas****  
Uma função que concede o acesso a recursos em uma conta a uma entidade principal confiável em outra conta. Os perfis são a principal forma de conceder acesso entre contas. No entanto, alguns dos serviços da AWS permitem que você anexe uma política diretamente a um recurso (em vez de usar uma função como proxy). Essas políticas são chamadas de políticas baseadas em recursos, e você pode usá-las para conceder acesso ao recurso para entidades principais em outra Conta da AWS. Alguns desses recursos incluem buckets do Amazon Simple Storage Service (S3), cofres do Amazon Glacier, tópicos do Amazon Simple Notification Service (SNS) e filas do Amazon Simple Queue Service (SQS). Para saber quais serviços oferecem suporte a políticas baseadas em recursos, consulte [AWSServiços da que funcionam com o IAM](reference_aws-services-that-work-with-iam.md). Para obter mais informações sobre políticas baseadas em recursos, consulte [Acesso a recursos entre contas no IAM](access_policies-cross-account-resource-access.md).

## Recursos adicionais
<a name="id_roles_additional-resources"></a>

Os seguintes recursos podem ajudar você a saber mais sobre a terminologia do IAM relacionada a perfis do IAM.
+ **Entidades principais** são entidades na AWS que podem executar ações e acessar recursos. Uma entidade principal pode ser um Usuário raiz da conta da AWS, um usuário do IAM ou um perfil. Uma entidade principal que representa a identidade de um serviço da AWS é uma [entidade principal de serviço](reference_policies_elements_principal.md#principal-services). Use o elemento Principal nas políticas de confiança do perfil para definir as entidades principais em que você confia para assumir o perfil.

   Para obter mais informações e exemplos de entidades principais que você pode permitir que assumam um perfil, consulte [Elementos da política JSON da AWS: Principal](reference_policies_elements_principal.md). 
+ A **federação de identidades** cria uma relação de confiança entre um provedor de identidades externo e a AWS. É possível usar seu provedor de OpenID Connect (OIDC) ou Security Assertion Markup Language (SAML) 2.0 existente para gerenciar quem pode acessar os recursos da AWS. Quando você usa o OIDC e o SAML 2.0 para configurar uma relação de confiança entre esses provedores de identidades externos e a AWS, o usuário é atribuído a um perfil do IAM. O usuário também recebe credenciais temporárias que permitem que ele acesse seus recursos da AWS.

  Para obter mais informações sobre entidades principais federadas, consulte [Federação e provedores de identidade na AWS](id_roles_providers.md).
+ **Entidades principais federadas** são identidades existentes do Directory Service, do diretório de usuários da sua empresa ou de um provedor OIDC. A AWS atribui um perfil a uma entidade principal federada quando o acesso é solicitado por meio de um [provedor de identidade](id_roles_providers.md).

  Para obter mais informações sobre as entidades principais federadas SAML e OIDC, consulte [Sessões de usuários federados e perfis](introduction_access-management.md#intro-access-roles).
+ As **políticas de permissões** são políticas baseadas em identidade que definem quais ações e recursos o perfil pode usar. O documento é criado de acordo com as regras da linguagem da política do IAM. 

  Para obter mais informações, consulte [Referência de política JSON do IAM](reference_policies.md).
+ Os **limites de permissões** são um recurso avançado em que você usa políticas para limitar as permissões máximas que uma política baseada em identidade pode conceder a uma função. Você não pode aplicar um limite de permissões a uma função vinculada ao serviço.

  Para obter mais informações, consulte [Limites de permissões para entidades do IAM](access_policies_boundaries.md).

# O problema "confused deputy"
<a name="confused-deputy"></a>

O problema "confused deputy" é um problema de segurança em que uma entidade que não tem permissão para executar uma ação pode coagir uma entidade mais privilegiada a executar a ação. Para evitar isso, a AWS fornece ferramentas que ajudam você a proteger sua conta se você fornecer acesso aos recursos na sua conta a terceiros (conhecido como *entre contas*) ou a outros serviços da AWS (conhecido como *entre serviços*).

Às vezes, poderá ser necessário conceder acesso aos recursos da AWS a terceiros (delegar acesso). Por exemplo, você decide contratar uma empresa terceirizada chamada Example Corp para monitorar sua Conta da AWS e ajudar a otimizar os custos. Para rastrear seus gastos diários, a Example Corp precisa de acesso aos seus recursos da AWS. A Example Corp também monitora muitas outras Contas da AWS para outros clientes. É possível usar um perfil do IAM para estabelecer uma relação de confiança entre sua Conta da AWS e a conta da Example Corp. Um aspecto importante desse cenário é o *ID externo*, um identificador opcional que você pode usar em uma política de confiança do perfil do IAM para designar quem pode assumir ao perfil. A função principal do ID externo é abordar e impedir o problema "confused deputy".

Alguns serviços (serviços de chamada) da AWS usam a entidade principal do serviço da AWS para acessar recursos da AWS de outros serviços da AWS (serviços chamados). Em algumas dessas interações de serviços, você pode configurar serviços de chamada para se comunicarem com os recursos de um serviço chamado em outra Conta da AWS. Um exemplo disso é configurar o AWS CloudTrail para gravar em um bucket central do Amazon S3 localizado em outra Conta da AWS. É concedido ao serviço de chamadas CloudTrail acesso ao bucket do S3 usando a política de bucket do S3 por meio da adição de uma instrução de permissão para `cloudtrail.amazonaws.com`.

Quando uma entidade principal de serviço da AWS de um serviço de chamada está acessando um recurso de um serviço chamado, a política de recursos do serviço chamado está autorizando somente a entidade principal do serviço AWS, e não o ator que configurou o serviço de chamada. Por exemplo, um bucket do S3 que confia na entidade principal do serviço CloudTrail sem condições pode receber logs do CloudTrail das Contas da AWS configuradas por um administrador confiável, mas também logs do CloudTrail de um agente não autorizado em sua Conta da AWS, se ele souber o nome do bucket do Amazon S3.

O problema "confused deputy" surge quando um ator usa a confiança de uma entidade principal de um serviço da AWS para obter acesso a recursos aos quais não deveria ter acesso.

## Prevenção de "confused deputy" entre contas
<a name="mitigate-confused-deputy"></a>

O diagrama a seguir ilustra o problema "confused deputy" entre contas.

![\[A descrição de um problema "confused deputy"\]](http://docs.aws.amazon.com/pt_br/IAM/latest/UserGuide/images/confuseddeputyproblem2.png)


Este cenário supõe o seguinte:
+ **AWS1** é a sua Conta da AWS.
+ **AWS1:ExampleRole** é uma função em sua conta. Esta política de confiança da função confia na Example Corp especificando a conta da AWS da Example Corp como a conta que pode assumir a função.

Veja o que acontece:

1. Ao começar a usar o serviço da Exemplo Corp, você fornece o ARN **AWS1:ExampleRole** à Exemplo Corp.

1. A Example Corp usa esse ARN de perfil para obter credenciais de segurança temporárias para acessar recursos na sua Conta da AWS. Dessa forma, confie na Example Corp como um "substituto" que pode agir em seu nome.

1. Outro cliente da AWS também começa a usar os serviços da Exemplo Corp e também fornece o ARN **AWS1:ExampleRole** para a Exemplo Corp usar. Provavelmente, o outro cliente soube ou adivinhou o **AWS1:ExampleRole**, que não é um segredo.

1. Quando o outro cliente pede à Exemplo Corp que acesse os recursos da AWS (o que ele afirma ser) em sua conta, a Exemplo Corp usa **AWS1:ExampleRole** para acessar os recursos da sua conta.

Dessa forma, o outro cliente pode obter acesso não autorizado aos seus recursos. Como esse outro cliente foi capaz de burlar a Example Corp para agir involuntariamente em seus recursos, a Example Corp agora é um "confused deputy."

A Example Corp pode abordar o problema "confused deputy" exigindo que você inclua a verificação de condição `ExternalId` na política de confiança da função. A Example Corp gera um único valor de `ExternalId` para cada cliente e usa esse valor em sua solicitação para assumir a função. O valor de `ExternalId` deve ser exclusivo entre os clientes da Example Corp e controlado pela Example Corp, não por seus clientes. É por isso que ele é fornecido pela Example Corp e não é criado por você. Isso impede que a Example Corp seja um "confused deputy" e conceda acesso a recursos da AWS de outra conta.

Em nosso cenário, imagine que seu identificador exclusivo da Example Corp seja 12345 e que o identificador do outro cliente seja 67890. Esses identificadores são simplificados para esse cenário. Em geral, esses identificadores são GUIDs. Supondo que esses identificadores sejam exclusivos entre os clientes da Example Corp, eles são valores confidenciais próprios para o ID externo. 

A Example Corp atribui o valor do ID externo "12345" a você. É necessário adicionar um elemento `Condition` à política de confiança do perfil que exija que o valor [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#condition-keys-sts](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#condition-keys-sts) seja 12345, da seguinte forma:

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Principal": {
      "AWS": "Example Corp's AWS Account ID"
    },
    "Action": "sts:AssumeRole",
    "Condition": {
      "StringEquals": {
        "sts:ExternalId": "12345"
      }
    }
  }
}
```

------

O elemento Condition (Condição) dessa política só permite que a Example Corp assuma a função quando a chamada de API AssumeRole incluir o valor do ID externo 12345. A Example Corp garante que sempre que assumir uma função em nome de um cliente, incluirá o valor do ID externo desse cliente em uma chamada AssumeRole. Mesmo que outro cliente forneça seu ARN à Example Corp, ele não poderá controlar o ID externo que a Example Corp inclui em sua solicitação para a AWS. Isso ajuda a evitar que um cliente não autorizado tenha acesso aos seus recursos.

O diagrama a seguir ilustra isso.

![\[Como mitigar um problema "confused deputy".\]](http://docs.aws.amazon.com/pt_br/IAM/latest/UserGuide/images/confuseddeputymitigation2.png)


1. Como antes, ao começar a usar o serviço da Exemplo Corp, você fornece o ARN **AWS1:ExampleRole** à Exemplo Corp.

1.  Quando a Exemplo Corp usa esse ARN de perfil para assumir a função **AWS1:ExampleRole**, ela inclui o ID externo (12345) na chamada de API AssumeRole. O ID externo corresponde à política de confiança da perfil e, portanto, a chamada de API AssumeRole tem êxito, e a Example Corp obtém credenciais de segurança temporárias para acessar recursos na sua Conta da AWS.

1. Outro cliente da AWS também começa a usar os serviços da Exemplo Corp e, assim como antes, esse cliente também fornece o ARN **AWS1:ExampleRole** para a Exemplo Corp usar. 

1. Mas, desta vez, quando a Exemplo Corp tenta assumir a função **AWS1:ExampleRole**, ela fornece o ID externo associado a outro cliente (67890). O outro cliente não tem como alterar isso. A Example Corp faz isso porque a solicitação para usar a função veio de outro cliente, portanto, 67890 indica a circunstância em que a Example Corp está atuando. Como você adicionou uma condição com seu próprio ID externo (12345) à política de confiança de **AWS1:ExampleRole**, a chamada de API AssumeRole não vai funcionar. O outro cliente será impedido de obter o acesso não autorizado aos recursos na sua conta (indicado pelo "X" vermelho no diagrama).

O ID externo ajuda a prevenir que qualquer outro cliente engane a Example Corp a acessar seus recursos involuntariamente.

## Prevenção do problema "confused deputy" entre serviços
<a name="cross-service-confused-deputy-prevention"></a>

O diagrama a seguir demonstra o problema "confused deputy" entre serviços usando o exemplo de interação entre o CloudTrail e o Amazon S3, em que um ator não autorizado grava logs do CloudTrail em um bucket do Amazon S3 ao qual não está autorizado a ter acesso.

![\[Um ator não autorizado recebe acesso a um bucket do Amazon S3 em outra conta usando a entidade principal do serviço do CloudTrail.\]](http://docs.aws.amazon.com/pt_br/IAM/latest/UserGuide/images/cross-service-confused-deputy1.png)


Para ajudar a evitar que um ator não autorizado use a confiança de uma entidade principal da AWS para obter acesso aos seus recursos, as entidades principais de serviços da AWS incluem informações sobre o recurso da AWS, a Conta da AWS e a organização da AWS em nome dos quais estão agindo.

Essas informações estão disponíveis em valores-chave de condições globais que podem ser usados em uma política de recursos ou política de controle de recursos para solicitações feitas pelas entidades principais de serviços da AWS. Recomendamos usar [aws:SourceArn](reference_policies_condition-keys.md#condition-keys-sourcearn), [aws:SourceAccount](reference_policies_condition-keys.md#condition-keys-sourceaccount), [aws:SourceOrgID](reference_policies_condition-keys.md#condition-keys-sourceorgid) ou [aws:SourceOrgPaths](reference_policies_condition-keys.md#condition-keys-sourceorgpaths) nas políticas de recursos sempre que uma entidade principal de serviço da AWS receber permissão para acessar um dos seus recursos. Essas chaves de condição permitem que você teste nas políticas de recursos ou nas políticas de controle de recursos se as entidades principais de serviços da AWS que acessam os recursos estão fazendo isso em nome dos recursos da AWS, das Contas da AWS ou do AWS Organizations que você espera.
+ Use `aws:SourceArn` para permitir que uma entidade principal de serviço da AWS acesse os recursos em nome de um recurso específico, como uma trilha do AWS CloudTrail específica ou uma frota do AppStream.
+ Use `aws:SourceAccount` para permitir que uma entidade principal de serviço da AWS acesse os recursos em nome de uma Conta da AWS específica.
+ Use `aws:SourceOrgID` para permitir que a entidade principal de um serviço da AWS acesse os seus recursos em nome de determinadas AWS Organizations.
+ Use `aws:SourceOrgPaths` para permitir que uma entidade principal de serviço da AWS acesse os recursos em nome de um caminho do AWS Organizations específico.

O diagrama a seguir demonstra o cenário de "confused deputy" entre serviços quando um recurso é configurado com a chave de contexto de condição global `aws:SourceAccount`, e um ator não autorizado de outra conta tenta acessar recursos da AWS aos quais não deveria ter acesso.

![\[Um ator não autorizado tem o acesso negado a um bucket do Amazon S3 em outra conta usando a entidade principal do serviço do CloudTrail.\]](http://docs.aws.amazon.com/pt_br/IAM/latest/UserGuide/images/cross-service-confused-deputy2.png)


Usar as chaves de condição global `aws:SourceArn`, `aws:SourceAccount`, `aws:SourceOrgID` e `aws:SourceOrgPaths` em uma política ajuda a garantir que as entidades principais de serviços estejam acessando os recursos em seu nome. Recomendamos usar essas chaves de condição sempre que o acesso a um de seus recursos for concedido a uma entidade principal de serviço da AWS. 

**nota**  
Algumas interações de AWS service (Serviço da AWS) têm controles adicionais para ajudar a proteger contra problemas "confused deputy" entre serviços que testam o acesso de usuários a um recurso. Por exemplo, quando uma concessão de chave do KMS é emitida para um AWS service (Serviço da AWS), o AWS KMS usa o contexto de criptografia associado ao recurso e a concessão de chave para ajudar a proteger contra problemas "confused deputy" entre serviços.  
Consulte a documentação dos serviços que você usa para obter mais informações sobre os mecanismos específicos dos serviços que podem ajudar a evitar os riscos de "confused deputy" entre serviços e se `aws:SourceArn`, `aws:SourceAccount`, `aws:SourceOrgID` e `aws:SourceOrgPaths` são compatíveis.

## Proteção contra "confused deputy" entre serviços com políticas baseadas em recursos
<a name="cross-service-confused-deputy-prevention-resource"></a>

O exemplo de política a seguir concede à entidade principal de serviço `cloudtrail.amazonaws.com` acesso ao bucket do Amazon S3, arn:aws:s3:::amzn-s3-demo-bucket1, somente quando a entidade principal de serviço está agindo em nome da Conta da AWS 111122223333.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "CloudTrailAclCheck",
            "Effect": "Allow",
            "Principal": {"Service": "cloudtrail.amazonaws.com"},
            "Action": "s3:GetBucketAcl",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket1",
            "Condition": {
                "StringEquals": {
                    "aws:SourceAccount": "111122223333"
                }
            }
        },
        {
            "Sid": "AWSCloudTrailWrite",
            "Effect": "Allow",
            "Principal": {"Service": "cloudtrail.amazonaws.com"},
            "Action": "s3:PutObject",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket1/[optionalPrefix]/Logs/myAccountID/*",
            "Condition": {
                "StringEquals": {
                    "aws:SourceAccount": "111122223333"
                }
            }
        }
    ]
}
```

------

Esse exemplo de política de bucket concede à entidade principal de serviço `appstream.amazonaws.com` acesso ao script do PowerShell examplefile.psh em s3://amzn-s3-demo-bucket2 somente quando ele está agindo em nome da frota especificada do Amazon AppStream, especificando o ARN da frota com `aws:SourceArn`.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": [
                    "appstream.amazonaws.com"
                ]
            },
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket2/examplefile.psh",
            "Condition": {
                "ArnEquals": {
                    "aws:SourceArn": "arn:aws:appstream:us-east-1:111122223333:fleet/ExampleFleetName"
                } 
            }
        }
    ]
}
```

------

## Proteção contra "confused deputy" entre serviços com políticas de controle de recursos
<a name="cross-service-confused-deputy-prevention-resource-control"></a>

Você pode usar políticas de controle de recursos (RCP) para aplicar controles contra "confused deputy" entre serviços aos recursos de Serviços da AWS compatíveis. As RCPs permitem que você aplique de forma centralizada controles contra "confused deputy" entre serviços em seus recursos. Você pode usar chaves de condição como `aws:SourceOrgId` e `aws:SourceOrgPaths` com RCPs anexadas ao AWS Organizations, a unidades organizacionais (OU) ou a Contas da AWS em sua organização sem adicionar instruções a políticas específicas baseadas em recursos. Para obter mais informações sobre RCPs e serviços compatíveis, consulte [Políticas de Controle de Recursos (RCP)](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_rcps.html) no *Guia do usuário do AWS Organizations*.

O exemplo a seguir de RCP nega às entidades principais de serviço da AWS o acesso aos buckets do Amazon S3 nas contas de membros quando `aws:SourceOrgID` não é igual a o-ExampleOrg. Uma permissão correspondente deve estar presente na política baseada em recursos do bucket do Amazon S3 para permitir as entidades principais do AWS service (Serviço da AWS) com um `SourceOrgID` igual a o-ExampleOrg.

Essa política aplica o controle somente nas solicitações das entidades principais de serviço (`"Bool": {"aws:PrincipalIsAWSService": "true"}`) que tenham a chave `aws:SourceAccount` presente (`"Null": {"aws:SourceAccount": "false"}`), de modo que as integrações de serviços que não exijam o uso da chave de condição e as chamadas pelas entidades principais não sejam afetadas. Se a chave de condição `aws:SourceAccount` estiver presente no contexto da solicitação, a condição de anulação será avaliada como true, fazendo com que `aws:SourceOrgID` seja aplicada. Usamos `aws:SourceAccount` em vez de `aws:SourceOrgID` no operador de condição de anulação para que o controle ainda se seja aplicado caso a solicitação se origine de uma conta que não pertença a uma organização.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "RCPEnforceConfusedDeputyProtectionForS3",
      "Effect": "Deny",
      "Principal": "*",
      "Action": [
        "s3:*"
      ],
      "Resource": "*",
      "Condition": {
        "StringNotEqualsIfExists": {
          "aws:SourceOrgID": "o-ExampleOrg"
        },
        "Null": {
          "aws:SourceAccount": "false"
        },
        "Bool": {
          "aws:PrincipalIsAWSService": "true"
        }
      }
    }
  ]
}
```

------

# Cenários comuns para perfis do IAM
<a name="id_roles_common-scenarios"></a>

Assim como ocorre com a maioria dos recursos da AWS, você geralmente tem duas maneiras de usar uma função: interativamente no console do IAM ou de forma programática com a AWS CLI, o Tools for Windows PowerShell ou a API.
+ Os usuários do IAM na sua conta que estiverem usando o console do IAM podem *mudar para* uma função para usarem, temporariamente, as permissões da função no console. Os usuários cedem suas permissões originais e assumem as permissões atribuídas à função. Quando os usuários saem da função, suas permissões originais são restauradas.
+ Uma aplicação ou um serviço oferecido pela AWS (como o Amazon EC2) pode *assumir* uma função ao solicitar credenciais de segurança temporárias para uma função com as quais faça solicitações, de forma programática, para a AWS. Use uma função dessa forma para que você não precise compartilhar ou manter credenciais de segurança de longo prazo (por exemplo, criando um usuário do IAM) para cada entidade que necessite de acesso a um recurso.

**nota**  
Esse guia usa as frases *mudar para uma função* e *assumir uma função* de forma intercambiável.

A maneira mais simples de usar perfis é conceder aos seus usuários do IAM permissões para mudar para os perfis que você cria dentro da sua própria conta ou em outra Conta da AWS. Eles podem mudar de funções facilmente usando o console do IAM para usar permissões que você normalmente não deseja que eles tenham e, depois, sair da função para devolver essas permissões. Isso pode ajudar a impedir o acesso *acidental* ou a modificação de recursos confidenciais.

Para obter mais utilizações complexas de funções, como concessão de acesso a aplicativos e serviços ou usuários externos federados, chame a API `AssumeRole`. Essa chamada de API retorna um conjunto de credenciais temporárias que o aplicativo pode usar em chamadas de API subsequentes. Ações executadas com as credenciais temporárias têm apenas as permissões concedidas pela função associada. Um aplicativo não precisa "sair" de uma função da mesma forma que um usuário no console; em vez disso, o aplicativo simplesmente é interrompido usando as credenciais temporárias e continua fazendo chamadas com as credenciais originais.

Os usuários federados fazem login usando credenciais de um provedor de identidade (IdP). A AWS fornece credenciais temporárias ao IdP confiável para serem transmitidas ao usuário e incluídas em solicitações de recursos subsequentes da AWS. Essas credenciais fornecem as permissões concedidas para a função atribuída.

Essa seção fornece uma visão geral dos seguintes cenários:
+ [Fornecer acesso para um usuário do IAM em uma Conta da AWS que você possui para acessar recursos em outra conta que você possui](id_roles_common-scenarios_aws-accounts.md)
+ [Fornecer acesso a workloads que não são da AWS](id_roles_common-scenarios_non-aws.md)
+ [Fornecer acesso a usuários do IAM em Contas da AWS de terceiros](id_roles_common-scenarios_third-party.md)
+ [Fornecer acesso para serviços oferecidos pela AWS para recursos da AWS](id_roles_common-scenarios_services.md)
+ [Fornecer acesso aos usuários autenticados externamente (federação de identidades)](id_roles_common-scenarios_federated-users.md)

# Acesso a um usuário do IAM em outra Conta da AWS de sua propriedade
<a name="id_roles_common-scenarios_aws-accounts"></a>

Você pode conceder aos usuários do IAM permissões para alternar para perfis na sua Conta da AWS ou para perfis definidos em outras Contas da AWS que você possui. 

**nota**  
Se deseja conceder acesso a uma conta que você não possui ou controla, veja [Acesso às Contas da AWS de propriedade de terceiros](id_roles_common-scenarios_third-party.md) mais adiante neste tópico. 

Imagine que você tenha instâncias do Amazon EC2 que são críticas para sua organização. Em vez de conceder diretamente aos usuários permissão para encerrar as instâncias, você pode criar uma função com esses privilégios. Em seguida, permita que os administradores alternem para a função quando eles precisam encerrar uma instância. Isso adiciona as seguintes camadas de proteção para as instâncias:
+ É necessário conceder explicitamente aos usuários permissão para assumir a função.
+ Os usuários devem alternar ativamente para a função usando o Console de gerenciamento da AWS ou assumir a função usando a AWS CLI ou a API da AWS.
+ Você pode adicionar a proteção de autenticação multifator (MFA) à função para que somente os usuários que fizerem login com um dispositivo MFA possam assumir a função. Para saber como configurar uma função de maneira que os usuários que assumem a função precisem primeiro ser autenticados usando a autenticação multifator (MFA), consulte [Acesso seguro à API com a MFA](id_credentials_mfa_configure-api-require.md).

Recomendamos usar essa abordagem para aplicar o *princípio do privilégio mínimo*. Isso significa restringir o uso de permissões elevadas para apenas quando elas forem necessárias para tarefas específicas. Com as funções, você pode ajudar a evitar alterações acidentais em ambientes confidenciais, especialmente se você combiná-las com uma [auditoria](cloudtrail-integration.md) para ajudar a garantir que as funções sejam usadas apenas quando necessário.

Quando cria uma função com esse propósito, você especifica as contas pelo ID cujos usuários precisam de acesso no elemento `Principal` da política de confiança da função. Depois, você pode conceder permissões a usuários específicos nessas outras contas para alternar para a função. Para saber se as entidades de contas fora de sua zona de confiança (organização confiável ou conta) têm acesso para assumir as suas funções, consulte [O que é o IAM Access Analyzer?](https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html).

Um usuário em uma conta pode alternar para uma função na mesma conta ou em uma diferente. Ao usar a função, o usuário pode executar somente as ações e acessar somente os recursos permitidos pela função; as permissões originais do usuário são suspensas. Quando o usuário fecha a função, as permissões originais do usuário são restauradas.

## Cenário de exemplo que usa contas separadas de desenvolvimento e produção
<a name="id_roles_common-scenarios_aws-accounts-example"></a>

Imagine que sua organização tenha várias Contas da AWS para isolar um ambiente de desenvolvimento de um ambiente de produção. Os usuários na conta de desenvolvimento podem precisar acessar os recursos na conta de produção. Por exemplo, você pode precisar de acesso entre contas ao promover uma atualização do ambiente de desenvolvimento para um ambiente de produção. Embora você pudesse criar identidades (e senhas) separadas para os usuários que trabalham nas duas contas, gerenciar credenciais para várias contas dificulta o gerenciamento de identidades. Na figura a seguir, todos os usuários são gerenciados na conta de desenvolvimento, mas alguns desenvolvedores exigem acesso limitado à conta de produção. A conta de desenvolvimento tem dois grupos: os testadores e os desenvolvedores, e cada grupo tem sua própria política.

![\[Use uma função para delegar permissões para um usuário em uma conta diferente\]](http://docs.aws.amazon.com/pt_br/IAM/latest/UserGuide/images/roles-usingroletodelegate.png)


1. Na conta de produção, um administrador usa o IAM para criar a função `UpdateApp` nessa conta. Na função, o administrador define uma política de confiança que especifica a conta de desenvolvimento como `Principal`, o que significa que usuários autorizados da conta de desenvolvimento podem usar a função `UpdateApp`. O administrador também define uma política de permissões para a função que especifica as permissões de leitura e gravação para o bucket do Amazon S3 denominado `productionapp`.

   O administrador acaba compartilhando as informações apropriadas com qualquer pessoa que precise assumir a função. Essas informações são o número da conta e o nome da função (para usuários do console da AWS) ou o Amazon Resource Name (ARN) (para acesso à AWS CLI ou à API da AWS). O ARN da função pode ser semelhante a `arn:aws:iam::123456789012:role/UpdateApp`, em que a função se chama `UpdateApp` e foi criada na conta de número 123456789012.
**nota**  
O administrador pode optar por configurar a função para que os usuários que assumirem a função precisem primeiro ser autenticados usando a autenticação multifator (MFA). Para obter mais informações, consulte [Acesso seguro à API com a MFA](id_credentials_mfa_configure-api-require.md). 

1. Na conta de desenvolvimento, um administrador concede aos membros do grupo de desenvolvedores permissão para alternar para a função. Isso é feito ao conceder ao grupo de desenvolvedores a permissão para chamar a API AWS Security Token Service do AWS STS (`AssumeRole`) para a função `UpdateApp`. Qualquer usuário do IAM que pertença ao grupo de desenvolvedores na conta de desenvolvimento agora pode alternar para a função `UpdateApp` na conta de produção. Outros usuários que não estão no grupo de desenvolvedor não têm permissão para alternar para a função e, portanto, não podem acessar o bucket do S3 na conta de produção.

1. As solicitações do usuário alternam para a função:
   + Console da AWS: O usuário escolhe o nome da conta na barra de navegação e escolhe **Mudar de função**. O usuário especifica o ID da conta (ou alias) e o nome da função. Como alternativa, o usuário pode clicar em um link enviado por e-mail pelo administrador. O link leva o usuário para a página **Alternar função** com os detalhes já preenchidos.
   + API da AWS/AWS CLI : Um usuário no grupo de desenvolvedores da conta de desenvolvimento chama a função `AssumeRole` para obter credenciais para a função `UpdateApp`. O usuário especifica o ARN da função `UpdateApp` como parte da chamada. Se um usuário no grupo de testadores faz a mesma solicitação, a solicitação falha porque os testadores não têm permissão para chamar `AssumeRole` para o ARN da função `UpdateApp`.

1. AWS STSO retorna credenciais temporárias:
   + Console da AWS: o AWS STS verifica a solicitação com a política de confiança da função para garantir que a solicitação é de uma entidade confiável (que é a conta de desenvolvimento). Após a verificação, o AWS STS retorna as [credenciais de segurança temporárias](https://docs.aws.amazon.com/STS/latest/UsingSTS/Welcome.html) ao console da AWS.
   + API/CLI: o AWS STS verifica a solicitação em relação à política de confiança da função para garantir que a solicitação é de uma entidade confiável (que é a conta de desenvolvimento). Após a verificação, o AWS STS retorna as [credenciais de segurança temporárias](https://docs.aws.amazon.com/STS/latest/UsingSTS/Welcome.html) ao aplicativo.

1. As credenciais temporárias permitem acesso aos recursos da AWS:
   + Console da AWS: o console da AWS usa as credenciais temporárias em nome do usuário para todas as ações subsequentes do console, nesse caso, para ler e gravar no bucket `productionapp`. O console não pode acessar qualquer outro recurso na conta de produção. Quando o usuário fecha a função, as permissões do usuário revertem para as permissões mantidas antes de alternar para a função.
   + API/CLI: o aplicativo usa as credenciais de segurança temporárias para atualizar o bucket `productionapp`. Com as credenciais de segurança temporárias, o aplicativo só poderá ler e gravar no bucket `productionapp` e não poderá acessar qualquer outro recurso na conta de produção. O aplicativo não tem que sair da função, mas, em vez disso, interromper o uso de credenciais temporárias e usar as credenciais nas chamadas de API subsequentes.

## Recursos adicionais
<a name="id_roles_common-scenarios_more-info"></a>

Para saber mais, consulte:
+ [Tutorial do IAM: Delegar acesso entre contas da AWS usando funções do IAM](tutorial_cross-account-with-roles.md)

# Acesso para workloads que não sejam da AWS
<a name="id_roles_common-scenarios_non-aws"></a>

Um [perfil do IAM](id_roles.md) é um objeto no AWS Identity and Access Management (IAM) que recebe [permissões](access_policies.md). Quando você [assume esse perfil](id_roles_manage-assume.md) usando uma identidade do IAM ou uma identidade de fora da AWS, credenciais de segurança temporárias são fornecidas para sua sessão de perfil. Você pode ter workloads em execução em seu data center ou em outra infraestrutura fora da AWS que precisem acessar seus recursos da AWS. Em vez de criar, distribuir e gerenciar chaves de acesso de longo prazo, você pode usar o AWS Identity and Access Management Roles Anywhere (IAM Roles Anywhere) para autenticar suas workloads que não são da AWS. O IAM Roles Anywhere usa certificados X.509 de sua autoridade de certificação (CA) para autenticar identidades e fornecer acesso seguro aos Serviços da AWS com as credenciais temporárias fornecidas por um perfil do IAM.

**Para usar o IAM Roles Anywhere**

1. Configure uma CA usando o [Autoridade de Certificação Privada da AWS](https://docs.aws.amazon.com/privateca/latest/userguide/PcaWelcome.html) ou use uma CA de sua própria infraestrutura de PKI.

1. Depois de configurar uma CA, crie um objeto no IAM Roles Anywhere chamado *âncora de confiança*. Essa âncora estabelece confiança entre o IAM Roles Anywhere e sua CA para autenticação.

1. Em seguida, você pode configurar seus perfis existentes do IAM ou criar novos perfis que confiam no serviço do IAM Roles Anywhere.

1. Autentique suas workloads não AWS com o IAM Roles Anywhere usando a âncora de confiança. A AWS concede credenciais temporárias às workloads que não sejam da AWS para o perfil do IAM que tem acesso aos seus recursos da AWS.

## Recursos adicionais
<a name="id_roles_non-aws_additional_resources"></a>

Os recursos a seguir podem ajudar você a saber mais sobre como fornecer acesso a workloads que não sejam da AWS.
+ Para obter mais informações sobre como configurar o IAM Roles Anywhere, consulte [O que é o AWS Identity and Access Management Roles Anywhere](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/introduction.html) no *Guia do usuário do IAM Roles Anywhere*.
+ Para saber como configurar a infraestrutura de chave pública (PKI) para o IAM Roles Anywhere, consulte [IAM Roles Anywhere with an external certificate authority](https://aws.amazon.com/blogs/) no *Blog de segurança da AWS*.

# Acesso às Contas da AWS de propriedade de terceiros
<a name="id_roles_common-scenarios_third-party"></a>

Quando terceiros precisam de acesso a recursos da AWS da sua organização, você pode usar funções para delegar acesso a eles. Por exemplo, um terceiro pode fornecer um serviço para gerenciar seus recursos da AWS. Com funções do IAM, você pode conceder a esses terceiros acesso aos seus recursos da AWS sem compartilhar suas credenciais de segurança da AWS. Em vez disso, os terceiros podem acessar seus recursos da AWS assumindo um perfil que você cria na sua Conta da AWS. Para saber se as entidades de contas fora de sua zona de confiança (organização confiável ou conta) têm acesso para assumir as suas funções, consulte [O que é o IAM Access Analyzer?](https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html).

Esses terceiros devem fornecer as seguintes informações para criar uma função que eles podem assumir:
+ **O ID da Conta da AWS do terceiro**. Você especifica o ID da Conta da AWS dele como a entidade principal ao definir a política de confiança para o perfil.
+ **Um ID externo a ser associado de forma exclusiva ao perfil.** O ID externo pode ser qualquer identificador secreto conhecido apenas por você e pelo terceiro. Por exemplo, você pode usar um ID da fatura entre você e o terceiro, mas não use algo que possa ser adivinhado, como o nome ou o número de telefone do terceiro. Você deve especificar esse ID ao definir a política de confiança para a função. O terceiro deve fornecer esse ID quando assumir a função.
+ **As permissões de que terceiros precisam para trabalhar com seus recursos da AWS**. Você deve especificar essas permissões ao definir a política de permissões da função. Essa política define quais ações podem ser tomadas e quais recursos podem ser acessados.

Depois de criar a função, você deve fornecer o nome de recurso da Amazon (ARN) ao terceiro. Eles requerem o ARN de sua função para assumir a função.

**Importante**  
Quando você concede a terceiros acesso aos seus recursos da AWS, eles podem acessar qualquer recurso que você especifique na política. O uso de seus recursos é cobrado de você. Certifique-se de limitar o uso de seus recursos de forma apropriada.

## ID externos para acesso de terceiros
<a name="id_roles_third-party_external-id"></a>

Um ID externo permite que o usuário que está assumindo o perfil assegure as circunstâncias nas quais elas operam. Também oferece uma forma para o proprietário da conta permitir que a função seja assumida apenas em determinadas circunstâncias. A função principal do ID externo é abordar e impedir o [O problema "confused deputy"](confused-deputy.md).

**Importante**  
AWSA não trata o ID externo como um segredo. Depois de criar um segredo, como um par de chaves de acesso ou uma senha na AWS, você não poderá visualizá-las novamente. O ID externo de uma função pode ser visto por qualquer pessoa com permissão para visualizar a função. 

## Quando devo usar um ID externo?
<a name="external-id-use"></a>

Use um ID externo nas seguintes situações:
+ Você é proprietário de uma Conta da AWS e configurou uma perfil para um terceiro que acessa outras Contas da AWS além da sua. Você deve solicitar um ID externo ao terceiro que ele inclui quando assume a sua função. Depois, você verifica o ID externo na política de confiança da sua função. Isso garante que o terceiro externo possa assumir sua função somente quando estiver agindo em seu nome.
+ Você está na posição de assumir funções em nome de clientes diferentes, como a Example Corp em nosso cenário anterior. Você deve atribuir um ID externo exclusivo para cada cliente e instruí-los a adicionar o ID externo à política de confiança de sua função. Certifique-se de sempre incluir o ID externo correto em suas solicitações para assumir funções.

  Provavelmente, você já tem um identificador exclusivo para cada um de seus clientes e esse ID exclusivo será suficiente para ser usado como ID externo. O ID externo não é um valor especial que você precisa criar, explicitamente, ou rastrear, separadamente, apenas para essa finalidade.

  Sempre especifique o ID externo em suas chamadas de API `AssumeRole`. Quando um cliente oferecer a você um ARN da função, teste se você poderá assumir a função com e sem o ID externo correto. Se você assumir a função sem o ID externo correto, não armazene o ARN da função do cliente em seu sistema. Aguarde até que o cliente tenha atualizado a política de confiança de função para exigir o ID externo correto. Dessa forma, você ajudará seus clientes a agir da forma correta, mantendo-os protegidos contra o problema confused deputy.

## Exemplo de cenário usando um ID externo
<a name="id_roles_third-party_example"></a>

Por exemplo, suponha que você decida contratar uma empresa terceirizada chamada Example Corp para monitorar sua Conta da AWS e ajudar a otimizar os custos. Para rastrear seus gastos diários, a Example Corp precisa de acesso aos seus recursos da AWS. A Example Corp também monitora muitas outras contas da AWS para outros clientes.

Não dê à Exemplo Corp acesso a um usuário do IAM e suas credenciais de longo prazo na sua conta da AWS. Em vez disso, use uma função do IAM e suas credenciais de segurança temporárias. Um perfil do IAM fornece um mecanismo que permite o acesso de terceiros aos recursos da AWS sem a necessidade de compartilhar credenciais de longo prazo (como uma chave de acesso de usuário do IAM).

Você pode usar um perfil do IAM para estabelecer uma relação de confiança entre sua Conta da AWS e a conta da Example Corp. Depois que esse relacionamento for estabelecido, um membro da conta Exemplo Corp pode chamar a API [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) do AWS Security Token Service para obter credenciais de segurança temporárias. Os membros da Example Corp podem usar as credenciais para acessar recursos da AWS na sua conta. 

**nota**  
Para obter mais informações sobre AssumeRole e outras APIs da AWS que você pode chamar para obter credenciais de segurança temporárias, consulte [Compare credenciais do AWS STS](id_credentials_sts-comparison.md).

Veja aqui um detalhamento desse cenário:

1. Contrate a Example Corp, para que eles criem um identificador de clientes exclusivo para você. Eles fornecerão o ID de cliente exclusivo e o número da Conta da AWS deles. Essas informações são necessárias para criar uma função do IAM na próxima etapa. 
**nota**  
A Example Corp pode usar qualquer valor de string que desejar para o ExternalId, desde que seja exclusivo para cada cliente. Pode ser o número da conta de um cliente ou até mesmo uma string aleatória de caracteres, desde que dois clientes não tenham o mesmo valor. Isso não deve ser um "segredo". A Example Corp deve fornecer o valor do ExternalId para cada cliente. O essencial é que ele deve ser gerado pela Example Corp e ***não*** pelos clientes dela para garantir que cada ID externo seja exclusivo.

1. Faça login na AWS e crie uma função do IAM que dê à Exemplo Corp acesso aos seus recursos. Como qualquer função do IAM, a função tem duas políticas, uma política de permissão e uma política de confiança. A política de confiança da função especifica quem pode assumir a função. Em nosso cenário de exemplo, a política especifica o número de Conta da AWS da Example Corp como `Principal`. Isso permite que as identidades dessa conta assumam a função. Além disso, você adiciona um elemento `[Condition](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#Condition)` à política de confiança. Esse elemento `Condition` testa a chave de contexto `ExternalId` para garantir que ela corresponda ao ID do cliente exclusivo da Example Corp. Por exemplo:

   ```
       "Principal": {"AWS": "Example Corp's Conta da AWS ID"},
       "Condition": {"StringEquals": {"sts:ExternalId": "Unique ID Assigned by Example Corp"}}
   ```

1. A política de permissões da função especifica o que a função permite que alguém faça. Por exemplo, você pode especificar que a função permita que alguém gerencie apenas seus recursos do Amazon EC2 e Amazon RDS, mas não seus usuários ou grupos do IAM. Em nosso cenário de exemplo, use a política de permissões para dar acesso somente leitura à Example Corp a todos os recursos na sua conta.

1. Depois de criar a função, forneça o nome de recurso da Amazon (ARN) da função à Example Corp.

1. Quando a Exemplo Corp precisar acessar seus recursos da AWS, alguém da empresa chamará a API `sts:AssumeRole` da AWS. A chamada inclui o ARN da função a ser assumida e o parâmetro ExternalId que corresponde ao ID do cliente.

Se a solicitação vier de alguém que estiver usando a Conta da AWS da Example Corp, e se o ARN do perfil e o ID externo estiverem corretos, a solicitação será bem-sucedida. Nesse caso, ela fornecerá credenciais de segurança temporárias que a Example Corp poderá usar para acessar os recursos da AWS permitidos pela sua função.

Em outras palavras, quando uma política de função incluir um ID externo, qualquer pessoa que desejar assumir a função deverá ser especificada como um principal na função e deverá incluir o ID externo correto.

## Pontos-chave para IDs externos
<a name="id_roles_third-party_key-points"></a>
+ Em um ambiente de vários locatários onde você oferece suporte a vários clientes com AWS contas diferentes, recomendamos usar um ID externo por Conta da AWS. Esse ID deve ser uma string aleatória gerada por um terceiro.
+ Para exigir que o terceiro forneça um ID externo ao assumir uma função, atualize a política de confiança da função com o ID externo de sua escolha.
+ Para fornecer um ID externo quando você assumir uma função, use a AWS CLI ou a API da AWS para assumir essa função. Para obter mais informações, consulte a operação da API STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) ou a operação da CLI [assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html) STS.
+ O valor `ExternalId` deve ter no mínimo 2 e no máximo 1.224 caracteres. O valor deve ser alfanumérico sem espaço em branco. Ele também pode incluir os seguintes símbolos: mais (\$1), igual (=), vírgula (,), ponto (.), arroba (@), dois pontos (:), barra (/) e hífen (-).

## Recursos adicionais
<a name="id_roles_third-party_additional_resources"></a>

Os seguintes recursos podem ajudar você a saber mais sobre como fornecer acesso a Contas da AWS de terceiros.
+ Para saber mais sobre como permitir que outras pessoas realizem ações na sua Conta da AWS, consulte [Criar um perfil usando políticas de confiança personalizadas](id_roles_create_for-custom.md).
+ Para saber mais sobre como conceder permissão para alternar para um perfil, consulte [Conceder permissões a um usuário para alternar perfis](id_roles_use_permissions-to-switch.md)
+ Para saber mais sobre como criar e fornecer credenciais de segurança temporárias aos usuários confiáveis, [Permissões de credenciais de segurança temporárias](id_credentials_temp_control-access.md).

# Acesso a um serviço da AWS
<a name="id_roles_common-scenarios_services"></a>

Muitos serviços da AWS exigem que você use funções para controlar o que esse serviço pode acessar. A [função de serviço](id_roles.md#iam-term-service-role) é uma função que um serviço assume para realizar ações em seu nome. Quando uma função atende a uma finalidade especializada para um serviço, ela pode ser categorizada como uma [função vinculada ao serviço](id_roles.md#iam-term-service-linked-role). Consulte a [documentação da AWS](https://docs.aws.amazon.com/) de cada serviço para ver se ele usa funções e saber como atribuir uma função ao serviço a ser usado.

Para obter detalhes sobre a criação de uma função para delegar acesso a um serviço oferecido pela AWS, consulte [Criar um perfil para delegar permissões a um serviço da AWS](id_roles_create_for-service.md).

# Acesso aos usuários autenticados externamente (federação de identidades)
<a name="id_roles_common-scenarios_federated-users"></a>

Seus usuários podem já ter identidades fora da AWS, por exemplo, no diretório corporativo. Se esses usuários precisarem trabalhar com recursos da AWS (ou trabalhar com aplicações que acessem esses recursos), os usuários também precisarão de credenciais de segurança da AWS. Você pode usar uma função do IAM para especificar permissões para usuários cuja identidade é federada de sua organização ou de um provedor de identidade (IdP) de terceiros.

**nota**  
Como prática recomendada de segurança, recomendamos que você gerencie o acesso do usuário no [Centro de identidade do IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/what-is.html) com federação de identidades em vez de criar usuários do IAM. Para obter informações sobre situações específicas em que um usuário do IAM é necessário, consulte [Quando criar um usuário do IAM (em vez de um perfil)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_which-to-choose).

## Federação de usuários de um aplicativo móvel ou baseado na Web com o Amazon Cognito
<a name="id_roles_common-scenarios_federated-users-cognito"></a>

Se você criar um aplicativo móvel ou baseado na Web que acesse recursos da AWS, ele precisará de credenciais de segurança para fazer solicitações programáticas à AWS. Para a maioria dos cenários de aplicações móveis, recomendamos usar o [Amazon Cognito](https://aws.amazon.com/cognito/). Você pode usar esse serviço com o [AWS Mobile SDK para iOS](https://aws.amazon.com/sdkforios/) e o [AWS Mobile SDK para Android e Fire OS](https://aws.amazon.com/sdkforandroid/) a fim de criar identidades exclusivas para os usuários e autenticá-las para assegurar o acesso aos seus recursos da AWS. O Amazon Cognito oferece suporte aos mesmos provedores de identidade listados na próxima seção e também oferece suporte a [identidades autenticadas pelo desenvolvedor](https://aws.amazon.com/blogs/mobile/amazon-cognito-announcing-developer-authenticated-identities) e acesso não autenticado (de convidado). O Amazon Cognito também fornece operações de API para sincronização de dados de usuário para que eles sejam preservados à medida que passarem de um dispositivo para outro. Para obter mais informações, consulte [Amazon Cognito para aplicativos móveis](id_federation_common_scenarios.md#id_roles_providers_oidc_cognito). 

## Federação de usuários com provedores de serviços de identidade pública ou OpenID Connect
<a name="id_roles_common-scenarios_federated-users-openId"></a>

Sempre que possível, use o Amazon Cognito para cenários de aplicativos móveis e baseados na Web. O Amazon Cognito faz a maior parte do trabalho em segundo plano com os serviços do provedor de identidade pública para você. Ele funciona com os mesmos serviços de terceiros e também dá suporte a logins anônimos. No entanto, para cenários mais avançados, você pode trabalhar diretamente com um serviço de terceiros, como o Login with Amazon, Facebook, Google ou qualquer provedor compatível com o OpenID Connect (OIDC). Para obter mais informações sobre como usar a federação OIDC com um desses serviços, consulte [Federação OIDC](id_roles_providers_oidc.md).

## Federação de usuários com SAML 2.0
<a name="id_roles_common-scenarios_federated-users-saml20"></a>

Se sua organização já usa um pacote de software de provedor de identidade que ofereça suporte a SAML 2.0 (Security Assertion Markup Language 2.0), você poderá criar confiança entre a organização como provedor de identidade (IdP) e a AWS como o provedor de serviços. Em seguida, você pode usar SAML para fornecer aos usuários logon único (SSO) federado ao Console de gerenciamento da AWS ou acesso federado para chamar operações de API da AWS. Por exemplo, se sua empresa usa o Microsoft Active Directory e o Active Directory Federation Services, você poderá realizar a federação usando o SAML 2.0. Para obter mais informações sobre como federar usuários com SAML 2.0, consulte [Federação SAML 2.0](id_roles_providers_saml.md).

## Federação de usuários criando um aplicativo identity broker personalizado
<a name="id_roles_common-scenarios_federated-users-idbroker"></a>

Se o armazenamento de identidades não for compatível com o SAML 2.0, você poderá criar um aplicativo identity broker personalizado para executar uma função semelhante. O aplicativo agente autentica os usuários, solicita credenciais temporárias para usuários da AWS e, em seguida, as fornece ao usuário para acessar os recursos da AWS. 

Por exemplo, a Corp. de Exemplo tem muitos funcionários que precisam executar aplicativos internos que acessam os recursos da AWS da empresa. Os funcionários já têm identidades no sistema de autenticação e identidade da empresa, e a Corp. de Exemplo não deseja criar um usuário do IAM separado para cada funcionário da empresa.

Bob é um desenvolvedor na Corp. de Exemplo. Para permitir que os aplicativos internos da Corp. de Exemplo acessem os recursos da AWS da empresa, Bob desenvolve um aplicativo identity broker personalizado. O aplicativo confirma que os funcionários existentes estão conectados ao sistema de autenticação e identidade da Corp. de Exemplo, que pode usar LDAP, Active Directory ou outro sistema. O aplicativo identity broker, em seguida, obtém credenciais de segurança temporárias para os funcionários. Esse cenário é semelhante ao anterior (um aplicativo móvel que usa um sistema de autenticação personalizada), exceto pelo fato de que as aplicações que precisam de acesso a todos os recursos da AWS são executados dentro da rede corporativa, e a empresa tem um sistema de autenticação.

Para obter credenciais de segurança temporárias, o aplicativo identity broker chama `AssumeRole` ou `GetFederationToken` para obter credenciais de segurança temporárias, dependendo de como Bob precisa gerenciar as políticas para os usuários e quando as credenciais temporárias devem expirar. (Para obter mais informações sobre as diferenças entre essas operações de API, veja [Credenciais de segurança temporárias no IAM](id_credentials_temp.md) e [Permissões de credenciais de segurança temporárias](id_credentials_temp_control-access.md).) A chamada retorna as credenciais de segurança temporárias que consistem em um ID da chave de acesso da AWS, uma chave de acesso secreta e um token de sessão. O aplicativo identity broker torna essas credenciais temporárias de segurança disponíveis para os aplicativos internos da empresa. Em seguida, o aplicativo pode usar as credenciais temporárias para fazer chamadas para a AWS diretamente. O aplicativo armazena as credenciais em cache até elas expirarem e, em seguida, solicita um novo conjunto de credenciais temporárias. A figura a seguir ilustra esse cenário.

![\[Exemplo de fluxo de trabalho usando um aplicativo agente de identidades personalizado\]](http://docs.aws.amazon.com/pt_br/IAM/latest/UserGuide/images/enterprise-authentication-with-identity-broker-application.diagram.png)


Esse cenário tem os seguintes atributos:
+ A aplicação do agente de identidades tem permissões para acessar a API do serviço de token (STS) do IAM para criar credenciais de segurança temporárias.
+ O aplicativo identity broker é capaz de verificar se os funcionários estão autenticados dentro do sistema de autenticação existente.
+ Os usuários podem obter um URL temporário que forneça a elrd acesso ao Console de Gerenciamento da AWS (chamada de autenticação única).

Para obter informações sobre a criação de credenciais de segurança temporárias, consulte [Compare credenciais do AWS STS](id_credentials_sts-comparison.md). Para obter mais informações sobre como as entidades principais federadas SAML obtêm acesso ao Console de Gerenciamento da AWS, consulte [Habilitar o acesso das entidades principais federadas do SAML 2.0 ao Console de gerenciamento da AWS](id_roles_providers_enable-console-saml.md).

# Criar um perfil do IAM
<a name="id_roles_create"></a>

Para criar uma função você pode usar o Console de gerenciamento da AWS, a AWS CLI, o Tools for Windows PowerShell ou a API do IAM.

Se você usar o Console de gerenciamento da AWS, um assistente orienta você durante as etapas para a criação de uma função. O assistente tem etapas ligeiramente diferentes dependendo se você esta criando um perfil para um serviço da AWS, para uma Conta da AWS ou para uma entidade principal federada SAML ou OIDC.

**Perfis para usuários do IAM**  
Crie esse perfil para delegar permissões na sua Conta da AWS ou para perfis definidos em outras Contas da AWS que você possui. Um usuário em uma conta pode alternar para uma função na mesma conta ou em uma diferente. Ao usar a função, o usuário pode executar somente as ações e acessar somente os recursos permitidos pela função; as permissões originais do usuário são suspensas. Quando o usuário fecha a função, as permissões originais do usuário são restauradas.

Para obter mais informações, consulte [Criar um perfil para conceder permissões a um usuário do IAM](id_roles_create_for-user.md).

Para obter mais informações sobre a criação de perfis para acesso entre contas, consulte [Criar um perfil usando políticas de confiança personalizadas](id_roles_create_for-custom.md).

**Perfis para serviços da AWS**  
Crie esse perfil para delegar permissões a um serviço que pode realizar ações em seu nome. Um [perfil de serviço](id_roles.md#iam-term-service-role) que você passa para um serviço deve ter uma política do IAM com as permissões que possibilitem que o serviço realize ações associadas a esse serviço. Diferentes permissões são necessárias para cada um dos serviços da AWS.

Para obter mais informações sobre como criar perfis de serviço, consulte [Criar um perfil para delegar permissões a um serviço da AWS](id_roles_create_for-service.md).

Para obter mais informações sobre como criar perfis vinculados a serviço, consulte [Criar um perfil vinculado ao serviço](id_roles_create-service-linked-role.md).

**Perfis para federação de identidades**  
Crie esse perfil para delegar permissões a usuários que já têm identidades externas à AWS. Quando você usa um provedor de identidade do , não precisa criar código de login personalizado nem gerenciar suas próprias identidades de usuários. Os usuários externos fazem login por meio do IdP, e você pode conceder a essas identidades externas permissões para usar os recursos da AWS na sua conta. Os provedores de identidade ajudam a manter sua conta da AWS segura, pois você não precisa distribuir nem incorporar credenciais de segurança de longo prazo, como chaves de acesso, em sua aplicação.

Para obter mais informações, consulte [Criar um perfil para um provedor de identidade de terceiros](id_roles_create_for-idp.md).

# Criar um perfil para conceder permissões a um usuário do IAM
<a name="id_roles_create_for-user"></a>

É possível usar perfis do IAM para delegar acesso aos seus recursos da AWS. Com funções do IAM, você pode estabelecer relações de confiança entre sua conta de *confiança* e outras contas *confiáveis* da AWS. A conta de confiança tem o recurso a ser acessado e a conta confiável contém os usuários que precisam de acesso ao recurso. No entanto, é possível que outra conta tenha um recurso em sua conta. Por exemplo, a conta de confiança pode permitir que a conta confiável crie novos recursos, como a criação de novos objetos em um bucket do Amazon S3. Nesse caso, a conta que cria o recurso possui o recurso e controla quem pode acessar esse recurso.

Depois de criar a relação de confiança, um usuário do IAM ou um aplicativo da conta confiável pode usar a operação [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) da API do AWS Security Token Service (AWS STS). Essa operação fornece credenciais de segurança temporárias que permitem acesso aos recursos da AWS em sua conta.

As contas podem ser controladas por você ou a conta com os usuários pode ser controlada por terceiros. Se a outra conta com os usuários for uma Conta da AWS controlada por você, use o atributo `externalId`. O ID externo pode ser qualquer palavra ou número combinado entre você e o administrador da conta de terceiros. Esta opção adiciona automaticamente uma condição à política de confiança que permite ao usuário assumir a função somente se a solicitação incluir o correto `sts:ExternalID`. Para obter mais informações, consulte [Acesso às Contas da AWS de propriedade de terceiros](id_roles_common-scenarios_third-party.md).

Para obter informações sobre como usar funções para delegar permissões, consulte [Termos e conceitos das funções](id_roles.md#id_roles_terms-and-concepts). Para obter mais informações sobre o uso de uma função de serviço para permitir que os serviços acessem recursos na sua conta, consulte [Criar um perfil para delegar permissões a um serviço da AWS](id_roles_create_for-service.md).

## Criação de uma função do IAM (console)
<a name="roles-creatingrole-user-console"></a>

Você pode usar o Console de gerenciamento da AWS para criar uma função que um usuário do IAM pode assumir. Por exemplo, suponha que sua organização tem várias Contas da AWS para isolar um ambiente de desenvolvimento de um ambiente de produção. Para obter informações de alto nível sobre a criação de uma função que permita que os usuários na conta de desenvolvimento acessem recursos na conta de produção, consulte [Cenário de exemplo que usa contas separadas de desenvolvimento e produção](id_roles_common-scenarios_aws-accounts.md#id_roles_common-scenarios_aws-accounts-example).

**Permissões mínimas**  
Para executar as etapas a seguir, é necessário ter as seguintes permissões do IAM:  
`access-analyzer:ValidatePolicy`
`iam:AttachRolePolicy`
`iam:CreatePolicy`
`iam:CreateRole`
`iam:GetAccountSummary`
`iam:GetPolicy`
`iam:GetPolicyVersion`
`iam:GetRole`
`iam:ListAccountAliases`
`iam:ListAttachedRolePolicies`
`iam:ListOpenIDConnectProviders`
`iam:ListPolicies`
`iam:ListRolePolicies`
`iam:ListRoles`
`iam:ListRoleTags`
`iam:ListSAMLProviders`

------
#### [ Console ]

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação do console, escolha **Roles** (Perfis) e, em seguida, clique em **Create role** (Criar perfil).

1. Escolha o tipo de perfil do **Conta da AWS**.

1. Para criar uma função para sua conta, escolha **This account** (Esta conta). Para criar um perfil para outra conta, escolha **Outra Conta da AWS** e insira o **ID da conta** para o qual você deseja conceder acesso a seus recursos.

   O administrador da conta especificada pode conceder permissão para assumir essa função a qualquer usuário do IAM dessa conta. Para fazer isso, o administrador anexa uma política ao usuário ou grupo que concede permissão para a ação `sts:AssumeRole`. Essa política deve especificar o ARN da função como `Resource`. 

1. Se estiver concedendo permissões aos usuários de uma conta que você não controla e os usuários assumirem essa função de maneira programática, selecione **Require external ID** (Exigir ID externo). O ID externo pode ser qualquer palavra ou número combinado entre você e o administrador da conta de terceiros. Esta opção adiciona automaticamente uma condição à política de confiança que permite ao usuário assumir a função somente se a solicitação incluir o correto `sts:ExternalID`. Para obter mais informações, consulte [Acesso às Contas da AWS de propriedade de terceiros](id_roles_common-scenarios_third-party.md).
**Importante**  
A escolha dessa opção restringe o acesso à função apenas por meio da AWS CLI, do Tools for Windows PowerShell ou da API da AWS. A razão disso é que você não pode usar o console da AWS para alternar para uma função que tenha uma condição `externalId` na sua política de confiança. No entanto, você pode criar esse tipo de acesso de modo programático ao escrever um script ou um aplicativo usando o SDK relevante. Para obter mais informações e um script de exemplo, consulte [How to Enable Cross-Account Access to the Console de gerenciamento da AWS](https://aws.amazon.com/blogs/security/how-to-enable-cross-account-access-to-the-aws-management-console) no AWS Security Blog.

1. Se você desejar restringir a função a usuários que façam login usando um dispositivo de multi-factor authentication (MFA), selecione a opção **Exigir MFA**. Isso adiciona uma condição à política de confiança da função que verifica a existência de um login MFA. Um usuário que desejar assumir a função deverá fazer login com uma senha de uso único temporária a partir de um dispositivo MFA configurado. Os usuários sem a autenticação por MFA não podem assumir a função. Para obter mais informações sobre MFA, consulte [Código da autenticação multifator no IAM da AWS](id_credentials_mfa.md)

1. Escolha **Próximo**.

1. O IAM inclui uma lista das políticas gerenciadas pela AWS e pelo cliente em sua conta. Selecione a política a ser usada para a política de permissões ou escolha **Create policy (Criar política)** para abrir uma nova guia no navegador e criar uma nova política a partir do zero. Para obter mais informações, consulte [Criação de políticas do IAM](access_policies_create-console.md#access_policies_create-start). Depois de criar a política, feche essa guia e retorne à guia original. Marque a caixa de seleção ao lado das políticas de permissões que você deseja que qualquer pessoa que assuma a função tenha. Se preferir, você pode optar por não selecionar nenhuma política neste momento e anexar as políticas à função mais tarde. Por padrão, uma função não tem nenhuma permissões.

1. (Opcional) Defina um [limite de permissões](access_policies_boundaries.md). Este é um recurso avançado. 

   Abra a seção **Set permissions boundary (Definir limite de permissões)** e escolha **Use a permissions boundary to control the maximum role permissions (Usar um limite de permissões para controlar o número máximo de permissões de funções)**. Selecione a política a ser usada para o limite de permissões.

1. Escolha **Próximo**.

1. Em **Role name (Nome da função)**, digite um nome para sua função. Os nomes de função devem ser exclusivos em sua Conta da AWS. Ao ser usado em uma política ou como parte de um ARN, o nome de perfil diferencia maiúsculas de minúsculas. Quando exibida para os clientes no console, por exemplo, como durante o processo de login, o nome de função não diferencia maiúsculas de minúsculas. Como várias entidades podem fazer referência à função, não é possível editar o nome da função depois de criada.

1. (Opcional) Em **Descrição da função**, insira uma descrição para a nova função.

1. Escolha **Edit** (Editar) nas seções **Etapa 1: selecionar entidades confiáveis** ou na **Etapa 2: adicionar permissões** para editar os casos de uso e as permissões para a função. Você será levado de volta às páginas anteriores para fazer as edições.

1. (Opcional) Adicione metadados à função anexando tags como pares de chave-valor. Para obter mais informações sobre como usar tags no IAM, consulte [Tags para recursos do AWS Identity and Access Management](id_tags.md).

1. Revise o perfil e escolha **Criar perfil**.
**Importante**  
Lembre-se de que esta é apenas a metade da configuração necessária. Você também deve conceder aos usuários individuais na conta confiável permissões para alternar para a função no console ou assumir a função de forma programática. Para obter mais informações sobre essa etapa, consulte [Conceder permissões a um usuário para alternar perfis](id_roles_use_permissions-to-switch.md).

------

## Criação de uma função do IAM (AWS CLI)
<a name="roles-creatingrole-user-cli"></a>

A criação de uma função a partir da AWS CLI envolve várias etapas. Quando o console é usado para criar uma função, muitas das etapas são concluídas por você, mas com a AWS CLI, é necessário executar explicitamente cada etapa. Você deve criar a função e atribuir uma política de permissões à função. Opcionalmente, você também pode definir o [limite de permissões](access_policies_boundaries.md) para sua função.

**Para criar uma função para acesso entre contas (AWS CLI)**

1. Criar uma função: [aws iam create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html)

1. Anexar uma política de permissões gerenciada à função: [aws iam attach-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html)

    ou

   Criar uma política de permissões em linha para a função: [aws iam put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)

1. (Opcional) Adicione atributos personalizados à função anexando tags: [aws iam tag-role](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-role.html)

   Para obter mais informações, consulte [Gerenciar etiquetas em funções do IAM (AWS CLI ou API da AWS)](id_tags_roles.md#id_tags_roles_procs-cli-api).

1. (Opcional) Definir o [limite de permissões](access_policies_boundaries.md) para a função: [aws iam put-role-permissions-boundary](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html)

   Um limite de permissões controla o número máximo de permissões que uma função pode ter. Os limites de permissões são um recurso avançado da AWS.

O exemplo a seguir mostra as duas primeiras e as etapas mais comuns para a criação de uma função entre contas em um ambiente simples. Este exemplo permite que qualquer usuário na conta `123456789012` assuma a função e visualize o bucket `example_bucket` do Amazon S3. Este exemplo também supõe que você está em um computador cliente com o Windows e já configurou a interface de linha de comando com as credenciais de sua conta e região. Para obter mais informações, consulte [Configurar a interface de linha de comando da AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).

Neste exemplo, inclua a seguinte política de confiança no primeiro comando ao criar a função. A política de confiança permite que os usuários na conta `123456789012` assumam a função usando a operação `AssumeRole`, mas apenas se o usuário fornecer autenticação MFA usando os parâmetros `SerialNumber` e `TokenCode`. Para obter mais informações sobre MFA, consulte [Código da autenticação multifator no IAM da AWS](id_credentials_mfa.md).

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
      {
          "Effect": "Allow",
          "Principal": { "AWS": "arn:aws:iam::123456789012:root" },
          "Action": "sts:AssumeRole",
          "Condition": { "Bool": { "aws:MultiFactorAuthPresent": "true" } }
      }
  ]
}
```

------

**Importante**  
Se seu elemento `Principal` contiver o ARN de uma função ou um usuário específico do IAM, esse ARN será transformado em um ID de entidade de segurança exclusivo quando a política for salva. Isso ajuda a reduzir o risco de alguém elevar suas permissões ao remover e recriar a função ou usuário. Normalmente, você não vê esse ID no console, porque há também uma transformação reversa de volta para o ARN quando a política de confiança é exibida. No entanto, se você excluir a função ou o usuário, o ID da entidade principal aparecerá no console porque a AWS não pode mais mapeá-lo de volta para um ARN. Portanto, se você excluir e recriar um usuário ou função referenciado no elemento `Principal` de uma política de confiança, você deverá editar a função para substituir o ARN.

Quando usa o segundo comando, você deve anexar uma política gerenciada existente à função. A política de permissões a seguir permite que qualquer pessoa que assuma a função execute apenas a ação `ListBucket` no bucket `example_bucket` do Amazon S3.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
      {
          "Effect": "Allow",
          "Action": "s3:ListBucket",
          "Resource": "arn:aws:s3:::example_bucket"
      }
  ]
}
```

------

Para criar essa `Test-UserAccess-Role` função, você deve primeiro salvar a política de confiança anterior com o nome `trustpolicyforacct123456789012.json` na pasta `policies` em sua `C:` unidade local. Em seguida, salve a política de permissões anterior como uma política gerenciada pelo cliente na sua Conta da AWS com o nome `PolicyForRole`. Você pode usar os comandos a seguir para criar a função e anexar a política gerenciada.

```
# Create the role and attach the trust policy file that allows users in the specified account to assume the role.
$ aws iam create-role --role-name Test-UserAccess-Role --assume-role-policy-document file://C:\policies\trustpolicyforacct123456789012.json

# Attach the permissions policy (in this example a managed policy) to the role to specify what it is allowed to do.
$ aws iam attach-role-policy --role-name Test-UserAccess-Role --policy-arn arn:aws:iam::123456789012:policy/PolicyForRole
```

**Importante**  
Lembre-se de que esta é apenas a metade da configuração necessária. Você também deve conceder aos usuários individuais na conta confiável permissões para alternar para a função. Para obter mais informações sobre essa etapa, consulte [Conceder permissões a um usuário para alternar perfis](id_roles_use_permissions-to-switch.md).

Depois de criar a função e conceder permissões a ela para executar tarefas da AWS ou acessar recursos da AWS, qualquer usuário da conta `123456789012` poderá assumir a função. Para obter mais informações, consulte [Alterar para uma perfil do IAM (AWS CLI)](id_roles_use_switch-role-cli.md).

## Criação de uma função do IAM (API da AWS)
<a name="roles-creatingrole-user-api"></a>

A criação de uma função na API da AWS envolve várias etapas. Quando o console é usado para criar uma função, muitas das etapas são concluídas por você, mas com a API, é necessário executar explicitamente cada etapa. Você deve criar a função e atribuir uma política de permissões à função. Opcionalmente, você também pode definir o [limite de permissões](access_policies_boundaries.md) para sua função.

**Para criar uma função em código (API da AWS)**

1. Criar uma função: [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)

   Para a política de confiança da função, você pode especificar um local de arquivo.

1. Anexar uma política de permissões gerenciada à função: [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)

   ou

   Criar uma política de permissões embutida para a função: [PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html)
**Importante**  
Lembre-se de que esta é apenas a metade da configuração necessária. Você também deve conceder aos usuários individuais na conta confiável permissões para alternar para a função. Para obter mais informações sobre essa etapa, consulte [Conceder permissões a um usuário para alternar perfis](id_roles_use_permissions-to-switch.md).

1. (Opcional) Adicione atributos personalizados ao usuário anexando tags: [TagRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagRole.html)

   Para obter mais informações, consulte [Gerenciamento de etiquetas em usuários do IAM (AWS CLI ou API da AWS)](id_tags_users.md#id_tags_users_procs-cli-api).

1. (Opcional) Definir o [limite de permissões](access_policies_boundaries.md) para a função: [PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html)

   Um limite de permissões controla o número máximo de permissões que uma função pode ter. Os limites de permissões são um recurso avançado da AWS.

Depois de criar a função e conceder permissões a ela para executar tarefas da AWS ou acessar recursos da AWS, você deve conceder permissões aos usuários da conta para permitir que eles assumam a função. Para obter mais informações sobre a assunção de uma função, consulte [Alternar para um perfil do IAM (API da AWS)](id_roles_use_switch-role-api.md).

## Criação de uma função do IAM (AWS CloudFormation)
<a name="roles_creatingrole-user-cloudformation"></a>

Para obter informações sobre como criar uma função do IAM no AWS CloudFormation, consulte a [referência de recursos e propriedades](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html) e [exemplos](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#aws-resource-iam-role--examples) no *Guia do usuário do AWS CloudFormation*.

Para obter mais informações sobre os modelos do IAM no AWS CloudFormation, consulte [Trechos de modelo do AWS Identity and Access Management](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/quickref-iam.html) no *Guia do usuário do AWS CloudFormation*.

# Criar um perfil para delegar permissões a um serviço da AWS
<a name="id_roles_create_for-service"></a>

Muitos serviços da AWS exigem que você use funções para permitir que o serviço acesse recursos em outros serviços em seu nome. A [função de serviço](id_roles.md#iam-term-service-role) é uma função que um serviço assume para realizar ações em seu nome. Quando um perfil atende a uma finalidade especializada para um serviço, ela é categorizada como um [perfil vinculado ao serviço](id_roles.md#iam-term-service-linked-role). Para ver quais serviços oferecem suporte ao uso de funções vinculadas a serviços, ou se um serviço oferece suporte a qualquer forma de credenciais temporárias, consulte [AWSServiços da que funcionam com o IAM](reference_aws-services-that-work-with-iam.md). Para saber como determinado serviço usa funções, escolha o nome do serviço na tabela para visualizar a documentação dele.

Ao definir a permissão `PassRole`, é necessário garantir que um usuário não passe um perfil em que o perfil tenha mais permissões do que você deseja que o usuário tenha. Por exemplo, Alice pode não ter permissão para realizar nenhuma ação do Amazon S3. Se Alice pudesse passar um perfil para um serviço que permite ações do Amazon S3, o serviço poderia realizar ações do Amazon S3 em nome de Alice ao executar o trabalho.

Para obter informações sobre como as funções ajudam você a delegar permissões, consulte [Termos e conceitos das funções](id_roles.md#id_roles_terms-and-concepts).

## Permissões de função de serviço
<a name="id_roles_create_service-permissions"></a>

Configure permissões para que uma entidade do IAM (usuário ou função) crie ou edite uma função de serviço.

**nota**  
O ARN de uma função vinculado ao serviço inclui uma entidade principal do serviço que é indicada nas políticas a seguir como `SERVICE-NAME.amazonaws.com`. Não tente adivinhar a entidade principal do serviço, pois ela faz distinção entre maiúsculas e minúsculas, e o formato pode variar entre os serviços da AWS. Para visualizar a entidade principal do serviço, consulte a documentação do perfil vinculado ao serviço.

**Para permitir que uma entidade do IAM crie uma função de serviço específica**

Adicione a seguinte política à entidade do IAM que precisa criar a função de serviço. Essa política permite que você crie uma função de serviço para o serviço especificado e com um nome específico. Em seguida, você poderá anexar políticas em linha ou gerenciadas a essa função. 

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "iam:AttachRolePolicy",
                "iam:CreateRole",
                "iam:PutRolePolicy"
            ],
            "Resource": "arn:aws:iam::*:role/SERVICE-ROLE-NAME"
        }
    ]
}
```

------

**Para permitir que uma entidade do IAM crie qualquer função de serviço**

A AWS recomenda permitir apenas que usuários administrativos criem qualquer perfil de serviço. Uma pessoa com permissões para criar uma função e anexar qualquer política pode aumentar as próprias permissões. Em vez disso, crie uma política que permita criar apenas as funções necessárias ou peça para um administrador criar a função de serviço no nome dessas pessoas.

Para anexar uma política que permita que um administrador acesse toda a sua Conta da AWS, use a política gerenciada [AdministratorAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AdministratorAccess) da AWS.

**Para permitir que uma entidade do IAM edite uma função de serviço**

Adicione a seguinte política à entidade do IAM que precisa editar a função de serviço.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "EditSpecificServiceRole",
            "Effect": "Allow",
            "Action": [
                "iam:AttachRolePolicy",
                "iam:DeleteRolePolicy",
                "iam:DetachRolePolicy",
                "iam:GetRole",
                "iam:GetRolePolicy",
                "iam:ListAttachedRolePolicies",
                "iam:ListRolePolicies",
                "iam:PutRolePolicy",
                "iam:UpdateRole",
                "iam:UpdateRoleDescription"
            ],
            "Resource": "arn:aws:iam::*:role/SERVICE-ROLE-NAME"
        },
        {
            "Sid": "ViewRolesAndPolicies",
            "Effect": "Allow",
            "Action": [
                "iam:GetPolicy",
                "iam:ListRoles"
            ],
            "Resource": "*"
        }
    ]
}
```

------

**Para permitir que uma entidade do IAM exclua uma função de serviço específica**

Adicione a seguinte instrução à política de permissões à entidade do IAM que precisa excluir a função de serviço especificada.

```
{
    "Effect": "Allow",
    "Action": "iam:DeleteRole",
    "Resource": "arn:aws:iam::*:role/SERVICE-ROLE-NAME"
}
```

**Para permitir que uma entidade do IAM exclua qualquer função de serviço**

A AWS recomenda permitir apenas que usuários administrativos excluam qualquer perfil de serviço. Em vez disso, crie uma política que permita excluir apenas as funções necessárias ou peça para um administrador excluir a função de serviço no nome dessas pessoas.

Para anexar uma política que permita que um administrador acesse toda a sua Conta da AWS, use a política gerenciada [AdministratorAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AdministratorAccess) da AWS.

## Criar uma função para um serviço da AWS (console)
<a name="roles-creatingrole-service-console"></a>

É possível usar o Console de gerenciamento da AWS para criar um perfil para um serviço. Como alguns serviços oferecem suporte a mais de uma função de serviço, consulte a [Documentação da AWS](https://docs.aws.amazon.com/) para o seu serviço para ver qual caso de uso escolher. É possível saber como atribuir as políticas de confiança e as permissões necessárias ao perfil para que o serviço possa assumir o perfil em seu nome. As etapas que podem se usadas para controlar as permissões para a sua função podem variar, dependendo de como o serviço define os casos de uso e de se você cria ou não uma função vinculada ao serviço.

------
#### [ Console ]

**Para criar uma função para um AWS service (Serviço da AWS) (console do IAM)**

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação do console do IAM, escolha **Perfis** e, em seguida, **Criar perfil**.

1. Em **Tipo de entidade confiável**, escolha **AWS service (Serviço da AWS)**.

1. Para **Serviço ou caso de uso**, escolha um serviço e, em seguida, escolha o caso de uso. Casos de uso são definidos pelo serviço para incluir a política de confiança exigida pelo serviço.

1. Escolha **Próximo**.

1. As opções para **Políticas de permissões** dependem do caso de uso selecionado.
   + Se o serviço definir as permissões para o perfil, não será possível selecionar políticas de permissões.
   + Selecione em um conjunto limitado de políticas de permissões.
   + Selecione entre todas as políticas de permissões.
   + Não selecione nenhuma política de permissão; crie políticas após a criação do perfil e, em seguida, anexe as políticas ao perfil.

1. (Opcional) Defina um [limite de permissões](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html). Esse é um atributo avançado que está disponível para perfis de serviço, mas não para perfis vinculados ao serviço.

   1. Abra a seção **Definir limite de permissões** e escolha **Usar um limite de permissões para controlar o número máximo de permissões do perfil**. 

      O IAM inclui uma lista das políticas gerenciadas pela AWS e pelo cliente em sua conta.

   1. Selecione a política a ser usada para o limite de permissões.

1. Escolha **Próximo**.

1. Para **Nome do perfil**, as opções dependem do serviço:
   + Se o serviço definir o nome do perfil, não será possível editar esse nome.
   + Se o serviço definir um prefixo para o nome do perfil, você poderá inserir um sufixo opcional.
   + Se o serviço definir o nome do perfil, você poderá atribuir um nome ao perfil.
**Importante**  
Quando nomear um perfil, observe o seguinte:  
Os nomes do perfil devem ser exclusivos em sua Conta da AWS e não podem ser diferenciados caso a caso.  
Por exemplo, não crie dois perfis denominados **PRODROLE** e **prodrole**. Quando usado em uma política ou como parte de um ARN, o nome de perfil diferencia maiúsculas de minúsculas. No entanto, quando exibido para os clientes no console, como durante o processo de login, o nome de perfil diferencia maiúsculas de minúsculas.
Não é possível editar o nome do perfil depois de criá-lo porque outras entidades podem referenciar o perfil.

1. (Opcional) Em **Descrição**, insira uma descrição para o perfil.

1. (Opcional) Para editar os casos de uso e as permissões do perfil, escolha **Editar** nas seções **Etapa 1: selecionar entidades confiáveis** ou **Etapa 2: adicionar permissões**.

1. (Opcional) Para ajudar a identificar, organizar ou pesquisar o perfil, adicione tags como pares de chave-valor. Para obter mais informações sobre o uso de tags no IAM, consulte [Tags para recursos do AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html) no *Guia do usuário do IAM*.

1. Reveja a função e escolha **Criar função**.

------

## Criar uma função para um serviço (AWS CLI)
<a name="roles-creatingrole-service-cli"></a>

A criação de uma função a partir da AWS CLI envolve várias etapas. Quando o console é usado para criar uma função, muitas das etapas são concluídas por você, mas com a AWS CLI, é necessário executar explicitamente cada etapa. Você deve criar a função e atribuir uma política de permissões à função. Se o serviço com o qual você está trabalhando for o Amazon EC2, você também deverá criar um perfil de instância e adicionar a função a ele. Opcionalmente, você também pode definir o [limite de permissões](access_policies_boundaries.md) para sua função.

**Para criar uma função para um serviço da AWS na AWS CLI**

1. O seguinte comando `[create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html)` cria uma função chamada *Test-Role* e anexa uma política de confiança a ela:

   `aws iam create-role --role-name Test-Role --assume-role-policy-document file://Test-Role-Trust-Policy.json`

1. Anexe uma política de permissões gerenciadas à função: [aws iam attach-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html).

   Por exemplo, o seguinte comando `attach-role-policy` anexa a política gerenciada pela AWS chamada `ReadOnlyAccess` à função do IAM chamada `ReadOnlyRole`:

   `aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/ReadOnlyAccess --role-name ReadOnlyRole`

    ou

   Criar uma política de permissões em linha para a função: [aws iam put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)

   Para adicionar uma política de permissões em linha, consulte o seguinte exemplo:

    `aws iam put-role-policy --role-name Test-Role --policy-name ExamplePolicy --policy-document file://AdminPolicy.json`

1. (Opcional) Adicione atributos personalizados à função anexando tags: [aws iam tag-role](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-role.html)

   Para obter mais informações, consulte [Gerenciar etiquetas em funções do IAM (AWS CLI ou API da AWS)](id_tags_roles.md#id_tags_roles_procs-cli-api).

1. (Opcional) Definir o [limite de permissões](access_policies_boundaries.md) para a função: [aws iam put-role-permissions-boundary](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html)

   Um limite de permissões controla o número máximo de permissões que uma função pode ter. Os limites de permissões são um recurso avançado da AWS.

Se você for usar a função com o Amazon EC2 ou outro produto da AWS que use o Amazon EC2, armazene a função em um perfil de instância. Um perfil da instância é um contêiner para uma função que pode ser anexado a uma instância do Amazon EC2 quando iniciada. Um perfil da instância pode conter somente uma função, e esse limite não pode ser aumentado. Se você criar a função usando o Console de gerenciamento da AWS, o perfil da instância será criado com o mesmo nome que a função. Para obter mais informações sobre os perfis da instância, consulte [Usar perfis de instância](id_roles_use_switch-role-ec2_instance-profiles.md). Para obter informações sobre como executar uma instância do EC2 com um perfil, consulte [Controle de acesso aos recursos do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UsingIAM.html#UsingIAMrolesWithAmazonEC2Instances) no *Guia do usuário do Amazon EC2*.

**Para criar um perfil de instância e armazenar a função nele (AWS CLI)**

1. Criar um perfil da instância: [aws iam create-instance-profile](https://docs.aws.amazon.com/cli/latest/reference/iam/create-instance-profile.html)

1. Adicionar a função ao perfil da instância: [aws iam add-role-to-instance-profile](https://docs.aws.amazon.com/cli/latest/reference/iam/add-role-to-instance-profile.html)

O comando da AWS CLI de exemplo definido a seguir demonstra as duas primeiras etapas para criar uma função e anexar permissões. Também mostra as duas etapas para criar um perfil de instância e adicionar a função ao perfil. Este exemplo de política de confiança permite que o serviço Amazon EC2 assuma a função e visualize o bucket `example_bucket` do Amazon S3. O exemplo também presume que você está executando em um computador cliente com o Windows e já configurou a interface de linha de comando com as credenciais de sua conta e região. Para obter mais informações, consulte [Configurar a interface de linha de comando da AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).

Neste exemplo, inclua a seguinte política de confiança no primeiro comando ao criar a função. Essa política de confiança permite que o serviço Amazon EC2 assuma a função. 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Principal": {"Service": "ec2.amazonaws.com"},
    "Action": "sts:AssumeRole"
  }
}
```

------

Quando usa o segundo comando, você deve anexar uma política de permissões à função. A política de permissões de exemplo a seguir permite que a função execute apenas a ação `ListBucket` no bucket `example_bucket` do Amazon S3.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Action": "s3:ListBucket",
    "Resource": "arn:aws:s3:::example_bucket"
  }
}
```

------

Para criar essa função `Test-Role-for-EC2`, você deve primeiro salvar a política de confiança anterior com o nome `trustpolicyforec2.json` e a política de permissões anterior com o nome `permissionspolicyforec2.json` no diretório `policies` na unidade `C:` local. Em seguida, você pode usar os seguintes comandos para criar a função, anexar a política, criar o perfil da instância e adicionar a função ao perfil da instância.

```
# Create the role and attach the trust policy that allows EC2 to assume this role.
$ aws iam create-role --role-name Test-Role-for-EC2 --assume-role-policy-document file://C:\policies\trustpolicyforec2.json

# Embed the permissions policy (in this example an inline policy) to the role to specify what it is allowed to do.
$ aws iam put-role-policy --role-name Test-Role-for-EC2 --policy-name Permissions-Policy-For-Ec2 --policy-document file://C:\policies\permissionspolicyforec2.json

# Create the instance profile required by EC2 to contain the role
$ aws iam create-instance-profile --instance-profile-name EC2-ListBucket-S3

# Finally, add the role to the instance profile
$ aws iam add-role-to-instance-profile --instance-profile-name EC2-ListBucket-S3 --role-name Test-Role-for-EC2
```

Quando você ativar a instância do EC2, especifique o nome do perfil da instância na página **Configure Instance Details** se você usar o console da AWS. Se você usar o comando CLI `aws ec2 run-instances`, especifique o parâmetro `--iam-instance-profile`.

## Criar uma função para um serviço (API da AWS)
<a name="roles-creatingrole-service-api"></a>

A criação de uma função na API da AWS envolve várias etapas. Quando o console é usado para criar uma função, muitas das etapas são concluídas por você, mas com a API, é necessário executar explicitamente cada etapa. Você deve criar a função e atribuir uma política de permissões à função. Se o serviço com o qual você está trabalhando for o Amazon EC2, você também deverá criar um perfil de instância e adicionar a função a ele. Opcionalmente, você também pode definir o [limite de permissões](access_policies_boundaries.md) para sua função.

**Para criar uma função para um serviço da AWS (API da AWS)**

1. Criar uma função: [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)

   Para a política de confiança da função, você pode especificar um local de arquivo.

1. Anexar uma política de permissões gerenciada à função: [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)

    ou

   Criar uma política de permissões em linha para a função: [PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html)

1. (Opcional) Adicione atributos personalizados ao usuário anexando tags: [TagRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagRole.html)

   Para obter mais informações, consulte [Gerenciamento de etiquetas em usuários do IAM (AWS CLI ou API da AWS)](id_tags_users.md#id_tags_users_procs-cli-api).

1. (Opcional) Definir o [limite de permissões](access_policies_boundaries.md) para a função: [PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html)

   Um limite de permissões controla o número máximo de permissões que uma função pode ter. Os limites de permissões são um recurso avançado da AWS.

Se você for usar a função com o Amazon EC2 ou outro produto da AWS que use o Amazon EC2, armazene a função em um perfil de instância. Um perfil da instância é um contêiner para uma função. Cada perfil da instância pode conter somente uma função e esse limite não pode ser aumentado. Se você criar a função no Console de gerenciamento da AWS, o perfil da instância será criado para você com o mesmo nome da função. Para obter mais informações sobre os perfis da instância, consulte [Usar perfis de instância](id_roles_use_switch-role-ec2_instance-profiles.md). Para obter informações sobre como executar uma instância do Amazon EC2 com um perfil, consulte [Controle de acesso aos recursos do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UsingIAM.html#UsingIAMrolesWithAmazonEC2Instances) no *Guia do usuário do Amazon EC2*. 

**Para criar um perfil de instância e armazenar a função nele (API da AWS)**

1. Criar um perfil da instância: [CreateInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateInstanceProfile.html)

1. Adicionar a função ao perfil da instância: [AddRoleToInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AddRoleToInstanceProfile.html)

# Criar um perfil vinculado ao serviço
<a name="id_roles_create-service-linked-role"></a>

Uma função vinculada ao serviço é um tipo exclusivo de função do IAM vinculado diretamente a um serviço da AWS. As funções vinculadas a serviços são predefinidas pelo serviço e incluem todas as permissões que o serviço requer para chamar outros serviços da AWS em seu nome. O serviço vinculado também define como criar, modificar e excluir uma função vinculada a serviço. Um serviço pode criar ou excluir a função automaticamente. Ele pode permitir que você crie, modifique ou exclua a função como parte de um assistente ou processo no serviço. Ou pode exigir que você use o IAM para criar ou excluir a função. Independente do método, as funções vinculadas a serviço simplificam o processo de configurar um serviço da , pois você não precisa adicionar manualmente as permissões para o serviço concluir as ações em seu nome.

**nota**  
Lembre-se de que perfis de serviço são diferentes de perfis vinculados a serviços. O perfil de serviço é um [perfil do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) que um serviço assume para executar ações em seu nome. Um administrador do IAM pode criar, modificar e excluir um perfil de serviço do IAM. Para obter mais informações, consulte [Criação de um perfil para delegar permissões a um AWS service (Serviço da AWS)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) no *Guia do Usuário do IAM*. Um perfil vinculado ao serviço é um tipo de perfil de serviço vinculado a um AWS service (Serviço da AWS). O serviço pode presumir o perfil de executar uma ação em seu nome. Perfis vinculados ao serviço aparecem em sua Conta da AWS e são de propriedade do serviço. Um administrador do IAM pode visualizar, mas não editar as permissões para perfis vinculados ao serviço. 

O serviço vinculado define as permissões de suas funções vinculadas ao serviço e, a menos que definido em contrário, somente aquele serviço pode assumir as funções. As permissões definidas incluem a política de confiança e a política de permissões, que não pode ser anexada a nenhuma outra entidade do IAM.

Para poder excluir as funções, você deve primeiroexcluir os recursos relacionados a eles. Isso ajuda a impedir que você remova por engano a permissão para acessar os recursos. 

**dica**  
Para obter informações sobre quais serviços oferecem suporte a funções vinculadas a serviços, consulte [AWSServiços da que funcionam com o IAM](reference_aws-services-that-work-with-iam.md) e procure os serviços que têm **Sim **na coluna **Função vinculada ao serviço**. Escolha um **Sim** com um link para visualizar a documentação do perfil vinculado para esse serviço.

## Permissões de perfil vinculado ao serviço
<a name="service-linked-role-permissions"></a>

Configure as permissões para que uma entidade do IAM (usuário ou função) permita que o usuário ou a função crie ou edite a função vinculada ao serviço.

**nota**  
O ARN de uma função vinculada ao serviço inclui uma entidade principal do serviço que é indicada nas políticas abaixo como `SERVICE-NAME.amazonaws.com`. Não tente adivinhar a entidade principal do serviço, pois ela faz distinção entre maiúsculas e minúsculas, e o formato pode variar entre os serviços da AWS. Para visualizar a entidade principal do serviço, consulte a documentação do perfil vinculado ao serviço.

**Para permitir que uma entidade do IAM; crie uma função vinculada ao serviço**

Adicione a seguinte política à entidade do IAM que precisa criar a função vinculada ao serviço.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "iam:CreateServiceLinkedRole",
            "Resource": "arn:aws:iam::*:role/aws-service-role/SERVICE-NAME.amazonaws.com/SERVICE-LINKED-ROLE-NAME-PREFIX*",
            "Condition": {"StringLike": {"iam:AWSServiceName": "SERVICE-NAME.amazonaws.com"}}
        },
        {
            "Effect": "Allow",
            "Action": [
                "iam:AttachRolePolicy",
                "iam:PutRolePolicy"
            ],
            "Resource": "arn:aws:iam::*:role/aws-service-role/SERVICE-NAME.amazonaws.com/SERVICE-LINKED-ROLE-NAME-PREFIX*"
        }
    ]
}
```

------

**Para permitir que uma entidade do IAM crie qualquer função vinculada ao serviço**

Adicione a seguinte instrução à política de permissões da entidade do IAM que precisa criar uma função vinculada ao serviço ou qualquer função de serviço que inclua as políticas necessárias. Esta declaração de política não permite que a entidade do IAM anexe uma política à função.

```
{
    "Effect": "Allow",
    "Action": "iam:CreateServiceLinkedRole",
    "Resource": "arn:aws:iam::*:role/aws-service-role/*"
}
```

**Para permitir que uma entidade do IAM edite a descrição de todas as funções de serviço**

Adicione a seguinte instrução à política de permissões da entidade do IAM que precisa editar uma descrição de uma função vinculada ao serviço ou qualquer função de serviço.

```
{
    "Effect": "Allow",
    "Action": "iam:UpdateRoleDescription",
    "Resource": "arn:aws:iam::*:role/aws-service-role/*"
}
```

**Para permitir que uma entidade do IAM exclua uma função vinculada ao serviço específica**

Adicione a seguinte instrução à política de permissões para a entidade do IAM que precisa excluir a função vinculada ao serviço.

```
{
    "Effect": "Allow",
    "Action": [
        "iam:DeleteServiceLinkedRole",
        "iam:GetServiceLinkedRoleDeletionStatus"
    ],
    "Resource": "arn:aws:iam::*:role/aws-service-role/SERVICE-NAME.amazonaws.com/SERVICE-LINKED-ROLE-NAME-PREFIX*"
}
```

**Para permitir que uma entidade do IAM exclua qualquer função vinculada ao serviço**

Adicione a seguinte instrução à política de permissões da entidade do IAM que precisa excluir uma função vinculada ao serviço, mas não a função de serviço.

```
{
    "Effect": "Allow",
    "Action": [
        "iam:DeleteServiceLinkedRole",
        "iam:GetServiceLinkedRoleDeletionStatus"
    ],
    "Resource": "arn:aws:iam::*:role/aws-service-role/*"
}
```

**Para permitir que uma entidade do IAM transmita uma função existente para o serviço**

Alguns serviços do AWS permitem que você transmita uma função existente para o serviço, ao invés de criar uma nova função vinculada ao serviço. Para fazer isso, um usuário deve ter permissões para *transmitir a função* para o serviço. Adicione a seguinte instrução à política de permissões para a entidade do IAM necessária para transmitir a função. Esta declaração de política também permite que a entidade visualize uma lista de funções a partir da qual elas podem escolher a função a ser transmitida. Para obter mais informações, consulte [Conceda permissões a um usuário para passar um perfil para um serviço da AWS](id_roles_use_passrole.md).

```
{
  "Sid": "PolicyStatementToAllowUserToListRoles",
  "Effect": "Allow",
  "Action": ["iam:ListRoles"],
  "Resource": "*"
},
{
  "Sid": "PolicyStatementToAllowUserToPassOneSpecificRole",
  "Effect": "Allow",
  "Action": [ "iam:PassRole" ],
  "Resource": "arn:aws:iam::account-id:role/my-role-for-XYZ"
}
```

## Permissões indiretas com funções vinculadas a serviços
<a name="create-service-linked-role-permissions-transfer"></a>

As permissões concedidas por uma função vinculada a um serviço podem ser transferidas indiretamente para outros usuários e funções. Quando um perfil vinculado ao serviço é usado por um serviço da AWS, esse perfil vinculado ao serviço pode usar suas próprias permissões para chamar outros serviços da AWS. Isso significa que usuários e funções com permissões para chamar um serviço que usa uma função vinculada ao serviço podem ter acesso indireto aos serviços acessíveis por essa função vinculada ao serviço.

Por exemplo, quando você cria uma instância de banco de dados do Amazon RDS, [uma função vinculada ao serviço para o RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.IAM.ServiceLinkedRoles.html) será criada automaticamente se ainda não houver uma. Essa função permite que o RDS chame o Amazon EC2, o Amazon SNS, o Amazon CloudWatch Logs e o Amazon Kinesis em seu nome. Se você permitir que usuários e perfis em sua conta modifiquem ou criem bancos de dados do RDS, eles poderão interagir indiretamente com o Amazon EC2, o Amazon SNS, os logs do Amazon CloudWatch Logs e os recursos do Amazon Kinesis por meio de chamadas ao RDS, pois o RDS usaria sua função vinculada ao serviço para acessar esses recursos.

### Métodos de criação de perfis vinculados ao serviço
<a name="create-service-linked-role"></a>

O método que você usa para criar uma função vinculada ao serviço depende do serviço. Em alguns casos, você não precisa criar manualmente uma função vinculada ao serviço. Por exemplo, quando você conclui uma ação específica (como a criação de um recurso) no serviço, o serviço pode criar a função vinculada ao serviço para você. Ou, se você estava usando um serviço antes que ele começou a oferecer suporte a funções vinculadas ao serviço, o serviço pode ter criado automaticamente a função na sua conta. Para saber mais, consulte [Uma nova função apareceu na minha conta da AWS](troubleshoot_roles.md#troubleshoot_roles_new-role-appeared).

Em outros casos, o serviço pode oferecer suporte à criação de uma função vinculada ao serviço manualmente usando o console, API ou CLI do serviço. Para obter informações sobre quais serviços oferecem suporte a funções vinculadas a serviços, consulte [AWSServiços da que funcionam com o IAM](reference_aws-services-that-work-with-iam.md) e procure os serviços que têm **Sim **na coluna **Função vinculada ao serviço**. Para saber se o serviço oferece suporte para criar a função vinculada ao serviço, escolha o link **Sim** para visualizar a documentação da função vinculada a esse serviço.

Se o serviço não for compatível com a criação da função, você poderá usar o IAM para criar a função vinculada ao serviço.

**Importante**  
Perfis vinculados a serviço contam para o limite dos seus [perfis do IAM em uma Conta da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html#reference_iam-quotas-entities), mas, se você tiver atingido seu limite, ainda poderá criar perfis vinculados a serviço na sua conta. Somente as funções vinculadas ao serviço podem exceder o limite.

### Criar uma função vinculada ao serviço (console)
<a name="create-service-linked-role-iam-console"></a>

Antes de criar uma função vinculada ao serviço no IAM, descubra se o serviço vinculado cria automaticamente funções vinculadas ao serviço. Além disso, saiba se você pode criar a função no console, na API ou na CLI do serviço.<a name="create-service-linked-role-iam-console"></a>

**Para criar uma função vinculada ao serviço (console)**

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação do console do IAM, escolha **Perfis**. Depois, escolha **Create role** (Criar perfil).

1. Escolha o tipo de função **AWS Service** (Service).

1. Escolha o caso de uso para o seu serviço. Casos de uso são definidos pelo serviço para incluir a política de confiança exigida pelo serviço. Em seguida, escolha **Próximo**.

1. Escolha uma ou mais políticas de permissões a serem anexadas à função. Dependendo do caso de uso que você selecionou, o serviço pode executar uma das seguintes ações:
   + Defina as permissões usadas pela função.
   + Permita que você escolha um conjunto limitado de permissões.
   + Permita que você escolha entre todas as permissões.
   + Permitir que você opte por não selecionar nenhuma política no momento, criar políticas mais tarde e, em seguida, anexá-las à função.

   Marque a caixa de seleção ao lado da política que atribui as permissões que você deseja que o perfil tenha e escolha **Próximo**. 
**nota**  
As permissões que você especificar estarão disponíveis para qualquer entidade que usar a função. Por padrão, uma função não tem nenhuma permissões.

1. Para **Nome do perfil**, o grau de personalização do nome do perfil é definido pelo serviço. Se o serviço define o nome da função, essa opção não é editável. Em outros casos, o serviço pode definir um prefixo para a função e permitir que você insira um sufixo opcional.

   Se possível, insira um sufixo de nome de função a ser adicionado ao nome padrão. O sufixo ajuda a identificar a finalidade dessa função. Os nomes de função devem ser exclusivos em sua conta AWS. Eles não são diferenciados por letras maiúsculas e minúsculas. Por exemplo, não é possível criar perfis denominados **<service-linked-role-name>\$1SAMPLE** e **<service-linked-role-name>\$1sample**. Como várias entidades podem fazer referência à função, não é possível editar o nome da função depois que ela é criada.

1. (Opcional) Em **Description** (Descrição), edite a descrição para a nova função vinculado ao serviço.

1. Você não pode anexar tags para funções vinculadas ao serviço durante a criação. Para obter mais informações sobre como usar tags no IAM, consulte [Tags para recursos do AWS Identity and Access Management](id_tags.md).

1. Revise o perfil e escolha **Criar perfil**.

### Criar uma função vinculada ao serviço (AWS CLI)
<a name="create-service-linked-role-iam-cli"></a>

Antes de criar uma função vinculada ao serviço no IAM, descubra se o serviço vinculado cria automaticamente as funções vinculadas ao serviço e se você pode criar a função na CLI do serviço. Se a CLI do serviço não for compatível, você poderá usar comandos do IAM para criar uma função vinculada ao serviço com a política de confiança e políticas em linha de que o serviço precisa assumir a função.

**Para criar uma função vinculada ao serviço (AWS CLI)**

Execute o seguinte comando:

```
aws iam [create-service-linked-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-service-linked-role.html) --aws-service-name SERVICE-NAME.amazonaws.com
```

### Criar uma função vinculada ao serviço (API da AWS)
<a name="create-service-linked-role-iam-api"></a>

Antes de criar uma função vinculada ao serviço no IAM, descubra se o serviço vinculado cria automaticamente as funções vinculadas ao serviço e se você pode criar a função na API do serviço. Se a API do serviço não for suportada, você pode usar a API do AWS para criar uma função vinculada ao serviço com a política de confiança e políticas em linha de que o serviço precisa para assumir a função.

**Para criar uma função vinculada ao serviço (API da AWS)**

Use a chamada de API [CreateServiceLinkedRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateServiceLinkedRole.html). Na solicitação, especifique o nome do serviço na forma de `SERVICE_NAME_URL.amazonaws.com`. 

Por exemplo, para criar a função vinculada ao serviço **Lex Bots**, use `lex.amazonaws.com`.

# Criar um perfil para um provedor de identidade de terceiros
<a name="id_roles_create_for-idp"></a>

Você pode usar provedores de identidade em vez de criar usuários do IAM na sua Conta da AWS. Com um provedor de identidade (IdP), você pode gerenciar as identidades de usuários fora da AWS e fornecer a essas identidades de usuários externos permissões para acessar recursos da AWS na sua conta. Para obter mais informações sobre federação e provedores de identidade, consulte [Federação e provedores de identidade na AWS](id_roles_providers.md).

## Criar um perfil para entidades principais federadas OIDC e SAML (console)
<a name="roles-creatingrole-federated-users-console"></a>

Os procedimentos para criar um perfil dependem de sua opção de provedores de terceiros:
+ Para OpenID Connect (OIDC), consulte [Criar uma função para uma federação do OpenID Connect (console)](id_roles_create_for-idp_oidc.md).
+ Para SAML 2.0, consulte [Criar um perfil para uma federação do SAML 2.0 (console)](id_roles_create_for-idp_saml.md).

## Criar uma função para acesso federado (AWS CLI)
<a name="roles-creatingrole-identityprovider-cli"></a>

As etapas para criar uma função para provedores de identidade (OIDC ou SAML) na AWS CLI são idênticas. A diferença está no conteúdo da política de confiança que você cria nas etapas obrigatórias. Comece seguindo as etapas na seção **Pré-requisitos** para o tipo de provedor que você está usando:
+ Para um provedor do OIDC, consulte [Pré-requisitos para a criação de uma função para o OIDC](id_roles_create_for-idp_oidc.md#idp_oidc_Prerequisites).
+ Para um provedor do SAML, consulte [Pré-requisitos para a criação de uma função para o SAML](id_roles_create_for-idp_saml.md#idp_saml_Prerequisites).

A criação de uma função a partir da AWS CLI envolve várias etapas. Quando o console é usado para criar uma função, muitas das etapas são concluídas por você, mas com a AWS CLI, é necessário executar explicitamente cada etapa. Você deve criar a função e atribuir uma política de permissões à função. Opcionalmente, você também pode definir o [limite de permissões](access_policies_boundaries.md) para sua função.

**Para criar um perfil (AWS CLI)**

1. Criar uma função: [aws iam create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html)

1. Anexar uma política de permissões à função: [aws iam attach-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html)

    ou

   Criar uma política de permissões em linha para a função: [aws iam put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)

1. (Opcional) Adicione atributos personalizados à função anexando tags: [aws iam tag-role](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-role.html)

   Para obter mais informações, consulte [Gerenciar etiquetas em funções do IAM (AWS CLI ou API da AWS)](id_tags_roles.md#id_tags_roles_procs-cli-api).

1. (Opcional) Definir o [limite de permissões](access_policies_boundaries.md) para a função: [aws iam put-role-permissions-boundary](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html)

   Um limite de permissões controla o número máximo de permissões que uma função pode ter. Os limites de permissões são um recurso avançado da AWS.

O exemplo a seguir mostra as duas primeiras e as etapas mais comuns para a criação de uma função de provedor de identidade em um ambiente simples. Este exemplo permite que qualquer usuário na conta `123456789012` assuma a função e visualize o bucket `example_bucket` do Amazon S3. Este exemplo também supõe que você esteja executando a AWS CLI em um computador Windows e já tenha configurado a AWS CLI com suas credenciais. Para obter mais informações, consulte [Configurar a AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).

A política de confiança do exemplo a seguir será designada para um aplicativo móvel se o usuário fizer login usando o Amazon Cognito. Neste exemplo, *us-east:12345678-ffff-ffff-ffff-123456* representa o ID do grupo de identidades atribuído pelo Amazon Cognito.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": {
        "Sid": "RoleForCognito",
        "Effect": "Allow",
        "Principal": {"Federated": "cognito-identity.amazonaws.com"},
        "Action": "sts:AssumeRoleWithWebIdentity",
        "Condition": {"StringEquals": {"cognito-identity.amazonaws.com:aud": "us-east:12345678-ffff-ffff-ffff-123456"}}
    }
}
```

------

A política de permissões a seguir permite que qualquer pessoa que assuma a função execute apenas a ação `ListBucket` no bucket `example_bucket` do Amazon S3.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Action": "s3:ListBucket",
    "Resource": "arn:aws:s3:::example_bucket"
  }
}
```

------

Para criar essa função `Test-Cognito-Role`, você deve primeiro salvar a política de confiança anterior com o nome `trustpolicyforcognitofederation.json` e a política de permissões anterior com o nome `permspolicyforcognitofederation.json` na pasta `policies` na unidade `C:` local. Você pode usar os comandos a seguir para criar a função e anexar a política em linha.

```
# Create the role and attach the trust policy that enables users in an account to assume the role.
$ aws iam create-role --role-name Test-Cognito-Role --assume-role-policy-document file://C:\policies\trustpolicyforcognitofederation.json

# Attach the permissions policy to the role to specify what it is allowed to do.
aws iam put-role-policy --role-name Test-Cognito-Role --policy-name Perms-Policy-For-CognitoFederation --policy-document file://C:\policies\permspolicyforcognitofederation.json
```

## Criar uma função para acesso federado (API da AWS)
<a name="roles-creatingrole-identityprovider-api"></a>

As etapas para criar uma função para provedores de identidade (OIDC ou SAML) na AWS CLI são idênticas. A diferença está no conteúdo da política de confiança que você cria nas etapas obrigatórias. Comece seguindo as etapas na seção **Pré-requisitos** para o tipo de provedor que você está usando:
+ Para um provedor do OIDC, consulte [Pré-requisitos para a criação de uma função para o OIDC](id_roles_create_for-idp_oidc.md#idp_oidc_Prerequisites).
+ Para um provedor do SAML, consulte [Pré-requisitos para a criação de uma função para o SAML](id_roles_create_for-idp_saml.md#idp_saml_Prerequisites).

**Para criar um perfil (API AWS)**

1. Criar uma função: [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)

1. Anexar uma política de permissões à função: [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)

    ou

   Criar uma política de permissões em linha para a função: [PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html)

1. (Opcional) Adicione atributos personalizados ao usuário anexando tags: [TagRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagRole.html)

   Para obter mais informações, consulte [Gerenciamento de etiquetas em usuários do IAM (AWS CLI ou API da AWS)](id_tags_users.md#id_tags_users_procs-cli-api).

1. (Opcional) Definir o [limite de permissões](access_policies_boundaries.md) para a função: [PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html)

   Um limite de permissões controla o número máximo de permissões que uma função pode ter. Os limites de permissões são um recurso avançado da AWS.

# Criar uma função para uma federação do OpenID Connect (console)
<a name="id_roles_create_for-idp_oidc"></a>

É possível usar os provedores de identidades federadas do OpenID Connect (OIDC) em vez de criar usuários do AWS Identity and Access Management em sua Conta da AWS. Com um provedor de identidade (IdP), você pode gerenciar as identidades de usuários fora da AWS e fornecer a essas identidades de usuários externos permissões para acessar recursos da AWS na sua conta. Para obter mais informações sobre federação e IdPs, consulte [Federação e provedores de identidade na AWS](id_roles_providers.md).

## Pré-requisitos para a criação de uma função para o OIDC
<a name="idp_oidc_Prerequisites"></a>

Para criar uma função para a federação OIDC, você primeiro deve concluir as etapas obrigatórias a seguir.<a name="oidc-prereqs"></a>

**Para se preparar para uma função para a federação do OIDC**

1. Inscreva-se em um ou mais serviços que oferecem identidades federadas OIDC. Se estiver criando um aplicativo que precisa de acesso a seus recursos da AWS, você também poderá configurar seu aplicativo com as informações do provedor. Quando você faz isso, o provedor fornece a você um ID de aplicação ou público que é exclusivo da aplicação. (Diferentes provedores usam diferentes terminologias para este processo. Este guia usa o termo *configurar* para o processo de identificação de sua aplicação com o provedor.) É possível configurar várias aplicações com cada provedor ou vários provedores com um único aplicativo. Visualize as informações sobre o uso de provedores de identidades:
   + [Centro do desenvolvedor do Login with Amazon](https://login.amazon.com/)
   + [Adicione o login do Facebook ao seu aplicativo ou site](https://developers.facebook.com/docs/facebook-login/v2.1) no site de desenvolvedores do Facebook.
   + [Uso de OAuth 2.0 para login (OpenID Connect)](https://developers.google.com/accounts/docs/OAuth2Login) no site de desenvolvedores do Google.

1. <a name="idpoidcstep2"></a>Depois de receber as informações necessárias do IdP, crie um IdP no IAM. Para obter mais informações, consulte [Criar um provedor de identidade OpenID Connect (OIDC) no IAM](id_roles_providers_create_oidc.md).
**Importante**  
Se você estiver usando um IdP OIDC do Google, Facebook ou Amazon Cognito, não crie um IdP do IAM separado no Console de gerenciamento da AWS. Esses provedores de identidades OIDC já estão integrados à AWS e estão disponíveis para uso. Ignore esta etapa e a criação de novas funções usando seu IdP na etapa a seguir.

1. Prepare as políticas para a função que os usuários autenticados pelo IdP assumirão. Assim como com qualquer função, uma função para um aplicativo móvel inclui duas políticas. Uma é a política de confiança que especifica quem pode assumir a função. A outra é a política de permissões que especifica as ações e os recursos reais da AWS aos quais o aplicativo móvel tem ou não permissão para acessar.

   Para idPs da Web, recomendamos que você use o [Amazon Cognito](https://aws.amazon.com/cognito/) para gerenciar identidades. Nesse caso, use uma política de confiança semelhante a este exemplo.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Principal": {"Federated": "cognito-identity.amazonaws.com"},
           "Action": "sts:AssumeRoleWithWebIdentity",
           "Condition": {
               "StringEquals": {"cognito-identity.amazonaws.com:aud": "us-east-2:12345678-abcd-abcd-abcd-123456"},
               "ForAnyValue:StringLike": {"cognito-identity.amazonaws.com:amr": "unauthenticated"}
           }
       }
   }
   ```

------

   Substitua `us-east-2:12345678-abcd-abcd-abcd-123456` pelo ID do grupo de identidades que o Amazon Cognito atribuir a você.

   Se você configurar manualmente um IdP do OIDC, ao criar a política de confiança, você deve usar três valores que garantem que apenas seu aplicativo possa assumir a função:
   + No elemento `Action`, use a ação `sts:AssumeRoleWithWebIdentity`.
   + No elemento `Principal`, use a string `{"Federated":providerUrl/providerArn}`.
     + Para alguns IdPs OIDC comuns, a `providerUrl` é um URL. Os exemplos a seguir incluem métodos para especificar a entidade principal para alguns IdPs comuns:

       `"Principal":{"Federated":"cognito-identity.amazonaws.com"}`

       `"Principal":{"Federated":"www.amazon.com"}`

       `"Principal":{"Federated":"graph.facebook.com"}`

       `"Principal":{"Federated":"accounts.google.com"}`
     + Para outros provedores OIDC, use nome do recurso da Amazon (ARN) do IdP OIDC que você criou em [Step 2](#idpoidcstep2), como o exemplo a seguir:

       `"Principal":{"Federated":"arn:aws:iam::123456789012:oidc-provider/server.example.com"}`
   + No elemento `Condition`, use uma condição `StringEquals` para limitar as permissões. Teste o ID do grupo de identidades para o Amazon Cognito ou o ID da aplicação para outros provedores. O ID do grupo de identidades deve corresponder ao ID da aplicação que você recebeu quando configurou a aplicação com o IdP. Essa correspondência entre os IDs garante que a solicitação seja proveniente da aplicação.
**nota**  
Os perfis do IAM para bancos de identidades do Amazon Cognito confiam na entidade principal do serviço `cognito-identity.amazonaws.com` para assumir o perfil. Perfis desse tipo devem conter pelo menos uma chave de condição para limitar as entidades principais que podem assumir o perfil.  
Considerações adicionais se aplicam aos bancos de identidades do Amazon Cognito que assumem [perfis do IAM entre contas](access_policies-cross-account-resource-access.md). As políticas de confiança desses perfis devem aceitar a entidade principal do serviço `cognito-identity.amazonaws.com` e conter a chave de condição `aud` para restringir a suposição de perfis aos usuários dos bancos de identidades pretendidos. Uma política que confia nos bancos de identidades do Amazon Cognito sem essa condição cria o risco de que um usuário de um banco de identidades não intencional possa assumir o perfil. Para obter mais informações, consulte [Políticas de confiança para perfis do IAM na autenticação básica (clássica)](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#trust-policies) no *Guia do Desenvolvedor do Amazon Cognito*.

     Crie um elemento de condição semelhante aos exemplos a seguir, dependendo do IdP que você está usando: 

     `"Condition": {"StringEquals": {"cognito-identity.amazonaws.com:aud": "us-east:12345678-ffff-ffff-ffff-123456"}}`

     `"Condition": {"StringEquals": {"www.amazon.com:app_id": "amzn1.application-oa2-123456"}}`

     `"Condition": {"StringEquals": {"graph.facebook.com:app_id": "111222333444555"}}`

     `"Condition": {"StringEquals": {"accounts.google.com:aud": "66677788899900pro0"}}`

     Para provedores OIDC, use o URL totalmente qualificado do IdP OIDC com a chave de contexto `aud`, como o exemplo a seguir: 

     `"Condition": {"StringEquals": {"server.example.com:aud": "appid_from_oidc_idp"}}`
**nota**  
Observe que os valores para a entidade principal na política de confiança para a função são específicos a um IdP. Um perfil pode especificar apenas uma entidade principal. Portanto, se a aplicação móvel permitir que os usuários se registrem em mais de um IdP, você deverá criar uma função separada para cada IdP que utilizar. Portanto, você deve criar políticas de confiança separadas para cada IdP.

   Se um usuário usar uma aplicação móvel para fazer login estando no Login with Amazon, a política de confiança do exemplo a seguir será aplicada. No exemplo, *amzn1.application-oa2-123456* representa o ID da aplicação que a Amazon atribuiu quando você configurou a aplicação usando o Login with Amazon.

------
#### [ JSON ]

****  

   ```
   {
         "Version":"2012-10-17",		 	 	 
         "Statement": [{
             "Sid": "RoleForLoginWithAmazon",
             "Effect": "Allow",
             "Principal": {"Federated": "www.amazon.com"},
             "Action": "sts:AssumeRoleWithWebIdentity",
             "Condition": {"StringEquals": {"www.amazon.com:app_id": "amzn1.application-oa2-123456"}}
         }]
     }
   ```

------

   Se um usuário usar uma aplicação móvel para fazer login estando no Facebook, a política de confiança do exemplo a seguir será aplicada. Neste exemplo, *111222333444555* representa o ID da aplicação atribuído pelo Facebook.

------
#### [ JSON ]

****  

   ```
   {
         "Version":"2012-10-17",		 	 	 
         "Statement": [{
             "Sid": "RoleForFacebook",
             "Effect": "Allow",
             "Principal": {"Federated": "graph.facebook.com"},
             "Action": "sts:AssumeRoleWithWebIdentity",
             "Condition": {"StringEquals": {"graph.facebook.com:app_id": "111222333444555"}}
         }]
     }
   ```

------

   Se um usuário usar uma aplicação móvel para fazer login estando no Goggle, a política de confiança do exemplo a seguir será aplicada. Nesse exemplo, *666777888999000* representa o ID da aplicação atribuído pelo Google.

------
#### [ JSON ]

****  

   ```
   {
         "Version":"2012-10-17",		 	 	 
         "Statement": [{
             "Sid": "RoleForGoogle",
             "Effect": "Allow",
             "Principal": {"Federated": "accounts.google.com"},
             "Action": "sts:AssumeRoleWithWebIdentity",
             "Condition": {"StringEquals": {"accounts.google.com:aud": "666777888999000"}}
         }]
     }
   ```

------

   Se um usuário usar uma aplicação móvel para fazer login estando no Amazon Cognito, a política de confiança do exemplo a seguir será aplicada. Neste exemplo, *us-east:12345678-ffff-ffff-ffff-123456* representa o ID do grupo de identidades atribuído pelo Amazon Cognito.

------
#### [ JSON ]

****  

   ```
   {
         "Version":"2012-10-17",		 	 	 
         "Statement": [{
             "Sid": "RoleForCognito",
             "Effect": "Allow",
             "Principal": {"Federated": "cognito-identity.amazonaws.com"},
             "Action": "sts:AssumeRoleWithWebIdentity",
             "Condition": {"StringEquals": {"cognito-identity.amazonaws.com:aud": "us-east:12345678-ffff-ffff-ffff-123456"}}
         }]
     }
   ```

------

## Como criar um perfil para o OIDC
<a name="idp_oidc_Create"></a>

Depois de concluir as etapas obrigatórias, você pode criar a função no IAM. Para provedores de identidade (IdPs) OpenID Connect (OIDC) compartilhados reconhecidos, o IAM exige uma avaliação explícita de declarações específicas em JSON Web Tokens (JWTs), os quais são conhecidos como *controles de provedor de identidade*. Para obter mais informações sobre quais IdPs OIDC têm *controles de provedor de identidade*, consulte [Controles de provedor de identidade para provedores OIDC compartilhados](id_roles_providers_oidc_secure-by-default.md).

O procedimento a seguir descreve como criar o perfil para federação OIDC no Console de gerenciamento da AWS. Para criar uma função na AWS CLI ou na API da AWS, consulte os procedimentos em [Criar um perfil para um provedor de identidade de terceiros](id_roles_create_for-idp.md).

**Importante**  
Se você estiver usando o Amazon Cognito, use o console do Amazon Cognito para configurar as funções. Caso contrário, use o console do IAM para criar uma função para federação OIDC.

**Criar um perfil do IAM para a federação OIDC**

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação, escolha **Funções** e **Criar função**.

1. Escolha a **identidade da Web** como o tipo de entidade confiável e selecione **Avançar**.

1. Em **Identity provider** (Provedor de identidades), escolha o IdP para a função: 
   + Se você desejar criar uma função para um IdP da Web individual, selecione **Login with Amazon**, **Facebook** ou **Google**. 
**nota**  
Você deve criar uma função separada para cada IdP que quiser utilizar.
   + Se você desejar criar uma função de cenário avançado para o Amazon Cognito, escolha **Amazon Cognito**. 
**nota**  
Você só precisa criar manualmente uma função para usar com o Amazon Cognito quando está trabalhando em um cenário avançado. Caso contrário, o Amazon Cognito pode criar funções para você. Para obter mais informações sobre o Amazon Cognito, consulte [Provedores externos de identidade de grupos de identidades (identidades federadas)](https://docs.aws.amazon.com/cognito/latest/developerguide/external-identity-providers.html) no *Guia do desenvolvedor do Amazon Cognito*. 
   + Para criar uma função para o GitHub Actions, é necessário adicionar o provedor OIDC do GitHub ao IAM. Depois de adicionar o provedor OIDC do GitHub ao IAM, escolha **token.actions.githubusercontent.com**. 
**nota**  
Para obter informações sobre como configurar a AWS para confiar no provedor de OIDC do GitHub como uma identidade federada, consulte [Documentos do GitHub – Configuração do OpenID Connect na Amazon Web Services](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services). Para obter informações sobre as práticas recomendadas para limitar o acesso às funções associadas ao IAM IdP para GitHub, consulte [Configurar uma função para o provedor de identidades OIDC GitHub](#idp_oidc_Create_GitHub) nesta página.
   + Se você desejar criar um perfil para a HashiCorp Cloud Platform (HCP) Terraform, comece adicionando o provedor de OIDC do Terraform ao IAM. Depois de adicionar o provedor de OIDC Terraform ao IAM, escolha **app.terraform.io**. 
**Importante**  
Os perfis do IAM para o provedor de OIDC Terraform da HashiCorp Cloud Platform (HCP) devem avaliar a chave de condição do IAM, `app.terraform.io:sub`, na política de confiança do perfil. Essa chave de condição limita quais organizações, projetos, espaços de trabalho ou fases de execução do HCP Terraform são capazes de assumir o perfil. Sem essa chave de condição, sua política de confiança concede acesso ao seu perfil e a recursos da AWS por meio de identidades fora da sua organização, o que não se alinha ao princípio de privilégio mínimo.   
Se você definir ou modificar uma política de confiança de um perfil para um perfil associado ao provedor de OIDC Terraform da HCP em sua conta da AWS, mas não avaliar a chave de condição do IAM `app.terraform.io:sub`, você receberá um erro. Além disso, o AWS STS negará solicitações de autorização se sua política de confiança de perfil não avaliar essa chave de condição.

1. As informações solicitadas variam de acordo com o provedor OIDC que você escolher.
   + Insira o identificador para a aplicação. O rótulo do identificador é alterado de acordo com o provedor escolhido:
     + Se você desejar criar uma função para o Login with Amazon, insira o ID da aplicação na caixa **Application ID** (ID da aplicação).
     + Se você desejar criar uma função para o Facebook, digite o ID da aplicação na caixa **Application ID** (ID da aplicação).
     + Se você desejar criar uma função para o Google, digite o nome do público na caixa **Audience** (Público).
     + Se você desejar criar uma função para o Amazon Cognito, digite o ID do grupo de identidades que você criou para as aplicações do Amazon Cognito na caixa **Identity Pool ID** (ID do grupo de identidades).
   + Para criar uma função para GitHub Actions, insira os seguintes detalhes:
     + Em **Público**, escolha `sts.amazonaws.com`.
     + Em **Organização do GitHub**, insira o nome da organização no GitHub. O nome da organização do GitHub é obrigatório e deve ser alfanumérico, incluindo traços (-). Não é permitido usar caracteres curinga (\$1 e ?) no nome da organização do GitHub.
     + (Opcional) Em **Repositório do GitHub**, insira o URL do seu repositório do GitHub. Se você não especificar um valor, o padrão será um coringa (`*`).
     + (Opcional) em **Filial do GitHub**, insira o nome da filial do GitHub. Se você não especificar um valor, o padrão será um coringa (`*`).
   + Se você desejar criar um perfil para a HashiCorp Cloud Platform (HCP) Terraform, insira os detalhes a seguir:
     + Em **Público**, escolha `aws.workload.identity`.
     + Em **Organização**, insira o nome da organização. É possível especificar um caractere curinga (`*`) para todas as organizações.
     + Em **Projeto**, insira o nome do projeto. É possível especificar um caractere curinga (`*`) para todos os projetos.
     + Em **Workspace**, insira o nome do workspace. É possível especificar um caractere curinga (`*`) para todos os workspaces.
     + Em **Fase de execução**, insira o nome da fase de execução. É possível especificar um caractere curinga (`*`) para todas as fases de execução.

1. (Opcional) em **Condição (opcional)**, escolha **Adicionar condição** para criar condições adicionais que devem ser atendidas para que os usuários da aplicação possam usar as permissões concedidas pela função. Por exemplo, você pode adicionar uma condição que conceda acesso a recursos da AWS apenas para um determinado ID de usuário do IAM. Você também pode adicionar condições à política de confiança após a criação da função. Para obter mais informações, consulte [Atualizar a política de confiança de um perfil](id_roles_update-role-trust-policy.md).

1. Revise suas informações de OIDC e escolha **Próximo**.

1. O IAM inclui uma lista das políticas gerenciadas pela AWS e pelo cliente em sua conta. Selecione a política a ser usada para a política de permissões ou escolha **Create policy** (Criar política) para abrir uma nova guia no navegador e criar uma nova política a partir do zero. Para obter mais informações, consulte [Criação de políticas do IAM](access_policies_create-console.md#access_policies_create-start). Depois de criar a política, feche essa guia e retorne à guia original. Marque a caixa de seleção ao lado das políticas de permissões que você deseja que os usuários do OIDC tenham. Se preferir, você pode optar por não selecionar nenhuma política neste momento e anexar as políticas à função mais tarde. Por padrão, uma função não tem nenhuma permissões.

1. (Opcional) Defina um [limite de permissões](access_policies_boundaries.md). Este é um recurso avançado.

   Abra a seção **Set permissions boundary** (Definir limite de permissões) e escolha **Use a permissions boundary to control the maximum role permissions** (Usar um limite de permissões para controlar o número máximo de permissões de função). Selecione a política a ser usada para o limite de permissões.

1. Escolha **Próximo**.

1. Em **Role name** (Nome da função), insira um nome. Os nomes de função devem ser exclusivos em sua Conta da AWS. Eles não diferenciam maiúsculas e minúsculas. Por exemplo, não é possível criar duas funções denominadas **PRODROLE** e **prodrole**. Como outros recursos da AWS podem referenciar a função, não é possível editar o nome da função depois que ele é criado.

1. (Opcional) Em **Description** (Descrição), insira uma descrição para a nova função.

1. Para editar os casos de uso e as permissões da função, escolha **Edit** (Editar) nas seções **Etapa 1: selecionar entidades confiáveis** ou na **Etapa 2: adicionar permissões**. 

1. (Opcional) Para adicionar metadados à função, anexe tags como pares de chave-valor. Para obter mais informações sobre como usar tags no IAM, consulte [Tags para recursos do AWS Identity and Access Management](id_tags.md).

1. Revise o perfil e escolha **Criar perfil**.

## Configurar uma função para o provedor de identidades OIDC GitHub
<a name="idp_oidc_Create_GitHub"></a>

Se você usar o GitHub como um provedor de identidades (IdP) Open ID Connect (OIDC), a prática recomendada será limitar as entidades que podem assumir o perfil associado ao IdP do IAM. Ao incluir uma instrução de condição na política de confiança, você pode limitar a função a uma organização, repositório ou ramificação específica do GitHub. É possível usar a chave de condição `token.actions.githubusercontent.com:sub` com operadores de condição de string para limitar o acesso. Recomendamos limitar a condição a um conjunto específico de repositórios ou ramificações em sua organização do GitHub. Para obter informações sobre como configurar a AWS para confiar no OIDC do GitHub como uma identidade federada, consulte [GitHub Docs - Configuring OpenID Connect in Amazon Web Services](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services) ("Documentos do GitHub - Configurar o OpenID Connect na Amazon Web Services"). 

Se você usar ambientes do GitHub em fluxos de trabalho de ação ou em políticas de OIDC, é extremamente recomendável adicionar regras de proteção ao ambiente para aumentar a segurança. Use ramificações e tags de implantação para restringir quais ramificações e tags podem ser implantadas no ambiente. Para obter mais informações sobre a configuração de ambientes com regras de proteção, consulte [Ramificações de implantação e marcas](https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#deployment-branches-and-tags) no artigo *Usando ambientes para implantação* do GitHub.

Quando o IdP OIDC do GitHub é a entidade principal confiável para seu perfil, o IAM verifica a condição da política de confiança do perfil para verificar se a chave de condição `token.actions.githubusercontent.com:sub` está presente e se seu valor não é apenas um caractere curinga (\$1 e ?) ou nulo. O IAM realiza essa verificação quando a política de confiança é criada ou atualizada. Se a chave de condição `token.actions.githubusercontent.com:sub` não estiver presente ou o valor da chave não satisfizer os critérios de valor mencionados, a solicitação falhará e retornará um erro.

**Importante**  
Se você não limitar a chave de condição `token.actions.githubusercontent.com:sub` a uma organização ou um repositório específico, as ações do GitHub de organizações ou repositórios fora do seu controle poderão assumir perfis associados ao IdP do IAM do GitHub na sua conta da AWS.

O exemplo de política de confiança a seguir limita o acesso à organização, repositório e ramificação definidos do GitHub. O valor da chave de condição `token.actions.githubusercontent.com:sub` no exemplo a seguir é o formato padrão do valor do assunto documentado pelo GitHub.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "arn:aws:iam::012345678910:oidc-provider/token.actions.githubusercontent.com"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "token.actions.githubusercontent.com:aud": "sts.amazonaws.com",
          "token.actions.githubusercontent.com:sub": "repo:GitHubOrg/GitHubRepo:ref:refs/heads/GitHubBranch"
        }
      }
    }
  ]
}
```

------

O exemplo de condição a seguir limita o acesso à organização e ao repositório definidos do GitHub, mas concede acesso a qualquer ramificação dentro do repositório.

```
"Condition": {
  "StringEquals": {
          "token.actions.githubusercontent.com:aud": "sts.amazonaws.com"
  },
  "StringLike": {    
    "token.actions.githubusercontent.com:sub": "repo:GitHubOrg/GitHubRepo:*"
  }
}
```

O exemplo de condição a seguir limita o acesso a qualquer repositório ou ramificação dentro da organização do GitHub definida. Recomendamos limitar a chave de condição `token.actions.githubusercontent.com:sub` a um valor específico que limita o acesso ao GitHub Actions de dentro da sua organização do GitHub.

```
"Condition": {
  "StringEquals": {
          "token.actions.githubusercontent.com:aud": "sts.amazonaws.com"
  },
  "StringLike": {    
    "token.actions.githubusercontent.com:sub": "repo:GitHubOrg/*"
  }
}
```

Para obter mais informações sobre chaves de federação OIDC disponíveis para verificação de condições nas políticas, consulte [Chaves disponíveis para federação OIDC da AWS](reference_policies_iam-condition-keys.md#condition-keys-wif).

# Criar um perfil para uma federação do SAML 2.0 (console)
<a name="id_roles_create_for-idp_saml"></a>

 Você pode usar a federação do SAML 2.0 em vez de criar usuários do IAM na sua Conta da AWS. Com um provedor de identidade (IdP), você pode gerenciar as identidades de usuários fora da AWS e fornecer a essas identidades de usuários externos permissões para acessar recursos da AWS na sua conta. Para obter mais informações sobre federação e provedores de identidade, consulte [Federação e provedores de identidade na AWS](id_roles_providers.md).

**nota**  
Para melhorar a resiliência da federação, recomendamos que você configure seu IdP e sua  federação da AWS para oferecer suporte a vários endpoints de login do SAML. Para obter detalhes, consulte o artigo do AWS Security Blog [How to use regional SAML endpoints for failover](https://aws.amazon.com/blogs//security/how-to-use-regional-saml-endpoints-for-failover).

## Pré-requisitos para a criação de uma função para o SAML
<a name="idp_saml_Prerequisites"></a>

Para criar uma função para a federação SAML 2.0, você primeiro deve concluir as etapas obrigatórias a seguir.<a name="saml-prereqs"></a>

**Para se preparar para uma função para a federação do SAML 2.0**

1. <a name="idpsamlstep1"></a>Antes de criar uma função para federação baseada em SAML, você deve criar um provedor SAML no IAM. Para obter mais informações, consulte [Criar um provedor de identidades SAML no IAM](id_roles_providers_create_saml.md).

1. Prepare as políticas para a função que os usuários autenticados pelo SAML 2.0 assumirão. Assim como com qualquer função, uma função para a federação do SAML inclui duas políticas. Uma é a política de confiança da função que especifica quem pode assumir a função. A outra é a política de permissões do IAM que especifica as ações e os recursos da AWS aos quais a entidade principal federada SAML tem ou não permissão para acessar.

   Quando você criar a política de confiança para sua função, deverá usar três valores para garantir que a função só possa ser assumida por sua aplicação:
   + No elemento `Action`, use a ação `sts:AssumeRoleWithSAML`.
   + No elemento `Principal`, use a string `{"Federated":ARNofIdentityProvider}`. Substitua `ARNofIdentityProvider` pelo nome de recurso da Amazon (ARN) do [provedor de identidade SAML](id_roles_providers_saml.md) que você criou em [Step 1](#idpsamlstep1).
   + Para o elemento `Condition`, use uma condição `StringEquals` para verificar se o atributo `saml:aud` da resposta SAML corresponde ao URL exibido pelo seu navegador durante o início de sessão no console. Essa URL do endpoint de início de sessão é o atributo de destinatário SAML do seu provedor de identidade. É possível incluir URLs de início de sessão em determinadas regiões. A AWS recomenda usar endpoints regionais em vez do endpoint global para melhorar a resiliência da federação. Para obter uma lista dos possíveis valores de *region-code* (região-código), consulte a coluna **Region** (Região) em [AWS Sign-In endpoints](https://docs.aws.amazon.com/general/latest/gr/signin-service.html) (Endpoints de login da ).

     Se a criptografia SAML for necessária, o URL de início de sessão deverá incluir o identificador exclusivo que a AWS atribui ao seu provedor SAML. É possível visualizar o identificador exclusivo selecionando o provedor de identidade no console do IAM para exibir a página de detalhes.

     `https://region-code.signin.aws.amazon.com/saml/acs/IdP-ID`

   A política de confiança de exemplo a seguir foi projetada para um usuário federado do SAML:

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Action": "sts:AssumeRoleWithSAML",
           "Principal": {
               "Federated": "arn:aws:iam::111122223333:saml-provider/PROVIDER-NAME"
           },
           "Condition": {
               "StringEquals": {
                   "SAML:aud": "https://region-code.signin.aws.amazon.com/saml"
               }
           }
       }
   }
   ```

------

   Substitua o ARN da entidade de segurança pelo ARN real do provedor SAML que você criou no IAM. Ele terá seu próprio ID de conta e nome de provedor. 

## Criar uma função para o SAML
<a name="idp_saml_Create"></a>

Depois de concluir as etapas obrigatórias, você pode criar a função para federação baseada no SAML. 

**Para criar uma função para a federação baseada em SAML**

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação do console do IAM, escolha **Roles (Funções)** e **Criar função (Create role)**.

1. Escolha o tipo de função **Federação SAML 2.0**.

1. Em **SAML Provider** (Provedor SAML), escolha o provedor para a função. 

1. Escolha o método de nível de acesso SAML 2.0. 
   + Escolha **Allow programmatic access only (Permitir acesso programático apenas)** para criar uma função que possa ser assumida programaticamente na API da AWS ou na AWS CLI.
   + Escolha **Allow programmatic and Console de gerenciamento da AWS access** (Permitir acesso programático e do console) para criar uma função que possa ser assumida de forma programática e no Console de gerenciamento da AWS.

   As funções criadas por ambos são semelhantes, mas a função que também pode ser assumida no console inclui uma política de confiança com uma determinada condição. Essa condição garante explicitamente que o público de SAML (atributo `SAML:aud`) seja definido como o endpoint de início de sessão da AWS para seu provedor SAML.

1. O procedimento para definir atributos varia em função do tipo de acesso.
   + Se estiver criando uma função para acesso programático, escolha um atributo na lista **Atributo**. Em seguida, na caixa **Value** (Valor), insira um valor a ser incluído na função. Isso restringe o acesso à função a usuários do provedor de identidade cuja resposta de autenticação SAML (declaração) inclua os atributos especificados. Você deve especificar pelo menos um atributo para garantir que sua função seja limitada a um subconjunto de usuários em sua organização. 
   + Se você estiver criando um perfil para acesso programático e via Console de gerenciamento da AWS, a seção **Endpoints de início de sessão** define o URL que seu navegador exibe durante o início de sessão no console. Esse endpoint é o atributo de destinatário SAML do seu provedor de identidade, que é mapeado na chave de contexto [`saml:aud`](reference_policies_iam-condition-keys.md#condition-keys-saml). Para obter mais informações, consulte [Configurar declarações SAML para a resposta de autenticação](id_roles_providers_create_saml_assertions.md).

     1. Escolha **Endpoints regionais** ou **Endpoint não regional**. Recomendamos o uso de vários endpoints de início de sessão SAML regionais para melhorar a resiliência da federação.

     1. Em **Regiões**, escolha as regiões às quais seu provedor de SAML oferece suporte para início de sessão na AWS.

     1.  Em **URLs de início de sessão devem incluir identificadores exclusivos**, selecione se os endpoints de início de sessão incluem os identificadores exclusivos que a AWS atribui ao seu provedor de identidade SAML. Essa opção é necessária para asserções SAML criptografadas. Para obter mais informações, consulte [Federação SAML 2.0](id_roles_providers_saml.md).

1. Para adicionar à política de confiança mais condições relacionadas a atributos, escolha **Condition (optional)** (Adicionar condições [opcional]), selecione a condição adicional e especifique um valor. 
**nota**  
A lista inclui os atributos do SAML usados com mais frequência. O IAM oferece suporte a atributos adicionais que você pode usar para criar condições. Para obter uma lista dos atributos com suporte, consulte [Chaves disponíveis para a federação do SAML](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#condition-keys-saml) Se precisar de uma condição para um atributo do SAML compatível que não esteja na lista, você poderá adicionar essa condição manualmente. Para fazer isso, edite a política de confiança depois de criar a função.

1.  Revise as informações de confiança do SAML 2.0 e, em seguida, escolha **Next** (Avançar). 

1. O IAM inclui uma lista das políticas gerenciadas pela AWS e pelo cliente em sua conta. Selecione a política a ser usada para a política de permissões ou escolha **Create policy** (Criar política) para abrir uma nova guia no navegador e criar uma nova política a partir do zero. Para obter mais informações, consulte [Criação de políticas do IAM](access_policies_create-console.md#access_policies_create-start). Depois de criar a política, feche essa guia e retorne à guia original. Marque a caixa de seleção ao lado das políticas de permissões que deseja que os usuários federados SAML tenham. Se preferir, você pode optar por não selecionar nenhuma política neste momento e anexar as políticas à função mais tarde. Por padrão, uma função não tem nenhuma permissões.

1. (Opcional) Defina um [limite de permissões](access_policies_boundaries.md). Este é um recurso avançado.

   Abra a seção **Set permissions boundary** (Definir limite de permissões) e escolha **Use a permissions boundary to control the maximum role permissions** (Usar um limite de permissões para controlar o número máximo de permissões de função). Selecione a política a ser usada para o limite de permissões.

1. Escolha **Próximo**.

1. Escolha **Próximo: revisar**.

1. Em **Role name** (Nome da função), insira um nome. Os nomes de função devem ser exclusivos em sua Conta da AWS. Eles não são diferenciados por letras maiúsculas e minúsculas. Por exemplo, não é possível criar perfis denominados **PRODROLE** e **prodrole**. Como outros recursos de AWS podem fazer referência à função, não é possível editar o nome da função depois de ela ser criada. 

1. (Opcional) Em **Description** (Descrição), insira uma descrição para a nova função.

1. Escolha **Edit** (Editar) nas seções **Etapa 1: selecionar entidades confiáveis** ou na **Etapa 2: adicionar permissões** para editar os casos de uso e as permissões para a função. 

1. (Opcional) Adicione metadados à função anexando tags como pares de chave-valor. Para obter mais informações sobre como usar tags no IAM, consulte [Tags para recursos do AWS Identity and Access Management](id_tags.md).

1. Revise o perfil e escolha **Criar perfil**.

Depois de criar a função, você conclui a confiança do SAML configurando o software do provedor de identidade com informações sobre a AWS. Essas informações incluem as funções que você deseja que seus usuários federados SAML usem. Isso é chamado de configuração da confiança da parte confiável entre seu IdP e a AWS. Para obter mais informações, consulte [Configurar o IdP SAML 2.0 com objeto de confiança de terceira parte confiável e adição de declarações](id_roles_providers_create_saml_relying-party.md). 

# Criar um perfil usando políticas de confiança personalizadas
<a name="id_roles_create_for-custom"></a>

Você pode criar uma política de confiança personalizada para delegar acesso e permitir que outras pessoas realizem ações na sua Conta da AWS. Para obter mais informações, consulte [Criação de políticas do IAM](access_policies_create-console.md#access_policies_create-start).

Para obter informações sobre como usar funções para delegar permissões, consulte [Termos e conceitos das funções](id_roles.md#id_roles_terms-and-concepts).

## Criar um perfil do IAM usando políticas de confiança personalizada (console)
<a name="roles-creatingrole-custom-trust-policy-console"></a>

Você pode usar o Console de gerenciamento da AWS para criar uma função que um usuário do IAM pode assumir. Por exemplo, suponha que sua organização tem várias Contas da AWS para isolar um ambiente de desenvolvimento de um ambiente de produção. Para obter informações de alto nível sobre a criação de uma função que permita que os usuários na conta de desenvolvimento acessem recursos na conta de produção, consulte [Cenário de exemplo que usa contas separadas de desenvolvimento e produção](id_roles_common-scenarios_aws-accounts.md#id_roles_common-scenarios_aws-accounts-example).

**Para criar uma função usando uma política de confiança personalizadas (console)**

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM, em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação do console, escolha **Roles** (Perfis) e, em seguida, clique em **Create role** (Criar perfil).

1. Selecione o tipo de função **Custom trust policy** (Política de confiança personalizada).

1. Na seção **Custom trust policy** (Política de confiança personalizada), insira ou cole a política de confiança personalizada para a função. Para obter mais informações, consulte [Criação de políticas do IAM](access_policies_create-console.md#access_policies_create-start).

1. Resolva os avisos de segurança, erros ou avisos gerais gerados durante a [validação de política](access_policies_policy-validator.md) e depois escolha **Next** (Avançar).

1. (Opcional) Defina um [limite de permissões](access_policies_boundaries.md). Esse é um atributo avançado que está disponível para perfis de serviço, mas não para perfis vinculados ao serviço.

   Abra a seção **Set permissions boundary** (Definir limite de permissões) e escolha **Use a permissions boundary to control the maximum role permissions** (Usar um limite de permissões para controlar o número máximo de permissões de função). O IAM inclui uma lista das políticas gerenciadas pela AWS e pelo cliente em sua conta. Selecione a política a ser usada para o limite de permissões.

1. Escolha **Próximo**.

1. Para **Nome do perfil**, o grau de personalização do nome do perfil é definido pelo serviço. Se o serviço definir o nome da função, essa opção não será editável. Em outros casos, o serviço pode definir um prefixo para a função e permitir que você informe um sufixo opcional. Alguns serviços permitem que você especifique todo o nome de sua função.

   Se possível, insira um nome de função ou um sufixo de nome de função. Os nomes de função devem ser exclusivos em sua Conta da AWS. Eles não são diferenciados por letras maiúsculas e minúsculas. Por exemplo, não é possível criar perfis denominados **PRODROLE** e **prodrole**. Como outros recursos de AWS podem fazer referência à função, não é possível editar o nome da função depois de ela ser criada.

1. (Opcional) Em **Description** (Descrição), insira uma descrição para a nova função.

1. (Opcional) Escolha **Editar** nas seções **Etapa 1: selecionar entidades confiáveis** ou **Etapa 2: adicionar permissões** para editar a política personalizada e as permissões do perfil. 

1. (Opcional) Adicione metadados à função anexando tags como pares de chave-valor. Para obter mais informações sobre como usar tags no IAM, consulte [Tags para recursos do AWS Identity and Access Management](id_tags.md).

1. Revise o perfil e escolha **Criar perfil**.

# Exemplos de políticas para delegação de acesso
<a name="id_roles_create_policy-examples"></a>

Os exemplos a seguir mostram como você pode permitir ou conceder acesso para uma Conta da AWS aos recursos em outra Conta da AWS. Para saber como criar uma política do IAM usando esses exemplos de documentos de política JSON, consulte [Criar políticas usando o editor de JSON](access_policies_create-console.md#access_policies_create-json-editor).

**Topics**
+ [

## Uso de perfis para delegar acesso aos recursos de outra Conta da AWS
](#example-delegate-xaccount-rolesapi)
+ [

## Uso de uma política para delegar acesso a serviços
](#id_roles_create_policy-examples-access-to-services)
+ [

## Uso de uma política baseada em recurso para delegar acesso a um bucket do Amazon S3 em outra conta
](#example-delegate-xaccount-S3)
+ [

## Uso de uma política baseada em recurso para delegar acesso a uma fila do Amazon SQS em outra conta
](#example-delegate-xaccount-SQS)
+ [

## Não é possível delegar acesso quando o acesso à conta é negado
](#example-delegate-xaccount-SQS-denied)

## Uso de perfis para delegar acesso aos recursos de outra Conta da AWS
<a name="example-delegate-xaccount-rolesapi"></a>

 Para obter um tutorial que mostra como usar funções do IAM para conceder aos usuários em uma conta acesso a recursos da AWS que estão em outra conta, consulte [Tutorial do IAM: Delegar acesso entre contas da AWS usando funções do IAM](tutorial_cross-account-with-roles.md). 

**Importante**  
Você pode incluir o ARN de uma função ou usuário específico no elemento `Principal` de uma política de confiança de função. Quando você salva a política, o AWS transforma o ARN em um ID principal exclusivo. Isso ajuda a reduzir o risco de alguém elevar seus privilégios ao remover e recriar a função ou usuário. Normalmente, você não vê esse ID no console, porque há também uma transformação reversa de volta para o ARN quando a política de confiança é exibida. No entanto, se você excluir a função ou usuário, o relacionamento é interrompido. A política não se aplica mais, mesmo se você recriar o usuário ou a função, pois ela não corresponde ao ID principal armazenado na política de confiança. Quando isso acontece, o ID principal é exibido no console, pois a AWS não pode mais mapeá-lo de volta para um ARN. O resultado é que, se você excluir e recriar um usuário ou uma função referenciados no elemento `Principal` de uma política de confiança, você deverá editar a função para substituir o nome de recurso da Amazon (ARN). Ele é transformado no novo ID principal quando você salva a política.

## Uso de uma política para delegar acesso a serviços
<a name="id_roles_create_policy-examples-access-to-services"></a>

O exemplo a seguir mostra uma política que pode ser anexada a uma função. A política permite que dois serviços, Amazon EMR e AWS Data Pipeline, assumam a função. Os serviços podem então realizar qualquer tarefa concedida pela política de permissões atribuída à função (não exibida). Para especificar vários principais de serviço, você não especifica dois elementos `Service`; pode ter apenas um. Em vez disso, você usa uma variedade de principais de serviços múltiplas como o valor de um único elemento `Service`.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": [
          "elasticmapreduce.amazonaws.com",
          "datapipeline.amazonaws.com"
        ]
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
```

------

## Uso de uma política baseada em recurso para delegar acesso a um bucket do Amazon S3 em outra conta
<a name="example-delegate-xaccount-S3"></a>

Neste exemplo, a conta A usa uma política baseada em recurso (uma [política de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingBucketPolicies.html) do Amazon S3) para conceder à conta B o acesso total ao bucket do S3 da conta A. Em seguida, a conta B cria uma política de usuário do IAM para delegar esse acesso ao bucket da conta A a um dos usuários na conta B. 

A política de bucket do S3 na conta A pode se parecer com a seguinte política. Neste exemplo, o bucket do S3 da conta A é denominado *amzn-s3-demo-bucket* e o número da conta B é 111122223333. Ele não especifica quaisquer usuários individuais ou grupos na conta B, apenas a conta em si.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Sid": "AccountBAccess1",
    "Effect": "Allow",
    "Principal": {"AWS": "111122223333"},
    "Action": "s3:*",
    "Resource": [
      "arn:aws:s3:::amzn-s3-demo-bucket",
      "arn:aws:s3:::amzn-s3-demo-bucket/*"
    ]
  }
}
```

------

Como alternativa, a conta A pode usar as [Listas de controle de acesso (ACLs)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3_ACLs_UsingACLs.html) do Amazon S3 para conceder à conta B acesso ao bucket do S3 ou a um único objeto de um bucket. Nesse caso, a única coisa que muda é como a conta A concede acesso à conta B. A conta B ainda usa uma política para delegar acesso a um grupo do IAM na conta B, conforme descrito na próxima parte deste exemplo. Para mais informações sobre como controlar o acesso em objetos e buckets do S3, acesse [Controle de acesso](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingAuthAccess.html) no *Guia do usuário do Amazon Simple Storage Service*. 

O administrador da conta B pode criar a seguinte política de exemplo. A política concede acesso de leitura a um grupo ou usuário na conta B. A política anterior concede acesso à conta B. No entanto, grupos e usuários individuais na conta B não podem acessar o recurso até que uma política de grupo ou usuário explicitamente conceda permissões ao recurso. As permissões nesta política podem ser apenas um subconjunto das permissões anteriores de políticas entre contas. A conta B não pode conceder mais permissões para seus grupos e usuários do que a conta A concedeu para a conta B na primeira política. Nesta política, o elemento `Action` é explicitamente definido para permitir apenas ações `List` e o elemento `Resource` desta política corresponde ao `Resource` para a política de bucket implantada pela conta A.

Para implementar essa política, a conta B usa o IAM para anexá-la ao usuário (ou grupo) apropriado na conta B. 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Action": "s3:List*",
    "Resource": [
      "arn:aws:s3:::amzn-s3-demo-bucket",
      "arn:aws:s3:::amzn-s3-demo-bucket/*"
    ]
  }
}
```

------

## Uso de uma política baseada em recurso para delegar acesso a uma fila do Amazon SQS em outra conta
<a name="example-delegate-xaccount-SQS"></a>

No exemplo a seguir, a conta A tem uma fila do Amazon SQS que usa uma política baseada em recurso anexada à fila para conceder acesso à fila para a conta B. Em seguida, a conta B usa uma política de grupo do IAM para delegar acesso a um grupo na conta B. 

O seguinte exemplo de política de fila concede à conta B permissão para realizar as ações `SendMessage` e `ReceiveMessage` na fila da conta A chamada *queue1*, mas apenas entre o meio-dia e 15:00 em 30 de novembro de 2014. O número de conta da conta B é 1111-2222-3333. A conta A usa o Amazon SQS para implementar esta política. 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Principal": {"AWS": "111122223333"},
    "Action": [
      "sqs:SendMessage",
      "sqs:ReceiveMessage"
    ],
    "Resource": ["arn:aws:sqs:*:123456789012:queue1"],
    "Condition": {
      "DateGreaterThan": {"aws:CurrentTime": "2014-11-30T12:00Z"},
      "DateLessThan": {"aws:CurrentTime": "2014-11-30T15:00Z"}
    }
  }
}
```

------

A política da conta B para delegar acesso a um grupo na conta B pode se parecer com o exemplo a seguir. A conta B usa o IAM para anexar essa política a um grupo (ou usuário). 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Action": "sqs:*",
    "Resource": "arn:aws:sqs:*:123456789012:queue1"
  }
}
```

------

No exemplo de política de usuário do IAM anterior, a conta B usa um caractere curinga para conceder a seu usuário acesso a todas as ações do Amazon SQS na fila da conta A. No entanto, a conta B pode delegar acesso somente na medida em que o acesso foi concedido a ela. O grupo da conta B que tem a segunda política pode acessar a fila apenas entre meio-dia e 15:00 em 30 de novembro de 2014. O usuário só pode executar as ações `SendMessage` e `ReceiveMessage`, conforme definido na política de fila do Amazon SQS da conta A. 

## Não é possível delegar acesso quando o acesso à conta é negado
<a name="example-delegate-xaccount-SQS-denied"></a>

Uma Conta da AWS não pode delegar acesso aos recursos de outra conta se a outra conta tiver explicitamente negado o acesso à conta pai do usuário. A negação se propaga para os usuários daquela conta, independentemente de terem ou não políticas existentes que concedam acesso a eles.

Por exemplo, a conta A grava uma política de bucket no bucket do S3 da conta A que explicitamente nega o acesso da conta B ao bucket da conta A. Mas a conta B escreve uma política de usuário do IAM que concede a um usuário na conta B acesso ao bucket da conta A. A negação explícita aplicada ao bucket do S3 da conta A se propaga para os usuários da conta B e substitui a política de usuário do IAM que concede acesso ao usuário da conta B. (Para obter informações detalhadas sobre como as permissões são avaliadas, consulte [Lógica da avaliação de política](reference_policies_evaluation-logic.md).) 

A política de bucket da conta A pode se parecer com a seguinte política. Neste exemplo, o bucket do S3 da conta A é denominado *amzn-s3-demo-bucket* e o número da conta B é 1111-2222-3333.. A conta A usa o Amazon S3 para implementar esta política. 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Sid": "AccountBDeny",
    "Effect": "Deny",
    "Principal": {"AWS": "111122223333"},
    "Action": "s3:*",
    "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
  }
}
```

------

Esta negação explícita substitui todas as políticas na conta B que concedem permissão para acessar o bucket do S3 na conta A. 

# Gerenciamento de perfis do IAM
<a name="id_roles_manage"></a>

Para que um usuário, uma aplicação ou um serviço possa usar um perfil que você criou, você deverá conceder permissões para alternar para esse perfil. É possível usar qualquer política anexada a grupos ou usuários para conceder as permissões necessárias. Esta seção descreve como conceder aos usuários permissão para usar uma função. Ela também explica como o usuário pode alternar para uma função no Console de gerenciamento da AWS, no Tools for Windows PowerShell, no AWS Command Line Interface (AWS CLI) e na API [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html).

**Importante**  
Ao criar uma função de forma programática, em vez de no console do IAM, você tem a opção de adicionar um `Path` de até 512 caracteres além do `RoleName`, que pode ter até 64 caracteres. No entanto, se você pretende usar uma função com o recurso **Switch Role** (Alternar função) no Console de gerenciamento da AWS, o `Path` e o `RoleName` combinados não podem exceder 64 caracteres.

**Topics**
+ [

## Visualizar acesso à função
](#roles-modify_prerequisites)
+ [

## Gerar uma política com base em informações de acesso
](#roles-modify_gen-policy)
+ [

# Conceder permissões a um usuário para alternar perfis
](id_roles_use_permissions-to-switch.md)
+ [

# Conceda permissões a um usuário para passar um perfil para um serviço da AWS
](id_roles_use_passrole.md)
+ [

# Revogar as credenciais de segurança temporárias do perfil do IAM
](id_roles_use_revoke-sessions.md)
+ [

# Atualizar um perfil vinculado ao serviço
](id_roles_update-service-linked-role.md)
+ [

# Atualizar a política de confiança de um perfil
](id_roles_update-role-trust-policy.md)
+ [

# Atualizar permissões para um perfil
](id_roles_update-role-permissions.md)
+ [

# Atualizar as configurações de um perfil
](id_roles_update-role-settings.md)
+ [

# Excluir perfis ou perfis de instância
](id_roles_manage_delete.md)

## Visualizar acesso à função
<a name="roles-modify_prerequisites"></a>

Antes de alterar as permissões de uma função, você deve revisar a atividade no nível de serviço recente. Isso é importante porque você não deseja remover acesso de uma entidade principal (pessoa ou aplicativo) que está usando. Para obter mais informações sobre como visualizar as informações acessadas por último, consulte [Refinar permissões na AWS usando informações do último acesso](access_policies_last-accessed.md).

## Gerar uma política com base em informações de acesso
<a name="roles-modify_gen-policy"></a>

Às vezes, você pode conceder permissões a uma entidade do IAM (usuário ou função) além do que é exigido. Para ajudar você a refinar as permissões concedidas, você pode gerar uma política do IAM baseada na atividade de acesso para uma entidade. 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 entidade no intervalo de datas especificado. Você pode usar o modelo para criar uma política gerenciada com permissões refinadas e anexá-la à entidade do IAM. Dessa forma, você concede apenas as permissões de que o usuário ou a função precisa para interagir com os recursos da AWS para seu caso de uso específico. Para saber mais, consulte [Geração de políticas do IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-generation.html).

# Conceder permissões a um usuário para alternar perfis
<a name="id_roles_use_permissions-to-switch"></a>

Ao [criar um perfil para acesso entre contas](id_roles_create_for-user.md), o administrador estabelece confiança entre a conta que possui perfil, os recursos (conta de confiança) e a conta que contém os usuários (conta confiável). Para fazer isso, o administrador da conta confiável especifica o número da conta de confiança como `Principal` na política de confiança da função. Isso *potencialmente* permite que qualquer usuário na conta confiável assuma o perfil. Para concluir a configuração, o administrador da conta confiável deve conceder a grupos ou usuários específicos nessa conta permissão para alternar para a função.

**Para conceder permissão para alternar para um perfil**

1. Como administrador da conta confiável, crie uma nova política para o usuário ou edite uma política existente adicionando os elementos necessários. Para obter detalhes, consulte [Criação ou edição da política](#roles-usingrole-createpolicy).

1. Em seguida, escolha como deseja compartilhar as informações do perfil: 
   + **Link do perfil:** envie aos usuários um link que os leve para a página **Switch Role** (Alternar perfil) com todos os detalhes já preenchidos. 
   + **Account ID or alias** (ID ou alias da conta): forneça a cada usuário o nome do perfil com o número de ID da conta ou o alias da conta. Em seguida, o usuário acessa a página **Alternar função** e adiciona os detalhes manualmente. 

   Para obter detalhes, consulte [Fornecer informações ao usuário](#roles-usingrole-giveuser).

Observe que você só pode alternar funções quando fizer login como um usuário do IAM, uma função federada SAML ou uma função federada de identidade da web. Você não pode mudar de funções quando se conecta como o Usuário raiz da conta da AWS.

**Importante**  
Não é possível alternar perfis no Console de gerenciamento da AWS para um perfil que exija um valor [ExternalId](id_roles_common-scenarios_third-party.md#id_roles_third-party_external-id). Você só pode alternar para tal perfil chamando a API [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html), que é compatível com o parâmetro `ExternalId`.

**Observações**  
Este tópico aborda políticas para um *usuário*, porque, em última análise, você está concedendo permissões a um usuário para realizar uma tarefa. Porém, não recomendamos conceder permissões diretamente a um usuário individual. Ao assumir um perfil, o usuário recebe as permissões associadas a esse perfil.
Quando você muda de funções no Console de gerenciamento da AWS, o console sempre usa suas credenciais originais para autorizar a mudança. Isso se aplica se você fizer login como usuário do IAM, como função federada SAML ou como função federada de identidade da Web. Por exemplo, se você mudar para RoleA, o IAM utilizará o usuário original ou as credenciais de perfil federado para determinar se você tem permissão para assumir o RoleA. Se você tentar mudar para a FunçãoB *enquanto estiver usando a FunçãoA*, o usuário **original** ou as credenciais de função federada serão usadas para autorizar sua tentativa. As credenciais para RoleA não são usadas para essa ação.

**Topics**
+ [

## Criação ou edição da política
](#roles-usingrole-createpolicy)
+ [

## Fornecer informações ao usuário
](#roles-usingrole-giveuser)

## Criação ou edição da política
<a name="roles-usingrole-createpolicy"></a>

Uma política que conceda a um usuário permissão para assumir uma função deve incluir uma instrução com o efeito `Allow` sobre o seguinte: 
+ A ação `sts:AssumeRole`
+ O Amazon Resource Name (ARN – Nome de recurso da Amazon) da função em um elemento `Resource`

Os usuários que obtêm a política têm permissão para alternar perfis no recurso listado (por meio da associação do grupo ou anexado diretamente).

**nota**  
Se `Resource` for definido como `*`, o usuário poderá assumir qualquer função em qualquer conta que confie na conta do usuário. (Em outras palavras, a política de confiança da função especifica a conta do usuário como `Principal`). Como melhor prática, recomendamos que você siga o [princípio do menor privilégio](http://en.wikipedia.org/wiki/Principle_of_least_privilege) e especifique o ARN completo apenas para as funções de que o usuário precisa.

O exemplo a seguir mostra uma política que permite que o usuário assuma funções em apenas uma conta. Além disso, a política usa um curinga (\$1) para especificar que o usuário só pode alternar para uma função caso o nome da função comece com as letras `Test`.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": {
        "Effect": "Allow",
        "Action": "sts:AssumeRole",
        "Resource": "arn:aws:iam::111122223333:role/Test*"
    }
}
```

------

**nota**  
As permissões que a função concede ao usuário não são adicionadas às permissões já concedidas ao usuário. Quando um usuário alterna para uma função, ele desiste temporariamente de suas permissões originais em troca das concedidas pela função. Quando o usuário sai da função, as permissões originais do usuário são restauradas automaticamente. Por exemplo, digamos que as permissões do usuário permitam trabalhar com instâncias do Amazon EC2, mas a política de permissões da função não conceda essas permissões. Nesse caso, enquanto usa a função, o usuário não pode trabalhar com instâncias do Amazon EC2 no console. Além disso, as credenciais temporárias obtidas por meio de `AssumeRole` não funcionam com instâncias do Amazon EC2 de maneira programática.

## Fornecer informações ao usuário
<a name="roles-usingrole-giveuser"></a>

Depois de criar uma função e conceder ao usuário permissões a fim de alternar para ela, você deverá fornecer ao usuário o seguinte:
+ O nome da função
+ O ID ou o alias da conta que contém a função

Você pode simplificar o acesso para seus usuários enviando a eles um link pré-configurado com o ID da conta e o nome do perfil. Você pode ver o link do perfil depois de concluir o assistente de **Criar perfil** selecionando o banner **Exibir perfil** ou na página **Resumo do perfil** para qualquer perfil habilitado para várias contas.

Você também pode usar o seguinte formato para construir manualmente o link. Substitua o ID ou o alias da conta e o nome da função para os dois parâmetros no exemplo a seguir.

`https://signin.aws.amazon.com/switchrole?account=your_account_ID_or_alias&roleName=optional_path/role_name`

Recomendamos direcionar seus usuários a [Mudar de um usuário para um perfil do IAM (console)](id_roles_use_switch-role-console.md) para orientá-los durante o processo. Para solucionar problemas comuns que você pode encontrar ao assumir um perfil, consulte [Não consigo assumir uma função](troubleshoot_roles.md#troubleshoot_roles_cant-assume-role).

**Considerações**
+ Se você criar o perfil de forma programática, poderá criá-lo com um caminho e um nome. Se você fizer isso, deverá fornecer o caminho completo e o nome da função aos usuários para que eles possam inseri-los na página **Switch Role** (Alternar função) do Console de gerenciamento da AWS. Por exemplo: `division_abc/subdivision_efg/role_XYZ`.
+ Se você criar um perfil de forma programática, poderá adicionar um `Path` de até 512 caracteres e um `RoleName`. O nome da função pode ter até 64 caracteres. No entanto, para usar uma função com o recurso **Switch Role** (Alternar função) no Console de gerenciamento da AWS, o `Path` e o `RoleName` combinados não podem exceder 64 caracteres.
+ Por motivos de segurança, você pode [revisar logs do AWS CloudTrail](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds) para saber quem executou uma ação na AWS. Você pode usar a chave de condição `sts:SourceIdentity` na política de confiança da função para exigir que os usuários especifiquem uma identidade quando assumirem uma função. Por exemplo, você pode exigir que os usuários do IAM especifiquem seu próprio nome de usuário como a identidade-fonte. Isso pode ajudar você a determinar qual usuário executou uma ação específica na AWS. Para obter mais informações, consulte [`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity). Você também pode usar [`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname) para exigir que os usuários especifiquem um nome de sessão quando assumirem uma função. Isso pode ajudar você a diferenciar as sessões de função quando uma função é usada por diferentes entidades de segurança.

# Conceda permissões a um usuário para passar um perfil para um serviço da AWS
<a name="id_roles_use_passrole"></a>

Para configurar muitos produtos da AWS é necessário *passar* uma função do IAM para o serviço. Isso permite que o serviço assuma a função posteriormente e realize ações em seu nome. Para a maioria dos serviços, você só precisa passar a função para o serviço uma vez durante a configuração, não toda vez que o serviço assumir a função. Por exemplo, suponha que você tenha uma aplicação em execução em uma instância do Amazon EC2. Esse aplicativo requer credenciais temporárias para autenticação, além de permissões para autorizar o aplicativo a executar ações na AWS. Ao configurar a aplicação, você deve passar uma função para o Amazon EC2 usar com a instância que fornece essas credenciais. Defina as permissões para as aplicações em execução na instância anexando uma política do IAM à função. O aplicativo assume a função sempre que necessário para executar as ações que são permitidas pela função.

Para transmitir uma função (e suas permissões) para um serviço da AWS, um usuário deve ter permissões para *transmitir a função* para o serviço. Isso ajuda os administradores a garantir que apenas usuários aprovados possam configurar um serviço com uma função que concede permissões. Para permitir que um usuário passe uma função para um produto da AWS, você deve conceder a permissão `PassRole` ao usuário, à função ou ao grupo do IAM do usuário.

**Atenção**  
A permissão `PassRole` só pode ser usada para passar um perfil do IAM para um serviço que compartilha a mesma conta da AWS. Para passar um perfil na Conta A para um serviço na Conta B, primeiro é necessário criar um perfil do IAM na Conta B que possa assumir o perfil da Conta A. Em seguida, o perfil na Conta B pode ser passado para o serviço. Para obter detalhes, consulte [Acesso a recursos entre contas no IAM](access_policies-cross-account-resource-access.md).
Não tente controlar quem pode passar por uma função marcando a função e, em seguida, usando a chave de condição `ResourceTag` em uma política com a ação `iam:PassRole`. Os resultados dessa abordagem não são confiáveis.

Ao definir a permissão `PassRole`, é necessário garantir que um usuário não passe um perfil em que o perfil tenha mais permissões do que você deseja que o usuário tenha. Por exemplo, Alice pode não ter permissão para realizar nenhuma ação do Amazon S3. Se Alice pudesse passar um perfil para um serviço que permite ações do Amazon S3, o serviço poderia realizar ações do Amazon S3 em nome de Alice ao executar o trabalho.

Ao especificar um perfil vinculado ao serviço, você também precisa ter permissão para atribuir o perfil ao serviço. Alguns serviços criam automaticamente uma função vinculada ao serviço na sua conta quando você executa uma ação nesse serviço. Por exemplo, o Amazon EC2 Auto Scaling cria a função vinculada ao serviço `AWSServiceRoleForAutoScaling` quando você cria um grupo do Auto Scaling pela primeira vez. Se tentar especificar o perfil vinculado ao serviço ao criar um grupo do Auto Scaling e não tiver a permissão `iam:PassRole`, você receberá um erro. Se você não especificar explicitamente o perfil, a permissão `iam:PassRole` não será necessária, e o padrão é usar o perfil `AWSServiceRoleForAutoScaling` para todas as operações executadas no grupo. Para saber quais serviços dão suporte a funções vinculadas ao serviço, consulte [AWSServiços da que funcionam com o IAM](reference_aws-services-that-work-with-iam.md). Para saber quais serviços criam automaticamente uma função vinculada quando você executa uma ação no serviço, escolha o link **Sim** e visualize a documentação das funções vinculadas a serviços para o serviço.

Um usuário pode transmitir um ARN da função como um parâmetro em qualquer operação da API que usa a função para atribuir permissões ao serviço. Em seguida, o serviço verifica se esse usuário tem a permissão `iam:PassRole`. Para limitar o usuário a passar apenas as funções aprovadas, filtre a permissão `iam:PassRole` com o elemento `Resources` da instrução de política do IAM. 

Você pode usar o elemento `Condition` em uma política JSON para testar o valor das chaves incluídas no contexto de solicitação de todas as solicitações da AWS. Para saber mais sobre como usar chaves de condição em uma política, consulte [Elementos de política JSON do IAM: Condition](reference_policies_elements_condition.md). A chave de condição `iam:PassedToService` pode ser usada para especificar o principal de serviço do serviço para o qual uma função pode ser passada. Para saber mais sobre como usar a chave de `iam:PassedToService` condição em uma política, consulte [iam:PassedToService](reference_policies_iam-condition-keys.md#ck_PassedToService).

**Exemplo 1**  
Suponha que você deseja conceder a um usuário a capacidade de transmitir qualquer função de um conjunto de funções aprovadas para o serviço Amazon EC2 ao executar uma instância. Três elementos são necessários:
+ Uma *política de permissões* do IAM anexada à função que determina o que a função pode fazer. Defina as permissões para apenas as ações que a função deve realizar e os recursos que a função precisa para essas ações. Você pode usar a política de permissões do IAM gerenciada pela AWS ou criada para o cliente.

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": {
          "Effect": "Allow",
          "Action": [ "A list of the permissions the role is allowed to use" ],
          "Resource": [ "A list of the resources the role is allowed to access" ]
      }
  }
  ```

------
+ Uma* política de confiança* para a função que permite que o serviço assuma a função. Por exemplo, você pode anexar a seguinte política de confiança à função com a ação `UpdateAssumeRolePolicy`. Essa política de confiança permite que o Amazon EC2 use a função e as permissões anexadas à função.

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": {
          "Sid": "TrustPolicyStatementThatAllowsEC2ServiceToAssumeTheAttachedRole",
          "Effect": "Allow",
          "Principal": { "Service": "ec2.amazonaws.com" },
         "Action": "sts:AssumeRole"
      }
  }
  ```

------
+ Uma *política de permissões* do IAM anexada ao usuário do IAM que permite que o usuário transmita apenas as funções aprovadas. Geralmente `iam:GetRole` é adicionada a `iam:PassRole` para que o usuário possa obter os detalhes da função a ser transmitida. Neste exemplo, o usuário pode transmitir apenas funções que existam na conta especificada com nomes começando com `EC2-roles-for-XYZ-`:

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "iam:GetRole",
                  "iam:PassRole"
              ],
              "Resource": "arn:aws:iam::111122223333:role/EC2-roles-for-XYZ-*"
          }
      ]
  }
  ```

------

Agora o usuário pode iniciar uma instância do Amazon EC2 com uma função atribuída. Os aplicativos em execução na instância podem acessar credenciais temporárias para a função por meio de metadados do perfil da instância. As políticas de permissões anexadas à função determinam o que a instância pode fazer. 

**Exemplo 2**  
O Amazon Relational Database Service (Amazon RDS) é compatível com um recurso chamado **Monitoramento aprimorado**. Este recurso permite que o Amazon RDS monitore uma instância de banco de dados usando um agente. Ele também permite que o Amazon RDS registre métricas de log no Amazon CloudWatch Logs. Para habilitar esse recurso, você deve criar uma função de serviço para conceder ao Amazon RDS permissões para monitorar e gravar métricas em seus logs. 

**Para criar uma função para o monitoramento aprimorado do Amazon RDS**

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Selecione **Funções** e, depois, **Criar função**.

1. Escolha o tipo de perfil **Serviço da AWS** e, em **Casos de uso para outros Serviços da AWS**, escolha o serviço **RDS**. Escolha **RDS – Enhanced Monitoring** (RDS: monitoramento aprimorado) e, em seguida **Next** (Avançar).

1. Escolha a política de permissões **AmazonRDSEnhancedMonitoringRole**.

1. Escolha **Próximo**.

1. Em **Role name** (Nome da função), insira um nome de função que ajude a identificar a finalidade da função. Os nomes de função devem ser exclusivos em sua Conta da AWS. Ao ser usado em uma política ou como parte de um ARN, o nome de perfil diferencia maiúsculas de minúsculas. Quando exibida para os clientes no console, por exemplo, como durante o processo de login, o nome de função não diferencia maiúsculas de minúsculas. Como várias entidades podem fazer referência à função, não é possível editar o nome da função depois de criada.

1. (Opcional) Em **Description** (Descrição), insira uma descrição para o nova função.

1. (Opcional) Adicione metadados ao usuário anexando tags como pares de chave-valor. Para obter mais informações sobre como usar tags no IAM, consulte [Tags para recursos do AWS Identity and Access Management](id_tags.md).

1. Revise o perfil e escolha **Criar perfil**.

A função obtém, automaticamente, uma política de confiança que concede as permissões de serviço `monitoring.rds.amazonaws.com` para assumir a função. Depois disso, o Amazon RDS pode executar todas as ações que a política `AmazonRDSEnhancedMonitoringRole` permite.

O usuário que você deseja que acesse o monitoramento aprimorado precisa de uma política com uma declaração que permita que o usuário liste os perfis do RDS e uma declaração que permita ao usuário transmitir a função, como apresentado a seguir. Use o número da sua conta e substitua o nome do perfil pelo nome fornecido na etapa 6.

```
    {
      "Sid": "PolicyStatementToAllowUserToListRoles",
      "Effect": "Allow",
      "Action": ["iam:ListRoles"],
      "Resource": "*"
    },
    {
        "Sid": "PolicyStatementToAllowUserToPassOneSpecificRole",
        "Effect": "Allow",
        "Action": [ "iam:PassRole" ],
        "Resource": "arn:aws:iam::account-id:role/RDS-Monitoring-Role"
    }
```

Você pode combinar esta instrução com instruções em outra política ou colocá-la em sua própria política. Em vez de especificar que o usuário pode passar qualquer função que comece com `RDS-`, é possível substituir o nome da função no ARN do recurso por um curinga, por exemplo:

```
        "Resource": "arn:aws:iam::account-id:role/RDS-*"
```

## Ações `iam:PassRole` em logs do AWS CloudTrail
<a name="id_roles_use_passrole_logs"></a>

 `PassRole` não é uma chamada de API. `PassRole` é uma permissão, o que significa que nenhum log do CloudTrail é gerado para o `PassRole` do IAM. Para analisar quais perfis são transferidos para quais Serviços da AWS no CloudTrail, é necessário analisar o log do CloudTrail que criou ou modificou o recurso da AWS que recebeu o perfil. Por exemplo, um perfil é transferido para uma função do AWS Lambda ao ser criado. O log da ação `CreateFunction` mostra um registro do perfil que foi transferido para a função. 

# Revogar as credenciais de segurança temporárias do perfil do IAM
<a name="id_roles_use_revoke-sessions"></a>

**Atenção**  
Se você seguir as etapas nesta página, todos os usuários com sessões atuais criadas ao assumiram a função terão o acesso negado a todas as ações e recursos da AWS. Como resultado, os usuários poderão perder trabalho não salvo.

Ao permitir que os usuários acessem o Console de gerenciamento da AWS com um tempo de duração de sessão longo (como 12 horas), suas respectivas credenciais temporárias não expiram com tanta rapidez. Se os usuários expuserem inadvertidamente suas credenciais a um terceiro não autorizado, este terá acesso durante toda a sessão. No entanto, se necessário, você poderá revogar imediatamente todas as permissões para as credenciais da função emitidas antes de um determinado momento. Todas as credenciais temporárias para essa função emitidas antes do tempo especificado se tornam inválidas. Isso força todos os usuários a refazerem a autenticação e solicitar novas credenciais.

 

**nota**  
Você não pode revogar a sessão para uma *[função vinculada a serviço](id_roles.md#iam-term-service-linked-role)*.

Quando você revoga permissões para uma função usando o procedimento neste tópico, a AWS anexa uma nova política em linha à função que nega todas as permissões para todas as ações. Ele incluirá uma condição aplicável às restrições somente se o usuário tiver assumido a função *antes* do momento em que você revogar as permissões. Se o usuário assumir a função *depois* que você revogar as permissões, a política de negação não se aplicará a esse usuário.

Para obter mais informações sobre acesso negado, consulte [Desabilitar permissões de credenciais de segurança temporárias](id_credentials_temp_control-access_disable-perms.md).

**Importante**  
Essa política de negação se aplica a todos os usuários da função especificada, não apenas às sessões do console com maior duração.

## Permissões mínimas para revogar as permissões de sessão de uma função
<a name="revoke-session-permissions"></a>

Para revogar permissões de sessão de uma função com êxito, você deve ter a permissão `PutRolePolicy` para a função. Isso permite que você anexe a política em linha `AWSRevokeOlderSessions` à função.

## Revogar permissões de uma sessão
<a name="revoke-session"></a>

Você pode revogar as permissões de sessão de um perfil para negar todas as permissões de qualquer usuário que tenha assumido esse perfil.

**nota**  
Não é possível editar perfis no IAM que foram criados a partir de conjuntos de permissões do Centro de Identidade do IAM. É necessário revogar a sessão ativa do conjunto de permissões de um usuário no Centro de Identidade do IAM. Para obter mais informações, consulte [Revogar sessões ativas de perfil do IAM criadas por conjuntos de permissões](https://docs.aws.amazon.com/singlesignon/latest/userguide/useraccess.html#revoke-user-permissions), no *Guia do usuário do Centro de Identidade do IAM*.

**Para negar imediatamente todas as permissões para qualquer usuário atual de credenciais de função**

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação, escolha **Perfis** e selecione o nome (não a caixa de seleção) da função cujas permissões você deseja revogar.

1. Na página **Resumo** para a função selecionada, escolha a guia **Revogar sessões**.

1. Na guia **Revogar sessões**, selecione **Revogar sessões ativas**.

1. AWSA pede que você confirme a ação. Marque a caixa de seleção **Confirmo que estou revogando todas as sessões ativas para essa função** e escolha **Revogar sessões ativas**.

   O IAM então anexa uma política chamada `AWSRevokeOlderSessions` ao perfil. Depois de escolher **Revogar sessões ativas**, a política nega todo o acesso aos usuários que assumiram o perfil no passado, bem como em aproximadamente 30 segundos no futuro. Essa escolha de horário futuro leva em consideração o atraso de propagação da política para lidar com uma nova sessão que foi adquirida ou renovada antes que a política atualizada entrasse em vigor em uma determinada região. Os usuários que assumirem o perfil em mais de aproximadamente 30 segundos após você escolher a opção Revogar sessões ativas não serão afetados. Para saber por que as mudanças nem sempre são imediatamente visíveis, consulte [As alterações que eu faço nem sempre ficam imediatamente visíveis](troubleshoot.md#troubleshoot_general_eventual-consistency). 

**nota**  
Se, posteriormente, você escolher **Revogar sessões ativas** novamente, a marca de data e hora da política será atualizada e ela voltará a negar todas as permissões a todos os usuários que assumiram o perfil antes da nova hora especificada.

Os usuários válidos cujas sessões são revogadas dessa forma devem adquirir credenciais temporárias para uma nova sessão para continuar a trabalhar. A AWS CLI armazena em cache as credenciais até que elas expirem. Para forçar a CLI a excluir e atualizar credenciais de cache que não são mais válidas, execute um dos seguintes comandos:

**Linux, macOS ou Unix**

```
$ rm -r ~/.aws/cli/cache
```

**Windows**

```
C:\> del /s /q %UserProfile%\.aws\cli\cache
```

## Revogar as permissões da sessão antes de uma hora especificada
<a name="revoke-session-policy"></a>

 Também é possível revogar as permissões da sessão a qualquer momento usando a AWS CLI ou o SDK para especificar um valor para a chave `aws:TokenIssueTime` no elemento Condição de uma política. 

Essa política nega todas as permissões quando o valor de `aws:TokenIssueTime` é anterior à data e hora especificadas. O valor do `aws:TokenIssueTime` corresponde ao tempo exato em que as credenciais de segurança temporárias foram criadas. O valor `aws:TokenIssueTime` está presente apenas no contexto de solicitações da AWS assinadas com credenciais de segurança temporárias. Portanto, a instrução Negar na política não afeta as solicitações assinadas com as credenciais de longo prazo do usuário do IAM.

Essa política também pode ser anexada a um perfil. Neste caso, a política afeta somente as credenciais de segurança temporárias que foram criadas pela função antes da data e hora especificadas.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Deny",
    "Action": "*",
    "Resource": "*",
    "Condition": {
      "DateLessThan": {"aws:TokenIssueTime": "2014-05-07T23:47:00Z"}
    }
  }
}
```

------

Os usuários válidos cujas sessões são revogadas dessa forma devem adquirir credenciais temporárias para uma nova sessão para continuar a trabalhar. A AWS CLI armazena em cache as credenciais até que elas expirem. Para forçar a CLI a excluir e atualizar credenciais de cache que não são mais válidas, execute um dos seguintes comandos:

**Linux, macOS ou Unix**

```
$ rm -r ~/.aws/cli/cache
```

**Windows**

```
C:\> del /s /q %UserProfile%\.aws\cli\cache
```

# Atualizar um perfil vinculado ao serviço
<a name="id_roles_update-service-linked-role"></a>

O método que você usa para editar uma função vinculada ao serviço depende do serviço. Alguns serviços podem permitir que você edite as permissões para uma função vinculada ao serviço no console, API ou CLI do serviço. Contudo, depois que você cria uma função vinculada ao serviço, você não pode mudar o nome da função porque várias entidades podem fazer referência à função. Você pode editar a descrição de qualquer função do console, da API ou da CLI do IAM.

Para obter informações sobre quais serviços oferecem suporte a funções vinculadas a serviços, consulte [AWSServiços da que funcionam com o IAM](reference_aws-services-that-work-with-iam.md) e procure os serviços que têm **Sim **na coluna **Função vinculada ao serviço**. Para saber se o serviço oferece suporte a edição da função vinculada ao serviço, escolha o link **Sim** para visualizar a documentação da função vinculada desse serviço.

## Editar a descrição de uma função vinculada ao serviço (console)
<a name="edit-service-linked-role-iam-console"></a>

Você pode usar o console do IAM para editar a descrição de uma função vinculada ao serviço.

**Para editar a descrição de uma função vinculada ao serviço (console)**

1. No painel de navegação do console do IAM, escolha **Perfis**.

1. Escolha o nome da função a ser modificada.

1. No extremo direito da **Descrição da função**, escolha **Editar**. 

1. Insira uma nova descrição na caixa e escolha **Salvar**.

## Editar a descrição de uma função vinculada ao serviço (AWS CLI)
<a name="edit-service-linked-role-iam-cli"></a>

Você pode usar comandos do IAM na AWS CLI para editar a descrição de uma função vinculada ao serviço.

**Para alterar a descrição de uma função vinculada ao serviço (AWS CLI)**

1. (Opcional) Para visualizar a descrição atual de uma função, execute os comandos a seguir:

   ```
   aws iam [get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html) --role-name ROLE-NAME
   ```

   Use o nome da função, não o nome de recurso da Amazon (ARN), para fazer referência às funções com os comandos da CLI. Por exemplo, se uma função tiver o seguinte nome de recurso da Amazon (ARN): `arn:aws:iam::123456789012:role/myrole`, você fará referência à função como **myrole**.

1. Para atualizar a descrição de uma função vinculada ao serviço, execute um dos seguintes comandos:

   ```
   aws iam [update-role](https://docs.aws.amazon.com/cli/latest/reference/iam/update-role.html) --role-name ROLE-NAME --description OPTIONAL-DESCRIPTION
   ```

## Editar a descrição de uma função vinculada ao serviço (API da AWS)
<a name="edit-service-linked-role-iam-api"></a>

Você pode usar a API do AWS para editar a descrição de uma função vinculada ao serviço.

**Para alterar a descrição de uma função (AWS API)**

1. (Opcional) Para visualizar a descrição atual de a uma função, chame a seguinte operação e especifique o nome da função:

   API do AWS: [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) 

1. Para atualizar a descrição de uma função, chame a seguinte operação e especifique o nome (e a descrição opcional) da função: 

   API da AWS: [UpdateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRole.html) 

# Atualizar a política de confiança de um perfil
<a name="id_roles_update-role-trust-policy"></a>

Para alterar quem pode assumir uma função, você deve modificar a política de confiança da função. Você não pode modificar a política de confiança para uma *[função vinculada a serviço](id_roles.md#iam-term-service-linked-role)*.

**Observações**  
Se um usuário for listado como principal em uma política de confiança da função, mas não puder assumir a função, verifique o [limite de permissões](access_policies_boundaries.md) do usuário. Se um limite de permissões for definido para o usuário, ele deverá permitir a ação `sts:AssumeRole`.
Para permitir que os usuários assumam novamente o perfil atual em uma sessão de perfil, especifique o ARN do perfil ou o ARN da Conta da AWS como entidade principal na política de confiança do perfil. Os Serviços da AWS que fornecem recursos computacionais, como o Amazon EC2, Amazon ECS, Amazon EKS e Lambda, fornecem credenciais temporárias e atualizam automaticamente essas credenciais. Isso garante que você tenha sempre um conjunto de credenciais válido. Nesses serviços, não é necessário assumir novamente a função atual para obter credenciais temporárias. Porém, se pretender passar [tags de sessão](id_session-tags.md) ou uma [política de sessão](access_policies.md#policies_session), você precisará assumir novamente a função atual.


## Atualizar a política de confiança de um perfil (console)
<a name="id_roles_update-trust-policy-console"></a>

**Para alterar a política de confiança de um perfil no Console de gerenciamento da AWS**

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação do console do IAM, escolha **Perfis**.

1. Na lista de funções em sua conta, escolha o nome da função que deseja modificar.

1. Escolha a guia **Relacionamentos de confiança** e, em seguida, escolha **Editar política de confiança**.

1. Edite a política de confiança, conforme necessário. Para adicionar outras entidades principais que podem assumir a função, especifique-as no elemento `Principal`. Por exemplo, o fragmento de política a seguir mostra como fazer referência a duas Contas da AWS no elemento `Principal`:

   ```
   "Principal": {
     "AWS": [
       "arn:aws:iam::111122223333:root",
       "arn:aws:iam::444455556666:root"
     ]
   },
   ```

   Se você especificar um principal em outra conta, adicionar uma conta à política de confiança de uma função é apenas metade da tarefa de estabelecer o relacionamento de confiança entre contas. Por padrão, nenhum usuário nas contas confiáveis pode assumir a função. O administrador da conta confiável recém-criada deve conceder aos usuários a permissão para assumir a função. Para fazer isso, o administrador deve criar ou editar uma política que está anexada ao usuário para permitir acesso ao usuário à ação `sts:AssumeRole`. Para obter mais informações, consulte o procedimento a seguir ou [Conceder permissões a um usuário para alternar perfis](id_roles_use_permissions-to-switch.md).

   O trecho da política a seguir mostra como referenciar dois produtos da AWS no elemento `Principal`:

   ```
   "Principal": {
     "Service": [
       "opsworks.amazonaws.com",
       "ec2.amazonaws.com"
     ]
   },
   ```

1. Ao concluir a edição da política de confiança, escolha **Update policy**(Atualizar política) para salvar as alterações.

   Para obter mais informações sobre a estrutura e a sintaxe da política, consulte [Políticas e permissões no AWS Identity and Access Management](access_policies.md) e [Referência de elemento de política JSON do IAM](reference_policies_elements.md).

**Para permitir que os usuários em uma conta externa confiável usem a função (console)**

Para obter mais informações e detalhes sobre esse procedimento, consulte [Conceder permissões a um usuário para alternar perfis](id_roles_use_permissions-to-switch.md).

1. Faz login na Conta da AWS externa confiável. 

1. Decida se deseja anexar as permissões a um usuário ou a um grupo. No painel de navegação do console do IAM, escolha **Users** (Usuários) ou **Groups** (Grupos) conforme o caso.

1. Escolha o nome do usuário ou do grupo ao qual você deseja conceder acesso e, em seguida, selecione a guia **Permissões**.

1. Execute um destes procedimentos:
   + Para editar uma política gerenciada pelo cliente, escolha o nome da política, escolha **Editar política** e, em seguida, selecione a guia **JSON**. Você não pode editar uma política AWS gerenciada. As políticas AWS gerenciadas são exibidas com o ícone da AWS (![\[Orange cube icon indicating a policy is managed by AWS.\]](http://docs.aws.amazon.com/pt_br/IAM/latest/UserGuide/images/policy_icon.png)). Para obter mais informações sobre a diferença entre políticas gerenciadas pela AWS e pelo cliente, consulte [Políticas gerenciadas e em linha](access_policies_managed-vs-inline.md).
   + Para editar uma política em linha, escolha a seta próxima ao nome da política e escolha **Editar política**.

1. No editor de políticas, adicione um novo elemento `Statement` que especifica o seguinte:

   ```
   {
     "Effect": "Allow",
     "Action": "sts:AssumeRole",
     "Resource": "arn:aws:iam::ACCOUNT-ID:role/ROLE-NAME"
   }
   ```

   Substitua o ARN na instrução pelo ARN da função que o usuário pode assumir.

1. Siga os prompts na tela para terminar de editar a política. 

## Atualizar a política de confiança de um perfil (AWS CLI)
<a name="id_roles-update-trust-policy-cli"></a>

Você pode usar a AWS CLI para alterar quem pode assumir um perfil.

**Como modificar uma política de confiança da função (AWS CLI)**

1. (Opcional) Se você não souber o nome da função que deseja modificar, execute o seguinte comando para listar as funções em sua conta:
   + [aws iam list-roles](https://docs.aws.amazon.com/cli/latest/reference/iam/list-roles.html)

1. (Opcional) Para visualizar a política de confiança atual de uma função, execute o seguinte comando:
   + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)

1. Para modificar as entidades principais confiáveis que podem acessar a função, crie um arquivo de texto com a política de confiança atualizada. É possível usar qualquer editor de texto para construir a política.

   Por exemplo, a seguinte política de confiança mostra como fazer referência a duas Contas da AWS no elemento `Principal`. Isso permite que os usuários de duas Contas da AWS separadas assumam esse perfil.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Principal": {"AWS": [
               "arn:aws:iam::111122223333:root",
               "arn:aws:iam::444455556666:root"
           ]},
           "Action": "sts:AssumeRole"
       }
   }
   ```

------

   Se você especificar um principal em outra conta, adicionar uma conta à política de confiança de uma função é apenas metade da tarefa de estabelecer o relacionamento de confiança entre contas. Por padrão, nenhum usuário nas contas confiáveis pode assumir a função. O administrador da conta confiável recém-criada deve conceder aos usuários a permissão para assumir a função. Para fazer isso, o administrador deve criar ou editar uma política que está anexada ao usuário para permitir acesso ao usuário à ação `sts:AssumeRole`. Para obter mais informações, consulte o procedimento a seguir ou [Conceder permissões a um usuário para alternar perfis](id_roles_use_permissions-to-switch.md).

1. Para usar o arquivo que você acabou de criar para atualizar a política de confiança, execute o seguinte comando:
   + [aws iam update-assume-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/update-assume-role-policy.html)

**Para permitir que os usuários em uma conta externa confiável usem a função (AWS CLI)**

Para obter mais informações e detalhes sobre esse procedimento, consulte [Conceder permissões a um usuário para alternar perfis](id_roles_use_permissions-to-switch.md).

1. Crie um arquivo JSON que contenha uma política de permissões que concede permissões para assumir a função. Por exemplo, a seguinte política contém as permissões necessárias mínimas:

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Action": "sts:AssumeRole",
           "Resource": "arn:aws:iam::111122223333:role/ROLE-NAME"
       }
   }
   ```

------

   Substitua o ARN na instrução pelo ARN da função que o usuário pode assumir.

1. Execute o seguinte comando para carregar o arquivo JSON que contém a política de confiança para o IAM:
   + [aws iam create-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html)

   O resultado desse comando inclui o ARN da política. Anote esse ARN, pois você precisará dele em uma etapa posterior. 

1. Decida qual usuário ou grupo ao qual anexar a política. Se você não souber o nome do usuário ou do grupo pretendido, use um dos seguintes comandos para listar os usuários ou os grupos em sua conta:
   + [aws iam list-users](https://docs.aws.amazon.com/cli/latest/reference/iam/list-users.html)
   + [aws iam list-groups](https://docs.aws.amazon.com/cli/latest/reference/iam/list-groups.html)

1. Use um dos seguintes comandos para anexar a política criada na etapa anterior ao usuário ou ao grupo:
   + [aws iam attach-user-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-user-policy.html)
   + [aws iam attach-group-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-group-policy.html)

## Atualizar a política de confiança de um perfil (API da AWS)
<a name="id_roles-update-trust-policy-api"></a>

Você pode usar a API da AWS para alterar quem pode assumir um perfil.

**Como modificar a política de confiança de uma função (API da AWS)**

1. (Opcional) Se você não souber o nome da função que deseja modificar, chame a seguinte operação para listar as funções em sua conta:
   + [ListRoles](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRoles.html)

1. (Opcional) Para visualizar a política de confiança atual de uma função, chame a seguinte operação:
   + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html)

1. Para modificar as entidades principais confiáveis que podem acessar a função, crie um arquivo de texto com a política de confiança atualizada. É possível usar qualquer editor de texto para construir a política.

   Por exemplo, a seguinte política de confiança mostra como fazer referência a duas Contas da AWS no elemento `Principal`. Isso permite que os usuários de duas Contas da AWS separadas assumam esse perfil.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Principal": {"AWS": [
               "arn:aws:iam::111122223333:root",
               "arn:aws:iam::444455556666:root"
           ]},
           "Action": "sts:AssumeRole"
       }
   }
   ```

------

   Se você especificar um principal em outra conta, adicionar uma conta à política de confiança de uma função é apenas metade da tarefa de estabelecer o relacionamento de confiança entre contas. Por padrão, nenhum usuário nas contas confiáveis pode assumir a função. O administrador da conta confiável recém-criada deve conceder aos usuários a permissão para assumir a função. Para fazer isso, o administrador deve criar ou editar uma política que está anexada ao usuário para permitir acesso ao usuário à ação `sts:AssumeRole`. Para obter mais informações, consulte o procedimento a seguir ou [Conceder permissões a um usuário para alternar perfis](id_roles_use_permissions-to-switch.md).

1. Para usar o arquivo que você acabou de criar para atualizar a política de confiança, chame a seguinte operação:
   + [UpdateAssumeRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateAssumeRolePolicy.html)

**Para permitir que os usuários em uma conta externa confiável usem a função (API da AWS)**

Para obter mais informações e detalhes sobre esse procedimento, consulte [Conceder permissões a um usuário para alternar perfis](id_roles_use_permissions-to-switch.md).

1. Crie um arquivo JSON que contenha uma política de permissões que concede permissões para assumir a função. Por exemplo, a seguinte política contém as permissões necessárias mínimas:

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Action": "sts:AssumeRole",
           "Resource": "arn:aws:iam::111122223333:role/ROLE-NAME"
       }
   }
   ```

------

   Substitua o ARN na instrução pelo ARN da função que o usuário pode assumir.

1. Chame a seguinte operação para carregar o arquivo JSON que contém a política de confiança para o IAM:
   + [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)

   O resultado dessa operação inclui o ARN da política. Anote esse ARN, pois você precisará dele em uma etapa posterior. 

1. Decida qual usuário ou grupo ao qual anexar a política. Se você não souber o nome do usuário ou do grupo pretendido, chame uma das seguintes operações para listar os usuários ou os grupos em sua conta:
   + [ListUsers](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListUsers.html)
   + [ListGroups](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListGroups.html)

1. Chame uma das seguintes operações para anexar a política criada na etapa anterior ao usuário ou ao grupo:
   +  API: [AttachUserPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachUserPolicy.html)
   + [AttachGroupPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachGroupPolicy.html)

# Atualizar permissões para um perfil
<a name="id_roles_update-role-permissions"></a>

Use os procedimentos a seguir para atualizar as políticas de permissões e os limites de permissões de um perfil.

## Pré-requisito: visualizar o acesso ao perfil
<a name="roles-modify_prerequisites"></a>

Antes de alterar as permissões de uma função, você deve revisar a atividade no nível de serviço recente. Isso é importante porque você não deseja remover acesso de uma entidade principal (pessoa ou aplicativo) que está usando. Para obter mais informações sobre como visualizar as informações acessadas por último, consulte [Refinar permissões na AWS usando informações do último acesso](access_policies_last-accessed.md).

## Atualizar a política de permissões para um perfil
<a name="id_roles_update-role-permissions-policy"></a>

Para alterar as permissões permitidas pela função, modifique a política de permissões da função (ou políticas). Você não pode modificar a política de permissões para uma *[função vinculada ao serviço](id_roles.md#iam-term-service-linked-role)* no IAM. Pode ser possível modificar a política de permissões no serviço que depende da função. Para verificar se um serviço oferece suporte a este recurso, consulte [AWSServiços da que funcionam com o IAM](reference_aws-services-that-work-with-iam.md) e procure os serviços que têm **Sim **na coluna **Funções vinculadas ao serviço**. Escolha um **Sim** com um link para visualizar a documentação do perfil vinculado para esse serviço.

### Atualizar a política de permissões de um perfil (console)
<a name="id_roles_update-role-permissions-policy-console"></a>

**Para alterar as permissões permitidas por uma função (console)**

1. Abra o console IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação do console do IAM, escolha **Perfis**.

1. Escolha o nome da função que você deseja modificar e, em seguida, escolha a guia **Permissões**.

1. Execute um destes procedimentos:
   + Para editar uma política gerenciada do cliente atual, escolha o nome da política e escolha **Editar política**.
**nota**  
Você não pode editar uma política AWS gerenciada. As políticas AWS gerenciadas são exibidas com o ícone da AWS (![\[Orange cube icon indicating a policy is managed by AWS.\]](http://docs.aws.amazon.com/pt_br/IAM/latest/UserGuide/images/policy_icon.png)). Para obter mais informações sobre a diferença entre políticas gerenciadas pela AWS e pelo cliente, consulte [Políticas gerenciadas e em linha](access_policies_managed-vs-inline.md). 
   + Para anexar uma política gerenciada existente à função, escolha **Add permissions** (Adicionar permissões)e, depois, escolha **Attach policies** (Anexar políticas).
   + Para editar uma política em linha existente, expanda a política e escolha **Edit** (Editar).
   + Para incorporar uma nova política em linha, escolha **Add permissions** (Adicionar permissões) e, depois, escolha **Create inline policy** (Criar política em linha). 
   + Para remover uma política existente do perfil, marque a caixa de seleção ao lado do nome da política e escolha **Remover**.

### Atualizar uma política de permissões de perfil (AWS CLI)
<a name="id_roles_update_permissions-policy-cli"></a>

Para alterar as permissões permitidas pela função, modifique a política de permissões da função (ou políticas). Você não pode modificar a política de permissões para uma *[função vinculada ao serviço](id_roles.md#iam-term-service-linked-role)* no IAM. Pode ser possível modificar a política de permissões no serviço que depende da função. Para verificar se um serviço oferece suporte a este recurso, consulte [AWSServiços da que funcionam com o IAM](reference_aws-services-that-work-with-iam.md) e procure os serviços que têm **Sim **na coluna **Funções vinculadas ao serviço**. Escolha um **Sim** com um link para visualizar a documentação do perfil vinculado para esse serviço.

**Para alterar as permissões permitidas por uma função (AWS CLI)**

1. (Opcional) Para visualizar as permissões atuais associadas a uma função, execute um dos comandos a seguir:

   1. [aws iam list-role-policies](https://docs.aws.amazon.com/cli/latest/reference/iam/list-role-policies.html) para listar as políticas em linha

   1. [aws iam list-attached-role-policies](https://docs.aws.amazon.com/cli/latest/reference/iam/list-attached-role-policies.html) para listar as políticas gerenciadas

1. O comando para atualizar as permissões para a função será diferente se você estiver atualizando uma política gerenciada ou uma política em linha.

   Para atualizar uma política gerenciada, execute o seguinte comando para criar uma nova versão da política gerenciada:
   + [aws iam create-policy-version](https://docs.aws.amazon.com/cli/latest/reference/iam/create-policy-version.html)

   Para atualizar uma política em linha, execute o seguinte comando:
   + [aws iam put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)

### Atualizar uma política de permissões de um perfil (API da AWS)
<a name="id_roles_update_permissions-policy-api"></a>

Para alterar as permissões permitidas pela função, modifique a política de permissões da função (ou políticas). Você não pode modificar a política de permissões para uma *[função vinculada ao serviço](id_roles.md#iam-term-service-linked-role)* no IAM. Pode ser possível modificar a política de permissões no serviço que depende da função. Para verificar se um serviço oferece suporte a este recurso, consulte [AWSServiços da que funcionam com o IAM](reference_aws-services-that-work-with-iam.md) e procure os serviços que têm **Sim **na coluna **Funções vinculadas ao serviço**. Escolha um **Sim** com um link para visualizar a documentação do perfil vinculado para esse serviço.

**Para alterar as permissões permitidas por uma função (API da AWS)**

1. (Opcional) Para visualizar as permissões atuais associadas a uma função, chame as seguintes operações:

   1. [ListRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRolePolicies.html) para listar as políticas em linha

   1. [ListAttachedRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedRolePolicies.html) para listar as políticas gerenciadas

1. A operação para atualizar as permissões para a função será diferente se você estiver atualizando uma política gerenciada ou uma política em linha.

   Para atualizar uma política gerenciada, chame a seguinte operação para criar uma nova versão da política gerenciada:
   + [CreatePolicyVersion](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicyVersion.html)

   Para atualizar uma política em linha, chame a seguinte operação:
   + [PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html)

## Atualizar o limite de permissões para um perfil
<a name="id_roles_update-role-permissions-boundary"></a>

Para alterar o número máximo de permissões permitidas para uma função, modifique o [limite de permissões](access_policies_boundaries.md) da função.

### Atualizar o limite de permissões de um perfil (console)
<a name="id_roles_update-permissions-boundary-console"></a>

**Para alterar a política usada para definir o limite de permissões para uma função**

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação, escolha **Perfis**.

1. Escolha o nome da função com o [limite de permissões](access_policies_boundaries.md) que você deseja alterar. 

1. Escolha a aba **Permissões**. Se necessário, abra a seção **Limite de permissões** e, em seguida, escolha **Alterar limite**.

1. Selecione a política que você deseja usar para o limite de permissões.

1. Escolha **Alterar limite**.

   Suas alterações não terão efeito até que alguém assuma essa função.

### Atualizar um limite de permissões de perfil (AWS CLI)
<a name="id_roles_update_permissions-boundary-cli"></a>

**Para alterar a política gerenciada usada para definir o limite de permissões para uma função (AWS CLI)**

1. (Opcional) Para visualizar a [política de permissões](access_policies_boundaries.md) atual de uma função, execute o seguinte comando: 
   + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)

1. Para usar uma política gerenciada diferente para atualizar o limite de permissões de uma função, execute o seguinte comando: 
   + [aws iam put-role-permissions-boundary](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html)

   Uma função pode ter apenas um conjunto de políticas gerenciadas como um limite de permissões. Se você alterar o limite de permissões, você altera o número máximo de permissões permitidas para uma função.

### Atualizar um limite de permissões de perfil (API da AWS)
<a name="id_roles_update-permissions-boundary-api"></a>

**Para alterar a política gerenciada usada para definir o limite de permissões para uma função (API da AWS)**

1. (Opcional) Para visualizar o [limite de permissões](access_policies_boundaries.md) atual de uma função, chame a seguinte operação: 
   + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html)

1. Para usar uma política gerenciada diferente para atualizar o limite de permissões de uma função, chame a seguinte operação: 
   + [PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html)

   Uma função pode ter apenas um conjunto de políticas gerenciadas como um limite de permissões. Se você alterar o limite de permissões, você altera o número máximo de permissões permitidas para uma função.

# Atualizar as configurações de um perfil
<a name="id_roles_update-role-settings"></a>

Use os procedimentos a seguir para atualizar a descrição de um perfil ou alterar a duração máxima da sessão de um perfil.

## Atualizar uma descrição de perfil
<a name="id_roles_update-description"></a>

Para alterar a descrição da função, modifique o texto da descrição.

### Atualizar a descrição de um perfil (console)
<a name="id_roles_update-description-console"></a>

**Para alterar a descrição de uma função (console)**

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação do console do IAM, escolha **Perfis**.

1. Escolha o nome da função a ser modificada.

1. Na seção **Summary** (Resumo), escolha **Edit** (Editar).

1. Insira uma nova descrição na caixa e escolha **Save changes** (Salvar alterações).

### Atualizar a descrição de um perfil (AWS CLI)
<a name="id_roles_update-description-cli"></a>

**Para alterar a descrição de uma função (AWS CLI)**

1. (Opcional) Para visualizar a descrição atual de uma função, execute o comando a seguir:
   + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)

1. Para atualizar a descrição de uma função, execute o seguinte comando com o parâmetro de descrição:
   + [aws iam update-role](https://docs.aws.amazon.com/cli/latest/reference/iam/update-role.html)

### Atualizar a descrição de um perfil (API da AWS)
<a name="id_roles_update-description-api"></a>

**Para alterar a descrição de uma função (API da AWS)**

1. (Opcional) Para visualizar a descrição atual de uma função, chame a seguinte operação:
   + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) 

1. Para atualizar a descrição de uma função, chame a seguinte operação com o parâmetro de descrição:
   + [UpdateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRole.html)

## Atualizar a duração máxima da sessão de um perfil
<a name="id_roles_update-session-duration"></a>

Para especificar a configuração de duração máxima da sessão para funções que são assumidas usando o console, a AWS CLI ou a API da AWS, modifique o valor da configuração da duração máxima da sessão. Essa configuração pode ter um valor de 1 hora a 12 horas. Se você não especificar um valor, o padrão máximo de 1 hora será aplicado. Essa configuração não limita sessões assumidas por serviços da AWS.

### Atualizar a duração máxima da sessão de um perfil (console)
<a name="id_roles_update-session-duration-console"></a><a name="id_roles_modify_max-session"></a>

**Como alterar a configuração de duração máxima da sessão para funções que são assumidas usando o console, a AWS CLI ou a API da AWS (console)**

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação do console do IAM, escolha **Perfis**.

1. Escolha o nome da função a ser modificada.

1. Na seção **Summary** (Resumo), escolha **Edit** (Editar).

1. Para **Maximum session duration** (Duração máxima da sessão), escolha um valor. Ou então, escolha **Custom duration** (Duração personalizada) e insira um valor (em segundos).

1. Escolha **Salvar alterações**.

   Suas alterações não terão efeito até que alguém assuma essa função. Para saber como revogar as sessões existentes para a função, consulte [Revogar as credenciais de segurança temporárias do perfil do IAM](id_roles_use_revoke-sessions.md).

No Console de gerenciamento da AWS, as sessões de usuário do IAM são de 12 horas por padrão. Os usuários do IAM que trocam de perfis no console recebem a duração máxima da sessão da perfil ou o tempo restante na sessão do usuário, o que for menor.

Qualquer pessoa que assuma a função da AWS CLI ou da API da AWS pode solicitar uma sessão mais longa, até esse máximo. A configuração `MaxSessionDuration` determina a duração máxima da sessão da função que pode ser solicitada.
+ Para especificar a duração de uma sessão usando a AWS CLI, use o parâmetro `duration-seconds`. Para saber mais, consulte [Alterar para uma perfil do IAM (AWS CLI)](id_roles_use_switch-role-cli.md).
+ Para especificar a duração de uma sessão usando a API da AWS, use o parâmetro `DurationSeconds`. Para saber mais, consulte [Alternar para um perfil do IAM (API da AWS)](id_roles_use_switch-role-api.md). 

### Atualizar a duração máxima da sessão do perfil (AWS CLI)
<a name="id_roles_update-session-duration-cli"></a>

**nota**  
Qualquer pessoa que assuma uma função a partir da AWS CLI ou da API pode usar o parâmetro da CLI `duration-seconds` ou o parâmetro da API `DurationSeconds` para solicitar uma sessão mais longa. A configuração `MaxSessionDuration` determina a duração máxima da sessão da função que pode ser solicitada usando o parâmetro `DurationSeconds`. Se os usuários não especificarem um valor para o parâmetro `DurationSeconds`, suas credenciais de segurança serão válidas por uma hora.

**Para alterar a configuração de duração máxima da sessão para funções que são assumidas usando a AWS CLI (AWS CLI)**

1. (Opcional) Para visualizar a configuração de duração máxima da sessão atual para uma função, execute o seguinte comando:
   + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)

1. Para atualizar uma configuração de duração máxima da sessão da função, execute o seguinte comando com o parâmetro da CLI `max-session-duration` ou o parâmetro da API `MaxSessionDuration`:
   + [aws iam update-role](https://docs.aws.amazon.com/cli/latest/reference/iam/update-role.html)

   Suas alterações não terão efeito até que alguém assuma essa função. Para saber como revogar as sessões existentes para a função, consulte [Revogar as credenciais de segurança temporárias do perfil do IAM](id_roles_use_revoke-sessions.md).

### Atualizar a duração máxima da sessão do perfil (API da AWS)
<a name="id_roles_update-session-duration-api"></a>

**nota**  
Qualquer pessoa que assuma uma função a partir da AWS CLI ou da API pode usar o parâmetro da CLI `duration-seconds` ou o parâmetro da API `DurationSeconds` para solicitar uma sessão mais longa. A configuração `MaxSessionDuration` determina a duração máxima da sessão da função que pode ser solicitada usando o parâmetro `DurationSeconds`. Se os usuários não especificarem um valor para o parâmetro `DurationSeconds`, suas credenciais de segurança serão válidas por uma hora.

**Para alterar a configuração de duração máxima da sessão para funções que são assumidas usando a API (API da AWS)**

1. (Opcional) Para visualizar a configuração de duração máxima da sessão atual para uma função, chame a seguinte operação:
   + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) 

1. Para atualizar uma configuração de duração máxima da sessão da função, chame a seguinte operação com o parâmetro da CLI `max-sessionduration` ou o parâmetro da API `MaxSessionDuration`:
   + [UpdateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRole.html)

   Suas alterações não terão efeito até que alguém assuma essa função. Para saber como revogar as sessões existentes para a função, consulte [Revogar as credenciais de segurança temporárias do perfil do IAM](id_roles_use_revoke-sessions.md).

# Excluir perfis ou perfis de instância
<a name="id_roles_manage_delete"></a>

Se você não precisar mais de uma função, recomendamos excluir a função e suas permissões associadas. Dessa forma, você não terá uma entidade não utilizada que não seja ativamente monitorada ou mantida. 

Se a função foi associada a uma instância do EC2, você também poderá remover a função do perfil de instância e excluir o perfil de instância.

**Atenção**  
Certifique-se de que você não tenha nenhuma instância do Amazon EC2 em execução com a função ou o perfil da instância que você está prestes a excluir. Excluir uma função ou perfil da instância associado a uma instância em execução interromperá todas as aplicações em execução na instância.

Se você preferir não excluir uma função permanentemente, poderá desabilitá-la. Para fazer isso, altere as políticas da função e revogue todas as sessões atuais. Por exemplo, você poderia adicionar uma política à função que negasse acesso a todas da AWS. Você também poderia editar a política de confiança para negar acesso a todos que tentassem assumir a função. Para obter mais informações sobre como revogar sessões, consulte [Revogar as credenciais de segurança temporárias do perfil do IAM](id_roles_use_revoke-sessions.md).

**Topics**
+ [

## Visualizar acesso a perfis
](#roles-delete_prerequisites)
+ [

## Excluir um perfil vinculado ao serviço
](#id_roles_manage_delete_slr)
+ [

## Exclusão de uma função do IAM (console)
](#roles-managingrole-deleting-console)
+ [

## Exclusão de uma função do IAM (AWS CLI)
](#roles-managingrole-deleting-cli)
+ [

## Exclusão de uma função do IAM (API da AWS)
](#roles-managingrole-deleting-api)
+ [

## Informações relacionadas
](#roles-managingrole-deleting-related-info)

## Visualizar acesso a perfis
<a name="roles-delete_prerequisites"></a>

Antes de excluir uma função, recomendamos que você revise quando a função foi usada pela última vez. Você pode fazer isso usando o Console de gerenciamento da AWS, a AWS CLI ou a API da AWS. Você deve visualizar essas informações porque não deseja remover o acesso de alguém que usa a função. 

A data das atividades mais recentes do perfil pode não corresponder à última data informada na guia **Acessados recentemente**. A guia [**Acessados recentemente**](access_policies_last-accessed-view-data.md) só informa as atividades em serviços permitidos pelas políticas de permissões do perfil. A data da última atividade da função inclui a última tentativa de acessar qualquer produto na AWS.

**nota**  
O período de rastreamento das atividades mais recentes de um perfil e os dados de Acessados recentemente são para os últimos 400 dias. Esse período pode ser mais curto se a sua Região começou a oferecer suporte a esses recursos no último ano. A função pode ter sido usada há mais de 400 dias. Para obter mais informações sobre o período de rastreamento, consulte [Onde a AWS rastreia informações acessadas por último](access_policies_last-accessed.md#last-accessed_tracking-period).

**Como visualizar quando uma função foi usada pela última vez (console)**

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação, escolha **Perfis**.

1. Localize a linha da função com a atividade que você deseja visualizar. É possível usar o campo de pesquisa para restringir os resultados. Exiba a coluna **Last activity (Última atividade)** para visualizar o número de dias desde que a função foi usada pela última vez. Se a função não tiver sido usada dentro do período de rastreamento, a tabela exibirá **None (Nenhum)**. 

1. Escolha o nome da função para exibir mais informações. A página **Summary** (Resumo) da função também inclui a **Last activity** (Última atividade), que exibe a data em que a função foi usada pela última vez. Se a função não tiver sido usada nos últimos 400 dias, a **Last activity (Última atividade)** exibirá **Não acessada no período de rastreamento**.

**Como visualizar quando uma função foi usada pela última vez (AWS CLI)**  
`[aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)` – execute este comando para receber informações sobre uma função, incluindo o objeto `RoleLastUsed`. Este objeto contém a `LastUsedDate` e a `Region` em que a função foi usada pela última vez. Se `RoleLastUsed` estiver presente, mas não contiver um valor, a função não foi usada dentro do período de rastreamento.

**Como visualizar quando uma função foi usada pela última vez (API da AWS)**  
`[GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/GetRole.html)` – chame esta operação para retornar informações sobre uma função, incluindo o objeto `RoleLastUsed`. Este objeto contém a `LastUsedDate` e a `Region` em que a função foi usada pela última vez. Se `RoleLastUsed` estiver presente, mas não contiver um valor, a função não foi usada dentro do período de rastreamento.

## Excluir um perfil vinculado ao serviço
<a name="id_roles_manage_delete_slr"></a>

O método que você usa para excluir um perfil vinculado ao serviço depende do serviço. Em alguns casos, você não precisa excluir manualmente uma função vinculada ao serviço. Por exemplo, quando você concluir uma ação específica (como a remoção de um recurso) no serviço, o serviço pode excluir a função vinculada ao serviço para você. Em outros casos, o serviço pode oferecer suporte a exclusão de uma função vinculada ao serviço manualmente usando o console, API ou a do serviço AWS CLI. 

Revise a documentação para o *[perfil vinculado ao serviço](id_roles.md#iam-term-service-linked-role)* no serviço vinculado para saber como excluir o perfil. Você pode visualizar as funções vinculadas ao serviço na sua conta acessando a página **Roles** (Funções) do IAM no console. As funções vinculadas ao serviço aparecem com **(Função vinculada ao serviço)** na coluna **Entidades confiáveis** da tabela. Um banner na página **Summary** (Resumo) da função também indica que a função é uma função vinculada ao serviço.

Se o serviço não incluir documentação para excluir a função vinculada ao serviço, você poderá usar o console do IAM, a AWS CLI ou a API para excluir a função.

## Exclusão de uma função do IAM (console)
<a name="roles-managingrole-deleting-console"></a>

Ao usar o Console de gerenciamento da AWS para excluir um perfil, o IAM desvincula automaticamente as políticas associadas ao perfil. Também exclui automaticamente as políticas em linha associadas ao perfil e todos os perfis de instâncias do Amazon EC2 que contêm o perfil. 

**Importante**  
Em alguns casos, uma função pode ser associada a um perfil de instância do Amazon EC2, e a função e o perfil de instância podem ter o mesmo nome. Neste caso, você pode usar o Console de gerenciamento da AWS para excluir a função e o perfil da instância. Essa ligação ocorre automaticamente para funções e perfis de instância criados no console. Se você criou a função da AWS CLI, do Tools for Windows PowerShell ou da API da AWS, a função e o perfil da instância poderão ter nomes diferentes. Nesse caso, você não pode usar o console para excluí-los. Em vez disso, você deve usar a AWS CLI, o Tools for Windows PowerShell ou a API da AWS para remover primeiro a função do perfil da instância. Você deve executar uma etapa separada para excluir a função.

**Para excluir uma função (console)**

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação, escolha **Roles (Funções)** e marque a caixa de seleção ao lado do nome da função que você deseja excluir. 

1. Na parte superior da página, escolha **Delete** (Excluir).

1. Na caixa de diálogo de confirmação, revise as informações acessadas por último, que mostram quando cada uma das funções selecionadas acessou pela última vez um serviço da AWS. Isso ajuda você a confirmar se a função está ativa no momento. Se você quiser continuar, insira o nome da função no campo de entrada de texto e escolha **Delete** (Excluir). Se você tiver certeza, prossiga com a exclusão, mesmo se as informações acessadas por último ainda estiverem sendo carregadas.

**nota**  
Você não pode usar o console para excluir um perfil de instância, a menos que ele tenha o mesmo nome da função. O perfil da instância é excluído como parte do processo de exclusão de uma função, conforme descrito no procedimento anterior. Para excluir um perfil de instância sem também excluir a função, você deve usar a AWS CLI, ou a API da AWS. Para obter mais informações, consulte as seções a seguir.

## Exclusão de uma função do IAM (AWS CLI)
<a name="roles-managingrole-deleting-cli"></a>

Ao usar a AWS CLI para excluir uma função, primeiro é necessário excluir as políticas em linha associadas à função. Também é necessário separar as políticas gerenciadas associadas ao perfil. Se quiser excluir o perfil de instância associado que contém o perfil, exclua-o separadamente.

**Para excluir uma função (AWS CLI)**

1. Se você não souber o nome da função que deseja excluir, digite o seguinte comando para listar as funções em sua conta:

   ```
   aws iam list-roles
   ```

   A lista inclui o nome de recurso da Amazon (ARN) de cada função. Use o nome da função, não o nome de recurso da Amazon (ARN), para fazer referência às funções com os comandos da CLI. Por exemplo, se uma função tiver o seguinte nome de recurso da Amazon (ARN): `arn:aws:iam::123456789012:role/myrole`, você fará referência à função como **myrole**.

1. Remova o perfil de todos os perfis de instância aos quais ele está associado.

   1. Para relacionar todos os perfis de instância aos quais a função está associada, digite o seguinte comando:

      ```
      aws iam list-instance-profiles-for-role --role-name role-name
      ```

   1. Para remover a função de um perfil de instância, digite o seguinte comando para cada perfil de instância:

      ```
      aws iam remove-role-from-instance-profile --instance-profile-name instance-profile-name --role-name role-name
      ```

1. Exclua todas as políticas associadas à função.

   1. Para listar todas as políticas em linha no perfil, digite o seguinte comando:

      ```
      aws iam list-role-policies --role-name role-name
      ```

   1. Para excluir cada política em linha do perfil, digite o comando a seguir para cada política: 

      ```
      aws iam delete-role-policy --role-name role-name --policy-name policy-name
      ```

   1. Para listar todas as políticas gerenciadas que estão associadas ao perfil, digite o seguinte comando:

      ```
      aws iam list-attached-role-policies --role-name role-name
      ```

   1. Para desassociar cada política gerenciada do perfil, digite o comando a seguir para cada política: 

      ```
      aws iam detach-role-policy --role-name role-name --policy-arn policy-arn
      ```

1. Digite o comando a seguir para excluir a função:

   ```
   aws iam delete-role --role-name role-name
   ```

1. Se você não planeja reutilizar o perfis de instância que foram associados à função, digite o seguinte comando para excluí-los:

   ```
   aws iam delete-instance-profile --instance-profile-name instance-profile-name
   ```

## Exclusão de uma função do IAM (API da AWS)
<a name="roles-managingrole-deleting-api"></a>

Ao usar a API do IAM para excluir uma função, primeiro é necessário excluir as políticas associadas à função. Também é necessário separar as políticas gerenciadas associadas ao perfil. Se quiser excluir o perfil de instância associado que contém o perfil, exclua-o separadamente.

**Para excluir uma função (API da AWS)**

1. Para listar todos os perfis de instância aos quais um perfil está associado, chame [ListInstanceProfilesForRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfilesForRole.html).

   Para remover o perfil de um perfil de instância, chame [RemoveRoleFromInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_RemoveRoleFromInstanceProfile.html). É necessário transmitir o nome do perfil e nome do perfil de instância. 

   Se você não for reutilizar um perfil de instância associado à função, chame [DeleteInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteInstanceProfile.html) para excluí-lo.

1. Para listar todas as políticas em linha para um perfil, chame [ListRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRolePolicies.html).

   Para excluir políticas em linha associadas ao perfil, chame [DeleteRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteRolePolicy.html). É necessário passar o nome do perfil e o nome da política em linha. 

1. Para listar todas as políticas gerenciadas associadas a um perfil, chame [ListAttachedRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedRolePolicies.html). 

   Para desassociar políticas gerenciadas associadas ao perfil, chame [DetachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DetachRolePolicy.html). É necessário passar o nome do perfil e o ARN da política gerenciada. 

1. Chame [DeleteRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteRole.html) para excluir a função.

## Informações relacionadas
<a name="roles-managingrole-deleting-related-info"></a>

Para obter informações gerais sobre os perfis de instância, consulte [Usar perfis de instância](id_roles_use_switch-role-ec2_instance-profiles.md).

Para obter informações gerais sobre funções vinculadas ao serviço, consulte [Criar um perfil vinculado ao serviço](id_roles_create-service-linked-role.md).

# Métodos para assumir um perfil
<a name="id_roles_manage-assume"></a>

Para que um usuário, uma aplicação ou um serviço possa usar um perfil que você criou, você deverá [conceder permissões para alternar](id_roles_use_permissions-to-switch.md) para esse perfil. É possível usar qualquer política anexada a grupos ou usuários para conceder as permissões necessárias. Depois que as permissões forem concedidas, o usuário poderá assumir um perfil do Console de gerenciamento da AWS, do Tools for Windows PowerShell, da AWS Command Line Interface (AWS CLI) e da API [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html).

**Importante**  
Ao criar uma função de forma programática, em vez de no console do IAM, você tem a opção de adicionar um `Path` de até 512 caracteres além do `RoleName`, que pode ter até 64 caracteres. No entanto, se você pretende usar uma função com o recurso **Switch Role** (Alternar função) no Console de gerenciamento da AWS, o `Path` e o `RoleName` combinados não podem exceder 64 caracteres.

O método usado para assumir o perfil determina quem pode assumir a função e por quanto tempo a sessão da função pode durar. Ao usar o código `AssumeRole*` das operações da API, o perfil do IAM que você assume é o de recursos. O usuário ou perfil que chama operações da API `AssumeRole*` é a entidade principal.

A tabela a seguir compara os métodos usados para assumir perfis.


|  Método de assumir a função |  **Quem pode assumir a função**  | **Método para especificar a vida útil da credencial** |  **Vida útil da credencial (mín.\$1máx.\$1padrão)**  | 
| --- | --- | --- | --- | 
| Console de gerenciamento da AWS | Usuário ou perfis¹ (via [alternância de perfis](id_roles_use_switch-role-console.md)) | Maximum session duration (Duração máxima da sessão) na página Resumo Role (Função) | 15 min\$1Configuração de duração máxima da sessão²\$11 h | 
| Operação da CLI [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html) ou da API [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) |  Usuário ou perfil¹ | Parâmetro da CLI duration-seconds ou da API DurationSeconds | 15 min\$1Configuração de duração máxima da sessão²\$11 h  | 
| Operação da CLI [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-saml.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-saml.html) ou da API [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) | Qualquer usuário autenticado usando SAML | Parâmetro da CLI duration-seconds ou da API DurationSeconds | 15 min\$1Configuração de duração máxima da sessão²\$11 h  | 
| Operação da CLI [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-web-identity.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-web-identity.html) ou da API [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) | Qualquer usuário autenticado usando um provedor OIDC | Parâmetro da CLI duration-seconds ou da API DurationSeconds | 15 min\$1Configuração de duração máxima da sessão²\$11 h  | 
| [URL do console](id_roles_providers_enable-console-custom-url.md) construído com AssumeRole  | Usuário ou perfil | Parâmetro HTML SessionDuration no URL | 15 min\$112 h\$11 h  | 
| [URL do console](id_roles_providers_enable-console-custom-url.md) construído com AssumeRoleWithSAML  | Qualquer usuário autenticado usando SAML | Parâmetro HTML SessionDuration no URL | 15 min\$112 h\$11 h | 
| [URL do console](id_roles_providers_enable-console-custom-url.md) construído com AssumeRoleWithWebIdentity  | Qualquer usuário autenticado usando um provedor OIDC | Parâmetro HTML SessionDuration no URL | 15 min\$112 h\$11 h  | 

¹ O uso de credenciais de um perfil para assumir um perfil diferente é chamado de [encadeamento de perfis](id_roles.md#iam-term-role-chaining). Quando você usa o encadeamento de perfis, a duração da sessão do perfil é limitada a uma hora. Isso se aplica à alternância de perfis do Console de gerenciamento da AWS, à AWS CLI e às operações de API. Essa limitação não se aplica à situação em que um perfil é assumido pela primeira vez por credenciais do usuário nem a aplicações executadas em instâncias do Amazon EC2 usando perfis de instância.

² Essa configuração pode ter um valor de 1 hora a 12 horas. Para obter detalhes sobre como modificar a configuração de duração máxima da sessão, consulte [Gerenciamento de perfis do IAM](id_roles_manage.md). Essa configuração determina a duração máxima da sessão que você pode solicitar ao obter as credenciais da função. Por exemplo, quando você usa as operações da API [AssumeRole\$1](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) para assumir uma função, você pode especificar um tamanho de sessão usando o parâmetro `DurationSeconds`. Use este parâmetro para especificar o tamanho da sessão da função de 900 segundos (15 minutos) até o valor configurado da duração máxima da sessão para a função. Os usuários do IAM que trocam de perfis no console recebem a duração máxima da sessão ou o tempo restante na sessão de usuário, o que for menor. Suponha que você defina uma duração máxima de 5 horas em uma função. Um usuário do IAM conectado ao console por 10 horas (do máximo padrão de 12) alterna para a função. A duração da sessão de função disponível é de 2 horas. Para saber como visualizar o valor máximo para sua função, consulte [Atualizar a duração máxima da sessão de um perfil](id_roles_update-role-settings.md#id_roles_update-session-duration) mais adiante nesta página.

**Observações**  
A configuração da duração máxima da sessão não limita as sessões assumidas por produtos da AWS.
As credenciais do perfil do IAM do Amazon EC2 não estão sujeitas à duração máxima da sessão configurada no perfil.
Para permitir que os usuários assumam novamente o perfil atual em uma sessão de perfil, especifique o ARN do perfil ou o ARN da Conta da AWS como entidade principal na política de confiança do perfil. Os Serviços da AWS que fornecem recursos computacionais, como o Amazon EC2, Amazon ECS, Amazon EKS e Lambda, fornecem credenciais temporárias e atualizam automaticamente essas credenciais. Isso garante que você tenha sempre um conjunto de credenciais válido. Nesses serviços, não é necessário assumir novamente a função atual para obter credenciais temporárias. Porém, se pretender passar [tags de sessão](id_session-tags.md) ou uma [política de sessão](access_policies.md#policies_session), você precisará assumir novamente a função atual. Para saber como modificar uma política de confiança de função para adicionar o ARN da função de entidade principal ou o ARN da Conta da AWS, consulte [Atualizar a política de confiança de um perfil](id_roles_update-role-trust-policy.md).

**Topics**
+ [

# Mudar de um usuário para um perfil do IAM (console)
](id_roles_use_switch-role-console.md)
+ [

# Alterar para uma perfil do IAM (AWS CLI)
](id_roles_use_switch-role-cli.md)
+ [

# Alternar para um perfil do IAM (Ferramentas para Windows PowerShell)
](id_roles_use_switch-role-twp.md)
+ [

# Alternar para um perfil do IAM (API da AWS)
](id_roles_use_switch-role-api.md)
+ [

# Use um perfil do IAM para conceder permissões a aplicações em execução em instâncias do Amazon EC2
](id_roles_use_switch-role-ec2.md)
+ [

# Usar perfis de instância
](id_roles_use_switch-role-ec2_instance-profiles.md)

# Mudar de um usuário para um perfil do IAM (console)
<a name="id_roles_use_switch-role-console"></a>

Você pode alternar perfis quando fizer login como usuário do IAM, como usuário no Centro de Identidade do IAM, como perfil federado SAML ou como perfil federado de identidade da Web. Uma *função* especifica um conjunto de permissões que você pode usar para acessar os recursos da AWS de que você precisa. No entanto, você não inicia sessão em um perfil, mas, depois de entrar como usuário do IAM, poderá mudar para um perfil do IAM. Isso separa, temporariamente, as permissões originais de usuário e, em vez disso, oferece a você as permissões atribuídas à função. O perfil pode estar em sua própria conta ou em qualquer outra Conta da AWS. Para obter mais informações sobre funções, seus benefícios e como criá-los, consulte [Perfis do IAM](id_roles.md)e [Criar um perfil do IAM](id_roles_create.md).

As permissões do seu usuário e quaisquer perfis para os quais você mudar não são cumulativos. Apenas um conjunto de permissões é ativo por vez. Quando você muda para uma função, perde, temporariamente, as permissões de usuário e trabalha com permissões atribuídas à função. Ao sair da função, suas permissões de usuário são, automaticamente, restauradas.

Quando você muda de funções no Console de gerenciamento da AWS, o console sempre usa suas credenciais originais para autorizar a mudança. Por exemplo, se você alternar para RoleA, o IAM usará suas credenciais originais para determinar se você tem permissão para assumir RoleA. Se você tentar mudar para RoleB *enquanto usa RoleA*, o AWS ainda usará suas credenciais **originais** para autorizar a mudança, e não as credenciais de RoleA.

**nota**  
Ao iniciar sessão como um usuário no Centro de Identidade do IAM, seja como um perfil federado SAML ou perfil federado de identidade da Web, você assumirá um perfil do IAM ao iniciar sua sessão. Por exemplo, quando um usuário no Centro de Identidade do IAM inicia sessão no portal de acesso do AWS, ele deve escolher um conjunto de permissões que se correlacione a uma função antes de poder acessar os recursos da AWS.

## Sessões de função
<a name="id_roles_iam_user-switch-role-sessions"></a>

Ao mudar de perfis, sua sessão do Console de gerenciamento da AWS dura 1 hora por padrão. As sessões de usuário do IAM são de 12 horas por padrão. Outros usuários podem ter durações de sessão diferentes definidas. Quando você muda de perfil no console, recebe a duração máxima da sessão ou o tempo restante na sessão de usuário, o que for menor. Ao assumir um perfil, não é possível pode estender a duração da sessão.

Por exemplo, suponha que uma duração máxima de sessão de dez horas seja definida para uma função. Você estava conectado ao console por 8 horas quando decide mudar para o perfil. Há 4 horas restantes em sua sessão de usuário. Portanto, a duração permitida da sessão de perfil é 4 horas, e não a duração máxima de 10 horas da sessão. A tabela a seguir mostra como determinar a duração da sessão de um usuário do IAM ao alternar funções no console.


| O tempo restante da sessão do usuário do IAM é de… | A duração da sessão da função é de… | 
| --- | --- | 
| Menor que a duração máxima da sessão da função | O tempo restante na sessão do usuário | 
| Maior que a duração máxima da sessão da função | Valor de duração máxima da sessão | 
| Igual à duração máxima da sessão da função | Valor máximo da duração da sessão (aproximado) | 

O uso de credenciais de um perfil para assumir um perfil diferente é chamado de [encadeamento de perfis](id_roles.md#iam-term-role-chaining). Quando você usa o encadeamento de perfis, a duração da sessão é limitada a uma hora, independentemente da configuração de duração máxima da sessão definida para perfis individuais. Isso se aplica à alternância de perfis do Console de gerenciamento da AWS, à AWS CLI e às operações de API.

**nota**  
Alguns consoles de produtos da AWS podem renovar automaticamente sua sessão de função quando ela expira sem que você execute nenhuma ação. Alguns podem solicitar que você recarregue a página do navegador para autenticar novamente sua sessão.

## Considerações
<a name="id_roles_iam_user-switch-role-considerations"></a>
+ Você não poderá mudar de perfis caso se conecte como Usuário raiz da conta da AWS. 
+ Os usuários devem receber permissão para mudar de perfil por meio de políticas. Para instruções, consulte [Conceder permissões a um usuário para alternar perfis](id_roles_use_permissions-to-switch.md).
+ Não é possível mudar de perfil no Console de gerenciamento da AWS para um perfil que exija um valor [ExternalId](id_roles_common-scenarios_third-party.md#id_roles_third-party_external-id). Você só pode alternar para tal perfil chamando a API [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html), que é compatível com o parâmetro `ExternalId`.

## Para mudar para uma função
<a name="id_roles_iam_user-switch-role-console-procedure"></a>

1. Siga o procedimento de login adequado para o tipo de usuário, conforme descrito no tópico [Sign in to the Console de gerenciamento da AWS](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html) no *Início de Sessão da AWS User Guide*.

1. No Console de gerenciamento da AWS, escolha seu nome de usuário na barra de navegação no canto superior direito. Geralmente, ele é assim: ***username*@*account\$1ID\$1number\$1or\$1alias***.

1. Selecione um dos seguintes métodos para alternar perfis:
   + Selecione **Alternar perfil**.
   + Se você optou pela compatibilidade com várias sessões, escolha **Adicionar sessão** e selecione **Alternar perfil**.
**nota**  
Você pode fazer login com até cinco identidades diferentes simultaneamente em um único navegador da Web no Console de gerenciamento da AWS. Para obter detalhes, consulte [Signing in to multiple accounts](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/multisession.html) no *Guia de conceitos básicos do Console de gerenciamento da AWS*.

1. Na página **Mudar de função**, digite o número do ID da conta ou o alias da conta e o nome da função fornecida pelo administrador.
**nota**  
Se o administrador criou a função com um caminho, como `division_abc/subdivision_efg/roleToDoX`, será necessário digitar este caminho completo e o nome na caixa **Função**. Se você digitar apenas o nome da função, ou se o `Path` e o `RoleName` combinados excederem 64 caracteres, a mudança de função falhará. Este é um limite dos cookies do navegador que armazena o nome da função. Se isso acontecer, entre em contato com o administrador e peça para reduzir o tamanho do nome do caminho e da função.

1. (Opcional) É possível inserir um nome de exibição e selecionar uma cor de exibição que destacará a função na barra de navegação do console.
   + Em **Display name**, digite o texto que deseja que seja exibido na barra de navegação no lugar de seu nome de usuário quando este perfil estiver ativo. Um nome é sugerido, baseado nas informações da conta e da função, mas você poderá alterá-lo para outro com significado para você. 
   + Em **Display color**, selecione uma cor para destacar o nome de exibição.

   O nome e a cor podem ajudar a lembrá-lo quando esta função está ativa, o que muda suas permissões. Por exemplo, para uma função que oferece acesso ao ambiente de teste, você pode especificar um **Display Name** (Nome de exibição) de **Test** e selecionar verde em **Color** (Cor). Para a função que oferece acesso à produção, você pode especificar um **Display Name** (Nome de exibição) de **Production** e selecionar vermelho em **Color** (Cor).

1. Selecione **Mudar de perfil**. O nome de exibição e a cor substituem seu nome de usuário na barra de navegação e você pode começar a usar as permissões concedidas pela função.

1. Depois de concluir as tarefas que exigem o perfil do IAM, você poderá voltar para a sessão original. Isso removerá as permissões adicionais fornecidas pelo perfil e restaurará as suas permissões padrão.

   1. No console do IAM, escolha o **Display Name** (Nome de exibição) da sua função na barra de navegação no canto superior direito.

   1. Selecione **Mudar de volta**.

      Por exemplo, suponha que você tenha feito login à conta número `123456789012` usando o nome de usuário `Richard`. Depois de usar a função `admin-role`, você deseja interromper o uso da função e retornar para suas permissões originais. Para parar de usar o perfil, escolha **admin-role @ 123456789012** e, em seguida, escolha **Mudar de volta**.  
![\[Gráfico que localiza a função Mudar de volta para parar de usar um perfil do IAM e retornar ao usuário original.\]](http://docs.aws.amazon.com/pt_br/IAM/latest/UserGuide/images/role-stop-using.png)

**dica**  
As últimas funções que você usou aparecem no menu. Na próxima vez que você precisar mudar para um desses perfis, bastará escolher o perfil desejado. Você só precisará digitar as informações da conta e do perfil manualmente se o perfil não for exibido no menu.

## Recursos adicionais
<a name="id_roles_use_switch-role-console_additional_resources"></a>
+ [Conceder permissões a um usuário para alternar perfis](id_roles_use_permissions-to-switch.md)
+ [Conceda permissões a um usuário para passar um perfil para um serviço da AWS](id_roles_use_passrole.md)
+ [Criar um perfil para conceder permissões a um usuário do IAM](id_roles_create_for-user.md)
+ [Criar um perfil para delegar permissões a um serviço da AWS](id_roles_create_for-service.md)
+ [Solucionar problemas de perfis do IAM](troubleshoot_roles.md)

# Alterar para uma perfil do IAM (AWS CLI)
<a name="id_roles_use_switch-role-cli"></a>

Uma *função* especifica um conjunto de permissões que você pode usar para acessar os recursos da AWS de que você precisa. Nesse sentido, ela é semelhante a um [usuário do AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) (IAM). Ao fazer login como usuário, você obtém um conjunto específico de permissões. No entanto, você não faz login em uma função mas, depois de fazer login como usuário, poderá mudar para uma função. Isso separa, temporariamente, as permissões originais de usuário e, em vez disso, oferece a você as permissões atribuídas à função. O perfil pode estar em sua própria conta ou em qualquer outra Conta da AWS. Para obter mais informações sobre funções, seus benefícios e como criar e configurá-las, consulte [Perfis do IAM](id_roles.md) e [Criar um perfil do IAM](id_roles_create.md). Para saber mais sobre os diferentes métodos que você pode usar para assumir uma função, consulte [Métodos para assumir um perfil](id_roles_manage-assume.md).

**Importante**  
As permissões do usuário do IAM e quaisquer funções você venha a assumir não são cumulativas. Apenas um conjunto de permissões é ativo por vez. Quando você assume um perfil, perde temporariamente as permissões de usuário ou perfil anteriores e trabalha com as permissões atribuídas ao perfil. Ao sair da função, suas permissões de usuário são, automaticamente, restauradas.

Você poderá usar uma função para executar um comando da AWS CLI quando estiver conectado como um usuário do IAM. Você também pode usar um perfil para executar um comando da AWS CLI quando tiver se conectado como um [usuário autenticado externamente](id_roles_providers.md) ([SAML](id_roles_providers_saml.md) ou [OIDC](id_roles_providers_oidc.md)) que já esteja usando um perfil. Além disso, você pode usar uma função para executar um comando da AWS CLI de uma instância do Amazon EC2 anexada a uma função por meio do perfil da instância. Você não pode assumir um perfil quando está conectado como o Usuário raiz da conta da AWS.

[**Encadeamento de funções**](id_roles.md#iam-term-role-chaining): você também pode usar o encadeamento de funções, que usa permissões de uma função para acessar uma segunda função.

Por padrão, a sessão da função dura uma hora. Quando assume esta função usando as operações da CLI `assume-role*`, você pode especificar um valor para o parâmetro `duration-seconds`. Esse valor pode variar de 900 segundos (15 minutos) até o valor configurado de duração máxima da sessão para o perfil. Se você alternar perfis no console, a duração da sessão será limitada a, no máximo, uma hora. Para saber como visualizar o valor máximo para sua função, consulte [Atualizar a duração máxima da sessão de um perfil](id_roles_update-role-settings.md#id_roles_update-session-duration). 

Se você usar o encadeamento de funções, a duração da sessão será limitada a um máximo de uma hora. Se você usar o parâmetro `duration-seconds` para fornecer um valor maior do que uma hora, a operação falhará.

## Cenário de exemplo: alternar para uma função de produção
<a name="switch-role-cli-scenario-prod-env"></a>

Imagine que você seja um usuário do IAM para trabalhar no ambiente de desenvolvimento. Nesse cenário, ocasionalmente, é necessário trabalhar com o ambiente de produção na linha de comando com a [AWS CLI](https://aws.amazon.com/cli/). Você já tem uma credencial de chave de acesso disponível para você. Esse pode ser o par de chaves de acesso atribuído ao usuário do IAM padrão. Ou, se estiver conectado como uma entidade principal federada SAML ou OIDC, ele poderá ser o par de chaves de acesso para o perfil inicialmente atribuído a você. Se suas permissões atuais concederem a capacidade de assumir uma função específica do IAM, você poderá identificar essa função em um “perfil” nos arquivos de configuração da AWS CLI. Esse comando é executado com as permissões da função do IAM especificada, não a identidade original. Quando especifica esse perfil em um comando da AWS CLI, você está usando a nova função. Nesta situação, você não pode usar as permissões originais na conta de desenvolvimento ao mesmo tempo. Isso porque apenas um conjunto de permissões pode ser ativado por vez.

**nota**  
Por motivos de segurança, os administradores podem [revisar logs do AWS CloudTrail](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds) para saber quem executou uma ação na AWS. Seu administrador pode exigir que você especifique uma identidade-fonte ou um nome de sessão de função ao assumir a função. Para obter mais informações, consulte [`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity) e [`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname).

**Para alternar para uma função de produção (AWS CLI)**

1. <a name="step-configure-default"></a>Se você nunca usou a AWS CLI, é necessário, primeiro, configurar seu perfil CLI padrão. Abra um prompt de comando e configure sua instalação da AWS CLI para usar a chave de acesso de seu usuário do IAM ou de sua função federada. Para obter mais informações, consulte [Configuração da AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html#cli-quick-configuration) no *Guia do usuário da AWS Command Line Interface*.

   Execute o comando [aws configure](https://docs.aws.amazon.com/cli/latest/reference/configure/) da seguinte forma:

   ```
   aws configure
   ```

   Quando solicitado, forneça as seguintes informações:

   ```
   AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
   AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
   Default region name [None]: us-east-2
   Default output format [None]: json
   ```

1. Crie um novo perfil para a função no arquivo `.aws/config` no Unix ou Linux ou o arquivo `C:\Users\USERNAME\.aws\config` no Windows. O exemplo a seguir cria um perfil chamado `prodaccess` que muda para a função `ProductionAccessRole` na conta `123456789012`. Você obtém o ARN da função do administrador da conta que criou a função. Quando este perfil é invocado, a AWS CLI usa as credenciais do `source_profile` para solicitar credenciais para a função. Por isso, a identidade mencionada como `source_profile` deve ter `sts:AssumeRole` permissões para a função especificada no `role_arn`.

   ```
   [profile prodaccess]
       role_arn = arn:aws:iam::123456789012:role/ProductionAccessRole
       source_profile = default
   ```

1. Depois de criar o novo perfil, qualquer comando da AWS CLI que especifique o parâmetro `--profile prodaccess` será executado sob as permissões anexadas à função `ProductionAccessRole` do IAM, em vez do usuário padrão.

   ```
   aws iam list-users --profile prodaccess
   ```

   Este comando funciona se as permissões atribuídas ao `ProductionAccessRole` permitem a listagem dos usuários na conta da AWS atual.

1. Para retornar para as permissões concedidas por suas credenciais originais, execute comandos sem o parâmetro `--profile`. A AWS CLI reverte para usar as credenciais em seu perfil padrão, que você configurou em [Step 1](#step-configure-default).

Para obter mais informações, consulte [Assumir uma função](https://docs.aws.amazon.com/cli/latest/userguide/cli-roles.html) no *Guia do usuário do AWS Command Line Interface*.

## Cenário de exemplo: permitir que uma função de perfil da instância alterne para uma função em outra conta
<a name="switch-role-cli-scenario-ec2-instance"></a>

Imagine que você esteja usando duas Contas da AWS e queira permitir que uma aplicação em execução em uma instância do Amazon EC2 execute comandos da [AWS CLI](https://aws.amazon.com/cli/) nas duas contas. Vamos supor que a instância do EC2 exista na conta `111111111111`. Essa instância inclui a função de perfil da instância `abcd` que permite que a aplicação execute tarefas somente leitura do Amazon S3 no bucket `amzn-s3-demo-bucket1` dentro da mesma conta `111111111111`. No entanto, o aplicativo também deve ter permissão para assumir a função entre contas `efgh` para executar tarefas na conta `222222222222`. Para fazer isso, a função de perfil de instância do EC2 `abcd` deve ter a seguinte política de permissões:

***Política de permissões da função `abcd` da conta 111111111111***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowAccountLevelS3Actions",
            "Effect": "Allow",
            "Action": [
                "s3:GetBucketLocation",
                "s3:GetAccountPublicAccessBlock",
                "s3:ListAccessPoints",
                "s3:ListAllMyBuckets"
            ],
            "Resource": "arn:aws:s3:::*"
        },
        {
            "Sid": "AllowListAndReadS3ActionOnMyBucket",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket1/*",
                "arn:aws:s3:::amzn-s3-demo-bucket1"
            ]
        },
        {
            "Sid": "AllowIPToAssumeCrossAccountRole",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Resource": "arn:aws:iam::222222222222:role/efgh"
        }
    ]
}
```

------

Vamos supor que a função entre contas `efgh` permita tarefas somente leitura do Amazon S3 no bucket `amzn-s3-demo-bucket2` na mesma conta `222222222222`. Para fazer isso, a função entre contas `efgh` deve ter a seguinte política de permissões:

***Política de permissões da função `efgh` da conta 222222222222***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowAccountLevelS3Actions",
            "Effect": "Allow",
            "Action": [
                "s3:GetBucketLocation",
                "s3:GetAccountPublicAccessBlock",
                "s3:ListAccessPoints",
                "s3:ListAllMyBuckets"
            ],
            "Resource": "arn:aws:s3:::*"
        },
        {
            "Sid": "AllowListAndReadS3ActionOnMyBucket",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket2/*",
                "arn:aws:s3:::amzn-s3-demo-bucket2"
            ]
        }
    ]
}
```

------

A função `efgh` deve permitir que a função do perfil de instância `abcd` a assuma. Para fazer isso, a função `efgh` deve ter a seguinte política de confiança:

***Política de confiança da função `efgh` da conta 222222222222***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "efghTrustPolicy",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Principal": {"AWS": "arn:aws:iam::111111111111:role/abcd"}
        }
    ]
}
```

------

Para executar comandos da AWS CLI na conta `222222222222`, você deve atualizar o arquivo de configuração da CLI. Identifique a função `efgh` como "perfil" e a função do perfil de instância do EC2 `abcd` como a “fonte de credencial” no arquivo de configuração da AWS CLI. Os comandos da CLI são executados com as permissões da função `efgh`, e não a função `abcd` original.

**nota**  
Para fins de segurança, você pode usar o AWS CloudTrail para auditar o uso de funções na conta. Para diferenciar sessões de função quando uma função é usada por diferentes entidades de segurança nos logs do CloudTrail, use o nome da sessão da função. Quando a AWS CLI assume uma função em nome de um usuário, como descrito neste tópico, um nome de sessão da função é automaticamente criado como `AWS-CLI-session-nnnnnnnn`. O valor *nnnnnnnn* é um número inteiro que representa o tempo no formato de [horário epoch Unix](http://wikipedia.org/wiki/Unix_time) (o número de segundos desde a meia-noite de 1º de janeiro de 1970, em UTC). Para obter mais informações, consulte [Referência de eventos do CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/eventreference.html) no *Guia do usuário do AWS CloudTrail*.

**Para permitir que uma função de perfil de instância do EC2 alterne para uma função entre contas (AWS CLI)**

1. Você não precisa configurar um perfil de CLI padrão. Em vez disso, você pode carregar credenciais dos metadados de perfil da instância do EC2. Crie um novo perfil para a função no arquivo `.aws/config`. O exemplo a seguir cria um perfil `instancecrossaccount` que muda para a função `efgh` na conta `222222222222`. Quando esse perfil é invocado, a AWS CLI usa as credenciais dos metadados de perfil da instância do EC2 para solicitar credenciais para a função. Por isso, a função de perfil de instância do EC2 deve ter permissões `sts:AssumeRole` para a função especificada no `role_arn`.

   ```
   [profile instancecrossaccount]
   role_arn = arn:aws:iam::222222222222:role/efgh
   credential_source = Ec2InstanceMetadata
   ```

1. Depois de criar o novo perfil, qualquer comando da AWS CLI que especifique o parâmetro `--profile instancecrossaccount` é executado sob as permissões anexadas à função `efgh` na conta `222222222222`.

   ```
   aws s3 ls amzn-s3-demo-bucket2 --profile instancecrossaccount
   ```

   Esse comando funciona se as permissões atribuídas ao perfil `efgh` permitem a listagem dos usuários na Conta da AWS atual.

1. Para retornar para as permissões originais do perfil de instância do EC2 na conta `111111111111`, execute os comandos da CLI sem o parâmetro `--profile`.

Para obter mais informações, consulte [Assumir uma função](https://docs.aws.amazon.com/cli/latest/userguide/cli-roles.html) no *Guia do usuário do AWS Command Line Interface*.

# Alternar para um perfil do IAM (Ferramentas para Windows PowerShell)
<a name="id_roles_use_switch-role-twp"></a>

Uma *função* especifica um conjunto de permissões que você pode usar para acessar os recursos da AWS de que você precisa. Nesse sentido, ela é semelhante a um [usuário do AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) (IAM). Ao fazer login como usuário, você obtém um conjunto específico de permissões. No entanto, você não faz login em uma função, mas uma vez que fez login, pode mudar para uma função. Isso separa, temporariamente, as permissões originais de usuário e, em vez disso, oferece a você as permissões atribuídas à função. O perfil pode estar em sua própria conta ou em qualquer outra Conta da AWS. Para obter mais informações sobre funções, seus benefícios e como criar e configurá-las, consulte [Perfis do IAM](id_roles.md) e [Criar um perfil do IAM](id_roles_create.md).

**Importante**  
As permissões do seu usuário do IAM e quaisquer funções para as quais você mude não são cumulativas. Apenas um conjunto de permissões é ativo por vez. Quando você muda para uma função, perde, temporariamente, as permissões de usuário e trabalha com permissões atribuídas à função. Ao sair da função, suas permissões de usuário são, automaticamente, restauradas.

Esta seção descreve como alternar entre funções ao trabalhar na linha de comando com o AWS Tools for Windows PowerShell.

Imagine que você tenha uma conta no ambiente de desenvolvimento e, ocasionalmente, precise trabalhar com o ambiente de produção na linha de comando usando o [Tools for Windows PowerShell](https://aws.amazon.com/powershell/). Você já tem um conjunto de credenciais de chave de acesso disponível para você. Elas podem ser um par de chaves de acesso atribuído ao seu usuário padrão do IAM. Ou, se você tiver feito login como uma entidade principal federada SAML ou OIDC, elas poderão ser o par de chaves de acesso para o perfil inicialmente atribuído a você. Você pode usar essas credenciais para executar o cmdlet `Use-STSRole` que transmite o ARN de uma nova função como um parâmetro. O comando retorna credenciais de segurança temporárias para a função solicitada. Em seguida, você pode usar essas credenciais em comandos subsequentes do PowerShell com as permissões da função para acessar recursos na produção. Enquanto você usa a função, não pode usar suas permissões de usuário na conta de desenvolvimento, pois apenas um conjunto de permissões pode estar ativado por vez.

**nota**  
Por motivos de segurança, os administradores podem [revisar logs do AWS CloudTrail](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds) para saber quem executou uma ação na AWS. Seu administrador pode exigir que você especifique uma identidade-fonte ou um nome de sessão de função ao assumir a função. Para obter mais informações, consulte [`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity) e [`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname).

Todas as chaves de acesso e tokens são apenas exemplos e não podem ser usados da forma que são mostrados. Substitua pelos valores apropriados do seu ambiente real.

**Para alternar para uma função (Tools for Windows PowerShell)**

1. Abra um prompt de comando do PowerShell e configure o perfil padrão para usar a chave de acesso do usuário do IAM ou de sua função federada. Se você já tive usado o Tools for Windows PowerShell, isso provavelmente já foi feito. Será possível alternar entre perfis somente se você estiver conectado como um usuário do IAM, e não como Usuário raiz da conta da AWS.

   ```
   PS C:\> Set-AWSCredentials -AccessKey AKIAIOSFODNN7EXAMPLE -SecretKey wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY -StoreAs MyMainUserProfile
   PS C:\> Initialize-AWSDefaults -ProfileName MyMainUserProfile -Region us-east-2
   ```

   Para obter mais informações, consulte [Uso de credenciais da AWS](https://docs.aws.amazon.com/powershell/latest/userguide/specifying-your-aws-credentials.html) no *Guia do usuário do Ferramentas da AWS para PowerShell*.

1. Para recuperar credenciais para a nova função, execute o comando a seguir para alternar para a função `RoleName` na conta 123456789012. Você obtém o ARN da função do administrador da conta que criou a função. O comando exige que você também forneça um nome de sessão. Você pode escolher qualquer texto para isso. O comando a seguir solicita as credenciais e, em seguida, captura o objeto de propriedade `Credentials` do objeto de resultados retornados e o armazena na variável `$Creds`.

   ```
   PS C:\> $Creds = (Use-STSRole -RoleArn "arn:aws:iam::123456789012:role/RoleName" -RoleSessionName "MyRoleSessionName").Credentials
   ```

   `$Creds` é um objeto que agora contém os elementos `AccessKeyId`, `SecretAccessKey` e `SessionToken` de que você precisa nas etapas a seguir. Os seguintes comandos de exemplo ilustram valores comuns:

   ```
   PS C:\> $Creds.AccessKeyId
   AKIAIOSFODNN7EXAMPLE
   
   PS C:\> $Creds.SecretAccessKey
   wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
   
   PS C:\> $Creds.SessionToken
   AQoDYXdzEGcaEXAMPLE2gsYULo+Im5ZEXAMPLEeYjs1M2FUIgIJx9tQqNMBEXAMPLECvSRyh0FW7jEXAMPLEW+vE/7s1HRp
   XviG7b+qYf4nD00EXAMPLEmj4wxS04L/uZEXAMPLECihzFB5lTYLto9dyBgSDyEXAMPLE9/g7QRUhZp4bqbEXAMPLENwGPy
   Oj59pFA4lNKCIkVgkREXAMPLEjlzxQ7y52gekeVEXAMPLEDiB9ST3UuysgsKdEXAMPLE1TVastU1A0SKFEXAMPLEiywCC/C
   s8EXAMPLEpZgOs+6hz4AP4KEXAMPLERbASP+4eZScEXAMPLEsnf87eNhyDHq6ikBQ==
   
   PS C:\> $Creds.Expiration
   Thursday, June 18, 2018 2:28:31 PM
   ```

1. Para usar essas credenciais para qualquer comando subsequente, inclua-as com o parâmetro `-Credential`. Por exemplo, o comando a seguir usa as credenciais da função e só funcionará se for concedida a permissão `iam:ListRoles` à função e o cmdlet `Get-IAMRoles` puder ser executado:

   ```
           PS C:\> get-iamroles -Credential $Creds
   ```

1. Para retornar para as suas credenciais originais, basta parar de usar o parâmetro `-Credentials $Creds` e permitir que o PowerShell reverta para as credenciais que estão armazenadas no perfil padrão.

# Alternar para um perfil do IAM (API da AWS)
<a name="id_roles_use_switch-role-api"></a>

Uma *função* especifica um conjunto de permissões que você pode usar para acessar os recursos da AWS. Nesse sentido, ela é semelhante a um [usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html). Um principal (pessoa ou aplicativo) assume uma função para receber permissões temporárias para executar as tarefas necessárias e interagir com recursos do AWS. O perfil pode estar em sua própria conta ou em qualquer outra Conta da AWS. Para obter mais informações sobre funções, seus benefícios e como criar e configurá-las, consulte [Perfis do IAM](id_roles.md) e [Criar um perfil do IAM](id_roles_create.md). Para saber mais sobre os diferentes métodos que você pode usar para assumir uma função, consulte [Métodos para assumir um perfil](id_roles_manage-assume.md).

**Importante**  
As permissões do usuário do IAM e quaisquer funções você venha a assumir não são cumulativas. Apenas um conjunto de permissões é ativo por vez. Quando você assume um perfil, perde temporariamente as permissões de usuário ou perfil anteriores e trabalha com as permissões atribuídas ao perfil. Ao sair da função, suas permissões originais serão, automaticamente, restauradas.

Para assumir uma função, um aplicativo chama a operação de API AWS STS[`AssumeRole` do ](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) e transmite o ARN da função a ser usada. A operação cria uma nova sessão com credenciais temporárias. Esta sessão tem as mesmas permissões que as políticas baseadas em identidade para essa função. 

Quando você chamar [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html), poderá transmitir as políticas de [políticas de sessão](access_policies.md#policies_session) gerenciadas ou em linha. As políticas de sessão são políticas avançadas que você transmite como um parâmetro quando cria de forma programática uma sessão de credencial temporária para um perfil ou sessão de usuário federado. É possível passar um único documento de política JSON de sessão em linha usando o parâmetro `Policy`. É possível usar o parâmetro `PolicyArns` para especificar até 10 políticas de sessão gerenciadas. As permissões da sessão resultam da interseção das políticas baseadas em identidade da entidade e das políticas de sessão. As políticas de sessão são úteis quando você precisa fornecer as credenciais temporárias da função para outra pessoa. A outra pessoa pode usar as credenciais temporárias da função em chamadas subsequentes à API da AWS para acessar recursos na conta que possui a função. Você não pode usar políticas de sessão para conceder mais permissões do que as permitidas pela política baseada em identidade. Para saber mais sobre como a AWS determina as permissões efetivas de uma função, consulte [Lógica da avaliação de política](reference_policies_evaluation-logic.md). 

![\[PermissionsWhenPassingRoles_Diagram\]](http://docs.aws.amazon.com/pt_br/IAM/latest/UserGuide/images/role_passed_policy_permissions.png)


Você pode chamar `AssumeRole` quando estiver conectado como um usuário do IAM ou como um [usuário autenticado externamente](id_roles_providers.md) ([SAML](id_roles_providers_saml.md) ou [OIDC](id_roles_providers_oidc.md)) que já esteja usando um perfil. Você também pode usar o [*encadeamento de funções*](id_roles.md#iam-term-role-chaining), que é o uso de uma função para assumir uma segunda função. Você não pode assumir um perfil quando está conectado como o Usuário raiz da conta da AWS.

Por padrão, a sessão do perfil dura uma hora. Quando assume esta função usando as operações de API AWS STS[`AssumeRole*` do ](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html), você pode especificar uma valor para o parâmetro `DurationSeconds`. Esse valor pode variar de 900 segundos (15 minutos) até o valor configurado de duração máxima da sessão para o perfil. Para saber como visualizar o valor máximo para sua função, consulte [Atualizar a duração máxima da sessão de um perfil](id_roles_update-role-settings.md#id_roles_update-session-duration). 

Se você usar o encadeamento de funções, a sessão será limitada a uma duração máxima de uma hora. Se você usar o parâmetro `DurationSeconds` para fornecer um valor maior do que uma hora, a operação falhará.

**nota**  
Por motivos de segurança, os administradores podem [revisar logs do AWS CloudTrail](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds) para saber quem executou uma ação na AWS. Seu administrador pode exigir que você especifique uma identidade-fonte ou um nome de sessão de função ao assumir a função. Para obter mais informações, consulte [`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity) e [`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname).

Os exemplos de código a seguir mostram como criar um usuário e assumir um perfil.

**Atenção**  
Para evitar riscos de segurança, não use usuários do IAM para autenticação ao desenvolver software com propósito específico ou trabalhar com dados reais. Em vez disso, use federação com um provedor de identidade, como [Centro de Identidade do AWS IAM](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html).
+ Crie um usuário sem permissões.
+ Crie uma função que conceda permissão para listar os buckets do Amazon S3 para a conta.
+ Adicione uma política para permitir que o usuário assuma a função.
+ Assuma o perfil e liste buckets do S3 usando credenciais temporárias, depois limpe os recursos.

------
#### [ .NET ]

**SDK para .NET**  
 Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/IAM#code-examples). 

```
global using Amazon.IdentityManagement;
global using Amazon.S3;
global using Amazon.SecurityToken;
global using IAMActions;
global using IamScenariosCommon;
global using Microsoft.Extensions.DependencyInjection;
global using Microsoft.Extensions.Hosting;
global using Microsoft.Extensions.Logging;
global using Microsoft.Extensions.Logging.Console;
global using Microsoft.Extensions.Logging.Debug;


namespace IAMActions;

public class IAMWrapper
{
    private readonly IAmazonIdentityManagementService _IAMService;

    /// <summary>
    /// Constructor for the IAMWrapper class.
    /// </summary>
    /// <param name="IAMService">An IAM client object.</param>
    public IAMWrapper(IAmazonIdentityManagementService IAMService)
    {
        _IAMService = IAMService;
    }

    /// <summary>
    /// Attach an IAM policy to a role.
    /// </summary>
    /// <param name="policyArn">The policy to attach.</param>
    /// <param name="roleName">The role that the policy will be attached to.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> AttachRolePolicyAsync(string policyArn, string roleName)
    {
        var response = await _IAMService.AttachRolePolicyAsync(new AttachRolePolicyRequest
        {
            PolicyArn = policyArn,
            RoleName = roleName,
        });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Create an IAM access key for a user.
    /// </summary>
    /// <param name="userName">The username for which to create the IAM access
    /// key.</param>
    /// <returns>The AccessKey.</returns>
    public async Task<AccessKey> CreateAccessKeyAsync(string userName)
    {
        var response = await _IAMService.CreateAccessKeyAsync(new CreateAccessKeyRequest
        {
            UserName = userName,
        });

        return response.AccessKey;

    }


    /// <summary>
    /// Create an IAM policy.
    /// </summary>
    /// <param name="policyName">The name to give the new IAM policy.</param>
    /// <param name="policyDocument">The policy document for the new policy.</param>
    /// <returns>The new IAM policy object.</returns>
    public async Task<ManagedPolicy> CreatePolicyAsync(string policyName, string policyDocument)
    {
        var response = await _IAMService.CreatePolicyAsync(new CreatePolicyRequest
        {
            PolicyDocument = policyDocument,
            PolicyName = policyName,
        });

        return response.Policy;
    }


    /// <summary>
    /// Create a new IAM role.
    /// </summary>
    /// <param name="roleName">The name of the IAM role.</param>
    /// <param name="rolePolicyDocument">The name of the IAM policy document
    /// for the new role.</param>
    /// <returns>The Amazon Resource Name (ARN) of the role.</returns>
    public async Task<string> CreateRoleAsync(string roleName, string rolePolicyDocument)
    {
        var request = new CreateRoleRequest
        {
            RoleName = roleName,
            AssumeRolePolicyDocument = rolePolicyDocument,
        };

        var response = await _IAMService.CreateRoleAsync(request);
        return response.Role.Arn;
    }


    /// <summary>
    /// Create an IAM service-linked role.
    /// </summary>
    /// <param name="serviceName">The name of the AWS Service.</param>
    /// <param name="description">A description of the IAM service-linked role.</param>
    /// <returns>The IAM role that was created.</returns>
    public async Task<Role> CreateServiceLinkedRoleAsync(string serviceName, string description)
    {
        var request = new CreateServiceLinkedRoleRequest
        {
            AWSServiceName = serviceName,
            Description = description
        };

        var response = await _IAMService.CreateServiceLinkedRoleAsync(request);
        return response.Role;
    }


    /// <summary>
    /// Create an IAM user.
    /// </summary>
    /// <param name="userName">The username for the new IAM user.</param>
    /// <returns>The IAM user that was created.</returns>
    public async Task<User> CreateUserAsync(string userName)
    {
        var response = await _IAMService.CreateUserAsync(new CreateUserRequest { UserName = userName });
        return response.User;
    }


    /// <summary>
    /// Delete an IAM user's access key.
    /// </summary>
    /// <param name="accessKeyId">The Id for the IAM access key.</param>
    /// <param name="userName">The username of the user that owns the IAM
    /// access key.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteAccessKeyAsync(string accessKeyId, string userName)
    {
        var response = await _IAMService.DeleteAccessKeyAsync(new DeleteAccessKeyRequest
        {
            AccessKeyId = accessKeyId,
            UserName = userName,
        });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM policy.
    /// </summary>
    /// <param name="policyArn">The Amazon Resource Name (ARN) of the policy to
    /// delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeletePolicyAsync(string policyArn)
    {
        var response = await _IAMService.DeletePolicyAsync(new DeletePolicyRequest { PolicyArn = policyArn });
        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM role.
    /// </summary>
    /// <param name="roleName">The name of the IAM role to delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteRoleAsync(string roleName)
    {
        var response = await _IAMService.DeleteRoleAsync(new DeleteRoleRequest { RoleName = roleName });
        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM role policy.
    /// </summary>
    /// <param name="roleName">The name of the IAM role.</param>
    /// <param name="policyName">The name of the IAM role policy to delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteRolePolicyAsync(string roleName, string policyName)
    {
        var response = await _IAMService.DeleteRolePolicyAsync(new DeleteRolePolicyRequest
        {
            PolicyName = policyName,
            RoleName = roleName,
        });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM user.
    /// </summary>
    /// <param name="userName">The username of the IAM user to delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteUserAsync(string userName)
    {
        var response = await _IAMService.DeleteUserAsync(new DeleteUserRequest { UserName = userName });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM user policy.
    /// </summary>
    /// <param name="policyName">The name of the IAM policy to delete.</param>
    /// <param name="userName">The username of the IAM user.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteUserPolicyAsync(string policyName, string userName)
    {
        var response = await _IAMService.DeleteUserPolicyAsync(new DeleteUserPolicyRequest { PolicyName = policyName, UserName = userName });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Detach an IAM policy from an IAM role.
    /// </summary>
    /// <param name="policyArn">The Amazon Resource Name (ARN) of the IAM policy.</param>
    /// <param name="roleName">The name of the IAM role.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DetachRolePolicyAsync(string policyArn, string roleName)
    {
        var response = await _IAMService.DetachRolePolicyAsync(new DetachRolePolicyRequest
        {
            PolicyArn = policyArn,
            RoleName = roleName,
        });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Gets the IAM password policy for an AWS account.
    /// </summary>
    /// <returns>The PasswordPolicy for the AWS account.</returns>
    public async Task<PasswordPolicy> GetAccountPasswordPolicyAsync()
    {
        var response = await _IAMService.GetAccountPasswordPolicyAsync(new GetAccountPasswordPolicyRequest());
        return response.PasswordPolicy;
    }


    /// <summary>
    /// Get information about an IAM policy.
    /// </summary>
    /// <param name="policyArn">The IAM policy to retrieve information for.</param>
    /// <returns>The IAM policy.</returns>
    public async Task<ManagedPolicy> GetPolicyAsync(string policyArn)
    {

        var response = await _IAMService.GetPolicyAsync(new GetPolicyRequest { PolicyArn = policyArn });
        return response.Policy;
    }


    /// <summary>
    /// Get information about an IAM role.
    /// </summary>
    /// <param name="roleName">The name of the IAM role to retrieve information
    /// for.</param>
    /// <returns>The IAM role that was retrieved.</returns>
    public async Task<Role> GetRoleAsync(string roleName)
    {
        var response = await _IAMService.GetRoleAsync(new GetRoleRequest
        {
            RoleName = roleName,
        });

        return response.Role;
    }


    /// <summary>
    /// Get information about an IAM user.
    /// </summary>
    /// <param name="userName">The username of the user.</param>
    /// <returns>An IAM user object.</returns>
    public async Task<User> GetUserAsync(string userName)
    {
        var response = await _IAMService.GetUserAsync(new GetUserRequest { UserName = userName });
        return response.User;
    }


    /// <summary>
    /// List the IAM role policies that are attached to an IAM role.
    /// </summary>
    /// <param name="roleName">The IAM role to list IAM policies for.</param>
    /// <returns>A list of the IAM policies attached to the IAM role.</returns>
    public async Task<List<AttachedPolicyType>> ListAttachedRolePoliciesAsync(string roleName)
    {
        var attachedPolicies = new List<AttachedPolicyType>();
        var attachedRolePoliciesPaginator = _IAMService.Paginators.ListAttachedRolePolicies(new ListAttachedRolePoliciesRequest { RoleName = roleName });

        await foreach (var response in attachedRolePoliciesPaginator.Responses)
        {
            attachedPolicies.AddRange(response.AttachedPolicies);
        }

        return attachedPolicies;
    }


    /// <summary>
    /// List IAM groups.
    /// </summary>
    /// <returns>A list of IAM groups.</returns>
    public async Task<List<Group>> ListGroupsAsync()
    {
        var groupsPaginator = _IAMService.Paginators.ListGroups(new ListGroupsRequest());
        var groups = new List<Group>();

        await foreach (var response in groupsPaginator.Responses)
        {
            groups.AddRange(response.Groups);
        }

        return groups;
    }


    /// <summary>
    /// List IAM policies.
    /// </summary>
    /// <returns>A list of the IAM policies.</returns>
    public async Task<List<ManagedPolicy>> ListPoliciesAsync()
    {
        var listPoliciesPaginator = _IAMService.Paginators.ListPolicies(new ListPoliciesRequest());
        var policies = new List<ManagedPolicy>();

        await foreach (var response in listPoliciesPaginator.Responses)
        {
            policies.AddRange(response.Policies);
        }

        return policies;
    }


    /// <summary>
    /// List IAM role policies.
    /// </summary>
    /// <param name="roleName">The IAM role for which to list IAM policies.</param>
    /// <returns>A list of IAM policy names.</returns>
    public async Task<List<string>> ListRolePoliciesAsync(string roleName)
    {
        var listRolePoliciesPaginator = _IAMService.Paginators.ListRolePolicies(new ListRolePoliciesRequest { RoleName = roleName });
        var policyNames = new List<string>();

        await foreach (var response in listRolePoliciesPaginator.Responses)
        {
            policyNames.AddRange(response.PolicyNames);
        }

        return policyNames;
    }


    /// <summary>
    /// List IAM roles.
    /// </summary>
    /// <returns>A list of IAM roles.</returns>
    public async Task<List<Role>> ListRolesAsync()
    {
        var listRolesPaginator = _IAMService.Paginators.ListRoles(new ListRolesRequest());
        var roles = new List<Role>();

        await foreach (var response in listRolesPaginator.Responses)
        {
            roles.AddRange(response.Roles);
        }

        return roles;
    }


    /// <summary>
    /// List SAML authentication providers.
    /// </summary>
    /// <returns>A list of SAML providers.</returns>
    public async Task<List<SAMLProviderListEntry>> ListSAMLProvidersAsync()
    {
        var response = await _IAMService.ListSAMLProvidersAsync(new ListSAMLProvidersRequest());
        return response.SAMLProviderList;
    }


    /// <summary>
    /// List IAM users.
    /// </summary>
    /// <returns>A list of IAM users.</returns>
    public async Task<List<User>> ListUsersAsync()
    {
        var listUsersPaginator = _IAMService.Paginators.ListUsers(new ListUsersRequest());
        var users = new List<User>();

        await foreach (var response in listUsersPaginator.Responses)
        {
            users.AddRange(response.Users);
        }

        return users;
    }


    /// <summary>
    /// Update the inline policy document embedded in a role.
    /// </summary>
    /// <param name="policyName">The name of the policy to embed.</param>
    /// <param name="roleName">The name of the role to update.</param>
    /// <param name="policyDocument">The policy document that defines the role.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> PutRolePolicyAsync(string policyName, string roleName, string policyDocument)
    {
        var request = new PutRolePolicyRequest
        {
            PolicyName = policyName,
            RoleName = roleName,
            PolicyDocument = policyDocument
        };

        var response = await _IAMService.PutRolePolicyAsync(request);
        return response.HttpStatusCode == HttpStatusCode.OK;
    }


    /// <summary>
    /// Add or update an inline policy document that is embedded in an IAM user.
    /// </summary>
    /// <param name="userName">The name of the IAM user.</param>
    /// <param name="policyName">The name of the IAM policy.</param>
    /// <param name="policyDocument">The policy document defining the IAM policy.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> PutUserPolicyAsync(string userName, string policyName, string policyDocument)
    {
        var request = new PutUserPolicyRequest
        {
            UserName = userName,
            PolicyName = policyName,
            PolicyDocument = policyDocument
        };

        var response = await _IAMService.PutUserPolicyAsync(request);
        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }

    /// <summary>
    /// Wait for a new access key to be ready to use.
    /// </summary>
    /// <param name="accessKeyId">The Id of the access key.</param>
    /// <returns>A boolean value indicating the success of the action.</returns>
    public async Task<bool> WaitUntilAccessKeyIsReady(string accessKeyId)
    {
        var keyReady = false;

        do
        {
            try
            {
                var response = await _IAMService.GetAccessKeyLastUsedAsync(
                    new GetAccessKeyLastUsedRequest { AccessKeyId = accessKeyId });
                if (response.UserName is not null)
                {
                    keyReady = true;
                }
            }
            catch (NoSuchEntityException)
            {
                keyReady = false;
            }
        } while (!keyReady);

        return keyReady;
    }
}



using Microsoft.Extensions.Configuration;

namespace IAMBasics;

public class IAMBasics
{
    private static ILogger logger = null!;

    static async Task Main(string[] args)
    {
        // Set up dependency injection for the AWS service.
        using var host = Host.CreateDefaultBuilder(args)
            .ConfigureLogging(logging =>
                logging.AddFilter("System", LogLevel.Debug)
                    .AddFilter<DebugLoggerProvider>("Microsoft", LogLevel.Information)
                    .AddFilter<ConsoleLoggerProvider>("Microsoft", LogLevel.Trace))
            .ConfigureServices((_, services) =>
            services.AddAWSService<IAmazonIdentityManagementService>()
            .AddTransient<IAMWrapper>()
            .AddTransient<UIWrapper>()
            )
            .Build();

        logger = LoggerFactory.Create(builder => { builder.AddConsole(); })
            .CreateLogger<IAMBasics>();


        IConfiguration configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("settings.json") // Load test settings from .json file.
            .AddJsonFile("settings.local.json",
                true) // Optionally load local settings.
            .Build();

        // Values needed for user, role, and policies.
        string userName = configuration["UserName"]!;
        string s3PolicyName = configuration["S3PolicyName"]!;
        string roleName = configuration["RoleName"]!;


        var iamWrapper = host.Services.GetRequiredService<IAMWrapper>();
        var uiWrapper = host.Services.GetRequiredService<UIWrapper>();

        uiWrapper.DisplayBasicsOverview();
        uiWrapper.PressEnter();

        // First create a user. By default, the new user has
        // no permissions.
        uiWrapper.DisplayTitle("Create User");
        Console.WriteLine($"Creating a new user with user name: {userName}.");
        var user = await iamWrapper.CreateUserAsync(userName);
        var userArn = user.Arn;

        Console.WriteLine($"Successfully created user: {userName} with ARN: {userArn}.");
        uiWrapper.WaitABit(15, "Now let's wait for the user to be ready for use.");

        // Define a role policy document that allows the new user
        // to assume the role.
        string assumeRolePolicyDocument = "{" +
          "\"Version\": \"2012-10-17\"," +
          "\"Statement\": [{" +
              "\"Effect\": \"Allow\"," +
              "\"Principal\": {" +
              $"	\"AWS\": \"{userArn}\"" +
              "}," +
              "\"Action\": \"sts:AssumeRole\"" +
          "}]" +
        "}";

        // Permissions to list all buckets.
        string policyDocument = "{" +
            "\"Version\": \"2012-10-17\"," +
            "	\"Statement\" : [{" +
                "	\"Action\" : [\"s3:ListAllMyBuckets\"]," +
                "	\"Effect\" : \"Allow\"," +
                "	\"Resource\" : \"*\"" +
            "}]" +
        "}";

        // Create an AccessKey for the user.
        uiWrapper.DisplayTitle("Create access key");
        Console.WriteLine("Now let's create an access key for the new user.");
        var accessKey = await iamWrapper.CreateAccessKeyAsync(userName);

        var accessKeyId = accessKey.AccessKeyId;
        var secretAccessKey = accessKey.SecretAccessKey;

        Console.WriteLine($"We have created the access key with Access key id: {accessKeyId}.");

        Console.WriteLine("Now let's wait until the IAM access key is ready to use.");
        var keyReady = await iamWrapper.WaitUntilAccessKeyIsReady(accessKeyId);

        // Now try listing the Amazon Simple Storage Service (Amazon S3)
        // buckets. This should fail at this point because the user doesn't
        // have permissions to perform this task.
        uiWrapper.DisplayTitle("Try to display Amazon S3 buckets");
        Console.WriteLine("Now let's try to display a list of the user's Amazon S3 buckets.");
        var s3Client1 = new AmazonS3Client(accessKeyId, secretAccessKey);
        var stsClient1 = new AmazonSecurityTokenServiceClient(accessKeyId, secretAccessKey);

        var s3Wrapper = new S3Wrapper(s3Client1, stsClient1);
        var buckets = await s3Wrapper.ListMyBucketsAsync();

        Console.WriteLine(buckets is null
            ? "As expected, the call to list the buckets has returned a null list."
            : "Something went wrong. This shouldn't have worked.");

        uiWrapper.PressEnter();

        uiWrapper.DisplayTitle("Create IAM role");
        Console.WriteLine($"Creating the role: {roleName}");

        // Creating an IAM role to allow listing the S3 buckets. A role name
        // is not case sensitive and must be unique to the account for which it
        // is created.
        var roleArn = await iamWrapper.CreateRoleAsync(roleName, assumeRolePolicyDocument);

        uiWrapper.PressEnter();

        // Create a policy with permissions to list S3 buckets.
        uiWrapper.DisplayTitle("Create IAM policy");
        Console.WriteLine($"Creating the policy: {s3PolicyName}");
        Console.WriteLine("with permissions to list the Amazon S3 buckets for the account.");
        var policy = await iamWrapper.CreatePolicyAsync(s3PolicyName, policyDocument);

        // Wait 15 seconds for the IAM policy to be available.
        uiWrapper.WaitABit(15, "Waiting for the policy to be available.");

        // Attach the policy to the role you created earlier.
        uiWrapper.DisplayTitle("Attach new IAM policy");
        Console.WriteLine("Now let's attach the policy to the role.");
        await iamWrapper.AttachRolePolicyAsync(policy.Arn, roleName);

        // Wait 15 seconds for the role to be updated.
        Console.WriteLine();
        uiWrapper.WaitABit(15, "Waiting for the policy to be attached.");

        // Use the AWS Security Token Service (AWS STS) to have the user
        // assume the role we created.
        var stsClient2 = new AmazonSecurityTokenServiceClient(accessKeyId, secretAccessKey);

        // Wait for the new credentials to become valid.
        uiWrapper.WaitABit(10, "Waiting for the credentials to be valid.");

        var assumedRoleCredentials = await s3Wrapper.AssumeS3RoleAsync("temporary-session", roleArn);

        // Try again to list the buckets using the client created with
        // the new user's credentials. This time, it should work.
        var s3Client2 = new AmazonS3Client(assumedRoleCredentials);

        s3Wrapper.UpdateClients(s3Client2, stsClient2);

        buckets = await s3Wrapper.ListMyBucketsAsync();

        uiWrapper.DisplayTitle("List Amazon S3 buckets");
        Console.WriteLine("This time we should have buckets to list.");
        if (buckets is not null)
        {
            buckets.ForEach(bucket =>
            {
                Console.WriteLine($"{bucket.BucketName} created: {bucket.CreationDate}");
            });
        }

        uiWrapper.PressEnter();

        // Now clean up all the resources used in the example.
        uiWrapper.DisplayTitle("Clean up resources");
        Console.WriteLine("Thank you for watching. The IAM Basics demo is complete.");
        Console.WriteLine("Please wait while we clean up the resources we created.");

        await iamWrapper.DetachRolePolicyAsync(policy.Arn, roleName);

        await iamWrapper.DeletePolicyAsync(policy.Arn);

        await iamWrapper.DeleteRoleAsync(roleName);

        await iamWrapper.DeleteAccessKeyAsync(accessKeyId, userName);

        await iamWrapper.DeleteUserAsync(userName);

        uiWrapper.PressEnter();

        Console.WriteLine("All done cleaning up our resources. Thank you for your patience.");
    }
}


namespace IamScenariosCommon;

using System.Net;

/// <summary>
/// A class to perform Amazon Simple Storage Service (Amazon S3) actions for
/// the IAM Basics scenario.
/// </summary>
public class S3Wrapper
{
    private IAmazonS3 _s3Service;
    private IAmazonSecurityTokenService _stsService;

    /// <summary>
    /// Constructor for the S3Wrapper class.
    /// </summary>
    /// <param name="s3Service">An Amazon S3 client object.</param>
    /// <param name="stsService">An AWS Security Token Service (AWS STS)
    /// client object.</param>
    public S3Wrapper(IAmazonS3 s3Service, IAmazonSecurityTokenService stsService)
    {
        _s3Service = s3Service;
        _stsService = stsService;
    }

    /// <summary>
    /// Assumes an AWS Identity and Access Management (IAM) role that allows
    /// Amazon S3 access for the current session.
    /// </summary>
    /// <param name="roleSession">A string representing the current session.</param>
    /// <param name="roleToAssume">The name of the IAM role to assume.</param>
    /// <returns>Credentials for the newly assumed IAM role.</returns>
    public async Task<Credentials> AssumeS3RoleAsync(string roleSession, string roleToAssume)
    {
        // Create the request to use with the AssumeRoleAsync call.
        var request = new AssumeRoleRequest()
        {
            RoleSessionName = roleSession,
            RoleArn = roleToAssume,
        };

        var response = await _stsService.AssumeRoleAsync(request);

        return response.Credentials;
    }


    /// <summary>
    /// Delete an S3 bucket.
    /// </summary>
    /// <param name="bucketName">Name of the S3 bucket to delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteBucketAsync(string bucketName)
    {
        var result = await _s3Service.DeleteBucketAsync(new DeleteBucketRequest { BucketName = bucketName });
        return result.HttpStatusCode == HttpStatusCode.OK;
    }

    /// <summary>
    /// List the buckets that are owned by the user's account.
    /// </summary>
    /// <returns>Async Task.</returns>
    public async Task<List<S3Bucket>?> ListMyBucketsAsync()
    {
        try
        {
            // Get the list of buckets accessible by the new user.
            var response = await _s3Service.ListBucketsAsync();

            return response.Buckets;
        }
        catch (AmazonS3Exception ex)
        {
            // Something else went wrong. Display the error message.
            Console.WriteLine($"Error: {ex.Message}");
            return null;
        }
    }

    /// <summary>
    /// Create a new S3 bucket.
    /// </summary>
    /// <param name="bucketName">The name for the new bucket.</param>
    /// <returns>A Boolean value indicating whether the action completed
    /// successfully.</returns>
    public async Task<bool> PutBucketAsync(string bucketName)
    {
        var response = await _s3Service.PutBucketAsync(new PutBucketRequest { BucketName = bucketName });
        return response.HttpStatusCode == HttpStatusCode.OK;
    }

    /// <summary>
    /// Update the client objects with new client objects. This is available
    /// because the scenario uses the methods of this class without and then
    /// with the proper permissions to list S3 buckets.
    /// </summary>
    /// <param name="s3Service">The Amazon S3 client object.</param>
    /// <param name="stsService">The AWS STS client object.</param>
    public void UpdateClients(IAmazonS3 s3Service, IAmazonSecurityTokenService stsService)
    {
        _s3Service = s3Service;
        _stsService = stsService;
    }
}


namespace IamScenariosCommon;

public class UIWrapper
{
    public readonly string SepBar = new('-', Console.WindowWidth);

    /// <summary>
    /// Show information about the IAM Groups scenario.
    /// </summary>
    public void DisplayGroupsOverview()
    {
        Console.Clear();

        DisplayTitle("Welcome to the IAM Groups Demo");
        Console.WriteLine("This example application does the following:");
        Console.WriteLine("\t1. Creates an Amazon Identity and Access Management (IAM) group.");
        Console.WriteLine("\t2. Adds an IAM policy to the IAM group giving it full access to Amazon S3.");
        Console.WriteLine("\t3. Creates a new IAM user.");
        Console.WriteLine("\t4. Creates an IAM access key for the user.");
        Console.WriteLine("\t5. Adds the user to the IAM group.");
        Console.WriteLine("\t6. Lists the buckets on the account.");
        Console.WriteLine("\t7. Proves that the user has full Amazon S3 access by creating a bucket.");
        Console.WriteLine("\t8. List the buckets again to show the new bucket.");
        Console.WriteLine("\t9. Cleans up all the resources created.");
    }

    /// <summary>
    /// Show information about the IAM Basics scenario.
    /// </summary>
    public void DisplayBasicsOverview()
    {
        Console.Clear();

        DisplayTitle("Welcome to IAM Basics");
        Console.WriteLine("This example application does the following:");
        Console.WriteLine("\t1. Creates a user with no permissions.");
        Console.WriteLine("\t2. Creates a role and policy that grant s3:ListAllMyBuckets permission.");
        Console.WriteLine("\t3. Grants the user permission to assume the role.");
        Console.WriteLine("\t4. Creates an S3 client object as the user and tries to list buckets (this will fail).");
        Console.WriteLine("\t5. Gets temporary credentials by assuming the role.");
        Console.WriteLine("\t6. Creates a new S3 client object with the temporary credentials and lists the buckets (this will succeed).");
        Console.WriteLine("\t7. Deletes all the resources.");
    }

    /// <summary>
    /// Display a message and wait until the user presses enter.
    /// </summary>
    public void PressEnter()
    {
        Console.Write("\nPress <Enter> to continue. ");
        _ = Console.ReadLine();
        Console.WriteLine();
    }

    /// <summary>
    /// Pad a string with spaces to center it on the console display.
    /// </summary>
    /// <param name="strToCenter">The string to be centered.</param>
    /// <returns>The padded string.</returns>
    public string CenterString(string strToCenter)
    {
        var padAmount = (Console.WindowWidth - strToCenter.Length) / 2;
        var leftPad = new string(' ', padAmount);
        return $"{leftPad}{strToCenter}";
    }

    /// <summary>
    /// Display a line of hyphens, the centered text of the title, and another
    /// line of hyphens.
    /// </summary>
    /// <param name="strTitle">The string to be displayed.</param>
    public void DisplayTitle(string strTitle)
    {
        Console.WriteLine(SepBar);
        Console.WriteLine(CenterString(strTitle));
        Console.WriteLine(SepBar);
    }

    /// <summary>
    /// Display a countdown and wait for a number of seconds.
    /// </summary>
    /// <param name="numSeconds">The number of seconds to wait.</param>
    public void WaitABit(int numSeconds, string msg)
    {
        Console.WriteLine(msg);

        // Wait for the requested number of seconds.
        for (int i = numSeconds; i > 0; i--)
        {
            System.Threading.Thread.Sleep(1000);
            Console.Write($"{i}...");
        }

        PressEnter();
    }
}
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API AWS SDK para .NET*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/PutUserPolicy)

------
#### [ Bash ]

**AWS CLI com script Bash**  
 Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/iam#code-examples). 

```
###############################################################################
# function iam_create_user_assume_role
#
# Scenario to create an IAM user, create an IAM role, and apply the role to the user.
#
#     "IAM access" permissions are needed to run this code.
#     "STS assume role" permissions are needed to run this code. (Note: It might be necessary to
#           create a custom policy).
#
# Returns:
#       0 - If successful.
#       1 - If an error occurred.
###############################################################################
function iam_create_user_assume_role() {
  {
    if [ "$IAM_OPERATIONS_SOURCED" != "True" ]; then

      source ./iam_operations.sh
    fi
  }

  echo_repeat "*" 88
  echo "Welcome to the IAM create user and assume role demo."
  echo
  echo "This demo will create an IAM user, create an IAM role, and apply the role to the user."
  echo_repeat "*" 88
  echo

  echo -n "Enter a name for a new IAM user: "
  get_input
  user_name=$get_input_result

  local user_arn
  user_arn=$(iam_create_user -u "$user_name")

  # shellcheck disable=SC2181
  if [[ ${?} == 0 ]]; then
    echo "Created demo IAM user named $user_name"
  else
    errecho "$user_arn"
    errecho "The user failed to create. This demo will exit."
    return 1
  fi

  local access_key_response
  access_key_response=$(iam_create_user_access_key -u "$user_name")
  # shellcheck disable=SC2181
  if [[ ${?} != 0 ]]; then
    errecho "The access key failed to create. This demo will exit."
    clean_up "$user_name"
    return 1
  fi

  IFS=$'\t ' read -r -a access_key_values <<<"$access_key_response"
  local key_name=${access_key_values[0]}
  local key_secret=${access_key_values[1]}

  echo "Created access key named $key_name"

  echo "Wait 10 seconds for the user to be ready."
  sleep 10
  echo_repeat "*" 88
  echo

  local iam_role_name
  iam_role_name=$(generate_random_name "test-role")
  echo "Creating a role named $iam_role_name with user $user_name as the principal."

  local assume_role_policy_document="{
    \"Version\": \"2012-10-17\",
    \"Statement\": [{
        \"Effect\": \"Allow\",
        \"Principal\": {\"AWS\": \"$user_arn\"},
        \"Action\": \"sts:AssumeRole\"
        }]
    }"

  local role_arn
  role_arn=$(iam_create_role -n "$iam_role_name" -p "$assume_role_policy_document")

  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    echo "Created IAM role named $iam_role_name"
  else
    errecho "The role failed to create. This demo will exit."
    clean_up "$user_name" "$key_name"
    return 1
  fi

  local policy_name
  policy_name=$(generate_random_name "test-policy")
  local policy_document="{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"s3:ListAllMyBuckets\",
                    \"Resource\": \"arn:aws:s3:::*\"}]}"

  local policy_arn
  policy_arn=$(iam_create_policy -n "$policy_name" -p "$policy_document")
  # shellcheck disable=SC2181
  if [[ ${?} == 0 ]]; then
    echo "Created  IAM policy named $policy_name"
  else
    errecho "The policy failed to create."
    clean_up "$user_name" "$key_name" "$iam_role_name"
    return 1
  fi

  if (iam_attach_role_policy -n "$iam_role_name" -p "$policy_arn"); then
    echo "Attached policy $policy_arn to role $iam_role_name"
  else
    errecho "The policy failed to attach."
    clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn"
    return 1
  fi

  local assume_role_policy_document="{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"sts:AssumeRole\",
                    \"Resource\": \"$role_arn\"}]}"

  local assume_role_policy_name
  assume_role_policy_name=$(generate_random_name "test-assume-role-")

  # shellcheck disable=SC2181
  local assume_role_policy_arn
  assume_role_policy_arn=$(iam_create_policy -n "$assume_role_policy_name" -p "$assume_role_policy_document")
  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    echo "Created  IAM policy named $assume_role_policy_name for sts assume role"
  else
    errecho "The policy failed to create."
    clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn"
    return 1
  fi

  echo "Wait 10 seconds to give AWS time to propagate these new resources and connections."
  sleep 10
  echo_repeat "*" 88
  echo

  echo "Try to list buckets without the new user assuming the role."
  echo_repeat "*" 88
  echo

  # Set the environment variables for the created user.
  # bashsupport disable=BP2001
  export AWS_ACCESS_KEY_ID=$key_name
  # bashsupport disable=BP2001
  export AWS_SECRET_ACCESS_KEY=$key_secret

  local buckets
  buckets=$(s3_list_buckets)

  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    local bucket_count
    bucket_count=$(echo "$buckets" | wc -w | xargs)
    echo "There are $bucket_count buckets in the account. This should not have happened."
  else
    errecho "Because the role with permissions has not been assumed, listing buckets failed."
  fi

  echo
  echo_repeat "*" 88
  echo "Now assume the role $iam_role_name and list the buckets."
  echo_repeat "*" 88
  echo

  local credentials

  credentials=$(sts_assume_role -r "$role_arn" -n "AssumeRoleDemoSession")
  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    echo "Assumed role $iam_role_name"
  else
    errecho "Failed to assume role."
    export AWS_ACCESS_KEY_ID=""
    export AWS_SECRET_ACCESS_KEY=""
    clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn" "$assume_role_policy_arn"
    return 1
  fi

  IFS=$'\t ' read -r -a credentials <<<"$credentials"

  export AWS_ACCESS_KEY_ID=${credentials[0]}
  export AWS_SECRET_ACCESS_KEY=${credentials[1]}
  # bashsupport disable=BP2001
  export AWS_SESSION_TOKEN=${credentials[2]}

  buckets=$(s3_list_buckets)

  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    local bucket_count
    bucket_count=$(echo "$buckets" | wc -w | xargs)
    echo "There are $bucket_count buckets in the account. Listing buckets succeeded because of "
    echo "the assumed role."
  else
    errecho "Failed to list buckets. This should not happen."
    export AWS_ACCESS_KEY_ID=""
    export AWS_SECRET_ACCESS_KEY=""
    export AWS_SESSION_TOKEN=""
    clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn" "$assume_role_policy_arn"
    return 1
  fi

  local result=0
  export AWS_ACCESS_KEY_ID=""
  export AWS_SECRET_ACCESS_KEY=""

  echo
  echo_repeat "*" 88
  echo "The created resources will now be deleted."
  echo_repeat "*" 88
  echo

  clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn" "$assume_role_policy_arn"

  # shellcheck disable=SC2181
  if [[ ${?} -ne 0 ]]; then
    result=1
  fi

  return $result
}
```
As funções do IAM usadas neste cenário.  

```
###############################################################################
# function iam_user_exists
#
# This function checks to see if the specified AWS Identity and Access Management (IAM) user already exists.
#
# Parameters:
#       $1 - The name of the IAM user to check.
#
# Returns:
#       0 - If the user already exists.
#       1 - If the user doesn't exist.
###############################################################################
function iam_user_exists() {
  local user_name
  user_name=$1

  # Check whether the IAM user already exists.
  # We suppress all output - we're interested only in the return code.

  local errors
  errors=$(aws iam get-user \
    --user-name "$user_name" 2>&1 >/dev/null)

  local error_code=${?}

  if [[ $error_code -eq 0 ]]; then
    return 0 # 0 in Bash script means true.
  else
    if [[ $errors != *"error"*"(NoSuchEntity)"* ]]; then
      aws_cli_error_log $error_code
      errecho "Error calling iam get-user $errors"
    fi

    return 1 # 1 in Bash script means false.
  fi
}

###############################################################################
# function iam_create_user
#
# This function creates the specified IAM user, unless
# it already exists.
#
# Parameters:
#       -u user_name  -- The name of the user to create.
#
# Returns:
#       The ARN of the user.
#     And:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_user() {
  local user_name response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_user"
    echo "Creates an AWS Identity and Access Management (IAM) user. You must supply a username:"
    echo "  -u user_name    The name of the user. It must be unique within the account."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "u:h" option; do
    case "${option}" in
      u) user_name="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$user_name" ]]; then
    errecho "ERROR: You must provide a username with the -u parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    User name:   $user_name"
  iecho ""

  # If the user already exists, we don't want to try to create it.
  if (iam_user_exists "$user_name"); then
    errecho "ERROR: A user with that name already exists in the account."
    return 1
  fi

  response=$(aws iam create-user --user-name "$user_name" \
    --output text \
    --query 'User.Arn')

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-user operation failed.$response"
    return 1
  fi

  echo "$response"

  return 0
}

###############################################################################
# function iam_create_user_access_key
#
# This function creates an IAM access key for the specified user.
#
# Parameters:
#       -u user_name -- The name of the IAM user.
#       [-f file_name] -- The optional file name for the access key output.
#
# Returns:
#       [access_key_id access_key_secret]
#     And:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_user_access_key() {
  local user_name file_name response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_user_access_key"
    echo "Creates an AWS Identity and Access Management (IAM) key pair."
    echo "  -u user_name   The name of the IAM user."
    echo "  [-f file_name]   Optional file name for the access key output."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "u:f:h" option; do
    case "${option}" in
      u) user_name="${OPTARG}" ;;
      f) file_name="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$user_name" ]]; then
    errecho "ERROR: You must provide a username with the -u parameter."
    usage
    return 1
  fi

  response=$(aws iam create-access-key \
    --user-name "$user_name" \
    --output text)

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-access-key operation failed.$response"
    return 1
  fi

  if [[ -n "$file_name" ]]; then
    echo "$response" >"$file_name"
  fi

  local key_id key_secret
  # shellcheck disable=SC2086
  key_id=$(echo $response | cut -f 2 -d ' ')
  # shellcheck disable=SC2086
  key_secret=$(echo $response | cut -f 4 -d ' ')

  echo "$key_id $key_secret"

  return 0
}

###############################################################################
# function iam_create_role
#
# This function creates an IAM role.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#       -p policy_json -- The assume role policy document.
#
# Returns:
#       The ARN of the role.
#     And:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_role() {
  local role_name policy_document response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_user_access_key"
    echo "Creates an AWS Identity and Access Management (IAM) role."
    echo "  -n role_name   The name of the IAM role."
    echo "  -p policy_json -- The assume role policy document."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      p) policy_document="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_document" ]]; then
    errecho "ERROR: You must provide a policy document with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam create-role \
    --role-name "$role_name" \
    --assume-role-policy-document "$policy_document" \
    --output text \
    --query Role.Arn)

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-role operation failed.\n$response"
    return 1
  fi

  echo "$response"

  return 0
}

###############################################################################
# function iam_create_policy
#
# This function creates an IAM policy.
#
# Parameters:
#       -n policy_name -- The name of the IAM policy.
#       -p policy_json -- The policy document.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_policy() {
  local policy_name policy_document response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_policy"
    echo "Creates an AWS Identity and Access Management (IAM) policy."
    echo "  -n policy_name   The name of the IAM policy."
    echo "  -p policy_json -- The policy document."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) policy_name="${OPTARG}" ;;
      p) policy_document="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$policy_name" ]]; then
    errecho "ERROR: You must provide a policy name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_document" ]]; then
    errecho "ERROR: You must provide a policy document with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam create-policy \
    --policy-name "$policy_name" \
    --policy-document "$policy_document" \
    --output text \
    --query Policy.Arn)

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-policy operation failed.\n$response"
    return 1
  fi

  echo "$response"
}

###############################################################################
# function iam_attach_role_policy
#
# This function attaches an IAM policy to a tole.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#       -p policy_ARN -- The IAM policy document ARN..
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_attach_role_policy() {
  local role_name policy_arn response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_attach_role_policy"
    echo "Attaches an AWS Identity and Access Management (IAM) policy to an IAM role."
    echo "  -n role_name   The name of the IAM role."
    echo "  -p policy_ARN -- The IAM policy document ARN."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      p) policy_arn="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_arn" ]]; then
    errecho "ERROR: You must provide a policy ARN with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam attach-role-policy \
    --role-name "$role_name" \
    --policy-arn "$policy_arn")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports attach-role-policy operation failed.\n$response"
    return 1
  fi

  echo "$response"

  return 0
}

###############################################################################
# function iam_detach_role_policy
#
# This function detaches an IAM policy to a tole.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#       -p policy_ARN -- The IAM policy document ARN..
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_detach_role_policy() {
  local role_name policy_arn response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_detach_role_policy"
    echo "Detaches an AWS Identity and Access Management (IAM) policy to an IAM role."
    echo "  -n role_name   The name of the IAM role."
    echo "  -p policy_ARN -- The IAM policy document ARN."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      p) policy_arn="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_arn" ]]; then
    errecho "ERROR: You must provide a policy ARN with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam detach-role-policy \
    --role-name "$role_name" \
    --policy-arn "$policy_arn")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports detach-role-policy operation failed.\n$response"
    return 1
  fi

  echo "$response"

  return 0
}

###############################################################################
# function iam_delete_policy
#
# This function deletes an IAM policy.
#
# Parameters:
#       -n policy_arn -- The name of the IAM policy arn.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_delete_policy() {
  local policy_arn response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_delete_policy"
    echo "Deletes an AWS Identity and Access Management (IAM) policy"
    echo "  -n policy_arn -- The name of the IAM policy arn."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:h" option; do
    case "${option}" in
      n) policy_arn="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$policy_arn" ]]; then
    errecho "ERROR: You must provide a policy arn with the -n parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    Policy arn:  $policy_arn"
  iecho ""

  response=$(aws iam delete-policy \
    --policy-arn "$policy_arn")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports delete-policy operation failed.\n$response"
    return 1
  fi

  iecho "delete-policy response:$response"
  iecho

  return 0
}

###############################################################################
# function iam_delete_role
#
# This function deletes an IAM role.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_delete_role() {
  local role_name response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_delete_role"
    echo "Deletes an AWS Identity and Access Management (IAM) role"
    echo "  -n role_name -- The name of the IAM role."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  echo "role_name:$role_name"
  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    Role name:  $role_name"
  iecho ""

  response=$(aws iam delete-role \
    --role-name "$role_name")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports delete-role operation failed.\n$response"
    return 1
  fi

  iecho "delete-role response:$response"
  iecho

  return 0
}

###############################################################################
# function iam_delete_access_key
#
# This function deletes an IAM access key for the specified IAM user.
#
# Parameters:
#       -u user_name  -- The name of the user.
#       -k access_key -- The access key to delete.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_delete_access_key() {
  local user_name access_key response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_delete_access_key"
    echo "Deletes an AWS Identity and Access Management (IAM) access key for the specified IAM user"
    echo "  -u user_name    The name of the user."
    echo "  -k access_key   The access key to delete."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "u:k:h" option; do
    case "${option}" in
      u) user_name="${OPTARG}" ;;
      k) access_key="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$user_name" ]]; then
    errecho "ERROR: You must provide a username with the -u parameter."
    usage
    return 1
  fi

  if [[ -z "$access_key" ]]; then
    errecho "ERROR: You must provide an access key with the -k parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    Username:   $user_name"
  iecho "    Access key:   $access_key"
  iecho ""

  response=$(aws iam delete-access-key \
    --user-name "$user_name" \
    --access-key-id "$access_key")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports delete-access-key operation failed.\n$response"
    return 1
  fi

  iecho "delete-access-key response:$response"
  iecho

  return 0
}

###############################################################################
# function iam_delete_user
#
# This function deletes the specified IAM user.
#
# Parameters:
#       -u user_name  -- The name of the user to create.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_delete_user() {
  local user_name response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_delete_user"
    echo "Deletes an AWS Identity and Access Management (IAM) user. You must supply a username:"
    echo "  -u user_name    The name of the user."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "u:h" option; do
    case "${option}" in
      u) user_name="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$user_name" ]]; then
    errecho "ERROR: You must provide a username with the -u parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    User name:   $user_name"
  iecho ""

  # If the user does not exist, we don't want to try to delete it.
  if (! iam_user_exists "$user_name"); then
    errecho "ERROR: A user with that name does not exist in the account."
    return 1
  fi

  response=$(aws iam delete-user \
    --user-name "$user_name")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports delete-user operation failed.$response"
    return 1
  fi

  iecho "delete-user response:$response"
  iecho

  return 0
}
```
+ Consulte detalhes da API nos tópicos a seguir na *Referência de comandos da AWS CLI*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/PutUserPolicy)

------
#### [ C\$1\$1 ]

**SDK para C\$1\$1**  
 Há mais no GitHub. Encontre o exemplo completo e veja como configurar e executar no [repositório de exemplos de código da AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/iam#code-examples). 

```
namespace AwsDoc {
    namespace IAM {
  
        //! Cleanup by deleting created entities.
        /*!
          \sa DeleteCreatedEntities
          \param client: IAM client.
          \param role: IAM role.
          \param user: IAM user.
          \param policy: IAM policy.
        */
        static bool DeleteCreatedEntities(const Aws::IAM::IAMClient &client,
                                          const Aws::IAM::Model::Role &role,
                                          const Aws::IAM::Model::User &user,
                                          const Aws::IAM::Model::Policy &policy);
    }

    static const int LIST_BUCKETS_WAIT_SEC = 20;

    static const char ALLOCATION_TAG[] = "example_code";
}

//! Scenario to create an IAM user, create an IAM role, and apply the role to the user.
// "IAM access" permissions are needed to run this code.
// "STS assume role" permissions are needed to run this code. (Note: It might be necessary to
//    create a custom policy).
/*!
  \sa iamCreateUserAssumeRoleScenario
  \param clientConfig: Aws client configuration.
  \return bool: Successful completion.
*/
bool AwsDoc::IAM::iamCreateUserAssumeRoleScenario(
        const Aws::Client::ClientConfiguration &clientConfig) {

    Aws::IAM::IAMClient client(clientConfig);
    Aws::IAM::Model::User user;
    Aws::IAM::Model::Role role;
    Aws::IAM::Model::Policy policy;

    // 1. Create a user.
    {
        Aws::IAM::Model::CreateUserRequest request;
        Aws::String uuid = Aws::Utils::UUID::RandomUUID();
        Aws::String userName = "iam-demo-user-" +
                               Aws::Utils::StringUtils::ToLower(uuid.c_str());
        request.SetUserName(userName);

        Aws::IAM::Model::CreateUserOutcome outcome = client.CreateUser(request);
        if (!outcome.IsSuccess()) {
            std::cout << "Error creating IAM user " << userName << ":" <<
                      outcome.GetError().GetMessage() << std::endl;
            return false;
        }
        else {
            std::cout << "Successfully created IAM user " << userName << std::endl;
        }

        user = outcome.GetResult().GetUser();
    }

    // 2. Create a role.
    {
        // Get the IAM user for the current client in order to access its ARN.
        Aws::String iamUserArn;
        {
            Aws::IAM::Model::GetUserRequest request;
            Aws::IAM::Model::GetUserOutcome outcome = client.GetUser(request);
            if (!outcome.IsSuccess()) {
                std::cerr << "Error getting Iam user. " <<
                          outcome.GetError().GetMessage() << std::endl;

                DeleteCreatedEntities(client, role, user, policy);
                return false;
            }
            else {
                std::cout << "Successfully retrieved Iam user "
                          << outcome.GetResult().GetUser().GetUserName()
                          << std::endl;
            }

            iamUserArn = outcome.GetResult().GetUser().GetArn();
        }

        Aws::IAM::Model::CreateRoleRequest request;

        Aws::String uuid = Aws::Utils::UUID::RandomUUID();
        Aws::String roleName = "iam-demo-role-" +
                               Aws::Utils::StringUtils::ToLower(uuid.c_str());
        request.SetRoleName(roleName);

        // Build policy document for role.
        Aws::Utils::Document jsonStatement;
        jsonStatement.WithString("Effect", "Allow");

        Aws::Utils::Document jsonPrincipal;
        jsonPrincipal.WithString("AWS", iamUserArn);
        jsonStatement.WithObject("Principal", jsonPrincipal);
        jsonStatement.WithString("Action", "sts:AssumeRole");
        jsonStatement.WithObject("Condition", Aws::Utils::Document());

        Aws::Utils::Document policyDocument;
        policyDocument.WithString("Version", "2012-10-17");

        Aws::Utils::Array<Aws::Utils::Document> statements(1);
        statements[0] = jsonStatement;
        policyDocument.WithArray("Statement", statements);

        std::cout << "Setting policy for role\n   "
                  << policyDocument.View().WriteCompact() << std::endl;

        // Set role policy document as JSON string.
        request.SetAssumeRolePolicyDocument(policyDocument.View().WriteCompact());

        Aws::IAM::Model::CreateRoleOutcome outcome = client.CreateRole(request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error creating role. " <<
                      outcome.GetError().GetMessage() << std::endl;

            DeleteCreatedEntities(client, role, user, policy);
            return false;
        }
        else {
            std::cout << "Successfully created a role with name " << roleName
                      << std::endl;
        }

        role = outcome.GetResult().GetRole();
    }

    // 3. Create an IAM policy.
    {
        Aws::IAM::Model::CreatePolicyRequest request;
        Aws::String uuid = Aws::Utils::UUID::RandomUUID();
        Aws::String policyName = "iam-demo-policy-" +
                                 Aws::Utils::StringUtils::ToLower(uuid.c_str());
        request.SetPolicyName(policyName);

        // Build IAM policy document.
        Aws::Utils::Document jsonStatement;
        jsonStatement.WithString("Effect", "Allow");
        jsonStatement.WithString("Action", "s3:ListAllMyBuckets");
        jsonStatement.WithString("Resource", "arn:aws:s3:::*");

        Aws::Utils::Document policyDocument;
        policyDocument.WithString("Version", "2012-10-17");

        Aws::Utils::Array<Aws::Utils::Document> statements(1);
        statements[0] = jsonStatement;
        policyDocument.WithArray("Statement", statements);

        std::cout << "Creating a policy.\n   " << policyDocument.View().WriteCompact()
                  << std::endl;

        // Set IAM policy document as JSON string.
        request.SetPolicyDocument(policyDocument.View().WriteCompact());

        Aws::IAM::Model::CreatePolicyOutcome outcome = client.CreatePolicy(request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error creating policy. " <<
                      outcome.GetError().GetMessage() << std::endl;

            DeleteCreatedEntities(client, role, user, policy);
            return false;
        }
        else {
            std::cout << "Successfully created a policy with name, " << policyName <<
                      "." << std::endl;
        }

        policy = outcome.GetResult().GetPolicy();
    }

    // 4. Assume the new role using the AWS Security Token Service (STS).
    Aws::STS::Model::Credentials credentials;
    {
        Aws::STS::STSClient stsClient(clientConfig);

        Aws::STS::Model::AssumeRoleRequest request;
        request.SetRoleArn(role.GetArn());
        Aws::String uuid = Aws::Utils::UUID::RandomUUID();
        Aws::String roleSessionName = "iam-demo-role-session-" +
                                      Aws::Utils::StringUtils::ToLower(uuid.c_str());
        request.SetRoleSessionName(roleSessionName);

        Aws::STS::Model::AssumeRoleOutcome assumeRoleOutcome;

        // Repeatedly call AssumeRole, because there is often a delay
        // before the role is available to be assumed.
        // Repeat at most 20 times when access is denied.
        int count = 0;
        while (true) {
            assumeRoleOutcome = stsClient.AssumeRole(request);
            if (!assumeRoleOutcome.IsSuccess()) {
                if (count > 20 ||
                    assumeRoleOutcome.GetError().GetErrorType() !=
                    Aws::STS::STSErrors::ACCESS_DENIED) {
                    std::cerr << "Error assuming role after 20 tries. " <<
                              assumeRoleOutcome.GetError().GetMessage() << std::endl;

                    DeleteCreatedEntities(client, role, user, policy);
                    return false;
                }
                std::this_thread::sleep_for(std::chrono::seconds(1));
            }
            else {
                std::cout << "Successfully assumed the role after " << count
                          << " seconds." << std::endl;
                break;
            }
            count++;
        }

        credentials = assumeRoleOutcome.GetResult().GetCredentials();
    }


    // 5. List objects in the bucket (This should fail).
    {
        Aws::S3::S3Client s3Client(
                Aws::Auth::AWSCredentials(credentials.GetAccessKeyId(),
                                          credentials.GetSecretAccessKey(),
                                          credentials.GetSessionToken()),
                Aws::MakeShared<Aws::S3::S3EndpointProvider>(ALLOCATION_TAG),
                clientConfig);
        Aws::S3::Model::ListBucketsOutcome listBucketsOutcome = s3Client.ListBuckets();
        if (!listBucketsOutcome.IsSuccess()) {
            if (listBucketsOutcome.GetError().GetErrorType() !=
                Aws::S3::S3Errors::ACCESS_DENIED) {
                std::cerr << "Could not lists buckets. " <<
                          listBucketsOutcome.GetError().GetMessage() << std::endl;
            }
            else {
                std::cout
                        << "Access to list buckets denied because privileges have not been applied."
                        << std::endl;
            }
        }
        else {
            std::cerr
                    << "Successfully retrieved bucket lists when this should not happen."
                    << std::endl;
        }
    }

    // 6. Attach the policy to the role.
    {
        Aws::IAM::Model::AttachRolePolicyRequest request;
        request.SetRoleName(role.GetRoleName());
        request.WithPolicyArn(policy.GetArn());

        Aws::IAM::Model::AttachRolePolicyOutcome outcome = client.AttachRolePolicy(
                request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error creating policy. " <<
                      outcome.GetError().GetMessage() << std::endl;

            DeleteCreatedEntities(client, role, user, policy);
            return false;
        }
        else {
            std::cout << "Successfully attached the policy with name, "
                      << policy.GetPolicyName() <<
                      ", to the role, " << role.GetRoleName() << "." << std::endl;
        }
    }

    int count = 0;
    // 7. List objects in the bucket (this should succeed).
    // Repeatedly call ListBuckets, because there is often a delay
    // before the policy with ListBucket permissions has been applied to the role.
    // Repeat at most LIST_BUCKETS_WAIT_SEC times when access is denied.
    while (true) {
        Aws::S3::S3Client s3Client(
                Aws::Auth::AWSCredentials(credentials.GetAccessKeyId(),
                                          credentials.GetSecretAccessKey(),
                                          credentials.GetSessionToken()),
                Aws::MakeShared<Aws::S3::S3EndpointProvider>(ALLOCATION_TAG),
                clientConfig);
        Aws::S3::Model::ListBucketsOutcome listBucketsOutcome = s3Client.ListBuckets();
        if (!listBucketsOutcome.IsSuccess()) {
            if ((count > LIST_BUCKETS_WAIT_SEC) ||
                listBucketsOutcome.GetError().GetErrorType() !=
                Aws::S3::S3Errors::ACCESS_DENIED) {
                std::cerr << "Could not lists buckets after " << LIST_BUCKETS_WAIT_SEC << " seconds. " <<
                          listBucketsOutcome.GetError().GetMessage() << std::endl;
                DeleteCreatedEntities(client, role, user, policy);
                return false;
            }

            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
        else {

            std::cout << "Successfully retrieved bucket lists after " << count
                      << " seconds." << std::endl;
            break;
        }
        count++;
    }

    // 8. Delete all the created resources.
    return DeleteCreatedEntities(client, role, user, policy);
}

bool AwsDoc::IAM::DeleteCreatedEntities(const Aws::IAM::IAMClient &client,
                                        const Aws::IAM::Model::Role &role,
                                        const Aws::IAM::Model::User &user,
                                        const Aws::IAM::Model::Policy &policy) {
    bool result = true;
    if (policy.ArnHasBeenSet()) {
        // Detach the policy from the role.
        {
            Aws::IAM::Model::DetachRolePolicyRequest request;
            request.SetPolicyArn(policy.GetArn());
            request.SetRoleName(role.GetRoleName());

            Aws::IAM::Model::DetachRolePolicyOutcome outcome = client.DetachRolePolicy(
                    request);
            if (!outcome.IsSuccess()) {
                std::cerr << "Error Detaching policy from roles. " <<
                          outcome.GetError().GetMessage() << std::endl;
                result = false;
            }
            else {
                std::cout << "Successfully detached the policy with arn "
                          << policy.GetArn()
                          << " from role " << role.GetRoleName() << "." << std::endl;
            }
        }

        // Delete the policy.
        {
            Aws::IAM::Model::DeletePolicyRequest request;
            request.WithPolicyArn(policy.GetArn());

            Aws::IAM::Model::DeletePolicyOutcome outcome = client.DeletePolicy(request);
            if (!outcome.IsSuccess()) {
                std::cerr << "Error deleting policy. " <<
                          outcome.GetError().GetMessage() << std::endl;
                result = false;
            }
            else {
                std::cout << "Successfully deleted the policy with arn "
                          << policy.GetArn() << std::endl;
            }
        }

    }

    if (role.RoleIdHasBeenSet()) {
        // Delete the role.
        Aws::IAM::Model::DeleteRoleRequest request;
        request.SetRoleName(role.GetRoleName());

        Aws::IAM::Model::DeleteRoleOutcome outcome = client.DeleteRole(request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error deleting role. " <<
                      outcome.GetError().GetMessage() << std::endl;
            result = false;
        }
        else {
            std::cout << "Successfully deleted the role with name "
                      << role.GetRoleName() << std::endl;
        }
    }

    if (user.ArnHasBeenSet()) {
        // Delete the user.
        Aws::IAM::Model::DeleteUserRequest request;
        request.WithUserName(user.GetUserName());

        Aws::IAM::Model::DeleteUserOutcome outcome = client.DeleteUser(request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error deleting user. " <<
                      outcome.GetError().GetMessage() << std::endl;
            result = false;
        }
        else {
            std::cout << "Successfully deleted the user with name "
                      << user.GetUserName() << std::endl;
        }
    }

    return result;
}
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API AWS SDK para C\$1\$1*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/PutUserPolicy)

------
#### [ Go ]

**SDK para Go V2**  
 Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/iam#code-examples). 
Execute um cenário interativo em um prompt de comando.  

```
import (
	"context"
	"errors"
	"fmt"
	"log"
	"math/rand"
	"strings"
	"time"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/credentials"
	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
	"github.com/aws/aws-sdk-go-v2/service/s3"
	"github.com/aws/aws-sdk-go-v2/service/sts"
	"github.com/aws/smithy-go"
	"github.com/awsdocs/aws-doc-sdk-examples/gov2/demotools"
	"github.com/awsdocs/aws-doc-sdk-examples/gov2/iam/actions"
)

// AssumeRoleScenario shows you how to use the AWS Identity and Access Management (IAM)
// service to perform the following actions:
//
//  1. Create a user who has no permissions.
//  2. Create a role that grants permission to list Amazon Simple Storage Service
//     (Amazon S3) buckets for the account.
//  3. Add a policy to let the user assume the role.
//  4. Try and fail to list buckets without permissions.
//  5. Assume the role and list S3 buckets using temporary credentials.
//  6. Delete the policy, role, and user.
type AssumeRoleScenario struct {
	sdkConfig      aws.Config
	accountWrapper actions.AccountWrapper
	policyWrapper  actions.PolicyWrapper
	roleWrapper    actions.RoleWrapper
	userWrapper    actions.UserWrapper
	questioner     demotools.IQuestioner
	helper         IScenarioHelper
	isTestRun      bool
}

// NewAssumeRoleScenario constructs an AssumeRoleScenario instance from a configuration.
// It uses the specified config to get an IAM client and create wrappers for the actions
// used in the scenario.
func NewAssumeRoleScenario(sdkConfig aws.Config, questioner demotools.IQuestioner,
	helper IScenarioHelper) AssumeRoleScenario {
	iamClient := iam.NewFromConfig(sdkConfig)
	return AssumeRoleScenario{
		sdkConfig:      sdkConfig,
		accountWrapper: actions.AccountWrapper{IamClient: iamClient},
		policyWrapper:  actions.PolicyWrapper{IamClient: iamClient},
		roleWrapper:    actions.RoleWrapper{IamClient: iamClient},
		userWrapper:    actions.UserWrapper{IamClient: iamClient},
		questioner:     questioner,
		helper:         helper,
	}
}

// addTestOptions appends the API options specified in the original configuration to
// another configuration. This is used to attach the middleware stubber to clients
// that are constructed during the scenario, which is needed for unit testing.
func (scenario AssumeRoleScenario) addTestOptions(scenarioConfig *aws.Config) {
	if scenario.isTestRun {
		scenarioConfig.APIOptions = append(scenarioConfig.APIOptions, scenario.sdkConfig.APIOptions...)
	}
}

// Run runs the interactive scenario.
func (scenario AssumeRoleScenario) Run(ctx context.Context) {
	defer func() {
		if r := recover(); r != nil {
			log.Printf("Something went wrong with the demo.\n")
			log.Println(r)
		}
	}()

	log.Println(strings.Repeat("-", 88))
	log.Println("Welcome to the AWS Identity and Access Management (IAM) assume role demo.")
	log.Println(strings.Repeat("-", 88))

	user := scenario.CreateUser(ctx)
	accessKey := scenario.CreateAccessKey(ctx, user)
	role := scenario.CreateRoleAndPolicies(ctx, user)
	noPermsConfig := scenario.ListBucketsWithoutPermissions(ctx, accessKey)
	scenario.ListBucketsWithAssumedRole(ctx, noPermsConfig, role)
	scenario.Cleanup(ctx, user, role)

	log.Println(strings.Repeat("-", 88))
	log.Println("Thanks for watching!")
	log.Println(strings.Repeat("-", 88))
}

// CreateUser creates a new IAM user. This user has no permissions.
func (scenario AssumeRoleScenario) CreateUser(ctx context.Context) *types.User {
	log.Println("Let's create an example user with no permissions.")
	userName := scenario.questioner.Ask("Enter a name for the example user:", demotools.NotEmpty{})
	user, err := scenario.userWrapper.GetUser(ctx, userName)
	if err != nil {
		panic(err)
	}
	if user == nil {
		user, err = scenario.userWrapper.CreateUser(ctx, userName)
		if err != nil {
			panic(err)
		}
		log.Printf("Created user %v.\n", *user.UserName)
	} else {
		log.Printf("User %v already exists.\n", *user.UserName)
	}
	log.Println(strings.Repeat("-", 88))
	return user
}

// CreateAccessKey creates an access key for the user.
func (scenario AssumeRoleScenario) CreateAccessKey(ctx context.Context, user *types.User) *types.AccessKey {
	accessKey, err := scenario.userWrapper.CreateAccessKeyPair(ctx, *user.UserName)
	if err != nil {
		panic(err)
	}
	log.Printf("Created access key %v for your user.", *accessKey.AccessKeyId)
	log.Println("Waiting a few seconds for your user to be ready...")
	scenario.helper.Pause(10)
	log.Println(strings.Repeat("-", 88))
	return accessKey
}

// CreateRoleAndPolicies creates a policy that grants permission to list S3 buckets for
// the current account and attaches the policy to a newly created role. It also adds an
// inline policy to the specified user that grants the user permission to assume the role.
func (scenario AssumeRoleScenario) CreateRoleAndPolicies(ctx context.Context, user *types.User) *types.Role {
	log.Println("Let's create a role and policy that grant permission to list S3 buckets.")
	scenario.questioner.Ask("Press Enter when you're ready.")
	listBucketsRole, err := scenario.roleWrapper.CreateRole(ctx, scenario.helper.GetName(), *user.Arn)
	if err != nil {
		panic(err)
	}
	log.Printf("Created role %v.\n", *listBucketsRole.RoleName)
	listBucketsPolicy, err := scenario.policyWrapper.CreatePolicy(
		ctx, scenario.helper.GetName(), []string{"s3:ListAllMyBuckets"}, "arn:aws:s3:::*")
	if err != nil {
		panic(err)
	}
	log.Printf("Created policy %v.\n", *listBucketsPolicy.PolicyName)
	err = scenario.roleWrapper.AttachRolePolicy(ctx, *listBucketsPolicy.Arn, *listBucketsRole.RoleName)
	if err != nil {
		panic(err)
	}
	log.Printf("Attached policy %v to role %v.\n", *listBucketsPolicy.PolicyName,
		*listBucketsRole.RoleName)
	err = scenario.userWrapper.CreateUserPolicy(ctx, *user.UserName, scenario.helper.GetName(),
		[]string{"sts:AssumeRole"}, *listBucketsRole.Arn)
	if err != nil {
		panic(err)
	}
	log.Printf("Created an inline policy for user %v that lets the user assume the role.\n",
		*user.UserName)
	log.Println("Let's give AWS a few seconds to propagate these new resources and connections...")
	scenario.helper.Pause(10)
	log.Println(strings.Repeat("-", 88))
	return listBucketsRole
}

// ListBucketsWithoutPermissions creates an Amazon S3 client from the user's access key
// credentials and tries to list buckets for the account. Because the user does not have
// permission to perform this action, the action fails.
func (scenario AssumeRoleScenario) ListBucketsWithoutPermissions(ctx context.Context, accessKey *types.AccessKey) *aws.Config {
	log.Println("Let's try to list buckets without permissions. This should return an AccessDenied error.")
	scenario.questioner.Ask("Press Enter when you're ready.")
	noPermsConfig, err := config.LoadDefaultConfig(ctx,
		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(
			*accessKey.AccessKeyId, *accessKey.SecretAccessKey, ""),
		))
	if err != nil {
		panic(err)
	}

	// Add test options if this is a test run. This is needed only for testing purposes.
	scenario.addTestOptions(&noPermsConfig)

	s3Client := s3.NewFromConfig(noPermsConfig)
	_, err = s3Client.ListBuckets(ctx, &s3.ListBucketsInput{})
	if err != nil {
		// The SDK for Go does not model the AccessDenied error, so check ErrorCode directly.
		var ae smithy.APIError
		if errors.As(err, &ae) {
			switch ae.ErrorCode() {
			case "AccessDenied":
				log.Println("Got AccessDenied error, which is the expected result because\n" +
					"the ListBuckets call was made without permissions.")
			default:
				log.Println("Expected AccessDenied, got something else.")
				panic(err)
			}
		}
	} else {
		log.Println("Expected AccessDenied error when calling ListBuckets without permissions,\n" +
			"but the call succeeded. Continuing the example anyway...")
	}
	log.Println(strings.Repeat("-", 88))
	return &noPermsConfig
}

// ListBucketsWithAssumedRole performs the following actions:
//
//  1. Creates an AWS Security Token Service (AWS STS) client from the config created from
//     the user's access key credentials.
//  2. Gets temporary credentials by assuming the role that grants permission to list the
//     buckets.
//  3. Creates an Amazon S3 client from the temporary credentials.
//  4. Lists buckets for the account. Because the temporary credentials are generated by
//     assuming the role that grants permission, the action succeeds.
func (scenario AssumeRoleScenario) ListBucketsWithAssumedRole(ctx context.Context, noPermsConfig *aws.Config, role *types.Role) {
	log.Println("Let's assume the role that grants permission to list buckets and try again.")
	scenario.questioner.Ask("Press Enter when you're ready.")
	stsClient := sts.NewFromConfig(*noPermsConfig)
	tempCredentials, err := stsClient.AssumeRole(ctx, &sts.AssumeRoleInput{
		RoleArn:         role.Arn,
		RoleSessionName: aws.String("AssumeRoleExampleSession"),
		DurationSeconds: aws.Int32(900),
	})
	if err != nil {
		log.Printf("Couldn't assume role %v.\n", *role.RoleName)
		panic(err)
	}
	log.Printf("Assumed role %v, got temporary credentials.\n", *role.RoleName)
	assumeRoleConfig, err := config.LoadDefaultConfig(ctx,
		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(
			*tempCredentials.Credentials.AccessKeyId,
			*tempCredentials.Credentials.SecretAccessKey,
			*tempCredentials.Credentials.SessionToken),
		),
	)
	if err != nil {
		panic(err)
	}

	// Add test options if this is a test run. This is needed only for testing purposes.
	scenario.addTestOptions(&assumeRoleConfig)

	s3Client := s3.NewFromConfig(assumeRoleConfig)
	result, err := s3Client.ListBuckets(ctx, &s3.ListBucketsInput{})
	if err != nil {
		log.Println("Couldn't list buckets with assumed role credentials.")
		panic(err)
	}
	log.Println("Successfully called ListBuckets with assumed role credentials, \n" +
		"here are some of them:")
	for i := 0; i < len(result.Buckets) && i < 5; i++ {
		log.Printf("\t%v\n", *result.Buckets[i].Name)
	}
	log.Println(strings.Repeat("-", 88))
}

// Cleanup deletes all resources created for the scenario.
func (scenario AssumeRoleScenario) Cleanup(ctx context.Context, user *types.User, role *types.Role) {
	if scenario.questioner.AskBool(
		"Do you want to delete the resources created for this example? (y/n)", "y",
	) {
		policies, err := scenario.roleWrapper.ListAttachedRolePolicies(ctx, *role.RoleName)
		if err != nil {
			panic(err)
		}
		for _, policy := range policies {
			err = scenario.roleWrapper.DetachRolePolicy(ctx, *role.RoleName, *policy.PolicyArn)
			if err != nil {
				panic(err)
			}
			err = scenario.policyWrapper.DeletePolicy(ctx, *policy.PolicyArn)
			if err != nil {
				panic(err)
			}
			log.Printf("Detached policy %v from role %v and deleted the policy.\n",
				*policy.PolicyName, *role.RoleName)
		}
		err = scenario.roleWrapper.DeleteRole(ctx, *role.RoleName)
		if err != nil {
			panic(err)
		}
		log.Printf("Deleted role %v.\n", *role.RoleName)

		userPols, err := scenario.userWrapper.ListUserPolicies(ctx, *user.UserName)
		if err != nil {
			panic(err)
		}
		for _, userPol := range userPols {
			err = scenario.userWrapper.DeleteUserPolicy(ctx, *user.UserName, userPol)
			if err != nil {
				panic(err)
			}
			log.Printf("Deleted policy %v from user %v.\n", userPol, *user.UserName)
		}
		keys, err := scenario.userWrapper.ListAccessKeys(ctx, *user.UserName)
		if err != nil {
			panic(err)
		}
		for _, key := range keys {
			err = scenario.userWrapper.DeleteAccessKey(ctx, *user.UserName, *key.AccessKeyId)
			if err != nil {
				panic(err)
			}
			log.Printf("Deleted access key %v from user %v.\n", *key.AccessKeyId, *user.UserName)
		}
		err = scenario.userWrapper.DeleteUser(ctx, *user.UserName)
		if err != nil {
			panic(err)
		}
		log.Printf("Deleted user %v.\n", *user.UserName)
		log.Println(strings.Repeat("-", 88))
	}

}

// IScenarioHelper abstracts input and wait functions from a scenario so that they
// can be mocked for unit testing.
type IScenarioHelper interface {
	GetName() string
	Pause(secs int)
}

const rMax = 100000

type ScenarioHelper struct {
	Prefix string
	Random *rand.Rand
}

// GetName returns a unique name formed of a prefix and a random number.
func (helper *ScenarioHelper) GetName() string {
	return fmt.Sprintf("%v%v", helper.Prefix, helper.Random.Intn(rMax))
}

// Pause waits for the specified number of seconds.
func (helper ScenarioHelper) Pause(secs int) {
	time.Sleep(time.Duration(secs) * time.Second)
}
```
Defina um struct que encapsule as ações de conta.  

```
import (
	"context"
	"log"

	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
)

// AccountWrapper encapsulates AWS Identity and Access Management (IAM) account actions
// used in the examples.
// It contains an IAM service client that is used to perform account actions.
type AccountWrapper struct {
	IamClient *iam.Client
}



// GetAccountPasswordPolicy gets the account password policy for the current account.
// If no policy has been set, a NoSuchEntityException is error is returned.
func (wrapper AccountWrapper) GetAccountPasswordPolicy(ctx context.Context) (*types.PasswordPolicy, error) {
	var pwPolicy *types.PasswordPolicy
	result, err := wrapper.IamClient.GetAccountPasswordPolicy(ctx,
		&iam.GetAccountPasswordPolicyInput{})
	if err != nil {
		log.Printf("Couldn't get account password policy. Here's why: %v\n", err)
	} else {
		pwPolicy = result.PasswordPolicy
	}
	return pwPolicy, err
}



// ListSAMLProviders gets the SAML providers for the account.
func (wrapper AccountWrapper) ListSAMLProviders(ctx context.Context) ([]types.SAMLProviderListEntry, error) {
	var providers []types.SAMLProviderListEntry
	result, err := wrapper.IamClient.ListSAMLProviders(ctx, &iam.ListSAMLProvidersInput{})
	if err != nil {
		log.Printf("Couldn't list SAML providers. Here's why: %v\n", err)
	} else {
		providers = result.SAMLProviderList
	}
	return providers, err
}
```
Defina um struct que encapsule as ações de política.  

```
import (
	"context"
	"encoding/json"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
)

// PolicyWrapper encapsulates AWS Identity and Access Management (IAM) policy actions
// used in the examples.
// It contains an IAM service client that is used to perform policy actions.
type PolicyWrapper struct {
	IamClient *iam.Client
}



// ListPolicies gets up to maxPolicies policies.
func (wrapper PolicyWrapper) ListPolicies(ctx context.Context, maxPolicies int32) ([]types.Policy, error) {
	var policies []types.Policy
	result, err := wrapper.IamClient.ListPolicies(ctx, &iam.ListPoliciesInput{
		MaxItems: aws.Int32(maxPolicies),
	})
	if err != nil {
		log.Printf("Couldn't list policies. Here's why: %v\n", err)
	} else {
		policies = result.Policies
	}
	return policies, err
}



// PolicyDocument defines a policy document as a Go struct that can be serialized
// to JSON.
type PolicyDocument struct {
	Version   string
	Statement []PolicyStatement
}

// PolicyStatement defines a statement in a policy document.
type PolicyStatement struct {
	Effect    string
	Action    []string
	Principal map[string]string `json:",omitempty"`
	Resource  *string           `json:",omitempty"`
}

// CreatePolicy creates a policy that grants a list of actions to the specified resource.
// PolicyDocument shows how to work with a policy document as a data structure and
// serialize it to JSON by using Go's JSON marshaler.
func (wrapper PolicyWrapper) CreatePolicy(ctx context.Context, policyName string, actions []string,
	resourceArn string) (*types.Policy, error) {
	var policy *types.Policy
	policyDoc := PolicyDocument{
		Version: "2012-10-17",
		Statement: []PolicyStatement{{
			Effect:   "Allow",
			Action:   actions,
			Resource: aws.String(resourceArn),
		}},
	}
	policyBytes, err := json.Marshal(policyDoc)
	if err != nil {
		log.Printf("Couldn't create policy document for %v. Here's why: %v\n", resourceArn, err)
		return nil, err
	}
	result, err := wrapper.IamClient.CreatePolicy(ctx, &iam.CreatePolicyInput{
		PolicyDocument: aws.String(string(policyBytes)),
		PolicyName:     aws.String(policyName),
	})
	if err != nil {
		log.Printf("Couldn't create policy %v. Here's why: %v\n", policyName, err)
	} else {
		policy = result.Policy
	}
	return policy, err
}



// GetPolicy gets data about a policy.
func (wrapper PolicyWrapper) GetPolicy(ctx context.Context, policyArn string) (*types.Policy, error) {
	var policy *types.Policy
	result, err := wrapper.IamClient.GetPolicy(ctx, &iam.GetPolicyInput{
		PolicyArn: aws.String(policyArn),
	})
	if err != nil {
		log.Printf("Couldn't get policy %v. Here's why: %v\n", policyArn, err)
	} else {
		policy = result.Policy
	}
	return policy, err
}



// DeletePolicy deletes a policy.
func (wrapper PolicyWrapper) DeletePolicy(ctx context.Context, policyArn string) error {
	_, err := wrapper.IamClient.DeletePolicy(ctx, &iam.DeletePolicyInput{
		PolicyArn: aws.String(policyArn),
	})
	if err != nil {
		log.Printf("Couldn't delete policy %v. Here's why: %v\n", policyArn, err)
	}
	return err
}
```
Defina um struct que encapsule as ações de perfil.  

```
import (
	"context"
	"encoding/json"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
)

// RoleWrapper encapsulates AWS Identity and Access Management (IAM) role actions
// used in the examples.
// It contains an IAM service client that is used to perform role actions.
type RoleWrapper struct {
	IamClient *iam.Client
}



// ListRoles gets up to maxRoles roles.
func (wrapper RoleWrapper) ListRoles(ctx context.Context, maxRoles int32) ([]types.Role, error) {
	var roles []types.Role
	result, err := wrapper.IamClient.ListRoles(ctx,
		&iam.ListRolesInput{MaxItems: aws.Int32(maxRoles)},
	)
	if err != nil {
		log.Printf("Couldn't list roles. Here's why: %v\n", err)
	} else {
		roles = result.Roles
	}
	return roles, err
}



// CreateRole creates a role that trusts a specified user. The trusted user can assume
// the role to acquire its permissions.
// PolicyDocument shows how to work with a policy document as a data structure and
// serialize it to JSON by using Go's JSON marshaler.
func (wrapper RoleWrapper) CreateRole(ctx context.Context, roleName string, trustedUserArn string) (*types.Role, error) {
	var role *types.Role
	trustPolicy := PolicyDocument{
		Version: "2012-10-17",
		Statement: []PolicyStatement{{
			Effect:    "Allow",
			Principal: map[string]string{"AWS": trustedUserArn},
			Action:    []string{"sts:AssumeRole"},
		}},
	}
	policyBytes, err := json.Marshal(trustPolicy)
	if err != nil {
		log.Printf("Couldn't create trust policy for %v. Here's why: %v\n", trustedUserArn, err)
		return nil, err
	}
	result, err := wrapper.IamClient.CreateRole(ctx, &iam.CreateRoleInput{
		AssumeRolePolicyDocument: aws.String(string(policyBytes)),
		RoleName:                 aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't create role %v. Here's why: %v\n", roleName, err)
	} else {
		role = result.Role
	}
	return role, err
}



// GetRole gets data about a role.
func (wrapper RoleWrapper) GetRole(ctx context.Context, roleName string) (*types.Role, error) {
	var role *types.Role
	result, err := wrapper.IamClient.GetRole(ctx,
		&iam.GetRoleInput{RoleName: aws.String(roleName)})
	if err != nil {
		log.Printf("Couldn't get role %v. Here's why: %v\n", roleName, err)
	} else {
		role = result.Role
	}
	return role, err
}



// CreateServiceLinkedRole creates a service-linked role that is owned by the specified service.
func (wrapper RoleWrapper) CreateServiceLinkedRole(ctx context.Context, serviceName string, description string) (
	*types.Role, error) {
	var role *types.Role
	result, err := wrapper.IamClient.CreateServiceLinkedRole(ctx, &iam.CreateServiceLinkedRoleInput{
		AWSServiceName: aws.String(serviceName),
		Description:    aws.String(description),
	})
	if err != nil {
		log.Printf("Couldn't create service-linked role %v. Here's why: %v\n", serviceName, err)
	} else {
		role = result.Role
	}
	return role, err
}



// DeleteServiceLinkedRole deletes a service-linked role.
func (wrapper RoleWrapper) DeleteServiceLinkedRole(ctx context.Context, roleName string) error {
	_, err := wrapper.IamClient.DeleteServiceLinkedRole(ctx, &iam.DeleteServiceLinkedRoleInput{
		RoleName: aws.String(roleName)},
	)
	if err != nil {
		log.Printf("Couldn't delete service-linked role %v. Here's why: %v\n", roleName, err)
	}
	return err
}



// AttachRolePolicy attaches a policy to a role.
func (wrapper RoleWrapper) AttachRolePolicy(ctx context.Context, policyArn string, roleName string) error {
	_, err := wrapper.IamClient.AttachRolePolicy(ctx, &iam.AttachRolePolicyInput{
		PolicyArn: aws.String(policyArn),
		RoleName:  aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't attach policy %v to role %v. Here's why: %v\n", policyArn, roleName, err)
	}
	return err
}



// ListAttachedRolePolicies lists the policies that are attached to the specified role.
func (wrapper RoleWrapper) ListAttachedRolePolicies(ctx context.Context, roleName string) ([]types.AttachedPolicy, error) {
	var policies []types.AttachedPolicy
	result, err := wrapper.IamClient.ListAttachedRolePolicies(ctx, &iam.ListAttachedRolePoliciesInput{
		RoleName: aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't list attached policies for role %v. Here's why: %v\n", roleName, err)
	} else {
		policies = result.AttachedPolicies
	}
	return policies, err
}



// DetachRolePolicy detaches a policy from a role.
func (wrapper RoleWrapper) DetachRolePolicy(ctx context.Context, roleName string, policyArn string) error {
	_, err := wrapper.IamClient.DetachRolePolicy(ctx, &iam.DetachRolePolicyInput{
		PolicyArn: aws.String(policyArn),
		RoleName:  aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't detach policy from role %v. Here's why: %v\n", roleName, err)
	}
	return err
}



// ListRolePolicies lists the inline policies for a role.
func (wrapper RoleWrapper) ListRolePolicies(ctx context.Context, roleName string) ([]string, error) {
	var policies []string
	result, err := wrapper.IamClient.ListRolePolicies(ctx, &iam.ListRolePoliciesInput{
		RoleName: aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't list policies for role %v. Here's why: %v\n", roleName, err)
	} else {
		policies = result.PolicyNames
	}
	return policies, err
}



// DeleteRole deletes a role. All attached policies must be detached before a
// role can be deleted.
func (wrapper RoleWrapper) DeleteRole(ctx context.Context, roleName string) error {
	_, err := wrapper.IamClient.DeleteRole(ctx, &iam.DeleteRoleInput{
		RoleName: aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't delete role %v. Here's why: %v\n", roleName, err)
	}
	return err
}
```
Defina um struct que encapsule as ações de usuário.  

```
import (
	"context"
	"encoding/json"
	"errors"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
	"github.com/aws/smithy-go"
)

// UserWrapper encapsulates user actions used in the examples.
// It contains an IAM service client that is used to perform user actions.
type UserWrapper struct {
	IamClient *iam.Client
}



// ListUsers gets up to maxUsers number of users.
func (wrapper UserWrapper) ListUsers(ctx context.Context, maxUsers int32) ([]types.User, error) {
	var users []types.User
	result, err := wrapper.IamClient.ListUsers(ctx, &iam.ListUsersInput{
		MaxItems: aws.Int32(maxUsers),
	})
	if err != nil {
		log.Printf("Couldn't list users. Here's why: %v\n", err)
	} else {
		users = result.Users
	}
	return users, err
}



// GetUser gets data about a user.
func (wrapper UserWrapper) GetUser(ctx context.Context, userName string) (*types.User, error) {
	var user *types.User
	result, err := wrapper.IamClient.GetUser(ctx, &iam.GetUserInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		var apiError smithy.APIError
		if errors.As(err, &apiError) {
			switch apiError.(type) {
			case *types.NoSuchEntityException:
				log.Printf("User %v does not exist.\n", userName)
				err = nil
			default:
				log.Printf("Couldn't get user %v. Here's why: %v\n", userName, err)
			}
		}
	} else {
		user = result.User
	}
	return user, err
}



// CreateUser creates a new user with the specified name.
func (wrapper UserWrapper) CreateUser(ctx context.Context, userName string) (*types.User, error) {
	var user *types.User
	result, err := wrapper.IamClient.CreateUser(ctx, &iam.CreateUserInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't create user %v. Here's why: %v\n", userName, err)
	} else {
		user = result.User
	}
	return user, err
}



// CreateUserPolicy adds an inline policy to a user. This example creates a policy that
// grants a list of actions on a specified role.
// PolicyDocument shows how to work with a policy document as a data structure and
// serialize it to JSON by using Go's JSON marshaler.
func (wrapper UserWrapper) CreateUserPolicy(ctx context.Context, userName string, policyName string, actions []string,
	roleArn string) error {
	policyDoc := PolicyDocument{
		Version: "2012-10-17",
		Statement: []PolicyStatement{{
			Effect:   "Allow",
			Action:   actions,
			Resource: aws.String(roleArn),
		}},
	}
	policyBytes, err := json.Marshal(policyDoc)
	if err != nil {
		log.Printf("Couldn't create policy document for %v. Here's why: %v\n", roleArn, err)
		return err
	}
	_, err = wrapper.IamClient.PutUserPolicy(ctx, &iam.PutUserPolicyInput{
		PolicyDocument: aws.String(string(policyBytes)),
		PolicyName:     aws.String(policyName),
		UserName:       aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't create policy for user %v. Here's why: %v\n", userName, err)
	}
	return err
}



// ListUserPolicies lists the inline policies for the specified user.
func (wrapper UserWrapper) ListUserPolicies(ctx context.Context, userName string) ([]string, error) {
	var policies []string
	result, err := wrapper.IamClient.ListUserPolicies(ctx, &iam.ListUserPoliciesInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't list policies for user %v. Here's why: %v\n", userName, err)
	} else {
		policies = result.PolicyNames
	}
	return policies, err
}



// DeleteUserPolicy deletes an inline policy from a user.
func (wrapper UserWrapper) DeleteUserPolicy(ctx context.Context, userName string, policyName string) error {
	_, err := wrapper.IamClient.DeleteUserPolicy(ctx, &iam.DeleteUserPolicyInput{
		PolicyName: aws.String(policyName),
		UserName:   aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't delete policy from user %v. Here's why: %v\n", userName, err)
	}
	return err
}



// DeleteUser deletes a user.
func (wrapper UserWrapper) DeleteUser(ctx context.Context, userName string) error {
	_, err := wrapper.IamClient.DeleteUser(ctx, &iam.DeleteUserInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't delete user %v. Here's why: %v\n", userName, err)
	}
	return err
}



// CreateAccessKeyPair creates an access key for a user. The returned access key contains
// the ID and secret credentials needed to use the key.
func (wrapper UserWrapper) CreateAccessKeyPair(ctx context.Context, userName string) (*types.AccessKey, error) {
	var key *types.AccessKey
	result, err := wrapper.IamClient.CreateAccessKey(ctx, &iam.CreateAccessKeyInput{
		UserName: aws.String(userName)})
	if err != nil {
		log.Printf("Couldn't create access key pair for user %v. Here's why: %v\n", userName, err)
	} else {
		key = result.AccessKey
	}
	return key, err
}



// DeleteAccessKey deletes an access key from a user.
func (wrapper UserWrapper) DeleteAccessKey(ctx context.Context, userName string, keyId string) error {
	_, err := wrapper.IamClient.DeleteAccessKey(ctx, &iam.DeleteAccessKeyInput{
		AccessKeyId: aws.String(keyId),
		UserName:    aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't delete access key %v. Here's why: %v\n", keyId, err)
	}
	return err
}



// ListAccessKeys lists the access keys for the specified user.
func (wrapper UserWrapper) ListAccessKeys(ctx context.Context, userName string) ([]types.AccessKeyMetadata, error) {
	var keys []types.AccessKeyMetadata
	result, err := wrapper.IamClient.ListAccessKeys(ctx, &iam.ListAccessKeysInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't list access keys for user %v. Here's why: %v\n", userName, err)
	} else {
		keys = result.AccessKeyMetadata
	}
	return keys, err
}
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API AWS SDK para Go*.
  + [AttachRolePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.AttachRolePolicy)
  + [CreateAccessKey](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreateAccessKey)
  + [CreatePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreatePolicy)
  + [CreateRole](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreateRole)
  + [CreateUser](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreateUser)
  + [DeleteAccessKey](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteAccessKey)
  + [DeletePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeletePolicy)
  + [DeleteRole](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteRole)
  + [DeleteUser](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteUser)
  + [DeleteUserPolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteUserPolicy)
  + [DetachRolePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DetachRolePolicy)
  + [PutUserPolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.PutUserPolicy)

------
#### [ Java ]

**SDK para Java 2.x**  
 Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/iam#code-examples). 
Crie a funções que envolvam ações do usuário do IAM.  

```
/*
  To run this Java V2 code example, set up your development environment, including your credentials.

  For information, see this documentation topic:

  https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html

  This example performs these operations:

  1. Creates a user that has no permissions.
  2. Creates a role and policy that grants Amazon S3 permissions.
  3. Creates a role.
  4. Grants the user permissions.
  5. Gets temporary credentials by assuming the role.  Creates an Amazon S3 Service client object with the temporary credentials.
  6. Deletes the resources.
 */

public class IAMScenario {
    public static final String DASHES = new String(new char[80]).replace("\0", "-");
    public static final String PolicyDocument = "{" +
            "  \"Version\": \"2012-10-17\"," +
            "  \"Statement\": [" +
            "    {" +
            "        \"Effect\": \"Allow\"," +
            "        \"Action\": [" +
            "            \"s3:*\"" +
            "       ]," +
            "       \"Resource\": \"*\"" +
            "    }" +
            "   ]" +
            "}";

    public static String userArn;

    public static void main(String[] args) throws Exception {

        final String usage = """

                Usage:
                    <username> <policyName> <roleName> <roleSessionName> <bucketName>\s

                Where:
                    username - The name of the IAM user to create.\s
                    policyName - The name of the policy to create.\s
                    roleName - The name of the role to create.\s
                    roleSessionName - The name of the session required for the assumeRole operation.\s
                    bucketName - The name of the Amazon S3 bucket from which objects are read.\s
                """;

        if (args.length != 5) {
            System.out.println(usage);
            System.exit(1);
        }

        String userName = args[0];
        String policyName = args[1];
        String roleName = args[2];
        String roleSessionName = args[3];
        String bucketName = args[4];

        Region region = Region.AWS_GLOBAL;
        IamClient iam = IamClient.builder()
                .region(region)
                .build();

        System.out.println(DASHES);
        System.out.println("Welcome to the AWS IAM example scenario.");
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println(" 1. Create the IAM user.");
        User createUser = createIAMUser(iam, userName);

        System.out.println(DASHES);
        userArn = createUser.arn();

        AccessKey myKey = createIAMAccessKey(iam, userName);
        String accessKey = myKey.accessKeyId();
        String secretKey = myKey.secretAccessKey();
        String assumeRolePolicyDocument = "{" +
                "\"Version\": \"2012-10-17\"," +
                "\"Statement\": [{" +
                "\"Effect\": \"Allow\"," +
                "\"Principal\": {" +
                "	\"AWS\": \"" + userArn + "\"" +
                "}," +
                "\"Action\": \"sts:AssumeRole\"" +
                "}]" +
                "}";

        System.out.println(assumeRolePolicyDocument);
        System.out.println(userName + " was successfully created.");
        System.out.println(DASHES);
        System.out.println("2. Creates a policy.");
        String polArn = createIAMPolicy(iam, policyName);
        System.out.println("The policy " + polArn + " was successfully created.");
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("3. Creates a role.");
        TimeUnit.SECONDS.sleep(30);
        String roleArn = createIAMRole(iam, roleName, assumeRolePolicyDocument);
        System.out.println(roleArn + " was successfully created.");
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("4. Grants the user permissions.");
        attachIAMRolePolicy(iam, roleName, polArn);
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("*** Wait for 30 secs so the resource is available");
        TimeUnit.SECONDS.sleep(30);
        System.out.println("5. Gets temporary credentials by assuming the role.");
        System.out.println("Perform an Amazon S3 Service operation using the temporary credentials.");
        assumeRole(roleArn, roleSessionName, bucketName, accessKey, secretKey);
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("6 Getting ready to delete the AWS resources");
        deleteKey(iam, userName, accessKey);
        deleteRole(iam, roleName, polArn);
        deleteIAMUser(iam, userName);
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("This IAM Scenario has successfully completed");
        System.out.println(DASHES);
    }

    public static AccessKey createIAMAccessKey(IamClient iam, String user) {
        try {
            CreateAccessKeyRequest request = CreateAccessKeyRequest.builder()
                    .userName(user)
                    .build();

            CreateAccessKeyResponse response = iam.createAccessKey(request);
            return response.accessKey();

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return null;
    }

    public static User createIAMUser(IamClient iam, String username) {
        try {
            // Create an IamWaiter object
            IamWaiter iamWaiter = iam.waiter();
            CreateUserRequest request = CreateUserRequest.builder()
                    .userName(username)
                    .build();

            // Wait until the user is created.
            CreateUserResponse response = iam.createUser(request);
            GetUserRequest userRequest = GetUserRequest.builder()
                    .userName(response.user().userName())
                    .build();

            WaiterResponse<GetUserResponse> waitUntilUserExists = iamWaiter.waitUntilUserExists(userRequest);
            waitUntilUserExists.matched().response().ifPresent(System.out::println);
            return response.user();

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return null;
    }

    public static String createIAMRole(IamClient iam, String rolename, String json) {

        try {
            CreateRoleRequest request = CreateRoleRequest.builder()
                    .roleName(rolename)
                    .assumeRolePolicyDocument(json)
                    .description("Created using the AWS SDK for Java")
                    .build();

            CreateRoleResponse response = iam.createRole(request);
            System.out.println("The ARN of the role is " + response.role().arn());
            return response.role().arn();

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return "";
    }

    public static String createIAMPolicy(IamClient iam, String policyName) {
        try {
            // Create an IamWaiter object.
            IamWaiter iamWaiter = iam.waiter();
            CreatePolicyRequest request = CreatePolicyRequest.builder()
                    .policyName(policyName)
                    .policyDocument(PolicyDocument).build();

            CreatePolicyResponse response = iam.createPolicy(request);
            GetPolicyRequest polRequest = GetPolicyRequest.builder()
                    .policyArn(response.policy().arn())
                    .build();

            WaiterResponse<GetPolicyResponse> waitUntilPolicyExists = iamWaiter.waitUntilPolicyExists(polRequest);
            waitUntilPolicyExists.matched().response().ifPresent(System.out::println);
            return response.policy().arn();

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return "";
    }

    public static void attachIAMRolePolicy(IamClient iam, String roleName, String policyArn) {
        try {
            ListAttachedRolePoliciesRequest request = ListAttachedRolePoliciesRequest.builder()
                    .roleName(roleName)
                    .build();

            ListAttachedRolePoliciesResponse response = iam.listAttachedRolePolicies(request);
            List<AttachedPolicy> attachedPolicies = response.attachedPolicies();
            String polArn;
            for (AttachedPolicy policy : attachedPolicies) {
                polArn = policy.policyArn();
                if (polArn.compareTo(policyArn) == 0) {
                    System.out.println(roleName + " policy is already attached to this role.");
                    return;
                }
            }

            AttachRolePolicyRequest attachRequest = AttachRolePolicyRequest.builder()
                    .roleName(roleName)
                    .policyArn(policyArn)
                    .build();

            iam.attachRolePolicy(attachRequest);
            System.out.println("Successfully attached policy " + policyArn + " to role " + roleName);

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }

    // Invoke an Amazon S3 operation using the Assumed Role.
    public static void assumeRole(String roleArn, String roleSessionName, String bucketName, String keyVal,
            String keySecret) {

        // Use the creds of the new IAM user that was created in this code example.
        AwsBasicCredentials credentials = AwsBasicCredentials.create(keyVal, keySecret);
        StsClient stsClient = StsClient.builder()
                .region(Region.US_EAST_1)
                .credentialsProvider(StaticCredentialsProvider.create(credentials))
                .build();

        try {
            AssumeRoleRequest roleRequest = AssumeRoleRequest.builder()
                    .roleArn(roleArn)
                    .roleSessionName(roleSessionName)
                    .build();

            AssumeRoleResponse roleResponse = stsClient.assumeRole(roleRequest);
            Credentials myCreds = roleResponse.credentials();
            String key = myCreds.accessKeyId();
            String secKey = myCreds.secretAccessKey();
            String secToken = myCreds.sessionToken();

            // List all objects in an Amazon S3 bucket using the temp creds retrieved by
            // invoking assumeRole.
            Region region = Region.US_EAST_1;
            S3Client s3 = S3Client.builder()
                    .credentialsProvider(
                            StaticCredentialsProvider.create(AwsSessionCredentials.create(key, secKey, secToken)))
                    .region(region)
                    .build();

            System.out.println("Created a S3Client using temp credentials.");
            System.out.println("Listing objects in " + bucketName);
            ListObjectsRequest listObjects = ListObjectsRequest.builder()
                    .bucket(bucketName)
                    .build();

            ListObjectsResponse res = s3.listObjects(listObjects);
            List<S3Object> objects = res.contents();
            for (S3Object myValue : objects) {
                System.out.println("The name of the key is " + myValue.key());
                System.out.println("The owner is " + myValue.owner());
            }

        } catch (StsException e) {
            System.err.println(e.getMessage());
            System.exit(1);
        }
    }

    public static void deleteRole(IamClient iam, String roleName, String polArn) {

        try {
            // First the policy needs to be detached.
            DetachRolePolicyRequest rolePolicyRequest = DetachRolePolicyRequest.builder()
                    .policyArn(polArn)
                    .roleName(roleName)
                    .build();

            iam.detachRolePolicy(rolePolicyRequest);

            // Delete the policy.
            DeletePolicyRequest request = DeletePolicyRequest.builder()
                    .policyArn(polArn)
                    .build();

            iam.deletePolicy(request);
            System.out.println("*** Successfully deleted " + polArn);

            // Delete the role.
            DeleteRoleRequest roleRequest = DeleteRoleRequest.builder()
                    .roleName(roleName)
                    .build();

            iam.deleteRole(roleRequest);
            System.out.println("*** Successfully deleted " + roleName);

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }

    public static void deleteKey(IamClient iam, String username, String accessKey) {
        try {
            DeleteAccessKeyRequest request = DeleteAccessKeyRequest.builder()
                    .accessKeyId(accessKey)
                    .userName(username)
                    .build();

            iam.deleteAccessKey(request);
            System.out.println("Successfully deleted access key " + accessKey +
                    " from user " + username);

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }

    public static void deleteIAMUser(IamClient iam, String userName) {
        try {
            DeleteUserRequest request = DeleteUserRequest.builder()
                    .userName(userName)
                    .build();

            iam.deleteUser(request);
            System.out.println("*** Successfully deleted " + userName);

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }
}
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API AWS SDK for Java 2.x*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/PutUserPolicy)

------
#### [ JavaScript ]

**SDK para JavaScript (v3)**  
 Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/iam#code-examples). 
Crie um usuário e um perfil do IAM que conceda permissão para listar os buckets do Amazon S3. O usuário só tem direitos para assumir a função. Após assumir a função, use credenciais temporárias para listar os buckets para a conta.  

```
import {
  CreateUserCommand,
  GetUserCommand,
  CreateAccessKeyCommand,
  CreatePolicyCommand,
  CreateRoleCommand,
  AttachRolePolicyCommand,
  DeleteAccessKeyCommand,
  DeleteUserCommand,
  DeleteRoleCommand,
  DeletePolicyCommand,
  DetachRolePolicyCommand,
  IAMClient,
} from "@aws-sdk/client-iam";
import { ListBucketsCommand, S3Client } from "@aws-sdk/client-s3";
import { AssumeRoleCommand, STSClient } from "@aws-sdk/client-sts";
import { retry } from "@aws-doc-sdk-examples/lib/utils/util-timers.js";
import { ScenarioInput } from "@aws-doc-sdk-examples/lib/scenario/index.js";

// Set the parameters.
const iamClient = new IAMClient({});
const userName = "iam_basic_test_username";
const policyName = "iam_basic_test_policy";
const roleName = "iam_basic_test_role";

/**
 * Create a new IAM user. If the user already exists, give
 * the option to delete and re-create it.
 * @param {string} name
 */
export const createUser = async (name, confirmAll = false) => {
  try {
    const { User } = await iamClient.send(
      new GetUserCommand({ UserName: name }),
    );
    const input = new ScenarioInput(
      "deleteUser",
      "Do you want to delete and remake this user?",
      { type: "confirm" },
    );
    const deleteUser = await input.handle({}, { confirmAll });
    // If the user exists, and you want to delete it, delete the user
    // and then create it again.
    if (deleteUser) {
      await iamClient.send(new DeleteUserCommand({ UserName: User.UserName }));
      await iamClient.send(new CreateUserCommand({ UserName: name }));
    } else {
      console.warn(
        `${name} already exists. The scenario may not work as expected.`,
      );
      return User;
    }
  } catch (caught) {
    // If there is no user by that name, create one.
    if (caught instanceof Error && caught.name === "NoSuchEntityException") {
      const { User } = await iamClient.send(
        new CreateUserCommand({ UserName: name }),
      );
      return User;
    }
    throw caught;
  }
};

export const main = async (confirmAll = false) => {
  // Create a user. The user has no permissions by default.
  const User = await createUser(userName, confirmAll);

  if (!User) {
    throw new Error("User not created");
  }

  // Create an access key. This key is used to authenticate the new user to
  // Amazon Simple Storage Service (Amazon S3) and AWS Security Token Service (AWS STS).
  // It's not best practice to use access keys. For more information, see https://aws.amazon.com/iam/resources/best-practices/.
  const createAccessKeyResponse = await iamClient.send(
    new CreateAccessKeyCommand({ UserName: userName }),
  );

  if (
    !createAccessKeyResponse.AccessKey?.AccessKeyId ||
    !createAccessKeyResponse.AccessKey?.SecretAccessKey
  ) {
    throw new Error("Access key not created");
  }

  const {
    AccessKey: { AccessKeyId, SecretAccessKey },
  } = createAccessKeyResponse;

  let s3Client = new S3Client({
    credentials: {
      accessKeyId: AccessKeyId,
      secretAccessKey: SecretAccessKey,
    },
  });

  // Retry the list buckets operation until it succeeds. InvalidAccessKeyId is
  // thrown while the user and access keys are still stabilizing.
  await retry({ intervalInMs: 1000, maxRetries: 300 }, async () => {
    try {
      return await listBuckets(s3Client);
    } catch (err) {
      if (err instanceof Error && err.name === "InvalidAccessKeyId") {
        throw err;
      }
    }
  });

  // Retry the create role operation until it succeeds. A MalformedPolicyDocument error
  // is thrown while the user and access keys are still stabilizing.
  const { Role } = await retry(
    {
      intervalInMs: 2000,
      maxRetries: 60,
    },
    () =>
      iamClient.send(
        new CreateRoleCommand({
          AssumeRolePolicyDocument: JSON.stringify({
            Version: "2012-10-17",
            Statement: [
              {
                Effect: "Allow",
                Principal: {
                  // Allow the previously created user to assume this role.
                  AWS: User.Arn,
                },
                Action: "sts:AssumeRole",
              },
            ],
          }),
          RoleName: roleName,
        }),
      ),
  );

  if (!Role) {
    throw new Error("Role not created");
  }

  // Create a policy that allows the user to list S3 buckets.
  const { Policy: listBucketPolicy } = await iamClient.send(
    new CreatePolicyCommand({
      PolicyDocument: JSON.stringify({
        Version: "2012-10-17",
        Statement: [
          {
            Effect: "Allow",
            Action: ["s3:ListAllMyBuckets"],
            Resource: "*",
          },
        ],
      }),
      PolicyName: policyName,
    }),
  );

  if (!listBucketPolicy) {
    throw new Error("Policy not created");
  }

  // Attach the policy granting the 's3:ListAllMyBuckets' action to the role.
  await iamClient.send(
    new AttachRolePolicyCommand({
      PolicyArn: listBucketPolicy.Arn,
      RoleName: Role.RoleName,
    }),
  );

  // Assume the role.
  const stsClient = new STSClient({
    credentials: {
      accessKeyId: AccessKeyId,
      secretAccessKey: SecretAccessKey,
    },
  });

  // Retry the assume role operation until it succeeds.
  const { Credentials } = await retry(
    { intervalInMs: 2000, maxRetries: 60 },
    () =>
      stsClient.send(
        new AssumeRoleCommand({
          RoleArn: Role.Arn,
          RoleSessionName: `iamBasicScenarioSession-${Math.floor(
            Math.random() * 1000000,
          )}`,
          DurationSeconds: 900,
        }),
      ),
  );

  if (!Credentials?.AccessKeyId || !Credentials?.SecretAccessKey) {
    throw new Error("Credentials not created");
  }

  s3Client = new S3Client({
    credentials: {
      accessKeyId: Credentials.AccessKeyId,
      secretAccessKey: Credentials.SecretAccessKey,
      sessionToken: Credentials.SessionToken,
    },
  });

  // List the S3 buckets again.
  // Retry the list buckets operation until it succeeds. AccessDenied might
  // be thrown while the role policy is still stabilizing.
  await retry({ intervalInMs: 2000, maxRetries: 120 }, () =>
    listBuckets(s3Client),
  );

  // Clean up.
  await iamClient.send(
    new DetachRolePolicyCommand({
      PolicyArn: listBucketPolicy.Arn,
      RoleName: Role.RoleName,
    }),
  );

  await iamClient.send(
    new DeletePolicyCommand({
      PolicyArn: listBucketPolicy.Arn,
    }),
  );

  await iamClient.send(
    new DeleteRoleCommand({
      RoleName: Role.RoleName,
    }),
  );

  await iamClient.send(
    new DeleteAccessKeyCommand({
      UserName: userName,
      AccessKeyId,
    }),
  );

  await iamClient.send(
    new DeleteUserCommand({
      UserName: userName,
    }),
  );
};

/**
 *
 * @param {S3Client} s3Client
 */
const listBuckets = async (s3Client) => {
  const { Buckets } = await s3Client.send(new ListBucketsCommand({}));

  if (!Buckets) {
    throw new Error("Buckets not listed");
  }

  console.log(Buckets.map((bucket) => bucket.Name).join("\n"));
};
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API AWS SDK para JavaScript*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/AttachRolePolicyCommand)
  + [CreateAccessKey](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreateAccessKeyCommand)
  + [CreatePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreatePolicyCommand)
  + [CreateRole](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreateRoleCommand)
  + [CreateUser](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreateUserCommand)
  + [DeleteAccessKey](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteAccessKeyCommand)
  + [DeletePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeletePolicyCommand)
  + [DeleteRole](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteRoleCommand)
  + [DeleteUser](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteUserCommand)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteUserPolicyCommand)
  + [DetachRolePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DetachRolePolicyCommand)
  + [PutUserPolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/PutUserPolicyCommand)

------
#### [ Kotlin ]

**SDK para Kotlin**  
 Há mais no GitHub. Encontre o exemplo completo e veja como configurar e executar no [repositório de exemplos de código da AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/iam#code-examples). 
Crie a funções que envolvam ações do usuário do IAM.  

```
suspend fun main(args: Array<String>) {
    val usage = """
    Usage:
        <username> <policyName> <roleName> <roleSessionName> <fileLocation> <bucketName> 

    Where:
        username - The name of the IAM user to create. 
        policyName - The name of the policy to create. 
        roleName - The name of the role to create. 
        roleSessionName - The name of the session required for the assumeRole operation. 
        fileLocation - The file location to the JSON required to create the role (see Readme). 
        bucketName - The name of the Amazon S3 bucket from which objects are read. 
    """

    if (args.size != 6) {
        println(usage)
        exitProcess(1)
    }

    val userName = args[0]
    val policyName = args[1]
    val roleName = args[2]
    val roleSessionName = args[3]
    val fileLocation = args[4]
    val bucketName = args[5]

    createUser(userName)
    println("$userName was successfully created.")

    val polArn = createPolicy(policyName)
    println("The policy $polArn was successfully created.")

    val roleArn = createRole(roleName, fileLocation)
    println("$roleArn was successfully created.")
    attachRolePolicy(roleName, polArn)

    println("*** Wait for 1 MIN so the resource is available.")
    delay(60000)
    assumeGivenRole(roleArn, roleSessionName, bucketName)

    println("*** Getting ready to delete the AWS resources.")
    deleteRole(roleName, polArn)
    deleteUser(userName)
    println("This IAM Scenario has successfully completed.")
}

suspend fun createUser(usernameVal: String?): String? {
    val request =
        CreateUserRequest {
            userName = usernameVal
        }

    IamClient { region = "AWS_GLOBAL" }.use { iamClient ->
        val response = iamClient.createUser(request)
        return response.user?.userName
    }
}

suspend fun createPolicy(policyNameVal: String?): String {
    val policyDocumentValue = """
    {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
            {
                "Effect": "Allow",
                "Action": [
                    "s3:*"
                ],
                "Resource": "*"
            }
        ]
    }
    """.trimIndent()

    val request =
        CreatePolicyRequest {
            policyName = policyNameVal
            policyDocument = policyDocumentValue
        }

    IamClient.fromEnvironment { region = "AWS_GLOBAL" }.use { iamClient ->
        val response = iamClient.createPolicy(request)
        return response.policy?.arn.toString()
    }
}

suspend fun createRole(
    rolenameVal: String?,
    fileLocation: String?,
): String? {
    val jsonObject = fileLocation?.let { readJsonSimpleDemo(it) } as JSONObject

    val request =
        CreateRoleRequest {
            roleName = rolenameVal
            assumeRolePolicyDocument = jsonObject.toJSONString()
            description = "Created using the AWS SDK for Kotlin"
        }

    IamClient { region = "AWS_GLOBAL" }.use { iamClient ->
        val response = iamClient.createRole(request)
        return response.role?.arn
    }
}

suspend fun attachRolePolicy(
    roleNameVal: String,
    policyArnVal: String,
) {
    val request =
        ListAttachedRolePoliciesRequest {
            roleName = roleNameVal
        }

    IamClient.fromEnvironment { region = "AWS_GLOBAL" }.use { iamClient ->
        val response = iamClient.listAttachedRolePolicies(request)
        val attachedPolicies = response.attachedPolicies

        // Ensure that the policy is not attached to this role.
        val checkStatus: Int
        if (attachedPolicies != null) {
            checkStatus = checkMyList(attachedPolicies, policyArnVal)
            if (checkStatus == -1) {
                return
            }
        }

        val policyRequest =
            AttachRolePolicyRequest {
                roleName = roleNameVal
                policyArn = policyArnVal
            }
        iamClient.attachRolePolicy(policyRequest)
        println("Successfully attached policy $policyArnVal to role $roleNameVal")
    }
}

fun checkMyList(
    attachedPolicies: List<AttachedPolicy>,
    policyArnVal: String,
): Int {
    for (policy in attachedPolicies) {
        val polArn = policy.policyArn.toString()

        if (polArn.compareTo(policyArnVal) == 0) {
            println("The policy is already attached to this role.")
            return -1
        }
    }
    return 0
}

suspend fun assumeGivenRole(
    roleArnVal: String?,
    roleSessionNameVal: String?,
    bucketName: String,
) {
    val stsClient = StsClient.fromEnvironment { region = "us-east-1" }
    val roleRequest =
        AssumeRoleRequest {
            roleArn = roleArnVal
            roleSessionName = roleSessionNameVal
        }

    val roleResponse = stsClient.assumeRole(roleRequest)
    val myCreds = roleResponse.credentials
    val key = myCreds?.accessKeyId
    val secKey = myCreds?.secretAccessKey
    val secToken = myCreds?.sessionToken

    val staticCredentials = StaticCredentialsProvider {
        accessKeyId = key
        secretAccessKey = secKey
        sessionToken = secToken
    }

    // List all objects in an Amazon S3 bucket using the temp creds.
    val s3 = S3Client.fromEnvironment {
        region = "us-east-1"
        credentialsProvider = staticCredentials
    }

    println("Created a S3Client using temp credentials.")
    println("Listing objects in $bucketName")

    val listObjects =
        ListObjectsRequest {
            bucket = bucketName
        }

    val response = s3.listObjects(listObjects)
    response.contents?.forEach { myObject ->
        println("The name of the key is ${myObject.key}")
        println("The owner is ${myObject.owner}")
    }
}

suspend fun deleteRole(
    roleNameVal: String,
    polArn: String,
) {
    val iam = IamClient.fromEnvironment { region = "AWS_GLOBAL" }

    // First the policy needs to be detached.
    val rolePolicyRequest =
        DetachRolePolicyRequest {
            policyArn = polArn
            roleName = roleNameVal
        }

    iam.detachRolePolicy(rolePolicyRequest)

    // Delete the policy.
    val request =
        DeletePolicyRequest {
            policyArn = polArn
        }

    iam.deletePolicy(request)
    println("*** Successfully deleted $polArn")

    // Delete the role.
    val roleRequest =
        DeleteRoleRequest {
            roleName = roleNameVal
        }

    iam.deleteRole(roleRequest)
    println("*** Successfully deleted $roleNameVal")
}

suspend fun deleteUser(userNameVal: String) {
    val iam = IamClient.fromEnvironment { region = "AWS_GLOBAL" }
    val request =
        DeleteUserRequest {
            userName = userNameVal
        }

    iam.deleteUser(request)
    println("*** Successfully deleted $userNameVal")
}

@Throws(java.lang.Exception::class)
fun readJsonSimpleDemo(filename: String): Any? {
    val reader = FileReader(filename)
    val jsonParser = JSONParser()
    return jsonParser.parse(reader)
}
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API AWS SDK para Kotlin*.
  + [AttachRolePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [CreateAccessKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [CreatePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [CreateRole](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [CreateUser](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeleteAccessKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeletePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeleteRole](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeleteUser](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeleteUserPolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DetachRolePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [PutUserPolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)

------
#### [ PHP ]

**SDK para PHP**  
 Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/iam#code-examples). 

```
namespace Iam\Basics;

require 'vendor/autoload.php';

use Aws\Credentials\Credentials;
use Aws\S3\Exception\S3Exception;
use Aws\S3\S3Client;
use Aws\Sts\StsClient;
use Iam\IAMService;

echo("\n");
echo("--------------------------------------\n");
print("Welcome to the IAM getting started demo using PHP!\n");
echo("--------------------------------------\n");

$uuid = uniqid();
$service = new IAMService();

$user = $service->createUser("iam_demo_user_$uuid");
echo "Created user with the arn: {$user['Arn']}\n";

$key = $service->createAccessKey($user['UserName']);
$assumeRolePolicyDocument = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Principal\": {\"AWS\": \"{$user['Arn']}\"},
                    \"Action\": \"sts:AssumeRole\"
                }]
            }";
$assumeRoleRole = $service->createRole("iam_demo_role_$uuid", $assumeRolePolicyDocument);
echo "Created role: {$assumeRoleRole['RoleName']}\n";

$listAllBucketsPolicyDocument = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"s3:ListAllMyBuckets\",
                    \"Resource\": \"arn:aws:s3:::*\"}]
}";
$listAllBucketsPolicy = $service->createPolicy("iam_demo_policy_$uuid", $listAllBucketsPolicyDocument);
echo "Created policy: {$listAllBucketsPolicy['PolicyName']}\n";

$service->attachRolePolicy($assumeRoleRole['RoleName'], $listAllBucketsPolicy['Arn']);

$inlinePolicyDocument = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"sts:AssumeRole\",
                    \"Resource\": \"{$assumeRoleRole['Arn']}\"}]
}";
$inlinePolicy = $service->createUserPolicy("iam_demo_inline_policy_$uuid", $inlinePolicyDocument, $user['UserName']);
//First, fail to list the buckets with the user
$credentials = new Credentials($key['AccessKeyId'], $key['SecretAccessKey']);
$s3Client = new S3Client(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $credentials]);
try {
    $s3Client->listBuckets([
    ]);
    echo "this should not run";
} catch (S3Exception $exception) {
    echo "successfully failed!\n";
}

$stsClient = new StsClient(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $credentials]);
sleep(10);
$assumedRole = $stsClient->assumeRole([
    'RoleArn' => $assumeRoleRole['Arn'],
    'RoleSessionName' => "DemoAssumeRoleSession_$uuid",
]);
$assumedCredentials = [
    'key' => $assumedRole['Credentials']['AccessKeyId'],
    'secret' => $assumedRole['Credentials']['SecretAccessKey'],
    'token' => $assumedRole['Credentials']['SessionToken'],
];
$s3Client = new S3Client(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $assumedCredentials]);
try {
    $s3Client->listBuckets([]);
    echo "this should now run!\n";
} catch (S3Exception $exception) {
    echo "this should now not fail\n";
}

$service->detachRolePolicy($assumeRoleRole['RoleName'], $listAllBucketsPolicy['Arn']);
$deletePolicy = $service->deletePolicy($listAllBucketsPolicy['Arn']);
echo "Delete policy: {$listAllBucketsPolicy['PolicyName']}\n";
$deletedRole = $service->deleteRole($assumeRoleRole['Arn']);
echo "Deleted role: {$assumeRoleRole['RoleName']}\n";
$deletedKey = $service->deleteAccessKey($key['AccessKeyId'], $user['UserName']);
$deletedUser = $service->deleteUser($user['UserName']);
echo "Delete user: {$user['UserName']}\n";
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API AWS SDK para PHP*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/PutUserPolicy)

------
#### [ Python ]

**SDK para Python (Boto3).**  
 Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/iam#code-examples). 
Crie um usuário e um perfil do IAM que conceda permissão para listar os buckets do Amazon S3. O usuário só tem direitos para assumir a função. Após assumir a função, use credenciais temporárias para listar os buckets para a conta.  

```
import json
import sys
import time
from uuid import uuid4

import boto3
from botocore.exceptions import ClientError


def progress_bar(seconds):
    """Shows a simple progress bar in the command window."""
    for _ in range(seconds):
        time.sleep(1)
        print(".", end="")
        sys.stdout.flush()
    print()


def setup(iam_resource):
    """
    Creates a new user with no permissions.
    Creates an access key pair for the user.
    Creates a role with a policy that lets the user assume the role.
    Creates a policy that allows listing Amazon S3 buckets.
    Attaches the policy to the role.
    Creates an inline policy for the user that lets the user assume the role.

    :param iam_resource: A Boto3 AWS Identity and Access Management (IAM) resource
                         that has permissions to create users, roles, and policies
                         in the account.
    :return: The newly created user, user key, and role.
    """
    try:
        user = iam_resource.create_user(UserName=f"demo-user-{uuid4()}")
        print(f"Created user {user.name}.")
    except ClientError as error:
        print(
            f"Couldn't create a user for the demo. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    try:
        user_key = user.create_access_key_pair()
        print(f"Created access key pair for user.")
    except ClientError as error:
        print(
            f"Couldn't create access keys for user {user.name}. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    print(f"Wait for user to be ready.", end="")
    progress_bar(10)

    try:
        role = iam_resource.create_role(
            RoleName=f"demo-role-{uuid4()}",
            AssumeRolePolicyDocument=json.dumps(
                {
                    "Version":"2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Principal": {"AWS": user.arn},
                            "Action": "sts:AssumeRole",
                        }
                    ],
                }
            ),
        )
        print(f"Created role {role.name}.")
    except ClientError as error:
        print(
            f"Couldn't create a role for the demo. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    try:
        policy = iam_resource.create_policy(
            PolicyName=f"demo-policy-{uuid4()}",
            PolicyDocument=json.dumps(
                {
                    "Version":"2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Action": "s3:ListAllMyBuckets",
                            "Resource": "arn:aws:s3:::*",
                        }
                    ],
                }
            ),
        )
        role.attach_policy(PolicyArn=policy.arn)
        print(f"Created policy {policy.policy_name} and attached it to the role.")
    except ClientError as error:
        print(
            f"Couldn't create a policy and attach it to role {role.name}. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    try:
        user.create_policy(
            PolicyName=f"demo-user-policy-{uuid4()}",
            PolicyDocument=json.dumps(
                {
                    "Version":"2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Action": "sts:AssumeRole",
                            "Resource": role.arn,
                        }
                    ],
                }
            ),
        )
        print(
            f"Created an inline policy for {user.name} that lets the user assume "
            f"the role."
        )
    except ClientError as error:
        print(
            f"Couldn't create an inline policy for user {user.name}. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    print("Give AWS time to propagate these new resources and connections.", end="")
    progress_bar(10)

    return user, user_key, role


def show_access_denied_without_role(user_key):
    """
    Shows that listing buckets without first assuming the role is not allowed.

    :param user_key: The key of the user created during setup. This user does not
                     have permission to list buckets in the account.
    """
    print(f"Try to list buckets without first assuming the role.")
    s3_denied_resource = boto3.resource(
        "s3", aws_access_key_id=user_key.id, aws_secret_access_key=user_key.secret
    )
    try:
        for bucket in s3_denied_resource.buckets.all():
            print(bucket.name)
        raise RuntimeError("Expected to get AccessDenied error when listing buckets!")
    except ClientError as error:
        if error.response["Error"]["Code"] == "AccessDenied":
            print("Attempt to list buckets with no permissions: AccessDenied.")
        else:
            raise


def list_buckets_from_assumed_role(user_key, assume_role_arn, session_name):
    """
    Assumes a role that grants permission to list the Amazon S3 buckets in the account.
    Uses the temporary credentials from the role to list the buckets that are owned
    by the assumed role's account.

    :param user_key: The access key of a user that has permission to assume the role.
    :param assume_role_arn: The Amazon Resource Name (ARN) of the role that
                            grants access to list the other account's buckets.
    :param session_name: The name of the STS session.
    """
    sts_client = boto3.client(
        "sts", aws_access_key_id=user_key.id, aws_secret_access_key=user_key.secret
    )
    try:
        response = sts_client.assume_role(
            RoleArn=assume_role_arn, RoleSessionName=session_name
        )
        temp_credentials = response["Credentials"]
        print(f"Assumed role {assume_role_arn} and got temporary credentials.")
    except ClientError as error:
        print(
            f"Couldn't assume role {assume_role_arn}. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    # Create an S3 resource that can access the account with the temporary credentials.
    s3_resource = boto3.resource(
        "s3",
        aws_access_key_id=temp_credentials["AccessKeyId"],
        aws_secret_access_key=temp_credentials["SecretAccessKey"],
        aws_session_token=temp_credentials["SessionToken"],
    )
    print(f"Listing buckets for the assumed role's account:")
    try:
        for bucket in s3_resource.buckets.all():
            print(bucket.name)
    except ClientError as error:
        print(
            f"Couldn't list buckets for the account. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise




def teardown(user, role):
    """
    Removes all resources created during setup.

    :param user: The demo user.
    :param role: The demo role.
    """
    try:
        for attached in role.attached_policies.all():
            policy_name = attached.policy_name
            role.detach_policy(PolicyArn=attached.arn)
            attached.delete()
            print(f"Detached and deleted {policy_name}.")
        role.delete()
        print(f"Deleted {role.name}.")
    except ClientError as error:
        print(
            "Couldn't detach policy, delete policy, or delete role. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    try:
        for user_pol in user.policies.all():
            user_pol.delete()
            print("Deleted inline user policy.")
        for key in user.access_keys.all():
            key.delete()
            print("Deleted user's access key.")
        user.delete()
        print(f"Deleted {user.name}.")
    except ClientError as error:
        print(
            "Couldn't delete user policy or delete user. Here's why: "
            f"{error.response['Error']['Message']}"
        )


def usage_demo():
    """Drives the demonstration."""
    print("-" * 88)
    print(f"Welcome to the IAM create user and assume role demo.")
    print("-" * 88)
    iam_resource = boto3.resource("iam")
    user = None
    role = None
    try:
        user, user_key, role = setup(iam_resource)
        print(f"Created {user.name} and {role.name}.")
        show_access_denied_without_role(user_key)
        list_buckets_from_assumed_role(user_key, role.arn, "AssumeRoleDemoSession")
    except Exception:
        print("Something went wrong!")
    finally:
        if user is not None and role is not None:
            teardown(user, role)
        print("Thanks for watching!")


if __name__ == "__main__":
    usage_demo()
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API AWS SDK para Python (Boto3)*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/PutUserPolicy)

------
#### [ Ruby ]

**SDK para Ruby**  
 Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/iam#code-examples). 
Crie um usuário e um perfil do IAM que conceda permissão para listar os buckets do Amazon S3. O usuário só tem direitos para assumir a função. Após assumir a função, use credenciais temporárias para listar os buckets para a conta.  

```
# Wraps the scenario actions.
class ScenarioCreateUserAssumeRole
  attr_reader :iam_client

  # @param [Aws::IAM::Client] iam_client: The AWS IAM client.
  def initialize(iam_client, logger: Logger.new($stdout))
    @iam_client = iam_client
    @logger = logger
  end

  # Waits for the specified number of seconds.
  #
  # @param duration [Integer] The number of seconds to wait.
  def wait(duration)
    puts('Give AWS time to propagate resources...')
    sleep(duration)
  end

  # Creates a user.
  #
  # @param user_name [String] The name to give the user.
  # @return [Aws::IAM::User] The newly created user.
  def create_user(user_name)
    user = @iam_client.create_user(user_name: user_name).user
    @logger.info("Created demo user named #{user.user_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info('Tried and failed to create demo user.')
    @logger.info("\t#{e.code}: #{e.message}")
    @logger.info("\nCan't continue the demo without a user!")
    raise
  else
    user
  end

  # Creates an access key for a user.
  #
  # @param user [Aws::IAM::User] The user that owns the key.
  # @return [Aws::IAM::AccessKeyPair] The newly created access key.
  def create_access_key_pair(user)
    user_key = @iam_client.create_access_key(user_name: user.user_name).access_key
    @logger.info("Created accesskey pair for user #{user.user_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't create access keys for user #{user.user_name}.")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  else
    user_key
  end

  # Creates a role that can be assumed by a user.
  #
  # @param role_name [String] The name to give the role.
  # @param user [Aws::IAM::User] The user who is granted permission to assume the role.
  # @return [Aws::IAM::Role] The newly created role.
  def create_role(role_name, user)
    trust_policy = {
      Version: '2012-10-17',
      Statement: [{
        Effect: 'Allow',
        Principal: { 'AWS': user.arn },
        Action: 'sts:AssumeRole'
      }]
    }.to_json
    role = @iam_client.create_role(
      role_name: role_name,
      assume_role_policy_document: trust_policy
    ).role
    @logger.info("Created role #{role.role_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't create a role for the demo. Here's why: ")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  else
    role
  end

  # Creates a policy that grants permission to list S3 buckets in the account, and
  # then attaches the policy to a role.
  #
  # @param policy_name [String] The name to give the policy.
  # @param role [Aws::IAM::Role] The role that the policy is attached to.
  # @return [Aws::IAM::Policy] The newly created policy.
  def create_and_attach_role_policy(policy_name, role)
    policy_document = {
      Version: '2012-10-17',
      Statement: [{
        Effect: 'Allow',
        Action: 's3:ListAllMyBuckets',
        Resource: 'arn:aws:s3:::*'
      }]
    }.to_json
    policy = @iam_client.create_policy(
      policy_name: policy_name,
      policy_document: policy_document
    ).policy
    @iam_client.attach_role_policy(
      role_name: role.role_name,
      policy_arn: policy.arn
    )
    @logger.info("Created policy #{policy.policy_name} and attached it to role #{role.role_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't create a policy and attach it to role #{role.role_name}. Here's why: ")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  end

  # Creates an inline policy for a user that lets the user assume a role.
  #
  # @param policy_name [String] The name to give the policy.
  # @param user [Aws::IAM::User] The user that owns the policy.
  # @param role [Aws::IAM::Role] The role that can be assumed.
  # @return [Aws::IAM::UserPolicy] The newly created policy.
  def create_user_policy(policy_name, user, role)
    policy_document = {
      Version: '2012-10-17',
      Statement: [{
        Effect: 'Allow',
        Action: 'sts:AssumeRole',
        Resource: role.arn
      }]
    }.to_json
    @iam_client.put_user_policy(
      user_name: user.user_name,
      policy_name: policy_name,
      policy_document: policy_document
    )
    puts("Created an inline policy for #{user.user_name} that lets the user assume role #{role.role_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't create an inline policy for user #{user.user_name}. Here's why: ")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  end

  # Creates an Amazon S3 resource with specified credentials. This is separated into a
  # factory function so that it can be mocked for unit testing.
  #
  # @param credentials [Aws::Credentials] The credentials used by the Amazon S3 resource.
  def create_s3_resource(credentials)
    Aws::S3::Resource.new(client: Aws::S3::Client.new(credentials: credentials))
  end

  # Lists the S3 buckets for the account, using the specified Amazon S3 resource.
  # Because the resource uses credentials with limited access, it may not be able to
  # list the S3 buckets.
  #
  # @param s3_resource [Aws::S3::Resource] An Amazon S3 resource.
  def list_buckets(s3_resource)
    count = 10
    s3_resource.buckets.each do |bucket|
      @logger.info "\t#{bucket.name}"
      count -= 1
      break if count.zero?
    end
  rescue Aws::Errors::ServiceError => e
    if e.code == 'AccessDenied'
      puts('Attempt to list buckets with no permissions: AccessDenied.')
    else
      @logger.info("Couldn't list buckets for the account. Here's why: ")
      @logger.info("\t#{e.code}: #{e.message}")
      raise
    end
  end

  # Creates an AWS Security Token Service (AWS STS) client with specified credentials.
  # This is separated into a factory function so that it can be mocked for unit testing.
  #
  # @param key_id [String] The ID of the access key used by the STS client.
  # @param key_secret [String] The secret part of the access key used by the STS client.
  def create_sts_client(key_id, key_secret)
    Aws::STS::Client.new(access_key_id: key_id, secret_access_key: key_secret)
  end

  # Gets temporary credentials that can be used to assume a role.
  #
  # @param role_arn [String] The ARN of the role that is assumed when these credentials
  #                          are used.
  # @param sts_client [AWS::STS::Client] An AWS STS client.
  # @return [Aws::AssumeRoleCredentials] The credentials that can be used to assume the role.
  def assume_role(role_arn, sts_client)
    credentials = Aws::AssumeRoleCredentials.new(
      client: sts_client,
      role_arn: role_arn,
      role_session_name: 'create-use-assume-role-scenario'
    )
    @logger.info("Assumed role '#{role_arn}', got temporary credentials.")
    credentials
  end

  # Deletes a role. If the role has policies attached, they are detached and
  # deleted before the role is deleted.
  #
  # @param role_name [String] The name of the role to delete.
  def delete_role(role_name)
    @iam_client.list_attached_role_policies(role_name: role_name).attached_policies.each do |policy|
      @iam_client.detach_role_policy(role_name: role_name, policy_arn: policy.policy_arn)
      @iam_client.delete_policy(policy_arn: policy.policy_arn)
      @logger.info("Detached and deleted policy #{policy.policy_name}.")
    end
    @iam_client.delete_role({ role_name: role_name })
    @logger.info("Role deleted: #{role_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't detach policies and delete role #{role.name}. Here's why:")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  end

  # Deletes a user. If the user has inline policies or access keys, they are deleted
  # before the user is deleted.
  #
  # @param user [Aws::IAM::User] The user to delete.
  def delete_user(user_name)
    user = @iam_client.list_access_keys(user_name: user_name).access_key_metadata
    user.each do |key|
      @iam_client.delete_access_key({ access_key_id: key.access_key_id, user_name: user_name })
      @logger.info("Deleted access key #{key.access_key_id} for user '#{user_name}'.")
    end

    @iam_client.delete_user(user_name: user_name)
    @logger.info("Deleted user '#{user_name}'.")
  rescue Aws::IAM::Errors::ServiceError => e
    @logger.error("Error deleting user '#{user_name}': #{e.message}")
  end
end

# Runs the IAM create a user and assume a role scenario.
def run_scenario(scenario)
  puts('-' * 88)
  puts('Welcome to the IAM create a user and assume a role demo!')
  puts('-' * 88)
  user = scenario.create_user("doc-example-user-#{Random.uuid}")
  user_key = scenario.create_access_key_pair(user)
  scenario.wait(10)
  role = scenario.create_role("doc-example-role-#{Random.uuid}", user)
  scenario.create_and_attach_role_policy("doc-example-role-policy-#{Random.uuid}", role)
  scenario.create_user_policy("doc-example-user-policy-#{Random.uuid}", user, role)
  scenario.wait(10)
  puts('Try to list buckets with credentials for a user who has no permissions.')
  puts('Expect AccessDenied from this call.')
  scenario.list_buckets(
    scenario.create_s3_resource(Aws::Credentials.new(user_key.access_key_id, user_key.secret_access_key))
  )
  puts('Now, assume the role that grants permission.')
  temp_credentials = scenario.assume_role(
    role.arn, scenario.create_sts_client(user_key.access_key_id, user_key.secret_access_key)
  )
  puts('Here are your buckets:')
  scenario.list_buckets(scenario.create_s3_resource(temp_credentials))
  puts("Deleting role '#{role.role_name}' and attached policies.")
  scenario.delete_role(role.role_name)
  puts("Deleting user '#{user.user_name}', policies, and keys.")
  scenario.delete_user(user.user_name)
  puts('Thanks for watching!')
  puts('-' * 88)
rescue Aws::Errors::ServiceError => e
  puts('Something went wrong with the demo.')
  puts("\t#{e.code}: #{e.message}")
end

run_scenario(ScenarioCreateUserAssumeRole.new(Aws::IAM::Client.new)) if $PROGRAM_NAME == __FILE__
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API AWS SDK para Ruby*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/PutUserPolicy)

------
#### [ Rust ]

**SDK para Rust**  
 Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples). 

```
use aws_config::meta::region::RegionProviderChain;
use aws_sdk_iam::Error as iamError;
use aws_sdk_iam::{config::Credentials as iamCredentials, config::Region, Client as iamClient};
use aws_sdk_s3::Client as s3Client;
use aws_sdk_sts::Client as stsClient;
use tokio::time::{sleep, Duration};
use uuid::Uuid;

#[tokio::main]
async fn main() -> Result<(), iamError> {
    let (client, uuid, list_all_buckets_policy_document, inline_policy_document) =
        initialize_variables().await;

    if let Err(e) = run_iam_operations(
        client,
        uuid,
        list_all_buckets_policy_document,
        inline_policy_document,
    )
    .await
    {
        println!("{:?}", e);
    };

    Ok(())
}

async fn initialize_variables() -> (iamClient, String, String, String) {
    let region_provider = RegionProviderChain::first_try(Region::new("us-west-2"));

    let shared_config = aws_config::from_env().region(region_provider).load().await;
    let client = iamClient::new(&shared_config);
    let uuid = Uuid::new_v4().to_string();

    let list_all_buckets_policy_document = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"s3:ListAllMyBuckets\",
                    \"Resource\": \"arn:aws:s3:::*\"}]
    }"
    .to_string();
    let inline_policy_document = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"sts:AssumeRole\",
                    \"Resource\": \"{}\"}]
    }"
    .to_string();

    (
        client,
        uuid,
        list_all_buckets_policy_document,
        inline_policy_document,
    )
}

async fn run_iam_operations(
    client: iamClient,
    uuid: String,
    list_all_buckets_policy_document: String,
    inline_policy_document: String,
) -> Result<(), iamError> {
    let user = iam_service::create_user(&client, &format!("{}{}", "iam_demo_user_", uuid)).await?;
    println!("Created the user with the name: {}", user.user_name());
    let key = iam_service::create_access_key(&client, user.user_name()).await?;

    let assume_role_policy_document = "{
        \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Principal\": {\"AWS\": \"{}\"},
                    \"Action\": \"sts:AssumeRole\"
                }]
            }"
    .to_string()
    .replace("{}", user.arn());

    let assume_role_role = iam_service::create_role(
        &client,
        &format!("{}{}", "iam_demo_role_", uuid),
        &assume_role_policy_document,
    )
    .await?;
    println!("Created the role with the ARN: {}", assume_role_role.arn());

    let list_all_buckets_policy = iam_service::create_policy(
        &client,
        &format!("{}{}", "iam_demo_policy_", uuid),
        &list_all_buckets_policy_document,
    )
    .await?;
    println!(
        "Created policy: {}",
        list_all_buckets_policy.policy_name.as_ref().unwrap()
    );

    let attach_role_policy_result =
        iam_service::attach_role_policy(&client, &assume_role_role, &list_all_buckets_policy)
            .await?;
    println!(
        "Attached the policy to the role: {:?}",
        attach_role_policy_result
    );

    let inline_policy_name = format!("{}{}", "iam_demo_inline_policy_", uuid);
    let inline_policy_document = inline_policy_document.replace("{}", assume_role_role.arn());
    iam_service::create_user_policy(&client, &user, &inline_policy_name, &inline_policy_document)
        .await?;
    println!("Created inline policy.");

    //First, fail to list the buckets with the user.
    let creds = iamCredentials::from_keys(key.access_key_id(), key.secret_access_key(), None);
    let fail_config = aws_config::from_env()
        .credentials_provider(creds.clone())
        .load()
        .await;
    println!("Fail config: {:?}", fail_config);
    let fail_client: s3Client = s3Client::new(&fail_config);
    match fail_client.list_buckets().send().await {
        Ok(e) => {
            println!("This should not run. {:?}", e);
        }
        Err(e) => {
            println!("Successfully failed with error: {:?}", e)
        }
    }

    let sts_config = aws_config::from_env()
        .credentials_provider(creds.clone())
        .load()
        .await;
    let sts_client: stsClient = stsClient::new(&sts_config);
    sleep(Duration::from_secs(10)).await;
    let assumed_role = sts_client
        .assume_role()
        .role_arn(assume_role_role.arn())
        .role_session_name(format!("iam_demo_assumerole_session_{uuid}"))
        .send()
        .await;
    println!("Assumed role: {:?}", assumed_role);
    sleep(Duration::from_secs(10)).await;

    let assumed_credentials = iamCredentials::from_keys(
        assumed_role
            .as_ref()
            .unwrap()
            .credentials
            .as_ref()
            .unwrap()
            .access_key_id(),
        assumed_role
            .as_ref()
            .unwrap()
            .credentials
            .as_ref()
            .unwrap()
            .secret_access_key(),
        Some(
            assumed_role
                .as_ref()
                .unwrap()
                .credentials
                .as_ref()
                .unwrap()
                .session_token
                .clone(),
        ),
    );

    let succeed_config = aws_config::from_env()
        .credentials_provider(assumed_credentials)
        .load()
        .await;
    println!("succeed config: {:?}", succeed_config);
    let succeed_client: s3Client = s3Client::new(&succeed_config);
    sleep(Duration::from_secs(10)).await;
    match succeed_client.list_buckets().send().await {
        Ok(_) => {
            println!("This should now run successfully.")
        }
        Err(e) => {
            println!("This should not run. {:?}", e);
            panic!()
        }
    }

    //Clean up.
    iam_service::detach_role_policy(
        &client,
        assume_role_role.role_name(),
        list_all_buckets_policy.arn().unwrap_or_default(),
    )
    .await?;
    iam_service::delete_policy(&client, list_all_buckets_policy).await?;
    iam_service::delete_role(&client, &assume_role_role).await?;
    println!("Deleted role {}", assume_role_role.role_name());
    iam_service::delete_access_key(&client, &user, &key).await?;
    println!("Deleted key for {}", key.user_name());
    iam_service::delete_user_policy(&client, &user, &inline_policy_name).await?;
    println!("Deleted inline user policy: {}", inline_policy_name);
    iam_service::delete_user(&client, &user).await?;
    println!("Deleted user {}", user.user_name());

    Ok(())
}
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API AWS SDK para Rust*.
  + [AttachRolePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.attach_role_policy)
  + [CreateAccessKey](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_access_key)
  + [CreatePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_policy)
  + [CreateRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_role)
  + [CreateUser](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_user)
  + [DeleteAccessKey](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_access_key)
  + [DeletePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_policy)
  + [DeleteRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_role)
  + [DeleteUser](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_user)
  + [DeleteUserPolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_user_policy)
  + [DetachRolePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.detach_role_policy)
  + [PutUserPolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.put_user_policy)

------

# Use um perfil do IAM para conceder permissões a aplicações em execução em instâncias do Amazon EC2
<a name="id_roles_use_switch-role-ec2"></a>

As aplicações executadas na instância do Amazon EC2 devem incluir credenciais da AWS nas solicitações de API da AWS. Você poderia fazer com que os desenvolvedores armazenassem as credenciais da AWS diretamente na instância do Amazon EC2 e permitissem que as aplicações nessa instância usassem essas credenciais. Contudo, os desenvolvedores teriam que gerenciar as credenciais e garantir a transmissão segura das credenciais para cada instância e atualização de cada instância do Amazon EC2 na hora certa para fazer a atualização das credenciais. Isso é muito trabalho adicional.

Em vez disso, você pode e deve usar um perfil do IAM para gerenciar credenciais *temporárias* para aplicações executadas em uma instância do Amazon EC2. Quando você usa um perfil, não é necessário distribuir credenciais de longo prazo (como credenciais de login ou chaves de acesso) para uma instância do Amazon EC2. Em vez disso, a função fornece permissões temporárias que os aplicativos podem usar ao fazer chamadas para outros recursos da AWS. Quando você executa uma instância do Amazon EC2, você especifica uma função do IAM para associar à instância. Os aplicativos que são executados na instância, por sua vez, usam as credenciais temporárias fornecidas pela função para assinar solicitações da API.

O uso de perfis para conceder permissões a aplicações que são executadas em instâncias do Amazon EC2 exige configuração adicional. Um aplicativo em execução em uma instância do Amazon EC2 é abstraído da AWS pelo sistema operacional virtualizado. Devido a essa separação adicional, é necessário ter uma etapa adicional para atribuir um perfil da AWS e suas permissões associadas a uma instância do Amazon EC2 e torná-las disponíveis para suas aplicações. Essa etapa adicional é a criação de um *[perfil da instância](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html)* anexado à instância. O perfil da instância contém a função e pode fornecer as credenciais temporárias da função para um aplicativo que é executado na instância. Essas credenciais temporárias podem ser usadas em chamadas da API do aplicativo para acessar recursos e limitar o acesso apenas aos recursos que a função especifica.

**nota**  
Só é possível atribuir um perfil a uma instância do Amazon EC2 por vez, e todas as aplicações na instância compartilham os mesmos perfil e permissões. Ao utilizar o Amazon ECS para gerenciar suas instâncias do Amazon EC2, é possível atribuir perfis às tarefas do Amazon ECS que podem ser diferenciadas do perfil da instância do Amazon EC2 na qual ela está sendo executada. A atribuição de um perfil a cada tarefa se alinha ao princípio do acesso de privilégio mínimo e permite um maior controle granular sobre ações e recursos.  
Para obter mais informações, consulte [Uso de perfis do IAM com tarefas do Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/bestpracticesguide/security-iam-roles.html) no *Guia das práticas recomendadas do Amazon Elastic Container Service*.

Usar funções dessa forma tem vários benefícios. Como as credenciais de perfil são temporárias e atualizadas automaticamente, não é necessário gerenciar credenciais, e você não precisa se preocupar com os riscos de segurança de longo prazo. Além disso, se usar uma única função para várias instâncias, você pode fazer uma alteração nessa função e a alteração se propagará automaticamente para todas as instâncias. 

**nota**  
Embora geralmente um perfil seja atribuído a uma instância do Amazon EC2 quando você a inicia, também é possível anexar um perfil a uma instância do Amazon EC2 que já esteja em execução. Para saber como anexar uma função a uma instância em execução, consulte [Funções do IAM do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).

**Topics**
+ [

## Como os perfis para as instâncias do Amazon EC2 funcionam?
](#roles-usingrole-ec2instance-roles)
+ [

## Permissões necessárias para usar funções com o Amazon EC2
](#roles-usingrole-ec2instance-permissions)
+ [

## Como faço para começar?
](#roles-usingrole-ec2instance-get-started)
+ [

## Informações relacionadas
](#roles-usingrole-ec2instance-related-info)

## Como os perfis para as instâncias do Amazon EC2 funcionam?
<a name="roles-usingrole-ec2instance-roles"></a>

Na figura a seguir, um desenvolvedor executa um aplicativo em uma instância do Amazon EC2 que requer acesso ao bucket do S3 denominado `amzn-s3-demo-bucket-photos`. Um administrador cria o perfil de serviço `Get-pics` e anexa o perfil à instância do Amazon EC2. A função inclui uma política de permissões que concede acesso somente leitura ao bucket do S3 especificado. Ela também inclui uma política de confiança que permite que a instância do Amazon EC2 assuma o perfil e recupere as credenciais temporárias. Quando o aplicativo é executado na instância, ele pode usar as credenciais temporárias da função para acessar o bucket de fotos. O administrador não precisa conceder ao desenvolvedor permissão para acessar o bucket de fotos, e o desenvolvedor nunca precisa compartilhar nem gerenciar as credenciais.

![\[Aplicativo em uma instância do Amazon EC2 que esteja acessando um recurso da AWS\]](http://docs.aws.amazon.com/pt_br/IAM/latest/UserGuide/images/roles-usingrole-ec2roleinstance.png)


1. O administrador usa o IAM para criar a função **Get-pics**. Na política de confiança do perfil, o administrador especifica que apenas as instâncias do Amazon EC2 podem assumir o perfil. Na política de permissões da função, o administrador especifica a permissão somente leitura para o bucket de `amzn-s3-demo-bucket-photos`.

1. Um desenvolvedor inicia uma instância do Amazon EC2 e atribui o perfil `Get-pics` a essa instância.
**nota**  
Se você usar o console do IAM, o perfil da instância será tanto gerenciado quanto mais transparente para você. No entanto, se você usar a AWS CLI ou a API para criar e gerenciar o perfil e a instância do Amazon EC2, será necessário criar o perfil de instância e atribuir o perfil a ela em etapas distintas. Assim, quando você executar a instância, será necessário especificar o nome de perfil da instância em vez do nome da função.

1. Quando a aplicação é executada, ela obtém as credenciais de segurança temporárias dos [metadados da instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) do Amazon EC2, conforme descrito em [Recuperar credenciais de segurança de metadados da instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#instance-metadata-security-credentials). Essas são as [credenciais de segurança temporárias](id_credentials_temp.md) que representam a função e são válidas por um período limitado. 

   Com alguns [SDKs da AWS](https://aws.amazon.com/tools/), o desenvolvedor pode usar um provedor que gerencia as credenciais de segurança temporárias de forma transparente. (A documentação para SDKs individuais da AWS descreve os recursos suportados pelo SDK para o gerenciamento de credenciais).

   Como alternativa, o aplicativo pode obter as credenciais temporárias diretamente dos metadados da instância do Amazon EC2. Credenciais e valores relacionados estão disponíveis na `iam/security-credentials/role-name` categoria (nesse caso, `iam/security-credentials/Get-pics`) dos metadados. Se o aplicativo obtiver as credenciais dos metadados da instância, ele poderá armazenar as credenciais em cache.

1. Ao usar as credenciais temporárias recuperadas, o aplicativo acessa o bucket de fotos. Devido a política anexada à função **Get-pics**, o aplicativo tem permissões somente leitura. 

   As credenciais temporárias de segurança disponíveis na instância são atualizadas automaticamente antes de perder a validade. Assim, há sempre um conjunto válido disponível. O aplicativo só precisa se certificar de receber um novo conjunto de credenciais dos metadados da instância antes que as atuais expirem. É possível usar o SDK da AWS para gerenciar credenciais para que a aplicação não precise incluir uma lógica adicional para atualizar as credenciais. Por exemplo, instanciando clientes com provedores de credenciais de perfis da instância. No entanto, se o aplicativo receber credenciais de segurança temporárias dos metadados da instância e os tiver armazenados em cache, ele deverá obter um conjunto de credenciais atualizadas a cada hora, ou pelo menos 15 minutos antes de o conjunto atual expirar. O tempo de validade está incluído nas informações que são retornadas na categoria `iam/security-credentials/role-name`. 

## Permissões necessárias para usar funções com o Amazon EC2
<a name="roles-usingrole-ec2instance-permissions"></a>

Para iniciar uma instância com um perfil, o desenvolvedor deve ter permissão para iniciar instâncias do Amazon EC2 e para transmitir perfis do IAM.

A política de exemplo a seguir permite que os usuários usem o Console de gerenciamento da AWS para executar uma instância com uma função. A política inclui curingas (`*`) para permitir que um usuário transmita qualquer função e execute as ações listadas do Amazon EC2. A ação `ListInstanceProfiles` permite que os usuários visualizem todas as perfis disponíveis na Conta da AWS.

**Example Exemplo de política que concede a um usuário permissão para usar o console do Amazon EC2 para executar uma instância com qualquer função**    
****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "IamPassRole",
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "iam:PassedToService": "ec2.amazonaws.com"
                }
            }
        },
        {
            "Sid": "ListEc2AndListInstanceProfiles",
            "Effect": "Allow",
            "Action": [
                "iam:ListInstanceProfiles",
                "ec2:Describe*",
                "ec2:Search*",
                "ec2:Get*"
            ],
            "Resource": "*"
        }
    ]
}
```

### Restringir quais perfis podem ser transmitidos para as instâncias do Amazon EC2 (usando PassRole)
<a name="roles-usingrole-ec2instance-passrole"></a>

Você pode usar a permissão `PassRole` para restringir quais perfis um usuário pode transmitir a uma instância do Amazon EC2 quando o usuário inicia a instância. Isso ajuda a evitar que o usuário execute aplicações que tenham mais permissões do que o usuário recebeu, ou seja, de poder obter privilégios elevados. Por exemplo, imagine que a usuária Alice tenha permissões apenas para iniciar instâncias do Amazon EC2 e trabalhar com buckets do Amazon S3, mas o perfil que ela transmite para uma instância do Amazon EC2 tem permissões para trabalhar com o IAM e o Amazon DynamoDB. Nesse caso, Alice pode ser capaz de executar a instância, fazer login nela, obter credenciais de segurança temporárias e, em seguida, executar ações no IAM ou no DynamoDB para as quais ela não tem autorização.

Para restringir quais perfis um usuário pode transmitir para uma instância do Amazon EC2, você cria uma política que permita a ação `PassRole`. Em seguida, anexe a política ao usuário (ou a um grupo do IAM ao qual o usuário pertença) que iniciará as instâncias do Amazon EC2. No elemento `Resource` da política, liste o perfil ou perfis que o usuário tem permissão para transmitir para instâncias do Amazon EC2. Quando o usuário executa uma instância e associa uma função a ela, o Amazon EC2 verifica se o usuário tem permissão para transmitir essa função. Naturalmente, você também deve garantir que a função que o usuário pode transmitir não inclua mais permissões do que o usuário deve ter.

**nota**  
`PassRole` não é uma ação da API da forma que `RunInstances` ou `ListInstanceProfiles` é. Em vez disso, é uma permissão que a AWS verifica sempre que um ARN da função é transmitido como um parâmetro para uma API (ou o console faz isso em nome do usuário). Ele ajuda um administrador a controlar quais funções podem ser transmitidas por quais usuários. Nesse caso, ele garante que o usuário tenha permissão para anexar uma função específica a uma instância do Amazon EC2.

**Example Exemplo de política que concede permissão para um usuário iniciar uma instância do Amazon EC2 com um perfil específico**  
A política de exemplo a seguir permite que os usuários usem a API do Amazon EC2 para executar uma instância com uma função. O elemento `Resource` especifica o nome de recurso da Amazon (ARN) de uma função. Ao especificar o ARN, a política concede ao usuário a permissão para transmitir apenas a função `Get-pics`. Se o usuário tentar especificar uma função diferente ao executar uma instância, a ação falhará. O usuário não tem permissões para executar qualquer instância, independentemente de ele transmitir uma função.    
****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "ec2:RunInstances",
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "arn:aws:iam::111122223333:role/Get-pics"
        }
    ]
}
```

### Permitir que uma função de perfil de instância alterne para uma função em outra conta
<a name="switch-role-ec2-another-account"></a>

Você pode permitir que uma aplicação em execução em uma instância do Amazon EC2 execute comandos em outra conta. Para fazer isso, é necessário permitir que o perfil de instância do Amazon EC2 na primeira conta alterne para um perfil na segunda conta.

Imagine que você esteja usando duas Contas da AWS e queira permitir que uma aplicação em execução em uma instância do Amazon EC2 execute comandos da [AWS CLI](https://aws.amazon.com/cli/) nas duas contas. Vamos supor que a instância do Amazon EC2 exista na conta `111111111111`. Essa instância inclui a função de perfil da instância `abcd` que permite que a aplicação execute tarefas somente leitura do Amazon S3 no bucket `amzn-s3-demo-bucket1` dentro da mesma conta `111111111111`. No entanto, a aplicação também deve ter permissão para assumir a função `efgh` entre contas para acessar o bucket `amzn-s3-demo-bucket2` do Amazon S3 na conta `222222222222`.

![\[O diagrama mostra como um desenvolvedor inicia uma instância do Amazon EC2 com o perfil para obter acesso a fotos em um bucket do Amazon S3.\]](http://docs.aws.amazon.com/pt_br/IAM/latest/UserGuide/images/roles-instance-profile-cross-account.png)


A função de perfil de instância `abcd` do Amazon EC2 deve ter a seguinte política de permissões para permitir que o aplicativo acesse o bucket `amzn-s3-demo-bucket1` do Amazon S3:

***Política de permissões da função `abcd` da conta 111111111111*** 

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowAccountLevelS3Actions",
            "Effect": "Allow",
            "Action": [
                "s3:GetBucketLocation",
                "s3:GetAccountPublicAccessBlock",
                "s3:ListAccessPoints",
                "s3:ListAllMyBuckets"
            ],
            "Resource": "arn:aws:s3:::*"
        },
        {
            "Sid": "AllowListAndReadS3ActionOnMyBucket",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket1/*",
                "arn:aws:s3:::amzn-s3-demo-bucket1"
            ]
        },
        {
            "Sid": "AllowIPToAssumeCrossAccountRole",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Resource": "arn:aws:iam::222222222222:role/efgh"
        }
    ]
}
```

------

A função `abcd` deve confiar no serviço do Amazon EC2 para assumir a função. Para fazer isso, a função `abcd` deve ter a seguinte política de confiança:

***Política de confiança da função `abcd` da conta 111111111111***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "abcdTrustPolicy",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Principal": {"Service": "ec2.amazonaws.com"}
        }
    ]
}
```

------

Vamos supor que a função entre contas `efgh` permita tarefas somente leitura do Amazon S3 no bucket `amzn-s3-demo-bucket2` na mesma conta `222222222222`. Para fazer isso, a função entre contas `efgh` deve ter a seguinte política de permissões:

***Política de permissões da função `efgh` da conta 222222222222***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowAccountLevelS3Actions",
            "Effect": "Allow",
            "Action": [
                "s3:GetBucketLocation",
                "s3:GetAccountPublicAccessBlock",
                "s3:ListAccessPoints",
                "s3:ListAllMyBuckets"
            ],
            "Resource": "arn:aws:s3:::*"
        },
        {
            "Sid": "AllowListAndReadS3ActionOnMyBucket",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket2/*",
                "arn:aws:s3:::amzn-s3-demo-bucket2"
            ]
        }
    ]
}
```

------

A função `efgh` deve confiar na função de perfil de instância `abcd` para assumi-la. Para fazer isso, a função `efgh` deve ter a seguinte política de confiança:

***Política de confiança da função `efgh` da conta 222222222222***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "efghTrustPolicy",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Principal": {"AWS": "arn:aws:iam::111111111111:role/abcd"}
        }
    ]
}
```

------

## Como faço para começar?
<a name="roles-usingrole-ec2instance-get-started"></a>

Para entender como os perfis funcionam com as instâncias do Amazon EC2, é necessário usar o console do IAM para criar um perfil, iniciar uma instância do EC2 que use esse perfil e, em seguida, examinar a instância em execução. Examine os [metadados da instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) para ver como as credenciais temporárias da função são disponibilizadas para uma instância. Você também pode ver como um aplicativo que é executado em uma instância pode usar a função. Use os recursos a seguir para saber mais. 
+ [Tutorial de perfis do IAM em instâncias do Amazon EC2](https://www.youtube.com/watch?v=TlCuOjviOhk). O vídeo vinculado mostra como usar um perfil do IAM com uma instância do Amazon EC2 para controlar o que um aplicativo pode fazer quando ele for executado na instância. O vídeo mostra como a aplicação (gravada no SDK da AWS) pode obter credenciais de segurança temporárias por meio da função. 
+ Demonstrações do SDK. A documentação do AWS SDK inclui demonstrações que mostram um aplicativo em execução em uma instância do Amazon EC2 que usa credenciais temporárias para perfis que fazem a leitura de um bucket do Amazon S3. Cada uma das demonstrações a seguir apresenta etapas semelhantes com uma linguagem de programação diferente:
  + [Configurar funções do IAM para o Amazon EC2 com o SDK for Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java-dg-roles.html) no *Guia do desenvolvedor do AWS SDK para Java* 
  + [Launch an Amazon EC2 Instance using the SDK for .NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/run-instance.html) (Iniciar uma instância do Amazon EC2 usando o SDK para .NET) no *Guia do desenvolvedor do AWS SDK para .NET*
  + [Criar uma instância do Amazon EC2 com o SDK for Ruby](https://docs.aws.amazon.com/sdk-for-ruby/latest/developer-guide/ec2-example-create-instance.html) no *Guia do desenvolvedor do AWS SDK para Ruby*

## Informações relacionadas
<a name="roles-usingrole-ec2instance-related-info"></a>

Para obter mais informações sobre a criação de perfis ou funções para instâncias do Amazon EC2, consulte as seguintes informações:
+ Para obter mais informações sobre [como usar perfis do IAM com instâncias do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html), consulte o *Guia do usuário do Amazon EC2*.
+ Para criar uma função, consulte [Criar um perfil do IAM](id_roles_create.md)
+ Para obter mais informações sobre o uso de credenciais de segurança temporárias, consulte [Credenciais de segurança temporárias no IAM](id_credentials_temp.md).
+ Se você trabalha com a API do IAM ou a CLI, é necessário criar e gerenciar os perfis de instância do IAM. Para obter mais informações sobre os perfis da instância, consulte [Usar perfis de instância](id_roles_use_switch-role-ec2_instance-profiles.md).
+ Para obter mais informações sobre credenciais temporárias de segurança para perfis nos metadados da instância, consulte [Recuperar credenciais de segurança dos metadados da instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#instance-metadata-security-credentials) no *Guia do usuário do Amazon EC2*.

# Usar perfis de instância
<a name="id_roles_use_switch-role-ec2_instance-profiles"></a>

Use um perfil de instância para passar uma função do IAM para uma instância do EC2. Para obter mais informações, consulte [Perfis do IAM para o Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) no *Guia do usuário do Amazon EC2*.

## Gerenciar perfis de instância (console)
<a name="instance-profiles-manage-console"></a>

Se você usar o Console de gerenciamento da AWS para criar uma função para o Amazon EC2, o console criará automaticamente um perfil de instância e dará a ele o mesmo nome da função. Ao usar o console do Amazon EC2 para executar uma instância com uma função do IAM, você pode selecionar uma função para associar à instância. No console, a lista exibida é, na verdade, uma lista de nomes de perfis de instância. O console não cria um perfil de instância para uma função que não esteja associada ao Amazon EC2.

Você pode usar o Console de gerenciamento da AWS para excluir funções do IAM e perfis de instância do Amazon EC2 se a função e o perfil da instância tiverem o mesmo nome. Para saber mais sobre como excluir perfis de instância, consulte [Excluir perfis ou perfis de instância](id_roles_manage_delete.md).

**nota**  
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.

## Gerenciar perfis de instância (AWS CLI ou API da AWS)
<a name="instance-profiles-manage-cli-api"></a>

Se gerenciar suas funções da AWS CLI ou da API da AWS, você criará funções e perfis de instância como ações separadas. Como funções e perfis de instância podem ter nomes diferentes, você precisa saber os nomes de seus perfis de instância, bem como os nomes das funções que eles contêm. Dessa forma, você pode escolher o perfil de instância correto ao executar uma instância do EC2. 

Você pode anexar etiquetas aos seus recursos do IAM, incluindo perfis de instância, para identificar, organizar e controlar o acesso a eles. Os perfis de instância só podem ser marcados quando você usa a AWS CLI ou a API da AWS. 

**nota**  
Um perfil de instância pode conter apenas uma função do IAM, embora uma função possa ser incluída em vários perfis de instância. Esse limite de uma função por perfil de instância não pode ser aumentado. Você pode remover a função existente e, em seguida, adicionar uma função diferente a um perfil de instância. Você deve então esperar que a mudança apareça em toda a AWS devido à [eventual consistency](https://en.wikipedia.org/wiki/Eventual_consistency). Para forçar a alteração, [desassocie o perfil de instância](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html), [associe o perfil de instância](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html), ou interrompa a instância e, em seguida, reinicie-a.

### Gerenciar perfis de instância (AWS CLI)
<a name="instance-profiles-manage-cli"></a>

Você pode usar os seguintes comandos da AWS CLI para trabalhar com perfis de instância em uma conta da AWS. 
+ Criar um perfil de instância: [https://docs.aws.amazon.com/cli/latest/reference/iam/create-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-instance-profile.html)
+ Marcar um perfil de instância: [https://docs.aws.amazon.com/cli/latest/reference/iam/tag-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-instance-profile.html)
+ Listar tags para um perfil de instância: [https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profile-tags.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profile-tags.html)
+ Desmarcar um perfil de instância: [https://docs.aws.amazon.com/cli/latest/reference/iam/untag-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/untag-instance-profile.html)
+ Adicionar uma função a um perfil de instância: [https://docs.aws.amazon.com/cli/latest/reference/iam/add-role-to-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/add-role-to-instance-profile.html) 
+ Listar perfis de instância: [https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles.html), [https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles-for-role.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles-for-role.html) 
+ Obter informações sobre um perfil de instância: [https://docs.aws.amazon.com/cli/latest/reference/iam/get-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/get-instance-profile.html) 
+ Remover uma função de um perfil de instância: [https://docs.aws.amazon.com/cli/latest/reference/iam/remove-role-from-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/remove-role-from-instance-profile.html)
+ Excluir um perfil de instância: [https://docs.aws.amazon.com/cli/latest/reference/iam/delete-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/delete-instance-profile.html) 

Você também pode anexar uma função a uma instância do EC2 já em execução usando os seguintes comandos. Para obter mais informações, consulte [Funções do IAM para o Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).
+ Anexar um perfil de instância com uma função a uma instância do EC2 em execução ou interrompida: [https://docs.aws.amazon.com/cli/latest/reference/ec2/associate-iam-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/associate-iam-instance-profile.html) 
+ Obter informações sobre um perfil de instância anexado a uma instância do EC: [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-iam-instance-profile-associations.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-iam-instance-profile-associations.html) 
+ Desanexar um perfil de instância com uma função de uma instância do EC2 em execução ou interrompida: [https://docs.aws.amazon.com/cli/latest/reference/ec2/disassociate-iam-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/disassociate-iam-instance-profile.html) 

### Gerenciar perfis de instância (API da AWS)
<a name="instance-profiles-manage-api"></a>

Você pode chamar as seguintes operações de API da AWS para trabalhar com perfis de instância em uma Conta da AWS.
+ Criar um perfil de instância: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateInstanceProfile.html) 
+ Marcar um perfil de instância: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html) 
+ Listar tags em um perfil de instância: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html) 
+ Desmarcar um perfil de instância: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html) 
+ Adicionar uma função a um perfil de instância: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_AddRoleToInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AddRoleToInstanceProfile.html) 
+ Listar perfis de instância: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfiles.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfiles.html), [https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfilesForRole.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfilesForRole.html) 
+ Obter informações sobre um perfil de instância: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetInstanceProfile.html) 
+ Remover uma função de um perfil de instância: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_RemoveRoleFromInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_RemoveRoleFromInstanceProfile.html) 
+ Excluir um perfil de instância: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteInstanceProfile.html) 

Você também pode anexar uma função a uma instância do EC2 já em execução chamando as seguintes operações. Para obter mais informações, consulte [Funções do IAM para o Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).
+ Anexar um perfil de instância com uma função a uma instância do EC2 em execução ou interrompida: [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html) 
+ Obter informações sobre um perfil de instância anexado a uma instância do EC: [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeIamInstanceProfileAssociations.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeIamInstanceProfileAssociations.html) 
+ Desanexar um perfil de instância com uma função de uma instância do EC2 em execução ou interrompida: [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html)