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 Apache
<a name="http-configuration-apache"></a>

Les clients de service synchrones AWS SDK for Java 2.x utilisent un client HTTP basé sur Apache, [ApacheHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html)par défaut. Le SDK `ApacheHttpClient` est basé sur Apache [HttpClient](https://hc.apache.org/httpcomponents-client-4.5.x/index.html).

Le SDK propose également le [UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html), qui se charge plus rapidement, mais comporte moins de fonctionnalités. Pour plus d'informations sur la configuration du`UrlConnectionHttpClient`, consultez[Configuration du client HTTP URLConnection basé](http-configuration-url.md). 

Pour voir l'ensemble complet des options de configuration disponibles pour le`ApacheHttpClient`, consultez [ApacheHttpClient.Builder et [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).

## Accédez au `ApacheHttpClient`
<a name="http-apache-dependency"></a>

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

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

### Aucune configuration nécessaire
<a name="http-config-apache-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'`apache-client`artefact. Cela rend la `ApacheHttpClient` 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 Apache, 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 introduit `<artifactId>s3</artifactId>` automatiquement le client HTTP basé sur Apache. 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>
    <!-- The s3 dependency automatically adds a runtime dependency on the ApacheHttpClient-->
    <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>s3</artifactId>
    </dependency>
</dependencies>
```

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

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

Pour configurer le`ApacheHttpClient`, vous devez ajouter une dépendance à la `apache-client` bibliothèque au moment de la *compilation*. 

Reportez-vous à l'exemple de `pom.xml` fichier Maven suivant pour configurer le`ApacheHttpClient`.

```
    <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>s3</artifactId>
        </dependency>
        <!-- By adding the apache-client dependency, ApacheHttpClient will be added to 
             the compile classpath so you can configure it. -->
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>apache-client</artifactId>
        </dependency>
    </dependencies>
```

## Utilisez et configurez `ApacheHttpClient`
<a name="http-apache-config"></a>

Vous pouvez configurer une instance `ApacheHttpClient` 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 `[ApacheHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.Builder.html)` pour configurer les propriétés du client HTTP basé sur Apache.

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

Si vous devez configurer une instance de`ApacheHttpClient`, nous vous recommandons de créer l'`ApacheHttpClient`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'`ApacheHttpClient`instance n'est pas fermée alors qu'elle n'est plus nécessaire.

L'exemple suivant crée `S3Client` et configure l'instance intégrée de `ApacheHttpClient` with `maxConnections` et `connectionTimeout` values. L'instance HTTP est créée à l'aide de la `httpClientBuilder` méthode de`S3Client.Builder`.

 **Importations** 

```
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```

 **Code** 

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

### Approche alternative : partager une `ApacheHttpClient` instance
<a name="http-config-apache-alt"></a>

Pour réduire l'utilisation des ressources et de la mémoire de votre application, vous pouvez configurer un `ApacheHttpClient` 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 `ApacheHttpClient` 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 Apache qui est utilisé par deux clients de service. L'`ApacheHttpClient`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** 

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

## Exemple de configuration de proxy
<a name="http-configuration-apache-proxy-conf-ex"></a>

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

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 -Dhttp.proxyHost=example.com -Dhttp.proxyPort=1234 -Dhttp.proxyUser=username \
-Dhttp.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```

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

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

**Note**  
Le client HTTP Apache ne prend actuellement pas en charge les propriétés du système proxy HTTPS ni la variable d'environnement HTTPS\$1PROXY.