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.

# Configurer le client asynchrone S3 basé sur Java pour utiliser les transferts parallèles
<a name="s3-async-client-multipart"></a>

Depuis la version 2.27.5, le client asynchrone S3 standard basé sur Java prend en charge les transferts parallèles automatiques (chargements partitionnés et téléchargements). Vous configurez la prise en charge des transferts parallèles lorsque vous créez le client asynchrone S3 basé sur Java. 

Cette section explique comment activer les transferts parallèles et comment personnaliser la configuration.

## Créez une instance de `S3AsyncClient`
<a name="s3-async-client-multipart-create"></a>

Lorsque vous créez une `S3AsyncClient` instance sans appeler aucune des `multipart*` méthodes du [générateur](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClientBuilder.html), les transferts parallèles ne sont pas activés. Chacune des instructions suivantes crée un client asynchrone S3 basé sur Java sans prise en charge des chargements partitionnés et des téléchargements.

### Créez *sans support* en plusieurs parties
<a name="s3-async-client-mp-off"></a>

**Example**  

```
import software.amazon.awssdk.auth.credentials.ProcessCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3AsyncClient;


S3AsyncClient s3Client = S3AsyncClient.create();

S3AsyncClient s3Client2 = S3AsyncClient.builder().build();

S3AsyncClient s3Client3 = S3AsyncClient.builder()
        .credentialsProvider(ProcessCredentialsProvider.builder().build())
        .region(Region.EU_NORTH_1)
        .build();
```

### Créez *avec un support* en plusieurs parties
<a name="s3-async-client-mp-on"></a>

Pour activer les transferts parallèles avec les paramètres par défaut, appelez `multipartEnabled` le générateur et `true` transmettez-le comme indiqué dans l'exemple suivant.

**Example**  

```
S3AsyncClient s3AsyncClient2 = S3AsyncClient.builder()
        .multipartEnabled(true)
        .build();
```

La valeur par défaut est de 8 MiB pour les paramètres `thresholdInBytes` et`minimumPartSizeInBytes`.

Si vous personnalisez les paramètres partitionnés, les transferts parallèles sont automatiquement activés comme indiqué ci-dessous.

**Example**  

```
import software.amazon.awssdk.services.s3.S3AsyncClient;
import static software.amazon.awssdk.transfer.s3.SizeConstant.MB;


S3AsyncClient s3AsyncClient2 = S3AsyncClient.builder()
        .multipartConfiguration(b -> b
                .thresholdInBytes(16 * MB)
                .minimumPartSizeInBytes(10 * MB))
        .build();
```

## Téléchargement de flux de taille inconnue
<a name="java-async-client-stream-unknown-size"></a>

Le client asynchrone S3 basé sur Java avec le multipart activé peut gérer efficacement les flux d'entrée dont la taille totale n'est pas connue à l'avance :

```
public PutObjectResponse asyncClient_multipart_stream_unknown_size(String bucketName, String key, InputStream inputStream) {

    S3AsyncClient s3AsyncClient = S3AsyncClient.builder().multipartEnabled(true).build();
    ExecutorService executor = Executors.newSingleThreadExecutor();
    AsyncRequestBody body = AsyncRequestBody.fromInputStream(inputStream, null, executor); // 'null' indicates that the
                                                                                           // content length is unknown.
    CompletableFuture<PutObjectResponse> responseFuture =
            s3AsyncClient.putObject(r -> r.bucket(bucketName).key(key), body)
                    .exceptionally(e -> {
                        if (e != null) {
                            logger.error(e.getMessage(), e);
                        }
                        return null;
                    });

    PutObjectResponse response = responseFuture.join(); // Wait for the response.
    executor.shutdown();
    return response;
}
```

Cette approche permet d'éviter les problèmes qui peuvent survenir lors de la spécification manuelle d'une longueur de contenu incorrecte, tels que des objets tronqués ou des échecs de téléchargement.