Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Configuration du client HTTP basé sur Netty
<a name="http-configuration-netty"></a>

Le client HTTP par défaut pour les opérations asynchrones dans le AWS SDK for Java 2.x est basé sur Netty. [NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html) [Le client basé sur Netty est basé sur le framework réseau asynchrone piloté par les événements du projet Netty.](https://netty.io/)

En tant que client HTTP alternatif, vous pouvez utiliser le nouveau client [HTTP AWS basé sur CRT](http-configuration-crt.md). Cette rubrique explique comment configurer le`NettyNioAsyncHttpClient`.

## Accédez au `NettyNioAsyncHttpClient`
<a name="http-config-netty-access"></a>

Dans la plupart des cas, vous utilisez le `NettyNioAsyncHttpClient` sans configuration explicite dans les programmes asynchrones. Vous déclarez vos clients de service asynchrones et le SDK les configurera `NettyNioAsyncHttpClient` avec des valeurs standard pour vous.

Si vous souhaitez le configurer explicitement `NettyNioAsyncHttpClient` ou l'utiliser avec plusieurs clients de service, vous devez le rendre disponible pour la configuration.

### Aucune configuration nécessaire
<a name="http-config-netty-no-config"></a>

Lorsque vous déclarez une dépendance à l'égard d'un client de service dans Maven, le SDK ajoute une dépendance *d'exécution* à l'`netty-nio-client`artefact. Cela rend la `NettyNioAsyncHttpClient` classe disponible pour votre code au moment de l'exécution, mais pas au moment de la compilation. Si vous ne configurez pas le client HTTP basé sur Netty, vous n'avez pas besoin de spécifier de dépendance pour celui-ci.

Dans l'extrait XML suivant d'un `pom.xml` fichier Maven, la dépendance déclarée avec de `<artifactId>dynamodb-enhanced</artifactId>` manière transitive introduit le client HTTP basé sur Netty. Il n'est pas nécessaire de déclarer une dépendance spécifiquement pour celle-ci.

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

Avec ces dépendances, vous ne pouvez pas modifier la configuration HTTP, car la `NettyNioAsyncHttpClient` bibliothèque se trouve uniquement sur le chemin de classe d'exécution. 

### Configuration requise
<a name="http-config-netty-yes-config"></a>

Pour configurer le`NettyNioAsyncHttpClient`, vous devez ajouter une dépendance à l'`netty-nio-client`artefact au moment de la *compilation*. 

Reportez-vous à l'exemple de `pom.xml` fichier Maven suivant pour configurer le`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>
```

## Utilisez et configurez le `NettyNioAsyncHttpClient`
<a name="http-netty-config"></a>

Vous pouvez configurer une instance `NettyNioAsyncHttpClient` tout en créant un client de service, ou vous pouvez configurer une instance unique à partager entre plusieurs clients de service. 

Quelle que soit l'approche, vous utilisez le [NettyNioAsyncHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.Builder.html) pour configurer les propriétés de l'instance client HTTP basée sur Netty.

### Meilleure pratique : dédier une `NettyNioAsyncHttpClient` instance à un client de service
<a name="http-config-netty-one-client"></a>

Si vous devez configurer une instance de`NettyNioAsyncHttpClient`, nous vous recommandons de créer une `NettyNioAsyncHttpClient` instance dédiée. Vous pouvez le faire en utilisant la `httpClientBuilder` méthode du générateur du client de service. Ainsi, le cycle de vie du client HTTP est géré par le SDK, ce qui permet d'éviter d'éventuelles fuites de mémoire si l'`NettyNioAsyncHttpClient`instance n'est pas fermée alors qu'elle n'est plus nécessaire.

L'exemple suivant crée une `DynamoDbAsyncClient` instance qui est utilisée par une `DynamoDbEnhancedAsyncClient` instance. L'`DynamoDbAsyncClient`instance contient l'`NettyNioAsyncHttpClient`instance avec des `maxConcurrency` valeurs `connectionTimeout` et. L'instance HTTP est créée à l'aide de la `httpClientBuilder` méthode de`DynamoDbAsyncClient.Builder`.

 **Importations** 

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

 **Code** 

```
// 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();
```

### Approche alternative : partager une `NettyNioAsyncHttpClient` instance
<a name="http-config-netty-multi-clients"></a>

Pour réduire l'utilisation des ressources et de la mémoire de votre application, vous pouvez en configurer un `NettyNioAsyncHttpClient` et le partager entre plusieurs clients de service. Le pool de connexions HTTP sera partagé, ce qui réduit l'utilisation des ressources.

**Note**  
Lorsqu'une `NettyNioAsyncHttpClient` instance est partagée, vous devez la fermer lorsqu'elle est prête à être supprimée. Le SDK ne ferme pas l'instance lorsque le client de service est fermé.

L'exemple suivant configure un client HTTP basé sur Netty qui est utilisé par deux clients de service. L'`NettyNioAsyncHttpClient`instance configurée est transmise à la `httpClient` méthode de chaque générateur. Lorsque les clients du service et le client HTTP ne sont plus nécessaires, le code les ferme explicitement. Le code ferme le client HTTP en dernier.

**Importations**

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

 **Code** 

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

## Configuration de la négociation du protocole ALPN
<a name="http-netty-config-alpn"></a>

ALPN (Application-Layer Protocol Negotiation) est une extension TLS qui permet à la couche application de négocier le protocole à exécuter via une connexion sécurisée de manière à éviter des allers-retours supplémentaires et à améliorer les performances.

Pour permettre au client HTTP basé sur Netty d'utiliser ALPN, appelez les méthodes du générateur comme indiqué dans l'extrait suivant :

```
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 négociation du protocole ALPN ne fonctionne actuellement qu'avec le protocole HTTP/2, comme indiqué dans l'extrait précédent.

## Exemple de configuration de proxy
<a name="http-config-netty-proxy-ex"></a>

L'extrait de code suivant utilise le [générateur de configuration du proxy pour le client 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();
```

Les propriétés système Java équivalentes pour la configuration du proxy sont indiquées dans l'extrait de ligne de commande suivant.

```
$ java -Dhttps.proxyHost=myproxy -Dhttps.proxyPort=1234 -Dhttps.proxyUser=username \
-Dhttps.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```

**Important**  
Pour utiliser l'une des propriétés du système proxy HTTPS, la `scheme` propriété doit être définie dans le code sur`https`. Si la propriété du schéma n'est pas définie dans le code, le schéma est défini par défaut sur HTTP et le SDK recherche uniquement les propriétés `http.*` du système.

La configuration équivalente qui utilise des variables d'environnement est la suivante :

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