Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Transfiera directorios hacia y desde Amazon S3 con la AWS SDK para PHP versión 3
La `Transfer` clase de la AWS SDK para PHP versión 3 se utiliza para cargar directorios completos en un bucket de Amazon S3 y descargar buckets completos en un directorio local.
## Cargar un directorio local en Amazon S3
El [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)objeto realiza las transferencias. En el siguiente ejemplo se muestra cómo cargar de forma recursiva un directorio local de archivos a un bucket de 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();
```
En este ejemplo, hemos creado un cliente de Amazon S3 y un objeto `Transfer`, y hemos realizado la transferencia de forma síncrona.
El ejemplo anterior demuestra la cantidad mínima de código necesaria para realizar una transferencia. Un `Transfer` objeto también puede realizar transferencias de forma asíncrona y tiene varias opciones de configuración que puede utilizar para personalizar las transferencias.
Puede cargar los archivos locales a una «subcarpeta» de un bucket de Amazon S3 añadiendo un prefijo de clave al URI de `s3://`. En el siguiente ejemplo se cargan los archivos locales en el disco en el bucket `bucket` y se almacenan los archivos con el prefijo de clave `foo`.
```
$source = '/path/to/source/files';
$dest = 's3://bucket/foo';
$directoryTransfer = new \Aws\S3\Transfer($client, $source, $dest);
$directoryTransfer->transfer();
```
## Descargar un bucket de Amazon S3
Puede descargar de forma recursiva un bucket de Amazon S3 en un directorio local del disco especificando el argumento `$source` como URI de Amazon S3 (por ejemplo, `s3://bucket`) y el argumento `$dest` como la ruta a un directorio local.
```
// 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**
El SDK crea automáticamente los directorios necesarios al descargar los objetos del depósito.
Puede incluir un prefijo de clave en el URI de Amazon S3 después del bucket para descargar solo los objetos almacenados en una «pseudocarpeta». En el siguiente ejemplo, solo se descargan los archivos almacenados con el prefijo de clave "/foo" del bucket determinado.
```
$source = 's3://bucket/foo';
$dest = '/path/to/destination/dir';
$directoryTransfer = new \Aws\S3\Transfer($client, $source, $dest);
$directoryTransfer->transfer();
```
## Configuración
El constructor del objeto `Transfer` acepta los siguientes argumentos.
** `$client` **
Es el objeto `Aws\ClientInterface` que hay que utilizar para ejecutar las transferencias.
** `$source` (cadena \$1 `Iterator`)**
Son los datos de origen que se están transfiriendo. Puede apuntar hacia una ruta local en el disco (por ejemplo, `/path/to/files`) o hacia un bucket de Amazon S3 (por ejemplo, `s3://bucket`). El URI `s3://` también pueden contener un prefijo de clave que se puede utilizar para transferir únicamente los objetos con un prefijo común.
Si el argumento `$source` es un URI de Amazon S3, el argumento `$dest` debe ser un directorio local (y viceversa).
Además de proporcionar un valor de cadena, también puede proporcionar un objeto `\Iterator` que da como resultado nombres de archivo absolutos. Si proporciona un `\Iterator` objeto, **debe** proporcionar una `base_dir` opción en la matriz `$options` asociativa.
** `$dest` **
Es el destino al que se transfieren los archivos. Si el argumento `$source` es una ruta local en el disco, `$dest` debe ser un URI de bucket de Amazon S3 (por ejemplo, `s3://bucket`). Si el argumento `$source` es un URI de bucket de Amazon S3, el argumento `$dest` debe ser una ruta local del disco.
** `$options` **
Es una matriz asociativa de opciones de transferencia. Las siguientes opciones de transferencia son válidas:
**`add_content_md5` (bool)**
Configúrelo `true` en para calcular la MD5 suma de comprobación de las cargas.
** `base_dir` (cadena)**
Es el directorio base del origen, si `$source` es un iterador. Si la opción `$source` no es una matriz, se omitirá.
** `before` (invocable)**
Es una devolución de llamada que se debe invocar antes de cada transferencia. La devolución de llamada debería tener una firma de la función del tipo `function (Aws\Command $command) {...}`. El comando proporcionado será un comando `GetObject`, `PutObject`, `CreateMultipartUpload`, `UploadPart` o `CompleteMultipartUpload`.
** `mup_threshold` (int)**
Es el tamaño en bytes por el que debe utilizarse una carga multiparte en lugar de `PutObject`. El valor predeterminado es `16777216` (16 MB).
** `concurrency` (int, valor predeterminado=5)**
Es el número de archivos que se debe cargar de forma simultánea. El valor de concurrencia ideal variará en función de la cantidad de archivos que se esté cargando y del tamaño medio de cada archivo. Por lo general, los archivos más pequeños se benefician de una mayor concurrencia, mientras que los archivos más grandes no.
** `debug` (bool)**
Establezca este parámetro en `true` para imprimir información de depuración para las transferencias. Establezca un recurso `fopen()` para escribir en un flujo específico en lugar de escribir en STDOUT.
## Transferencias asíncronas
El objeto `Transfer` es una instancia de `GuzzleHttp\Promise\PromisorInterface`. Esto significa que la transferencia puede producirse de forma asíncrona y que se inicia llamando al método `promise` del objeto.
```
$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 promesa se rechaza si algún archivo no se transfiere. Puede administrar la transferencia fallida de forma asíncrona utilizando el método `otherwise` de la promesa. La función `otherwise` acepta una devolución de llamada cuando se produce un error. La devolución de llamada acepta el `$reason` rechazo, que normalmente es una instancia de `Aws\Exception\AwsException` (aunque se puede enviar un valor de **cualquier** tipo a la devolución de llamada).
```
$promise->otherwise(function ($reason) {
echo 'Transfer failed: ';
var_dump($reason);
});
```
Dado que el objeto `Transfer` devuelve una promesa, estas transferencias pueden producirse de forma simultánea con otras promesas asíncronas.
## Personalización de la transferencia de directorios
Al añadir una llamada de retorno al constructor, puede personalizar las opciones que ejecuta. `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';
}
},
]);
```