O AWS SDK para Java 1.x chegou end-of-support em 31 de dezembro de 2025. Recomendamos que você migre para o [AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/home.html) para continuar recebendo novos recursos, melhorias de disponibilidade e atualizações de segurança.
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 o AWS SDK para Java
Esta seção fornece informações gerais importantes sobre programação com o AWS SDK para Java que se aplicam a todos os serviços que você pode usar com o SDK.
Para obter informações e exemplos de programação específicos do serviço (para Amazon EC2, Amazon S3 Amazon SWF, etc.), consulte Exemplos de [AWS SDK para Java código](prog-services.md).
**Topics**
+ [Melhores práticas para AWS desenvolvimento com o AWS SDK para Java](best-practices.md)
+ [Criar clientes de serviço](creating-clients.md)
+ [Fornecer credenciais temporárias](credentials.md)
+ [Região da AWS Seleção](java-dg-region-selection.md)
+ [Tratamento de exceções](java-dg-exceptions.md)
+ [Programação assíncrona](basics-async.md)
+ [Registrando AWS SDK para Java chamadas](java-dg-logging.md)
+ [Configuração do cliente](section-client-configuration.md)
+ [Políticas de controle de acesso](java-dg-access-control.md)
+ [Definir o JVM TTL para pesquisas de nome DNS](jvm-ttl-dns.md)
+ [Habilitando métricas para o AWS SDK para Java](generating-sdk-metrics.md)
# Melhores práticas para AWS desenvolvimento com o AWS SDK para Java
As práticas recomendadas a seguir podem ajudá-lo a evitar problemas ou problemas ao desenvolver AWS aplicativos com AWS SDK para Java o. Organizamos as melhores práticas por serviço.
## S3
### Evite ResetExceptions
Ao fazer upload de objetos usando fluxos ( Amazon S3 por meio de um `AmazonS3` cliente ou`TransferManager`), você pode encontrar problemas de conectividade de rede ou de tempo limite. Por padrão, as AWS SDK para Java tentativas de repetir as transferências falharam marcando o fluxo de entrada antes do início de uma transferência e, em seguida, redefinindo-o antes de tentar novamente.
Se o stream não suportar a marcação e a redefinição, o SDK lançará um [ResetException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ResetException.html)quando houver falhas transitórias e as novas tentativas forem ativadas.
**Melhor prática**
Recomendamos usar fluxos que deem suporte a operações de marcar e redefinir.
A maneira mais confiável de evitar a [ResetException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ResetException.html)é fornecer dados usando um [arquivo](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) ou [FileInputStream](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/FileInputStream.html), que eles AWS SDK para Java possam manipular sem serem limitados por limites de marcação e redefinição.
Se o stream não for um [FileInputStream](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/FileInputStream.html), mas oferecer suporte à marcação e à redefinição, você poderá definir o limite de marcas usando o `setReadLimit` método de [RequestClientOptions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/RequestClientOptions.html). O valor padrão é 128 KB. Definir o valor limite de leitura como *um byte maior que o tamanho do fluxo* evitará de forma confiável a. [ResetException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ResetException.html)
Por exemplo, se o tamanho esperado máximo de um fluxo for 100.000 bytes, defina o limite de leitura como 100.001 (100.000 \$1 1) bytes. A marca e a redefinição sempre funcionarão para 100.000 bytes ou menos. Lembre-se de que isso pode fazer alguns fluxos armazenarem em buffer esse número de bytes na memória.
# Criar clientes de serviço
Para fazer solicitações Amazon Web Services, primeiro você cria um objeto de cliente de serviço. A maneira recomendada é usar o compilador de cliente do serviço.
Cada um AWS service (Serviço da AWS) tem uma interface de serviço com métodos para cada ação na API de serviço. Por exemplo, a interface de serviço do DynamoDB é chamada. [AmazonDynamoDBClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/AmazonDynamoDBClient.html) Cada interface de serviço tem um compilador de cliente correspondente que você pode usar para construir uma implementação da interface de serviço. A classe do construtor de clientes DynamoDB se chama [AmazonDynamoDBClientBuilder](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDBClientBuilder.html).
## Obter um compilador de cliente
Para obter uma instância do compilador de cliente, use o método de fábrica estático `standard`, conforme mostrado no exemplo a seguir.
```
AmazonDynamoDBClientBuilder builder = AmazonDynamoDBClientBuilder.standard();
```
Assim que tiver um compilador, será possível personalizar as propriedades do cliente usando muitos setters fluentes na API do compilador. Por exemplo, você pode definir uma região e um provedor de credenciais personalizados da maneira a seguir.
```
AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.withCredentials(new ProfileCredentialsProvider("myProfile"))
.build();
```
**nota**
Os métodos `withXXX` fluentes retornam o objeto `builder`, de maneira que você possa vincular as chamadas ao método por comodidade e um código mais legível. Depois de configurar as propriedades desejadas, você poderá chamar o método `build` para criar o cliente. Assim que for criado, um cliente será imutável, e todas as chamadas para `setRegion` ou `setEndpoint` falharão.
Um compilador pode criar vários clientes com a mesma configuração. Quando você estiver escrevendo o aplicativo, lembre-se de que o compilador será mutável e não será thread-safe.
O código a seguir usa o compilador como uma fábrica para instâncias de cliente.
```
public class DynamoDBClientFactory {
private final AmazonDynamoDBClientBuilder builder =
AmazonDynamoDBClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.withCredentials(new ProfileCredentialsProvider("myProfile"));
public AmazonDynamoDB createClient() {
return builder.build();
}
}
```
[O construtor também expõe configuradores fluentes para [ClientConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html)e [RequestMetricCollector](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/metrics/RequestMetricCollector.html), e uma lista personalizada de 2. RequestHandler](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/handlers/RequestHandler2.html)
Este é um exemplo completo que substitui todas as propriedades configuráveis.
```
AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.withCredentials(new ProfileCredentialsProvider("myProfile"))
.withClientConfiguration(new ClientConfiguration().withRequestTimeout(5000))
.withMetricsCollector(new MyCustomMetricsCollector())
.withRequestHandlers(new MyCustomRequestHandler(), new MyOtherCustomRequestHandler)
.build();
```
## Criar clientes async
AWS SDK para Java Tem clientes assíncronos (ou assíncronos) para cada serviço (exceto para Amazon S3) e um construtor de clientes assíncronos correspondente para cada serviço.
### Para criar um cliente assíncrono do DynamoDB com o padrão ExecutorService
```
AmazonDynamoDBAsync ddbAsync = AmazonDynamoDBAsyncClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.withCredentials(new ProfileCredentialsProvider("myProfile"))
.build();
```
Além das opções de configuração suportadas pelo construtor de clientes síncronos (ou sincronizados), o cliente assíncrono permite que você defina um personalizado [ExecutorFactory](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/client/builder/ExecutorFactory.html)para alterar o `ExecutorService` que o cliente assíncrono usa. `ExecutorFactory`é uma interface funcional, portanto, interopera com expressões lambda e referências de métodos do Java 8.
### Para criar um cliente async com um executor personalizado
```
AmazonDynamoDBAsync ddbAsync = AmazonDynamoDBAsyncClientBuilder.standard()
.withExecutorFactory(() -> Executors.newFixedThreadPool(10))
.build();
```
## Usando DefaultClient
Os compiladores de cliente sync e async têm outro método de fábrica chamado `defaultClient`. Esse método cria um cliente de serviço com a configuração padrão usando a cadeia de fornecedores padrão para carregar credenciais e a Região da AWS. Se as credenciais ou a região não puderem ser determinadas pelo ambiente no qual o aplicativo estiver em execução, a chamada a `defaultClient` falhará. Consulte [Trabalhando com AWS credenciais](credentials.md) e [Região da AWS seleção](java-dg-region-selection.md) para obter mais informações sobre como as credenciais e a região são determinadas.
### Para criar um cliente de serviço padrão
```
AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
```
## Ciclo de vida do cliente
Os clientes de serviço no SDK são thread-safe e, tendo em vista o melhor desempenho, você deve tratá-los como objetos de longa duração. Cada cliente tem o próprio recurso do grupo de conexões. Desligue explicitamente clientes quando eles não são mais necessários para evitar vazamentos de recursos.
Para desligar explicitamente um cliente, chame o método `shutdown`. Depois da chamada de `shutdown`, todos os recursos de cliente serão lançados, e o cliente será inutilizável.
### Para desligar um cliente
```
AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
ddb.shutdown();
// Client is now unusable
```
# Forneça credenciais temporárias ao AWS SDK para Java
Para fazer solicitações Amazon Web Services, você deve fornecer credenciais AWS temporárias para AWS SDK para Java que o use ao chamar os serviços. Isso pode ser feito das seguintes maneiras:
+ Use a cadeia de fornecedores de credenciais padrão *(recomendado)*.
+ Use um fornecedor de credenciais específico ou uma cadeia de fornecedores (ou crie a própria).
+ Forneça você mesmo as credenciais temporárias em código.
## Usar a cadeia de fornecedores de credenciais padrão
[Quando você inicializa um novo cliente de serviço sem fornecer nenhum argumento, ele AWS SDK para Java tenta encontrar credenciais temporárias usando a *cadeia de fornecedores de credenciais padrão* implementada pela classe Default. AWSCredentials ProviderChain](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/DefaultAWSCredentialsProviderChain.html) A cadeia de fornecedores de credenciais padrão procura credenciais nesta ordem:
1. **Variáveis de ambiente**: `AWS_ACCESS_KEY_ID`, `AWS_SECRET_KEY` ou `AWS_SECRET_ACCESS_KEY` e `AWS_SESSION_TOKEN`. O AWS SDK para Java usa a [EnvironmentVariableCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/EnvironmentVariableCredentialsProvider.html)classe para carregar essas credenciais.
1. **Propriedades do sistema Java**: `aws.accessKeyId`, `aws.secretKey` (mas não `aws.secretAccessKey`) e `aws.sessionToken`. O AWS SDK para Java usa o [SystemPropertiesCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/SystemPropertiesCredentialsProvider.html)para carregar essas credenciais.
1. **Credenciais de token de identidade da Web** do ambiente ou contêiner.
1. **O arquivo de perfis de credenciais padrão** - normalmente localizado em `~/.aws/credentials` (a localização pode variar de acordo com a plataforma) e compartilhado por muitos dos AWS SDKs e pelos AWS CLI. O AWS SDK para Java usa o [ProfileCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/profile/ProfileCredentialsProvider.html)para carregar essas credenciais.
Você pode criar um arquivo de credenciais usando o `aws configure` comando fornecido pelo AWS CLI ou pode criá-lo editando o arquivo com um editor de texto. Para obter mais informações sobre o formato do arquivo de credenciais, consulte [Formato do arquivo de credenciais da AWS](#credentials-file-format).
1. **Credenciais de contêiner do Amazon ECS**: carregadas pelo Amazon ECS se a variável de ambiente `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` estiver definida. O AWS SDK para Java usa o [ContainerCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/ContainerCredentialsProvider.html)para carregar essas credenciais. É possível especificar o endereço IP para esse valor.
1. **Credenciais de perfil de instância** — usadas em instâncias do EC2 e fornecidas por meio do serviço de Amazon EC2 metadados. O AWS SDK para Java usa o [InstanceProfileCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/InstanceProfileCredentialsProvider.html)para carregar essas credenciais. É possível especificar o endereço IP para esse valor.
**nota**
As credenciais de perfil de instância serão usadas somente se `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` não estiver definido. Consulte [EC2ContainerCredentialsProviderWrapper](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/EC2ContainerCredentialsProviderWrapper.html) para obter mais informações.
### Configurar credenciais temporárias
Para poder usar credenciais AWS temporárias, elas devem ser definidas em *pelo menos um* dos locais anteriores. Para obter informações sobre como configurar credenciais, consulte os seguintes tópicos:
+ Para especificar credenciais no *ambiente* ou no *arquivo de perfis de credencial* padrão, consulte [Configurar credenciais temporárias](setup-credentials.md#setup-credentials-setting).
+ Para definir as *propriedades de sistema* do Java, consulte o tutorial [Propriedades do sistema](http://docs.oracle.com/javase/tutorial/essential/environment/sysprop.html) no site *Tutoriais do Java* oficial.
+ Para configurar e usar *credenciais de perfil de instância* com suas instâncias do EC2, consulte Como [usar funções do IAM para conceder acesso a AWS recursos em](java-dg-roles.md). Amazon EC2
### Configurar um perfil de credenciais alternativo
O AWS SDK para Java usa o perfil *padrão* por padrão, mas há maneiras de personalizar qual perfil é originado do arquivo de credenciais.
Você pode usar a variável AWS de ambiente Profile para alterar o perfil carregado pelo SDK.
Por exemplo, no Linux, no macOS ou no Unix, você executaria o comando a seguir a fim de alterar o perfil para *myProfile*.
```
export AWS_PROFILE="myProfile"
```
No Windows, você usaria o seguinte.
```
set AWS_PROFILE="myProfile"
```
A configuração da variável de `AWS_PROFILE` ambiente afeta o carregamento de credenciais de todas as ferramentas AWS SDKs e ferramentas oficialmente suportadas (incluindo a AWS CLI e a AWS Tools for Windows PowerShell). Para alterar somente o perfil de um aplicativo Java, você pode usar a propriedade do sistema `aws.profile` em seu lugar.
**nota**
A variável de ambiente tem precedência sobre a propriedade do sistema.
### Configurar um local de arquivo de credenciais alternativo
O AWS SDK para Java carrega credenciais AWS temporárias automaticamente do local padrão do arquivo de credenciais. No entanto, você também pode especificar o local configurando a variável de ambiente `AWS_CREDENTIAL_PROFILES_FILE` com o caminho completo para o arquivo de credenciais.
Você pode usar esse recurso para alterar temporariamente o local em que ele AWS SDK para Java procura seu arquivo de credenciais (por exemplo, definindo essa variável com a linha de comando). Ou você pode definir a variável de ambiente no ambiente de usuário ou sistema a fim de alterá-la para o usuário ou o sistema.
#### Para substituir o local do arquivo de credenciais padrão
+ Defina a variável de `AWS_CREDENTIAL_PROFILES_FILE` ambiente para o local do seu arquivo de AWS credenciais.
+ No Linux, macOS ou Unix, use:
```
export AWS_CREDENTIAL_PROFILES_FILE=path/to/credentials_file
```
+ No Windows, use:
```
set AWS_CREDENTIAL_PROFILES_FILE=path/to/credentials_file
```
### Formato do arquivo `Credentials`
Seguindo as [instruções na Configuração básica](signup-create-iam-user.md#setup-temp-creds) deste guia, seu arquivo de credenciais deve ter o seguinte formato básico.
```
[default]
aws_access_key_id=
aws_secret_access_key=
aws_session_token=
[profile2]
aws_access_key_id=
aws_secret_access_key=
aws_session_token=
```
O nome do perfil é especificado entre colchetes (por exemplo, `[default]`), seguido dos campos configuráveis nesse perfil como pares de chave/valor. Você pode ter vários perfis no arquivo `credentials`, que podem ser adicionados ou editados usando-se `aws configure --profile PROFILE_NAME ` para selecionar o perfil a ser configurado.
Você pode especificar campos adicionais, como `metadata_service_timeout` e `metadata_service_num_attempts`. Eles não são configuráveis com a CLI. Você deverá editar o arquivo manualmente se quiser usá-los. Para obter mais informações sobre o arquivo de configuração e seus campos disponíveis, consulte [Configurando o AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) no Guia do AWS Command Line Interface Usuário.
### Carregar credenciais
Depois que definir as credenciais temporárias, o SDK as carrega usando a cadeia de fornecedores de credenciais padrão.
Para fazer isso, você instancia um AWS service (Serviço da AWS) cliente sem fornecer explicitamente as credenciais ao construtor, da seguinte maneira.
```
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.build();
```
## Especificar um fornecedor de credenciais ou uma cadeia de fornecedores
Você pode especificar um fornecedor de credenciais diferente do fornecedor de credenciais *padrão* usando o compilador de cliente.
Você fornece uma instância de um provedor de credenciais ou cadeia de fornecedores para um criador de clientes que usa uma interface de [AWSCredentialsprovedor](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/AWSCredentialsProvider.html) como entrada. O exemplo a seguir mostra como usar credenciais de *ambiente* mais especificamente.
```
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withCredentials(new EnvironmentVariableCredentialsProvider())
.build();
```
[Para ver a lista completa de provedores AWS SDK para Java de credenciais e cadeias de provedores fornecidos, consulte **Todas as classes de implementação conhecidas** no AWSCredentials provedor.](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/AWSCredentialsProvider.html)
**nota**
Você pode usar essa técnica para fornecer provedores de credenciais ou cadeias de provedores que você cria usando seu próprio provedor de credenciais que implementa a `AWSCredentialsProvider` interface ou subclassificando a classe. [AWSCredentialsProviderChain](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/AWSCredentialsProviderChain.html)
## Especificar explicitamente credenciais temporárias
Se a cadeia de credenciais padrão ou um fornecedor personalizado ou específico ou a cadeia de fornecedores não funcionar para o código, será possível definir credenciais fornecidas explicitamente. Se você recuperou credenciais temporárias usando AWS STS, use esse método para especificar as credenciais de acesso. AWS
1. Instancie a [BasicSessionCredentials](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/BasicSessionCredentials.html)classe e forneça a ela a chave de AWS acesso, a chave AWS secreta e o token de AWS sessão que o SDK usará para a conexão.
1. Crie um [AWSStaticCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/AWSStaticCredentialsProvider.html)com o `AWSCredentials` objeto.
1. Configure o compilador de cliente com o `AWSStaticCredentialsProvider` e compilar o cliente.
Veja um exemplo do a seguir:
```
BasicSessionCredentials awsCreds = new BasicSessionCredentials("access_key_id", "secret_key_id", "session_token");
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withCredentials(new AWSStaticCredentialsProvider(awsCreds))
.build();
```
## Mais informações
+ [Inscreva-se AWS e crie um usuário do IAM](signup-create-iam-user.md)
+ [Configurar AWS credenciais e região para desenvolvimento](setup-credentials.md)
+ [Usando funções do IAM para conceder acesso a AWS recursos em Amazon EC2](java-dg-roles.md)
# Região da AWS Seleção
As regiões permitem que você acesse AWS serviços que residem fisicamente em uma área geográfica específica. Isso pode ser útil para redundância e para manter os dados e os aplicativos em execução próximo ao lugar onde você e os usuários os acessarão.
## Verificar disponibilidade do serviço em uma região
Para ver se um determinado AWS service (Serviço da AWS) está disponível em uma região, use o `isServiceSupported` método na região que você gostaria de usar.
```
Region.getRegion(Regions.US_WEST_2)
.isServiceSupported(AmazonDynamoDB.ENDPOINT_PREFIX);
```
Consulte a documentação da classe [Regions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/regions/Regions.html) das regiões que você pode especificar e usar o prefixo de endpoint do serviço a ser consultado. O prefixo de endpoint de cada serviço é definido na interface de serviço. [Por exemplo, o prefixo do DynamoDB endpoint é definido em AmazonDynamo DB.](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html)
## Escolher uma região
A partir da versão 1.4 do AWS SDK para Java, você pode especificar um nome de região e o SDK escolherá automaticamente um endpoint apropriado para você. Para escolher o endpoint por conta própria, consulte [Escolher um endpoint específico](#region-selection-choose-endpoint).
Para definir explicitamente uma região, recomendamos usar o enum [Regions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/regions/Regions.html). Esta é uma enumeração de todas as regiões disponíveis publicamente. Para criar um cliente com uma região do enum, use o código a seguir.
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.build();
```
Se a região que estiver tentando usar não estiver no enum `Regions`, será possível definir a região usando uma *string* que represente o nome da região.
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.standard()
.withRegion("{region_api_default}")
.build();
```
**nota**
Depois que você compilar um cliente com o compilador, ele será *imutável*, e a região *não poderá ser alterada*. Se você estiver trabalhando com vários Regiões da AWS para o mesmo serviço, deverá criar vários clientes — um por região.
## Escolher um endpoint específico
Cada AWS cliente pode ser configurado para usar um *endpoint específico* em uma região chamando o `withEndpointConfiguration` método ao criar o cliente.
Por exemplo, para configurar o Amazon S3 cliente para usar a região da Europa (Irlanda), use o código a seguir.
```
AmazonS3 s3 = AmazonS3ClientBuilder.standard()
.withEndpointConfiguration(new EndpointConfiguration(
"https://s3.eu-west-1.amazonaws.com",
"eu-west-1"))
.withCredentials(CREDENTIALS_PROVIDER)
.build();
```
Consulte [Regiões e endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html) para ver a lista atual de regiões e seus endpoints correspondentes para todos os AWS serviços.
## Determinar automaticamente a região pelo ambiente
**Importante**
Esta seção se aplica somente ao usar um [construtor de clientes](creating-clients.md) para acessar AWS serviços. AWS os clientes criados usando o construtor do cliente não determinarão automaticamente a região do ambiente e, em vez disso, usarão a região *padrão* do SDK ()USEast1.
Ao executar no Lambda Amazon EC2 ou no Lambda, talvez você queira configurar os clientes para usar a mesma região em que seu código está sendo executado. Isso desvincula o código do ambiente no qual está em execução e facilita ainda mais a implantação do aplicativo em várias regiões tendo em vista menos latência ou redundância.
*Você deve usar compiladores de cliente para que o SDK detecte automaticamente a região onde o código está sendo executado.*
Para usar a cadeia de credential/region fornecedores padrão para determinar a região a partir do ambiente, use o `defaultClient` método do construtor do cliente.
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
```
É o mesmo que usar `standard` seguido de `build`.
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.standard()
.build();
```
Se você não definir explicitamente uma região usando os métodos `withRegion`, o SDK consultará a cadeia de fornecedores da região padrão para tentar determinar a região a ser usada.
### Cadeia de fornecedores da região padrão
**Este é o processo de pesquisa da região:**
1. Qualquer região explícita definida usando-se `withRegion` ou `setRegion` no compilador propriamente dito tem precedência sobre todo o resto.
1. A variável de ambiente `AWS_REGION` está marcada. Se estiver definida, essa região será usada para configurar o cliente.
**nota**
Essa variável de ambiente é definida pelo Lambda contêiner.
1. O SDK verifica o arquivo de configuração AWS compartilhado (geralmente localizado em`~/.aws/config`). Se a propriedade da *região* estiver presente, ela será usada pelo SDK.
+ A variável de ambiente `AWS_CONFIG_FILE` pode ser usada para personalizar o local do arquivo de configuração compartilhado.
+ A variável de ambiente `AWS_PROFILE` ou a propriedade do sistema `aws.profile` pode ser usada para personalizar o perfil carregado pelo SDK.
1. O SDK tenta usar o serviço de metadados da Amazon EC2 instância para determinar a região da instância em execução Amazon EC2 no momento.
1. Se o SDK ainda não tiver encontrado uma região a esta altura, a criação do cliente falhará com uma exceção.
Ao desenvolver AWS aplicativos, uma abordagem comum é usar o *arquivo de configuração compartilhado* (descrito em [Usando a cadeia de fornecedores de credenciais padrão](credentials.md#credentials-default)) para definir a região para o desenvolvimento local e confiar na cadeia de fornecedores da região padrão para determinar a região quando executada na AWS infraestrutura. Isso simplifica muito a criação do cliente e mantém a portabilidade do aplicativo.
# Tratamento de exceções
Entender como e quando AWS SDK para Java as exceções são lançadas é importante para criar aplicativos de alta qualidade usando o SDK. As seções a seguir descrevem os casos diferentes de exceções lançadas pelo SDK e como processá-las da maneira apropriada.
## Por que exceções desmarcadas?
AWS SDK para Java Ele usa exceções de tempo de execução (ou não verificadas) em vez de exceções verificadas pelos seguintes motivos:
+ Como permitir que desenvolvedores controlem os erros que desejam processar sem forçá-los a processar casos excepcionais com os quais não estão preocupados (e tornar o código excessivamente detalhado)
+ Para evitar problemas de escalabilidade inerentes a exceções marcadas em aplicativos grandes
Em geral, as exceções marcadas funcionam bem em escalas pequenas, mas podem se tornar problemáticas à medida que os aplicativos crescem e se tornam mais complexos.
Para obter mais informações sobre o uso de exceções marcadas e desmarcadas, consulte:
+ [Exceções desmarcadas – A controvérsia](http://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html)
+ [O problema com exceções marcadas](http://www.artima.com/intv/handcuffs2.html)
+ [Exceções marcadas do Java foram um equívoco (e aqui está o que eu gostaria de fazer sobre isso)](http://radio-weblogs.com/0122027/stories/2003/04/01/JavasCheckedExceptionsWereAMistake.html)
## AmazonServiceException (e subclasses)
[AmazonServiceException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonServiceException.html)é a exceção mais comum que você enfrentará ao usar AWS SDK para Java o. Essa exceção representa uma resposta de erro de um AWS service (Serviço da AWS). Por exemplo, se você tentar encerrar uma Amazon EC2 instância que não existe, o EC2 retornará uma resposta de erro e todos os detalhes dessa resposta de erro serão incluídos na resposta `AmazonServiceException` lançada. Para alguns casos, uma subclasse de `AmazonServiceException` é lançada para permitir que os desenvolvedores controlem casos de erro por meio de blocos catch.
Ao encontrar um`AmazonServiceException`, você sabe que sua solicitação foi enviada com sucesso para o AWS service (Serviço da AWS) , mas não pôde ser processada com sucesso. Isso pode ocorrer devido a erros nos parâmetros da solicitação ou problemas no lado do serviço.
`AmazonServiceException` fornece informações como:
+ Código de status HTTP retornado
+ Código de AWS erro retornado
+ Mensagem de erro detalhada do serviço
+ AWS ID de solicitação para a solicitação com falha
`AmazonServiceException`também inclui informações sobre se a solicitação com falha foi culpa do chamador (uma solicitação com valores ilegais) ou culpa dele (um erro interno AWS service (Serviço da AWS) do serviço).
## AmazonClientException
[AmazonClientException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonClientException.html)indica que ocorreu um problema dentro do código do cliente Java, ao tentar enviar uma solicitação para AWS ou ao tentar analisar uma resposta de AWS. Um geralmente `AmazonClientException` é mais grave do que um `AmazonServiceException` e indica um grande problema que está impedindo o cliente de fazer chamadas de serviço para AWS os serviços. Por exemplo, AWS SDK para Java ele lança uma, `AmazonClientException` se nenhuma conexão de rede estiver disponível, quando você tenta chamar uma operação em um dos clientes.
# Programação assíncrona
Você pode usar métodos *síncronos* ou *assíncronos* para chamar operações em serviços. AWS Os métodos síncronos bloqueiam a execução do seu thread até o cliente receber uma resposta do serviço. Os métodos assíncronos retornam imediatamente, devolvendo o controle ao thread de chamada sem aguardar uma resposta.
Como um método assíncrono retorna antes de uma resposta estar disponível, você precisa de uma maneira de obter a resposta quando ela estiver pronta. O AWS SDK para Java fornece duas formas: *objetos futuros* e *métodos de retorno* de chamada.
## Futures do Java
*Os métodos assíncronos AWS SDK para Java retornam um objeto [Future](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/Future.html) que contém os resultados da operação assíncrona no futuro.*
Chame o método `Future` `isDone()` para ver se o serviço já forneceu um objeto de resposta. Quando a resposta estiver pronta, você poderá obter o objeto de resposta chamando o método `Future` `get()`. É possível usar esse mecanismo para sondar periodicamente os resultados da operação assíncrona, enquanto o aplicativo continua funcionando em outras atividades.
Aqui está um exemplo de uma operação assíncrona que chama uma Lambda função, recebendo uma `Future` que pode conter um objeto. [InvokeResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/InvokeResult.html) O objeto `InvokeResult` será recuperado somente depois que `isDone()` for `true`.
```
import com.amazonaws.services.lambda.AWSLambdaAsyncClient;
import com.amazonaws.services.lambda.model.InvokeRequest;
import com.amazonaws.services.lambda.model.InvokeResult;
import java.nio.ByteBuffer;
import java.util.concurrent.Future;
import java.util.concurrent.ExecutionException;
public class InvokeLambdaFunctionAsync
{
public static void main(String[] args)
{
String function_name = "HelloFunction";
String function_input = "{\"who\":\"SDK for Java\"}";
AWSLambdaAsync lambda = AWSLambdaAsyncClientBuilder.defaultClient();
InvokeRequest req = new InvokeRequest()
.withFunctionName(function_name)
.withPayload(ByteBuffer.wrap(function_input.getBytes()));
Future future_res = lambda.invokeAsync(req);
System.out.print("Waiting for future");
while (future_res.isDone() == false) {
System.out.print(".");
try {
Thread.sleep(1000);
}
catch (InterruptedException e) {
System.err.println("\nThread.sleep() was interrupted!");
System.exit(1);
}
}
try {
InvokeResult res = future_res.get();
if (res.getStatusCode() == 200) {
System.out.println("\nLambda function returned:");
ByteBuffer response_payload = res.getPayload();
System.out.println(new String(response_payload.array()));
}
else {
System.out.format("Received a non-OK response from {AWS}: %d\n",
res.getStatusCode());
}
}
catch (InterruptedException | ExecutionException e) {
System.err.println(e.getMessage());
System.exit(1);
}
System.exit(0);
}
}
```
## Retornos de chamada assíncronos
Além de usar o `Future` objeto Java para monitorar o status das solicitações assíncronas, o SDK também permite que você implemente uma classe que usa a interface. [AsyncHandler](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/handlers/AsyncHandler.html) `AsyncHandler`fornece dois métodos que são chamados dependendo de como a solicitação foi concluída: `onSuccess` `onError` e.
A principal vantagem da interface da abordagem de interface do retorno de chamada é que ela evita a necessidade de sondar o objeto `Future` para descobrir quando a requisição foi concluída. Em vez disso, o código pode iniciar imediatamente a próxima atividade e contar com o SDK para chamar o handler no momento certo.
```
import com.amazonaws.services.lambda.AWSLambdaAsync;
import com.amazonaws.services.lambda.AWSLambdaAsyncClientBuilder;
import com.amazonaws.services.lambda.model.InvokeRequest;
import com.amazonaws.services.lambda.model.InvokeResult;
import com.amazonaws.handlers.AsyncHandler;
import java.nio.ByteBuffer;
import java.util.concurrent.Future;
public class InvokeLambdaFunctionCallback
{
private class AsyncLambdaHandler implements AsyncHandler
{
public void onSuccess(InvokeRequest req, InvokeResult res) {
System.out.println("\nLambda function returned:");
ByteBuffer response_payload = res.getPayload();
System.out.println(new String(response_payload.array()));
System.exit(0);
}
public void onError(Exception e) {
System.out.println(e.getMessage());
System.exit(1);
}
}
public static void main(String[] args)
{
String function_name = "HelloFunction";
String function_input = "{\"who\":\"SDK for Java\"}";
AWSLambdaAsync lambda = AWSLambdaAsyncClientBuilder.defaultClient();
InvokeRequest req = new InvokeRequest()
.withFunctionName(function_name)
.withPayload(ByteBuffer.wrap(function_input.getBytes()));
Future future_res = lambda.invokeAsync(req, new AsyncLambdaHandler());
System.out.print("Waiting for async callback");
while (!future_res.isDone() && !future_res.isCancelled()) {
// perform some other tasks...
try {
Thread.sleep(1000);
}
catch (InterruptedException e) {
System.err.println("Thread.sleep() was interrupted!");
System.exit(0);
}
System.out.print(".");
}
}
}
```
## Práticas recomendadas
### Execução do retorno de chamada
A implementação de `AsyncHandler` é executada dentro do grupo de threads de propriedade do cliente assíncrono. Resumidamente, o código executado rapidamente é mais apropriado dentro da implementação `AsyncHandler`. Executar por muito tempo ou bloquear código dentro dos métodos handler pode causar contenção do grupo de threads usado pelo cliente assíncrono e evitar que o cliente execute requisições. Se você tiver uma tarefa de longa duração que precise começar de um retorno de chamada, o retorno de chamada deverá executar a tarefa em um novo thread ou em um grupo de threads gerenciado pelo aplicativo.
### Configuração do grupo de threads
Os clientes assíncronos no AWS SDK para Java fornecem um pool de threads padrão que deve funcionar para a maioria dos aplicativos. Você pode implementar um personalizado [ExecutorService](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/ExecutorService.html)e passá-lo para clientes AWS SDK para Java assíncronos para ter mais controle sobre como os grupos de threads são gerenciados.
Por exemplo, você pode fornecer uma `ExecutorService` implementação que usa um personalizado [ThreadFactory](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/ThreadFactory.html)para controlar como os encadeamentos no pool são nomeados ou para registrar informações adicionais sobre o uso do encadeamento.
### Processo assíncrono
A [TransferManager](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/TransferManager.html)classe no SDK oferece suporte assíncrono para trabalhar com. Amazon S3`TransferManager`gerencia uploads e downloads assíncronos, fornece relatórios detalhados sobre o progresso das transferências e oferece suporte a retornos de chamada em diferentes eventos.
# Registrando AWS SDK para Java chamadas
O AWS SDK para Java é instrumentado com o [Apache Commons Logging](http://commons.apache.org/proper/commons-logging/guide.html), que é uma camada de abstração que permite o uso de qualquer um dos vários sistemas de registro em tempo de execução.
Entre os sistemas de registro em log compatíveis estão o Java Logging Framework e o Apache Log4j, entre outros. Este tópico mostra como usar o Log4j. Você pode usar a funcionalidade de registro em log do SDK sem fazer alterações no código do aplicativo.
Para saber mais sobre o [Log4j](http://logging.apache.org/log4j/2.x/), consulte o [site do Apache](http://www.apache.org/).
**nota**
Este tópico se concentra no Log4j 1.x. O Log4j2 não oferece suporte diretamente ao Apache Commons Logging, mas fornece um adaptador que direciona automaticamente chamadas de registro em log para o Log4j2 usando a interface do Apache Commons Logging. Para obter mais informações, consulte [Commons Logging Bridge](https://logging.apache.org/log4j/2.x/log4j-jcl.html) na documentação do Log4j2.
## Fazer download do Log4J JAR
Para usar o Log4j com o SDK, você precisa fazer download do Log4j JAR no site do Apache. O SDK não inclui o JAR. Copie o arquivo JAR para um local no classpath.
O Log4j usa um arquivo de configuração, log4j.properties. Os arquivos de configuração de exemplo são mostrados abaixo. Copie esse arquivo de configuração para um diretório no classpath. O Log4j JAR e o arquivo log4j.properties não precisam estar no mesmo diretório.
O arquivo de configuração log4j.properties especifica propriedades como [nível de registro em log](http://logging.apache.org/log4j/2.x/manual/configuration.html#Loggers), em que a saída do registro em log é enviada (por exemplo, [para um arquivo ou para o console](http://logging.apache.org/log4j/2.x/manual/appenders.html)) e o [formato da saída](http://logging.apache.org/log4j/2.x/manual/layouts.html). O nível de registro em log é a granularidade de saída gerada pelo registrador em log. O Log4j dá suporte ao conceito de várias *hierarquias* de registro em log. O nível de registro em log é definido de maneira independente para cada hierarquia. As duas seguintes hierarquias de registro em log estão disponíveis no AWS SDK para Java:
+ log4j.logger.com.amazonaws
+ log4j.logger.org.apache.http.wire
## Definir o classpath
O Log4j JAR e o arquivo log4j.properties devem estar no classpath. Se você estiver usando o [Apache Ant](http://ant.apache.org/manual/), defina o classpath no elemento `path` do arquivo Ant. O exemplo a seguir mostra um elemento de caminho do arquivo Ant para o [exemplo](https://github.com/aws/aws-sdk-java/blob/master/src/samples/AmazonS3/build.xml) do Amazon S3 incluído no SDK.
```
```
Se estiver usando o IDE do Eclipse, você poderá definir o classpath abrindo o menu e navegando até **Project (Projeto)** \$1 **Properties (Propriedades)** \$1 **Java Build Path**.
## Erros e avisos específicos do serviço
Recomendamos sempre deixar a hierarquia do registrador em log "com.amazonaws" definida como "WARN" para interceptar todas as mensagens importantes das bibliotecas de cliente. Por exemplo, se o Amazon S3 cliente detectar que seu aplicativo não fechou corretamente `InputStream` e pode estar vazando recursos, o cliente S3 reportará isso por meio de uma mensagem de aviso aos registros. Isso também garante que as mensagens serão registradas em log se o cliente enfrentar algum problema ao processar requisições ou respostas.
O arquivo log4j.properties a seguir define o `rootLogger` como WARN, o que faz mensagens de erro e aviso de todos os registradores em log na hierarquia "com.amazonaws" serem incluídas. Você também pode definir explicitamente o registrador em log com.amazonaws como WARN.
```
log4j.rootLogger=WARN, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
# Or you can explicitly enable WARN and ERROR messages for the {AWS} Java clients
log4j.logger.com.amazonaws=WARN
```
## Registro em log do resumo de requisição/resposta
Cada solicitação para um AWS service (Serviço da AWS) gera um ID de AWS solicitação exclusivo que é útil se você tiver problemas com a forma como um AWS service (Serviço da AWS) está lidando com uma solicitação. AWS IDs as solicitações podem ser acessadas programaticamente por meio de objetos de exceção no SDK para qualquer chamada de serviço com falha e também podem ser relatadas por meio do nível de registro DEBUG no registrador “com.amazonaws.request”.
O arquivo log4j.properties a seguir permite um resumo das solicitações e respostas, incluindo a solicitação. AWS IDs
```
log4j.rootLogger=WARN, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
# Turn on DEBUG logging in com.amazonaws.request to log
# a summary of requests/responses with {AWS} request IDs
log4j.logger.com.amazonaws.request=DEBUG
```
Aqui está um exemplo da saída do log.
```
2009-12-17 09:53:04,269 [main] DEBUG com.amazonaws.request - Sending
Request: POST https://rds.amazonaws.com / Parameters: (MaxRecords: 20,
Action: DescribeEngineDefaultParameters, SignatureMethod: HmacSHA256,
AWSAccessKeyId: ACCESSKEYID, Version: 2009-10-16, SignatureVersion: 2,
Engine: mysql5.1, Timestamp: 2009-12-17T17:53:04.267Z, Signature:
q963XH63Lcovl5Rr71APlzlye99rmWwT9DfuQaNznkD, ) 2009-12-17 09:53:04,464
[main] DEBUG com.amazonaws.request - Received successful response: 200, {AWS}
Request ID: 694d1242-cee0-c85e-f31f-5dab1ea18bc6 2009-12-17 09:53:04,469
[main] DEBUG com.amazonaws.request - Sending Request: POST
https://rds.amazonaws.com / Parameters: (ResetAllParameters: true, Action:
ResetDBParameterGroup, SignatureMethod: HmacSHA256, DBParameterGroupName:
java-integ-test-param-group-0000000000000, AWSAccessKeyId: ACCESSKEYID,
Version: 2009-10-16, SignatureVersion: 2, Timestamp:
2009-12-17T17:53:04.467Z, Signature:
9WcgfPwTobvLVcpyhbrdN7P7l3uH0oviYQ4yZ+TQjsQ=, )
2009-12-17 09:53:04,646 [main] DEBUG com.amazonaws.request - Received
successful response: 200, {AWS} Request ID:
694d1242-cee0-c85e-f31f-5dab1ea18bc6
```
## Registro em log detalhado
Em alguns casos, pode ser útil ver as solicitações e respostas exatas que eles AWS SDK para Java enviam e recebem. Você não deve habilitar esse registro em sistemas de produção porque escrever grandes solicitações (por exemplo, um arquivo sendo carregado Amazon S3) ou respostas pode reduzir significativamente a velocidade de um aplicativo. Se você realmente precisar acessar essas informações, poderá ativá-las temporariamente por meio do registrador Apache HttpClient 4. Habilitar o nível DEBUG no registrador em log `org.apache.http.wire` permite o registro em log de todos os dados de requisição e resposta.
O arquivo log4j.properties a seguir ativa o registro completo de conexões no Apache HttpClient 4 e só deve ser ativado temporariamente, pois pode ter um impacto significativo no desempenho do seu aplicativo.
```
log4j.rootLogger=WARN, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
# Log all HTTP content (headers, parameters, content, etc) for
# all requests and responses. Use caution with this since it can
# be very expensive to log such verbose data!
log4j.logger.org.apache.http.wire=DEBUG
```
## Registro de métricas de latência
Se você estiver solucionando problemas e desejar ver métricas, como qual processo está consumindo mais tempo ou se o lado do servidor ou do cliente têm mais latência, o registrador de latência será útil. Defina o registrador `com.amazonaws.latency` como DEBUG para habilitá-lo.
**nota**
O registrador estará disponível somente se as métricas do SDK estiverem habilitadas. Para saber mais sobre o pacote de métricas do SDK, consulte [Habilitar métricas para o AWS SDK para Java](generating-sdk-metrics.md).
```
log4j.rootLogger=WARN, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
log4j.logger.com.amazonaws.latency=DEBUG
```
Aqui está um exemplo da saída do log.
```
com.amazonaws.latency - ServiceName=[{S3}], StatusCode=[200],
ServiceEndpoint=[https://list-objects-integ-test-test.s3.amazonaws.com],
RequestType=[ListObjectsV2Request], AWSRequestID=[REQUESTID], HttpClientPoolPendingCount=0,
RetryCapacityConsumed=0, HttpClientPoolAvailableCount=0, RequestCount=1,
HttpClientPoolLeasedCount=0, ResponseProcessingTime=[52.154], ClientExecuteTime=[487.041],
HttpClientSendRequestTime=[192.931], HttpRequestTime=[431.652], RequestSigningTime=[0.357],
CredentialsRequestTime=[0.011, 0.001], HttpClientReceiveResponseTime=[146.272]
```
# Configuração do cliente
O AWS SDK para Java permite que você altere a configuração padrão do cliente, o que é útil quando você deseja:
+ Conectar-se à Internet por meio de proxy
+ Alterar configurações de transporte HTTP, como tempo limite da conexão e novas tentativas de requisição
+ Especificar dicas de tamanho do buffer de soquete TCP
## Configuração do proxy
Ao construir um objeto cliente, você pode passar um [ClientConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html)objeto opcional para personalizar a configuração do cliente.
Se você se conectar à Internet por meio de um servidor de proxy, será necessário configurar as definições do servidor de proxy (host do proxy, porta e nome de usuário/senha) por meio do objeto `ClientConfiguration`.
## Configuração do transporte HTTP
Você pode configurar várias opções de transporte HTTP usando o [ClientConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html)objeto. Ocasionalmente, novas opções são adicionadas; para ver a lista completa de opções que você pode recuperar ou definir, consulte a Referência da AWS SDK para Java API.
**nota**
Cada um dos valores configuráveis tem um valor padrão definido por uma constante. Para obter uma lista dos valores constantes para`ClientConfiguration`, consulte [Valores de campo constantes](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/constant-values.html) na Referência da AWS SDK para Java API.
### Conexões máximas
Você pode definir o número máximo permitido de conexões HTTP abertas usando [ClientConfigurationo. setMaxConnections](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setMaxConnections-int-)método.
**Importante**
Defina o número máximo de conexões para o número de transações simultâneas de modo a evitar disputas de conexão e baixo desempenho. Para o valor máximo padrão das conexões, consulte [Valores de campo constantes](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/constant-values.html) na Referência AWS SDK para Java da API.
### Tempos limite e processamento de erros
Você pode definir opções relacionadas a tempos limite e processamento de erros com conexões HTTP.
+ **Tempo limite da conexão**
Tempo limite da conexão é o tempo (em milissegundos) que a conexão HTTP aguardará para estabelecer uma conexão antes de desistir. O padrão é 10.000 ms.
Para definir esse valor você mesmo, use [ClientConfigurationo. setConnectionTimeout](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setConnectionTimeout-int-)método.
+ **Time to Live (TTL – Tempo de vida) da conexão**
Por padrão, o SDK tentará reutilizar conexões HTTP, enquanto isso for possível. Em situações de falha nas quais uma conexão seja estabelecida com um servidor fora de serviço, ter um TTL finito pode ajudar na recuperação do aplicativo. Por exemplo, definir um TTL de 15 minutos garantirá que, mesmo se tiver uma conexão estabelecida com um servidor que esteja enfrentando problemas, você restabelecerá uma conexão com um novo servidor dentro de 15 minutos.
Para definir o TTL da conexão HTTP, use o [ClientConfigurationmétodo.setConnectionTTL](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setConnectionTTL-long-).
+ **Máximo de repetições com erro**
A contagem máxima padrão de novas tentativas para erros repetíveis é três. Você pode definir um valor diferente usando [ClientConfigurationo. setMaxErrorMétodo de repetição](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setMaxErrorRetry-int-).
### Endereço local
[Para definir o endereço local ao qual o cliente HTTP se vinculará, useClientConfiguration. setLocalAddress](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setLocalAddress-java.net.InetAddress-).
## Dicas de tamanho do buffer de soquete TCP
Usuários avançados que desejam ajustar parâmetros TCP de baixo nível também podem definir dicas de tamanho do buffer TCP por meio do objeto. [ClientConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html) A maioria dos usuários jamais precisará ajustar esses valores, mas eles são fornecidos para usuários avançados.
Os tamanhos de buffer TCP ideais de um aplicativo dependem muito das configurações e dos recursos da rede e do sistema operacional. Por exemplo, a maioria dos sistemas operacionais modernos oferece uma lógica de autoajuste para tamanhos de buffer TCP. Isso pode ter um grande impacto sobre o desempenho para conexões TCP mantidas abertas pelo tempo necessário para o autoajuste otimizar tamanhos de buffer.
Tamanhos de buffer grandes (por exemplo, 2 MB) permitem que o sistema operacional armazene em buffer mais dados na memória sem exigir que o servidor remoto confirme o recebimento dessas informações e, assim, podem ser especialmente úteis quando a rede tem alta latência.
Trata-se apenas de uma *dica*, e o sistema operacional talvez não esteja apto para isso. Ao usar essa opção, os usuários devem sempre verificar os limites configurados do sistema operacional e os padrões. A maioria dos sistemas operacionais tem um limite de tamanho de buffer TCP máximo configurado e não permitirá ir além desse limite, a menos que você aumente explicitamente o limite do tamanho de buffer TCP máximo.
Muitos recursos estão disponíveis para ajudar a definir configurações de tamanhos do buffer TCP e configurações específicas do sistema operacional, inclusive o seguinte:
+ [Ajuste do host](http://fasterdata.es.net/host-tuning/)
# Políticas de controle de acesso
AWS *as políticas de controle de acesso* permitem que você especifique controles de acesso refinados em seus recursos. AWS Uma política de controle de acesso consiste em um conjunto de *instruções*, que assumem a forma:
A *conta A* tem permissão para realizar a *ação B* no *recurso C* em que a *condição D* se aplica.
Em que:
+ *A* é o *principal* - Conta da AWS Aquele que está fazendo uma solicitação para acessar ou modificar um de seus AWS recursos.
+ *B* é a *ação*: a maneira pela qual seu AWS recurso está sendo acessado ou modificado, como enviar uma mensagem para uma Amazon SQS fila ou armazenar um objeto em um Amazon S3 bucket.
+ *C* é o *recurso* - A AWS entidade que o principal deseja acessar, como uma Amazon SQS fila ou um objeto armazenado Amazon S3.
+ *D* é um *conjunto de condições*: as restrições opcionais que especificam quando permitir ou negar acesso para a entidade principal acessar o recurso. Muitas condições expressivas estão disponíveis, algumas específicas de cada serviço. Por exemplo, você pode usar condições de data para permitir acesso aos recursos somente depois ou antes de uma hora específica.
## Amazon S3 Exemplo
O exemplo a seguir demonstra uma política que permite que qualquer pessoa acesse para ler todos os objetos em um bucket, mas restringe o acesso ao upload de objetos nesse bucket a dois Conta da AWS s específicos (além da conta do proprietário do bucket).
```
Statement allowPublicReadStatement = new Statement(Effect.Allow)
.withPrincipals(Principal.AllUsers)
.withActions(S3Actions.GetObject)
.withResources(new S3ObjectResource(myBucketName, "*"));
Statement allowRestrictedWriteStatement = new Statement(Effect.Allow)
.withPrincipals(new Principal("123456789"), new Principal("876543210"))
.withActions(S3Actions.PutObject)
.withResources(new S3ObjectResource(myBucketName, "*"));
Policy policy = new Policy()
.withStatements(allowPublicReadStatement, allowRestrictedWriteStatement);
AmazonS3 s3 = AmazonS3ClientBuilder.defaultClient();
s3.setBucketPolicy(myBucketName, policy.toJson());
```
## Amazon SQS Exemplo
Um uso comum das políticas é autorizar uma Amazon SQS fila para receber mensagens de um tópico do Amazon SNS.
```
Policy policy = new Policy().withStatements(
new Statement(Effect.Allow)
.withPrincipals(Principal.AllUsers)
.withActions(SQSActions.SendMessage)
.withConditions(ConditionFactory.newSourceArnCondition(myTopicArn)));
Map queueAttributes = new HashMap();
queueAttributes.put(QueueAttributeName.Policy.toString(), policy.toJson());
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
sqs.setQueueAttributes(new SetQueueAttributesRequest(myQueueUrl, queueAttributes));
```
## Exemplo do Amazon SNS
Alguns serviços oferecem condições adicionais que podem ser usadas em políticas. O Amazon SNS fornece condições para permitir ou negar assinaturas de tópicos do SNS com base no protocolo (por exemplo, e-mail, HTTP, HTTPS Amazon SQS) e no endpoint (por exemplo, endereço de e-mail, URL, Amazon SQS ARN) da solicitação de assinatura de um tópico.
```
Condition endpointCondition =
SNSConditionFactory.newEndpointCondition("*@mycompany.com");
Policy policy = new Policy().withStatements(
new Statement(Effect.Allow)
.withPrincipals(Principal.AllUsers)
.withActions(SNSActions.Subscribe)
.withConditions(endpointCondition));
AmazonSNS sns = AmazonSNSClientBuilder.defaultClient();
sns.setTopicAttributes(
new SetTopicAttributesRequest(myTopicArn, "Policy", policy.toJson()));
```
# Definir o JVM TTL para pesquisas de nome DNS
A JVM armazena em cache pesquisas de nome DNS. Quando a JVM resolve um nome de host para um endereço IP, ela armazena o endereço IP em cache por um período de tempo especificado, conhecido como (TTL). *time-to-live*
Como AWS os recursos usam entradas de nome DNS que mudam ocasionalmente, recomendamos que você configure sua JVM com um valor TTL de 5 segundos. Isso garante que, quando o endereço IP de um recurso mudar, o aplicativo poderá receber e usar o novo endereço IP do recurso consultando novamente o DNS.
Em algumas configurações do Java, o TTL padrão da JVM é definido de maneira que *jamais* atualizará entradas DNS até a JVM ser reiniciada. Portanto, se o endereço IP de um AWS recurso mudar enquanto seu aplicativo ainda estiver em execução, ele não poderá usar esse recurso até que você *reinicie manualmente* a JVM e as informações IP em cache sejam atualizadas. Nesse caso, é crucial definir o TTL da JVM, de forma que ele atualize periodicamente as informações de IP armazenadas em cache.
## Como definir o TTL da JVM
Para modificar o TTL da JVM, defina o valor da propriedade de segurança [networkaddress.cache.ttl](https://docs.oracle.com/en/java/javase/17/core/java-networking.html#GUID-A680DADB-C4C1-40F1-B568-D9A97C917F5D). Observe que `networkaddress.cache.ttl` é uma *propriedade de segurança, não uma propriedade* do sistema, ou seja, ela não pode ser definida com o sinalizador de `-D` linha de comando.
### Opção 1: defina-o programaticamente em seu aplicativo
Ligue [https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/security/Security.html](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/security/Security.html)logo na inicialização do aplicativo, antes que qualquer cliente AWS SDK seja criado e antes que qualquer solicitação de rede seja feita:
```
import java.security.Security;
public class MyApplication {
public static void main(String[] args) {
Security.setProperty("networkaddress.cache.ttl", "5");
// ... create SDK clients and run application
}
}
```
### Opção 2: defina-o no arquivo java.security
Defina a `networkaddress.cache.ttl` propriedade no `$JAVA_HOME/jre/lib/security/java.security` arquivo para Java 8 ou `$JAVA_HOME/conf/security/java.security` arquivo para Java 11 ou superior.
Veja a seguir um trecho de um arquivo `java.security` que mostra o cache de TTL definido para 5 segundos.
```
#
# The Java-level namelookup cache policy for successful lookups:
#
# any negative value: caching forever
# any positive value: the number of seconds to cache an address for
# zero: do not cache
#
...
networkaddress.cache.ttl=5
...
```
Todos os aplicativos executados na JVM representada pela variável de `$JAVA_HOME` ambiente usam essa configuração.
### Opção 3: usar o fallback de propriedades do sistema JDK (linha de comando)
Se você não puder modificar a configuração ou o código de segurança, poderá usar as propriedades do sistema JDK. Eles atuam como substitutos se nenhuma propriedade de segurança for definida.
+ `sun.net.inetaddr.ttl`— Controla pesquisas bem-sucedidas (TTL positivo)
+ `sun.net.inetaddr.negative.ttl`— Controla pesquisas com falha (TTL negativo)
```
java -Dsun.net.inetaddr.ttl=5 -Dsun.net.inetaddr.negative.ttl=1 -jar myapp.jar
```
**nota**
Essas são propriedades internas do JDK documentadas na referência [Oracle Java 8 Networking Properties](https://docs.oracle.com/javase/8/docs/technotes/guides/net/properties.html) como propriedades privadas que “podem não ser suportadas em futuras versões”. Use as Opções 1-2 quando possível.
# Habilitando métricas para o AWS SDK para Java
Eles AWS SDK para Java podem gerar métricas para visualização e monitoramento com a [Amazon CloudWatch](https://aws.amazon.com/cloudwatch/) que medem:
+ o desempenho do seu aplicativo ao acessar AWS
+ o desempenho do seu JVMs quando usado com AWS
+ detalhes do ambiente do tempo de execução, como a memória do heap, o número de threads e os descritores de arquivo aberto
## Como habilitar a geração de métricas do SDK do Java
Você precisa adicionar a seguinte dependência do Maven para permitir que o SDK envie métricas para. CloudWatch
```
com.amazonaws
aws-java-sdk-bom
1.12.490*
pom
import
com.amazonaws
aws-java-sdk-cloudwatchmetrics
provided
```
\$1Substitua o número da versão pela versão mais recente do SDK disponível na [central do Maven](https://central.sonatype.com/artifact/com.amazonaws/aws-java-sdk-bom).
AWS SDK para Java as métricas são *desativadas por padrão*. Para habilitá-la para o ambiente de desenvolvimento local, inclua uma propriedade de sistema que aponte para o arquivo de credencial de segurança da AWS durante a inicialização da JVM. Por exemplo:
```
-Dcom.amazonaws.sdk.enableDefaultMetrics=credentialFile=/path/aws.properties
```
Você precisa especificar o caminho para seu arquivo de credencial para que o SDK possa carregar os pontos de dados coletados para CloudWatch análise posterior.
**nota**
Se você estiver acessando AWS de uma Amazon EC2 instância usando o serviço de metadados da Amazon EC2 instância, não precisará especificar um arquivo de credencial. Neste caso, você precisa especificar somente:
```
-Dcom.amazonaws.sdk.enableDefaultMetrics
```
*Todas as métricas capturadas pelo AWS SDK para Java estão no namespace **AWSSDK/Java** e são enviadas para a região CloudWatch padrão (us-east-1).* Para alterar a região, especifique-a usando o atributo `cloudwatchRegion` na propriedade do sistema. Por exemplo, para definir a CloudWatch região como *us-east-1*, use:
```
-Dcom.amazonaws.sdk.enableDefaultMetrics=credentialFile=/path/aws.properties,cloudwatchRegion={region_api_default}
```
Depois de ativar o recurso, toda vez que houver uma solicitação de serviço para o AWS SDK para Java, pontos AWS de dados métricos serão gerados, colocados em fila para um resumo estatístico e enviados de forma assíncrona para aproximadamente uma vez a CloudWatch cada minuto. Assim que o upload das métricas for feito, você poderá visualizá-las usando o [Console de gerenciamento da AWS](https://console.aws.amazon.com/console/home) e definir alarmes para problemas em potencial, como vazamento de memória, vazamento do descritor de arquivo etc.
## Tipos de métrica disponíveis
O conjunto padrão de métricas é dividido em três categorias principais:
AWS Métricas de solicitação
+ Abrange áreas como a latência da requisição/resposta HTTP, o número de requisições, exceções e novas tentativas.
![\[RequestMetric 13111\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/v1/developer-guide/images/RequestMetric-131111.png)
AWS service (Serviço da AWS) Métricas
+ Inclua dados AWS service (Serviço da AWS) específicos, como a taxa de transferência e a contagem de bytes para uploads e downloads do S3.
![\[ServiceMetric 13111\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/v1/developer-guide/images/ServiceMetric-131111.png)
Métricas de máquina
+ Abrangem o ambiente do tempo de execução, inclusive a memória do heap, o número de threads e os descritores de arquivo aberto.
![\[MachineMetric 13111\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/v1/developer-guide/images/MachineMetric-131111.png)
Se você quiser excluir métricas de máquina, adicione `excludeMachineMetrics` à propriedade do sistema:
```
-Dcom.amazonaws.sdk.enableDefaultMetrics=credentialFile=/path/aws.properties,excludeMachineMetrics
```
## Mais informações
+ Consulte [amazonaws/metrics package summary](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/metrics/package-summary.html) para obter uma lista completa dos tipos de métrica de núcleo predefinidos.
+ Saiba mais sobre como trabalhar com o CloudWatch uso do AWS SDK para Java em [CloudWatch Exemplos usando AWS SDK para Java](examples-cloudwatch.md) o.
+ Saiba mais sobre o ajuste de desempenho na postagem [do blog Tuning AWS SDK para Java to Improve Resiliency](https://aws.amazon.com/blogs/developer/tuning-the-aws-sdk-for-java-to-improve-resiliency).