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.

# Ejemplos de Amazon S3 con la AWS SDK para PHP versión 3
<a name="s3-examples"></a>

Amazon Simple Storage Service (Amazon S3) es un servicio web que proporciona almacenamiento en la nube con una alto grado de escalabilidad. Amazon S3 ofrece almacenamiento de objetos fácil de usar con una sencilla interfaz de servicios web que puede utilizarse para almacenar y recuperar la cantidad de datos que desee, cuando desee y desde cualquier lugar de la web.

Todo el código de ejemplo para el AWS SDK para PHP está disponible [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

## Credenciales
<a name="examplecredentials"></a>

Antes de ejecutar el código de ejemplo, configure sus AWS credenciales, tal y como se describe en[Autenticación AWS con la AWS SDK para PHP versión 3](credentials.md). A continuación, importe las AWS SDK para PHP, tal y como se describe en[Instalación de la AWS SDK para PHP versión 3](getting-started_installation.md).

**Topics**
+ [Credenciales](#examplecredentials)
+ [Creación y uso de buckets de Amazon S3](s3-examples-creating-buckets.md)
+ [Administración de permisos de acceso a los buckets de Amazon S3](s3-examples-access-permissions.md)
+ [Configuración de los buckets de Amazon S3](s3-examples-configuring-a-bucket.md)
+ [Cargas multiparte de Amazon S3](s3-multipart-upload.md)
+ [URL prefirmada de Amazon S3](s3-presigned-url.md)
+ [Creación de POST prefirmados S3](s3-presigned-post.md)
+ [Uso de un bucket de Amazon S3 como host web estático](s3-examples-static-web-host.md)
+ [Uso de políticas de bucket de Amazon S3](s3-examples-bucket-policies.md)
+ [Uso de ARN de punto de acceso de S3](s3-examples-access-point-arn.md)
+ [Uso de puntos de acceso multirregionales](s3-multi-region-access-points.md)

# Creación y utilización de buckets de Amazon S3 con la versión 3 de AWS SDK para PHP
<a name="s3-examples-creating-buckets"></a>

Los siguientes ejemplos muestran cómo:
+ Obtener una lista de los buckets pertenecientes al remitente autenticado de la solicitud utilizando [ListBuckets](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#listbuckets).
+ Crear un nuevo bucket utilizando [CreateBucket](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#createbucket).
+ Añadir un objeto a un bucket utilizando [PutObject](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject).

Todo el código de ejemplo de AWS SDK para PHP está disponible [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

## Credenciales
<a name="examplecredentials"></a>

Antes de ejecutar el código de ejemplo, configure sus credenciales de AWS, como se indica en [Autenticación AWS con la AWS SDK para PHP versión 3](credentials.md). A continuación, importe AWS SDK para PHP, como se indica en [Instalación de la AWS SDK para PHP versión 3](getting-started_installation.md).

 **Importaciones** 

```
require 'vendor/autoload.php';

use Aws\S3\S3Client;
```

## Obtener una lista de buckets
<a name="list-buckets"></a>

Cree un archivo PHP con el siguiente código. En primer lugar, cree un servicio cliente AWS.S3 que especifique la región de AWS y la versión. A continuación, llame al método `listBuckets`, que devuelve todos los buckets de Amazon S3 que pertenecen al remitente de la solicitud como una matriz de estructuras Bucket.

 **Código de muestra** 

```
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

//Listing all S3 Bucket
$buckets = $s3Client->listBuckets();
foreach ($buckets['Buckets'] as $bucket) {
    echo $bucket['Name'] . "\n";
}
```

## Crear un bucket
<a name="create-a-bucket"></a>

Cree un archivo PHP con el siguiente código. En primer lugar, cree un servicio cliente AWS.S3 que especifique la región de AWS y la versión. Llame entonces al método `createBucket` con una matriz como parámetro. El único campo obligatorio es la clave 'Bucket', con un valor de cadena para el nombre del bucket que desea crear. Sin embargo, puede especificar también la región de AWS con el campo "CreateBucketConfiguration". Si se ejecuta correctamente, este método devuelve la ubicación del bucket.

 **Código de muestra** 

```
function createBucket($s3Client, $bucketName)
{
    try {
        $result = $s3Client->createBucket([
            'Bucket' => $bucketName,
        ]);
        return 'The bucket\'s location is: ' .
            $result['Location'] . '. ' .
            'The bucket\'s effective URI is: ' .
            $result['@metadata']['effectiveUri'];
    } catch (AwsException $e) {
        return 'Error: ' . $e->getAwsErrorMessage();
    }
}

function createTheBucket()
{
    $s3Client = new S3Client([
        'profile' => 'default',
        'region' => 'us-east-1',
        'version' => '2006-03-01'
    ]);

    echo createBucket($s3Client, 'amzn-s3-demo-bucket');
}

// Uncomment the following line to run this code in an AWS account.
// createTheBucket();
```

## Colocar un objeto en un bucket
<a name="put-an-object-in-a-bucket"></a>

Para añadir archivos a su nuevo bucket, cree un archivo PHP con el código siguiente.

Ejecute este archivo en la línea de comandos y especificando una cadena con el nombre del bucket en el que desea cargar su archivo, seguido de la ruta completa del archivo que desea cargar.

 **Código de muestra** 

```
$USAGE = "\n" .
    "To run this example, supply the name of an S3 bucket and a file to\n" .
    "upload to it.\n" .
    "\n" .
    "Ex: php PutObject.php <bucketname> <filename>\n";

if (count($argv) <= 2) {
    echo $USAGE;
    exit();
}

$bucket = $argv[1];
$file_Path = $argv[2];
$key = basename($argv[2]);

try {
    //Create a S3Client
    $s3Client = new S3Client([
        'profile' => 'default',
        'region' => 'us-west-2',
        'version' => '2006-03-01'
    ]);
    $result = $s3Client->putObject([
        'Bucket' => $bucket,
        'Key' => $key,
        'SourceFile' => $file_Path,
    ]);
} catch (S3Exception $e) {
    echo $e->getMessage() . "\n";
}
```

# Administración de permisos de acceso a los buckets de Amazon S3 con la versión 3 de AWS SDK para PHP
<a name="s3-examples-access-permissions"></a>

Las listas de control de acceso (ACL) son una de las opciones de política de acceso basada en recursos que puede utilizar para administrar el acceso a sus buckets y objetos. Puede utilizar las ACL para otorgar permisos básicos de lectura o escritura a otras cuentas de AWS. Para obtener más información, consulte [Administración de acceso con ACL](https://docs.aws.amazon.com/AmazonS3/latest/dev/S3_ACLs_UsingACLs.html).

El siguiente ejemplo muestra cómo:
+ Obtener la política de control de acceso para un bucket utilizando [GetBucketAcl](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getbucketacl).
+ Establecer los permisos en un bucket con ACL utilizando [PutBucketAcl](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putbucketacl).

Todo el código de ejemplo de AWS SDK para PHP está disponible [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

## Credenciales
<a name="examplecredentials"></a>

Antes de ejecutar el código de ejemplo, configure sus credenciales de AWS, como se indica en [Autenticación AWS con la AWS SDK para PHP versión 3](credentials.md). A continuación, importe AWS SDK para PHP, como se indica en [Instalación de la AWS SDK para PHP versión 3](getting-started_installation.md).

## Obtener y establecer una política de lista de control de acceso
<a name="get-and-set-an-access-control-list-policy"></a>

 **Importaciones** 

```
require 'vendor/autoload.php';

use Aws\S3\S3Client;  
use Aws\Exception\AwsException;
```

 **Código de muestra** 

```
// Create a S3Client 
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

// Gets the access control policy for a bucket
$bucket = 'amzn-s3-demo-bucket';
try {
    $resp = $s3Client->getBucketAcl([
        'Bucket' => $bucket
    ]);
    echo "Succeed in retrieving bucket ACL as follows: \n";
    var_dump($resp);
} catch (AwsException $e) {
    // output error message if fails
    echo $e->getMessage();
    echo "\n";
}

// Sets the permissions on a bucket using access control lists (ACL).
$params = [
    'ACL' => 'public-read',
    'AccessControlPolicy' => [
        // Information can be retrieved from `getBucketAcl` response
        'Grants' => [
            [
                'Grantee' => [
                    'DisplayName' => '<string>',
                    'EmailAddress' => '<string>',
                    'ID' => '<string>',
                    'Type' => 'CanonicalUser',
                    'URI' => '<string>',
                ],
                'Permission' => 'FULL_CONTROL',
            ],
            // ...
        ],
        'Owner' => [
            'DisplayName' => '<string>',
            'ID' => '<string>',
        ],
    ],
    'Bucket' => $bucket,
];

try {
    $resp = $s3Client->putBucketAcl($params);
    echo "Succeed in setting bucket ACL.\n";
} catch (AwsException $e) {
    // Display error message
    echo $e->getMessage();
    echo "\n";
}
```

# Configuración de los buckets de Amazon S3 con la versión 3 de AWS SDK para PHP
<a name="s3-examples-configuring-a-bucket"></a>

El uso compartido de recursos entre orígenes (CORS) define una manera para que las aplicaciones web de los clientes cargadas en un dominio interactúen con los recursos de un dominio diferente. Gracias a la compatibilidad con CORS en Amazon S3, puede desarrollar aplicaciones web del lado del cliente completas con Amazon S3 y permitir el acceso entre orígenes a sus recursos de Amazon S3 de forma selectiva.

Para obtener más información sobre el uso de la configuración CORS con un bucket de Amazon S3, consulte [Uso compartido de recursos entre orígenes (CORS)](https://docs.aws.amazon.com/AmazonS3/latest/dev/cors.html).

Los siguientes ejemplos muestran cómo:
+ Obtener la configuración CORS para un bucket utilizando [GetBucketCors](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getbucketcors).
+ Establecer la configuración CORS para un bucket utilizando [PutBucketCors](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putbucketcors).

Todo el código de ejemplo de AWS SDK para PHP está disponible [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

## Credenciales
<a name="examplecredentials"></a>

Antes de ejecutar el código de ejemplo, configure sus credenciales de AWS, como se indica en [Autenticación AWS con la AWS SDK para PHP versión 3](credentials.md). A continuación, importe AWS SDK para PHP, como se indica en [Instalación de la AWS SDK para PHP versión 3](getting-started_installation.md).

## Obtener la configuración CORS
<a name="get-the-cors-configuration"></a>

Cree un archivo PHP con el siguiente código. En primer lugar, cree un servicio de cliente AWS.S3, luego llame al método `getBucketCors` y especifique el bucket cuya configuración CORS desea.

El único parámetro necesario es el nombre del bucket seleccionado. Si el bucket tiene actualmente una configuración CORS, Amazon S3 devuelve dicha configuración como [objeto CORSRules](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#shape-corsrule).

 **Importaciones** 

```
require 'vendor/autoload.php';

use Aws\Exception\AwsException;
use Aws\S3\S3Client;
```

 **Código de muestra** 

```
$client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

try {
    $result = $client->getBucketCors([
        'Bucket' => $bucketName, // REQUIRED
    ]);
    var_dump($result);
} catch (AwsException $e) {
    // output error message if fails
    error_log($e->getMessage());
}
```

## Establecer la configuración CORS
<a name="set-the-cors-configuration"></a>

Cree un archivo PHP con el siguiente código. En primer lugar, cree un servicio de cliente de AWS.S3. A continuación, llame al método `putBucketCors` y especifique el bucket cuya configuración CORS desea establecer y la CORSConfiguration como [objeto JSON CORSRules](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#shape-corsrule).

 **Importaciones** 

```
require 'vendor/autoload.php';

use Aws\Exception\AwsException;
use Aws\S3\S3Client;
```

 **Código de muestra** 

```
$client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

try {
    $result = $client->putBucketCors([
        'Bucket' => $bucketName, // REQUIRED
        'CORSConfiguration' => [ // REQUIRED
            'CORSRules' => [ // REQUIRED
                [
                    'AllowedHeaders' => ['Authorization'],
                    'AllowedMethods' => ['POST', 'GET', 'PUT'], // REQUIRED
                    'AllowedOrigins' => ['*'], // REQUIRED
                    'ExposeHeaders' => [],
                    'MaxAgeSeconds' => 3000
                ],
            ],
        ]
    ]);
    var_dump($result);
} catch (AwsException $e) {
    // output error message if fails
    error_log($e->getMessage());
}
```

# Uso de cargas multiparte de Amazon S3 con AWS SDK para PHP la versión 3
<a name="s3-multipart-upload"></a>

Puede cargar objetos de hasta 5 GB en una única operación `PutObject`. Sin embargo, si utiliza los métodos de carga multiparte (por ejemplo, `CreateMultipartUpload`, `UploadPart`, `CompleteMultipartUpload`, `AbortMultipartUpload`), podrá cargar objetos de entre 5 MB y 5 TB.

El siguiente ejemplo muestra cómo:
+ Cargue un objeto en Amazon S3 mediante [ObjectUploader](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.ObjectUploader.html).
+ Cree una carga multiparte para un objeto de Amazon S3 mediante [MultipartUploader](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.MultipartUploader.html).
+ Copie objetos de una ubicación de Amazon S3 a otra utilizando [ObjectCopier](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.ObjectCopier.html).

Todo el código de ejemplo para el AWS SDK para PHP está disponible [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

## Credenciales
<a name="examplecredentials"></a>

Antes de ejecutar el código de ejemplo, configure sus AWS credenciales, tal y como se describe en[Autenticación AWS con la AWS SDK para PHP versión 3](credentials.md). A continuación, importe las AWS SDK para PHP, tal y como se describe en[Instalación de la AWS SDK para PHP versión 3](getting-started_installation.md).

## Cargador de objetos
<a name="object-uploader"></a>

Si no está seguro de si `PutObject` o `MultipartUploader` es mejor opción para la tarea, utilice `ObjectUploader`. `ObjectUploader` carga un archivo de gran tamaño en Amazon S3 utilizando `PutObject` o `MultipartUploader`, en función del tamaño de la carga útil.

```
require 'vendor/autoload.php';

use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\ObjectUploader;
use Aws\S3\S3Client;
```

 **Código de muestra** 

```
// Create an S3Client.
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-east-2',
    'version' => '2006-03-01'
]);

$bucket = 'your-bucket';
$key = 'my-file.zip';

// Use a stream instead of a file path.
$source = fopen('/path/to/large/file.zip', 'rb');

$uploader = new ObjectUploader(
    $s3Client,
    $bucket,
    $key,
    $source
);

do {
    try {
        $result = $uploader->upload();
        if ($result["@metadata"]["statusCode"] == '200') {
            print('<p>File successfully uploaded to ' . $result["ObjectURL"] . '.</p>');
        }
        print($result);
        // If the SDK chooses a multipart upload, try again if there is an exception.
        // Unlike PutObject calls, multipart upload calls are not automatically retried.
    } catch (MultipartUploadException $e) {
        rewind($source);
        $uploader = new MultipartUploader($s3Client, $source, [
            'state' => $e->getState(),
        ]);
    }
} while (!isset($result));

fclose($source);
```

### Configuración
<a name="object-uploader-configuration"></a>

El constructor del objeto `ObjectUploader` acepta los siguientes argumentos:

**`$client`**  
Es el objeto `Aws\ClientInterface` que hay que utilizar para ejecutar las transferencias. Debería ser una instancia de `Aws\S3\S3Client`.

**`$bucket`**  
(`string`, *obligatorio*) Es el nombre del bucket al que se está cargando el objeto.

**`$key`**  
(`string`, *obligatorio*) Es la clave que se utiliza para el objeto que se está cargando.

**`$body`**  
(`mixed`, *obligatorio*) Datos del objeto que se van a cargar. Puede ser un `StreamInterface`, un recurso de flujo de PH, o una cadena de datos a cargar.

**`$acl`**  
(`string`) Es la lista de control de acceso (ACL) para establecer el objeto que se carga. De forma predeterminada, los objetos son privados.

**`$options`**  
Es una matriz asociativa de opciones de configuración para la carga multiparte. Las siguientes opciones de configuración son válidas:    
**`add_content_md5`**  
(`bool`) Configúrelo en true para calcular automáticamente la MD5 suma de verificación de la carga.  
**`mup_threshold`**  
(`int`, *predeterminado*:`int(16777216)`) El número de bytes del tamaño del archivo. Si el tamaño del archivo supera este límite, se utiliza una carga multiparte.  
**`before_complete`**  
(`callable`) Es la devolución de llamada a invocar antes de la operación `CompleteMultipartUpload`. La devolución de llamada debe tener una firma de función similar a: `function (Aws\Command $command) {...}`. Consulta la [referencia de la CompleteMultipartUpload API](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#completemultipartupload) para ver los parámetros que puedes añadir al `CommandInterface` objeto.  
**`before_initiate`**  
(`callable`) Es la devolución de llamada a invocar antes de la operación `CreateMultipartUpload`. La devolución de llamada debe tener una firma de función similar a: `function (Aws\Command $command) {...}`. El SDK invoca esta devolución de llamada si el tamaño del archivo supera el valor de `mup_threshold`. Consulta la [referencia de la CreateMultipartUpload API](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#createmultipartupload) para ver los parámetros que puedes añadir al `CommandInterface` objeto.  
**`before_upload`**  
(`callable`) Es la devolución de llamada a invocar antes de cualquier operación `PutObject` o `UploadPart`. La devolución de llamada debe tener una firma de función similar a: `function (Aws\Command $command) {...}`. El SDK invoca esta devolución de llamada si el tamaño del archivo es igual o mayor que el valor de `mup_threshold`. Consulta la [referencia de la PutObject API](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject) para ver los parámetros que puedes aplicar a la `PutObject` solicitud. Para ver los parámetros que se aplican a una `UploadPart` solicitud, consulta la [referencia de la UploadPart API](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#uploadpart). El SDK ignora cualquier parámetro que no sea aplicable a la operación representada por el objeto `CommandInterface`.  
**`concurrency`**  
(`int`, *predeterminado*: `int(3)`) Es el número máximo de operaciones `UploadPart` simultáneas permitido durante la carga multiparte.  
**`part_size`**  
(`int`, *predeterminado*: `int(5242880)`) Es el tamaño de la parte, en bytes, que se debe utilizar al realizar una carga multiparte. El valor debe estar comprendido entre 5 MB y 5 GB, ambos incluidos.  
**`state`**  
(`Aws\Multipart\UploadState`) Es un objeto que representa el estado de la carga multiparte y que se utiliza para reanudar una carga previa. Si se proporciona esta opción, se ignoran los argumentos `$bucket` y `$key` arguments y la opción `part_size`.  
**`params`**  
Una matriz asociativa que proporciona opciones de configuración para cada subcomando. Por ejemplo:  

```
new ObjectUploader($bucket, $key, $body, $acl, ['params' => ['CacheControl' => <some_value>])
```

## MultipartUploader
<a name="multipartuploader"></a>

Las cargas multiparte están diseñadas para mejorar la experiencia de carga de los objetos más grandes. Estas permiten cargar objetos en partes independientes, en cualquier orden y en paralelo.

Se recomienda a los clientes de Amazon S3 que utilicen cargas multiparte para objetos de más de 100 MB.

## MultipartUploader objeto
<a name="multipartuploader-object"></a>

El SDK tiene un objeto `MultipartUploader` especial que simplifica el proceso de carga multiparte.

 **Importaciones** 

```
require 'vendor/autoload.php';

use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```

 **Código de muestra** 

```
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

// Use multipart upload
$source = '/path/to/large/file.zip';
$uploader = new MultipartUploader($s3Client, $source, [
    'bucket' => 'your-bucket',
    'key' => 'my-file.zip',
]);

try {
    $result = $uploader->upload();
    echo "Upload complete: {$result['ObjectURL']}\n";
} catch (MultipartUploadException $e) {
    echo $e->getMessage() . "\n";
}
```

El cargador crea un generador de datos de la parte, en función del origen que se haya proporcionado y de la configuración, e intenta cargar todas las partes. Si falla la carga de algunas partes, el cargador continúa cargando otras partes hasta que se haya leído todo el origen de datos. A continuación, el cargador vuelve a intentar cargar las partes que han dado error o genera una excepción que contiene información acerca de las partes que no se han podido cargar.

## Personalización de una carga multiparte
<a name="customizing-a-multipart-upload"></a>

Puede configurar las opciones personalizadas en las operaciones `CreateMultipartUpload`, `UploadPart` y `CompleteMultipartUpload` ejecutadas por el cargador multiparte mediante devoluciones de llamada transferidas a su constructor.

 **Importaciones** 

```
require 'vendor/autoload.php';

use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```

 **Código de muestra** 

```
// Create an S3Client
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

// Customizing a multipart upload
$source = '/path/to/large/file.zip';
$uploader = new MultipartUploader($s3Client, $source, [
    'bucket' => 'your-bucket',
    'key' => 'my-file.zip',
    'before_initiate' => function (Command $command) {
        // $command is a CreateMultipartUpload operation
        $command['CacheControl'] = 'max-age=3600';
    },
    'before_upload' => function (Command $command) {
        // $command is an UploadPart operation
        $command['RequestPayer'] = 'requester';
    },
    'before_complete' => function (Command $command) {
        // $command is a CompleteMultipartUpload operation
        $command['RequestPayer'] = 'requester';
    },
]);
```

### Recopilación manual de elementos no utilizados entre cargas de partes
<a name="manual-garbage-collection-between-part-uploads"></a>

Si se alcanza el límite de memoria al realizar cargas de gran tamaño, puede deberse a las referencias cíclicas generadas por el SDK que el [recolector de elementos no utilizados de PHP](https://www.php.net/manual/en/features.gc.php) todavía no había recopilado cuando se alcanzó el límite de memoria. Si se invoca manualmente el algoritmo de recopilación entre las operaciones, es posible que los ciclos se recopilen antes de alcanzar dicho límite. En el siguiente ejemplo, se invoca el algoritmo de recopilación mediante una devolución de llamada antes de la carga de cada parte. Tenga en cuenta que invocar el recolector de elementos no utilizados conlleva un costo de rendimiento y su uso óptimo dependerá de su caso de uso y su entorno.

```
$uploader = new MultipartUploader($client, $source, [
   'bucket' => 'your-bucket',
   'key' => 'your-key',
   'before_upload' => function(\Aws\Command $command) {
      gc_collect_cycles();
   }
]);
```

## Recuperación tras sufrir errores
<a name="recovering-from-errors"></a>

Cuando se produce un error durante el proceso de carga multiparte, se lanza una excepción `MultipartUploadException`. Esta excepción proporciona acceso al objeto `UploadState`, que contiene información sobre el progreso de la carga multiparte. El objeto `UploadState` puede utilizarse para reanudar una carga que no se ha completado.

 **Importaciones** 

```
require 'vendor/autoload.php';

use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```

 **Código de muestra** 

```
// Create an S3Client
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

$source = '/path/to/large/file.zip';
$uploader = new MultipartUploader($s3Client, $source, [
    'bucket' => 'your-bucket',
    'key' => 'my-file.zip',
]);

//Recover from errors
do {
    try {
        $result = $uploader->upload();
    } catch (MultipartUploadException $e) {
        $uploader = new MultipartUploader($s3Client, $source, [
            'state' => $e->getState(),
        ]);
    }
} while (!isset($result));

//Abort a multipart upload if failed
try {
    $result = $uploader->upload();
} catch (MultipartUploadException $e) {
    // State contains the "Bucket", "Key", and "UploadId"
    $params = $e->getState()->getId();
    $result = $s3Client->abortMultipartUpload($params);
}
```

Si se reanuda una carga a partir de un objeto `UploadState`, se intenta cargar las partes que todavía no se han cargado. El objeto de estado realiza un seguimiento de las partes que faltan, aunque no sean consecutivas. El cargador lee o busca en el archivo de origen facilitado los rangos de bytes que pertenecen a las partes que todavía deben cargarse.

 Los objetos `UploadState` se pueden serializar, por lo que también puede reanudar una carga en un proceso diferente. También puede obtener el objeto `UploadState`, incluso si no gestiona una excepción, llamando a `$uploader->getState()`.

**importante**  
Los flujos que se transfieren como un origen a un `MultipartUploader` no se rebobinan automáticamente antes de cargarlos. Si utiliza un flujo en lugar de una ruta de archivo en un bucle similar al del ejemplo anterior, restablezca la variable `$source` dentro del bloque `catch`.

 **Importaciones** 

```
require 'vendor/autoload.php';

use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```

 **Código de muestra** 

```
// Create an S3Client
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

//Using stream instead of file path
$source = fopen('/path/to/large/file.zip', 'rb');
$uploader = new MultipartUploader($s3Client, $source, [
    'bucket' => 'your-bucket',
    'key' => 'my-file.zip',
]);

do {
    try {
        $result = $uploader->upload();
    } catch (MultipartUploadException $e) {
        rewind($source);
        $uploader = new MultipartUploader($s3Client, $source, [
            'state' => $e->getState(),
        ]);
    }
} while (!isset($result));
fclose($source);
```

### Anulación de la carga multiparte
<a name="aborting-a-multipart-upload"></a>

Una carga multiparte se puede anular al recuperar el `UploadId` que se encuentra en el objeto `UploadState` y transferirlo a `abortMultipartUpload`.

```
try {
    $result = $uploader->upload();
} catch (MultipartUploadException $e) {
    // State contains the "Bucket", "Key", and "UploadId"
    $params = $e->getState()->getId();
    $result = $s3Client->abortMultipartUpload($params);
}
```

## Cargas multiparte asíncronas
<a name="asynchronous-multipart-uploads"></a>

Llamar a `upload()` en el `MultipartUploader` es una solicitud de bloqueo. Si está trabajando en un contexto asíncrono, puede obtener una [promesa](guide_promises.md) para la carga multiparte.

```
require 'vendor/autoload.php';

use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
```

 **Código de muestra** 

```
// Create an S3Client
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

$source = '/path/to/large/file.zip';
$uploader = new MultipartUploader($s3Client, $source, [
    'bucket' => 'your-bucket',
    'key' => 'my-file.zip',
]);

$promise = $uploader->promise();
```

### Configuración
<a name="asynchronous-multipart-uploads-configuration"></a>

El constructor del objeto `MultipartUploader` acepta los siguientes argumentos:

** `$client` **  
Es el objeto `Aws\ClientInterface` que hay que utilizar para ejecutar las transferencias. Debería ser una instancia de `Aws\S3\S3Client`.

** `$source` **  
Son los datos de origen que se están cargando. Esto puede ser una ruta o una URL (por ejemplo, `/path/to/file.jpg`), un controlador de recursos (por ejemplo, `fopen('/path/to/file.jpg', 'r)`) o una instancia de un [flujo PSR-7](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Psr.Http.Message.StreamInterface.html).

** `$config` **  
Es una matriz asociativa de opciones de configuración para la carga multiparte.  
Las siguientes opciones de configuración son válidas:    
** `acl` **  
(`string`) Es la lista de control de acceso (ACL) para establecer el objeto que se carga. De forma predeterminada, los objetos son privados.  
** `before_complete` **  
(`callable`) Es la devolución de llamada a invocar antes de la operación `CompleteMultipartUpload`. La devolución de llamada debería tener una firma de la función del tipo `function (Aws\Command $command) {...}`.  
** `before_initiate` **  
(`callable`) Es la devolución de llamada a invocar antes de la operación `CreateMultipartUpload`. La devolución de llamada debería tener una firma de la función del tipo `function (Aws\Command $command) {...}`.  
** `before_upload` **  
(`callable`) Es la devolución de llamada a invocar antes de cualquier operación `UploadPart`. La devolución de llamada debería tener una firma de la función del tipo `function (Aws\Command $command) {...}`.  
** `bucket` **  
(`string`, *obligatorio*) Es el nombre del bucket al que se está cargando el objeto.  
** `concurrency` **  
(`int`, *predeterminado*: `int(5)`) Es el número máximo de operaciones `UploadPart` simultáneas permitido durante la carga multiparte.  
** `key` **  
(`string`, *obligatorio*) Es la clave que se utiliza para el objeto que se está cargando.  
** `part_size` **  
(`int`, *predeterminado*: `int(5242880)`) Es el tamaño de la parte, en bytes, que se debe utilizar al realizar una carga multiparte. Debe ser de entre 5 MB y 5 GB, ambos incluidos.  
** `state` **  
(`Aws\Multipart\UploadState`) Es un objeto que representa el estado de la carga multiparte y que se utiliza para reanudar una carga previa. Si se proporciona esta opción, se omiten las opciones `bucket`, `key` y `part_size`.  
**`add_content_md5`**  
(`boolean`) Configúrelo en true para calcular automáticamente la MD5 suma de verificación de la carga.  
**`params`**  
Una matriz asociativa que proporciona opciones de configuración para cada subcomando. Por ejemplo:  

```
new MultipartUploader($client, $source, ['params' => ['CacheControl' => <some_value>]])
```

## Copias multiparte
<a name="multipart-copies"></a>

 AWS SDK para PHP También incluye un `MultipartCopy` objeto que se utiliza de forma similar al`MultipartUploader`, pero que está diseñado para copiar objetos de entre 5 GB y 5 TB de tamaño en Amazon S3.

```
require 'vendor/autoload.php';

use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartCopy;
use Aws\S3\S3Client;
```

 **Código de muestra** 

```
// Create an S3Client
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

//Copy objects within S3
$copier = new MultipartCopy($s3Client, '/bucket/key?versionId=foo', [
    'bucket' => 'your-bucket',
    'key' => 'my-file.zip',
]);

try {
    $result = $copier->copy();
    echo "Copy complete: {$result['ObjectURL']}\n";
} catch (MultipartUploadException $e) {
    echo $e->getMessage() . "\n";
}
```

# URL prefirmada de Amazon S3 con la AWS SDK para PHP versión 3
<a name="s3-presigned-url"></a>

Puede autenticar determinados tipos de solicitudes pasando la información requerida como parámetros de una cadena de consulta, en lugar de usar el encabezado de autorización HTTP. Esto resulta útil para permitir el acceso directo de navegadores de terceros a sus datos de Amazon S3 privados, sin enviar la solicitud por proxy. La idea es construir una solicitud “prefirmada” y codificarla como una URL que pueda utilizar otro usuario. Además, puede limitar una solicitud prefirmada especificando una fecha de vencimiento.

## Creación de una URL prefirmada para una solicitud GET de HTTP
<a name="s3-presigned-url-get"></a>

En el siguiente ejemplo de código se muestra cómo crear una URL prefirmada para una solicitud GET de HTTP mediante el SDK para PHP.

```
<?php

require 'vendor/autoload.php';

use Aws\S3\S3Client;

$s3Client = new S3Client([
    'region' => 'us-west-2',
]);

// Supply a CommandInterface object and an expires parameter to the `createPresignedRequest` method.
$request = $s3Client->createPresignedRequest(
    $s3Client->getCommand('GetObject', [
        'Bucket' => 'amzn-s3-demo-bucket',
        'Key' => 'demo-key',
    ]),
    '+1 hour'
);

// From the resulting RequestInterface object, you can get the URL.
$presignedUrl = (string) $request->getUri();

echo $presignedUrl;
```

En la [referencia de la API para el método `createPresignedRequest`](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.S3Client.html#method_createPresignedRequest) se proporcionan más detalles.

Otra persona puede utilizar el valor `$presignedUrl` para recuperar el objeto en la próxima hora. Cuando se realiza la solicitud GET de HTTP (por ejemplo, mediante un navegador), el servicio S3 considera que la llamada proviene del usuario que ha creado la URL prefirmada.

## Creación de una URL prefirmada para una solicitud PUT de HTTP
<a name="s3-presigned-url-put"></a>

En el siguiente ejemplo de código se muestra cómo crear una URL prefirmada para una solicitud PUT de HTTP mediante el SDK para PHP.

```
<?php

require 'vendor/autoload.php';

use Aws\S3\S3Client;

$s3Client = new S3Client([
    'region' => 'us-west-2',
]);

$request = $s3Client->createPresignedRequest(
    $s3Client->getCommand('PutObject', [
        'Bucket' => 'amzn-s3-demo-bucket',
        'Key' => 'demo-key',
    ]),
    '+1 hour'
);

// From the resulting RequestInterface object, you can get the URL.
$presignedUrl = (string) $request->getUri();
```

Otro usuario ahora puede utilizar la URL prefirmada en una solicitud PUT de HTTP para cargar un archivo:

```
use GuzzleHttp\Psr7\Request;
use GuzzleHttp\Psr7\Response;

// ...

function uploadWithPresignedUrl($presignedUrl, $filePath, $s3Client): ?Response
{
    // Get the HTTP handler from the S3 client.
    $handler = $s3Client->getHandlerList()->resolve();
    
    // Create a stream from the file.
    $fileStream = new Stream(fopen($filePath, 'r'));
    
    // Create the request.
    $request = new Request(
        'PUT',
        $presignedUrl,
        [
            'Content-Type' => mime_content_type($filePath),
            'Content-Length' => filesize($filePath)
        ],
        $fileStream
    );
    
    // Send the request using the handler.
    try {
        $promise = $handler($request, []);
        $response = $promise->wait();
        return $response;
    } catch (Exception $e) {
        echo "Error uploading file: " . $e->getMessage() . "\n";
        return null;
    }
}
```

# POST prefirmados de Amazon S3 con la versión 3 de AWS SDK para PHP
<a name="s3-presigned-post"></a>

Al igual que las URL prefirmadas, los POST prefirmados permiten dar acceso de escritura a un usuario sin proporcionarle credenciales de AWS. Los formularios POST prefirmados se pueden crear con la ayuda de una instancia de [AwsS3PostObjectV4](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.PostObjectV4.html).

Los siguientes ejemplos muestran cómo:
+ Obtener datos para un formulario de carga POST de objetos de S3 con [PostObjectV4](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.PostObjectV4.html).

Todo el código de ejemplo de AWS SDK para PHP está disponible [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

## Credenciales
<a name="examplecredentials"></a>

**nota**  
`PostObjectV4` no funciona con credenciales procedentes de AWS IAM Identity Center.

Antes de ejecutar el código de ejemplo, configure sus credenciales de AWS, como se indica en [Autenticación AWS con la AWS SDK para PHP versión 3](credentials.md). A continuación, importe AWS SDK para PHP, como se indica en [Instalación de la AWS SDK para PHP versión 3](getting-started_installation.md).

## Creación de PostObjectV4
<a name="create-postobjectv4"></a>

Para crear una instancia de `PostObjectV4`, debe proporcionar lo siguiente:
+ Instancia de `Aws\S3\S3Client` 
+ bucket
+ matriz asociativa de campos de entrada de formularios
+ conjunto de condiciones de política (consulte [Construcción de políticas](https://docs.aws.amazon.com/AmazonS3/latest/dev/HTTPPOSTForms.html) en la Guía del usuario de Amazon Simple Storage Service)
+ cadena de fecha de vencimiento para la política (opcional, una hora de forma predeterminada).

 **Importaciones** 

```
require '../vendor/autoload.php';

use Aws\S3\PostObjectV4;
use Aws\S3\S3Client;
```

 **Código de muestra** 

```
require '../vendor/autoload.php';

use Aws\S3\PostObjectV4;
use Aws\S3\S3Client;

$client = new S3Client([
    'profile' => 'default',
    'region' => 'us-east-1',
]);
$bucket = 'amzn-s3-demo-bucket10';
$starts_with = 'user/eric/';
$client->listBuckets();

// Set defaults for form input fields.
$formInputs = ['acl' => 'public-read'];

// Construct an array of conditions for policy.
$options = [
    ['acl' => 'public-read'],
    ['bucket' => $bucket],
    ['starts-with', '$key', $starts_with],
];

// Set an expiration time (optional).
$expires = '+2 hours';

$postObject = new PostObjectV4(
    $client,
    $bucket,
    $formInputs,
    $options,
    $expires
);

// Get attributes for the HTML form, for example, action, method, enctype.
$formAttributes = $postObject->getFormAttributes();

// Get attributes for the HTML form values.
$formInputs = $postObject->getFormInputs();
?>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
    <title>PHP</title>
</head>
<body>
<form action="<?php echo $formAttributes['action'] ?>" method="<?php echo $formAttributes['method'] ?>"
      enctype="<?php echo $formAttributes['enctype'] ?>">
    <label id="key">
        <input hidden type="text" name="key" value="<?php echo $starts_with ?><?php echo $formInputs['key'] ?>"/>
    </label>
    <h3>$formInputs:</h3>
    acl: <label id="acl">
        <input readonly type="text" name="acl" value="<?php echo $formInputs['acl'] ?>"/>
    </label><br/>
    X-Amz-Credential: <label id="credential">
        <input readonly type="text" name="X-Amz-Credential" value="<?php echo $formInputs['X-Amz-Credential'] ?>"/>
    </label><br/>
    X-Amz-Algorithm: <label id="algorithm">
        <input readonly type="text" name="X-Amz-Algorithm" value="<?php echo $formInputs['X-Amz-Algorithm'] ?>"/>
    </label><br/>
    X-Amz-Date: <label id="date">
        <input readonly type="text" name="X-Amz-Date" value="<?php echo $formInputs['X-Amz-Date'] ?>"/>
    </label><br/><br/><br/>
    Policy: <label id="policy">
        <input readonly type="text" name="Policy" value="<?php echo $formInputs['Policy'] ?>"/>
    </label><br/>
    X-Amz-Signature: <label id="signature">
        <input readonly type="text" name="X-Amz-Signature" value="<?php echo $formInputs['X-Amz-Signature'] ?>"/>
    </label><br/><br/>
    <h3>Choose file:</h3>
    <input type="file" name="file"/> <br/><br/>
    <h3>Upload file:</h3>
    <input type="submit" name="submit" value="Upload to Amazon S3"/>
</form>
</body>
</html>
```

# Uso de un bucket de Amazon S3 como host web estático con la versión 3 de AWS SDK para PHP
<a name="s3-examples-static-web-host"></a>

Puede alojar un sitio web estático en Amazon S3. Para obtener más información, consulte [Alojamiento de un sitio web estático en Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/WebsiteHosting.html).

El siguiente ejemplo muestra cómo:
+ Obtener la configuración de sitio web para un bucket con [GetBucketWebsite](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getbucketwebsite).
+ Establecer la configuración de sitio web para un bucket con [PutBucketWebsite](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putbucketwebsite).
+ Eliminar la configuración de sitio web para un bucket con [DeleteBucketWebsite](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#deletebucketwebsite).

Todo el código de ejemplo de la versión 3 de AWS SDK para PHP está disponible [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

## Credenciales
<a name="credentials-s3-examples-static-web-host"></a>

Antes de ejecutar el código de ejemplo, configure sus credenciales de AWS. Consulte [Credenciales para la versión 3 de AWS SDK para PHP](guide_credentials.md).

## Obtener, establecer y eliminar la configuración de sitio web para un bucket
<a name="get-set-and-delete-the-website-configuration-for-a-bucket"></a>

 **Importaciones** 

```
require 'vendor/autoload.php';

use Aws\Exception\AwsException;
use Aws\S3\S3Client;
```

 **Código de muestra** 

```
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

// Retrieving the Bucket Website Configuration
$bucket = 'amzn-s3-demo-bucket';
try {
    $resp = $s3Client->getBucketWebsite([
        'Bucket' => $bucket
    ]);
    echo "Succeed in retrieving website configuration for bucket: " . $bucket . "\n";
} catch (AwsException $e) {
    // output error message if fails
    echo $e->getMessage();
    echo "\n";
}

// Setting a Bucket Website Configuration
$params = [
    'Bucket' => $bucket,
    'WebsiteConfiguration' => [
        'ErrorDocument' => [
            'Key' => 'foo',
        ],
        'IndexDocument' => [
            'Suffix' => 'bar',
        ],
    ]
];

try {
    $resp = $s3Client->putBucketWebsite($params);
    echo "Succeed in setting bucket website configuration.\n";
} catch (AwsException $e) {
    // Display error message
    echo $e->getMessage();
    echo "\n";
}

// Deleting a Bucket Website Configuration
try {
    $resp = $s3Client->deleteBucketWebsite([
        'Bucket' => $bucket
    ]);
    echo "Succeed in deleting policy for bucket: " . $bucket . "\n";
} catch (AwsException $e) {
    // output error message if fails
    echo $e->getMessage();
    echo "\n";
}
```

# Uso de las políticas de los buckets de Amazon S3 con la versión 3 de AWS SDK para PHP
<a name="s3-examples-bucket-policies"></a>

Puede utilizar una política de bucket para conceder permisos a sus recursos de Amazon S3. Para obtener más información, consulte [Uso de políticas de bucket y usuario](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-iam-policies.html).

El siguiente ejemplo muestra cómo:
+ Devolver la política a un bucket determinado utilizando [GetBucketPolicy](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getbucketpolicy).
+ Sustituir una política en un bucket utilizando [PutBucketPolicy](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putbucketpolicy).
+ Eliminar una política de un bucket utilizando [DeleteBucketPolicy](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#deletebucketpolicy).

Todo el código de ejemplo de AWS SDK para PHP está disponible [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

## Credenciales
<a name="examplecredentials"></a>

Antes de ejecutar el código de ejemplo, configure sus credenciales de AWS, como se indica en [Autenticación AWS con la AWS SDK para PHP versión 3](credentials.md). A continuación, importe AWS SDK para PHP, como se indica en [Instalación de la AWS SDK para PHP versión 3](getting-started_installation.md).

## Obtener, eliminar y sustituir una política en un bucket
<a name="get-delete-and-replace-a-policy-on-a-bucket"></a>

 **Importaciones** 

```
require "vendor/autoload.php";

use Aws\Exception\AwsException;
use Aws\S3\S3Client;
```

 **Código de muestra** 

```
$s3Client = new S3Client([
    'profile' => 'default',
    'region' => 'us-west-2',
    'version' => '2006-03-01'
]);

$bucket = 'amzn-s3-demo-bucket';

// Get the policy of a specific bucket
try {
    $resp = $s3Client->getBucketPolicy([
        'Bucket' => $bucket
    ]);
    echo "Succeed in receiving bucket policy:\n";
    echo $resp->get('Policy');
    echo "\n";
} catch (AwsException $e) {
    // Display error message
    echo $e->getMessage();
    echo "\n";
}

// Deletes the policy from the bucket
try {
    $resp = $s3Client->deleteBucketPolicy([
        'Bucket' => $bucket
    ]);
    echo "Succeed in deleting policy of bucket: " . $bucket . "\n";
} catch (AwsException $e) {
    // Display error message
    echo $e->getMessage();
    echo "\n";
}

// Replaces a policy on the bucket
try {
    $resp = $s3Client->putBucketPolicy([
        'Bucket' => $bucket,
        'Policy' => 'foo policy',
    ]);
    echo "Succeed in put a policy on bucket: " . $bucket . "\n";
} catch (AwsException $e) {
    // Display error message
    echo $e->getMessage();
    echo "\n";
}
```

# Uso de los ARN de punto de acceso S3 en la versión 3 de AWS SDK para PHP
<a name="s3-examples-access-point-arn"></a>

S3 introdujo los puntos de acceso, una nueva forma de interactuar con los buckets de S3. Los puntos de acceso pueden tener políticas y configuraciones únicas aplicadas a ellos en lugar de directamente al bucket. AWS SDK para PHP le permite utilizar ARN de punto de acceso en el campo del bucket para operaciones de la API en lugar de especificar explícitamente el nombre del bucket. Puede encontrar más información sobre cómo funcionan los ARN y los puntos de acceso S3 [aquí](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-access-points.html). Los siguientes ejemplos muestran cómo:
+ Utilice [GetObject](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getobject) con un ARN de punto de acceso para obtener un objeto de un bucket.
+ Utilice [PutObject](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject) con un ARN de punto de acceso para agregar un objeto a un bucket.
+ Configure el cliente de S3 para que utilice la región ARN en lugar de la región de cliente.

Todo el código de ejemplo de AWS SDK para PHP está disponible [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

## Credenciales
<a name="examplecredentials"></a>

Antes de ejecutar el código de ejemplo, configure sus credenciales de AWS, como se indica en [Autenticación AWS con la AWS SDK para PHP versión 3](credentials.md). A continuación, importe AWS SDK para PHP, como se indica en [Instalación de la AWS SDK para PHP versión 3](getting-started_installation.md).

 **Importaciones** 

```
require 'vendor/autoload.php';

use Aws\S3\S3Client;
```

## Get Object
<a name="get-object"></a>

En primer lugar, cree un servicio cliente AWS.S3 que especifique la región de AWS y la versión. Luego llame al método `getObject` con su clave y un ARN de punto de acceso de S3 en el campo `Bucket`, que obtendrá el objeto del bucket asociado con ese punto de acceso.

 **Código de muestra** 

```
$s3 = new S3Client([
    'version'     => 'latest',
    'region'      => 'us-west-2',
]);
$result = $s3->getObject([
    'Bucket' => 'arn:aws:s3:us-west-2:123456789012:accesspoint:endpoint-name',
    'Key' => 'MyKey'
]);
```

## Colocar un objeto en un bucket
<a name="put-an-object-in-a-bucket"></a>

En primer lugar, cree un servicio cliente AWS.S3 que especifique la región de AWS y la versión. A continuación, llame al método `putObject` con la clave, el cuerpo o el archivo de origen deseados y un ARN de punto de acceso de S3 en el campo `Bucket`, que colocará el objeto en el bucket asociado con ese punto de acceso.

 **Código de muestra** 

```
$s3 = new S3Client([
    'version'     => 'latest',
    'region'      => 'us-west-2',
]);
$result = $s3->putObject([
    'Bucket' => 'arn:aws:s3:us-west-2:123456789012:accesspoint:endpoint-name',
    'Key' => 'MyKey',
    'Body' => 'MyBody'
]);
```

## Configure el cliente de S3 para que utilice la región ARN en lugar de la región de cliente
<a name="configure-the-s3-client-to-use-the-arn-region-instead-of-the-client-region"></a>

Cuando se utiliza un ARN de punto de acceso de S3 en una operación de cliente de S3, de forma predeterminada el cliente se asegurará de que la región ARN coincida con la región de cliente, produciendo una excepción si no lo hace. Este comportamiento se puede cambiar para aceptar la región ARN por delante de la región de cliente estableciendo la opción de configuración `use_arn_region` en `true`. De forma predeterminada, la opción se establece en `false`.

 **Código de muestra** 

```
$s3 = new S3Client([
    'version'        => 'latest',
    'region'         => 'us-west-2',
    'use_arn_region' => true
]);
```

El cliente también comprobará una variable de entorno y una opción de archivo de configuración, en el siguiente orden de prioridad:

1. La opción de cliente `use_arn_region`, como en el ejemplo anterior.

1. La variable de entorno de la `AWS_S3_USE_ARN_REGION` 

```
export AWS_S3_USE_ARN_REGION=true
```

1. La variable de configuración `s3_use_arn_region` en el archivo de configuración compartida de AWS (de forma predeterminada en `~/.aws/config`).

```
[default]
s3_use_arn_region = true
```

# Utilice los puntos de acceso multirregionales de Amazon S3 con la AWS SDK para PHP versión 3
<a name="s3-multi-region-access-points"></a>

Los [puntos de acceso multirregionales de Amazon Simple Storage Service (S3)](https://docs.aws.amazon.com//AmazonS3/latest/userguide/MultiRegionAccessPoints.html) proporcionan un punto de conexión global para enrutar el tráfico de solicitudes de Amazon S3 entre Regiones de AWS.

Puede crear puntos de acceso multirregionales [mediante el SDK for PHP](https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-s3control-2018-08-20.html#createmultiregionaccesspoint), otro AWS SDK, la [consola S3 o la AWS CLI,](https://docs.aws.amazon.com//AmazonS3/latest/userguide/multi-region-access-point-create-examples.html)

**importante**  
Para usar puntos de acceso multirregionales con el SDK para PHP, su entorno PHP debe tener instalada la [extensión AWS Common Runtime (AWS CRT)](guide_crt.md).

Cuando crea un punto de acceso multirregional, Amazon S3 genera un nombre de recurso de Amazon (ARN) con el siguiente formato: 

`arn:aws:s3::account-id:accesspoint/MultiRegionAccessPoint_alias`

Puede utilizar el ARN generado en lugar del nombre del bucket para los métodos `[getObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getobject)` y `[putObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject)`.

```
<?php
require './vendor/autoload.php';

use Aws\S3\S3Client;

// Assign the Multi-Region Access Point to a variable and use it place of a bucket name.
$mrap = 'arn:aws:s3::123456789012:accesspoint/mfzwi23gnjvgw.mrap';
$key = 'my-key';

$s3Client = new S3Client([
    'region' => 'us-east-1'
]);

$s3Client->putObject([
    'Bucket' => $mrap,
    'Key' => $key,
    'Body' => 'Hello World!'
]);

$result = $s3Client->getObject([
    'Bucket' => $mrap,
    'Key' => $key
]);

echo $result['Body'] . "\n";

// Clean up.
$result = $s3Client->deleteObject([
    'Bucket' => $mrap,
    'Key' => $key
]);

$s3Client->waitUntil('ObjectNotExists', ['Bucket' => $mrap, 'Key' => $key]);

echo "Object deleted\n";
```