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.

# Configurar el cliente HTTP basado en Netty
<a name="http-configuration-netty"></a>

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`
<a name="http-config-netty-access"></a>

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
<a name="http-config-netty-no-config"></a>

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 `<artifactId>dynamodb-enhanced</artifactId>` trae de forma transitoria el cliente HTTP basado en Netty. No necesita declarar una dependencia específicamente para ella.

```
<dependencyManagement>
   <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>bom</artifactId>
            <version>2.27.21</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
    <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>dynamodb-enhanced</artifactId>
    </dependency>
</dependencies>
```

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
<a name="http-config-netty-yes-config"></a>

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`.

```
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>software.amazon.awssdk</groupId>
                <artifactId>bom</artifactId>
                <version>2.27.21</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>dynamodb-enhanced</artifactId>
        </dependency>
        <!-- By adding the netty-nio-client dependency, NettyNioAsyncHttpClient will be 
             added to the compile classpath so you can configure it. -->
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>netty-nio-client</artifactId>
        </dependency>
    </dependencies>
```

## Utilizar y configurar el `NettyNioAsyncHttpClient`
<a name="http-netty-config"></a>

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
<a name="http-config-netty-one-client"></a>

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`
<a name="http-config-netty-multi-clients"></a>

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
<a name="http-netty-config-alpn"></a>

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
<a name="http-config-netty-proxy-ex"></a>

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
```