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á.
# Configure clientes HTTP no AWS SDK for Java 2.x
É possível alterar o cliente HTTP a ser usado para o cliente de serviço, bem como alterar a configuração padrão para clientes HTTP com o AWS SDK for Java 2.x. Esta seção discute os clientes HTTP e as configurações do SDK.
## Clientes HTTP disponíveis no SDK para Java
### Clientes síncronos
Clientes HTTP síncronos no SDK for Java implementam [SdkHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/SdkHttpClient.html)a interface. Um cliente de serviço síncrono, como o `S3Client` ou o `DynamoDbClient`, requer o uso de um cliente HTTP síncrono. O AWS SDK para Java oferece três clientes HTTP síncronos.
**ApacheHttpClient (padrão)**
[ApacheHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html)é o cliente HTTP padrão para clientes de serviços síncronos. Para obter mais informações sobre a configuração do `ApacheHttpClient`, consulte [Configurar o cliente HTTP baseado em Apache](http-configuration-apache.md).
**AwsCrtHttpClient**
[AwsCrtHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.html)fornece alto rendimento e E/S sem bloqueio. Ele é construído no AWS Common Runtime (CRT) Http Client. Para receber informações sobre como configurar o `AwsCrtHttpClient` e usá-lo com clientes de serviço, consulte [Configurar clientes AWS HTTP baseados em CRT](http-configuration-crt.md).
**UrlConnectionHttpClient**
Para minimizar o número de jars e bibliotecas de terceiros que seu aplicativo usa, você pode usar o. [UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html) Para obter mais informações sobre a configuração do `UrlConnectionHttpClient`, consulte [Configurar o cliente HTTP URLConnection baseado](http-configuration-url.md).
**Apache 5 HttpClient**
[O Apache5 HttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache5/Apache5HttpClient.html) *é uma versão atualizada `ApacheHttpClient` que é construída no Apache 5.x. HttpClient A versão 5.x* é a versão mantida ativamente pelo Apache e melhora a versão anterior usada, trazendo compatibilidade com o ecossistema Java moderno, incluindo suporte a threads virtuais para Java 21 e maior flexibilidade de registro por meio de SLF4 J. `Apache5HttpClient` will replace `ApacheHttpClient` como cliente síncrono padrão em uma versão futura do SDK for AWS Java 2.x. `ApacheHttpClient` Ele tem uma API e recursos idênticos, o que o torna ideal como substituto imediato. Para obter mais informações sobre a configuração do `Apache5HttpClient`, consulte [Configurar o cliente HTTP baseado em Apache 5.x](http-configuration-apache5.md).
### Clientes assíncronos
Clientes HTTP assíncronos no SDK for Java implementam a interface. [SdkAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/async/SdkAsyncHttpClient.html) Um cliente de serviço assíncrono, como o `S3AsyncClient` ou o `DynamoDbAsyncClient`, requer o uso de um cliente HTTP assíncrono. O AWS SDK para Java oferece dois clientes HTTP assíncronos.
**NettyNioAsyncHttpClient (padrão)**
[NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html)é o cliente HTTP padrão usado por clientes assíncronos. Para obter mais informações sobre a configuração do `NettyNioAsyncHttpClient`, consulte [Configurar o cliente HTTP baseado em Netty](http-configuration-netty.md).
**AwsCrtAsyncHttpClient**
[AwsCrtAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.html)É baseado no cliente HTTP AWS Common Runtime (CRT). Para obter mais informações sobre a configuração do `AwsCrtAsyncHttpClient`, consulte [Configurar clientes AWS HTTP baseados em CRT](http-configuration-crt.md).
## Recomendações do cliente HTTP
Diversos fatores entram em cena quando você escolhe uma implementação de cliente HTTP. Use as informações a seguir para ajudá-lo a decidir.
### Fluxograma de recomendação
O fluxograma a seguir fornece orientação geral para ajudá-lo a determinar qual cliente HTTP usar.
![\[Fluxograma das recomendações do cliente HTTP.\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/images/JavaDevGuide-HTTPflowchart-DI.png)
### Comparação de clientes HTTP
A tabela a seguir contém informações detalhadas para cada cliente HTTP.
| Cliente HTTP | Síncrono ou assíncrono | Quando usar | Limitação/desvantagem |
| --- | --- | --- | --- |
| Cliente HTTP baseado em Apache *(cliente HTTP síncrono padrão)* | Síncrono | Use-o se você preferir baixa latência em vez de alta taxa de transferência | Tempo de inicialização mais lento em comparação com outros clientes HTTP |
| Cliente HTTP baseado em URLConnection | Sincronização | Use-o se você tiver um requisito rígido de limitar dependências de terceiros | Não é compatível com o método HTTP PATCH, exigido por algumas APIS, como as operações do Amazon APIGateway Update |
| AWS Cliente HTTP de sincronização baseado em CRT 1 | Sincronização | • Use-o se seu aplicativo estiver sendo executado em AWS Lambda • Use-o se você preferir alta taxa de transferência em vez de baixa latência • Use-o se preferir clientes do SDK síncronos. | As seguintes propriedades do sistema Java não são compatíveis: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/http-configuration.html) |
| Cliente HTTP baseado em Netty *(cliente HTTP síncrono padrão)* | Assíncrono | • Use-o se seu aplicativo invocar algo APIs que exija suporte a HTTP/2, como a Kinesis API [SubscribeToShard](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_SubscribeToShard.html) | Tempo de inicialização mais lento em comparação com outros clientes HTTP |
| AWS Cliente HTTP assíncrono baseado em CRT 1 | Assíncrono | • Use-o se seu aplicativo estiver sendo executado no AWS Lambda• Use-o se você preferir alta taxa de transferência em vez de baixa latência• Use-o se preferir clientes do SDK assíncronos. | • Não oferece suporte a clientes de serviços que exigem suporte HTTP/2, como `KinesisAsynClient` e `TranscribeStreamingAsyncClient` As seguintes propriedades do sistema Java não são compatíveis: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/http-configuration.html) |
1 Por causa de seus benefícios adicionais, recomendamos que você use os clientes HTTP AWS baseados em CRT, se possível.
## Padrões de configuração inteligentes
A AWS SDK for Java 2.x (versão 2.17.102 ou posterior) oferece um recurso de padrões de configuração inteligente. Esse recurso otimiza duas propriedades do cliente HTTP além de outras propriedades que não afetam o cliente HTTP.
Os padrões de configuração inteligentes definem valores razoáveis para as propriedades `connectTimeoutInMillis` e `tlsNegotiationTimeoutInMillis` com base em um valor de modo padrão fornecido por você. Você escolhe o valor de modo padrão com base nas características do seu aplicativo.
Para obter mais informações sobre padrões de configuração inteligente e como escolher o valor do modo padrão mais adequado para seus aplicativos, consulte o Guia de referência de ferramentas [AWS SDKs e](https://docs.aws.amazon.com/sdkref/latest/guide/feature-smart-config-defaults.html) ferramentas.
A seguir estão quatro maneiras de definir o modo padrão para seu aplicativo.
------
#### [ Service client ]
Use o builder do cliente de serviço para configurar o modo padrão diretamente no cliente de serviço. O exemplo a seguir define o modo padrão como `auto` para o `DynamoDbClient`.
```
DynamoDbClient ddbClient = DynamoDbClient.builder()
.defaultsMode(DefaultsMode.AUTO)
.build();
```
------
#### [ System property ]
Você pode usar a propriedade `aws.defaultsMode` do sistema para especificar o modo padrão. Se você definir a propriedade do sistema em Java, precisará defini-la antes de inicializar qualquer cliente de serviço.
O exemplo a seguir mostra como definir o modo padrão como `auto` usando uma propriedade do sistema definida em Java.
```
System.setProperty("aws.defaultsMode", "auto");
```
O exemplo a seguir demonstra como definir o modo padrão como `auto` usando uma opção `-D` do comando `java`.
```
java -Daws.defaultsMode=auto
```
------
#### [ Environment variable ]
Defina um valor para a variável de ambiente `AWS_DEFAULTS_MODE` para selecionar o modo padrão para o seu aplicativo.
As informações a seguir mostram o comando a ser executado para definir o valor do modo padrão como `auto` usando uma variável de ambiente.
| Sistema operacional | Comando para definir variáveis de ambiente |
| --- | --- |
| Linux, macOS ou Unix | export AWS\$1DEFAULTS\$1MODE=auto |
| Windows | set AWS\$1DEFAULTS\$1MODE=auto |
------
#### [ AWS config file ]
Você pode adicionar uma propriedade `defaults_mode` de configuração ao AWS `config` arquivo compartilhado, conforme mostrado no exemplo a seguir.
```
[default]
defaults_mode = auto
```
------
Se você definir o modo padrão globalmente com a propriedade do sistema, a variável de ambiente ou o arquivo config da AWS , poderá substituir as configurações ao criar um cliente HTTP.
Quando você cria um cliente HTTP com o método `httpClientBuilder()`, as configurações se aplicam somente à instância que você está criando. Um exemplo disso é mostrado [aqui](http-configuration-netty.md#http-config-netty-one-client). O cliente HTTP baseado em Netty neste exemplo substitui todos os valores de modo padrão definidos globalmente para `connectTimeoutInMillis` e `tlsNegotiationTimeoutInMillis`.
# Configurar o cliente HTTP baseado em Apache
Os clientes de serviço síncrono AWS SDK for Java 2.x usam um cliente HTTP baseado em Apache, por padrão. [ApacheHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html) O SDK `ApacheHttpClient` é baseado no [HttpClient](https://hc.apache.org/httpcomponents-client-4.5.x/index.html)Apache.
O SDK também oferece o [UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html), que carrega mais rapidamente, mas tem menos recursos. Para obter mais informações sobre a configuração do `UrlConnectionHttpClient`, consulte [Configurar o cliente HTTP URLConnection baseado](http-configuration-url.md).
Para ver o conjunto completo de opções de configuração disponíveis para o`ApacheHttpClient`, consulte [ApacheHttpClient.Builder e [ProxyConfiguration.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ProxyConfiguration.Builder.html)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.Builder.html).
## Acesse o `ApacheHttpClient`
Na maioria das situações, você usa o `ApacheHttpClient` sem nenhuma configuração explícita. Você vai declarar os clientes de serviço e o SDK vai configurar o `ApacheHttpClient` com valores padrão para você.
Se você quiser configurar o `ApacheHttpClient` explicitamente ou usá-lo com vários clientes de serviço, precisará disponibilizá-lo para configuração.
### Nenhuma configuração necessária
Quando você declara uma dependência de um cliente de serviço no Maven, o SDK adiciona uma dependência de *tempo de execução* ao artefato `apache-client`. Isso torna a classe `ApacheHttpClient` disponível para o código em runtime, mas não no momento da compilação. Se você não estiver configurando o cliente HTTP baseado em Apache, não precisará especificar uma dependência para ele.
No seguinte trecho XML de um arquivo `pom.xml` do Maven, a dependência declarada com `s3` traz automaticamente o cliente HTTP baseado em Apache. Você não precisa declarar uma dependência especificamente para isso.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
s3
```
Com essas dependências, você não pode fazer nenhuma alteração explícita na configuração HTTP, porque a biblioteca `ApacheHttpClient` está somente no caminho de classe em tempo de execução.
### Configuração necessária
Para configurar o `ApacheHttpClient`, você precisa adicionar uma dependência na biblioteca `apache-client` em tempo de *compilação*.
Consulte o exemplo a seguir de um arquivo `pom.xml` do Maven para configurar o `ApacheHttpClient`.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
s3
software.amazon.awssdk
apache-client
```
## Usar e configurar o `ApacheHttpClient`
Você pode configurar uma instância do `ApacheHttpClient` junto com a criação de um cliente de serviço ou pode configurar uma única instância para compartilhar entre vários clientes de serviço.
Com qualquer abordagem, você usa o `[ApacheHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.Builder.html)` para configurar as propriedades do cliente HTTP baseado em Apache.
### Prática recomendada: dedicar uma instância do `ApacheHttpClient` a um cliente de serviço
Se você precisar configurar uma instância do `ApacheHttpClient`, recomendamos que você crie a instância `ApacheHttpClient` dedicada. Faça isso usando o método `httpClientBuilder` do builder do cliente do serviço. Dessa forma, o ciclo de vida do cliente HTTP é gerenciado pelo SDK, o que ajuda a evitar possíveis vazamentos de memória se a instância do `ApacheHttpClient` não for fechada quando não for mais necessária.
O exemplo a seguir cria um`S3Client` e configura a instância embutida do `ApacheHttpClient` com os valores `maxConnections` e `connectionTimeout`. A instância HTTP é criada usando o método `httpClientBuilder` do `S3Client.Builder`.
**Importações**
```
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Código**
```
S3Client s3Client = S3Client // Singleton: Use the s3Client for all requests.
.builder()
.httpClientBuilder(ApacheHttpClient.builder()
.maxConnections(100)
.connectionTimeout(Duration.ofSeconds(5))
).build();
// Perform work with the s3Client.
s3Client.close(); // Requests completed: Close all service clients.
```
### Abordagem alternativa: compartilhar uma instância do `ApacheHttpClient`
Para ajudar a reduzir o uso de recursos e memória do seu aplicativo, você pode configurar um `ApacheHttpClient` e compartilhá-lo entre vários clientes de serviço. O pool de conexões HTTP será compartilhado, o que reduz o uso de recursos.
**nota**
Quando uma instância do `ApacheHttpClient` é compartilhada, você deve fechá-la quando ela estiver pronta para ser descartada. O SDK não fechará a instância quando o cliente de serviço for fechado.
O exemplo a seguir configura um cliente HTTP baseado em Apache, que é usado por dois clientes de serviço. A instância `ApacheHttpClient` configurada é transmitida ao método `httpClient` de cada construtor. Quando os clientes do serviço e o cliente HTTP não são mais necessários, o código os fecha explicitamente. O código fecha o cliente HTTP por último.
**Importações**
```
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.s3.S3Client;
```
**Código**
```
SdkHttpClient apacheHttpClient = ApacheHttpClient.builder()
.maxConnections(100).build();
// Singletons: Use the s3Client and dynamoDbClient for all requests.
S3Client s3Client =
S3Client.builder()
.httpClient(apacheHttpClient).build();
DynamoDbClient dynamoDbClient =
DynamoDbClient.builder()
.httpClient(apacheHttpClient).build();
// Perform work with the s3Client and dynamoDbClient.
// Requests completed: Close all service clients.
s3Client.close();
dynamoDbClient.close();
apacheHttpClient.close(); // Explicitly close apacheHttpClient.
```
## Exemplo de configuração do proxy
O trecho de código a seguir usa o [builder de configuração de proxy para o cliente Apache HTTP](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ProxyConfiguration.Builder.html).
```
SdkHttpClient apacheHttpClient = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.endpoint(URI.create("http://example.com:1234"))
.username("username")
.password("password")
.addNonProxyHost("localhost")
.addNonProxyHost("host.example.com")
.build())
.build();
```
As propriedades equivalentes do sistema Java para a configuração do proxy são mostradas no trecho da linha de comando a seguir.
```
$ java -Dhttp.proxyHost=example.com -Dhttp.proxyPort=1234 -Dhttp.proxyUser=username \
-Dhttp.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
A configuração equivalente que usa variáveis de ambiente é:
```
// Set the following environment variables.
// $ export HTTP_PROXY="http://username:password@example.com:1234"
// $ export NO_PROXY="localhost|host.example.com"
// Set the 'useSystemPropertyValues' to false on the proxy configuration.
SdkHttpClient apacheHttpClient = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.useSystemPropertyValues(Boolean.FALSE)
.build())
.build();
// Run the application.
// $ java -cp ... App
```
**nota**
Atualmente, o cliente Apache HTTP não é compatível com as propriedades do sistema do proxy HTTPS nem com a variável de ambiente HTTPS\$1PROXY.
# Configurar o cliente HTTP URLConnection baseado
O AWS SDK for Java 2.x oferece um cliente `[UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html)` HTTP mais leve em comparação com o padrão. `ApacheHttpClient` O `UrlConnectionHttpClient` é baseado no `[URLConnection](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/net/URLConnection.html)` do Java.
O `UrlConnectionHttpClient` é carregado mais rapidamente do que o cliente HTTP baseado em Apache, mas tem menos recursos. Por carregar mais rapidamente, é uma [boa solução](lambda-optimize-starttime.md) para funções AWS Lambda do Java.
O `UrlConnectionHttpClient` possui várias [opções configuráveis](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.Builder.html) que você pode acessar.
**nota**
O `UrlConnectionHttpClient` não é compatível com o método HTTP PATCH.
Algumas operações de AWS API exigem solicitações de PATCH. Esses nomes de operação geralmente começam com `Update*`. Veja alguns exemplos a seguir.
[Várias `Update*` operações](https://docs.aws.amazon.com/securityhub/1.0/APIReference/API_Operations.html) na AWS Security Hub CSPM API e também a [BatchUpdateFindings](https://docs.aws.amazon.com/securityhub/1.0/APIReference/API_BatchUpdateFindings.html)operação
Todas as [operações `Update*`](https://docs.aws.amazon.com/apigateway/latest/api/API_UpdateAccount.html) da API do Amazon API Gateway
Se você puder usar o`UrlConnectionHttpClient`, primeiro consulte a Referência da API para o AWS service (Serviço da AWS) que você está usando. Verifique se as operações necessárias usam a operação PATCH.
## Acesse o `UrlConnectionHttpClient`
Para configurar e usar o `UrlConnectionHttpClient`, você declara uma dependência do artefato `url-connection-client` do Maven em seu arquivo `pom.xml`.
Ao contrário do `ApacheHttpClient`, o `UrlConnectionHttpClient` não é adicionado automaticamente ao seu projeto; portanto, quando usado, ele deve ser declarado especificamente.
O exemplo de arquivo `pom.xml` a seguir mostra as dependências necessárias para usar e configurar o cliente HTTP.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
url-connection-client
```
## Usar e configurar o `UrlConnectionHttpClient`
Você pode configurar uma instância do `UrlConnectionHttpClient` junto com a criação de um cliente de serviço ou pode configurar uma única instância para compartilhar entre vários clientes de serviço.
Com qualquer abordagem, você usa o [UrlConnectionHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.Builder.html) para configurar as propriedades do cliente HTTP URLConnection baseado.
### Prática recomendada: dedicar uma instância do `UrlConnectionHttpClient` a um cliente de serviço
Se você precisar configurar uma instância do `UrlConnectionHttpClient`, recomendamos que você crie a instância `UrlConnectionHttpClient` dedicada. Faça isso usando o método `httpClientBuilder` do builder do cliente do serviço. Dessa forma, o ciclo de vida do cliente HTTP é gerenciado pelo SDK, o que ajuda a evitar possíveis vazamentos de memória se a instância do `UrlConnectionHttpClient` não for fechada quando não for mais necessária.
O exemplo a seguir cria um`S3Client` e configura a instância embutida do `UrlConnectionHttpClient` com os valores `socketTimeout` e `proxyConfiguration`. O método `proxyConfiguration` usa uma expressão lambda Java do tipo ` Consumer<[ProxyConfiguration.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/ProxyConfiguration.Builder.html)>`.
**Importações**
```
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.urlconnection.UrlConnectionHttpClient;
import java.net.URI;
import java.time.Duration;
```
**Código**
```
// Singleton: Use the s3Client for all requests.
S3Client s3Client =
S3Client.builder()
.httpClientBuilder(UrlConnectionHttpClient.builder()
.socketTimeout(Duration.ofMinutes(5))
.proxyConfiguration(proxy -> proxy.endpoint(URI.create("http://proxy.mydomain.net:8888"))))
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.build();
// Perform work with the s3Client.
s3Client.close(); // Requests completed: Close the s3client.
```
### Abordagem alternativa: compartilhar uma instância do `UrlConnectionHttpClient`
Para ajudar a reduzir o uso de recursos e memória do seu aplicativo, você pode configurar um `UrlConnectionHttpClient` e compartilhá-lo entre vários clientes de serviço. O pool de conexões HTTP será compartilhado, o que reduz o uso de recursos.
**nota**
Quando uma instância do `UrlConnectionHttpClient` é compartilhada, você deve fechá-la quando ela estiver pronta para ser descartada. O SDK não fechará a instância quando o cliente de serviço for fechado.
O exemplo a seguir configura um cliente HTTP URLConnection baseado que é usado por dois clientes de serviço. A instância `UrlConnectionHttpClient` configurada é transmitida ao método `httpClient` de cada criador. Quando os clientes do serviço e o cliente HTTP não são mais necessários, o código os fecha explicitamente. O código fecha o cliente HTTP por último.
**Importações**
```
import software.amazon.awssdk.auth.credentials.EnvironmentVariableCredentialsProvider;
import software.amazon.awssdk.awscore.defaultsmode.DefaultsMode;
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.urlconnection.ProxyConfiguration;
import software.amazon.awssdk.http.urlconnection.UrlConnectionHttpClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.net.URI;
import java.time.Duration;
```
**Código**
```
SdkHttpClient urlHttpClient = UrlConnectionHttpClient.create();
// Singletons: Use the s3Client and dynamoDbClient for all requests.
S3Client s3Client =
S3Client.builder()
.httpClient(urlHttpClient)
.defaultsMode(DefaultsMode.IN_REGION)
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.build();
DynamoDbClient dynamoDbClient =
DynamoDbClient.builder()
.httpClient(urlHttpClient)
.defaultsMode(DefaultsMode.IN_REGION)
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.build();
// Perform work with the s3Client and dynamoDbClient.
// Requests completed: Close all service clients.
s3Client.close();
dynamoDbClient.close();
urlHttpClient.close();
```
#### Usar `URLConnectionHttpClient` e `ApacheHttpClient` em conjunto
Ao usar o `UrlConnectionHttpClient` na aplicação, é necessário fornecer a cada cliente de serviço uma instância `URLConnectionHttpClient` ou `ApacheHttpClient` usando o método `httpClientBuilder` do criador do cliente de serviço.
Uma exceção ocorre se o programa usar vários clientes do serviço e estas duas condições forem verdadeiras:
+ Um cliente de serviço está configurado para usar uma instância do `UrlConnectionHttpClient`
+ Outro cliente de serviço usa o `ApacheHttpClient` padrão sem criá-lo explicitamente com os métodos `httpClient()` ou `httpClientBuilder()`
A exceção indicará que várias implementações HTTP foram encontradas no caminho de classe.
O exemplo de trecho de código a seguir leva a uma exceção.
```
// The dynamoDbClient uses the UrlConnectionHttpClient
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.httpClient(UrlConnectionHttpClient.create())
.build();
// The s3Client below uses the ApacheHttpClient at runtime, without specifying it.
// An SdkClientException is thrown with the message that multiple HTTP implementations were found on the classpath.
S3Client s3Client = S3Client.create();
// Perform work with the s3Client and dynamoDbClient.
dynamoDbClient.close();
s3Client.close();
```
Evite a exceção configurando explicitamente o `S3Client` com um `ApacheHttpClient`.
```
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.httpClient(UrlConnectionHttpClient.create())
.build();
S3Client s3Client = S3Client.builder()
.httpClient(ApacheHttpClient.create()) // Explicitly build the ApacheHttpClient.
.build();
// Perform work with the s3Client and dynamoDbClient.
dynamoDbClient.close();
s3Client.close();
```
**nota**
Para criar explicitamente o `ApacheHttpClient`, você deve [adicionar uma dependência](http-configuration-apache.md#http-apache-dependency) do artefato `apache-client` em seu arquivo de projeto do Maven.
## Exemplo de configuração do proxy
O trecho de código a seguir usa o [builder de configuração de proxy para o cliente HTTP da conexão do URL](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/ProxyConfiguration.Builder.html).
```
SdkHttpClient urlHttpClient = UrlConnectionHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.endpoint(URI.create("http://example.com:1234"))
.username("username")
.password("password")
.addNonProxyHost("localhost")
.addNonProxyHost("host.example.com")
.build())
.build();
```
As propriedades equivalentes do sistema Java para a configuração do proxy são mostradas no trecho da linha de comando a seguir.
```
$ java -Dhttp.proxyHost=example.com -Dhttp.proxyPort=1234 -Dhttp.proxyUser=username \
-Dhttp.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
A configuração equivalente que usa variáveis de ambiente é:
```
// Set the following environment variables.
// $ export HTTP_PROXY="http://username:password@example.com:1234"
// $ export NO_PROXY="localhost|host.example.com"
// Set the 'useSystemPropertyValues' to false on the proxy configuration.
SdkHttpClient apacheHttpClient = UrlConnectionHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.useSystemPropertyValues(Boolean.FALSE)
.build())
.build();
// Run the application.
// $ java -cp ... App
```
**nota**
Atualmente, o cliente HTTP URLConnection baseado não oferece suporte às propriedades do sistema proxy HTTPS ou à variável de ambiente HTTPS\$1PROXY.
# Configurar o cliente HTTP baseado em Netty
O cliente HTTP padrão para operações assíncronas no AWS SDK for Java 2.x é o baseado em Netty. [NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html) O cliente baseado em Netty é baseado na estrutura de rede assíncrona orientada por eventos do [projeto Netty](https://netty.io/).
Como cliente HTTP alternativo, é possível usar o novo [cliente HTTP baseado em AWS CRT](http-configuration-crt.md). Este tópico mostra como configurar o `NettyNioAsyncHttpClient`.
## Acesse o `NettyNioAsyncHttpClient`
Na maioria das situações, você usa o `NettyNioAsyncHttpClient` sem nenhuma configuração explícita em programas assíncronos. Você declara seus clientes de serviço assíncronos e o SDK configurará o `NettyNioAsyncHttpClient` com valores padrão para você.
Se você quiser configurar o `NettyNioAsyncHttpClient` explicitamente ou usá-lo com vários clientes de serviço, precisará disponibilizá-lo para configuração.
### Nenhuma configuração necessária
Quando você declara uma dependência de um cliente de serviço no Maven, o SDK adiciona uma dependência de *tempo de execução* ao artefato `netty-nio-client`. Isso torna a classe `NettyNioAsyncHttpClient` disponível para o código em runtime, mas não no momento da compilação. Se você não estiver configurando o cliente HTTP baseado em Netty, não precisará especificar uma dependência para ele.
No seguinte trecho XML de um arquivo `pom.xml` do Maven, a dependência declarada com `dynamodb-enhanced` traz transitivamente o cliente HTTP baseado em Netty. Você não precisa declarar uma dependência especificamente para isso.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
dynamodb-enhanced
```
Com essas dependências, você não pode fazer nenhuma alteração na configuração HTTP, pois a biblioteca `NettyNioAsyncHttpClient` está apenas no caminho de classe em runtime.
### Configuração necessária
Para configurar o `NettyNioAsyncHttpClient`, você precisa adicionar uma dependência no artefato `netty-nio-client` em tempo de *compilação*.
Consulte o exemplo a seguir de um arquivo `pom.xml` do Maven para configurar o `NettyNioAsyncHttpClient`.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
dynamodb-enhanced
software.amazon.awssdk
netty-nio-client
```
## Usar e configurar o `NettyNioAsyncHttpClient`
Você pode configurar uma instância do `NettyNioAsyncHttpClient` junto com a criação de um cliente de serviço ou pode configurar uma única instância para compartilhar entre vários clientes de serviço.
Com qualquer abordagem, você usa o [NettyNioAsyncHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.Builder.html) para configurar as propriedades da instância do cliente HTTP baseada em Netty.
### Prática recomendada: dedicar uma instância `NettyNioAsyncHttpClient` a um cliente de serviço
Se você precisar configurar uma instância do `NettyNioAsyncHttpClient`, recomendamos criar uma instância `NettyNioAsyncHttpClient` dedicada. Faça isso usando o método `httpClientBuilder` do builder do cliente do serviço. Dessa forma, o ciclo de vida do cliente HTTP é gerenciado pelo SDK, o que ajuda a evitar possíveis vazamentos de memória se a instância do `NettyNioAsyncHttpClient` não for fechada quando não for mais necessária.
O exemplo a seguir cria uma instância `DynamoDbAsyncClient`, que também é usada por uma instância `DynamoDbEnhancedAsyncClient`. A instância `DynamoDbAsyncClient` contém a instância `NettyNioAsyncHttpClient` com valores `connectionTimeout` e `maxConcurrency`. A instância HTTP é criada usando o método `httpClientBuilder` do `DynamoDbAsyncClient.Builder`.
**Importações**
```
import software.amazon.awssdk.auth.credentials.EnvironmentVariableCredentialsProvider;
import software.amazon.awssdk.awscore.defaultsmode.DefaultsMode;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedAsyncClient;
import software.amazon.awssdk.enhanced.dynamodb.extensions.AutoGeneratedTimestampRecordExtension;
import software.amazon.awssdk.http.nio.netty.NettyNioAsyncHttpClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;
import java.time.Duration;
```
**Código**
```
// DynamoDbAsyncClient is the lower-level client used by the enhanced client.
DynamoDbAsyncClient dynamoDbAsyncClient =
DynamoDbAsyncClient
.builder()
.httpClientBuilder(NettyNioAsyncHttpClient.builder()
.connectionTimeout(Duration.ofMillis(5_000))
.maxConcurrency(100)
.tlsNegotiationTimeout(Duration.ofMillis(3_500)))
.defaultsMode(DefaultsMode.IN_REGION)
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.build();
// Singleton: Use dynamoDbAsyncClient and enhancedClient for all requests.
DynamoDbEnhancedAsyncClient enhancedClient =
DynamoDbEnhancedAsyncClient
.builder()
.dynamoDbClient(dynamoDbAsyncClient)
.extensions(AutoGeneratedTimestampRecordExtension.create())
.build();
// Perform work with the dynamoDbAsyncClient and enhancedClient.
// Requests completed: Close dynamoDbAsyncClient.
dynamoDbAsyncClient.close();
```
### Abordagem alternativa: compartilhar uma instância `NettyNioAsyncHttpClient`
Para ajudar a reduzir o uso de recursos e memória do seu aplicativo, você pode configurar um `NettyNioAsyncHttpClient` e compartilhá-lo entre vários clientes de serviço. O pool de conexões HTTP será compartilhado, o que reduz o uso de recursos.
**nota**
Quando uma instância `NettyNioAsyncHttpClient` é compartilhada, você deve fechá-la quando ela estiver pronta para ser descartada. O SDK não fechará a instância quando o cliente de serviço for fechado.
O exemplo a seguir configura um cliente HTTP baseado em Netty, que é usado por dois clientes de serviço. A instância `NettyNioAsyncHttpClient` configurada é transmitida ao método `httpClient` de cada criador. Quando os clientes do serviço e o cliente HTTP não são mais necessários, o código os fecha explicitamente. O código fecha o cliente HTTP por último.
**Importações**
```
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.s3.S3Client;
```
**Código**
```
// Create a NettyNioAsyncHttpClient shared instance.
SdkAsyncHttpClient nettyHttpClient = NettyNioAsyncHttpClient.builder().maxConcurrency(100).build();
// Singletons: Use the s3AsyncClient, dbAsyncClient, and enhancedAsyncClient for all requests.
S3AsyncClient s3AsyncClient =
S3AsyncClient.builder()
.httpClient(nettyHttpClient)
.build();
DynamoDbAsyncClient dbAsyncClient =
DynamoDbAsyncClient.builder()
.httpClient(nettyHttpClient)
.defaultsMode(DefaultsMode.IN_REGION)
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.build();
DynamoDbEnhancedAsyncClient enhancedAsyncClient =
DynamoDbEnhancedAsyncClient.builder()
.dynamoDbClient(dbAsyncClient)
.extensions(AutoGeneratedTimestampRecordExtension.create())
.build();
// Perform work with s3AsyncClient, dbAsyncClient, and enhancedAsyncClient.
// Requests completed: Close all service clients.
s3AsyncClient.close();
dbAsyncClient.close()
nettyHttpClient.close(); // Explicitly close nettyHttpClient.
```
## Configurar a negociação do protocolo ALPN
O ALPN (negociação do protocolo da camada da aplicação) é uma extensão TLS que permite que a camada da aplicação negocie qual protocolo deve ser executado em uma conexão segura de uma maneira que evite viagens de ida e volta adicionais e ofereça melhor desempenho.
Para permitir que o cliente HTTP baseado em Netty use o ALPN, chame os métodos do compilador conforme mostrado no seguinte trecho:
```
import software.amazon.awssdk.http.Protocol;
import software.amazon.awssdk.http.ProtocolNegotiation;
import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
import software.amazon.awssdk.http.nio.netty.NettyNioAsyncHttpClient;
import software.amazon.awssdk.services.transcribestreaming.TranscribeStreamingAsyncClient;
// Configure the Netty-based HTTP client to use the ALPN protocol.
SdkAsyncHttpClient nettyClient = NettyNioAsyncHttpClient.builder()
.protocol(Protocol.HTTP2)
.protocolNegotiation(ProtocolNegotiation.ALPN)
.build();
// Use the Netty-based HTTP client with a service client.
TranscribeStreamingAsyncClient transcribeClient = TranscribeStreamingAsyncClient.builder()
.httpClient(nettyClient)
.build();
```
Atualmente, a negociação do protocolo ALPN funciona somente com o protocolo HTTP/2, conforme mostrado no trecho anterior.
## Exemplo de configuração do proxy
O trecho de código a seguir usa o [builder de configuração de proxy para o cliente HTTP Netty](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/ProxyConfiguration.Builder.html).
```
SdkAsyncHttpClient nettyHttpClient = NettyNioAsyncHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.scheme("https")
.host("myproxy")
.port(1234)
.username("username")
.password("password")
.nonProxyHosts(Set.of("localhost", "host.example.com"))
.build())
.build();
```
As propriedades equivalentes do sistema Java para a configuração do proxy são mostradas no trecho da linha de comando a seguir.
```
$ java -Dhttps.proxyHost=myproxy -Dhttps.proxyPort=1234 -Dhttps.proxyUser=username \
-Dhttps.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
**Importante**
Para usar qualquer uma das propriedades do sistema proxy HTTPS, a propriedade `scheme` deve ser definida no código como `https`. Se a propriedade scheme não estiver definida no código, o esquema usará HTTP como padrão, e o SDK procurará somente as propriedades do sistema `http.*`.
A configuração equivalente que usa variáveis de ambiente é:
```
// Set the following environment variables.
// $ export HTTPS_PROXY="https://username:password@myproxy:1234"
// $ export NO_PROXY="localhost|host.example.com"
// Set the 'useSystemPropertyValues' to false on the proxy configuration.
SdkAsyncHttpClient nettyHttpClient = NettyNioAsyncHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.useSystemPropertyValues(Boolean.FALSE)
.build())
.build();
// Run the application.
// $ java -cp ... App
```
# Configurar clientes AWS HTTP baseados em CRT
Os clientes HTTP AWS baseados em CRT incluem o síncrono e o assíncrono. [AwsCrtHttpClient[AwsCrtAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.html)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.html) Os clientes HTTP AWS baseados em CRT oferecem os seguintes benefícios do cliente HTTP:
+ Menor tempo de inicialização do SDK
+ Menor espaço ocupado na memória
+ Tempo de latência reduzido
+ Gerenciamento de integridade da conexão
+ balanceamento de carga do DNS
**AWS Componentes baseados em CRT no SDK**
Os clientes *HTTP AWS * baseados em CRT, descritos neste tópico, e o cliente *S3 AWS * baseado em CRT são componentes diferentes no SDK.
Os **clientes HTTP baseados em AWS CRT** síncronos e assíncronos são implementações da interface de cliente HTTP do SDK usadas para a comunicação HTTP em geral. Eles são alternativas aos outros clientes HTTP síncronos ou assíncronos no SDK, com benefícios adicionais.
O **[cliente S3 AWS baseado em CRT](crt-based-s3-client.md)** é uma implementação da AsyncClient interface [S3](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html) e é usado para trabalhar com o serviço Amazon S3. É uma alternativa à implementação da interface `S3AsyncClient` baseada em Java e oferece vários benefícios.
Embora ambos os componentes usem bibliotecas do [AWS Common Runtime](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html), os clientes HTTP AWS baseados em CRT não usam a [biblioteca aws-c-s 3](https://github.com/awslabs/aws-c-s3) e não oferecem suporte aos recursos da API de upload de [várias partes do S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html). O cliente S3 AWS baseado em CRT, por outro lado, foi criado especificamente para oferecer suporte aos recursos da API de upload de várias partes do S3.
## Acesse os clientes AWS HTTP baseados em CRT
Antes de usar os clientes HTTP AWS baseados em CRT, adicione o `aws-crt-client` artefato com uma versão mínima de 2.22.0 às dependências do seu projeto.
Use uma das opções a seguir para configurar o arquivo `pom.xml` do Maven.
**nota**
Você pode optar por usar a *opção jar específica da plataforma* se precisar manter o tamanho das dependências de tempo de execução menor, por exemplo, se seu aplicativo for executado em uma função. AWS Lambda
------
#### [ Uber-jar option ]
Por padrão, o `aws-crt-client` usa um uber-jar de artefatos AWS CRT que contém binários para várias plataformas, incluindo Linux, Windows e macOS.
```
2.29.10*
software.amazon.awssdk
bom
${aws.sdk.version}
pom
import
software.amazon.awssdk
aws-crt-client
```
\$1Substitua a versão mostrada em vermelho pela versão do Java SDK que você deseja usar. Encontre as últimas novidades no [Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).
------
#### [ Platform-specific jar option ]
*Para restringir o Java Runtime à versão específica da plataforma da biblioteca AWS CRT, faça as seguintes alterações na opção Uber-JAR.*
+ Adicione um elemento `exclusions` ao artefato `aws-crt-client` do SDK. Essa exclusão impede que o SDK use transitivamente o uber-jar CRT. AWS
+ Adicione um elemento de dependência para a versão específica da plataforma AWS CRT de que você precisa. Consulte as **etapas para determinar a versão do artefato AWS CRT** abaixo para saber como determinar a versão correta.
```
2.29.101
software.amazon.awssdk
bom
${aws.sdk.java.version}
pom
import
software.amazon.awssdk
aws-crt-client
software.amazon.awssdk.crt
aws-crt
software.amazon.awssdk.crt
aws-crt
0.31.32
linux-x86_643
```
1Substitua a versão mostrada em vermelho pela versão do Java SDK que você deseja usar. Encontre as últimas novidades no [Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).
2Substitua a versão de `software.amazon.awssdk.crt:aws-crt` que seria fornecida pela *opção Uber-JAR*. Consulte as **etapas a seguir para determinar a versão do artefato AWS CRT**.
3Substitua o valor `classifier` por um para sua plataforma. Consulte a GitHub página AWS CRT para Java para obter uma [lista dos valores disponíveis](https://github.com/awslabs/aws-crt-java?tab=readme-ov-file#platform-specific-jars).
**Etapas para determinar a versão do artefato AWS CRT**
Use as etapas a seguir para determinar a versão do artefato AWS CRT compatível com a versão do SDK for Java que você está usando.
1. Configure o arquivo `pom.xml` conforme mostrado na *opção Uber-JAR*. Essa configuração permite que você veja qual versão do `software.amazon.awssdk.crt:aws-crt` o SDK traz por padrão.
1. Na raiz do projeto (no mesmo diretório do arquivo `pom.xml`), execute o seguinte comando do Maven:
```
mvn dependency:tree -Dincludes=software.amazon.awssdk.crt:aws-crt
```
O Maven pode realizar outras ações, mas no final você deve ver a saída do console da dependência `software.amazon.awssdk.crt:aws-crt` que o SDK usa transitivamente. O trecho a seguir mostra um exemplo de saída com base em uma versão do SDK do `2.29.10`:
```
[INFO] org.example:yourProject:jar:1.0-SNAPSHOT
[INFO] \- software.amazon.awssdk:aws-crt-client:jar:2.29.10:compile
[INFO] \- software.amazon.awssdk.crt:aws-crt:jar:0.31.3:compile
```
1. Use a versão que o console mostra para o artefato `software.amazon.awssdk.crt:aws-crt`. Nesse caso, adicione `0.31.3` ao arquivo `pom.xml`.
------
## Use e configure um cliente HTTP AWS baseado em CRT
Você pode configurar um cliente HTTP AWS baseado em CRT junto com a criação de um cliente de serviço ou pode configurar uma única instância para compartilhar entre vários clientes de serviço.
Com qualquer abordagem, você usa um construtor para [configurar as propriedades da instância](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.Builder.html) do cliente HTTP AWS baseada em CRT.
### Prática recomendada: dedicar uma instância do a um cliente de serviço
Se você precisar configurar uma instância de um cliente HTTP AWS baseado em CRT, recomendamos que você dedique a instância construindo-a junto com o cliente de serviço. Faça isso usando o método `httpClientBuilder` do builder do cliente do serviço. Dessa forma, o ciclo de vida do cliente HTTP é gerenciado pelo SDK, o que ajuda a evitar possíveis vazamentos de memória se a instância do cliente HTTP AWS baseada em CRT não for fechada quando não for mais necessária.
O exemplo a seguir cria um cliente de serviço S3 e configura um cliente HTTP AWS baseado em CRT com valores e. `connectionTimeout` `maxConcurrency`
------
#### [ Synchronous client ]
**Importações**
```
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Código**
```
// Singleton: Use s3Client for all requests.
S3Client s3Client = S3Client.builder()
.httpClientBuilder(AwsCrtHttpClient
.builder()
.connectionTimeout(Duration.ofSeconds(3))
.maxConcurrency(100))
.build();
// Perform work with the s3Client.
// Requests completed: Close the s3Client.
s3Client.close();
```
------
#### [ Asynchronous client ]
**Importações**
```
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import java.time.Duration;
```
**Código**
```
// Singleton: Use s3AsyncClient for all requests.
S3AsyncClient s3AsyncClient = S3AsyncClient.builder()
.httpClientBuilder(AwsCrtAsyncHttpClient
.builder()
.connectionTimeout(Duration.ofSeconds(3))
.maxConcurrency(100))
.build();
// Perform work with the s3AsyncClient.
// Requests completed: Close the s3AsyncClient.
s3AsyncClient.close();
```
------
### Abordagem alternativa: compartilhar uma instância do
Para ajudar a reduzir o uso de recursos e memória do seu aplicativo, você pode configurar um cliente HTTP AWS baseado em CRT e compartilhá-lo entre vários clientes de serviço. O pool de conexões HTTP será compartilhado, o que reduz o uso de recursos.
**nota**
Quando uma instância de cliente HTTP AWS baseada em CRT é compartilhada, você deve fechá-la quando ela estiver pronta para ser descartada. O SDK não fechará a instância quando o cliente de serviço for fechado.
O exemplo a seguir configura uma instância de cliente HTTP AWS baseada em CRT com valores e. `connectionTimeout` `maxConcurrency` A instância configurada é transmitida ao método `httpClient` do criador de cada cliente de serviço. Quando os clientes do serviço e o cliente HTTP não são mais necessários, eles são explicitamente fechados. O cliente HTTP é fechado por último.
------
#### [ Synchronous client ]
**Importações**
```
import software.amazon.awssdk.auth.credentials.EnvironmentVariableCredentialsProvider;
import software.amazon.awssdk.awscore.defaultsmode.DefaultsMode;
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Código**
```
// Create an AwsCrtHttpClient shared instance.
SdkHttpClient crtHttpClient = AwsCrtHttpClient.builder()
.connectionTimeout(Duration.ofSeconds(3))
.maxConcurrency(100)
.build();
// Singletons: Use the s3Client and dynamoDbClient for all requests.
S3Client s3Client = S3Client.builder()
.httpClient(crtHttpClient)
.credentialsProvider(EnvironmentVariableCredentialsProvider.crea
.defaultsMode(DefaultsMode.IN_REGION)
.region(Region.US_EAST_1)
.build();
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.httpClient(crtHttpClient)
.credentialsProvider(EnvironmentVariableCredentialsProvider.crea
.defaultsMode(DefaultsMode.IN_REGION)
.region(Region.US_EAST_1)
.build();
// Requests completed: Close all service clients.
s3Client.close();
dynamoDbClient.close();
crtHttpClient.close(); // Explicitly close crtHttpClient.
```
------
#### [ Asynchronous client ]
**Importações**
```
import software.amazon.awssdk.auth.credentials.EnvironmentVariableCredentialsProvider;
import software.amazon.awssdk.awscore.defaultsmode.DefaultsMode;
import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import java.time.Duration;
```
**Código**
```
// Create an AwsCrtAsyncHttpClient shared instance.
SdkAsyncHttpClient crtAsyncHttpClient = AwsCrtAsyncHttpClient.builder()
.connectionTimeout(Duration.ofSeconds(3))
.maxConcurrency(100)
.build();
// Singletons: Use the s3AsyncClient and dynamoDbAsyncClient for all requests.
S3AsyncClient s3AsyncClient = S3AsyncClient.builder()
.httpClient(crtAsyncHttpClient)
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.defaultsMode(DefaultsMode.IN_REGION)
.region(Region.US_EAST_1)
.build();
DynamoDbAsyncClient dynamoDbAsyncClient = DynamoDbAsyncClient.builder()
.httpClient(crtAsyncHttpClient)
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.defaultsMode(DefaultsMode.IN_REGION)
.region(Region.US_EAST_1)
.build();
// Requests completed: Close all service clients.
s3AsyncClient.close();
dynamoDbAsyncClient.close();
crtAsyncHttpClient.close(); // Explicitly close crtAsyncHttpClient.
```
------
## Defina um cliente HTTP AWS baseado em CRT como padrão
Você pode configurar seu arquivo de compilação do Maven para que o SDK use um cliente HTTP AWS baseado em CRT como o cliente HTTP padrão para clientes de serviço.
Você faz isso adicionando um elemento `exclusions` com as dependências padrão do cliente HTTP a cada artefato do cliente de serviço.
No `pom.xml` exemplo a seguir, o SDK usa um cliente HTTP AWS baseado em CRT para serviços do S3. Se o cliente de serviço no código for um `S3AsyncClient`, o SDK usará `AwsCrtAsyncHttpClient`. Se o cliente de serviço for um S3Client, o SDK usará `AwsCrtHttpClient`. Com essa configuração, o cliente HTTP assíncrono padrão baseado em Netty e o HTTP síncrono padrão baseado em Apache não estão disponíveis.
```
VERSION
software.amazon.awssdk
s3
${aws.sdk.version}
software.amazon.awssdk
netty-nio-client
software.amazon.awssdk
apache-client
software.amazon.awssdk
aws-crt-client
```
Visite o repositório central do Maven para obter o valor mais recente [https://central.sonatype.com/artifact/software.amazon.awssdk/bom](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).
**nota**
Se vários clientes de serviço forem declarados em um arquivo `pom.xml`, todos precisarão do elemento XML `exclusions`.
### Usar uma propriedade do sistema Java
Para usar os clientes HTTP AWS baseados em CRT como o HTTP padrão para seu aplicativo, você pode definir a propriedade do sistema Java `software.amazon.awssdk.http.async.service.impl` com um valor de. `software.amazon.awssdk.http.crt.AwsCrtSdkHttpService`
Para definir durante a inicialização do aplicativo, execute um comando semelhante ao seguinte.
```
java app.jar -Dsoftware.amazon.awssdk.http.async.service.impl=\
software.amazon.awssdk.http.crt.AwsCrtSdkHttpService
```
Use o trecho de código a seguir para definir a propriedade do sistema no código do seu aplicativo.
```
System.setProperty("software.amazon.awssdk.http.async.service.impl",
"software.amazon.awssdk.http.crt.AwsCrtSdkHttpService");
```
**nota**
Você precisa adicionar uma dependência do `aws-crt-client` artefato em seu `poml.xml` arquivo ao usar uma propriedade do sistema para configurar o uso dos clientes HTTP baseados em AWS CRT.
## Configuração avançada de clientes HTTP AWS baseados em CRT
Você pode usar várias configurações dos clientes HTTP AWS baseados em CRT, incluindo configuração de integridade da conexão e tempo máximo de inatividade. Você pode revisar as [opções de configuração disponíveis](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.Builder.html) para o `AwsCrtAsyncHttpClient`. É possível configurar as mesmas opções para o `AwsCrtHttpClient`.
### Configuração de integridade da conexão
Você pode configurar a integridade da conexão para os clientes HTTP AWS baseados em CRT usando o `connectionHealthConfiguration` método no construtor de clientes HTTP.
O exemplo a seguir cria um cliente de serviço S3 que usa uma instância de cliente HTTP AWS baseada em CRT configurada com configuração de integridade da conexão e um tempo máximo de inatividade para conexões.
------
#### [ Synchronous client ]
**Importações**
```
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Código**
```
// Singleton: Use the s3Client for all requests.
S3Client s3Client = S3Client.builder()
.httpClientBuilder(AwsCrtHttpClient
.builder()
.connectionHealthConfiguration(builder -> builder
.minimumThroughputInBps(32000L)
.minimumThroughputTimeout(Duration.ofSeconds(3)))
.connectionMaxIdleTime(Duration.ofSeconds(5)))
.build();
// Perform work with s3Client.
// Requests complete: Close the service client.
s3Client.close();
```
------
#### [ Asynchronous client ]
**Importações**
```
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import java.time.Duration;
```
**Código**
```
// Singleton: Use the s3AsyncClient for all requests.
S3AsyncClient s3AsyncClient = S3AsyncClient.builder()
.httpClientBuilder(AwsCrtAsyncHttpClient
.builder()
.connectionHealthConfiguration(builder -> builder
.minimumThroughputInBps(32000L)
.minimumThroughputTimeout(Duration.ofSeconds(3)))
.connectionMaxIdleTime(Duration.ofSeconds(5)))
.build();
// Perform work with s3AsyncClient.
// Requests complete: Close the service client.
s3AsyncClient.close();
```
------
## Suporte a HTTP/2
O protocolo HTTP/2 ainda não é suportado nos clientes HTTP AWS baseados em CRT, mas está planejado para uma versão futura.
Enquanto isso, se você estiver usando clientes de serviço que exigem suporte a HTTP/2, como o [KinesisAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/kinesis/KinesisAsyncClient.html)ou o [TranscribeStreamingAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/transcribestreaming/TranscribeStreamingAsyncClient.html), considere usar o. [NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html)
## Exemplo de configuração do proxy
O trecho de código a seguir mostra o uso do [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/ProxyConfiguration.Builder.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/ProxyConfiguration.Builder.html) que você usa para definir a configuração de proxy no código.
------
#### [ Synchronous client ]
**Importações**
```
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.http.crt.ProxyConfiguration;
```
**Código**
```
SdkHttpClient crtHttpClient = AwsCrtHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.scheme("https")
.host("myproxy")
.port(1234)
.username("username")
.password("password")
.nonProxyHosts(Set.of("localhost", "host.example.com"))
.build())
.build();
```
------
#### [ Asynchronous client ]
**Importações**
```
import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.http.crt.ProxyConfiguration;
```
**Código**
```
SdkAsyncHttpClient crtAsyncHttpClient = AwsCrtAsyncHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.scheme("https")
.host("myproxy")
.port(1234)
.username("username")
.password("password")
.nonProxyHosts(Set.of("localhost", "host.example.com"))
.build())
.build();
```
------
As propriedades equivalentes do sistema Java para a configuração do proxy são mostradas no trecho da linha de comando a seguir.
```
$ java -Dhttps.proxyHost=myproxy -Dhttps.proxyPort=1234 -Dhttps.proxyUser=username \
-Dhttps.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
**Importante**
Para usar qualquer uma das propriedades do sistema proxy HTTPS, a propriedade `scheme` deve ser definida no código como `https`. Se a propriedade scheme não estiver definida no código, o esquema usará HTTP como padrão, e o SDK procurará somente as propriedades do sistema `http.*`.
A configuração equivalente que usa variáveis de ambiente é:
```
// Set the following environment variables.
// $ export HTTPS_PROXY="https://username:password@myproxy:1234"
// $ export NO_PROXY="localhost|host.example.com"
// Set the 'useSystemPropertyValues' to false on the proxy configuration.
SdkAsyncHttpClient crtAsyncHttpClient = AwsCrtAsyncHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.scheme("https")
.useSystemPropertyValues(Boolean.FALSE)
.build())
.build();
// Run the application.
// $ java -cp ... App
```
# Configurar proxies HTTP
Você pode configurar proxies HTTP usando código, definindo propriedades do sistema Java ou definindo variáveis de ambiente.
## Configurar no código
Você configura proxies no código com um builder `ProxyConfiguration` específico do cliente ao criar o cliente de serviço. O código a seguir mostra um exemplo de configuração de proxy para um cliente HTTP baseado em Apache que é usado por um cliente de serviço do Amazon S3.
```
SdkHttpClient httpClient1 = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.endpoint(URI.create("http://proxy.example.com"))
.username("username")
.password("password")
.addNonProxyHost("localhost")
.build())
.build();
S3Client s3Client = S3Client.builder()
.httpClient(httpClient)
.build();
```
A seção de cada cliente HTTP neste tópico mostra um exemplo de configuração de proxy.
+ [Cliente HTTP Apache](http-configuration-apache.md#http-configuration-apache-proxy-conf-ex)
+ [URLConnectioncliente HTTP baseado](http-configuration-url.md#http-configuration-url-proxy-conf-ex)
+ [Cliente HTTP baseado em Netty](http-configuration-netty.md#http-config-netty-proxy-ex)
+ [AWS Cliente HTTP baseado em CRT](http-configuration-crt.md#http-config-crt-proxy-ex)
## Configurar proxies HTTP com configurações externas
Mesmo que você não use explicitamente um compilador `ProxyConfiguration` no código, o SDK procura configurações externas para definir uma configuração de proxy padrão.
Por padrão, o SDK primeiro pesquisa as propriedades do sistema de JVM. Se pelo menos uma propriedade for encontrada, o SDK usará o valor e quaisquer outros valores de propriedade do sistema. Se nenhuma propriedade do sistema estiver disponível, o SDK procurará variáveis de ambiente proxy.
O SDK pode usar as seguintes propriedades do sistema Java e variáveis de ambiente.
**Propriedades do sistema Java**
| Propriedades do sistema | Description | Suporte do cliente HTTP |
| --- | --- | --- |
| http.proxyHost | Nome do host do servidor proxy HTTP | Todos |
| http.proxyPort | Número da porta do servidor proxy HTTP | Todos |
| http.proxyUser | Nome de usuário para autenticação de proxy HTTP | Todos |
| http.proxyPassword | Senha para autenticação de proxy HTTP | Todos |
| http. nonProxyHosts | Lista de hosts que devem ser acessados diretamente, contornando o proxy. [Essa lista também é válida quando o HTTPS é usado](https://docs.oracle.com/javase/8/docs/technotes/guides/net/proxies.html). | Todos |
| https.proxyHost | Nome do host do servidor proxy HTTPS | Netty, CRT |
| https.proxyPort | Número da porta do servidor proxy HTTPS | Netty, CRT |
| https.proxyUser | Nome de usuário para autenticação de proxy HTTPS | Netty, CRT |
| https.proxyPassword | Senha para autenticação de proxy HTTPS | Netty, CRT |
**Variáveis de ambiente**
| Variável de ambiente | Description | Suporte do cliente HTTP |
| --- | --- | --- |
| HTTP\$1PROXY1 | Um URL válido com um esquema de HTTP | Todos |
| HTTPS\$1PROXY1 | Um URL válido com um esquema de HTTPS | Netty, CRT |
| NO\$1PROXY2 | Lista de hosts que devem ser acessados diretamente, contornando o proxy. A lista é válida tanto para HTTP quanto para HTTPS. | Todos |
### Exibir notas principais e de rodapé
**Tudo**: todos os clientes HTTP oferecidos pelo SDK: `UrlConnectionHttpClient`, `ApacheHttpClient`, `NettyNioAsyncHttpClient` e `AwsCrtAsyncHttpClient`.
**Netty**: o cliente HTTP baseado em Netty (`NettyNioAsyncHttpClient`).
**CRT** - Os clientes HTTP AWS baseados em CRT, (e)`AwsCrtHttpClient`. `AwsCrtAsyncHttpClient`
1A variável de ambiente consultada, seja `HTTP_PROXY` ou `HTTPS_PROXY`, depende da configuração do esquema na `ProxyConfiguration` do cliente. O esquema padrão é HTTP. O seguinte trecho mostra como alterar o esquema para HTTPS usado para resolução de variáveis de ambiente.
```
SdkHttpClient httpClient = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.scheme("https")
.build())
.build();
```
2A variável de ambiente `NO_PROXY` permite uma combinação de separadores “\$1” e “,” entre nomes de host. Os nomes de host podem incluir o caractere curinga “\$1”.
## Usar uma combinação de configurações
É possível usar uma combinação de configurações de proxy HTTP no código, nas propriedades do sistema e nas variáveis de ambiente.
**Example – configuração fornecida por uma propriedade do sistema e pelo código**
```
// Command line with the proxy password set as a system property.
$ java -Dhttp.proxyPassword=SYS_PROP_password -cp ... App
// Since the 'useSystemPropertyValues' setting is 'true' (the default), the SDK will supplement
// the proxy configuration in code with the 'http.proxyPassword' value from the system property.
SdkHttpClient apacheHttpClient = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.endpoint(URI.create("http://localhost:1234"))
.username("username")
.build())
.build();
// Use the apache HTTP client with proxy configuration.
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.httpClient(apacheHttpClient)
.build();
```
O SDK resolve as seguintes configurações de proxy.
```
Host = localhost
Port = 1234
Password = SYS_PROP_password
UserName = username
Non ProxyHost = null
```
**Example – as propriedades do sistema e as variáveis de ambiente estão disponíveis**
Cada compilador do `ProxyConfiguration` de cliente HTTP oferece configurações chamadas `useSystemPropertyValues` e `useEnvironmentVariablesValues`. Por padrão, ambas as configurações são `true`. Quando `true`, o SDK usa automaticamente valores de propriedade do sistema ou variáveis de ambiente para opções que não são fornecidas pelo compilador `ProxyConfiguration`.
Propriedades do sistema têm precedência sobre variáveis de ambiente. Se uma propriedade do sistema de proxy HTTP for encontrada, o SDK recuperará ***todos*** os valores das propriedades do sistema e nenhum das variáveis de ambiente. Se você quiser priorizar as variáveis de ambiente em relação às propriedades do sistema, defina `useSystemPropertyValues` como `false`.
Neste exemplo, as seguintes configurações estão disponíveis no runtime:
```
// System properties
http.proxyHost=SYS_PROP_HOST.com
http.proxyPort=2222
http.password=SYS_PROP_PASSWORD
http.user=SYS_PROP_USER
// Environment variables
HTTP_PROXY="http://EnvironmentUser:EnvironmentPassword@ENV_VAR_HOST:3333"
NO_PROXY="environmentnonproxy.host,environmentnonproxy2.host:1234"
```
O cliente do serviço é criado com uma das declarações a seguir. Nenhuma das declarações define explicitamente uma configuração de proxy.
```
DynamoDbClient client = DynamoDbClient.create();
DynamoDbClient client = DynamoDbClient.builder().build();
DynamoDbClient client = DynamoDbClient.builder()
.httpClient(ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.build())
.build())
.build();
```
As configurações de proxy a seguir são resolvidas pelo SDK:
```
Host = SYS_PROP_HOST.com
Port = 2222
Password = SYS_PROP_PASSWORD
UserName = SYS_PROP_USER
Non ProxyHost = null
```
Como o cliente de serviço tem configurações de proxy padrão, o SDK pesquisa as propriedades do sistema e, depois, as variáveis de ambiente. Como as configurações de propriedades do sistema têm precedência sobre as variáveis de ambiente, o SDK usa somente propriedades do sistema.
Se o uso das propriedades do sistema for alterado para `false` conforme mostrado no código a seguir, o SDK resolverá somente as variáveis de ambiente.
```
DynamoDbClient client = DynamoDbClient.builder()
.httpClient(ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.useSystemPropertyValues(Boolean.FALSE)
.build())
.build())
.build();
```
As configurações de proxy resolvidas usando HTTP são:
```
Host = ENV_VAR_HOST
Port = 3333
Password = EnvironmentPassword
UserName = EnvironmentUser
Non ProxyHost = environmentnonproxy.host, environmentnonproxy2.host:1234
```
# Configurar o cliente HTTP baseado em Apache 5.x
## Acesse o Apache5 HttpClient
Para usar o, `Apache5HttpClient` você deve adicionar uma dependência **apache5-client** e configurar explicitamente `Apache5HttpClient` em seus clientes de serviço.
```
software.amazon.awssdk
bom
2.41.0*
pom
import
software.amazon.awssdk
s3
software.amazon.awssdk
apache5-client
```
\$1Substitua a versão mostrada em vermelho pela versão do Java SDK que você deseja usar. Encontre as últimas novidades no [Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).
### Usar e configurar o `Apache5HttpClient`
Você pode configurar uma instância do `Apache5HttpClient` junto com a criação de um cliente de serviço ou pode configurar uma única instância para compartilhar entre vários clientes de serviço.
Com qualquer abordagem, você usa o [Apache5 HttpClient .Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache5/Apache5HttpClient.Builder.html) para configurar as propriedades do cliente HTTP baseado no Apache 5.
#### Melhor prática: dedicar uma HttpClient instância do Apache5 a um cliente de serviço
Se você precisar configurar uma instância do `Apache5HttpClient`, recomendamos que você crie a instância `Apache5HttpClient` dedicada. Você pode fazer isso usando o httpClientBuilder método do construtor do cliente de serviço. Dessa forma, o ciclo de vida do cliente HTTP é gerenciado pelo SDK, o que ajuda a evitar possíveis vazamentos de memória se a instância do `Apache5HttpClient` não for fechada quando não for mais necessária.
O exemplo a seguir cria um S3Client e configura a instância incorporada `Apache5HttpClient` com valores maxConnections e connectionTimeout. A instância HTTP é criada usando o método `httpClientBuilder` do `S3Client.Builder`.
**Importações**
```
import software.amazon.awssdk.http.apache5.Apache5HttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Código**
```
S3Client s3Client = S3Client // Singleton: Use the s3Client for all requests.
.builder()
.httpClientBuilder(Apache5HttpClient.builder()
.maxConnections(100)
.connectionTimeout(Duration.ofSeconds(5))
)
.build();
// Perform work with the s3Client.
s3Client.close(); // Requests completed: Close all service clients.
```
#### Abordagem alternativa: compartilhar uma instância do `Apache5HttpClient`
Para ajudar a reduzir o uso de recursos e memória do seu aplicativo, você pode configurar um `Apache5HttpClient` e compartilhá-lo entre vários clientes de serviço. O pool de conexões HTTP será compartilhado, o que reduz o uso de recursos.
**nota**
Quando uma instância do `Apache5HttpClient` é compartilhada, você deve fechá-la quando ela estiver pronta para ser descartada. O SDK não fechará a instância quando o cliente de serviço for fechado.
O exemplo a seguir configura um cliente HTTP baseado em Apache, que é usado por dois clientes de serviço. A `ApacheHttpClient` instância configurada é passada para o método HttpClient de cada construtor. Quando os clientes do serviço e o cliente HTTP não são mais necessários, o código os fecha explicitamente. O código fecha o cliente HTTP por último.
**Importações**
```
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.apache5.Apache5HttpClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.s3.S3Client;
```
**Código**
```
SdkHttpClient apache5HttpClient = Apache5HttpClient.builder()
.maxConnections(100).build();
// Singletons: Use the s3Client and dynamoDbClient for all requests.
S3Client s3Client =
S3Client.builder()
.httpClient(apache5HttpClient).build();
DynamoDbClient dynamoDbClient =
DynamoDbClient.builder()
.httpClient(apache5HttpClient).build();
// Perform work with the s3Client and dynamoDbClient.
// Requests completed: Close all service clients.
s3Client.close();
dynamoDbClient.close();
apache5HttpClient.close(); // Explicitly close apache5HttpClient.
```