As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Exemplos do Amazon S3 usando a AWS SDK para PHP versão 3
<a name="s3-examples"></a>

O Amazon Simple Storage Service (Amazon S3) é um serviço da Web que oferece um armazenamento na nuvem altamente escalável. O Amazon S3 fornece armazenamento de objetos fácil de usar com uma interface de web service para armazenar e recuperar qualquer quantidade de dados de qualquer lugar da web.

Todo o código de exemplo para o AWS SDK para PHP está disponível [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

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

Antes de executar o código de exemplo, configure suas AWS credenciais, conforme descrito em[Autenticando com o AWS uso da AWS SDK para PHP versão 3](credentials.md). Em seguida, importe o AWS SDK para PHP, conforme descrito em[Instalando a AWS SDK para PHP versão 3](getting-started_installation.md).

**Topics**
+ [Credenciais](#examplecredentials)
+ [Criação e uso de buckets do Amazon S3](s3-examples-creating-buckets.md)
+ [Gerenciar permissões de acesso ao bucket do Amazon S3](s3-examples-access-permissions.md)
+ [Configurar buckets do Amazon S3](s3-examples-configuring-a-bucket.md)
+ [Carregamentos fracionados do Amazon S3](s3-multipart-upload.md)
+ [URL pré-assinado do Amazon S3](s3-presigned-url.md)
+ [Criar POSTs pré-assinados do S3](s3-presigned-post.md)
+ [Usar um bucket do Amazon S3 como um host estático da Web](s3-examples-static-web-host.md)
+ [Trabalhar com políticas de bucket do Amazon S3](s3-examples-bucket-policies.md)
+ [Usar ARNs de ponto de acesso do S3](s3-examples-access-point-arn.md)
+ [Usar pontos de acesso multirregionais](s3-multi-region-access-points.md)

# Criação e uso de buckets do Amazon S3 com o AWS SDK para PHP versão 3
<a name="s3-examples-creating-buckets"></a>

Os exemplos a seguir mostram como:
+ Retornar uma lista de buckets pertencentes ao remetente autenticado da solicitação usando [ListBuckets](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#listbuckets).
+ Criar um novo bucket usando [CreateBucket](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#createbucket).
+ Adicionar um objeto a um bucket usando [PutObject](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject).

O código de exemplo completo do AWS SDK para PHP está disponível [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

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

Antes de executar o código de exemplo, configure suas credenciais da AWS, conforme descrito em [Autenticando com o AWS uso da AWS SDK para PHP versão 3](credentials.md). Em seguida, importe o AWS SDK para PHP, conforme descrito em [Instalando a AWS SDK para PHP versão 3](getting-started_installation.md).

 **Importações** 

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

use Aws\S3\S3Client;
```

## Listar buckets
<a name="list-buckets"></a>

Crie um arquivo PHP com o seguinte código. Primeiro crie um serviço cliente do AWS.S3 que especifique a região e a versão da AWS. Depois, chame o método `listBuckets`, que retorna todos os buckets do Amazon S3 pertencentes ao remetente da solicitação como uma matriz de estruturas de bucket.

 **Código de exemplo** 

```
$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";
}
```

## Criar um bucket
<a name="create-a-bucket"></a>

Crie um arquivo PHP com o seguinte código. Primeiro crie um serviço cliente do AWS.S3 que especifique a região e a versão da AWS. Em seguida, chame o método `createBucket` com uma matriz como o parâmetro. O único campo obrigatório é a chave "Bucket", com um valor de string para o nome do bucket a ser criado. No entanto, você pode especificar a região da AWS com o campo “CreateBucketConfiguration”. Se for bem-sucedido, esse método retornará o “Local” do bucket.

 **Código de exemplo** 

```
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 um objeto em um bucket
<a name="put-an-object-in-a-bucket"></a>

Para adicionar arquivos ao novo bucket, crie um arquivo PHP com o código a seguir.

Na linha de comando, execute esse arquivo e passe o nome do bucket no qual você deseja fazer upload do arquivo como uma sequência, seguido pelo caminho completo para o arquivo cujo upload você deseja fazer.

 **Código de exemplo** 

```
$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";
}
```

# Gerenciar permissões de acesso ao bucket do Amazon S3 com o AWS SDK para PHP versão 3
<a name="s3-examples-access-permissions"></a>

As listas de controle de acesso (ACLs) são uma das opções da política de acesso com base em recurso que pode ser usada para gerenciar o acesso aos buckets e objetos. Use as ACLs para conceder permissões básicas de leitura/gravação a outras contas da AWS. Para saber mais, consulte [Gerenciar acesso com ACLs](https://docs.aws.amazon.com/AmazonS3/latest/dev/S3_ACLs_UsingACLs.html).

O exemplo a seguir mostra como:
+ Obter a política de controle de acesso de um bucket usando [GetBucketAcl](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getbucketacl).
+ Definir as permissões em um bucket que usa ACLs usando [PutBucketAcl](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putbucketacl).

O código de exemplo completo do AWS SDK para PHP está disponível [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

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

Antes de executar o código de exemplo, configure suas credenciais da AWS, conforme descrito em [Autenticando com o AWS uso da AWS SDK para PHP versão 3](credentials.md). Em seguida, importe o AWS SDK para PHP, conforme descrito em [Instalando a AWS SDK para PHP versão 3](getting-started_installation.md).

## Obter e definir uma política de lista de controle de acesso
<a name="get-and-set-an-access-control-list-policy"></a>

 **Importações** 

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

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

 **Código de exemplo** 

```
// 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";
}
```

# Configuração de buckets do Amazon S3 com o AWS SDK para PHP versão 3
<a name="s3-examples-configuring-a-bucket"></a>

O compartilhamento de recursos de origem cruzada (CORS) define uma maneira de os aplicativos web clientes carregados em um domínio interagirem com recursos em outro domínio. Com o suporte do CORS no Amazon S3, você pode criar aplicações web no lado do cliente com o Amazon S3 e permitir seletivamente o acesso de origem cruzada aos seus recursos do Amazon S3.

Para obter mais informações sobre como usar a configuração do CORS com um bucket do Amazon S3, consulte [Compartilhamento de recursos entre origens (CORS)](https://docs.aws.amazon.com/AmazonS3/latest/dev/cors.html).

Os exemplos a seguir mostram como:
+ Obter a configuração do CORS para um bucket usando [GetBucketCors](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getbucketcors).
+ Definir a configuração do CORS para um bucket usando [PutBucketCors](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putbucketcors).

O código de exemplo completo do AWS SDK para PHP está disponível [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

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

Antes de executar o código de exemplo, configure suas credenciais da AWS, conforme descrito em [Autenticando com o AWS uso da AWS SDK para PHP versão 3](credentials.md). Em seguida, importe o AWS SDK para PHP, conforme descrito em [Instalando a AWS SDK para PHP versão 3](getting-started_installation.md).

## Obter a configuração do CORS
<a name="get-the-cors-configuration"></a>

Crie um arquivo PHP com o seguinte código. Primeiro crie um serviço de cliente AWS.S3 e, em seguida, chame o método `getBucketCors` e especifique o bucket cuja configuração de CORS você deseja.

O único parâmetro obrigatório é o nome do bucket selecionado. Se o bucket tiver uma configuração do CORS, essa configuração será retornada pelo Amazon S3 como um [objeto CORSRules](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#shape-corsrule).

 **Importações** 

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

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

 **Código de exemplo** 

```
$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());
}
```

## Definir a configuração do CORS
<a name="set-the-cors-configuration"></a>

Crie um arquivo PHP com o seguinte código. Primeiro crie um serviço de cliente do AWS.S3. Depois, chame o método `putBucketCors` e especifique o bucket que tenha a configuração do CORS a ser definida e o CORSConfiguration como um [objeto JSON CORSRules](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#shape-corsrule).

 **Importações** 

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

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

 **Código de exemplo** 

```
$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());
}
```

# Usando uploads de várias partes do Amazon S3 com a versão 3 AWS SDK para PHP
<a name="s3-multipart-upload"></a>

Com uma única operação `PutObject`, você pode fazer upload de objetos de até 5 GB. No entanto, usando os métodos de multipart upload (por exemplo `CreateMultipartUpload`, `UploadPart`, `CompleteMultipartUpload`, `AbortMultipartUpload`), você pode fazer upload de objetos de 5 MB a 5 TB.

O exemplo a seguir mostra como:
+ Faça upload de um objeto para o Amazon S3, usando. [ObjectUploader](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.ObjectUploader.html)
+ Crie um upload de várias partes para um objeto do Amazon S3 usando o. [MultipartUploader](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.MultipartUploader.html)
+ Copie objetos de um local do Amazon S3 para outro usando. [ObjectCopier](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.ObjectCopier.html)

Todo o código de exemplo para o AWS SDK para PHP está disponível [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

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

Antes de executar o código de exemplo, configure suas AWS credenciais, conforme descrito em[Autenticando com o AWS uso da AWS SDK para PHP versão 3](credentials.md). Em seguida, importe o AWS SDK para PHP, conforme descrito em[Instalando a AWS SDK para PHP versão 3](getting-started_installation.md).

## Uploader de objeto
<a name="object-uploader"></a>

Se você não tiver certeza se `PutObject` ou `MultipartUploader` é melhor para a tarefa, use `ObjectUploader`. O `ObjectUploader` fará upload de um arquivo grande no Amazon S3 usando `PutObject` ou `MultipartUploader`, dependendo do tamanho da 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 exemplo** 

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

### Configuração
<a name="object-uploader-configuration"></a>

O construtor do objeto `ObjectUploader` aceita os seguintes argumentos:

**`$client`**  
O objeto `Aws\ClientInterface` a ser usado para executar as transferências. Deve ser uma instância de `Aws\S3\S3Client`.

**`$bucket`**  
(`string`, *obrigatório*) Nome do bucket para o qual o objeto está sendo enviado.

**`$key`**  
(`string`, *obrigatório*) Chave a ser usada para o objeto que está sendo enviado.

**`$body`**  
(`mixed`, *obrigatório*) Dados do objeto a serem carregados. Pode ser um `StreamInterface`, um recurso de fluxo de PHP ou uma string de dados a ser carregada.

**`$acl`**  
(`string`) Lista de controle de acesso (ACL) a ser definida no objeto que está sendo obtido por upload. Por padrão, os objetos são privados.

**`$options`**  
Uma matriz associativa de opções de configuração para o multipart upload. As seguintes opções de configuração são válidas:    
**`add_content_md5`**  
(`bool`) Defina como verdadeiro para calcular automaticamente a MD5 soma de verificação do upload.  
**`mup_threshold`**  
(`int`, *padrão*: `int(16777216)`) O número de bytes para o tamanho do arquivo. Se o tamanho do arquivo exceder esse limite, será usado um carregamento fracionado.  
**`before_complete`**  
(`callable`) Retorno de chamada a ser invocado antes da operação `CompleteMultipartUpload`. O retorno de chamada deve ter uma assinatura de função similar a: `function (Aws\Command $command) {...}`. Consulte a [referência CompleteMultipartUpload da API](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#completemultipartupload) para ver os parâmetros que você pode adicionar ao `CommandInterface` objeto.  
**`before_initiate`**  
(`callable`) Retorno de chamada a ser invocado antes da operação `CreateMultipartUpload`. O retorno de chamada deve ter uma assinatura de função similar a: `function (Aws\Command $command) {...}`. O SDK invocará esse retorno de chamada se o tamanho do arquivo exceder o valor de `mup_threshold`. Consulte a [referência CreateMultipartUpload da API](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#createmultipartupload) para ver os parâmetros que você pode adicionar ao `CommandInterface` objeto.  
**`before_upload`**  
(`callable`) Retorno de chamada a ser invocado antes de qualquer operação `PutObject` ou `UploadPart`. O retorno de chamada deve ter uma assinatura de função similar a: `function (Aws\Command $command) {...}`. O SDK invocará esse retorno de chamada se o tamanho do arquivo for inferior ou igual ao valor de `mup_threshold`. Consulte a [referência PutObject da API](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject) para ver os parâmetros que você pode aplicar à `PutObject` solicitação. Para os parâmetros que se aplicam a uma `UploadPart` solicitação, consulte a [referência UploadPart da API](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#uploadpart). O SDK ignora qualquer parâmetro que não seja aplicável à operação representada pelo objeto `CommandInterface`.  
**`concurrency`**  
(`int`, *padrão*: `int(3)`) O número máximo de operações `UploadPart` simultâneas permitidas durante o multipart upload.  
**`part_size`**  
(`int`, *padrão*: `int(5242880)`) Tamanho da parte, em bytes, a ser usado ao fazer um multipart upload. Esse valor deve ser de 5 MB a 5 GB, inclusive.  
**`state`**  
(`Aws\Multipart\UploadState`) Um objeto que representa o estado do multipart upload e que é usado para retomar um upload anterior. Quando essa opção for fornecida, os argumentos `$bucket` e `$key` e a opção `part_size` serão ignoradas.  
**`params`**  
Uma matriz associativa que fornece opções de configuração para cada subcomando. Por exemplo:  

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

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

Os multipart uploads são projetados para melhorar a experiência de upload de objetos maiores. Eles permitem fazer upload de objetos em partes independentemente, em qualquer ordem e em paralelo.

Os clientes do Amazon S3 são incentivados a usar os carregamentos fracionados para objetos maiores que 100 MB.

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

O SDK tem um objeto `MultipartUploader` especial que simplifica o processo de multipart upload.

 **Importações** 

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

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

 **Código de exemplo** 

```
$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";
}
```

O carregador cria um gerador de dados da parte, com base na origem fornecida e na configuração e tenta fazer upload de todas as partes. Se houver falha em alguma parte do upload, o uploader continuará a fazer upload das partes até que todos os dados de origem tenham sido lidos. Posteriormente, o uploader tentará novamente fazer upload das partes com falha ou lançará uma exceção que contém informações sobre as partes com falha de upload.

## Personalização de um carregamento fracionado
<a name="customizing-a-multipart-upload"></a>

Você pode definir opções personalizadas nas operações `CreateMultipartUpload`, `UploadPart` e `CompleteMultipartUpload` executadas pelo multipart uploader por meio de retornos de chamada passados para o construtor.

 **Importações** 

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

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

 **Código de exemplo** 

```
// 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';
    },
]);
```

### Coleta de resíduos manual entre carregamentos de partes
<a name="manual-garbage-collection-between-part-uploads"></a>

Se você atingir o limite de memória com grandes uploads, isso pode ser devido a referências cíclicas geradas pelo SDK ainda não terem sido coletadas pelo [coletor de lixo do PHP](https://www.php.net/manual/en/features.gc.php) quando o limite de memória foi atingido. Invocar manualmente o algoritmo de coleta entre operações pode permitir que os ciclos sejam coletados antes que esse limite seja atingido. O exemplo a seguir que invoca o algoritmo de coleta usando um retorno de chamada antes de fazer upload de cada parte. Observe que a invocação do coletor de lixo não vêm com um custo de desempenho e o uso ideal dependerá do seu caso de uso e do ambiente.

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

## Recuperação de erros
<a name="recovering-from-errors"></a>

Quando ocorre um erro durante o processo de multipart upload, é lançada uma `MultipartUploadException`. Essa exceção fornece acesso ao objeto `UploadState`, que contém informações sobre o andamento do multipart upload. O `UploadState` pode ser usado para retomar um upload que não foi concluído.

 **Importações** 

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

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

 **Código de exemplo** 

```
// 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);
}
```

A retomada de um upload de um `UploadState` tenta fazer upload das partes que ainda não foram obtidas por upload. O objeto de estado rastreia a partes ausentes, mesmo que sejam consecutivas. O uploader lê ou procura no arquivo de origem fornecido os intervalos de bytes que pertencem às partes que ainda precisam ser obtidas por upload.

 Os objetos `UploadState` são serializáveis, portanto, você também pode retomar um upload em um outro processo. Você também pode obter o objeto `UploadState`, mesmo quando não estiver tratando de uma exceção, chamando `$uploader->getState()`.

**Importante**  
Streams passados como uma origem para um `MultipartUploader` não são automaticamente retrocedidos antes do upload. Se estiver usando um stream em vez de um caminho de arquivo em um loop semelhante ao exemplo anterior, será necessário redefinir a variável `$source` dentro do bloco `catch`.

 **Importações** 

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

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

 **Código de exemplo** 

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

### Abortar um multipart upload
<a name="aborting-a-multipart-upload"></a>

Um multipart upload pode ser anulado recuperando o `UploadId` contido no objeto `UploadState` e passando-o para `abortMultipartUpload`.

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

## Carregamentos fracionados assíncronos
<a name="asynchronous-multipart-uploads"></a>

Chamar `upload()` no `MultipartUploader` é uma solicitação de bloqueio. Se estiver trabalhando em um contexto assíncrono, você poderá obter uma [promessa](guide_promises.md) para o multipart upload.

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

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

 **Código de exemplo** 

```
// 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();
```

### Configuração
<a name="asynchronous-multipart-uploads-configuration"></a>

O construtor do objeto `MultipartUploader` aceita os seguintes argumentos:

** `$client` **  
O objeto `Aws\ClientInterface` a ser usado para executar as transferências. Deve ser uma instância de `Aws\S3\S3Client`.

** `$source` **  
A origem dos dados que estão sendo carregados. Isso pode ser um caminho ou um URL (por exemplo, `/path/to/file.jpg`), um identificador de recurso (por exemplo, `fopen('/path/to/file.jpg', 'r)`) ou uma instância de um [stream PSR-7](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Psr.Http.Message.StreamInterface.html).

** `$config` **  
Uma matriz associativa de opções de configuração para o multipart upload.  
As seguintes opções de configuração são válidas:    
** `acl` **  
(`string`) Lista de controle de acesso (ACL) a ser definida no objeto que está sendo obtido por upload. Por padrão, os objetos são privados.  
** `before_complete` **  
(`callable`) Retorno de chamada a ser invocado antes da operação `CompleteMultipartUpload`. O retorno de chamada deve ter uma assinatura de função como `function (Aws\Command $command) {...}`.  
** `before_initiate` **  
(`callable`) Retorno de chamada a ser invocado antes da operação `CreateMultipartUpload`. O retorno de chamada deve ter uma assinatura de função como `function (Aws\Command $command) {...}`.  
** `before_upload` **  
(`callable`) Retorno de chamada a ser invocado antes de qualquer operação `UploadPart`. O retorno de chamada deve ter uma assinatura de função como `function (Aws\Command $command) {...}`.  
** `bucket` **  
(`string`, *obrigatório*) Nome do bucket para o qual o objeto está sendo enviado.  
** `concurrency` **  
(`int`, *padrão*: `int(5)`) O número máximo de operações `UploadPart` simultâneas permitidas durante o multipart upload.  
** `key` **  
(`string`, *obrigatório*) Chave a ser usada para o objeto que está sendo enviado.  
** `part_size` **  
(`int`, *padrão*: `int(5242880)`) Tamanho da parte, em bytes, a ser usado ao fazer um multipart upload. Esse tamanho deve ser de 5 MB a 5 GB, inclusive.  
** `state` **  
(`Aws\Multipart\UploadState`) Um objeto que representa o estado do multipart upload e que é usado para retomar um upload anterior. Quando essa opção for fornecida, as opções `bucket`, `key` e `part_size` serão ignoradas.  
**`add_content_md5`**  
(`boolean`) Defina como verdadeiro para calcular automaticamente a MD5 soma de verificação do upload.  
**`params`**  
Uma matriz associativa que fornece opções de configuração para cada subcomando. Por exemplo:  

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

## Cópias de várias partes
<a name="multipart-copies"></a>

Isso AWS SDK para PHP também inclui um `MultipartCopy` objeto que é usado de forma semelhante ao`MultipartUploader`, mas foi projetado para copiar objetos entre 5 GB e 5 TB de tamanho no Amazon S3.

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

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

 **Código de exemplo** 

```
// 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 pré-assinada do Amazon S3 com a versão 3 AWS SDK para PHP
<a name="s3-presigned-url"></a>

Você pode autenticar determinados tipos de solicitações passando as informações necessárias como parâmetros de query string em vez de usar o cabeçalho de autorização HTTP. Isso é útil para habilitar o acesso de navegadores de terceiros a seus dados privados do Amazon S3 sem um proxy na solicitação. A ideia é construir uma solicitação “pré-assinada” e codificá-la como um URL que outro usuário possa usar. Além disso, você pode limitar uma solicitação pré-assinada, especificando um tempo de expiração.

## Criar um URL pré-assinado para uma solicitação HTTP GET
<a name="s3-presigned-url-get"></a>

O exemplo de código a seguir mostra como criar um URL pré-assinado para uma solicitação HTTP GET usando o 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;
```

A [referência da API para o método `createPresignedRequest`](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.S3Client.html#method_createPresignedRequest) fornece mais detalhes.

Outra pessoa pode usar o valor de `$presignedUrl` para recuperar o objeto na próxima hora. Quando a solicitação HTTP GET é feita, usando um navegador, por exemplo, o serviço S3 interpreta que a chamada está vindo do usuário que criou o URL pré-assinado.

## Criar um URL pré-assinado para uma solicitação HTTP PUT
<a name="s3-presigned-url-put"></a>

O exemplo de código a seguir mostra como criar um URL pré-assinado para uma solicitação HTTP PUT usando o 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();
```

Agora, outra pessoa pode usar o URL pré-assinado em uma solicitação HTTP PUT para fazer o upload de um arquivo:

```
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;
    }
}
```

# POSTs pré-assinados do Amazon S3 com o AWS SDK para PHP versão 3
<a name="s3-presigned-post"></a>

Assim como os URLs pré-assinados, os POSTs pré-assinados permitem fornecer acesso de gravação a um usuário sem conceder credenciais da AWS ao usuário. Os formulários de POST pré-assinados podem ser criados com a ajuda de uma instância de [AwsS3PostObjectV4](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.PostObjectV4.html).

Os exemplos a seguir mostram como:
+ Obter dados de um objeto do formulário de upload POST do S3 usando [PostObjectV4](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.PostObjectV4.html).

O código de exemplo completo do AWS SDK para PHP está disponível [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

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

**nota**  
`PostObjectV4` não funciona com credenciais provenientes do Centro de Identidade do AWS IAM.

Antes de executar o código de exemplo, configure suas credenciais da AWS, conforme descrito em [Autenticando com o AWS uso da AWS SDK para PHP versão 3](credentials.md). Em seguida, importe o AWS SDK para PHP, conforme descrito em [Instalando a AWS SDK para PHP versão 3](getting-started_installation.md).

## Criar PostObjectV4
<a name="create-postobjectv4"></a>

Para criar uma instância de `PostObjectV4`, você deve fornecer o seguinte:
+ instância de `Aws\S3\S3Client` 
+ bucket
+ matriz associativa de campos de entrada de formulário
+ conjunto de condições de políticas (consulte [Construção de políticas](https://docs.aws.amazon.com/AmazonS3/latest/dev/HTTPPOSTForms.html) no Guia do usuário do Amazon Simple Storage Service)
+ sequência de tempo de expiração para a política (opcional, uma hora por padrão).

 **Importações** 

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

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

 **Código de exemplo** 

```
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 um bucket do Amazon S3 como um host estático da Web com o AWS SDK para PHP versão 3
<a name="s3-examples-static-web-host"></a>

Você pode hospedar um site estático no Amazon S3. Para saber mais, consulte [Hospedagem de um site estático no Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/WebsiteHosting.html).

O exemplo a seguir mostra como:
+ Obter a configuração do site de um bucket usando [GetBucketWebsite](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getbucketwebsite).
+ Definir a configuração do site de um bucket usando [PutBucketWebsite](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putbucketwebsite).
+ Remover a configuração do site de um bucket usando [DeleteBucketWebsite](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#deletebucketwebsite).

Todo o código de exemplo do AWS SDK para PHP versão 3 está disponível [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

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

Antes de executar o código de exemplo, configure suas credenciais da AWS. Consulte as [Credenciais do AWS SDK para PHP versão 3](guide_credentials.md).

## Obter, definir e excluir a configuração do site de um bucket
<a name="get-set-and-delete-the-website-configuration-for-a-bucket"></a>

 **Importações** 

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

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

 **Código de exemplo** 

```
$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";
}
```

# Trabalhar com políticas de bucket do Amazon S3 com o AWS SDK para PHP versão 3
<a name="s3-examples-bucket-policies"></a>

Você pode usar uma política de bucket para conceder permissão aos recursos do Amazon S3. Para saber mais sobre isso, consulte [Usar políticas de bucket e de usuário](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-iam-policies.html).

O exemplo a seguir mostra como:
+ Retornar a política de um bucket especificado usando [GetBucketPolicy](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getbucketpolicy).
+ Substituir uma política em um bucket usando [PutBucketPolicy](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putbucketpolicy).
+ Excluir uma política de um bucket usando [DeleteBucketPolicy](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#deletebucketpolicy).

O código de exemplo completo do AWS SDK para PHP está disponível [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

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

Antes de executar o código de exemplo, configure suas credenciais da AWS, conforme descrito em [Autenticando com o AWS uso da AWS SDK para PHP versão 3](credentials.md). Em seguida, importe o AWS SDK para PHP, conforme descrito em [Instalando a AWS SDK para PHP versão 3](getting-started_installation.md).

## Obter, excluir e substituir uma política em um bucket
<a name="get-delete-and-replace-a-policy-on-a-bucket"></a>

 **Importações** 

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

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

 **Código de exemplo** 

```
$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";
}
```

# Usar ARNs de ponto de acesso do S3 no AWS SDK para PHP versão 3
<a name="s3-examples-access-point-arn"></a>

O S3 incluiu pontos de acesso, uma nova maneira de interagir com buckets do S3. Os pontos de acesso podem ter políticas e configurações exclusivas aplicadas a eles, em vez de diretamente ao bucket. O AWS SDK para PHP permite que você use ARNs de ponto de acesso no campo do bucket para operações de API em vez de especificar explicitamente o nome do bucket. Mais detalhes sobre como os pontos de acesso do S3 e os ARNs funcionam podem ser encontrados [aqui](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-access-points.html). Os exemplos a seguir mostram como:
+ Usar [GetObject](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getobject) com um ARN de ponto de acesso para obter um objeto de um bucket.
+ Usar [PutObject](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject) com um ARN de ponto de acesso para adicionar um objeto a um bucket.
+ Configurar o cliente do S3 para usar a região do ARN em vez da região do cliente.

O código de exemplo completo do AWS SDK para PHP está disponível [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code).

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

Antes de executar o código de exemplo, configure suas credenciais da AWS, conforme descrito em [Autenticando com o AWS uso da AWS SDK para PHP versão 3](credentials.md). Em seguida, importe o AWS SDK para PHP, conforme descrito em [Instalando a AWS SDK para PHP versão 3](getting-started_installation.md).

 **Importações** 

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

use Aws\S3\S3Client;
```

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

Primeiro crie um serviço cliente do AWS.S3 que especifique a região e a versão da AWS. Depois, chame o método `getObject` com sua chave e um ARN de ponto de acesso do S3 no campo `Bucket`, que obterá o objeto do bucket associado a esse ponto de acesso.

 **Código de exemplo** 

```
$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 um objeto em um bucket
<a name="put-an-object-in-a-bucket"></a>

Primeiro crie um serviço cliente do AWS.S3 que especifique a região e a versão da AWS. Depois, chame o método `putObject` com a chave desejada, o corpo ou o arquivo de origem e um ARN de ponto de acesso do S3 no campo `Bucket`, que colocará o objeto no bucket associado a esse ponto de acesso.

 **Código de exemplo** 

```
$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'
]);
```

## Configurar o cliente do S3 para usar a região do ARN em vez da região do cliente
<a name="configure-the-s3-client-to-use-the-arn-region-instead-of-the-client-region"></a>

Ao usar um ARN de ponto de acesso do S3 em uma operação de cliente do S3, por padrão, o cliente se certificará de que a região do ARN corresponda à região do cliente, lançando uma exceção, caso contrário. Esse comportamento pode ser alterado para aceitar a região do ARN em vez da região do cliente definindo a opção de configuração de `use_arn_region` como `true`. Por padrão, a opção é definida como `false`.

 **Código de exemplo** 

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

O cliente também verificará uma variável de ambiente e uma opção de arquivo de configuração, na seguinte ordem de prioridade:

1. A opção do cliente `use_arn_region`, como no exemplo acima.

1. A variável de ambiente `AWS_S3_USE_ARN_REGION` 

```
export AWS_S3_USE_ARN_REGION=true
```

1. A variável de configuração `s3_use_arn_region` no arquivo de configuração compartilhado da AWS (por padrão em `~/.aws/config`).

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

# Use os pontos de acesso multirregionais do Amazon S3 com a versão 3 AWS SDK para PHP
<a name="s3-multi-region-access-points"></a>

Os [pontos de acesso multirregionais do Amazon Simple Storage Service (S3)](https://docs.aws.amazon.com//AmazonS3/latest/userguide/MultiRegionAccessPoints.html) fornecem um endpoint global para rotear o tráfego de solicitações do Amazon S3 entre Regiões da AWS.

Você pode criar pontos de acesso multirregionais [usando o SDK for](https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-s3control-2018-08-20.html#createmultiregionaccesspoint) PHP, AWS outro SDK, o [console S3 ou a CLI](https://docs.aws.amazon.com//AmazonS3/latest/userguide/multi-region-access-point-create-examples.html), AWS 

**Importante**  
Para usar pontos de acesso multirregionais com o SDK for PHP, seu ambiente PHP deve ter AWS a extensão [Common Runtime AWS (CRT](guide_crt.md)) instalada.

Quando você cria um ponto de acesso multirregional, o Amazon S3 gera um nome do recurso da Amazon (ARN) que tem o seguinte formato: 

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

Você pode usar o ARN gerado no lugar de um nome de bucket para os métodos `[getObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#getobject)` e `[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";
```