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á.
# Usando provedores de credenciais no AWS SDK for Java 2.x
A função de um provedor de credenciais no AWS SDK for Java 2.x é fornecer e fornecer credenciais aos clientes do SDK. AWS service (Serviço da AWS) O SDK usa as credenciais que ele gera para se autenticar no serviço assinando criptograficamente cada solicitação. As credenciais geralmente consistem em chaves de acesso; uma combinação do ID de uma chave de acesso e uma chave de acesso secreta.
Quando você usa credenciais temporárias, que são usadas quando você configura a configuração do [provedor de token SSO](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config) ou configura seu tempo de execução para [assumir uma função IAM (AWS Identity and Access Management)](https://docs.aws.amazon.com/sdkref/latest/guide/access-assume-role.html#credOrSourceAssumeRole) como exemplos, um token de sessão é adicionado às chaves de acesso, fornecendo acesso por tempo limitado aos recursos. AWS
Este tópico aborda várias maneiras de permitir que o SDK acesse as credenciais.
**Topics**
+ [Trabalho de desenvolvimento interativo](credentials-temporary.md)
+ [Cadeia de fornecedores de credenciais padrão](credentials-chain.md)
+ [Armazenamento em cache de credenciais](credential-caching.md)
+ [Especificar um provedor de credenciais específico](credentials-providers.md)
+ [Use perfis de configuração compartilhada](credentials-profiles.md)
+ [Usar um processo externo](credentials-process.md)
+ [Fornecer credenciais no código](credentials-explicit.md)
+ [Ler credenciais de perfil do IAM no Amazon EC2](ec2-iam-roles.md)
# Acesse as credenciais para o trabalho de desenvolvimento interativo usando AWS SDK for Java 2.x
Para aumentar a segurança, AWS recomenda que você configure o SDK for Java [para usar credenciais temporárias](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) em vez de credenciais de longa duração. As credenciais temporárias consistem em uma chave de acesso (ID de chave de acesso e chave de acesso secreta) e um token de sessão.
Várias abordagens estão disponíveis para você trabalhar com credenciais temporárias. A abordagem que você usa e, portanto, a configuração que você fornece ao SDK, depende do seu caso de uso.
Ao fazer um trabalho de desenvolvimento interativo com o Java SDK, recomendamos que você use as credenciais de login AWS do Console.
## Usando credenciais de login do console
Você pode usar suas credenciais de login existentes do AWS Management Console para acesso programático aos serviços. AWS Depois de um fluxo de autenticação baseado em navegador, AWS gera credenciais temporárias que funcionam em ferramentas de desenvolvimento locais, como o AWS CLI e o SDK for Java 2.x.
Com esse processo, você pode se autenticar usando credenciais raiz criadas durante a configuração inicial da conta, um usuário do IAM ou uma identidade federada do seu provedor de identidade, e ele gerencia AWS CLI automaticamente as credenciais temporárias para você. Essa abordagem aprimora a segurança ao eliminar a necessidade de armazenar credenciais de longo prazo localmente.
Ao executar o comando `aws login`, você pode selecionar entre suas sessões ativas do console ou fazer login por meio do fluxo de autenticação baseado em navegador para que sejam geradas credenciais temporárias automaticamente. O SDK for Java 2.x atualizará automaticamente essas credenciais por até 12 horas.
**Importante**
Além da configuração definida no arquivo de configuração compartilhado que funciona para todos os projetos, cada projeto Java individual requer a seguinte dependência no arquivo `pom.xml` Maven:
```
software.amazon.awssdk
signin
```
A `signin` dependência fornece o código que permite que o SDK for Java 2.x acesse e use as credenciais de login do console.
Para obter mais informações sobre pré-requisitos, login e saída, consulte [Login para desenvolvimento AWS local usando credenciais do console](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sign-in.html) no Guia de referência do *AWS SDK e das ferramentas*.
## Single-sign-on abordagem
Ao fazer um trabalho de desenvolvimento interativo com o Java SDK, você também pode usar a abordagem de login único. Essa abordagem requer a seguinte configuração:
+ [Configurar por meio do Centro de Identidade do IAM](get-started-auth.md#setup-auth)
+ [Configurar um perfil no arquivo de configuração AWS compartilhado](get-started-auth.md#setup-credentials)
+ usando AWS CLI e [executando um comando](get-started-auth.md#setup-login-sso) para fazer login e criar uma sessão ativa
### Configuração do IAM Identify Center
Quando você configura o SDK para usar o acesso de autenticação única do Centro de Identidade do IAM, conforme descrito em [Visão geral da configuração](setup.md#setup-overview) neste guia, o SDK usa credenciais temporárias.
O SDK usa o token de acesso do IAM Identity Center para obter acesso ao perfil do IAM que está configurado com a configuração `sso_role_name` em seu arquivo `config`. O SDK assume esse perfil do IAM e recupera credenciais temporárias para assinar as solicitações de AWS service (Serviço da AWS) .
Para obter mais detalhes sobre como o SDK obtém credenciais temporárias da configuração, consulte a seção [Entendendo a autenticação do IAM Identity Center](https://docs.aws.amazon.com/sdkref/latest/guide/understanding-sso.html) do AWS SDKs Guia de referência de ferramentas.
**Importante**
Além da configuração definida no arquivo de `config` compartilhado que funciona para todos os projetos, cada projeto Java individual requer as seguintes dependências no arquivo `pom.xml` do Maven:
```
software.amazon.awssdk
sso
software.amazon.awssdk
ssooidc
```
As dependências `sso` e `ssooidc` fornecem o código que permite que o SDK para Java 2.x acesse credenciais temporárias.
### Recupere credenciais temporárias do portal de AWS acesso
Como alternativa à configuração de login único do IAM Identity Center, você pode copiar e usar credenciais temporárias disponíveis no AWS portal de acesso. É possível usar as credenciais temporárias em um perfil ou usá-las como valores para propriedades do sistema e variáveis de ambiente.
**Configurar um arquivo de credenciais local para credenciais temporárias**
1. [Criar um arquivo de credenciais compartilhadas](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html)
1. No arquivo de credenciais, cole o texto do espaço reservado a seguir até colar as credenciais temporárias de trabalho.
```
[default]
aws_access_key_id=
aws_secret_access_key=
aws_session_token=
```
1. Salve o arquivo. Agora, o arquivo `~/.aws/credentials` deve existir em seu sistema de desenvolvimento local. Esse arquivo contém o [perfil [padrão]](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile) que o SDK para Java usa se um perfil nomeado específico não for especificado.
1. [Faça login no portal de AWS acesso](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosignin.html)
1. Siga essas instruções no título [Atualização manual de credenciais](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html#how-to-get-temp-credentials) para copiar as credenciais da função do IAM do AWS portal de acesso.
1. Na etapa 2 das instruções vinculadas, escolha `Access keys` como nome do perfil do IAM que concede acesso para suas necessidades de desenvolvimento. Essa função geralmente tem um nome como **PowerUserAccess**ou **Desenvolvedor**.
1. Na caixa de diálogo modal, selecione seu sistema operacional e copie o conteúdo de **Adicionar um perfil ao arquivo de credenciais da AWS **.
1. Cole as credenciais copiadas em seu arquivo `credentials` local e remova o nome do perfil gerado. Seu arquivo deve se parecer com o seguinte.
```
[default]
aws_access_key_id=AKIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token=IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
1. Salve o arquivo `credentials`.
Quando o SDK para Java 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 5a 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.
Depois que as credenciais temporárias expirarem, repita as etapas de 4 a 7.
# Cadeia de provedores de credenciais padrão no AWS SDK for Java 2.x
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 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
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.
# Cache de credenciais no AWS SDK for Java 2.x
O AWS SDK for Java 2.x implementa o armazenamento em cache de credenciais para melhorar o desempenho e reduzir as chamadas para fontes de credenciais. Esta seção explica como o armazenamento em cache de credenciais funciona e como você pode configurá-lo para suas aplicações.
## Noções básicas do armazenamento em cache do provedor de credenciais
Os provedores de credenciais no SDK para Java 2.x usam estratégias de armazenamento em cache diferentes:
+ **Armazenamento em cache interno de credenciais**: muitos provedores armazenam em cache as credenciais que eles recuperam.
+ **Atualização automática**: provedores com credenciais em cache implementam mecanismos de atualização.
### Provedores com armazenamento em cache interno de credenciais
Os seguintes provedores de credenciais armazenam as credenciais em cache internamente, mesmo quando você cria instâncias:
+ **Provedor de credenciais de perfil de instância**: armazena em cache as credenciais do serviço de metadados do Amazon EC2.
+ **Provedor de credenciais de contêiner**: armazena em cache as credenciais do endpoint de metadados do contêiner.
+ **Provedores baseados em STS**: armazene em cache as credenciais temporárias de AWS Security Token Service (STS).
+ **Provedores de tokens de identidade da web**: armazene em cache as credenciais obtidas dos tokens de identidade da web.
+ **Provedor de credenciais de processo**: armazena em cache as credenciais de processos externos.
### Provedores sem armazenamento em cache interno
Os seguintes provedores não implementam o armazenamento em cache interno:
+ **Provedor de credenciais de variáveis de ambiente**
+ **Provedor de credenciais de propriedade do sistema**
+ **Provedor de credenciais estáticas**
## Configurar o armazenamento em cache de credenciais
É possível personalizar o comportamento do armazenamento em cache ao criar provedores de credenciais:
### Tempo de inatividade
Controla quando as credenciais são consideradas inativas e precisam ser atualizadas:
```
.staleTime(Duration.ofMinutes(2)) // Consider stale 2 minutes before expiration.
```
### Tempo de pré-obtenção
Determina quando começar a atualizar as credenciais antes que elas expirem:
```
.prefetchTime(Duration.ofMinutes(10)) // Start refresh 10 minutes before expiration.
```
### Atualizações assíncronas
Permite a atualização de credenciais em segundo plano:
```
.asyncCredentialUpdateEnabled(true) // Refresh credentials in background thread.
```
### Duração da sessão
Para provedores baseados no STS, controla por quanto tempo as credenciais temporárias permanecem válidas:
```
.refreshRequest(r -> r.durationSeconds(3600)) // 1 hour session.
```
## Exemplo de configuração de credenciais armazenadas em cache
Como exemplo de configuração do armazenamento em cache para a implementação de um provedor de credenciais, o SDK pode usar uma thread em segundo plano para a pré-obtenção (recuperação com antecedência) das credenciais antes que elas expirem. Dessa forma, você pode evitar a chamada de bloqueio que recupera novas credenciais.
Veja a seguir um exemplo que cria um `[StsAssumeRoleCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsAssumeRoleCredentialsProvider.html)` que usa uma thread em segundo plano para a pré-obtenção de credenciais definindo a propriedade `[asyncCredentialUpdateEnabled](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsCredentialsProvider.BaseBuilder.html#asyncCredentialUpdateEnabled(java.lang.Boolean))` como `true` no compilador:
```
StsAssumeRoleCredentialsProvider provider = StsAssumeRoleCredentialsProvider.builder()
.refreshRequest(r -> r
.roleArn("arn:aws:iam::111122223333:role/example-role")
.roleSessionName("example-session")
.durationSeconds(3600)) // 1 hour session
.staleTime(Duration.ofMinutes(5)) // Consider stale 5 minutes before expiration
.prefetchTime(Duration.ofMinutes(10)) // Start refresh 10 minutes before expiration
.asyncCredentialUpdateEnabled(true) // Refresh in background
.build();
S3Client s3 = S3Client.builder()
.credentialsProvider(provider)
.build();
```
Quando você invoca uma operação ativada `s3Client` pela primeira vez, uma `[AssumeRoleRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/model/AssumeRoleRequest.html)` é enviada para o AWS Security Token Service (STS). O STS retorna credenciais temporárias válidas por 15 minutos (900 segundos). A instância `s3Client` usa as credenciais armazenadas em cache até a hora de atualizá-las antes de decorridos os 15 minutos. Por padrão, o SDK tenta recuperar novas credenciais para uma nova sessão entre cinco minutos e um minuto antes do prazo de expiração da sessão atual. A janela de pré-obtenção pode ser configurada usando as propriedades `[prefetchTime](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsCredentialsProvider.BaseBuilder.html#prefetchTime(java.time.Duration))` e `[staleTime](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsCredentialsProvider.BaseBuilder.html#staleTime(java.time.Duration))`.
É possível configurar os seguintes provedores de credenciais baseados em sessão da mesma forma:
+ `StsWebIdentityTokenFileCredentialsProvider`
+ `StsGetSessionTokenCredentialsProvider`
+ `StsGetFederationTokenCredentialsProvider`
+ `StsAssumeRoleWithWebIdentityCredentialsProvider`
+ `StsAssumeRoleWithSamlCredentialsProvider`
+ `StsAssumeRoleCredentialsProvider`
+ `DefaultCredentialsProvider` (quando delega ao provedor de credenciais que usa sessões)
+ `ProcessCredentialsProvider`
+ `WebIdentityTokenFileCredentialsProvider`
+ `ContainerCredentialsProvider`
+ `InstanceProfileCredentialsProvider`
Compreender o cache de credenciais ajuda você a otimizar o desempenho e a confiabilidade do seu aplicativo ao trabalhar com. Serviços da AWS
# Especifique um provedor de credenciais específico no AWS SDK for Java 2.x
Embora a cadeia de provedores de credenciais padrão seja conveniente para muitos cenários, especificar explicitamente os provedores de credenciais oferece maior controle sobre o comportamento, o desempenho e a segurança da autenticação.
Os motivos pelos quais é recomendável especificar um provedor de credenciais podem incluir:
+ A cadeia de provedores padrão verifica várias origens sequencialmente, o que pode adicionar latência:
```
// The default provider chain checks might check multiple sources until it finds
// sufficient configuration.
S3Client s3Client = S3Client.builder().build();
// You can specify exactly where to look.
S3Client optimizedClient = S3Client.builder()
.credentialsProvider(InstanceProfileCredentialsProvider.create())
.build();
```
+ Você precisa usar locais não padrão para acessar a configuração de credenciais:
```
// Use configuration from a custom file location.
S3Client s3Client = S3Client.builder()
.credentialsProvider(ProfileCredentialsProvider.builder()
.profileFile(ProfileFile.builder()
.content(Paths.get("/custom/path/to/configuration/file"))
.type(ProfileFile.Type.CONFIGURATION) // Expects all non-default profiles to be prefixed with "profile".
.build())
.profileName("custom")
.build())
.build();
```
+ Use credenciais diferentes para clientes de serviços diferentes. Por exemplo, se seu aplicativo precisar acessar várias AWS contas ou usar permissões diferentes para serviços diferentes:
```
// S3 client using one set of credentials.
S3Client s3Client = S3Client.builder()
.credentialsProvider(ProfileCredentialsProvider.create("s3-readonly"))
.build();
// DynamoDB client using different credentials.
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("dynamodb-admin"))
.build();
```
+ Controle o comportamento de atualização de credenciais:
```
// Create a provider with custom refresh behavior.
StsAssumeRoleCredentialsProvider customRefreshProvider =
StsAssumeRoleCredentialsProvider.builder()
.refreshRequest(AssumeRoleRequest.builder()
.roleArn("arn:aws:iam::123456789012:role/my-role")
.roleSessionName("custom-session")
.build())
.stsClient(StsClient.create())
.asyncCredentialUpdateEnabled(true) // Use a background thread to prefetch credentials.
.build();
S3Client s3Client = S3Client.builder()
.credentialsProvider(customRefreshProvider)
.build();
```
# Use perfis de configuração AWS compartilhados no AWS SDK for Java 2.x
Ao usar o arquivo compartilhado `config` e `credentials`, você pode configurar vários perfis. Isso permite que seu aplicativo use vários conjuntos de configuração de credenciais. O perfil `[default]` foi mencionado anteriormente. O SDK usa a [ProfileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ProfileCredentialsProvider.html)classe para carregar configurações de perfis definidos no `credentials` arquivo compartilhado.
O trecho de código a seguir demonstra como criar um cliente de serviço que usa as configurações definidas como parte do perfil nomeado `my_profile`.
```
Region region = Region.US_WEST_2;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.credentialsProvider(ProfileCredentialsProvider.create("my_profile"))
.build();
```
## Definir um perfil diferente como padrão
Para definir um perfil diferente do perfil `[default]` como padrão para seu aplicativo, defina a variável de ambiente `AWS_PROFILE` com o nome do seu perfil personalizado.
Para definir essa variável no Linux, macOS ou Unix, use `export`:
```
export AWS_PROFILE="other_profile"
```
Para definir essas variáveis no Windows, use :`set`
```
set AWS_PROFILE="other_profile"
```
Como alternativa, defina a propriedade do sistema `aws.profile` Java com o nome do perfil.
## Recarregar credenciais de perfil
Você pode configurar qualquer provedor de credenciais que tenha um método `profileFile()` em seu construtor para recarregar as credenciais do perfil. Essas classes de perfil de credenciais são: `ProfileCredentialsProvider`, `DefaultCredentialsProvider`, `InstanceProfileCredentialsProvider` e `ProfileTokenProvider.`
**nota**
O recarregamento da credencial do perfil funciona somente com as seguintes configurações no arquivo de perfil: `aws_access_key_id`, `aws_secret_access_key` e `aws_session_token`.
Configurações como `region`, `sso_session`, `sso_account_id` e `source_profile` são ignoradas.
Para configurar um provedor de credenciais compatível para recarregar as configurações do perfil, forneça uma instância do [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/profiles/ProfileFileSupplier.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/profiles/ProfileFileSupplier.html) ao método `profileFile()` do construtor. O exemplo de código a seguir demonstra um `ProfileCredentialsProvider` que recarrega as configurações de credenciais do perfil `[default]`.
```
ProfileCredentialsProvider provider = ProfileCredentialsProvider
.builder()
.profileFile(ProfileFileSupplier.defaultSupplier())
.build();
// Set up a service client with the provider instance.
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.region(Region.US_EAST_1)
.credentialsProvider(provider)
.build();
/*
Before dynamoDbClient makes a request, it reloads the credentials settings
by calling provider.resolveCredentials().
*/
```
Quando `ProfileCredentialsProvider.resolveCredentials()` é chamado, o SDK para Java recarrega as configurações. `ProfileFileSupplier.defaultSupplier()` é uma das [várias implementações de conveniência](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/profiles/ProfileFileSupplier.html) do `ProfileFileSupplier` fornecidas pelo SDK. Se seu caso de uso exigir, você pode fornecer sua própria implementação.
O exemplo a seguir mostra o uso do método de conveniência `ProfileFileSupplier.reloadWhenModified()`. `reloadWhenModified()` usa um parâmetro `Path`, o que dá flexibilidade na designação do arquivo de origem para a configuração, em vez do local padrão `~/.aws/credentials` (ou `config`).
As configurações serão recarregadas quando `resolveCredentials()` for chamado somente se o SDK determinar que o conteúdo do arquivo foi modificado.
```
Path credentialsFilePath = ...
ProfileCredentialsProvider provider = ProfileCredentialsProvider
.builder()
.profileFile(ProfileFileSupplier.reloadWhenModified(credentialsFilePath, ProfileFile.Type.CREDENTIALS))
.profileName("my-profile")
.build();
/*
A service client configured with the provider instance calls provider.resolveCredential()
before each request.
*/
```
O método `ProfileFileSupplier.aggregate()` mescla o conteúdo de vários arquivos de configuração. Você decide se um arquivo é recarregado por chamada para o `resolveCredentials()` ou se as configurações de um arquivo são fixadas no momento em que ele foi lido pela primeira vez.
O exemplo a seguir mostra um `DefaultCredentialsProvider` que mescla as configurações de dois arquivos que contêm configurações de perfil. O SDK recarrega as configurações no arquivo apontado pela variável `credentialsFilePath` sempre que `resolveCredentials()` é chamado e as configurações são alteradas. As configurações do objeto `profileFile` permanecem as mesmas.
```
Path credentialsFilePath = ...;
ProfileFile profileFile = ...;
DefaultCredentialsProvider provider = DefaultCredentialsProvider
.builder()
.profileFile(ProfileFileSupplier.aggregate(
ProfileFileSupplier.reloadWhenModified(credentialsFilePath, ProfileFile.Type.CREDENTIALS),
ProfileFileSupplier.fixedProfileFile(profileFile)))
.profileName("my-profile")
.build();
/*
A service client configured with the provider instance calls provider.resolveCredential()
before each request.
*/
```
# Carregue credenciais de um processo externo usando o AWS SDK for Java 2.x
**Atenção**
A seguir, descrevemos um método de obtenção de credenciais temporárias de um processo externo. Isto pode ser potencialmente perigoso, portanto, prossiga com cuidado. É recomendável utilizar outros provedores de credenciais, se possível. Ao usar esta opção, recomendamos que você se certifique de que o arquivo `config` esteja o mais bloqueado possível usando as práticas recomendadas de segurança para seu sistema operacional.
Certifique-se de que sua ferramenta de credenciais personalizadas não grave nenhuma informação secreta em. `StdErr` SDKs e AWS CLI pode capturar e registrar essas informações, potencialmente expondo-as a usuários não autorizados.
Com o SDK para Java 2.x, você pode adquirir credenciais temporárias de um processo externo para casos de uso personalizados. Há duas maneiras de configurar essa funcionalidade.
## Usar a configuração `credential_process`
Se você tiver um método que forneça credenciais temporárias, poderá integrá-lo adicionando a configuração `credential_process` como parte de uma definição de perfil no arquivo `config`. O valor especificado deve usar o caminho completo para o arquivo de comando. Se o caminho do arquivo contiver espaços, você deverá colocá-lo entre aspas.
O SDK chama o comando exatamente como determinado e, em seguida, lê dados JSON de `stdout`.
Os exemplos a seguir mostram o uso dessa configuração para caminhos de arquivo sem espaços e caminhos de arquivo com espaços.
------
#### [ Linux/macOS ]
**Sem espaços no caminho do arquivo**
```
[profile process-credential-profile]
credential_process = /path/to/credential/file/credential_file.sh --custom-command custom_parameter
```
**Espaços no caminho do arquivo**
```
[profile process-credential-profile]
credential_process = "/path/with/space to/credential/file/credential_file.sh" --custom-command custom_parameter
```
------
#### [ Windows ]
**Sem espaços no caminho do arquivo**
```
[profile process-credential-profile]
credential_process = C:\Path\To\credentials.cmd --custom_command custom_parameter
```
**Espaços no caminho do arquivo**
```
[profile process-credential-profile]
credential_process = "C:\Path\With Space To\credentials.cmd" --custom_command custom_parameter
```
------
O trecho de código a seguir demonstra como criar um cliente de serviço que usa as credenciais temporárias definidas como parte do perfil nomeado `process-credential-profile`.
```
Region region = Region.US_WEST_2;
S3Client s3Client = S3Client.builder()
.region(region)
.credentialsProvider(ProfileCredentialsProvider.create("process-credential-profile"))
.build();
```
Para obter informações detalhadas sobre o uso de um processo externo como fonte de credenciais temporárias, consulte a [seção de credenciais do processo no Guia](https://docs.aws.amazon.com/sdkref/latest/guide/feature-process-credentials.html) de referência de ferramentas AWS SDKs e ferramentas.
## Usar um `ProcessCredentialsProvider`
Como alternativa ao uso das configurações no arquivo `config`, você pode usar o `[ProcessCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ProcessCredentialsProvider.html)` de SDKs para carregar credenciais temporárias usando Java.
Os exemplos a seguir mostram várias versões de como especificar um processo externo usando o `ProcessCredentialsProvider` e configurando um cliente de serviço que usa as credenciais temporárias.
------
#### [ Linux/macOS ]
**Sem espaços no caminho do arquivo**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("/path/to/credentials.sh optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
**Espaços no caminho do arquivo**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("/path\\ with\\ spaces\\ to/credentials.sh optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
------
#### [ Windows ]
**Sem espaços no caminho do arquivo**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("C:\\Path\\To\\credentials.exe optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
**Espaços no caminho do arquivo**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("\"C:\\Path\\With Spaces To\\credentials.exe\" optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
------
## Usar o IAM Roles Anywhere para autenticação
O [IAM Roles Anywhere](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/introduction.html) permite AWS service (Serviço da AWS) que você obtenha AWS credenciais temporárias para cargas de trabalho executadas fora do. AWS Ele permite acesso seguro a recursos da AWS de ambientes on-premises ou de outros ambientes de nuvem.
Antes de autenticar solicitações com o IAM Roles Anywhere, primeiro você precisa reunir as informações necessárias e baixar a [ferramenta de assistente de credenciais](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/credential-helper.html). Seguindo as instruções em [Conceitos básicos](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/getting-started.html) no Guia do usuário do IAM Roles Anywhere, você pode criar os artefatos necessários.
O SDK para Java não tem um provedor de credenciais dedicado para recuperar credenciais temporárias do IAM Roles Anywhere, mas você pode usar a ferramenta de assistente de credenciais junto com uma das opções para [recuperar credenciais de um processo externo](#credentials-process).
### Usar a configuração `credential_process` em um perfil
O trecho a seguir no arquivo de AWS configuração compartilhado mostra um perfil chamado `roles_anywhere` que usa a configuração: `credential_process`
```
[profile roles_anywhere]
credential_process = ./aws_signing_helper credential-process \
--certificate /path/to/certificate \
--private-key /path/to/private-key \
--trust-anchor-arn arn:aws:rolesanywhere:region:account:trust-anchor/TA_ID \
--profile-arn arn:aws:rolesanywhere:region:account:profile/PROFILE_ID \
--role-arn arn:aws:iam::account:role/role-name-with-path
```
Você precisa substituir o texto mostrado em vermelho por seus valores depois de reunir todos os artefatos. O primeiro elemento na configuração, `aws_signing_helper`, é o executável da ferramenta de assistente de credenciais e `credential-process` é o comando.
Quando você configura um cliente de serviço para usar o perfil `roles_anywhere`, conforme mostrado no código a seguir, o SDK armazena em cache as credenciais temporárias e as atualiza antes que elas expirem:
```
S3Client s3Client = S3Client.builder()
.credentialsProvider(ProfileCredentialsProvider.builder()
.profileName("roles_anywhere").build())
.build();
```
### Configurar um `ProcessCredentialsProvider`
Conforme mostrado a seguir, é possível usar uma abordagem somente de código com o `ProcessCredentialsProvider` em vez de usar as configurações de perfil:
```
ProcessCredentialsProvider processCredentialsProvider = ProcessCredentialsProvider.builder()
.command("""
./aws_signing_helper credential-process \
--certificate /path/to/certificate \
--private-key /path/to/private-key \
--trust-anchor-arn arn:aws:rolesanywhere:region:account:trust-anchor/TA_ID \
--profile-arn arn:aws:rolesanywhere:region:account:profile/PROFILE_ID \
--role-arn arn:aws:iam::account:role/role-name-with-path
""").build();
S3Client s3Client = S3Client.builder()
.credentialsProvider(processCredentialsProvider)
.build();
```
Substitua o texto mostrado em vermelho por seus valores depois de reunir todos os artefatos.
# Forneça credenciais em código usando o AWS SDK for Java 2.x
Se a cadeia de credenciais padrão, um provedor personalizado ou específico ou a cadeia de fornecedores não funcionar para seu aplicativo, você poderá fornecer as credenciais temporárias diretamente no código. Elas podem ser [credenciais de função do IAM](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html), conforme [descrito acima](credentials-temporary.md#credentials-temporary-from-portal), ou credenciais temporárias recuperadas de AWS Security Token Service ().AWS STS Se você recuperou credenciais temporárias usando AWS STS, forneça-as a um AWS service (Serviço da AWS) cliente conforme mostrado no exemplo de código a seguir.
1. Assuma um perfil chamando `StsClient.assumeRole()`.
1. Crie um [StaticCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/StaticCredentialsProvider.html)objeto e forneça o `AwsSessionCredentials` objeto a ele.
1. Configure o construtor de cliente de serviço com o `StaticCredentialsProvider` e construa o cliente.
O exemplo a seguir cria um cliente de serviço Amazon S3 usando credenciais temporárias retornadas por AWS STS para uma função assumida pelo IAM.
```
// The AWS IAM Identity Center identity (user) who executes this method does not have permission to list buckets.
// The identity is configured in the [default] profile.
public static void assumeRole(String roleArn, String roleSessionName) {
// The IAM role represented by the 'roleArn' parameter can be assumed by identities in two different accounts
// and the role permits the user to only list buckets.
// The SDK's default credentials provider chain will find the single sign-on settings in the [default] profile.
// The identity configured with the [default] profile needs permission to call AssumeRole on the STS service.
try {
Credentials tempRoleCredentials;
try (StsClient stsClient = StsClient.create()) {
AssumeRoleRequest roleRequest = AssumeRoleRequest.builder()
.roleArn(roleArn)
.roleSessionName(roleSessionName)
.build();
AssumeRoleResponse roleResponse = stsClient.assumeRole(roleRequest);
tempRoleCredentials = roleResponse.credentials();
}
// Use the following temporary credential items for the S3 client.
String key = tempRoleCredentials.accessKeyId();
String secKey = tempRoleCredentials.secretAccessKey();
String secToken = tempRoleCredentials.sessionToken();
// List all buckets in the account associated with the assumed role
// by using the temporary credentials retrieved by invoking stsClient.assumeRole().
StaticCredentialsProvider staticCredentialsProvider = StaticCredentialsProvider.create(
AwsSessionCredentials.create(key, secKey, secToken));
try (S3Client s3 = S3Client.builder()
.credentialsProvider(staticCredentialsProvider)
.build()) {
List buckets = s3.listBuckets().buckets();
for (Bucket bucket : buckets) {
System.out.println("bucket name: " + bucket.name());
}
}
} catch (StsException | S3Exception e) {
logger.error(e.getMessage());
System.exit(1);
}
}
```
## Conjuntos de permissões
O seguinte conjunto de permissões definido em Centro de Identidade do AWS IAM permite que a identidade (usuário) execute as duas operações a seguir:
1. A operação `GetObject` do Amazon Simple Storage Service.
1. A operação `AssumeRole` do AWS Security Token Service.
Sem assumir o perfil, o método `s3.listBuckets()` mostrado no exemplo falharia.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"sts:AssumeRole"
],
"Resource": [
"*"
]
}
]
}
```
------
## Função assumida
### Política de permissões do perfil assumido
A política de permissões a seguir é anexada ao perfil assumido no exemplo anterior. Essa política de permissões permite listar todos os buckets na mesma conta do perfil.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListAllMyBuckets"
],
"Resource": [
"*"
]
}
]
}
```
------
### Política de confiança do perfil assumido
A política de confiança a seguir é anexada ao perfil assumido no exemplo anterior. A política permite que o perfil seja assumido por identidades (usuários) em duas contas.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:root",
"arn:aws:iam::555555555555:root"
]
},
"Action": "sts:AssumeRole",
"Condition": {}
}
]
}
```
------
# Ler credenciais de perfil do IAM no Amazon EC2 usando o SDK para Java 2.x
Você pode usar uma função do IAM para gerenciar credenciais temporárias para aplicativos que estão sendo executados em uma instância do EC2 e fazendo solicitações AWS CLI de AWS API. É preferível fazer isso a armazenar chaves de acesso na instância do EC2. Para atribuir uma AWS função a uma instância do EC2 e disponibilizá-la para todos os seus aplicativos, você cria um perfil de instância anexado à instância. Um perfil de instância contém o perfil e permite que os programas em execução na instância do EC2 obtenham credenciais temporárias. Para mais informações, consulte [Utilizar um perfil do IAM para conceder permissões a aplicações em execução nas instâncias do Amazon EC2](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html) no *Guia do usuário do IAM*.
Este tópico fornece informações sobre como configurar seu aplicativo Java para ser executado em uma instância do EC2 e permitir que o AWS SDK for Java 2.x adquira credenciais de IAM função.
## Adquirir credenciais de perfil do IAM do ambiente
Se seu aplicativo criar um cliente AWS de serviço usando o `create` método (ou `builder().build()` métodos), o SDK for Java usará *a cadeia de fornecedores de credenciais padrão*. A cadeia de provedores de credenciais padrão pesquisa no ambiente de execução os elementos de configuração que o SDK pode trocar por credenciais temporárias. A seção [Cadeia de provedores de credenciais padrão no AWS SDK for Java 2.x](credentials-chain.md) descreve o processo completo de pesquisa.
A etapa final na cadeia de fornecedores padrão está disponível somente quando seu aplicativo é executado em uma Amazon EC2 instância. Nesta etapa, o SDK usa um `InstanceProfileCredentialsProvider` para ler o perfil do IAM definido no perfil da instância do EC2. Depois, o SDK adquire credenciais temporárias para esse perfil do IAM.
Embora essas credenciais sejam temporárias e acabem expirando, o `InstanceProfileCredentialsProvider` as atualiza periodicamente para você, de maneira que elas continuem permitindo o acesso à AWS.
## Adquirir credenciais de perfil do IAM programaticamente
Como alternativa à cadeia de provedores de credenciais padrão que eventualmente usa um `InstanceProfileCredentialsProvider` no EC2, você pode configurar um cliente de serviço explicitamente com um `InstanceProfileCredentialsProvider`. Essa abordagem é mostrada no trecho a seguir.
```
S3Client s3 = S3Client.builder()
.credentialsProvider(InstanceProfileCredentialsProvider.create())
.build();
```
## Adquirir com segurança as credenciais de perfil do IAM
Por padrão, as instâncias do EC2 executam o [IMDS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html) (Instance Metadata Service), que permite que o `InstanceProfileCredentialsProvider` do SDK acesse informações como o perfil do IAM que foi configurado. As instâncias do EC2 executam duas versões do IMDS por padrão:
+ Instance Metadata Service versão 1 (IMDSv1) — um método request/response
+ Instance Metadata Service versão 2 (IMDSv2) — um método orientado a sessões
[IMDSv2 é uma abordagem mais segura](https://aws.amazon.com/blogs/security/defense-in-depth-open-firewalls-reverse-proxies-ssrf-vulnerabilities-ec2-instance-metadata-service/) do que IMDSv1.
Por padrão, o Java SDK primeiro tenta obter IMDSv2 a função do IAM, mas se isso falhar, ele tenta IMDSv1. No entanto, como IMDSv1 é menos seguro, AWS recomenda o uso de IMDSv2 somente e desabilitar o SDK de tentar IMDSv1.
Para usar a abordagem mais segura, desative o uso do SDK IMDSv1 fornecendo uma das configurações a seguir com um valor de`true`.
+ Variável de ambiente: `AWS_EC2_METADATA_V1_DISABLED`
+ Propriedade do sistema de JVM: aws.`disableEc2MetadataV1`
+ Configuração do arquivo de configuração compartilhado: `ec2_metadata_v1_disabled`
Com uma dessas configurações definida como`true`, o SDK não carrega as credenciais da função IMDS usando IMDSv1 se a chamada inicial IMDSv2 falhar.