

**Esta documentação é somente para a versão 1 da AWS CLI.**

Anunciamos o próximo fim do suporte para a AWS CLI versão 1. É recomendável migrar para a AWS CLI versão 2. Para saber as datas e receber detalhes e informações adicionais sobre como migrar, consulte o [anúncio](https://aws.amazon.com/blogs/developer/cli-v1-maintenance-mode-announcement/). Para obter a documentação relacionada à AWS CLI versão 2, consulte o [Guia do usuário da versão 2](https://docs.aws.amazon.com/cli/latest/userguide/).

# Autenticação e credenciais de acesso para a AWS CLI
<a name="cli-chap-authentication"></a>

É necessário estabelecer como a AWS CLI faz a autenticação com a AWS quando você desenvolve com serviços da AWS. Para configurar credenciais para acesso programático para a AWS CLI, escolha uma das opções a seguir. As opções estão em ordem de recomendação.


****  

| Tipo de autenticação | Finalidade | Instruções | 
| --- | --- | --- | 
| Credenciais de curto prazo para usuários do IAM | Use as credenciais de curto prazo para usuários do IAM, que são mais seguras do que as credenciais de longo prazo. Se suas credenciais estiverem comprometidas, há um tempo limitado para usá-las antes de expirarem. | [Autenticação de credenciais de curto prazo para a AWS CLI](cli-authentication-short-term.md) | 
|  em uma instância do Amazon EC2.  | Use os metadados da instância do Amazon EC2 para consultar credenciais temporárias usando a função atribuída à instância do Amazon EC2. | [Uso de metadados da instância do Amazon EC2 como credenciais na AWS CLI](cli-configure-metadata.md) | 
| Assumir funções para obter permissões | Combine outro método de credencial e assuma um perfil para acesso temporário aos Serviços da AWS ao qual seu usuário talvez não tenha acesso. | [Uso de funções do IAM na AWS CLI](cli-configure-role.md) | 
| Credenciais de longo prazo para usuários do IAM | (Não recomendado) Use credenciais de longo prazo, que não têm prazo de expiração. | [Autenticação usando credenciais de usuário do IAM para a AWS CLI](cli-authentication-user.md) | 
| Armazenamento externo de  | (Não recomendado) Combine outro método de credencial, mas armazene valores de credencial em um local fora da AWS CLI. Esse método é tão seguro quanto o local externo em que as credenciais são armazenadas. | [Credenciais de fornecimento com um processo externo na AWS CLI](cli-configure-sourcing-external.md) | 

## Precedência de credenciais e configurações
<a name="cli-chap-authentication-precedence"></a>

As credenciais e as configurações estão localizadas em vários locais, como variáveis de ambiente do sistema ou do usuário, arquivos de configuração local da AWS, ou explicitamente declaradas na linha de comando como um parâmetro. Certos locais têm precedência sobre outros. As credenciais da AWS CLI e as definições de configuração têm precedência na seguinte ordem:

1. **[Opções da linha de comando](cli-configure-options.md)**: substituem as configurações em qualquer outro local, como nos parâmetros `--region`, `--output` e `--profile`.

1. **[Variáveis de ambiente](cli-configure-envvars.md)**: você pode armazenar valores nas variáveis de ambiente do sistema.

1. **[Assumir perfil](cli-configure-role.md)**: assuma as permissões de um perfil do IAM por meio da configuração ou do comando [https://docs.aws.amazon.com/cli/v1/reference/sts/assume-role.html](https://docs.aws.amazon.com/cli/v1/reference/sts/assume-role.html).

1. **[Assumir perfil com identidade da web](cli-configure-role.md)**: assuma as permissões de um perfil do IAM usando uma identidade da web por meio da configuração ou do comando [https://docs.aws.amazon.com/cli/v1/reference/sts/assume-role-with-web-identity.html](https://docs.aws.amazon.com/cli/v1/reference/sts/assume-role-with-web-identity.html).

1. **[Arquivo de credenciais](cli-configure-files.md)**: os arquivos `credentials` e `config` são atualizados quando você executa o comando `aws configure`. O arquivo `credentials` está localizado em `~/.aws/credentials` no Linux ou MacOS ou em `C:\Users\USERNAME\.aws\credentials` no Windows.

1. **[Processo personalizado](cli-configure-sourcing-external.md)**: obtenha suas credenciais de uma fonte externa.

1. **[Arquivo de configuração](cli-configure-files.md)**: os arquivos `credentials` e `config` são atualizados quando você executa o comando `aws configure`. O arquivo `config` está localizado em `~/.aws/config` no Linux ou MacOS ou em `C:\Users\USERNAME\.aws\config` no Windows.

1. **[Credenciais de container](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html)**: você pode associar uma função do IAM a cada uma das suas definições de tarefa do Amazon Elastic Container Service (Amazon ECS). As credenciais temporárias para essa função estão disponíveis para os contêineres dessa tarefa. Para mais informações, consulte [Funções do IAM para Tarefas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) no *Guia de Desenvolvedor Amazon Elastic Container Service*.

1. **[Credenciais de perfil de instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html)**: você pode associar um perfil do IAM a cada uma das suas instâncias do Amazon Elastic Compute Cloud (Amazon EC2). As credenciais temporárias para essa função estão disponíveis para o código em execução na instância. As credenciais são fornecidas por meio do serviço de metadados do Amazon 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* e [Uso de perfis de instância](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html) no *Guia do usuário do IAM*.

## Tópicos adicionais nesta seção
<a name="cli-chap-authentication-topics"></a>
+ [Autenticação de credenciais de curto prazo para a AWS CLI](cli-authentication-short-term.md)
+ [Uso de funções do IAM na AWS CLI](cli-configure-role.md)
+ [Autenticação usando credenciais de usuário do IAM para a AWS CLI](cli-authentication-user.md)
+ [Uso de metadados da instância do Amazon EC2 como credenciais na AWS CLI](cli-configure-metadata.md)
+ [Credenciais de fornecimento com um processo externo na AWS CLI](cli-configure-sourcing-external.md)

# Autenticação de credenciais de curto prazo para a AWS CLI
<a name="cli-authentication-short-term"></a>

Recomendamos configurar o SDK ou a ferramenta para usar a [autenticação do IAM Identity Center](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html) com opções de duração de sessão estendida. No entanto, você pode copiar e usar credenciais temporárias que estão disponíveis no portal de acesso da AWS. As novas credenciais precisarão ser copiadas quando essas expirarem. É possível usar as credenciais temporárias em um perfil ou usá-las como valores para propriedades do sistema e variáveis de ambiente.

1. [Faça login no portal de acesso da AWS](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosignin.html).

1. Siga [estas instruções](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html) para copiar as credenciais de perfil do IAM do portal de acesso da AWS.

   1. Na etapa 2 das instruções vinculadas, escolha a conta da AWS e o nome do perfil do IAM que concede acesso para suas necessidades de desenvolvimento. Esse perfil normalmente tem um nome como **PowerUserAccess** ou **Developer**. 

   1. Na etapa 4, selecione a opção **Adicionar um perfil ao seu arquivo de credenciais da AWS** e copie o conteúdo. 

1. Crie ou abra o arquivo `credentials` compartilhado. Esse arquivo é `~/.aws/credentials` em sistemas Linux e macOS e `%USERPROFILE%\.aws\credentials` no Windows. Para obter mais informações, consulte [Configurações do arquivo de configuração e credenciais na AWS CLI](cli-configure-files.md). 

1. Adicione o texto a seguir ao arquivo `credentials` compartilhado. Substitua os valores da amostra pelas credenciais que você copiou. 

   ```
   [default] 
   aws_access_key_id = AKIAIOSFODNN7EXAMPLE 
   aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
   aws_session_token = IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
   ```

1. Adicione a região e o formato padrão preferidos ao arquivo `config` compartilhado. 

   ```
   [default]
   region=us-west-2
   output=json
   
   [profile user1]
   region=us-east-1
   output=text
   ```

Quando o SDK cria um cliente de serviço, ele acessa essas credenciais temporárias e as usa para cada solicitação. As configurações do perfil do IAM escolhidas na etapa 2a determinam [por quanto tempo as credenciais temporárias são válidas](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosessionduration.html). A duração máxima é de doze horas.

Repita essas etapas sempre que suas credenciais expirarem.

# Uso de funções do IAM na AWS CLI
<a name="cli-configure-role"></a>

Um [perfil do AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) é uma ferramenta de autorização que permite que um usuário obtenha permissões adicionais (ou diferentes) ou obtenha permissões para executar ações em uma conta diferente da AWS. 

**Topics**
+ [Pré-requisitos](#cli-role-prereqs)
+ [Visão geral do uso de funções do IAM](#cli-role-overview)
+ [Configurar e usar uma função](#cli-role-prepare)
+ [Usar autenticação multifator](#cli-configure-role-mfa)
+ [Funções entre contas e ID externo](#cli-configure-role-xaccount)
+ [Especificar um nome de sessão de função para facilitar a auditoria](#cli-configure-role-session-name)
+ [Assumir a função com a identidade da web](#cli-configure-role-oidc)
+ [Limpar as credenciais em cache](#cli-configure-role-cache)

## Pré-requisitos
<a name="cli-role-prereqs"></a>

Para executar os comandos `iam`, você precisa instalar e configurar a AWS CLI. Isso inclui a configuração de um perfil configurado, presumindo que uma função esteja associada a outro método de credencial. Para obter mais informações, consulte [Instalar, atualizar e desinstalar a AWS CLI](cli-chap-install.md). 

## Visão geral do uso de funções do IAM
<a name="cli-role-overview"></a>

Você pode configurar a AWS Command Line Interface (AWS CLI) para usar uma função do IAM definindo um perfil para a função no arquivo `~/.aws/config`. 

O exemplo a seguir mostra um perfil de função chamado `marketingadmin`. Se você executar comandos com `--profile marketingadmin` (ou especificá-los com a [variável de ambiente AWS\$1PROFILE](cli-configure-envvars.md)), a AWS CLI usará as credenciais definidas em um perfil do `user1` separado para assumir a função com o nome de recurso da Amazon (ARN) `arn:aws:iam::123456789012:role/marketingadminrole`. É possível executar quaisquer operações que forem permitidas pelas permissões atribuídas a essa função.

```
[profile marketingadmin]
role_arn = arn:aws:iam::123456789012:role/marketingadminrole
source_profile = user1
```

Então, é possível especificar um `source_profile` que aponte para um perfil nomeado separado que contenha credenciais de usuário com permissão para usar o perfil. No exemplo anterior, o perfil `marketingadmin` usa as credenciais no perfil `user1`. Quando você especifica que um comando da AWS CLI deve usar o perfil `marketingadmin`, a AWS CLI procura automaticamente as credenciais para o perfil `user1` vinculado e as utiliza para solicitar credenciais temporárias para a função especificada do IAM. A CLI usa a operação [sts:AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) em segundo plano para fazer isso. Essas credenciais temporárias são então usadas para executar o comando da AWS CLI solicitado. A função especificada deve ter políticas de permissão do IAM associadas que permitam a execução do comando da AWS CLI solicitado.

Para executar um comando da AWS CLI em uma instância do Amazon Elastic Compute Cloud (Amazon EC2) ou um contêiner do Amazon Elastic Container Service (Amazon ECS), você pode usar uma função do IAM anexada ao perfil de instância ou ao contêiner. Se você não especificar nenhum perfil ou não definir variáveis de ambiente, essa função será usada diretamente. Isso permite que você evite armazenar chaves de acesso de longa duração em suas instâncias. Também é possível usar essas funções de instância ou contêiner apenas para obter credenciais para outra função. Para isso, use `credential_source` (em vez de `source_profile`) para especificar como localizar as credenciais. O atributo `credential_source` oferece suporte aos seguintes valores:
+ `Environment`: recupera as credenciais de origem de variáveis de ambiente.
+ `Ec2InstanceMetadata`: usa a função do IAM anexada ao perfil de instância do Amazon EC2.
+ `EcsContainer`: usa a função do IAM anexada ao contêiner do Amazon ECS.

O exemplo a seguir mostra a mesma função `marketingadminrole` usada fazendo referência a um perfil de instância do Amazon EC2.

```
[profile marketingadmin]
role_arn = arn:aws:iam::123456789012:role/marketingadminrole
credential_source = Ec2InstanceMetadata
```

Ao invocar uma função, você tem opções adicionais que podem ser exigidas, como o uso de autenticação multifator e um ID externo (usado por empresas de terceiros para acessar os recursos de seus clientes). Também é possível especificar nomes de sessão de função exclusivos que possam ser auditados com mais facilidade nos logs do AWS CloudTrail.

## Configurar e usar uma função
<a name="cli-role-prepare"></a>

Ao executar comandos usando um perfil que especifica uma função do IAM, a AWS CLI usa as credenciais do perfil de origem para chamar AWS Security Token Service (AWS STS) e solicitar credenciais temporárias para a função especificada. O usuário no perfil de origem deve ter permissão para chamar `sts:assume-role` para a função no perfil especificado. A função deve ter uma relação de confiança que permita que o usuário no perfil de origem use a função. Geralmente, o processo de recuperar e depois usar credenciais temporárias para uma função é chamado de *assumir a função*.

É possível criar um perfil no IAM com as permissões que você deseja que os usuários assumam seguindo o procedimento em [Criação de um perfil para conceder permissões a um usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) no *Manual do usuário do AWS Identity and Access Management*. Se a função e o usuário do do perfil de origem estão na mesma conta, é possível inserir seu próprio ID de conta ao configurar a relação de confiança da função.

Depois de criar a função, modifique a relação de confiança para permitir que o usuário assumir . 

O exemplo a seguir mostra uma política de confiança que pode ser associada a uma função. Essa política permite que o perfil seja assumido por qualquer usuário na conta 123456789012, ***se*** o administrador dessa conta conceder explicitamente a permissão `sts:AssumeRole` ao usuário.

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

****  

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

------

A política de confiança não concede permissões. O administrador da conta deve delegar a permissão para assumir a função para usuários individuais, anexando uma política com as permissões apropriadas. O exemplo a seguir mostra uma política que pode ser associada a um usuário, permitindo que ele assuma apenas o perfil `marketingadminrole`. Para obter mais informações sobre como conceder a um usuário acesso para assumir uma função, consulte [Como conceder a um usuário permissão para alternar funções no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_permissions-to-switch.html) no *Manual do usuário do IAM*.

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

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "sts:AssumeRole",
      "Resource": "arn:aws:iam::123456789012:role/marketingadminrole"
    }
  ]
}
```

------

O usuário não precisa ter permissões adicionais para executar os comandos da AWS CLI usando o perfil. Em vez disso, as permissões para executar o comando vêm das associadas à *função*. Você pode associar políticas à função para especificar quais ações podem ser executadas em quais recursos da AWS. Para obter mais informações sobre como associar permissões a um perfil (que funciona de maneira idêntica a um usuário), consulte [Alteração de permissões de um usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html) no *Manual do usuário do IAM*.

Agora que o perfil de função, as permissões de função, a relação de confiança de função e as permissões de usuário estão configurados corretamente, é possível usar a função na linha de comando invocando a opção `--profile`. Por exemplo, o indicado a seguir chama o comando `ls` do Amazon S3 usando as permissões anexadas à função `marketingadmin`, conforme definido no exemplo no início desse tópico.

```
$ aws s3 ls --profile marketingadmin
```

Para usar a função para várias chamadas, defina a variável de ambiente `AWS_PROFILE` para a sessão atual na linha de comando. Enquanto essa variável de ambiente é definida, você não precisa especificar a opção `--profile` em cada comando. 

**Linux ou macOS**

```
$ export AWS_PROFILE=marketingadmin
```

**Windows**

```
C:\> setx AWS_PROFILE marketingadmin
```

Para obter mais informações sobre como configurar usuários e funções, consulte [Identidades do IAM (usuários, grupos de usuários e perfis)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) e [Perfis do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id-roles.html) no *Guia do usuário do IAM*.

## Usar autenticação multifator
<a name="cli-configure-role-mfa"></a>

Para segurança adicional, você pode exigir que os usuários forneçam uma chave única gerada a partir de um dispositivo de autenticação multifator (MFA), um dispositivo U2F ou uma aplicação móvel quando eles tentarem fazer uma chamada usando o perfil de função.

Primeiro, você pode optar por modificar a relação de confiança na função do IAM para exigir MFA. Isso impede que alguém usando a função sem antes autenticar usando MFA. Por exemplo, veja a linha `Condition` no exemplo a seguir. Essa política permite que o usuário chamado `anika` assuma o perfil ao qual a política está anexada, mas somente se ele se autenticar usando MFA. 

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

****  

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

------

Depois, adicione uma linha à função que especifica o perfil do usuário ARN do dispositivo MFA. As entradas do exemplo de arquivo `config` a seguir mostram dois perfis que usam as chaves de acesso para o usuário `anika` solicitar credenciais temporárias para o perfil `cli-role`. O usuário `anika` tem permissão para assumir a função, concedida pela política de confiança da função.

```
[profile role-without-mfa]
region = us-west-2
role_arn= arn:aws:iam::128716708097:role/cli-role
source_profile=cli-user

[profile role-with-mfa]
region = us-west-2
role_arn= arn:aws:iam::128716708097:role/cli-role
source_profile = cli-user
mfa_serial = arn:aws:iam::128716708097:mfa/cli-user

[profile cli-user]
region = us-west-2
output = json
```

A configuração `mfa_serial` pode usar um ARN, conforme mostrado, ou o número de série de um token MFA de hardware.

O primeiro perfil, `role-without-mfa`, não exige MFA. No entanto, como a política de confiança do exemplo anterior anexada à função requer MFA, qualquer tentativa de executar um comando com esse perfil vai falhar.

```
$ aws iam list-users --profile role-without-mfa

An error occurred (AccessDenied) when calling the AssumeRole operation: Access denied
```

A segunda entrada do perfil, `role-with-mfa`, identifica um dispositivo MFA para usar. Quando o usuário tenta executar um comando da AWS CLI com esse perfil, a AWS CLI solicita que o usuário insira a senha de uso único (OTP) fornecida pelo dispositivo MFA. Se a autenticação de MFA for bem-sucedida, o comando executará a operação solicitada. A OTP não é exibida na tela.

```
$ aws iam list-users --profile role-with-mfa
Enter MFA code for arn:aws:iam::123456789012:mfa/cli-user:
{
    "Users": [
        {
            ...
```

## Funções entre contas e ID externo
<a name="cli-configure-role-xaccount"></a>

É possível permitir que os usuários do usem funções que pertençam a diferentes contas ao configurar a função como uma função entre contas. Durante a criação do perfil, defina o tipo de perfil como **Outra conta da AWS**, conforme descrito em [Criar um perfil para conceder permissões a um usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html). Como opção, selecione **Require MFA (Exigir MFA)**. **Require MFA (Exigir MFA)** configura a condição apropriada na relação de confiança, conforme descrito em [Usar autenticação multifator](#cli-configure-role-mfa).

Se usar um [ID externo](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) para fornecer mais controle sobre quem pode usar uma função em todas as contas, você também deverá adicionar o parâmetro `external_id` ao perfil da função. Normalmente, isso é usado somente quando a outra conta é controlada por alguém de fora da sua empresa ou organização.

```
[profile crossaccountrole]
role_arn = arn:aws:iam::234567890123:role/SomeRole
source_profile = default
mfa_serial = arn:aws:iam::123456789012:mfa/saanvi
external_id = 123456
```

## Especificar um nome de sessão de função para facilitar a auditoria
<a name="cli-configure-role-session-name"></a>

Quando muitos indivíduos compartilham uma função, a auditoria torna-se um desafio. É recomendável associar cada operação invocada ao indivíduo que invocou a ação. No entanto, quando o indivíduo usa uma função, a assunção da função por ele é uma ação separada da invocação de uma operação, e é necessário correlacionar manualmente as duas.

É possível simplificar isso especificando nomes de sessão de função exclusivos quando os usuários assumem uma função. Para fazer isso, adicione um parâmetro `role_session_name` a cada perfil nomeado no arquivo `config` que especifica uma função. O valor `role_session_name` é transmitido para a operação `AssumeRole` e se torna parte do ARN da sessão da função. Ele também é incluído nos logs do AWS CloudTrail de todas as operações registradas.

Por exemplo, é possível criar um perfil baseado em função da maneira a seguir. 

```
[profile namedsessionrole]
role_arn = arn:aws:iam::234567890123:role/SomeRole
source_profile = default
role_session_name = Session_Maria_Garcia
```

Isso faz com que a sessão da função tenha o ARN a seguir.

```
arn:aws:iam::234567890123:assumed-role/SomeRole/Session_Maria_Garcia
```

Além disso, todos os logs do AWS CloudTrail incluem o nome da sessão da função nas informações capturadas para cada operação.

## Assumir a função com a identidade da web
<a name="cli-configure-role-oidc"></a>

É possível configurar um perfil para indicar que a AWS CLI deve assumir uma função usando a [federação de identidades da web e o Open ID Connect (OIDC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html). Quando isso é especificado em um perfil, a AWS CLI faz automaticamente a chamada AWS STS `AssumeRoleWithWebIdentity` correspondente para você.

**nota**  
Quando você especifica um perfil que usa uma função do IAM, a AWS CLI faz as chamadas apropriadas para recuperar credenciais temporárias. Essas credenciais são armazenadas em `~/.aws/cli/cache`. Os comandos subsequentes da AWS CLI que especificam o mesmo perfil usam as credenciais temporárias armazenadas em cache até que elas expirem. Nesse ponto, a AWS CLI atualiza automaticamente as credenciais.

Para recuperar e usar credenciais temporárias usando a federação de identidades da web, é possível especificar os valores de configuração a seguir em um perfil compartilhado.

[role\$1arn](#cli-configure-role)  
Especifica o ARN da função a assumir.

web\$1identity\$1token\$1file  
Especifica o caminho para um arquivo que contém um token de acesso OAuth 2.0 ou token de ID OpenID Connect fornecido pelo provedor de identidade. A AWS CLI carrega esse arquivo e transmite seu conteúdo como o argumento `WebIdentityToken` da operação `AssumeRoleWithWebIdentity`.

[role\$1session\$1name](#cli-configure-role-session-name)  
Especifica um nome opcional aplicado a essa sessão assume-role.

Veja a seguir um exemplo da configuração mínima necessária para uma função de admissão com o perfil de identidade da web:

```
# In ~/.aws/config

[profile web-identity]
role_arn=arn:aws:iam:123456789012:role/RoleNameToAssume
web_identity_token_file=/path/to/a/token
```

Também é possível fornecer essa configuração usando [variáveis de ambiente](cli-configure-envvars.md).

AWS\$1ROLE\$1ARN  
O ARN da função a ser assumida

AWS\$1WEB\$1IDENTITY\$1TOKEN\$1FILE  
O caminho para o arquivo de token de identidade da web.

AWS\$1ROLE\$1SESSION\$1NAME  
O nome aplicado a essa sessão assume-role.

**nota**  
No momento, essas variáveis de ambiente se aplicam somente à função de admissão com o provedor de identidade da web. Elas não se aplicam à configuração geral do provedor de função.

## Limpar as credenciais em cache
<a name="cli-configure-role-cache"></a>

Quando você usa uma função, a AWS CLI armazena em cache as credenciais temporárias localmente até que elas expirem. Na próxima vez que você tentar usá-las, a AWS CLI tentará renová-las em seu nome. 

Se as credenciais temporárias da função forem [revogadas](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_revoke-sessions.html), elas não serão renovadas automaticamente, e as tentativas de usá-las falharão. No entanto, é possível excluir o cache para forçar a AWS CLI a recuperar novas credenciais.

**Linux ou macOS**

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

**Windows**

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

# Autenticação usando credenciais de usuário do IAM para a AWS CLI
<a name="cli-authentication-user"></a>

**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).

Essa seção explica como definir as configurações básicas com um usuário do IAM. Isso inclui suas credenciais de segurança usando os arquivos `config` e `credentials`. 

**Contents**
+ [Etapa 1: criar o usuário do IAM](#cli-authentication-user-create)
+ [Etapa 2: obter as chaves de acesso](#cli-authentication-user-get)
+ [Etapa 3: configurar a AWS CLI](#cli-authentication-user-configure.title)
  + [Usar o `aws configure`](#cli-authentication-user-configure-wizard)

## Etapa 1: criar o usuário do IAM
<a name="cli-authentication-user-create"></a>

Crie o usuário do IAM seguindo o procedimento de [Criação de usuários do IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html#id_users_create_console) no *Guia do usuário do IAM*. 
+ Em **Opções de permissão**, escolha **Anexar políticas diretamente** para como você deseja atribuir permissões a esse usuário.
+ A maioria dos tutoriais de “Conceitos básicos” do SDK usa o serviço Amazon S3 como exemplo. Para fornecer à aplicação acesso total ao Amazon S3, selecione a política `AmazonS3FullAccess` para anexar a esse usuário.

## Etapa 2: obter as chaves de acesso
<a name="cli-authentication-user-get"></a>

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, selecione **Usuários** e escolha o usuário **`User name`** que você criou anteriormente. 

1. Na página do usuário, selecione a página **Credenciais de segurança**. Depois, em **Chaves de acesso**, selecione **Criar chave de acesso**.

1.  Em **Criar chave de acesso: etapa 1**, escolha **Command Line Interface (CLI)**.

1. Em **Criar chave de acesso: etapa 2**, insira uma tag opcional e selecione **Próximo**. 

1. Em **Criar chave de acesso: etapa 3**, selecione **Baixar arquivo .csv** para salvar um arquivo `.csv` com a chave de acesso e a chave de acesso secreta do usuário do IAM. Você precisará dessas informações posteriormente.

1. Selecione Concluído.

## Etapa 3: configurar a AWS CLI
<a name="cli-authentication-user-configure.title"></a>

Para uso geral, a AWS CLI precisa das seguintes informações:
+ Access key ID (ID da chave de acesso)
+ Secret access key (Chave de acesso secreta)
+ Região da AWS
+ Formato de saída

A AWS CLI armazena essas informações em um *perfil* (um conjunto de configurações) chamado `default` no arquivo `credentials`. Por padrão, as informações neste perfil são usadas quando você executa um comando da AWS CLI que não especifica explicitamente um perfil a ser usado. Para obter mais informações sobre o arquivo `credentials`, consulte [Configurações do arquivo de configuração e credenciais na AWS CLI](cli-configure-files.md).

Para configurar a AWS CLI, use um dos seguintes procedimentos:

**Topics**
+ [Usar o `aws configure`](#cli-authentication-user-configure-wizard)

### Usar o `aws configure`
<a name="cli-authentication-user-configure-wizard"></a>

Para uso geral, o comando `aws configure` é a maneira mais rápida de configurar sua instalação da AWS CLI. Esse assistente de configuração solicita cada informação necessária para começar. A menos que especificado de outra forma usando a opção `--profile`, a AWS CLI armazena essas informações no perfil `default`.

O exemplo a seguir configura um perfil `default` usando valores de amostra. Substitua-os por seus próprios valores, conforme descrito nas seções a seguir.

```
$ aws configure
AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: us-west-2
Default output format [None]: json
```

O exemplo a seguir configura um perfil chamado `userprod` usando valores de amostra. Substitua-os por seus próprios valores, conforme descrito nas seções a seguir.

```
$ aws configure --profile userprod
AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: us-west-2
Default output format [None]: json
```

# Uso de metadados da instância do Amazon EC2 como credenciais na AWS CLI
<a name="cli-configure-metadata"></a>

Quando você executa a AWS CLI em uma instância do Amazon Elastic Compute Cloud (Amazon EC2), é possível simplificar o fornecimento de credenciais aos seus comandos. Cada instância do Amazon EC2 contém metadados que a AWS CLI pode consultar diretamente por credenciais temporárias. Quando uma função do IAM é associada à instância, a AWS CLI recupera de forma automática e segura as credenciais dos metadados da instância. 

Para desabilitar esse serviço, use a variável de ambiente [AWS\$1EC2\$1METADATA\$1DISABLED](cli-configure-envvars.md#envvars-list-AWS_EC2_METADATA_DISABLED).

**Topics**
+ [Pré-requisitos](#cli-configure-metadata-prereqs)
+ [Configuração de um perfil para metadados do Amazon EC2](#cli-configure-metadata-configure)

## Pré-requisitos
<a name="cli-configure-metadata-prereqs"></a>

Para usar credenciais do Amazon EC2 com a AWS CLI, é necessário concluir o seguinte:
+ Instale e configure a AWS CLI. Para ter mais informações, consulte [Instalar, atualizar e desinstalar a AWS CLI](cli-chap-install.md) e [Autenticação e credenciais de acesso para a AWS CLI](cli-chap-authentication.md).
+ Conhecer os arquivos de configuração e os perfis nomeados. Para obter mais informações, consulte [Configurações do arquivo de configuração e credenciais na AWS CLI](cli-configure-files.md). 
+ Você criou uma função do AWS Identity and Access Management (IAM) que tem acesso aos recursos necessários e associou essa função à instância do Amazon EC2 ao iniciá-la. Para obter mais informações, consulte [Políticas do IAM para Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policies-for-amazon-ec2.html) no *Guia do usuário do Amazon EC2* e [Conceder de acesso a recursos da AWS para aplicações executadas em instâncias do Amazon EC2](https://docs.aws.amazon.com/IAM/latest/UserGuide/role-usecase-ec2app.html) no *Guia do usuário do IAM*.

## Configuração de um perfil para metadados do Amazon EC2
<a name="cli-configure-metadata-configure"></a>

Para especificar que você deseja usar as credenciais disponíveis no perfil de instância de hospedagem do Amazon EC2, use a sintaxe a seguir no perfil nomeado em seu arquivo de configuração. Veja as etapas a seguir para obter mais instruções. 

```
[profile profilename]
role_arn = arn:aws:iam::123456789012:role/rolename
credential_source = Ec2InstanceMetadata
region = region
```

1. Crie um perfil em seu arquivo de configuração.

   ```
   [profile profilename]
   ```

1. Adicione a função arn do IAM que tem acesso aos recursos necessários.

   ```
   role_arn = arn:aws:iam::123456789012:role/rolename
   ```

1. Especifique `Ec2InstanceMetadata` como sua fonte de credencial.

   ```
   credential_source = Ec2InstanceMetadata
   ```

1. Defina sua região.

   ```
   region = region
   ```

**Exemplo**

O exemplo a seguir assume o perfil *`marketingadminrole`* e usa a região `us-west-2` em um perfil de instância do Amazon EC2 chamado `marketingadmin`.

```
[profile marketingadmin]
role_arn = arn:aws:iam::123456789012:role/marketingadminrole
credential_source = Ec2InstanceMetadata
region = us-west-2
```

# Credenciais de fornecimento com um processo externo na AWS CLI
<a name="cli-configure-sourcing-external"></a>

**Atenção**  
Este tópico discute as credenciais de fornecimento de um processo externo. Isso poderá ser um risco de segurança se o comando para gerar as credenciais se tornar acessível por processos ou usuários não aprovados. Recomendamos que você use as alternativas seguras compatíveis fornecidas pela AWS CLI e pela AWS para reduzir o risco de comprometer suas credenciais. Certifique-se de proteger o arquivo `config` e todos os arquivos e ferramentas com suporte para impedir a divulgação.  
Certifique-se de que sua ferramenta de credenciais personalizada não grave informações secretas em `StdErr` porque os SDKs e a AWS CLI podem capturar e registrar essas informações, possivelmente expondo-as a usuários não autorizados.

Se você tiver um método para gerar ou procurar credenciais não compatíveis diretamente com a AWS CLI, poderá configurar a AWS CLI para usá-lo definindo a configuração `credential_process` no arquivo `config`. 

Por exemplo, você pode incluir uma entrada semelhante à seguinte no arquivo `config`.

```
[profile developer]
credential_process = /opt/bin/awscreds-custom --username helen
```

**Sintaxe**  
Para criar essa string de uma forma compatível com qualquer sistema operacional, siga estas regras:
+ Se o caminho ou o nome do arquivo contiver um espaço, coloque o caminho completo e o nome do arquivo entre aspas duplas (“ ”). O caminho e o nome do arquivo podem ter somente os caracteres: A–Z a–z 0–9 - \$1 . espaço
+ Se um nome de parâmetro ou um valor de parâmetro tiver um espaço, coloque esse elemento entre aspas duplas (“ ”). Coloque somente o nome ou o valor entre aspas, não o par.
+ Não inclua variáveis de ambiente nas strings. Por exemplo, não inclua `$HOME` ou `%USERPROFILE%`.
+ Não especifique a pasta base como `~`. É necessário especificar o caminho completo.

**Exemplo para Windows**

```
credential_process = "C:\Path\To\credentials.cmd" parameterWithoutSpaces "parameter with spaces"
```

**Exemplo para Linux ou macOS**

```
credential_process = "/Users/Dave/path/to/credentials.sh" parameterWithoutSpaces "parameter with spaces"
```

**Saída esperada do programa de credenciais**

A AWS CLI executa o comando conforme especificado no perfil e lê os dados de `STDOUT`. O comando especificado deverá gerar a saída JSON em `STDOUT` que corresponde à sintaxe a seguir.

```
{
  "Version": 1,
  "AccessKeyId": "an AWS access key",
  "SecretAccessKey": "your AWS secret access key",
  "SessionToken": "the AWS session token for temporary credentials", 
  "Expiration": "ISO8601 timestamp when the credentials expire"
}
```

**nota**  
No momento da elaboração deste documento, a chave `Version` deve ser definida como `1`. Isso pode aumentar ao longo do tempo conforme a estrutura evolui.

A chave `Expiration` é um timestamp no formato [ISO8601](https://en.wikipedia.org/wiki/ISO_8601). Se a chave `Expiration` não estiver presente na saída da ferramenta, a CLI vai supor que as credenciais são em longo prazo que não são atualizadas. Caso contrário, as credenciais serão consideradas temporárias e serão atualizadas automaticamente com a nova execução do comando `credential_process` antes de expirarem.

**nota**  
A AWS CLI ***não*** armazena em cache as credenciais do processo como faz com credenciais assume-role. Se o armazenamento em cache for obrigatório, implemente-o no processo externo.

O processo externo pode retornar um código de retorno diferente de zero para indicar que ocorreu um erro ao recuperar as credenciais.