Chargements en plusieurs parties dans Amazon S3 avec Java

1. Vue d'ensemble

Dans ce didacticiel, nous verrons comment gérer les chargements en plusieurs parties dans Amazon S3 avec AWS Java SDK.

En termes simples, dans un téléchargement en plusieurs parties, nous divisons le contenu en parties plus petites et téléchargeons chaque partie individuellement. Toutes les pièces sont réassemblées une fois reçues.

Les téléchargements en plusieurs parties offrent les avantages suivants:

  • Débit plus élevé - nous pouvons télécharger des pièces en parallèle
  • Récupération d'erreurs plus facile - nous devons télécharger à nouveau uniquement les pièces défectueuses
  • Interrompre et reprendre les téléchargements - nous pouvons télécharger des pièces à tout moment. L'ensemble du processus peut être suspendu et les parties restantes peuvent être téléchargées plus tard

Notez que lorsque vous utilisez le téléchargement en plusieurs parties avec Amazon S3, chaque partie, à l'exception de la dernière, doit avoir une taille d'au moins 5 Mo.

2. Dépendances de Maven

Avant de commencer, nous devons ajouter la dépendance AWS SDK dans notre projet:

 com.amazonaws aws-java-sdk 1.11.290 

Pour voir la dernière version, consultez Maven Central.

3. Exécution du téléchargement en plusieurs parties

3.1. Création d'un client Amazon S3

Tout d'abord, nous devons créer un client pour accéder à Amazon S3. Nous utiliserons AmazonS3ClientBuilder à cette fin:

AmazonS3 amazonS3 = AmazonS3ClientBuilder .standard() .withCredentials(new DefaultAWSCredentialsProviderChain()) .withRegion(Regions.DEFAULT_REGION) .build();

Cela crée un client utilisant la chaîne de fournisseur d'informations d'identification par défaut pour accéder aux informations d'identification AWS.

Pour plus de détails sur le fonctionnement de la chaîne de fournisseurs d'informations d'identification par défaut, consultez la documentation. Si vous utilisez une région autre que la région par défaut ( USA Ouest-2 ), assurez-vous de remplacer Regions.DEFAULT_REGION par cette région personnalisée.

3.2. Création de TransferManager pour la gestion des téléchargements

Nous utiliserons TransferManagerBuilder pour créer une instance de TransferManager .

Cette classe fournit des API simples pour gérer les chargements et les téléchargements avec Amazon S3 et gère toutes les tâches associées:

TransferManager tm = TransferManagerBuilder.standard() .withS3Client(amazonS3) .withMultipartUploadThreshold((long) (5 * 1024 * 1025)) .build();

Le seuil de téléchargement en plusieurs parties spécifie la taille, en octets, au-dessus de laquelle le téléchargement doit être effectué en tant que téléchargement en plusieurs parties.

Amazon S3 impose une taille de pièce minimale de 5 Mo (pour les pièces autres que la dernière pièce), nous avons donc utilisé 5 Mo comme seuil de téléchargement en plusieurs parties.

3.3. Téléchargement d'un objet

Pour télécharger objet à l' aide TransferManager nous avons simplement besoin d'appeler son upload () fonction . Cela télécharge les pièces en parallèle:

String bucketName = "baeldung-bucket"; String keyName = "my-picture.jpg"; String file = new File("documents/my-picture.jpg"); Upload upload = tm.upload(bucketName, keyName, file);

TransferManager.upload () renvoie un objet Upload . Cela peut être utilisé pour vérifier l'état et gérer les téléchargements. Nous le ferons dans la section suivante.

3.4. En attente de la fin du téléchargement

TransferManager.upload () est une fonction non bloquante ; il revient immédiatement pendant que le téléchargement s'exécute en arrière-plan.

Nous pouvons utiliser l' objet Upload renvoyé pour attendre la fin du téléchargement avant de quitter le programme:

try { upload.waitForCompletion(); } catch (AmazonClientException e) { // ... }

3.5. Suivi de la progression du téléchargement

Suivre la progression du téléchargement est une exigence assez courante; nous pouvons le faire à l'aide d'une instance de P rogressListener :

ProgressListener progressListener = progressEvent -> System.out.println( "Transferred bytes: " + progressEvent.getBytesTransferred()); PutObjectRequest request = new PutObjectRequest( bucketName, keyName, file); request.setGeneralProgressListener(progressListener); Upload upload = tm.upload(request);

Le ProgressListener nous avons créé va simplement continuer à imprimer le nombre d'octets transférés jusqu'à ce que le finalise de téléchargement.

3.6. Contrôle du parallélisme de téléchargement

Par défaut, TransferManager utilise un maximum de dix threads pour effectuer des téléchargements en plusieurs parties.

Nous pouvons cependant contrôler cela en spécifiant un ExecutorService lors de la construction de TransferManager :

int maxUploadThreads = 5; TransferManager tm = TransferManagerBuilder.standard() .withS3Client(amazonS3) .withMultipartUploadThreshold((long) (5 * 1024 * 1025)) .withExecutorFactory(() -> Executors.newFixedThreadPool(maxUploadThreads)) .build();

Ici, nous avons utilisé un lambda pour créer une implémentation wrapper d' ExecutorFactory et l' avons passé à la fonction withExecutorFactory () .

4. Conclusion

Dans cet article rapide, nous avons appris comment effectuer des téléchargements en plusieurs parties à l'aide du kit AWS SDK pour Java, et nous avons vu comment contrôler certains aspects du téléchargement et suivre sa progression.

Comme toujours, le code complet de cet article est disponible à l'adresse over sur GitHub.