Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Trasferisci le directory da e verso Amazon S3 utilizzando AWS SDK per PHP la versione 3
<a name="s3-transfer"></a>

Usa la `Transfer` classe nella AWS SDK per PHP versione 3 per caricare intere directory in un bucket Amazon S3 e scaricare interi bucket in una directory locale.

## Caricamento di una directory locale su Amazon S3
<a name="uploading-a-local-directory-to-s3"></a>

L'[https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.Transfer.html](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.Transfer.html)oggetto esegue i trasferimenti. L'esempio seguente mostra come caricare in modo ricorsivo una directory locale di file in un bucket Amazon S3.

```
// Create an S3 client.
$client = new \Aws\S3\S3Client([
    'region'  => 'us-west-2',
    'version' => '2006-03-01',
]);

// Where the files will be sourced from.
$source = '/path/to/source/files';

// Where the files will be transferred to.
$dest = 's3://bucket';

// Create a transfer object.
$directoryTransfer = new \Aws\S3\Transfer($client, $source, $dest);

// Perform the transfer synchronously.
$directoryTransfer->transfer();
```

In questo esempio, abbiamo creato un client Amazon S3, creato un `Transfer` oggetto ed eseguito il trasferimento in modo sincrono. 

L'esempio precedente mostra la quantità minima di codice necessaria per eseguire un trasferimento. Un `Transfer` oggetto può anche eseguire trasferimenti in modo asincrono e dispone di varie opzioni di configurazione che è possibile utilizzare per personalizzare i trasferimenti.

Puoi caricare i file locali in una «sottocartella» di un bucket Amazon S3 fornendo un key prefix nell'URI. `s3://` L'esempio seguente mostra come caricare file locali su disco in un bucket `bucket` e come archiviare file con il prefisso della chiave `foo`.

```
$source = '/path/to/source/files';
$dest = 's3://bucket/foo';
$directoryTransfer = new \Aws\S3\Transfer($client, $source, $dest);
$directoryTransfer->transfer();
```

## Scaricare un bucket Amazon S3
<a name="downloading-an-s3-bucket"></a>

Puoi scaricare in modo ricorsivo un bucket Amazon S3 in una directory locale su disco specificando l'argomento `$source` come URI Amazon S3 (ad esempio`s3://bucket`) e `$dest` l'argomento come percorso di una directory locale.

```
// Where the files will be sourced from.
$source = 's3://bucket';

// Where the files will be transferred to.
$dest = '/path/to/destination/dir';

$directoryTransfer = new \Aws\S3\Transfer($client, $source, $dest);
$directoryTransfer->transfer();
```

**Nota**  
L'SDK crea automaticamente tutte le directory necessarie durante il download degli oggetti nel bucket.

Puoi includere un prefisso chiave nell'URI di Amazon S3 dopo il bucket per scaricare solo gli oggetti archiviati in una «pseudo-cartella». L'esempio seguente mostra i download dei soli file memorizzati con il prefisso della chiave "/foo" di un determinato bucket.

```
$source = 's3://bucket/foo';
$dest = '/path/to/destination/dir';
$directoryTransfer = new \Aws\S3\Transfer($client, $source, $dest);
$directoryTransfer->transfer();
```

## Configurazione
<a name="configuration"></a>

Il costruttore dell'oggetto `Transfer` accetta i seguenti argomenti.

** `$client` **  
L'oggetto `Aws\ClientInterface` da utilizzare per eseguire i trasferimenti.

** `$source`(`Iterator`stringa \$1)**  
I dati di origine in fase di trasferimento. Questo può indicare un percorso locale su disco (ad esempio`/path/to/files`) o un bucket Amazon S3 (ad esempio). `s3://bucket` L'URI `s3://` può contenere anche una chiave del prefisso che può essere utilizzata solo per il trasferimento di oggetti con un prefisso comune.  
Se l'`$source`argomento è un URI Amazon S3, l'`$dest`argomento deve essere una directory locale (e viceversa).  
Oltre a fornire un valore della stringa, è anche possibile fornire un oggetto `\Iterator` che produce nomi di file assoluti. Se fornisci un `\Iterator` oggetto, **devi** fornire un'`base_dir`opzione nell'array `$options` associativo.

** `$dest` **  
La destinazione in cui i file verranno trasferiti. Se l'`$source`argomento è un percorso locale su disco, `$dest` deve essere un URI del bucket Amazon S3 (ad esempio). `s3://bucket` Se l'`$source`argomento è un URI del bucket Amazon S3, l'`$dest`argomento deve essere un percorso locale su disco.

** `$options` **  
Un array associativo delle opzioni di trasferimento. Le seguenti opzioni di trasferimento sono valide:    
**`add_content_md5` (bool)**  
Imposta su `true` per calcolare il MD5 checksum per i caricamenti.  
** `base_dir` (Stringa)**  
Directory di base dell'origine, se `$source` è un'iterazione. Se l'opzione `$source` non è un array, questa opzione viene ignorata.  
** `before` (callable)**  
Un callback da invocare prima di ogni trasferimento. Il callback deve disporre di una firma della funzione, come `function (Aws\Command $command) {...}`. Il comando fornito sarà `GetObject`, `PutObject`, `CreateMultipartUpload`, `UploadPart` o `CompleteMultipartUpload`.  
** `mup_threshold` (int)**  
Le dimensioni in byte di un caricamento in più parti da utilizzare al posto di `PutObject`. Il valore predefinito è `16777216` (16 MB).  
** `concurrency` (int, predefinito=5)**  
Numero di file da caricare simultaneamente. Il valore ottimale varia in base al numero di file caricati e alle dimensioni medie di ciascun file. Di solito, i file di dimensioni minori possono contare su un valore di simultaneità maggiore rispetto ai file di dimensioni più grandi.  
** `debug` (bool)**  
Imposta su `true` per stampare le informazioni di debug per i trasferimenti. Imposta su una risorsa `fopen()` per la scrittura su un flusso specifico invece che su STDOUT.

## Trasferimenti asincroni
<a name="async-transfers"></a>

L'oggetto `Transfer` è un'istanza di `GuzzleHttp\Promise\PromisorInterface`. Pertanto, il trasferimento può verificarsi in modo asincrono e viene avviato chiamando il metodo `promise` dell'oggetto.

```
$source = '/path/to/source/files';
$dest = 's3://bucket';
$directoryTransfer = new \Aws\S3\Transfer($client, $source, $dest);

// Initiate the transfer and get a promise.
$promise = $directoryTransfer->promise();

// Do something when the transfer is complete using the then() method.
$promise->then(function () {
    echo 'Done!';
});
```

La promessa viene rifiutata se un file non viene trasferito. È possibile gestire il trasferimento non riuscito in modo asincrono utilizzando il metodo `otherwise` della promessa. La funzione `otherwise` accetta un callback da invocare quando si verifica un errore. Il callback accetta il comando `$reason` for the rejection, che in genere è un'istanza di `Aws\Exception\AwsException` (sebbene al callback possa essere fornito un valore di **qualsiasi** tipo).

```
$promise->otherwise(function ($reason) {
    echo 'Transfer failed: ';
    var_dump($reason);
});
```

Poiché l'oggetto `Transfer` restituisce una promessa, questi trasferimenti possono verificarsi simultaneamente con altre promesse asincrone.

## Personalizzazione del trasferimento delle directory
<a name="customizing-the-transfer-manager-s-commands"></a>

Aggiungendo un callback al costruttore, è possibile personalizzare le opzioni che esegue. `Transfer`

```
$uploader = new Transfer($s3Client, $source, $dest, [
    'before' => function (\Aws\Command $command) {
        // Commands can vary for multipart uploads, so check which command
        // is being processed.
        if (in_array($command->getName(), ['PutObject', 'CreateMultipartUpload'])) {
            // Set custom cache-control metadata.
            $command['CacheControl'] = 'max-age=3600';
            // Apply a canned ACL.
            $command['ACL'] = strpos($command['Key'], 'CONFIDENTIAL') ### false
                ? 'public-read'
                : 'private';
        }
    },
]);
```