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 de clients AWS HTTP basés sur CRT
<a name="http-configuration-crt"></a>

Les clients HTTP AWS basés sur CRT incluent les clients synchrones et asynchrones. [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) Les clients HTTP AWS basés sur CRT offrent les avantages suivants :
+ Temps de démarrage plus rapide du kit SDK
+ Empreinte mémoire réduite
+ Temps de latence réduit
+ Gestion de l’état des connexions
+ Équilibrage de charge DNS

**AWS Composants du SDK basés sur le CRT**

Les clients *HTTP AWS * CRT, décrits dans cette rubrique, et le client *S3 AWS * basé sur CRT sont des composants différents du SDK. 

Les clients HTTP synchrones et asynchrones **AWS basés sur le CRT sont des interfaces client HTTP** du SDK d'implémentation et sont utilisés pour les communications HTTP générales. Ils constituent des alternatives aux autres clients HTTP synchrones ou asynchrones du SDK avec des avantages supplémentaires.

Le **[client S3 AWS basé sur CRT](crt-based-s3-client.md)** est une implémentation de l'AsyncClientinterface [S3](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html) et est utilisé pour travailler avec le service Amazon S3. Il s'agit d'une alternative à l'implémentation Java de l'`S3AsyncClient`interface et offre plusieurs avantages.

Bien que les deux composants utilisent des bibliothèques issues du [AWS Common Runtime](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html), les clients HTTP AWS basés sur CRT n'utilisent pas la [bibliothèque aws-c-s 3](https://github.com/awslabs/aws-c-s3) et ne prennent pas en charge les fonctionnalités de l'API de [téléchargement partitionné S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html). Le client S3 AWS basé sur CRT, en revanche, a été spécialement conçu pour prendre en charge les fonctionnalités de l'API de téléchargement partitionné S3.

## Accédez aux clients HTTP AWS basés sur CRT
<a name="http-config-crt-access"></a>

Avant de pouvoir utiliser les clients HTTP AWS CRT, ajoutez l'`aws-crt-client`artefact avec une version minimale de 2.22.0 aux dépendances de votre projet.

Utilisez l'une des options suivantes pour configurer votre `pom.xml` fichier Maven.

**Note**  
 Vous pouvez choisir d'utiliser l'*option jar spécifique à la plate-forme* si vous devez réduire la taille des dépendances d'exécution, par exemple si votre application s'exécute dans une fonction. AWS Lambda 

------
#### [ Uber-jar option ]

Par défaut, il `aws-crt-client` utilise un uber-jar d'artefacts AWS CRT contenant des fichiers binaires pour plusieurs plateformes, notamment Linux, Windows et macOS.

```
<project>
   <properties>
     <aws.sdk.java.version>2.29.10*</aws.sdk.java.version>
  </properties>
  <dependencyManagement>
   <dependencies>
      <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>bom</artifactId>
        <version>${aws.sdk.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
   </dependencies>
  </dependencyManagement>
  <dependencies>
   <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>aws-crt-client</artifactId>
   </dependency>
  </dependencies>
</project>
```

\$1Remplacez la version affichée en rouge par la version du SDK Java que vous souhaitez utiliser. Découvrez les dernières actualités sur [Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).

------
#### [ Platform-specific jar option ]

*Pour limiter le runtime Java à la version spécifique à la plate-forme de la bibliothèque AWS CRT, apportez les modifications suivantes à l'option Uber-JAR.*
+ Ajoutez un `exclusions` élément à l'`aws-crt-client`artefact du SDK. Cette exclusion empêche le SDK d'utiliser l'uber-jar AWS CRT de manière transitive.
+ Ajoutez un élément de dépendance pour la version de plate-forme AWS CRT spécifique dont vous avez besoin. Consultez les **étapes pour déterminer la version de l'artefact AWS CRT** ci-dessous pour savoir comment déterminer la bonne version.

```
<project>
   <properties>
     <aws.sdk.java.version>2.29.101</aws.sdk.java.version>
  </properties>
   <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>software.amazon.awssdk</groupId>
                <artifactId>bom</artifactId>
                <version>${aws.sdk.java.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>aws-crt-client</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>software.amazon.awssdk.crt</groupId>
                    <artifactId>aws-crt</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>software.amazon.awssdk.crt</groupId>
            <artifactId>aws-crt</artifactId>
            <version>0.31.32</version>
            <classifier>linux-x86_643</classifier>
        </dependency>
    </dependencies>
```

1 Remplacez la version affichée en rouge par la version du SDK Java que vous souhaitez utiliser. Découvrez les dernières actualités sur [Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).

2 Remplacez la version `software.amazon.awssdk.crt:aws-crt` qui serait fournie par l'option *Uber-jar*. Consultez les **étapes suivantes pour déterminer la version de l'artefact AWS CRT**.

3 Remplacez la `classifier` valeur par une valeur pour votre plateforme. Reportez-vous à la GitHub page AWS CRT pour Java pour obtenir [la liste des valeurs disponibles](https://github.com/awslabs/aws-crt-java?tab=readme-ov-file#platform-specific-jars).

**Étapes pour déterminer la version de l'artefact AWS CRT**

Procédez comme suit pour déterminer la version de l'artefact AWS CRT compatible avec la version du SDK pour Java que vous utilisez.

1. Configurez votre `pom.xml` fichier comme indiqué dans l'option *Uber-jar*. Cette configuration vous permet de voir quelle version `software.amazon.awssdk.crt:aws-crt` du SDK est introduite par défaut.

1. À la racine du projet (dans le même répertoire que le `pom.xml` fichier), exécutez la commande Maven suivante :

   ```
   mvn dependency:tree -Dincludes=software.amazon.awssdk.crt:aws-crt
   ```

   Maven peut effectuer d'autres actions, mais à la fin, vous devriez voir une sortie de console indiquant la `software.amazon.awssdk.crt:aws-crt` dépendance que le SDK utilise de manière transitive. L'extrait suivant montre un exemple de sortie basé sur une version du 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. Utilisez la version affichée sur la console pour l'`software.amazon.awssdk.crt:aws-crt`artefact. Dans ce cas, ajoutez-le `0.31.3` à votre `pom.xml` fichier.

------

## Utiliser et configurer un client AWS HTTP CRT
<a name="http-crt-config"></a>

Vous pouvez configurer un client HTTP AWS CRT 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 un générateur pour [configurer les propriétés](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.Builder.html) de l'instance client HTTP AWS basée sur CRT.

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

Si vous devez configurer une instance d'un client HTTP AWS CRT, nous vous recommandons de la dédier en la créant avec le client de service. 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'instance du client HTTP AWS basée sur CRT n'est pas fermée alors qu'elle n'est plus nécessaire.

L'exemple suivant crée un client de service S3 et configure un client HTTP AWS CRT avec `connectionTimeout` des valeurs et. `maxConcurrency` 

------
#### [ Synchronous client ]

**Importations**

```
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```

**Code**

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

**Importations**

```
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import java.time.Duration;
```

**Code**

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

------

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

Pour réduire l'utilisation des ressources et de la mémoire de votre application, vous pouvez configurer un client HTTP AWS CRT 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 instance de AWS client HTTP CRT 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 une instance de client HTTP AWS CRT avec `connectionTimeout` des valeurs et. `maxConcurrency` L'instance configurée est transmise à la `httpClient` méthode du générateur de chaque client de service. Lorsque les clients du service et le client HTTP ne sont plus nécessaires, ils sont explicitement fermés. Le client HTTP est fermé en dernier.

------
#### [ Synchronous client ]

**Importations**

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

**Code**

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

**Importations**

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

**Code**

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

------

## Définir un client HTTP AWS CRT comme client par défaut
<a name="setting-the-crt-based-http-client-as-the-default"></a>

Vous pouvez configurer votre fichier de compilation Maven pour que le SDK utilise un client HTTP AWS CRT comme client HTTP par défaut pour les clients de service.

Pour ce faire, ajoutez un `exclusions` élément avec les dépendances du client HTTP par défaut à chaque artefact du client de service.

Dans l'`pom.xml`exemple suivant, le SDK utilise un client HTTP AWS CRT pour les services S3. Si le client de service de votre code est un`S3AsyncClient`, le SDK utilise`AwsCrtAsyncHttpClient`. Si le client de service est un client S3, le SDK utilise. `AwsCrtHttpClient` Avec cette configuration, le client HTTP asynchrone par défaut basé sur Netty et le HTTP synchrone basé sur Apache par défaut ne sont pas disponibles.

```
<project>
   <properties>
     <aws.sdk.version>VERSION</aws.sdk.version>
  </properties>
  <dependencies>
   <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>s3</artifactId>
      <version>${aws.sdk.version}</version>
      <exclusions>
         <exclusion>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>netty-nio-client</artifactId>
         </exclusion>
         <exclusion>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>apache-client</artifactId>
         </exclusion>
      </exclusions>
   </dependency>
   <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>aws-crt-client</artifactId>
   </dependency>
  </dependencies>
</project>
```

Visitez le référentiel central de Maven pour obtenir la dernière [https://central.sonatype.com/artifact/software.amazon.awssdk/bom](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)valeur.

**Note**  
Si plusieurs clients de service sont déclarés dans un `pom.xml` fichier, ils ont tous besoin de l'élément `exclusions` XML.

### Utiliser une propriété système Java
<a name="setting-via-java-system-property"></a>

Pour utiliser les clients HTTP AWS CRT comme protocole HTTP par défaut pour votre application, vous pouvez définir la propriété système Java sur une valeur `software.amazon.awssdk.http.async.service.impl` de. `software.amazon.awssdk.http.crt.AwsCrtSdkHttpService`

Pour définir lors du démarrage de l'application, exécutez une commande similaire à la suivante.

```
java app.jar -Dsoftware.amazon.awssdk.http.async.service.impl=\
software.amazon.awssdk.http.crt.AwsCrtSdkHttpService
```

Utilisez l'extrait de code suivant pour définir la propriété système dans le code de votre application.

```
System.setProperty("software.amazon.awssdk.http.async.service.impl",
"software.amazon.awssdk.http.crt.AwsCrtSdkHttpService");
```

**Note**  
Vous devez ajouter une dépendance à l'`aws-crt-client`artefact de votre `poml.xml` fichier lorsque vous utilisez une propriété système pour configurer l'utilisation des clients HTTP AWS CRT.

## Configuration avancée des clients HTTP AWS basés sur CRT
<a name="configuring-the-crt-based-http-client"></a>

Vous pouvez utiliser différents paramètres de configuration des clients HTTP AWS basés sur CRT, notamment la configuration de l'état de la connexion et le temps d'inactivité maximal. Vous pouvez consulter les [options de configuration disponibles](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.Builder.html) pour`AwsCrtAsyncHttpClient`. Vous pouvez configurer les mêmes options pour`AwsCrtHttpClient`.

### Configuration de l'état de la connexion
<a name="connection-health-checks"></a>

Vous pouvez configurer la configuration de l'état de la connexion pour les clients HTTP AWS basés sur CRT en utilisant la `connectionHealthConfiguration` méthode du générateur de clients HTTP. 

L'exemple suivant crée un client de service S3 qui utilise une instance de client HTTP AWS CRT configurée avec une configuration d'état de connexion et une durée d'inactivité maximale pour les connexions. 

------
#### [ Synchronous client ]

**Importations**

```
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```

**Code**

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

**Importations**

```
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import java.time.Duration;
```

**Code**

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

------

## Support HTTP/2
<a name="limitation-the-crt-based-http-client"></a>

Le protocole HTTP/2 n'est pas encore pris en charge dans les clients HTTP AWS basés sur CRT, mais il est prévu pour une future version. 

En attendant, si vous utilisez des clients de service qui nécessitent un support HTTP/2 tel que le [KinesisAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/kinesis/KinesisAsyncClient.html)ou le [TranscribeStreamingAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/transcribestreaming/TranscribeStreamingAsyncClient.html), pensez à utiliser le à la [NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html)place. 

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

L'extrait de code suivant montre l'utilisation 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)celui que vous utilisez pour configurer les paramètres du proxy dans le code.

------
#### [ Synchronous client ]

**Importations**

```
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.http.crt.ProxyConfiguration;
```

**Code**

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

**Importations**

```
import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.http.crt.ProxyConfiguration;
```

**Code**

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

------

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 crtAsyncHttpClient = AwsCrtAsyncHttpClient.builder()
    .proxyConfiguration(ProxyConfiguration.builder()
        .scheme("https")
        .useSystemPropertyValues(Boolean.FALSE)
        .build())
    .build();

// Run the application.
// $ java -cp ... App
```