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.

# Migrez le gestionnaire de transfert de la version 1 à la version 2 du AWS SDK pour Java
<a name="migration-s3-transfer-manager"></a>

Ce guide de migration décrit les principales différences entre Transfer Manager v1 et S3 Transfer Manager v2, notamment les modifications du constructeur, les mappages de méthodes et des exemples de code pour les opérations courantes. Après avoir examiné ces différences, vous pouvez migrer avec succès votre code Transfer Manager existant afin de tirer parti des performances améliorées et des opérations asynchrones de la version 2.

**À propos de l' AWS outil de migration du SDK**  
 AWS SDK pour Java Il fournit un [outil de migration](migration-tool.md) automatique qui peut migrer une grande partie de l'API Transfer Manager v1 vers la v2. Cependant, l'outil de migration ne prend pas en charge plusieurs fonctionnalités de la version 1 de Transfer Manager. Dans ces cas, vous devez migrer manuellement le code de Transfer Manager en suivant les instructions de cette rubrique.  
Tout au long de ce guide, l'**état de migration** indique si l'outil de migration peut migrer automatiquement un constructeur, une méthode ou une fonctionnalité :  
**Supporté** : l'outil de migration peut transformer automatiquement ce code
**Non pris en charge** : vous devez migrer le code manuellement
Même pour les éléments marqués comme « pris en charge », passez en revue les résultats de la migration et testez-les de manière approfondie. La migration de Transfer Manager implique des modifications architecturales importantes, passant d'opérations synchrones à des opérations asynchrones.

## Présentation de
<a name="s3-tm-migration-overview"></a>

S3 Transfer Manager v2 apporte des modifications importantes à l'API Transfer Manager. S3 Transfer Manager v2 repose sur des opérations asynchrones et offre de meilleures performances, en particulier lorsque vous utilisez le client AWS Amazon S3 basé sur CRT.

### Principales différences
<a name="s3-tm-migration-key-differences"></a>
+ **Package** : `com.amazonaws.services.s3.transfer` → `software.amazon.awssdk.transfer.s3`
+ **Nom de la classe** : `TransferManager` → `S3TransferManager`
+ **Dépendance du client** : client Amazon S3 synchrone → client Amazon S3 asynchrone () `S3AsyncClient`
+ **Architecture** : Opérations synchrones → Opérations asynchrones avec `CompletableFuture`
+ **Performances** : améliorées grâce au support AWS client basé sur CRT

## Changements de haut niveau
<a name="s3-tm-migration-high-level-changes"></a>


| Aspect | V1 | V2 | 
| --- | --- | --- | 
| Dépendance à Maven | aws-java-sdk-s3 | s3-transfer-manager | 
| Package | com.amazonaws.services.s3.transfer | software.amazon.awssdk.transfer.s3 | 
| Classe principale | TransferManager | S3TransferManager | 
| Client Amazon S3 | AmazonS3(synchronisation) | S3AsyncClient(asynchrone) | 
| Types de retours | Opérations de blocage | CompletableFuture<T> | 

## Dépendances de Maven
<a name="s3-tm-migration-dependencies"></a>


| V1 | V2 | 
| --- | --- | 
|  <pre><dependencyManagement><br />    <dependencies><br />        <dependency><br />            <groupId>com.amazonaws</groupId><br />            <artifactId>aws-java-sdk-bom</artifactId><br />            <version>>{{1.12.7871}}</version><br />            <type>pom</type><br />            <scope>import</scope><br />        </dependency><br />    </dependencies><br /></dependencyManagement><br /><dependencies><br />    <dependency><br />        <groupId>com.amazonaws</groupId><br />        <artifactId>aws-java-sdk-s3</artifactId><br />    </dependency><br /></dependencies></pre>  |  <pre><dependencyManagement><br />    <dependencies><br />        <dependency><br />            <groupId>software.amazon.awssdk</groupId><br />            <artifactId>bom</artifactId><br />            <version>{{2.31.682}}</version><br />            <type>pom</type><br />            <scope>import</scope><br />        </dependency><br />    </dependencies><br /></dependencyManagement><br /><dependencies><br />    <dependency><br />        <groupId>software.amazon.awssdk</groupId><br />        <artifactId>s3-transfer-manager</artifactId><br />    </dependency><br />    <!-- Optional: For enhanced performance with AWS CRT --><br />    <dependency><br />        <groupId>software.amazon.awssdk.crt</groupId><br />        <artifactId>aws-crt</artifactId><br />        <version>{{0.38.53}}</version><br />    </dependency><br /></dependencies></pre>  | 

1 [Dernière version](https://central.sonatype.com/artifact/com.amazonaws/aws-java-sdk-bom). 2 [Dernière version](https://central.sonatype.com/artifact/software.amazon.awssdk/bom). 3 [Dernière version](https://central.sonatype.com/artifact/software.amazon.awssdk.crt/aws-crt).

## Migration du constructeur client
<a name="s3-tm-migration-client-constructor"></a>

### Constructeurs pris en charge (migration automatique)
<a name="s3-tm-migration-supported-constructors"></a>


| Constructeur V1 | équivalent V2 | État de la migration | 
| --- | --- | --- | 
| new TransferManager() | S3TransferManager.create() | Pris en charge | 
| TransferManagerBuilder. defaultTransferManager() | S3TransferManager.create() | Pris en charge | 
| TransferManagerBuilder. standard().build() | S3TransferManager.builder().build() | Pris en charge | 
| new TransferManager(AWSCredentials) | S3TransferManager.builder() .s3Client(S3AsyncClient.builder() .credentialsProvider(...).build()) .build() | Pris en charge | 
| new TransferManager( AWSCredentialsProvider) | S3TransferManager.builder() .s3Client(S3AsyncClient.builder() .credentialsProvider(...).build()) .build() | Pris en charge | 

### Constructeurs non pris en charge (migration manuelle requise)
<a name="s3-tm-migration-unsupported-constructors"></a>


| Constructeur V1 | équivalent V2 | Remarques sur la migration | 
| --- | --- | --- | 
| new TransferManager(AmazonS3) | Migration manuelle requise | Créez un S3AsyncClient séparément | 
| new TransferManager(AmazonS3, ExecutorService) | Migration manuelle requise | Création S3AsyncClient et configuration d'un exécuteur | 
| new TransferManager(AmazonS3, ExecutorService, boolean) | Migration manuelle requise | shutDownThreadPoolsparamètre non pris en charge | 

### Exemples de migration manuelle
<a name="s3-tm-migration-manual-examples"></a>

**Code V1 :**

```
AmazonS3 s3Client = AmazonS3ClientBuilder.defaultClient();
TransferManager transferManager = new TransferManager(s3Client);
```

**Code V2 :**

```
// Create an `S3AsyncClient` with similar configuration
S3AsyncClient s3AsyncClient = S3AsyncClient.builder()
    .credentialsProvider(DefaultCredentialsProvider.create())
    .build();

// Provide the configured `S3AsyncClient` to the S3 transfer manager builder.
S3TransferManager transferManager = S3TransferManager.builder()
    .s3Client(s3AsyncClient)
    .build();
```

## Migration de la méthode client
<a name="s3-tm-migration-client-methods"></a>

Actuellement, l'outil de migration prend en charge les `resumeUpload` méthodes de base `copy` `download` `upload` `uploadDirectory``downloadDirectory`,`resumeDownload`,,, et.

### Méthodes de transfert de base
<a name="s3-tm-migration-core-transfer-methods"></a>


| Méthode V1 | Méthode V2 | Changement de type de retour | État de la migration | 
| --- | --- | --- | --- | 
| upload(String, String, File) | uploadFile(UploadFileRequest) | Upload → FileUpload | Pris en charge | 
| upload(PutObjectRequest) | upload(UploadRequest) | Upload → Upload | Pris en charge | 
| download(String, String, File) | downloadFile(DownloadFileRequest) | Download → FileDownload | Pris en charge | 
| download(GetObjectRequest, File) | downloadFile(DownloadFileRequest) | Download → FileDownload | Pris en charge | 
| copy(String, String, String, String) | copy(CopyRequest) | Copy → Copy | Pris en charge | 
| copy(CopyObjectRequest) | copy(CopyRequest) | Copy → Copy | Pris en charge | 
| uploadDirectory(String, String, File, boolean) | uploadDirectory( UploadDirectoryRequest) | MultipleFileUpload → DirectoryUpload | Pris en charge | 
| downloadDirectory(String, String, File) | downloadDirectory( DownloadDirectoryRequest) | MultipleFileDownload → DirectoryDownload | Pris en charge | 

### Méthodes de transfert pouvant être reprises
<a name="s3-tm-migration-resumable-methods"></a>


| Méthode V1 | Méthode V2 | État de la migration | 
| --- | --- | --- | 
| resumeUpload(PersistableUpload) | resumeUploadFile(ResumableFileUpload) | Pris en charge | 
| resumeDownload(PersistableDownload) | resumeDownloadFile(ResumableFileDownload) | Pris en charge | 

### Méthodes de cycle de vie
<a name="s3-tm-migration-lifecycle-methods"></a>


| Méthode V1 | Méthode V2 | État de la migration | 
| --- | --- | --- | 
| shutdownNow() | close() | Pris en charge | 
| shutdownNow(boolean) | Ajustez manuellement le code à l'aide de la close() méthode | Non pris en charge | 

### Méthodes client V1 non prises en charge
<a name="s3-tm-migration-unsupported-methods"></a>


| Méthode V1 | Alternative V2 | Remarques | 
| --- | --- | --- | 
| abortMultipartUploads(String, Date) | Utiliser le client Amazon S3 de bas niveau | Non pris en charge | 
| getAmazonS3Client() | Enregistrer une référence séparément | Non pris en charge ; aucun getter dans la version 2 | 
| getConfiguration() | Enregistrer une référence séparément | Non pris en charge ; aucun getter dans la version 2 | 
| uploadFileList(...) | Passez plusieurs uploadFile() appels | Non pris en charge | 
| copyméthodes avec un TransferStateChangeListener paramètre | Utilisation des TransferListener | [Voir l'exemple de migration manuelle](#tm-unsupported-client-methods-copy) | 
| downloadméthodes avec un S3ProgressListener paramètre | Utilisation des [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/progress/TransferListener.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/transfer/s3/progress/TransferListener.html) | [Voir l'exemple de migration manuelle](#tm-unsupported-client-methods-download) | 
| `downloadDirectory`méthodes avec 4 paramètres ou plus |  | [Voir l'exemple de migration manuelle](#tm-unsupported-client-methods-download-dir) | 
| uploadméthode avec ObjectMetadataProvider paramètre | Définir les métadonnées dans la demande | [Voir l'exemple de migration manuelle](#tm-unsupported-client-methods-upload) | 
| uploadDirectoryméthodes avec \*Provider paramètre | Définir les tags dans la demande | [Voir l'exemple de migration manuelle](#tm-unsupported-client-methods-uploadDirectory) | 

#### `copy`méthodes avec un `TransferStateChangeListener` paramètre
<a name="tm-unsupported-client-methods-copy"></a>
+ `copy(CopyObjectRequest copyObjectRequest, AmazonS3 srcS3, TransferStateChangeListener stateChangeListener)`
+ `copy(CopyObjectRequest copyObjectRequest, TransferStateChangeListener stateChangeListener)`

```
// V1 ----------------------------------------------------------------------------------------------
// Initialize source S3 client
AmazonS3 s3client = AmazonS3ClientBuilder.standard()
                .withRegion("us-west-2")
                .build();
                
// Initialize Transfer Manager
TransferManager tm = TransferManagerBuilder.standard()
                .withS3Client(srcS3)
                .build();

CopyObjectRequest copyObjectRequest = new CopyObjectRequest(
                "amzn-s3-demo-source-bucket",
                "source-key",         
                "amzn-s3-demo-destination-bucket", 
                "destination-key"    
        );

TransferStateChangeListener stateChangeListener = new TransferStateChangeListener() {
            @Override
            public void transferStateChanged(Transfer transfer, TransferState state) {
              //Implementation of the TransferStateChangeListener
            }
        };

Copy copy = tm.copy(copyObjectRequest, srcS3, stateChangeListener);


// V2 ----------------------------------------------------------------------------------------------
S3AsyncClient s3AsyncClient = S3AsyncClient.builder()
                .region(Region.US_WEST_2)          
                .build();

S3TransferManager transferManager = S3TransferManager.builder()
                .s3Client(s3AsyncClient)
                .build();

// Create transfer listener (equivalent to TransferStateChangeListener in v1)                                
TransferListener transferListener = new TransferListener() {
            @Override
            public void transferInitiated(Context.TransferInitiated context) {
               //Implementation
               System.out.println("Transfer initiated");
            }

            @Override
            public void bytesTransferred(Context.BytesTransferred context) {
                //Implementation
                System.out.println("Bytes transferred");
            }

            @Override
            public void transferComplete(Context.TransferComplete context) {
                //Implementation
                System.out.println("Transfer completed!");
            }

            @Override
            public void transferFailed(Context.TransferFailed context) {
                //Implementation
                System.out.println("Transfer failed");
            }
        };

CopyRequest copyRequest = CopyRequest.builder()
                              .copyObjectRequest(req -> req
                                  .sourceBucket("amzn-s3-demo-source-bucket")
                                  .sourceKey("source-key")
                                  .destinationBucket("amzn-s3-demo-destination-bucket")
                                  .destinationKey("destination-key")
                               )
                                .addTransferListener(transferListener) // Configure the transferListener into the request
                                .build();
  
Copy copy = transferManager.copy(copyRequest);
```

#### `download`méthodes avec un `S3ProgressListener` paramètre
<a name="tm-unsupported-client-methods-download"></a>
+ `download(GetObjectRequest getObjectRequest, File file, S3ProgressListener progressListener)`
+ `download(GetObjectRequest getObjectRequest, File file, S3ProgressListener progressListener, long timeoutMillis)`
+ `download(GetObjectRequest getObjectRequest, File file, S3ProgressListener progressListener, long timeoutMillis, boolean resumeOnRetry)`

```
// V1 ----------------------------------------------------------------------------------------------
S3ProgressListener progressListener = new S3ProgressListener() {
        @Override
        public void progressChanged(com.amazonaws.event.ProgressEvent progressEvent) {
            long bytes = progressEvent.getBytesTransferred();
            ProgressEventType eventType = progressEvent.getEventType();
            // Use bytes and eventType as needed
        }

        @Override
        public void onPersistableTransfer(PersistableTransfer persistableTransfer) {

        }
    };

Download download1 = tm.download(getObjectRequest, file, progressListener); 
Download download2 = tm.download(getObjectRequest, file, progressListener, timeoutMillis)
Download download3 = tm.download(getObjectRequest, file, progressListener, timeoutMillis, true)

// V2 ----------------------------------------------------------------------------------------------
TransferListener transferListener = new TransferListener() {
    @Override
    public void transferInitiated(Context.InitializedContext context) {
        // Equivalent to ProgressEventType.TRANSFER_STARTED_EVENT
        System.out.println("Transfer initiated");
    }

    @Override
    public void bytesTransferred(Context.BytesTransferred context) {
        // Equivalent to ProgressEventType.REQUEST_BYTE_TRANSFER_EVENT
        long bytes = context.bytesTransferred();
        System.out.println("Bytes transferred: " + bytes);
    }

    @Override
    public void transferComplete(Context.TransferComplete context) {
        // Equivalent to ProgressEventType.TRANSFER_COMPLETED_EVENT
        System.out.println("Transfer completed");
    }

    @Override
    public void transferFailed(Context.TransferFailed context) {
        // Equivalent to ProgressEventType.TRANSFER_FAILED_EVENT
        System.out.println("Transfer failed: " + context.exception().getMessage());
    }
};
DownloadFileRequest downloadFileRequest = 
                         DownloadFileRequest.builder()
                             .getObjectRequest(getObjectRequest)
                             .destination(file.toPath())
                             .addTransferListener(transferListener)
                             .build();

// For download1
FileDownload download = transferManager.downloadFile(downloadFileRequest);

// For download2
CompletedFileDownload completedFileDownload = download.completionFuture()
                                                  .get(timeoutMillis, TimeUnit.MILLISECONDS);

// For download3, the v2 SDK does not have a direct equiavalent to the `resumeOnRetry` method of v1.
// If a download is interrupted, you need to start a new download request.
```

#### `downloadDirectory`méthodes avec 4 paramètres ou plus
<a name="tm-unsupported-client-methods-download-dir"></a>
+ `downloadDirectory(String bucketName, String keyPrefix, File destinationDirectory, boolean resumeOnRetry)`
+ `downloadDirectory(String bucketName, String keyPrefix, File destinationDirectory, boolean resumeOnRetry, KeyFilter filter)`
+ `downloadDirectory(String bucketName, String keyPrefix, File destinationDirectory, KeyFilter filter)`

```
// V1 ----------------------------------------------------------------------------------------------
KeyFilter filter = new KeyFilter() {
            @Override
            public boolean shouldInclude(S3ObjectSummary objectSummary) {
                //Filter implementation
            }
        };
MultipleFileDownload multipleFileDownload = tm.downloadDirectory(bucketName, keyPrefix, destinationDirectory, filter);

// V2 ----------------------------------------------------------------------------------------------
// The v2 SDK does not have a direct equiavalent to the `resumeOnRetry` method of v1.
// If a download is interrupted, you need to start a new download request.
DownloadFilter filter = new DownloadFilter() {
            @Override
            public boolean test(S3Object s3Object) {
                // Filter implementation.
            }
        };

DownloadDirectoryRequest downloadDirectoryRequest = 
                              DownloadDirectoryRequest.builder()
                                  .bucket(bucketName)
                                  .filter(filter)
                                  .listObjectsV2RequestTransformer(builder -> builder.prefix(keyPrefix))
                                  .destination(destinationDirectory.toPath())
                                  .build();
                                                                            
DirectoryDownload directoryDownload = transferManager.downloadDirectory(downloadDirectoryRequest);
```

#### `upload`méthode avec `ObjectMetadata` paramètre
<a name="tm-unsupported-client-methods-upload"></a>
+ `upload(String bucketName, String key, InputStream input, ObjectMetadata objectMetadata)`

```
// V1 ----------------------------------------------------------------------------------------------ObjectMetadata metadata = new ObjectMetadata();
ObjectMetadata metadata = new ObjectMetadata();

metadata.setContentType("text/plain");        // System-defined metadata
metadata.setContentLength(22L);               // System-defined metadata
metadata.addUserMetadata("myKey", "myValue"); // User-defined metadata

PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, key, inputStream, metadata);

Upload upload = transferManager.upload("amzn-s3-demo-bucket", "my-key", inputStream, metadata);

// V2 ----------------------------------------------------------------------------------------------
/* When you use an InputStream to upload in V2, you should specify the content length 
   and use `RequestBody.fromInputStream()`. 
   If you don't provide the content length, the entire stream will be buffered in memory. 
   If you can't determine the content length, we recommend using the CRT-based S3 client.
*/
Map<String, String> userMetadata = new HashMap<>();
userMetadata.put("x-amz-meta-myKey", "myValue");

PutObjectRequest putObjectRequest = 
                        PutObjectRequest.builder()
                            .bucket("amzn-s3-demo-bucket1")
                            .key("k")
                            .contentType("text/plain") //System-defined metadata usually has separate methods in the builder.
                            .contentLength(22L)
                            .metadata(userMetadata) //metadata() is only for user-defined metadata.
                            .build();

UploadRequest uploadRequest = 
                        UploadRequest.builder()
                            .putObjectRequest(putObjectRequest)
                            .requestBody(AsyncRequestBody.fromInputStream(stream, 22L, executor))
                            .build();
                                                   
transferManager.upload(uploadRequest).completionFuture().join();
```

#### `uploadDirectory`avec `ObjectMetadataProvider` paramètre
<a name="tm-unsupported-client-methods-uploadDirectory"></a>
+ `uploadDirectory(String bucketName, String virtualDirectoryKeyPrefix, File directory, boolean includeSubdirectories, ObjectMetadataProvider metadataProvider)`
+ `uploadDirectory(String bucketName, String virtualDirectoryKeyPrefix, File directory, boolean includeSubdirectories, ObjectMetadataProvider metadataProvider, ObjectTaggingProvider taggingProvider)`
+ `uploadDirectory(String bucketName, String virtualDirectoryKeyPrefix, File directory, boolean includeSubdirectories, ObjectMetadataProvider metadataProvider, ObjectTaggingProvider taggingProvider, ObjectCannedAclProvider cannedAclProvider)`

```
// V1 ----------------------------------------------------------------------------------------------
tm.uploadDirectory(bucketName, virtualDirectoryKeyPrefix, directory, includeSubdirectories, metadataProvider)
tm.uploadDirectory(bucketName, virtualDirectoryKeyPrefix, directory, includeSubdirectories, metadataProvider, taggingProvider)
tm.uploadDirectory(bucketName, virtualDirectoryKeyPrefix, directory, includeSubdirectories, metadataProvider, taggingProvider, cannedAclProvider)

// V2 ----------------------------------------------------------------------------------------------
UploadDirectoryRequest request = UploadDirectoryRequest.builder()
                                  .bucket(bucketName)
                                  .s3Prefix(virtualDirectoryKeyPrefix)
                                  .source(directory.toPath())
                                  .maxDepth(includeSubdirectories ? Integer.MAX_VALUE : 1)
                                  .uploadFileRequestTransformer(builder -> {
                                      // 1.Replace `ObjectMetadataProvider`, `ObjectTaggingProvider`, and `ObjectCannedAclProvider` with an
                                        // `UploadFileRequestTransformer` that can combine the functionality of all three *Provider implementations.
                                        // 2. Convert your v1 `ObjectMetadata` to v2 `PutObjectRequest` parameters.
                                        // 3. Convert your v1 `ObjectTagging` to v2 `Tagging`.
                                        // 4. Convert your v1 `CannedAccessControlList` to v2 `ObjectCannedACL`.
                                  })
                                  .build();
        
DirectoryUpload directoryUpload = transferManager.uploadDirectory(request);
```

## Migration d'objets du modèle
<a name="s3-tm-migration-model-objects"></a>

En AWS SDK for Java 2.x, de nombreux objets du `TransferManager` modèle ont été redessinés et plusieurs méthodes getter et setter disponibles dans les objets modèle de la version 1 ne sont plus prises en charge. 

Dans la version 2, vous pouvez utiliser la `CompletableFuture<T>` classe pour effectuer des actions une fois le transfert terminé, que ce soit avec succès ou avec une exception. Vous pouvez utiliser `join()` cette méthode pour attendre la fin si nécessaire. 

### Objets de transfert principaux
<a name="s3-tm-migration-core-transfer-objects"></a>


| Classe V1 | Classe V2 | État de la migration | 
| --- | --- | --- | 
| TransferManager | S3TransferManager | Pris en charge | 
| TransferManagerBuilder | S3TransferManager.Builder | Pris en charge | 
| Transfer | Transfer | Pris en charge | 
| AbortableTransfer | Transfer | Pris en charge (pas de classe séparée) | 
| Copy | Copy | Pris en charge | 
| Download | FileDownload | Pris en charge | 
| Upload | Upload / FileUpload | Pris en charge | 
| MultipleFileDownload | DirectoryDownload | Pris en charge | 
| MultipleFileUpload | DirectoryUpload | Pris en charge | 

### Objets de persistance
<a name="s3-tm-migration-persistence-objects"></a>


| Classe V1 | Classe V2 | État de la migration | 
| --- | --- | --- | 
| PersistableDownload | ResumableFileDownload | Pris en charge | 
| PersistableUpload | ResumableFileUpload | Pris en charge | 
| PersistableTransfer | ResumableTransfer | Pris en charge | 
| PauseResult<T> | Objet directement réutilisable | Non pris en charge | 

### Objets de résultat
<a name="s3-tm-migration-result-objects"></a>


| Classe V1 | Classe V2 | État de la migration | 
| --- | --- | --- | 
| CopyResult | CompletedCopy | Pris en charge | 
| UploadResult | CompletedUpload | Pris en charge | 

### Objets de configuration
<a name="s3-tm-migration-configuration-objects"></a>


| Classe V1 | Classe V2 | État de la migration | 
| --- | --- | --- | 
| TransferManagerConfiguration | MultipartConfiguration(sur le client Amazon S3) | Pris en charge | 
| TransferProgress | TransferProgress \+ TransferProgressSnapshot | Pris en charge | 
| KeyFilter | DownloadFilter | Pris en charge | 

### Objets non pris en charge
<a name="s3-tm-migration-unsupported-objects"></a>


| Classe V1 | Alternative V2 | État de la migration | 
| --- | --- | --- | 
| PauseStatus | Non pris en charge | Non pris en charge | 
| UploadContext | Non pris en charge | Non pris en charge | 
| ObjectCannedAclProvider | PutObjectRequest.builder().acl() | Non pris en charge | 
| ObjectMetadataProvider | PutObjectRequest.builder().metadata() | Non pris en charge | 
| ObjectTaggingProvider | PutObjectRequest.builder().tagging() | Non pris en charge | 
| PresignedUrlDownload | Non pris en charge | Non pris en charge | 

## TransferManagerBuilder migration de configuration
<a name="s3-tm-migration-builder-configuration"></a>

### Configuration changes
<a name="migration-transfer-manager-config-changes"></a>

Les modifications de configuration que vous devez définir pour le gestionnaire de transfert v2 dépendent du client S3 que vous utilisez. Vous avez le choix entre le client S3 AWS basé sur CRT ou le client asynchrone S3 standard basé sur Java. Pour plus d'informations sur les différences, consultez la [clients S3 dans le AWS SDK for Java 2.x](examples-s3.md#s3-clients) rubrique.

------
#### [ Use the AWS CRT-based S3 client ]


****  

| Paramètre | v1 | v2 - Gestionnaire de transfert utilisant un client S3 AWS basé sur CRT | 
| --- | --- | --- | 
|  <br />(trouvez un constructeur) |  <pre>TransferManagerBuilder tmBuilder = <br />   TransferManagerBuilder.standard();</pre>  |  <pre>S3TransferManager.Builder tmBuilder  = <br />  S3TransferManager.builder();</pre>  | 
|  <br />Client S3 |  <pre>tmBuilder.withS3Client(...);<br />tmBuilder.setS3Client(...);</pre>  |  <pre>tmBuilder.s3Client(...);</pre>  | 
|  <br />Exécuteur |  <pre>tmBuilder.withExecutorFactory(...);<br />tmBuilder.setExecutorFactory(...);</pre>  |  <pre>tmBuilder.executor(...);</pre>  | 
|  <br />Arrêter les pools de threads |  <pre>tmBuilder.withShutDownThreadPools(...);<br />tmBuilder.setShutdownThreadPools(...);</pre>  | Non pris en charge. L'exécuteur fourni ne sera pas arrêté à la fermeture du S3TransferManager | 
|  <br />Taille minimale de la pièce à télécharger |  <pre>tmBuilder.withMinimumUploadPartSize(...);<br />tmBuilder.setMinimumUploadPartSize(...);</pre>  |  <pre>S3AsyncClient s3 = S3AsyncClient.crtBuilder().<br />      minimumPartSizeInBytes(...).build();<br /><br />tmBuilder.s3Client(s3);</pre>  | 
|  <br />Seuil de téléchargement en plusieurs parties |  <pre>tmBuilder.withMultipartUploadThreshold(...);<br />tmBuilder.setMultipartUploadThreshold(...);</pre>  |  <pre>S3AsyncClient s3 = S3AsyncClient.crtBuilder().<br />      thresholdInBytes(...).build();<br /><br />tmBuilder.s3Client(s3);</pre>  | 
|  <br />Taille minimale des parties de copie |  <pre>tmBuilder.withMultipartCopyPartSize(...);<br />tmBuilder.setMultipartCopyPartSize(...);</pre>  |  <pre>S3AsyncClient s3 = S3AsyncClient.crtBuilder().<br />      minimumPartSizeInBytes(...).build();<br /><br />tmBuilder.s3Client(s3);</pre>  | 
|  <br />Seuil de copie en plusieurs parties |  <pre>tmBuilder.withMultipartCopyThreshold(...);<br />tmBuilder.setMultipartCopyThreshold(...);</pre>  |  <pre>S3AsyncClient s3 = S3AsyncClient.crtBuilder().<br />      thresholdInBytes(...).build();<br /><br />tmBuilder.s3Client(s3);</pre>  | 
|  <br />Désactiver les téléchargements parallèles |  <pre>tmBuilder.withDisableParallelDownloads(...);<br />tmBuilder.setDisableParallelDownloads(...);</pre>  | Désactivez les téléchargements parallèles en transmettant un client S3 standard basé sur Java avec le multipart désactivé (par défaut) au gestionnaire de transfert.<pre>S3AsyncClient s3 =<br />   S3AsyncClient.builder().build();<br /><br />tmBuilder.s3Client(s3);</pre> | 
|  <br />Calculez toujours le md5 en plusieurs parties |  <pre>tmBuilder.withAlwaysCalculateMultipartMd5(...);<br />tmBuilder.setAlwaysCalculateMultipartMd5(...);</pre>  | Non pris en charge. | 

------
#### [ Use Java-based S3 async client ]


****  

| Paramètre | v1 | v2 - Gestionnaire de transfert utilisant un client asynchrone S3 basé sur Java | 
| --- | --- | --- | 
|  <br />(trouvez un constructeur) |  <pre>TransferManagerBuilder tmBuilder = <br />   TransferManagerBuilder.standard();</pre>  |  <pre>S3TransferManager.Builder tmBuilder  = <br />  S3TransferManager.builder();</pre>  | 
|  <br />Client S3 |  <pre>tmBuilder.withS3Client(...);<br />tmBuilder.setS3Client(...);</pre>  |  <pre>tmBuilder.s3Client(...);</pre>  | 
|  <br />Exécuteur |  <pre>tmBuilder.withExecutorFactory(...);<br />tmBuilder.setExecutorFactory(...);</pre>  |  <pre>tmBuilder.executor(...);</pre>  | 
|  <br />Arrêter les pools de threads |  <pre>tmBuilder.withShutDownThreadPools(...);<br />tmBuilder.setShutdownThreadPools(...);</pre>  | Non pris en charge. L'exécuteur fourni ne sera pas arrêté à la fermeture du S3TransferManager | 
|  <br />Taille minimale de la pièce à télécharger |  <pre>tmBuilder.withMinimumUploadPartSize(...);<br />tmBuilder.setMinimumUploadPartSize(...);</pre>  |  <pre>S3AsyncClient s3 = S3AsyncClient.builder()<br />    .multipartConfiguration(cfg -><br />        cfg.minimumPartSizeInBytes(...)).build();<br /><br />tmBuilder.s3Client(s3);</pre>  | 
|  <br />Seuil de téléchargement en plusieurs parties |  <pre>tmBuilder.withMultipartUploadThreshold(...);<br />tmBuilder.setMultipartUploadThreshold(...);</pre>  |  <pre>S3AsyncClient s3 = S3AsyncClient.builder()<br />    .multipartConfiguration(cfg -><br />        cfg.thresholdInBytes(...)).build();<br /><br />tmBuilder.s3Client(s3);</pre>  | 
|  <br />Taille minimale des parties de copie |  <pre>tmBuilder.withMultipartCopyPartSize(...);<br />tmBuilder.setMultipartCopyPartSize(...);</pre>  |  <pre>S3AsyncClient s3 = S3AsyncClient.builder()<br />    .multipartConfiguration(cfg -><br />        cfg.minimumPartSizeInBytes(...)).build();<br /><br />tmBuilder.s3Client(s3);</pre>  | 
|  <br />Seuil de copie en plusieurs parties |  <pre>tmBuilder.withMultipartCopyThreshold(...);<br />tmBuilder.setMultipartCopyThreshold(...);</pre>  |  <pre>S3AsyncClient s3 = S3AsyncClient.builder()<br />    .multipartConfiguration(cfg -><br />        cfg.thresholdInBytes(...)).build();<br /><br />tmBuilder.s3Client(s3);</pre>  | 
|  <br />Désactiver les téléchargements parallèles |  <pre>tmBuilder.withDisableParallelDownloads(...);<br />tmBuilder.setDisableParallelDownloads(...);</pre>  | Désactivez les téléchargements parallèles en transmettant un client S3 standard basé sur Java avec le multipart désactivé (par défaut) au gestionnaire de transfert.<pre>S3AsyncClient s3 =<br />   S3AsyncClient.builder().build();<br /><br />tmBuilder.s3Client(s3);</pre> | 
|  <br />Calculez toujours le md5 en plusieurs parties |  <pre>tmBuilder.withAlwaysCalculateMultipartMd5(...);<br />tmBuilder.setAlwaysCalculateMultipartMd5(...);</pre>  | Non pris en charge. | 

------

## Changements de comportement
<a name="s3-tm-migration-behavior-changes"></a>

### Opérations asynchrones
<a name="s3-tm-migration-async-operations"></a>

**V1 (blocage) :**

```
Upload upload = transferManager.upload("amzn-s3-demo-bucket", "key", file);
upload.waitForCompletion(); // Blocks until complete
```

**V2 (asynchrone) :**

```
FileUpload upload = transferManager.uploadFile(UploadFileRequest.builder()
    .putObjectRequest(PutObjectRequest.builder()
        .bucket("amzn-s3-demo-bucket")
        .key("key")
        .build())
    .source(file)
    .build());

CompletedFileUpload result = upload.completionFuture().join(); // Blocks until complete
// Or handle asynchronously:
upload.completionFuture().thenAccept(result -> {
    System.out.println("Upload completed: " + result.response().eTag());
});
```

### Gestion des erreurs
<a name="s3-tm-migration-error-handling"></a>

**V1 :** Les transferts de répertoire échouent complètement si une sous-requête échoue.

**V2 :** Les transferts de répertoire se terminent avec succès même si certaines sous-requêtes échouent. Vérifiez les erreurs de manière explicite :

```
DirectoryUpload directoryUpload = transferManager.uploadDirectory(request);
CompletedDirectoryUpload result = directoryUpload.completionFuture().join();

// Check for failed transfers
if (!result.failedTransfers().isEmpty()) {
    System.out.println("Some uploads failed:");
    result.failedTransfers().forEach(failed -> 
        System.out.println("Failed: " + failed.exception().getMessage()));
}
```

### Téléchargement parallèle via des extractions par plage d'octets
<a name="migration-transfer-manager-behavior-fetches"></a>

Lorsque la fonction de transfert parallèle automatique est activée dans le SDK v2, le gestionnaire de transfert S3 utilise des extractions par [plage d'octets pour récupérer des](https://docs.aws.amazon.com/AmazonS3/latest/userguide/optimizing-performance-guidelines.html#optimizing-performance-guidelines-get-range) parties spécifiques de l'objet en parallèle (téléchargement en plusieurs parties). La façon dont un objet est téléchargé avec la version v2 ne dépend pas de la manière dont l'objet a été initialement chargé. Tous les téléchargements peuvent bénéficier d'un débit élevé et d'une simultanéité. 

En revanche, avec le gestionnaire de transfert de la version 1, la manière dont l'objet a été initialement chargé est importante. Le gestionnaire de transfert v1 récupère les parties de l'objet de la même manière que les parties ont été téléchargées. Si un objet a été initialement chargé en tant qu'objet unique, le gestionnaire de transfert v1 n'est pas en mesure d'accélérer le processus de téléchargement en utilisant des sous-requêtes.