As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Cadeia de provedores de credenciais padrão no AWS SDK for Java 2.x
<a name="credentials-chain"></a>

A cadeia de provedores de credenciais padrão na pesquisa AWS SDK for Java 2.x automaticamente as AWS credenciais em uma sequência predefinida de locais, permitindo que os aplicativos se autentiquem Serviços da AWS sem especificar explicitamente as fontes de credenciais.

A cadeia de fornecedores de credenciais padrão é implementada pela [DefaultCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/DefaultCredentialsProvider.html)classe. Ela delega sequencialmente a outros provedores de credenciais implementações que verificam a configuração em vários locais. O primeiro provedor de credenciais que consegue encontrar todos os elementos de configuração necessários faz com que a cadeia termine.

Para usar a cadeia de provedores de credenciais padrão para fornecer credenciais temporárias, crie um compilador de clientes de serviço, mas não especifique um provedor de credenciais. O trecho de código a seguir cria um `DynamoDbClient` que usa a cadeia de provedores de credenciais padrão para localizar e recuperar as configurações.

```
// Any external Region configuration is overridden.
// The SDK uses the default credentials provider chain because no specific credentials provider is specified.
Region region = Region.US_WEST_2;
DynamoDbClient ddb = 
    DynamoDbClient.builder()
                  .region(region)
                  .build();
```

## Ordem de recuperação das configurações de credenciais
<a name="credentials-default"></a>

A cadeia de fornecedores de credenciais padrão do SDK para Java 2.x pesquisa a configuração em seu ambiente usando uma sequência predefinida.

1. Propriedades do sistema Java
   + O SDK usa a [SystemPropertyCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/SystemPropertyCredentialsProvider.html)classe para carregar credenciais temporárias das propriedades`aws.accessKeyId`,`aws.secretAccessKey`, e do sistema `aws.sessionToken` Java.
**nota**  
Para mais informações sobre como definir as propriedades de sistema do Java, consulte o tutorial [Propriedades do sistema](https://docs.oracle.com/javase/tutorial/essential/environment/sysprop.html) no site *Tutoriais do Java* oficial.

1. Variáveis de ambiente
   + O SDK usa a [EnvironmentVariableCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/EnvironmentVariableCredentialsProvider.html)classe para carregar credenciais temporárias das variáveis de `AWS_SESSION_TOKEN` ambiente `AWS_ACCESS_KEY_ID``AWS_SECRET_ACCESS_KEY`, e.

1. Token de identidade da web e ARN do perfil do IAM
   + O SDK usa a [WebIdentityTokenFileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/WebIdentityTokenFileCredentialsProvider.html)classe para carregar credenciais assumindo uma função usando um token de identidade da web.
   + O provedor de credenciais procura as seguintes variáveis de ambiente ou propriedades do sistema de JVM:
     + `AWS_WEB_IDENTITY_TOKEN_FILE or aws.webIdentityTokenFile`
     + `AWS_ROLE_ARN` ou `aws.roleArn`
     + `AWS_ROLE_SESSION_NAME` ou `aws.roleSessionName` (opcional)
   + Depois que o SDK adquire os valores, ele chama o AWS Security Token Service (STS) e usa as credenciais temporárias que retorna para assinar as solicitações.
   + Ambientes de tempo de execução, como o Amazon Elastic Kubernetes Service (EKS), disponibilizam automaticamente tokens de identidade da web, permitindo que os aplicativos obtenham AWS SDKs credenciais temporárias. AWS 

1. Os arquivos `credentials` e `config` compartilhados
   + O SDK usa o [ProfileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ProfileCredentialsProvider.html)para carregar as configurações de login único do IAM Identity Center ou credenciais temporárias do `[default]` perfil nos arquivos compartilhados. `credentials` `config` 

     O Guia de referência do AWS SDKs and Tools tem [informações detalhadas](https://docs.aws.amazon.com/sdkref/latest/guide/understanding-sso.html#idccredres) sobre como o SDK for Java funciona com o token de login único do IAM Identity Center para obter credenciais temporárias que o SDK usa para chamar. Serviços da AWS
**nota**  
Os `config` arquivos `credentials` e são compartilhados por várias AWS SDKs ferramentas. Para obter mais informações, consulte [o. aws/credentials and .aws/config](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html)arquivos no Guia de referência de ferramentas AWS SDKs e ferramentas.
   + Como um perfil nos arquivos de `credentials` e `config` compartilhados pode conter muitos conjuntos diferentes de configurações, o `ProfileCredentialsProvider` delega a uma série de outros provedores para procurar as configurações no perfil `[default]`:
     + **Credenciais de token de identidade da web** (classe `WebIdentityTokenCredentialsProvider`): quando o perfil contém `role_arn` e `web_identity_token_file`.
     + **Credenciais de SSO** (classe `SsoCredentialsProvider`): quando o perfil contém propriedades relacionadas ao SSO, como `sso_role_name` e `sso_account_id`.
     + **Credenciais baseadas em perfis com perfil de origem** (classe `StsAssumeRoleCredentialsProvider`): quando o perfil contém `role_arn` e `source_profile`.
     + **Credenciais baseadas em perfis com origem de credenciais** (classe `StsAssumeRoleWithSourceCredentialsProvider`): quando o perfil contém `role_arn` e `credential_source`. 
       + Quando `credential_source = Environment`: é usada uma cadeia de `SystemPropertyCredentialsProvider` e `EnvironmentVariableCredentialsProvider`
       + Quando `credential_source = Ec2InstanceMetadata`: é usado `InstanceProfileCredentialsProvider`
       + Quando `credential_source = EcsContainer`: é usado `ContainerCredentialsProvider`
     + **Credenciais de login do console** (classe`LoginCredentialsProvider`): quando o perfil contém `login_session` 
     + **Credenciais de processo** (classe `ProcessCredentialsProvider`): quando o perfil contém `credential_process`.
     + **Credenciais de sessão** (classe `StaticSessionCredentialsProvider`): quando o perfil contém `aws_access_key_id`, `aws_secret_access_key` e `aws_session_token`.
     + **Credenciais básicas** (classe `StaticCredentialsProvider`): quando o perfil contém `aws_access_key_id` e `aws_secret_access_key`.

1.  Amazon ECS credenciais de contêiner
   + O SDK usa a [ContainerCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ContainerCredentialsProvider.html)classe para carregar credenciais temporárias usando as seguintes variáveis de ambiente:

     1. `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` ou `AWS_CONTAINER_CREDENTIALS_FULL_URI`

     1. `AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE` ou `AWS_CONTAINER_AUTHORIZATION_TOKEN`

   O agente de contêiner do ECS define automaticamente a variável de ambiente `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI`, que aponta para o endpoint de credenciais do ECS. As outras variáveis de ambiente geralmente são definidas em cenários específicos em que o endpoint padrão da credencial do ECS não é usado.

1.  Amazon EC2 credenciais fornecidas pela função IAM da instância
   + O SDK usa a [InstanceProfileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/InstanceProfileCredentialsProvider.html)classe para carregar credenciais temporárias do serviço de Amazon EC2 metadados.

1. Se o SDK não conseguir encontrar as configurações necessárias por meio de todas as etapas listadas acima, ele lançará uma exceção com uma saída semelhante à seguinte:

   ```
   software.amazon.awssdk.core.exception.SdkClientException: Unable to load credentials from any of the providers 
   in the chain AwsCredentialsProviderChain(credentialsProviders=[SystemPropertyCredentialsProvider(), 
   EnvironmentVariableCredentialsProvider(), WebIdentityTokenCredentialsProvider(), ProfileCredentialsProvider(), 
   ContainerCredentialsProvider(), InstanceProfileCredentialsProvider()])
   ```

## Usar o `DefaultCredentialsProvider` no código
<a name="default-credentials-provider-in-code"></a>

Você pode usar explicitamente a cadeia de provedores de credenciais padrão no código. Funcionalmente, isso equivale a você não especificar nenhum provedor de credenciais, já que o SDK usa `DefaultCredentialsProvider` por padrão. No entanto, o uso explícito pode tornar seu código mais legível e autodocumentado. Isso mostra claramente sua intenção de usar a cadeia de credenciais padrão.

```
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;

public class ExplicitDefaultCredentialsExample {
    public static void main(String[] args) {
        // Explicitly create the DefaultCredentialsProvider.
        DefaultCredentialsProvider defaultCredentialsProvider = DefaultCredentialsProvider
                                                                    .builder().build();

        // Use it with any service client.
        S3Client s3Client = S3Client.builder()
            .region(Region.US_WEST_2)
            .credentialsProvider(defaultCredentialsProvider)
            .build();

        // Now you can use the client with the default credentials chain.
        s3Client.listBuckets();
    }
}
```

Ao criar o provedor de credenciais padrão, você pode fornecer mais configurações:

```
DefaultCredentialsProvider customizedProvider = DefaultCredentialsProvider.builder()
    .profileName("custom-profile")  // Use a specific profile if the chain gets to the `ProfileCredentialsProvider` stage.
    .asyncCredentialUpdateEnabled(true)  // Enable async credential updates.
    .build();
```

Essa abordagem oferece mais controle e, ao mesmo tempo, fornece a conveniência da cadeia de credenciais padrão.