TOC

Uploads en plusieurs parties dans Amazon S3 avec Java

Chargements multiples en 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.

Simply put, in a multipart upload, we split the content into smaller parts and upload each part individually. 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'erreur plus facile - nous devons télécharger à nouveau uniquement les pièces défectueuses

  • Suspendre et reprendre les téléchargements - nous pouvons télécharger des pièces à tout moment. L'ensemble du processus peut être mis en pause et les pièces restantes peuvent être téléchargées plus tard

Notez que lors de l'utilisation du téléchargement en plusieurs partieswith Amazon S3, each part except the last part must be at least 5 MB in size.

2. Dépendances Maven

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


    com.amazonaws
    aws-java-sdk
    1.11.290

Pour afficher la dernière version, consultezMaven Central.

3. Effectuer un téléchargement en plusieurs parties

3.1. Création d'un client Amazon S3

Tout d'abord, nous devonscreate a client for accessing Amazon S3. Nous utiliserons lesAmazonS3ClientBuilder à 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, veuillez consulterthe documentation. Si vous utilisez une région autre que la région par défaut (US West-2), assurez-vous de remplacerRegions.DEFAULT_REGION par cette région personnalisée.

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

Nous utiliseronsTransferManagerBuilder pour créer une instanceTransferManager.

Cette classeprovides simple APIs to manage uploads and downloads with 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 partie minimale de 5 Mo (pour les parties autres que la dernière partie), nous avons donc utilisé 5 Mo comme seuil de chargement en plusieurs parties.

3.3. Téléchargement d'un objet

To upload object using TransferManager we simply need to call its upload() function. Ceci télécharge les pièces en parallèle: 

String bucketName = "example-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 objetUpload. Ceci peut être utilisé pour vérifier le statut 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() is a non-blocking function; il revient immédiatement pendant que le téléchargement s'exécute en arrière-plan.

On peutuse the returned Upload object to wait for the upload to complete 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 instanceProgressListener: 

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

LesProgressListener que nous avons créés continueront simplement à imprimer le nombre d'octets transférés jusqu'à la fin du 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 unExecutorService lors de la construction deTransferManager: 

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 deExecutorFactory et l'avons passé à la fonctionwithExecutorFactory().

4. Conclusion

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

Comme toujours, le code complet de cet article est disponibleover on GitHub.

Related