Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Configure los clientes HTTP en el AWS SDK for Java 2.x
Puede cambiar el cliente HTTP para usarlo en su cliente de servicio, así como cambiar la configuración predeterminada de los clientes HTTP con AWS SDK for Java 2.x. En esta sección se describen los clientes HTTP y la configuración del SDK.
## Clientes HTTP disponibles en el SDK para Java
### Clientes síncronos
Los clientes HTTP sincrónicos del SDK para Java implementan la [SdkHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/SdkHttpClient.html)interfaz. Un cliente de servicio síncrono, como el `S3Client` o el `DynamoDbClient`, requiere el uso de un cliente HTTP síncrono. AWS SDK para Java Ofrece tres clientes HTTP sincrónicos.
**ApacheHttpClient (predeterminado)**
[ApacheHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html)es el cliente HTTP predeterminado para los clientes de servicios síncronos. Para obtener información acerca de cómo configurar el `ApacheHttpClient`, consulte [Configurar el cliente HTTP basado en Apache](http-configuration-apache.md).
**AwsCrtHttpClient**
[AwsCrtHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.html)proporciona E/S de alto rendimiento y sin bloqueo. Se basa en el cliente HTTP AWS Common Runtime (CRT). Para obtener información sobre cómo configurar el `AwsCrtHttpClient` y utilizar el servicio con los clientes, consulte [Configurar clientes AWS HTTP basados en CRT](http-configuration-crt.md).
**UrlConnectionHttpClient**
Para minimizar la cantidad de archivos jar y bibliotecas de terceros que utiliza la aplicación, puede utilizar el [UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html). Para obtener información acerca de cómo configurar el `UrlConnectionHttpClient`, consulte [Configurar el cliente HTTP URLConnection basado](http-configuration-url.md).
**Apache 5 HttpClient**
[Apache5 HttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache5/Apache5HttpClient.html) *es una versión actualizada `ApacheHttpClient` que se basa en Apache 5.x. HttpClient La versión 5.x* es la versión que Apache mantiene activamente y mejora la versión anterior utilizada al ofrecer compatibilidad con el ecosistema moderno de Java, incluida la compatibilidad con subprocesos virtuales para Java 2.1 y una mayor flexibilidad de registro mediante SLF4 J. que `Apache5HttpClient` sustituirá `ApacheHttpClient` como cliente síncrono predeterminado en una futura versión del AWS SDK para Java 2.x. `ApacheHttpClient` Cuenta con una API y características idénticas, lo que la hace ideal como reemplazo directo. Para obtener información acerca de cómo configurar el `Apache5HttpClient`, consulte [Configurar el cliente HTTP basado en Apache 5.x](http-configuration-apache5.md).
### Clientes asíncronos
Los clientes HTTP asíncronos del SDK for Java implementan la interfaz. [SdkAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/async/SdkAsyncHttpClient.html) Un cliente de servicio asíncrono, como el `S3AsyncClient` o el `DynamoDbAsyncClient`, requiere el uso de un cliente HTTP asíncrono. AWS SDK para Java Ofrece dos clientes HTTP asíncronos.
**NettyNioAsyncHttpClient (predeterminado)**
[NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html)es el cliente HTTP predeterminado que utilizan los clientes asíncronos. Para obtener información acerca de cómo configurar el `NettyNioAsyncHttpClient`, consulte [Configurar el cliente HTTP basado en Netty](http-configuration-netty.md).
**AwsCrtAsyncHttpClient**
[AwsCrtAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.html)Se basa en el cliente HTTP AWS Common Runtime (CRT). Para obtener información acerca de cómo configurar el `AwsCrtAsyncHttpClient`, consulte [Configurar clientes AWS HTTP basados en CRT](http-configuration-crt.md).
## Recomendaciones sobre el cliente HTTP
Al elegir una implementación de cliente HTTP entran en juego varios factores. Utilice la siguiente información para ayudarle en la decisión.
### Diagrama de flujo de recomendaciones
El siguiente diagrama de flujo proporciona una guía general para ayudarle a determinar qué cliente HTTP debe utilizar.
![\[Diagrama de flujo de recomendaciones sobre clientes HTTP.\]](http://docs.aws.amazon.com/es_es/sdk-for-java/latest/developer-guide/images/JavaDevGuide-HTTPflowchart-DI.png)
### Comparación de clientes HTTP
La siguiente tabla proporciona información detallada de cada cliente HTTP.
| Cliente HTTP | Sínc. or asínc. | Cuándo se debe usar | Limitación o inconveniente |
| --- | --- | --- | --- |
| Cliente HTTP basado en Apache *(cliente HTTP de sincronización predeterminado)* | Sincronizar | Úselo si prefiere una latencia baja en lugar de un alto rendimiento | Tiempo de startup más lento en comparación con otros clientes HTTP |
| Cliente HTTP basado en URLConnection | Sincronizar | Úselo si tiene requisitos estrictos para limitar las dependencias de terceros | No admite el método HTTP PATCH, que requieren algunas API, como las operaciones de Amazon APIGateway Update |
| AWS Cliente HTTP de sincronización basado en CRT 1 | Sincronizar | • Úselo si su aplicación se está ejecutando en AWS Lambda - Utilícelo si prefiere un alto rendimiento a una baja latencia • Úselo si prefiere clientes del SDK síncronos | Ya no se admiten las siguientes propiedades del sistema de Java. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sdk-for-java/latest/developer-guide/http-configuration.html) |
| Netty-based HTTP client *(cliente HTTP asíncrono predeterminado)* | Asíncrono | • Úselo si su aplicación invoca elementos APIs que requieren compatibilidad con HTTP/2, como la API de Kinesis [SubscribeToShard](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_SubscribeToShard.html) | Tiempo de startup más lento en comparación con otros clientes HTTP |
| AWS Cliente HTTP asíncrono basado en CRT 1 | Asíncrono | • Úselo si su aplicación se está ejecutando en AWS Lambda- Utilícelo si prefiere un alto rendimiento a una baja latencia• Úselo si prefiere clientes del SDK asíncronos | • No es compatible con clientes de servicio que requieran compatibilidad con HTTP/2, como `KinesisAsynClient` y `TranscribeStreamingAsyncClient` Ya no se admiten las siguientes propiedades del sistema de Java. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sdk-for-java/latest/developer-guide/http-configuration.html) |
1 Debido a sus ventajas adicionales, le recomendamos que utilice los clientes HTTP AWS basados en CRT si es posible.
## Valores predeterminados de configuración inteligente
La AWS SDK for Java 2.x versión 2.17.102 o posterior ofrece una función de configuración inteligente por defecto. Esta característica optimiza dos propiedades del cliente HTTP junto con otras propiedades que no afectan al cliente HTTP.
Los valores predeterminados de la configuración inteligente establecen valores razonables para las propiedades `connectTimeoutInMillis` y `tlsNegotiationTimeoutInMillis` en función del valor de modo predeterminado que proporcione. El valor de modo predeterminado se elige según las características de la aplicación.
[Para obtener más información sobre los valores predeterminados de la configuración inteligente y sobre cómo elegir el valor de modo predeterminado que mejor se adapte a sus aplicaciones, consulte la AWS SDKs Guía de referencia de herramientas y herramientas.](https://docs.aws.amazon.com/sdkref/latest/guide/feature-smart-config-defaults.html)
A continuación, se muestran cuatro formas de configurar el modo predeterminado para su aplicación.
------
#### [ Service client ]
Utilice el generador de clientes de servicio para configurar el modo predeterminado directamente en el cliente de servicio. El siguiente ejemplo establece el modo predeterminado en `auto` para el `DynamoDbClient`.
```
DynamoDbClient ddbClient = DynamoDbClient.builder()
.defaultsMode(DefaultsMode.AUTO)
.build();
```
------
#### [ System property ]
Puede usar la propiedad del `aws.defaultsMode` sistema para especificar el modo predeterminado. Si establece la propiedad del sistema en Java, debe establecerla antes de inicializar cualquier cliente de servicio.
En el siguiente ejemplo, se muestra cómo configurar el modo predeterminado en `auto` usar un conjunto de propiedades del sistema en Java.
```
System.setProperty("aws.defaultsMode", "auto");
```
En el siguiente ejemplo, se muestra cómo configurar el modo predeterminado como `auto` mediante una opción `-D` del comando `java`.
```
java -Daws.defaultsMode=auto
```
------
#### [ Environment variable ]
Defina un valor para la variable de entorno `AWS_DEFAULTS_MODE` para seleccionar el modo predeterminado de la aplicación.
La siguiente información muestra el comando que se debe ejecutar para establecer el valor del modo predeterminado como `auto` utilizando una variable de entorno.
| Sistema operativo | Comando para definir variables de entorno |
| --- | --- |
| Linux, macOS o Unix | export AWS\$1DEFAULTS\$1MODE=auto |
| Windows | set AWS\$1DEFAULTS\$1MODE=auto |
------
#### [ AWS config file ]
Puede añadir una propiedad de `defaults_mode` configuración al AWS `config` archivo compartido, como se muestra en el siguiente ejemplo.
```
[default]
defaults_mode = auto
```
------
Si define el modo predeterminado de forma global con la propiedad del sistema, la variable de entorno o el archivo de configuración AWS , puede sustituir la configuración cuando cree un cliente HTTP.
Al crear un cliente HTTP con el método `httpClientBuilder()`, la configuración se aplica solo a la instancia que se está creando. Un ejemplo de ello se muestra [aquí](http-configuration-netty.md#http-config-netty-one-client). En este ejemplo, el cliente HTTP basado en Netty anula cualquier valor de modo predeterminado establecido globalmente para `connectTimeoutInMillis` y `tlsNegotiationTimeoutInMillis`.
# Configurar el cliente HTTP basado en Apache
Los clientes del servicio sincrónico AWS SDK for Java 2.x utilizan un cliente HTTP basado en Apache de forma predeterminada. [ApacheHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html) El SDK `ApacheHttpClient` se basa en Apache. [HttpClient](https://hc.apache.org/httpcomponents-client-4.5.x/index.html)
El SDK también ofrece el [UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html), que se carga más rápido, pero tiene menos funciones. Para obtener información acerca de cómo configurar el `UrlConnectionHttpClient`, consulte [Configurar el cliente HTTP URLConnection basado](http-configuration-url.md).
Para ver el conjunto completo de opciones de configuración disponibles para el`ApacheHttpClient`, consulte [ApacheHttpClient.Builder y [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).
## Acceso al `ApacheHttpClient`
En la mayoría de las situaciones, `ApacheHttpClient` se utiliza sin ninguna configuración explícita. Declare sus clientes de servicios y el SDK configurará los `ApacheHttpClient` con valores estándar por usted.
Si quiere configurar de forma explícita el `ApacheHttpClient` o usarlo con varios clientes de servicio, tiene que hacerlo disponible para su configuración.
### No se necesita configuración
Cuando declara una dependencia de un cliente de servicio en Maven, el SDK añade una dependencia en *tiempo de ejecución* del artefacto `apache-client`. Esto hace que la clase `ApacheHttpClient` esté disponible para su código en el tiempo de ejecución, pero no en el de compilación. Si no está configurando el cliente HTTP basado en Apache, no necesita especificar una dependencia para él.
En el siguiente fragmento XML de un archivo `pom.xml` Maven, la dependencia declarada con `s3` trae de forma transitoria el cliente HTTP basado en Apache. No necesita declarar una dependencia específicamente para ella.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
s3
```
Con estas dependencias, no puede realizar ningún cambio en la configuración HTTP, ya que la biblioteca `ApacheHttpClient` solo se encuentra en la ruta de clases del tiempo de ejecución.
### Se necesita configuración
Para configurar el `ApacheHttpClient`, es necesario añadir una dependencia a la biblioteca `apache-client` en el momento de la *compilación*.
Consulte el siguiente ejemplo de un archivo `pom.xml` Maven para configurar el `ApacheHttpClient`.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
s3
software.amazon.awssdk
apache-client
```
## Utilizar y configurar el `ApacheHttpClient`
Puede configurar una instancia del `ApacheHttpClient` junto con la creación de un cliente de servicio, o configurar una sola instancia para compartirla entre varios clientes de servicio.
Con cualquiera de estos enfoques, utilice `[ApacheHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.Builder.html)` para configurar las propiedades de la instancia de cliente HTTP basada en Apache.
### Práctica recomendada: dedicar una instancia de `ApacheHttpClient` a un cliente de servicio
Si necesita configurar una instancia del `ApacheHttpClient`, le recomendamos que cree la instancia `ApacheHttpClient` dedicada. Puede hacerlo con el método `httpClientBuilder` del generador del cliente del servicio. De esta forma, el SDK administra el ciclo de vida del cliente HTTP, lo que ayuda a evitar posibles pérdidas de memoria si la instancia `ApacheHttpClient` no se cierra cuando ya no se necesita.
En el ejemplo siguiente, se crea un `S3Client` y se configura la instancia integrada de `ApacheHttpClient` con los valores `maxConnections` y `connectionTimeout`. La instancia HTTP se crea mediante el método `httpClientBuilder` de `S3Client.Builder`.
**Importaciones**
```
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.
```
### Enfoque alternativo: compartir una instancia `ApacheHttpClient`
Para reducir el uso de recursos y memoria en su aplicación, puede configurar un `ApacheHttpClient` y compartirlo entre varios clientes de servicio. El grupo de conexiones HTTP se compartirá, lo que reduce el uso de recursos.
**nota**
Al compartir una instancia de `ApacheHttpClient`, es preciso cerrarla cuando esté lista para ser eliminada. El SDK no cerrará la instancia cuando el cliente del servicio esté cerrado.
En el siguiente ejemplo, se configura un cliente HTTP basado en Apache, utilizado por dos clientes de servicio. La instancia de `ApacheHttpClient` configurada se pasa al método `httpClient` de cada creador. Cuando los clientes de servicio y el cliente HTTP ya no son necesarios, el código los cierra de forma explícita. El código cierra el cliente HTTP por última vez.
**Importaciones**
```
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.
```
## Ejemplo de configuración proxy
El siguiente fragmento de código utiliza el [generador de configuración proxy para el cliente HTTP de Apache](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();
```
Las propiedades del sistema Java equivalentes para la configuración del proxy se muestran en el siguiente fragmento de línea de comandos.
```
$ java -Dhttp.proxyHost=example.com -Dhttp.proxyPort=1234 -Dhttp.proxyUser=username \
-Dhttp.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
La configuración equivalente que usa variables de entorno es:
```
// 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**
El cliente HTTP de Apache no admite actualmente las propiedades del sistema proxy de HTTPS ni la variable de entorno HTTPS\$1PROXY.
# Configurar el cliente HTTP URLConnection basado
AWS SDK for Java 2.x Ofrece un cliente `[UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html)` HTTP más ligero en comparación con el predeterminado. `ApacheHttpClient` El `UrlConnectionHttpClient` se basa en el `[URLConnection](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/net/URLConnection.html)` de Java.
El `UrlConnectionHttpClient` se carga más rápido que el cliente HTTP basado en Apache, pero tiene menos características. Como se carga más rápido, es una [buena solución](lambda-optimize-starttime.md) para las funciones AWS Lambda de Java.
El `UrlConnectionHttpClient` tiene varias [opciones configurables](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.Builder.html) a las que puede acceder.
**nota**
El `UrlConnectionHttpClient` no admite el método HTTP PATCH.
Algunas operaciones de AWS API requieren solicitudes de PATCH. Los nombres de esas operaciones suelen empezar por `Update*`. A continuación se presentan varios ejemplos.
[Varias `Update*` operaciones](https://docs.aws.amazon.com/securityhub/1.0/APIReference/API_Operations.html) en la AWS Security Hub CSPM API y también en la [BatchUpdateFindings](https://docs.aws.amazon.com/securityhub/1.0/APIReference/API_BatchUpdateFindings.html)operación
Todas las [operaciones de `Update*`](https://docs.aws.amazon.com/apigateway/latest/api/API_UpdateAccount.html) de la API de Amazon API Gateway
Si puedes usar la`UrlConnectionHttpClient`, consulta primero la referencia de la API Servicio de AWS que estés usando. Compruebe si las operaciones que necesita utilizan la operación PATCH.
## Acceso al `UrlConnectionHttpClient`
Para configurar y utilizar el `UrlConnectionHttpClient`, debe declarar una dependencia en el artefacto Maven `pom.xml` de su archivo `url-connection-client`.
A diferencia del `ApacheHttpClient`, el `UrlConnectionHttpClient` se añade automáticamente al proyecto, por lo que el usuario debe declararlo específicamente.
El siguiente ejemplo de un archivo `pom.xml` muestra las dependencias necesarias para usar y configurar el cliente HTTP.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
url-connection-client
```
## Utilizar y configurar el `UrlConnectionHttpClient`
Puede configurar una instancia del `UrlConnectionHttpClient` junto con la creación de un cliente de servicio, o configurar una sola instancia para compartirla entre varios clientes de servicio.
Con cualquiera de los dos enfoques, se utiliza el [UrlConnectionHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.Builder.html) para configurar las propiedades del cliente HTTP URLConnection basado.
### Práctica recomendada: dedicar una instancia de `UrlConnectionHttpClient` a un cliente de servicio
Si necesita configurar una instancia del `UrlConnectionHttpClient`, le recomendamos que cree la instancia `UrlConnectionHttpClient` dedicada. Puede hacerlo con el método `httpClientBuilder` del generador del cliente del servicio. De esta forma, el SDK administra el ciclo de vida del cliente HTTP, lo que ayuda a evitar posibles pérdidas de memoria si la instancia `UrlConnectionHttpClient` no se cierra cuando ya no se necesita.
En el ejemplo siguiente, se crea un `S3Client` y se configura la instancia integrada de `UrlConnectionHttpClient` con los valores `socketTimeout` y `proxyConfiguration`. El método `proxyConfiguration` toma una expresión lambda de Java de tipo ` Consumer<[ProxyConfiguration.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/ProxyConfiguration.Builder.html)>`.
**Importaciones**
```
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.
```
### Enfoque alternativo: compartir una instancia `UrlConnectionHttpClient`
Para reducir el uso de recursos y memoria en su aplicación, puede configurar un `UrlConnectionHttpClient` y compartirlo entre varios clientes de servicio. El grupo de conexiones HTTP se compartirá, lo que reduce el uso de recursos.
**nota**
Al compartir una instancia de `UrlConnectionHttpClient`, es preciso cerrarla cuando esté lista para ser eliminada. El SDK no cerrará la instancia cuando el cliente del servicio esté cerrado.
El siguiente ejemplo configura un cliente HTTP URLConnection basado que utilizan dos clientes de servicio. La instancia de `UrlConnectionHttpClient` configurada se pasa al método `httpClient` de cada creador. Cuando los clientes de servicio y el cliente HTTP ya no son necesarios, el código los cierra de forma explícita. El código cierra el cliente HTTP por última vez.
**Importaciones**
```
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();
```
#### Utiliza `URLConnectionHttpClient` y `ApacheHttpClient` juntos
Al utilizar el `UrlConnectionHttpClient` en su aplicación, debe proporcionar a cada cliente de servicio una instancia `URLConnectionHttpClient` o una instancia `ApacheHttpClient` mediante el método `httpClientBuilder` del creador de clientes de servicio.
Se produce una excepción si el programa utiliza varios clientes de servicio y se cumplen las siguientes condiciones:
+ Un cliente de servicio está configurado para usar una instancia `UrlConnectionHttpClient`
+ Otro cliente de servicio utiliza el `ApacheHttpClient` predeterminado sin compilarlo explícitamente con los métodos `httpClient()` o `httpClientBuilder()`
La excepción indicará que se encontraron varias implementaciones HTTP en la ruta de clases.
El siguiente fragmento de código de ejemplo conduce a una excepción.
```
// 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 la excepción configurando explícitamente el `S3Client` con un `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 crear explícitamente el `ApacheHttpClient`, debe [añadir una dependencia](http-configuration-apache.md#http-apache-dependency) del artefacto `apache-client` en su archivo de proyecto Maven.
## Ejemplo de configuración proxy
El siguiente fragmento de código utiliza el [generador de configuración proxy para el cliente HTTP de conexión 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();
```
Las propiedades del sistema Java equivalentes para la configuración del proxy se muestran en el siguiente fragmento de línea de comandos.
```
$ java -Dhttp.proxyHost=example.com -Dhttp.proxyPort=1234 -Dhttp.proxyUser=username \
-Dhttp.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
La configuración equivalente que usa variables de entorno es:
```
// 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**
El cliente HTTP URLConnection basado no admite actualmente las propiedades del sistema proxy HTTPS ni la variable de entorno HTTPS\$1PROXY.
# Configurar el cliente HTTP basado en Netty
El cliente HTTP predeterminado para las operaciones asíncronas en el AWS SDK for Java 2.x es el basado en Netty. [NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html) El cliente basado en Netty se basa en el marco de red asíncrono dirigido por eventos del [proyecto Netty](https://netty.io/).
Como cliente HTTP alternativo, puede utilizar el nuevo [cliente HTTP basado en CRT de AWS .](http-configuration-crt.md) En este tema se muestra cómo configurar el `NettyNioAsyncHttpClient`.
## Acceso al `NettyNioAsyncHttpClient`
En la mayoría de las situaciones, se utiliza `NettyNioAsyncHttpClient` sin ninguna configuración explícita en los programas asíncronos. Declara sus clientes de servicios asíncronos y el SDK configurará los `NettyNioAsyncHttpClient` con valores estándar por usted.
Si quiere configurar de forma explícita el `NettyNioAsyncHttpClient` o usarlo con varios clientes de servicio, tiene que hacerlo disponible para su configuración.
### No se necesita configuración
Cuando declara una dependencia de un cliente de servicio en Maven, el SDK añade una dependencia en *tiempo de ejecución* del artefacto `netty-nio-client`. Esto hace que la clase `NettyNioAsyncHttpClient` esté disponible para su código en el tiempo de ejecución, pero no en el de compilación. Si no está configurando el cliente HTTP basado en Netty, no necesita especificar una dependencia para él.
En el siguiente fragmento XML de un archivo `pom.xml` Maven, la dependencia declarada con `dynamodb-enhanced` trae de forma transitoria el cliente HTTP basado en Netty. No necesita declarar una dependencia específicamente para ella.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
dynamodb-enhanced
```
Con estas dependencias, no puede realizar ningún cambio en la configuración HTTP, ya que la biblioteca `NettyNioAsyncHttpClient` solo se encuentra en la ruta de clases del tiempo de ejecución.
### Se necesita configuración
Para configurar el `NettyNioAsyncHttpClient`, es necesario añadir una dependencia al artefacto `netty-nio-client` en tiempo de *compilación*.
Consulte el siguiente ejemplo de un archivo `pom.xml` Maven para configurar el `NettyNioAsyncHttpClient`.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
dynamodb-enhanced
software.amazon.awssdk
netty-nio-client
```
## Utilizar y configurar el `NettyNioAsyncHttpClient`
Puede configurar una instancia del `NettyNioAsyncHttpClient` junto con la creación de un cliente de servicio, o configurar una sola instancia para compartirla entre varios clientes de servicio.
Con cualquiera de los dos enfoques, se utiliza el [NettyNioAsyncHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.Builder.html) para configurar las propiedades de la instancia de cliente HTTP basada en Netty.
### Práctica recomendada: dedicar una instancia de `NettyNioAsyncHttpClient` a un cliente de servicio
Si necesita configurar una instancia del `NettyNioAsyncHttpClient`, le recomendamos que cree una instancia de `NettyNioAsyncHttpClient` dedicada. Puede hacerlo con el método `httpClientBuilder` del generador del cliente del servicio. De esta forma, el SDK administra el ciclo de vida del cliente HTTP, lo que ayuda a evitar posibles pérdidas de memoria si la instancia `NettyNioAsyncHttpClient` no se cierra cuando ya no se necesita.
En el siguiente ejemplo, se crea una instancia `DynamoDbAsyncClient`, que también es utilizada por una instancia `DynamoDbEnhancedAsyncClient`. La instancia `DynamoDbAsyncClient` contiene la instancia `NettyNioAsyncHttpClient` con los valores `connectionTimeout` y `maxConcurrency`. La instancia HTTP se crea mediante el método `httpClientBuilder` de `DynamoDbAsyncClient.Builder`.
**Importaciones**
```
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();
```
### Enfoque alternativo: compartir una instancia `NettyNioAsyncHttpClient`
Para reducir el uso de recursos y memoria en su aplicación, puede configurar un `NettyNioAsyncHttpClient` y compartirlo entre varios clientes de servicio. El grupo de conexiones HTTP se compartirá, lo que reduce el uso de recursos.
**nota**
Al compartir una instancia de `NettyNioAsyncHttpClient`, es preciso cerrarla cuando esté lista para ser eliminada. El SDK no cerrará la instancia cuando el cliente del servicio esté cerrado.
En el siguiente ejemplo, se configura un cliente HTTP basado en Netty, utilizado por dos clientes de servicio. La instancia de `NettyNioAsyncHttpClient` configurada se pasa al método `httpClient` de cada creador. Cuando los clientes de servicio y el cliente HTTP ya no son necesarios, el código los cierra de forma explícita. El código cierra el cliente HTTP por última vez.
**Importaciones**
```
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.
```
## Configuración de la negociación del protocolo ALPN
ALPN (negociación de protocolos de capa de aplicación) es una extensión de TLS que permite a la capa de aplicación negociar qué protocolo debe ejecutarse a través de una conexión segura, de manera que se evitan viajes de ida y vuelta adicionales y se obtiene mayor rendimiento.
Para permitir que el cliente de HTTP basado en Netty utilice ALPN, llame a los métodos del compilador como se muestra en el siguiente fragmento de código:
```
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();
```
La negociación de protocolos de ALPN actualmente solo funciona con el protocolo HTTP/2, como se muestra en el fragmento de código anterior.
## Ejemplo de configuración proxy
El siguiente fragmento de código utiliza el [generador de configuración proxy para el cliente HTTP de 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();
```
Las propiedades del sistema Java equivalentes para la configuración del proxy se muestran en el siguiente fragmento de línea de comandos.
```
$ java -Dhttps.proxyHost=myproxy -Dhttps.proxyPort=1234 -Dhttps.proxyUser=username \
-Dhttps.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
**importante**
Para utilizar cualquiera de las propiedades del sistema proxy HTTPS, la propiedad `scheme` debe estar configurada en código para `https`. Si la propiedad del esquema no está configurada en el código, el esquema predeterminado es HTTP y el SDK solo busca las propiedades del sistema `http.*`.
La configuración equivalente que usa variables de entorno es:
```
// 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 basados en CRT
Los clientes HTTP AWS basados en CRT incluyen los clientes síncronos y asíncronos. [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) Los clientes HTTP AWS basados en CRT ofrecen las siguientes ventajas para los clientes HTTP:
+ Tiempo de inicio del SDK más rápido
+ Ocupación de menos espacio de memoria
+ Tiempo de latencia reducido
+ Administración del estado de conexión
+ equilibrio de carga de DNS
**AWS Componentes basados en CRT en el SDK**
Los clientes *HTTP AWS * basados en CRT, que se describen en este tema, y el cliente *S3 AWS * basado en CRT son componentes diferentes del SDK.
Los clientes **HTTP basados en CRT de AWS ** síncronos y asíncronos son implementaciones e interfaces de cliente HTTP de SDK y se utilizan para la comunicación HTTP general. Son alternativas a los otros clientes HTTP síncronos o asíncronos del SDK con ventajas adicionales.
El **[cliente S3 AWS basado en CRT](crt-based-s3-client.md)** es una implementación de la AsyncClient interfaz [S3](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html) y se utiliza para trabajar con el servicio Amazon S3. Es una alternativa a la implementación de la interfaz `S3AsyncClient` basada en Java y ofrece varias ventajas.
Si bien ambos componentes utilizan bibliotecas del [AWS Common Runtime](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html), los clientes HTTP AWS basados en CRT no utilizan la [biblioteca aws-c-s 3](https://github.com/awslabs/aws-c-s3) y no admiten las funciones de la API de carga [multiparte de S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html). El cliente S3 AWS basado en CRT, por el contrario, se creó específicamente para admitir las funciones de la API de carga multiparte de S3.
## Acceda a los clientes HTTP basados en CRT AWS
Antes de poder usar los clientes HTTP AWS basados en CRT, agrega el `aws-crt-client` artefacto con una versión mínima de 2.22.0 a las dependencias de tu proyecto.
Utilice una de las siguientes opciones para configurar el archivo `pom.xml` de Maven.
**nota**
Puedes optar por utilizar la *opción jar específica de la plataforma* si necesitas reducir el tamaño de las dependencias del tiempo de ejecución, por ejemplo, si tu aplicación se ejecuta en una función. AWS Lambda
------
#### [ Uber-jar option ]
De forma predeterminada, `aws-crt-client` utiliza un supercontenedor de artefactos AWS CRT que contiene archivos binarios para varias plataformas, incluidas Linux, Windows y macOS.
```
2.29.10*
software.amazon.awssdk
bom
${aws.sdk.version}
pom
import
software.amazon.awssdk
aws-crt-client
```
\$1Reemplace la versión que se muestra en rojo por la versión del SDK de Java que desee utilizar. Busque las últimas novedades sobre [Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).
------
#### [ Platform-specific jar option ]
*Para restringir el tiempo de ejecución de Java a la versión de la biblioteca AWS CRT específica para cada plataforma, realice los siguientes cambios en la opción Uber-JAR.*
+ Añada un elemento de `exclusions` al artefacto `aws-crt-client` del SDK. Esta exclusión impide que el SDK utilice transitoriamente el uber-jar CRT. AWS
+ Agrega un elemento de dependencia para la versión específica de la plataforma AWS CRT que necesites. Consulte los **pasos para determinar la versión del artefacto AWS CRT que aparecen a continuación para saber cómo determinar la versión** correcta.
```
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
```
1Reemplace la versión que se muestra en rojo por la versión del SDK de Java que desee utilizar. Busque las últimas novedades sobre [Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).
2Reemplace la versión de `software.amazon.awssdk.crt:aws-crt` que proporcionaría la *Opción Uber-jar*. Consulta los siguientes **pasos para determinar la versión del artefacto AWS CRT.**
3Reemplace el valor de `classifier` por uno para su plataforma. Consulte la GitHub página AWS CRT para Java para obtener una [lista de](https://github.com/awslabs/aws-crt-java?tab=readme-ov-file#platform-specific-jars) los valores disponibles.
**Pasos para determinar la versión del AWS artefacto CRT**
Siga los pasos siguientes para determinar la versión del artefacto AWS CRT que es compatible con la versión del SDK para Java que está utilizando.
1. Configure el archivo `pom.xml` como se muestra en la *Opción Uber-jar*. Esta configuración permite ver qué versión de `software.amazon.awssdk.crt:aws-crt` del SDK está incluida de forma predeterminada.
1. En la raíz del proyecto (en el mismo directorio que el archivo `pom.xml`), ejecute el siguiente comando de Maven:
```
mvn dependency:tree -Dincludes=software.amazon.awssdk.crt:aws-crt
```
Maven puede realizar otras acciones, pero al final debería ver la salida de la consola de la dependencia de `software.amazon.awssdk.crt:aws-crt` que utiliza el SDK de forma transitiva. En el siguiente fragmento de código se muestra una salida de ejemplo basada en una versión del SDK de `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. Utilice la versión que muestra la consola para el artefacto de `software.amazon.awssdk.crt:aws-crt`. En este caso, añada `0.31.3` al archivo `pom.xml`.
------
## Utilice y configure un cliente HTTP basado en AWS CRT
Puede configurar un cliente HTTP AWS basado en CRT junto con la creación de un cliente de servicio, o puede configurar una sola instancia para compartirla entre varios clientes de servicio.
Con cualquiera de estos enfoques, se utiliza un generador para [configurar las propiedades de la instancia](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.Builder.html) de cliente HTTP AWS basada en CRT.
### Práctica recomendada: dedicar una instancia de a un cliente de servicio
Si necesitas configurar una instancia de un cliente HTTP AWS basado en CRT, te recomendamos que dediques la instancia y la compiles junto con el cliente de servicio. Puede hacerlo con el método `httpClientBuilder` del generador del cliente del servicio. De esta forma, el SDK administra el ciclo de vida del cliente HTTP, lo que ayuda a evitar posibles pérdidas de memoria si la instancia del cliente HTTP AWS basada en CRT no se cierra cuando ya no es necesaria.
En el siguiente ejemplo, se crea un cliente de servicio S3 y se configura un cliente HTTP AWS basado en CRT con valores y valores. `connectionTimeout` `maxConcurrency`
------
#### [ Synchronous client ]
**Importaciones**
```
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 ]
**Importaciones**
```
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();
```
------
### Enfoque alternativo: compartir una instancia
Para reducir el uso de recursos y memoria para su aplicación, puede configurar un cliente HTTP AWS basado en CRT y compartirlo entre varios clientes de servicio. El grupo de conexiones HTTP se compartirá, lo que reduce el uso de recursos.
**nota**
Cuando se comparte una instancia de cliente HTTP AWS basada en CRT, debe cerrarla cuando esté lista para su eliminación. El SDK no cerrará la instancia cuando el cliente del servicio esté cerrado.
El siguiente ejemplo configura una instancia de cliente HTTP AWS basada en CRT con valores y. `connectionTimeout` `maxConcurrency` La instancia configurada se pasa al método `httpClient` del creador de cada cliente de servicio. Cuando los clientes de servicio y el cliente HTTP ya no son necesarios, se cierran de forma explícita. El cliente HTTP se cierra en último lugar.
------
#### [ Synchronous client ]
**Importaciones**
```
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 ]
**Importaciones**
```
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.
```
------
## Establezca un cliente HTTP AWS basado en CRT como predeterminado
Puede configurar su archivo de compilación de Maven para que el SDK utilice un cliente HTTP AWS basado en CRT como cliente HTTP predeterminado para los clientes de servicio.
Para ello, añada un elemento `exclusions` con las dependencias predeterminadas del cliente HTTP a cada artefacto del cliente de servicio.
En el siguiente `pom.xml` ejemplo, el SDK usa un cliente HTTP AWS basado en CRT para los servicios de S3. Si el cliente de servicio de su código es un `S3AsyncClient`, el SDK utiliza `AwsCrtAsyncHttpClient`. Si el cliente de servicio es un S3Client, el SDK utiliza `AwsCrtHttpClient`. Con esta configuración, el cliente HTTP asíncrono predeterminado basado en Netty y el HTTP síncrono predeterminado basado en Apache no están disponibles.
```
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 el repositorio central de Maven para obtener el valor más reciente. [https://central.sonatype.com/artifact/software.amazon.awssdk/bom](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)
**nota**
Si se declaran varios clientes de servicio en un archivo `pom.xml`, todos requieren el elemento XML `exclusions`.
### Utilizar una propiedad del sistema Java
Para usar los clientes HTTP AWS basados en CRT como HTTP predeterminado para su aplicación, puede establecer la propiedad del sistema Java en un valor `software.amazon.awssdk.http.async.service.impl` de. `software.amazon.awssdk.http.crt.AwsCrtSdkHttpService`
Para configurarlo durante el inicio de la aplicación, ejecute un comando similar al siguiente.
```
java app.jar -Dsoftware.amazon.awssdk.http.async.service.impl=\
software.amazon.awssdk.http.crt.AwsCrtSdkHttpService
```
Use el siguiente fragmento de código para establecer la propiedad del sistema en el código de la aplicación.
```
System.setProperty("software.amazon.awssdk.http.async.service.impl",
"software.amazon.awssdk.http.crt.AwsCrtSdkHttpService");
```
**nota**
Debe añadir una dependencia al `aws-crt-client` artefacto del `poml.xml` archivo cuando utilice una propiedad del sistema para configurar el uso de los clientes HTTP basados en AWS CRT.
## Configuración avanzada de clientes HTTP basados en AWS CRT
Puede utilizar varios ajustes de configuración de los clientes HTTP AWS basados en CRT, incluida la configuración del estado de la conexión y el tiempo máximo de inactividad. Puede revisar las [opciones de configuración disponibles](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.Builder.html) para el `AwsCrtAsyncHttpClient`. Puede configurar las mismas opciones para `AwsCrtHttpClient`.
### Configuración del estado de conexión
Puede configurar el estado de la conexión para los clientes HTTP AWS basados en CRT mediante el `connectionHealthConfiguration` método del generador de clientes HTTP.
En el siguiente ejemplo, se crea un cliente de servicio S3 que utiliza una instancia de cliente HTTP AWS basada en CRT configurada con una configuración de mantenimiento de la conexión y un tiempo máximo de inactividad para las conexiones.
------
#### [ Synchronous client ]
**Importaciones**
```
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 ]
**Importaciones**
```
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();
```
------
## Compatibilidad con HTTP/2
El protocolo HTTP/2 aún no es compatible con los clientes HTTP AWS basados en CRT, pero está previsto que se publique en un futuro.
Mientras tanto, si utiliza clientes de servicio que requieren compatibilidad con HTTP/2, como el [KinesisAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/kinesis/KinesisAsyncClient.html)o el [TranscribeStreamingAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/transcribestreaming/TranscribeStreamingAsyncClient.html), considere la posibilidad de utilizar el en su lugar. [NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html)
## Ejemplo de configuración proxy
El siguiente fragmento de código muestra el uso de [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 se utiliza para configurar el proxy en el código.
------
#### [ Synchronous client ]
**Importaciones**
```
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 ]
**Importaciones**
```
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();
```
------
Las propiedades del sistema Java equivalentes para la configuración del proxy se muestran en el siguiente fragmento de línea de comandos.
```
$ java -Dhttps.proxyHost=myproxy -Dhttps.proxyPort=1234 -Dhttps.proxyUser=username \
-Dhttps.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
**importante**
Para utilizar cualquiera de las propiedades del sistema proxy HTTPS, la propiedad `scheme` debe estar configurada en código para `https`. Si la propiedad del esquema no está configurada en el código, el esquema predeterminado es HTTP y el SDK solo busca las propiedades del sistema `http.*`.
La configuración equivalente que usa variables de entorno es:
```
// 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
```
# Configuración de proxies de HTTP
Puede configurar proxies de HTTP mediante código, definiendo propiedades del sistema Java o definiendo variables de entorno.
## Configuración en código
Los proxies se configuran en código con un generador `ProxyConfiguration` específico del cliente al crear el cliente de servicio. El código siguiente muestra una configuración de proxy de ejemplo para un cliente HTTP basado en Apache que utiliza un cliente de servicio de 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();
```
En la sección correspondiente a cada cliente HTTP de este tema se muestra un ejemplo de configuración de proxy.
+ [Cliente HTTP basado en Apache](http-configuration-apache.md#http-configuration-apache-proxy-conf-ex)
+ [URLConnectioncliente HTTP basado](http-configuration-url.md#http-configuration-url-proxy-conf-ex)
+ [Netty-based HTTP client](http-configuration-netty.md#http-config-netty-proxy-ex)
+ [AWS Cliente HTTP basado en CRT](http-configuration-crt.md#http-config-crt-proxy-ex)
## Configuración de proxies de HTTP con ajustes externos
Aunque no utilice explícitamente un compilador de `ProxyConfiguration` en el código, el SDK busca ajustes externos para configurar una configuración de proxy predeterminada.
De forma predeterminada, el SDK busca primero las propiedades del sistema JVM. Si se encuentra una sola propiedad, el SDK usa el valor y cualquier otro valor de propiedad del sistema. Si no hay propiedades del sistema disponibles, el SDK busca variables de entorno del proxy.
El SDK puede usar las siguientes propiedades y variables de entorno del sistema Java.
**Propiedades del sistema Java**
| Propiedad del sistema | Description (Descripción) | Compatibilidad con clientes HTTP |
| --- | --- | --- |
| http.proxyHost | Nombre de host del servidor proxy HTTP | Todos |
| http.proxyPort | Número de puerto del servidor proxy HTTP | Todos |
| http.proxyUser | Nombre de usuario para la autenticación mediante proxy HTTP | Todos |
| http.proxyPassword | Contraseña para la autenticación mediante proxy HTTP | Todos |
| http. nonProxyHosts | Lista de hosts a los que se debe acceder directamente, sin pasar por el proxy. [Esta lista también es válida cuando se utiliza HTTPS](https://docs.oracle.com/javase/8/docs/technotes/guides/net/proxies.html). | Todos |
| https.proxyHost | Nombre de host del servidor proxy HTTP | Netty, CRT |
| https.proxyPort | Número de puerto del servidor proxy HTTP | Netty, CRT |
| https.proxyUser | Nombre de usuario para la autenticación mediante proxy HTTPS | Netty, CRT |
| https.proxyPassword | Contraseña para la autenticación mediante proxy HTTPS | Netty, CRT |
**Variables de entorno**
| Variable de entorno | Description (Descripción) | Compatibilidad con clientes HTTP |
| --- | --- | --- |
| HTTP\$1PROXY1 | URL válida con un esquema de HTTP | Todos |
| HTTPS\$1PROXY1 | URL válida con un esquema de HTTPS | Netty, CRT |
| NO\$1PROXY2 | Lista de hosts a los que se debe acceder directamente, sin pasar por el proxy. La lista es válida tanto para HTTP como para HTTPS. | Todos |
### Visualización de notas clave y al pie
**Todos**: todos los clientes HTTP que ofrece el SDK: `UrlConnectionHttpClient`, `ApacheHttpClient`, `NettyNioAsyncHttpClient`, `AwsCrtAsyncHttpClient`.
**Netty**: el cliente de HTTP basado en Netty (`NettyNioAsyncHttpClient`)
**CRT**: los clientes HTTP AWS basados en CRT, (y)`AwsCrtHttpClient`. `AwsCrtAsyncHttpClient`
1La variable de entorno consultada, ya sea `HTTP_PROXY` o `HTTPS_PROXY`, depende de la configuración del esquema en la `ProxyConfiguration` del cliente. El esquema predeterminado es HTTP. El siguiente fragmento de código muestra cómo cambiar el esquema a HTTPS utilizado para la resolución de variables de entorno.
```
SdkHttpClient httpClient = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.scheme("https")
.build())
.build();
```
2La variable de entorno `NO_PROXY` admite una combinación de separadores “\$1” y “,” entre los nombres de host. Los nombres de host pueden incluir el comodín “\$1”.
## Uso de una combinación de ajustes
Puede usar una combinación de ajustes de proxy de HTTP en el código, las propiedades del sistema y las variables de entorno.
**Example – configuración proporcionada por una propiedad del sistema y por 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();
```
El SDK resuelve la siguiente configuración del proxy.
```
Host = localhost
Port = 1234
Password = SYS_PROP_password
UserName = username
Non ProxyHost = null
```
**Example – están disponibles tanto las propiedades del sistema como las variables de entorno**
El compilador `ProxyConfiguration` del cliente de HTTP ofrece configuraciones denominadas `useSystemPropertyValues` y `useEnvironmentVariablesValues`. De forma predeterminada, ambas configuraciones son `true`. Cuando es `true`, el SDK utiliza automáticamente valores de propiedades del sistema o variables de entorno para las opciones que no proporciona el compilador `ProxyConfiguration`.
Las propiedades del sistema tienen prioridad sobre las variables de entorno. Si se encuentra una propiedad del sistema proxy de HTTP, el SDK recupera ***todos*** los valores de las propiedades del sistema y ninguno de las variables de entorno. Si desea priorizar las variables de entorno sobre las propiedades del sistema, establezca `useSystemPropertyValues` en `false`.
En este ejemplo, los siguientes ajustes están disponibles en tiempo de ejecución:
```
// 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"
```
El cliente de servicio se crea con una de las instrucciones siguientes. Ninguna de las instrucciones establece explícitamente una configuración de proxy.
```
DynamoDbClient client = DynamoDbClient.create();
DynamoDbClient client = DynamoDbClient.builder().build();
DynamoDbClient client = DynamoDbClient.builder()
.httpClient(ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.build())
.build())
.build();
```
El SDK resuelve la siguiente configuración del proxy.
```
Host = SYS_PROP_HOST.com
Port = 2222
Password = SYS_PROP_PASSWORD
UserName = SYS_PROP_USER
Non ProxyHost = null
```
Dado que el cliente de servicio tiene la configuración de proxy predeterminada, el SDK busca las propiedades del sistema y, a continuación, las variables de entorno. Puesto que la configuración de las propiedades del sistema tiene prioridad sobre las variables de entorno, el SDK utiliza únicamente las propiedades del sistema.
Si el uso de las propiedades del sistema se cambia a `false`, como se muestra en el código siguiente, el SDK resuelve solo las variables de entorno.
```
DynamoDbClient client = DynamoDbClient.builder()
.httpClient(ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.useSystemPropertyValues(Boolean.FALSE)
.build())
.build())
.build();
```
La configuración de proxy resuelta mediante HTTP es:
```
Host = ENV_VAR_HOST
Port = 3333
Password = EnvironmentPassword
UserName = EnvironmentUser
Non ProxyHost = environmentnonproxy.host, environmentnonproxy2.host:1234
```
# Configurar el cliente HTTP basado en Apache 5.x
## Acceda al Apache5 HttpClient
Para poder utilizar el, `Apache5HttpClient` debe agregar una dependencia **apache5-client** y configurarlo explícitamente `Apache5HttpClient` en sus clientes de servicio.
```
software.amazon.awssdk
bom
2.41.0*
pom
import
software.amazon.awssdk
s3
software.amazon.awssdk
apache5-client
```
\$1Reemplace la versión que se muestra en rojo por la versión del SDK de Java que desee utilizar. Busque las últimas novedades sobre [Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).
### Utilizar y configurar el `Apache5HttpClient`
Puede configurar una instancia del `Apache5HttpClient` junto con la creación de un cliente de servicio, o configurar una sola instancia para compartirla entre varios clientes de servicio.
Con cualquiera de los dos enfoques, se utiliza el [Apache5 HttpClient .Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache5/Apache5HttpClient.Builder.html) para configurar las propiedades del cliente HTTP basado en Apache 5.
#### Práctica recomendada: dedicar una instancia de Apache5 HttpClient a un cliente de servicio
Si necesita configurar una instancia del `Apache5HttpClient`, le recomendamos que cree la instancia `Apache5HttpClient` dedicada. Para ello, utilice el httpClientBuilder método del creador del cliente de servicio. De esta forma, el SDK administra el ciclo de vida del cliente HTTP, lo que ayuda a evitar posibles pérdidas de memoria si la instancia `Apache5HttpClient` no se cierra cuando ya no se necesita.
En el siguiente ejemplo, se crea un S3Client y se configura la instancia integrada `Apache5HttpClient` con los valores MaxConnections y ConnectionTimeout. La instancia HTTP se crea mediante el método `httpClientBuilder` de `S3Client.Builder`.
**Importaciones**
```
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.
```
#### Enfoque alternativo: compartir una instancia `Apache5HttpClient`
Para reducir el uso de recursos y memoria en su aplicación, puede configurar un `Apache5HttpClient` y compartirlo entre varios clientes de servicio. El grupo de conexiones HTTP se compartirá, lo que reduce el uso de recursos.
**nota**
Al compartir una instancia de `Apache5HttpClient`, es preciso cerrarla cuando esté lista para ser eliminada. El SDK no cerrará la instancia cuando el cliente del servicio esté cerrado.
En el siguiente ejemplo, se configura un cliente HTTP basado en Apache, utilizado por dos clientes de servicio. La `ApacheHttpClient` instancia configurada se pasa al método HttpClient de cada generador. Cuando los clientes de servicio y el cliente HTTP ya no son necesarios, el código los cierra de forma explícita. El código cierra el cliente HTTP por última vez.
**Importaciones**
```
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.
```