# Fazer upload de objetos
Quando você faz upload de um arquivo no Amazon S3, ele é armazenado como um *objeto* do S3. Os objetos consistem em dados e metadados de arquivo que descrevem o objeto. Você pode ter um número ilimitado de objetos em um bucket. Antes de fazer upload de arquivos em um bucket do Amazon S3, você precisa escrever permissões para o bucket. Para obter mais informações sobre permissões de acesso, consulte [Gerenciamento de identidade e acesso para o Amazon S3](security-iam.md).
Você pode fazer upload de qualquer tipo de arquivo (imagens, backups, dados, filmes etc.) para um bucket do S3. O tamanho máximo de arquivo que você pode carregar usando o console do Amazon S3 é de 160 GB. Para fazer upload de um arquivo com mais de 160 GB, use a AWS Command Line Interface (AWS CLI), AWS SDKs ou a API REST do Amazon S3.
Se você fizer upload de um objeto com um nome de chave que já existe em um bucket com versionamento habilitado, o Amazon S3 criará outra versão de objeto em vez de substituir o objeto existente. Para ter mais informações sobre como habilitar o versionamento, consulte [Habilitar o versionamento em buckets](manage-versioning-examples.md).
Dependendo do tamanho de dados enviados por upload, o Amazon S3 oferece as seguintes opções:
+ **Fazer upload de um objeto em uma única operação usando AWS SDKs, a API REST ou a AWS CLI**: com uma única operação `PUT`, você pode fazer upload de um único objeto com até 5 GB.
+ **Fazer upload de um único objeto usando o console do Amazon S3****:** com o console do Amazon S3, é possível fazer upload de um único objeto com até 160 GB de tamanho.
+ **Fazer upload de um objeto em partes usando AWS SDKs, a API REST ou a AWS CLI****:** com a operação de API de upload de várias partes, é possível fazer upload de um único objeto grande, com até 50 TB.
A operação de API de upload de várias partes foi projetada para melhorar a experiência de upload de objetos maiores. É possível fazer upload de um objeto em partes. O upload dessas partes de objetos pode ser feito independentemente, em qualquer ordem, e em paralelo. É possível usar um multipart upload de objetos de 5 MB a 50 TB. Para obter mais informações, consulte [Carregar e copiar objetos usando upload fracionado no Amazon S3](mpuoverview.md).
Para fazer upload de arquivos com mais de 5 TB, use a Transferência de Arquivos do S3 no Java v1/v2, no Python ou em SDKs da AWS CLI. Para ter o melhor desempenho, use a AWS Common Runtime (CRT) mais recente com esses SDKs, que foi otimizada para melhorar a utilização de recursos.
Quando são carregados grandes objetos do fluxo de memória, a CRT armazena temporariamente cada parte de até 5 GB na memória, limitando o throughput geral pela memória alocada. É possível ajustar o limite de memória da CRT usando opções de configuração, como `maxNativeMemoryLimitInBytes` para o SDK para Java. Para uploads do disco, a CRT muda automaticamente para streaming direto do disco em vez de armazenar em buffer partes intermediárias, melhorando o uso da memória. Esse comportamento é habilitado automaticamente para objetos grandes, mas também pode ser habilitado para arquivos menores por meio de parâmetros de solicitação, como `should_stream` para a AWS CLI e `CRT_MEMORY_BUFFER_DISABLED` para o SDK para Java.
Quando você faz upload de um objeto, ele é automaticamente criptografado usando criptografia do lado do servidor com chaves gerenciadas pelo Amazon S3 (SSE-S3) por padrão. Quando você faz download, o objeto é descriptografado. Para obter mais informações, consulte [Definir o comportamento padrão da criptografia para os buckets do Amazon S3](bucket-encryption.md) e [Proteger dados com criptografia](UsingEncryption.md).
Ao fazer upload de um objeto, se quiser usar um tipo diferente de criptografia padrão, você também pode especificar a criptografia do lado do servidor com chaves do AWS Key Management Service (AWS KMS) (SSE-KMS) nas solicitações `PUT` do S3 ou definir a configuração de criptografia padrão no bucket de destino para usar o SSE-KMS para criptografar os dados. Para obter mais informações sobre SSE-KMS, consulte [Especificação de criptografia no lado do servidor com o AWS KMS (SSE-KMS)](specifying-kms-encryption.md). Se quiser usar uma chave do KMS que seja de propriedade de outra conta, você deverá ter permissão para usar a chave. Para obter mais informações sobre permissões entre contas para chaves do KMS, consulte [Criar chaves do KMS que outras contas podem usar](https://docs.aws.amazon.com//kms/latest/developerguide/key-policy-modifying-external-accounts.html#cross-account-console) no *Guia do desenvolvedor do AWS Key Management Service*.
Se você encontrar um erro de Acesso negado (403 Proibido) no Amazon S3, consulte [Solucionar erros de acesso negado (403 Forbidden) no Amazon S3](troubleshoot-403-errors.md) para saber mais sobre as causas comuns.
## Fazer upload de um objeto
### Usar o console do S3
Este procedimento explica como fazer upload de objetos e pastas para um bucket do Amazon S3 usando o console.
Quando você faz upload de um objeto, o nome da chave de objeto é o nome do arquivo e quaisquer prefixos opcionais. No console do Amazon S3, você pode criar pastas para organizar seus objetos. No Amazon S3, as pastas são representadas como prefixos que aparecem no nome da chave de objeto. Se você fizer upload um objeto individual para uma pasta no console do Amazon S3, o nome da pasta será incluído no nome da chave do objeto.
Por exemplo, se você carregar um objeto chamado `sample1.jpg` para uma pasta chamada `backup`, o nome da chave será `backup/sample1.jpg`. Contudo, o objeto é exibido no console como `sample1.jpg` na pasta `backup`. Para obter mais informações sobre nomes de chave, consulte [Trabalhar com metadados de objeto](UsingMetadata.md).
**nota**
Se você renomear um objeto ou alterar qualquer uma das propriedades no console do Amazon S3, por exemplo **Classe de armazenamento**, **Criptografia** ou **Metadados**, será criado outro objeto para substituir o antigo. Se o versionamento do S3 estiver habilitado, uma nova versão do objeto será criada e o objeto existente se tornará uma versão mais antiga. O perfil que altera a propriedade também se torna o proprietário do novo objeto (ou versão do objeto).
Quando você faz upload de uma pasta, o Amazon S3 faz upload de todos os arquivos e subpastas da pasta especificada em seu bucket. Ele então atribui um nome de chave de objeto que é uma combinação do nome de arquivo carregado com o nome da pasta. Por exemplo, se você fizer upload de uma pasta chamada `/images` que contém dois arquivos, `sample1.jpg` e `sample2.jpg`, o Amazon S3 fará upload dos arquivos e atribuirá a eles os nomes de chave correspondentes, `images/sample1.jpg` e `images/sample2.jpg`. Os nomes de chave incluem o nome da pasta como um prefixo. O console do Amazon S3 exibe somente a parte do nome de chave que vem depois da última `/`. Por exemplo, em uma pasta `images`, os objetos `images/sample1.jpg` e `images/sample2.jpg` são exibidos como `sample1.jpg` e `sample2.jpg`.
**Para fazer upload de pastas e arquivos para um bucket do S3**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Buckets**.
1. Na lista **Buckets**, escolha o nome do bucket no qual você deseja carregar suas pastas ou arquivos.
1. Escolha **Upload (Fazer upload)**.
1. Na janela **Upload (Fazer upload)**, siga um destes procedimentos:
+ Arraste e solte arquivos e pastas para a janela **Upload (Fazer upload)** .
+ Escolha **Adicionar arquivo** ou **Adicionar pasta**, escolha arquivos ou pastas para fazer upload e depois escolha **Abrir**.
1. Para habilitar o versionamento, em **Destination (Destino)**, escolha **Enable Bucket Versioning (Ativar versionamento de bucket)**.
1. Para fazer upload dos arquivos e pastas listados sem configurar opções de upload adicionais, na parte inferior da página, escolha **Upload (Fazer upload)**.
O Amazon S3 faz o upload de seus objetos e pastas. Quando o upload for concluído, você verá uma mensagem de sucesso na página **Upload: status**.
**Para configurar propriedades de objeto adicionais**
1. Para alterar as permissões da lista de controle de acesso, escolha **Permissions** (Permissões).
1. Em **Access control list (ACL)** (Lista de controle de acesso (ACL)), edite as permissões.
Para informações sobre permissões de acesso a objeto, consulte [Usar o console do S3 para definir permissões de ACL para um objeto](managing-acls.md#set-object-permissions). Você pode conceder acesso de leitura aos seus objetos ao público (todos no mundo), para todos os arquivos que você está carregando. No entanto, recomendamos não alterar a configuração padrão para acesso de leitura público. Conceder acesso público de leitura é aplicável a um pequeno subconjunto de casos de uso, como quando buckets são usados para sites. Você sempre pode alterar as permissões de objeto depois de carregar o objeto.
1. Para configurar outras propriedades, escolha **Properties** (Propriedades).
1. Na seção **Classe de armazenamento** escolha a classe de armazenamento para os arquivos que você está carregando.
Para obter mais informações sobre classes de armazenamento, consulte [Compreender e gerenciar classes de armazenamento do Amazon S3](storage-class-intro.md).
1. Para atualizar as configurações de criptografia para seus objetos, em **Server-side encryption settings (Configurações de criptografia do lado do servidor)**, faça o seguinte.
1. Escolha **Specify an encryption key** (Especificar uma chave de criptografia).
1. Em **Configurações de criptografia**, escolha **Usar configurações de bucket para criptografia padrão** ou **Substituir configurações de bucket para criptografia padrão**.
1. Se você escolher **Substituir configurações do bucket para criptografia padrão**, deverá definir as configurações de criptografia a seguir.
+ Para criptografar os arquivos carregados usando chaves gerenciadas pelo Amazon S3, escolha **Chave gerenciada pelo Amazon S3 (SSE-S3)**.
Para obter mais informações, consulte [Usar a criptografia do lado do servidor com chaves gerenciadas pelo Amazon S3 (SSE-S3)](UsingServerSideEncryption.md).
+ Para criptografar os arquivos carregados usando chaves armazenadas no AWS Key Management Service (AWS KMS), selecione **Chave do AWS Key Management Service (SSE-KMS)**. Depois, escolha uma das seguintes opções para a **chave do AWS KMS**:
+ Para escolher entre uma lista de chaves do KMS disponíveis, selecione **Escolher de sua AWS KMS keys** e escolha a **chave do KMS** na lista de chaves disponíveis.
As chaves Chave gerenciada pela AWS (`aws/s3`) e as chaves gerenciadas pelo cliente são exibidas nessa lista. Para ter mais informações sobre chaves gerenciadas pelo cliente, consulte [Chaves de clientes e chaves da AWS](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#key-mgmt) no *Guia do desenvolvedor do AWS Key Management Service*.
+ Para inserir o ARN da chave do KMS, selecione **Inserir ARN da AWS KMS key** e insira o ARN da chave do KMS no campo exibido.
+ Para criar uma chave gerenciada pelo cliente no console do AWS KMS, selecione **Criar uma chave do KMS**.
Para ter mais informações sobre como criar uma AWS KMS key, consulte [Criação de chaves](https://docs.aws.amazon.com//kms/latest/developerguide/create-keys.html) no * Guia do desenvolvedor do AWS Key Management Service*.
**Importante**
Você só pode usar chaves do KMS disponíveis na mesma Região da AWS que o bucket. O console do Amazon S3 lista somente as primeiras 100 chaves do KMS na mesma região que o bucket. Para usar uma chave do KMS que não esteja listada, você deve inserir o ARN da chave do KMS. Se quiser usar uma chave do KMS que seja de propriedade de outra conta, primeiro você deverá ter permissão para usar a chave e, depois, inserir o ARN da chave do KMS.
O Amazon S3 só é compatível com chaves do KMS de criptografia simétrica, e não com chaves assimétricas do KMS. Para ter mais informações, consulte [Identificar chaves do KMS simétricas e assimétricas](https://docs.aws.amazon.com//kms/latest/developerguide/find-symm-asymm.html) no *Guia do desenvolvedor do AWS Key Management Service*.
1. Para usar somas de verificação adicionais, escolha **On** (Ativar). Em seguida, em **Checksum function** (Função de soma de verificação), escolha a função que você gostaria de usar. O Amazon S3 calcula e armazena o valor da soma de verificação depois de receber o objeto inteiro. Você pode usar a caixa **Precalculated value** (Valor pré-calculado) para fornecer esse valor. Se fizer isso, o Amazon S3 vai comparar o valor que você forneceu com o valor calculado. Se os dois valores não corresponderem, o Amazon S3 gerará um erro.
As somas de verificação adicionais permitem que você especifique o algoritmo de soma de verificação que gostaria de usar para verificar seus dados. Para obter mais informações sobre somas de verificação adicionais, consulte [Verificar a integridade do objeto no Amazon S3](checking-object-integrity.md).
1. Para adicionar tags a todos os objetos que você está carregando, escolha **Add tag (Adicionar tag)**. Insira um nome de tag no campo **Chave**. Insira um valor para a tag.
A marcação de objetos é uma forma de categorizar o armazenamento. Cada tag é um par de chave-valor. Os valores de chave e tag diferenciam maiúsculas de minúsculas. É possível ter até dez tags por objeto. Uma chave de tag pode ter até 128 caracteres Unicode e os valores de tag podem ter até 255 caracteres Unicode. Para obter mais informações sobre tags de objeto, consulte [Categorizar objetos usando tags](object-tagging.md).
1. Para adicionar metadados, escolha **Add metadata (Adicionar metadados)**.
1. Em **Type (Tipo)**, escolha **System defined (Definido pelo sistema)** ou **User defined (Definido pelo usuário)**.
Para metadados definidos pelo sistema, você pode selecionar cabeçalhos HTTP comuns, como **Content-Type** e **Content-Disposition**. Para obter uma lista de metadados definidos pelo sistema e informações sobre a possibilidade de adicionar o valor, consulte [Metadados do objeto definidos pelo sistema](UsingMetadata.md#SysMetadata). Todos os metadados que começam com o prefixo `x-amz-meta-` são tratados como metadados definidos pelo usuário. Os metadados definidos pelo usuário são armazenados com o objeto e retornados quando você baixa o objeto. As chaves e seus valores devem estar em conformidade com os padrões US-ASCII. Metadados definidos pelo usuário podem ter até 2 KB. Para obter mais informações sobre metadados definidos pelo sistema e pelo usuário, consulte [Trabalhar com metadados de objeto](UsingMetadata.md).
1. Para **Key (Chave)**, escolha uma chave.
1. Digite um valor para a chave.
1. Para carregar seus objetos, escolha **Upload (Fazer upload)**.
O Amazon S3 faz o upload do objeto. Quando o upload for concluído, você pode ver uma mensagem de sucesso na página de **Upload: status**.
1. Selecione **Exit (Sair)**.
### Como usar o AWS CLI
Você pode enviar uma solicitação `PUT` para fazer upload de um objeto de até 5 GB em uma única operação. Para obter mais informações, consulte o exemplo de [https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html#examples](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html#examples) na *Referência de comandos da AWS CLI*.
### Uso da API REST
Você pode enviar solicitações REST para fazer upload de um objeto. Você pode enviar uma solicitação `PUT` para carregar dados em uma única operação. Para obter mais informações, consulte [Objeto PUT](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html).
### Usar SDKs da AWS
Consulte exemplos de como fazer upload de um objeto com os SDKs da AWS em [Exemplos de código](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_PutObject_section.html) na *Referência de API do Amazon Simple Storage Service*.
Consulte informações gerais sobre como usar diferentes SDKs da AWS em [Desenvolvimento com o Amazon S3 usando SDKs da AWS](https://docs.aws.amazon.com/AmazonS3/latest/API/sdk-general-information-section.html) na *Referência de API do Amazon Simple Storage Service*.
## Impedir o upload de objetos com nomes de chave idênticos
É possível conferir a existência de um objeto no bucket antes de criá-lo usando uma gravação condicional nas operações de upload. Isso pode evitar a substituição de dados existentes. As gravações condicionais confirmarão que não há nenhum objeto com o mesmo nome de chave no bucket durante o upload.
É possível usar gravações condicionais para solicitações [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) ou [CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html).
Para ter mais informações sobre solicitações condicionais, consulte [Adicionar condições prévias às operações do S3 com solicitações condicionais](conditional-requests.md).
# Carregar e copiar objetos usando upload fracionado no Amazon S3
O upload fracionado permite que você faça upload de um único objeto no Amazon S3 como um conjunto de partes. Cada parte é uma parte contígua de dados do objeto. O upload dessas partes de objetos pode ser feito de maneira independente e em qualquer ordem. Para uploads, o cliente da AWS atualizado calcula automaticamente uma soma de verificação do objeto e a envia para o Amazon S3 com o tamanho do objeto como parte da solicitação. Se a transmissão de alguma parte falhar, você poderá retransmitir essa parte sem afetar outras partes. Depois que todas as partes do objeto forem carregadas, o Amazon S3 montará as partes e criará o objeto. É uma prática recomendada usar o upload fracionado para objetos com 100 MB ou mais, em vez de carregá-los em uma única operação.
Usar o multipart upload fornece as seguintes vantagens:
+ **Improved throughput** (Throughput aprimorada): você pode carregar as partes em paralelo para melhorar o throughput.
+ **Quick recovery from any network issues** (Recuperação rápida de qualquer problema de rede): o tamanho menor das partes minimiza o impacto de reiniciar um carregamento que falhou devido a um erro de rede.
+ **Pause and resume object uploads** (Pausar e retomar carregamentos de objetos): você pode carregar as partes do objeto ao longo do tempo. Após ser iniciado um carregamento fracionado, ele não expira; você deve concluir ou interromper explicitamente o carregamento fracionado.
+ **Iniciar um upload antes de saber o tamanho final do objeto** você pode fazer upload de um objeto ao criá-lo.
Recomendamos que você use o carregamento fracionado das seguintes maneiras:
+ Se você fizer upload de objetos grandes em uma rede de banda larga estável, use o upload fracionado para maximizar o uso da largura de banda disponível, fazendo upload de partes do objeto em paralelo para performance com vários threads.
+ Se fizer upload em uma rede lenta, use o upload fracionado para aumentar a resiliência contra erros de rede, evitando reinicializações de uploads. Ao usar o upload fracionado, tente carregar novamente apenas as partes que foram interrompidas durante o carregamento. Você não precisa reiniciar o upload do seu objeto do começo.
**nota**
Para obter mais informações sobre o uso da classe de armazenamento Amazon S3 Express One Zone com buckets de diretório, consulte [S3 Express One Zone](directory-bucket-high-performance.md#s3-express-one-zone) e [Trabalhar com buckets de diretório](directory-buckets-overview.md). Para obter mais informações sobre como usar multipart upload com a classe S3 Express One Zone e buckets de diretório, consulte [Usar uploads multiparte com buckets de diretório](s3-express-using-multipart-upload.md).
## Processo multipart upload
O upload fracionado é um processo de três etapas: você inicia o upload, faz upload de partes do objeto e, depois de fazer upload de todas as partes, conclui o upload fracionado. Ao receber a solicitação de conclusão do upload fracionado, o Amazon S3 cria o objeto com base nas partes carregadas, e você poderá acessar o objeto como qualquer outro objeto no bucket.
Você pode listar todos os seus multipart uploads em andamento ou obter uma lista das partes que carregou para um multipart upload específico. Cada uma dessas operações é explicada nesta seção.
**Iniciação do multipart upload**
Ao enviar uma solicitação para iniciar um upload fracionado, especifique um tipo de soma de verificação. Depois, o Amazon S3 retornará uma resposta com um ID de upload, que é um identificador exclusivo para o upload fracionado. Esse ID de upload é necessário ao fazer upload de partes, listar as partes, concluir um upload ou interromper um upload. Se você quiser fornecer metadados que descrevam o objeto que está sendo carregado, deverá fornecê-los na solicitação para iniciar o upload fracionado. Usuários anônimos não podem iniciar carregamentos fracionados.
**Carregar partes**
Ao fazer upload de uma parte, além do ID de upload, é necessário especificar um número de parte. Você pode escolher qualquer número de parte entre 1 e 10.000. Um número de parte identifica com exclusividade a parte e sua posição no objeto do qual você está fazendo upload. O número de parte que você escolheu não precisa estar em uma sequência consecutiva (por exemplo, pode ser 1, 5 e 14). Saiba que, se você fizer upload de uma nova parte usando o mesmo número da parte anteriormente carregada, a parte anteriormente carregada será substituída.
Quando você faz upload de uma parte, o Amazon S3 retorna o tipo de algoritmo de soma de verificação com o valor da soma para cada parte como cabeçalho na resposta. Para cada upload de parte, você deve registrar o número de parte e o valor de ETag. Você tem que incluir esses valores na solicitação subsequente para concluir o multipart upload. Cada parte terá sua própria ETag no momento do upload. No entanto, quando o upload fracionado estiver concluído e todas as partes estiverem consolidadas, todas as partes pertencerão a uma ETag como uma soma de verificação das somas de verificação.
**Importante**
Depois de inicializar um upload fracionado e fazer upload de uma ou mais partes, será necessário concluir ou interromper o upload fracionado para interromper a cobrança pelo armazenamento das partes carregadas. Somente *depois* que você concluir ou interromper um upload fracionado é que o Amazon S3 liberará o armazenamento das partes e deixará de cobrar pelo armazenamento das partes.
Depois de interromper um upload fracionado, você não poderá fazer upload de nenhuma parte usando esse ID de upload novamente. Se havia uploads de partes em andamento, eles ainda poderão ser bem-sucedidos ou falhar mesmo depois da interrupção. Para liberar todo o armazenamento consumido por todas as partes, você deve interromper um upload fracionado somente depois que todos os uploads de partes forem concluídos.
**Conclusão do multipart upload**
Quando você concluir um multipart upload, o Amazon S3 criará um objeto concatenando as partes em ordem crescente com base no número da parte. Se algum metadado de objeto for fornecido na solicitação *iniciar multipart upload*, o Amazon S3 associará esses metadados ao objeto. Depois de uma solicitação de *conclusão* bem-sucedida, as partes não existem mais.
Sua solicitação de *conclusão do upload fracionado* deve incluir o ID de upload e uma lista dos números das partes e dos valores de ETag correspondentes. A resposta do Amazon S3 inclui um ETag que identifica exclusivamente os dados do objeto combinados. Esse ETag não é necessariamente um hash MD5 dos dados do objeto.
Ao fornecer uma soma de verificação de objeto inteiro durante um upload fracionado, o AWS SDK envia a soma de verificação para o Amazon S3, e o S3 valida a integridade do objeto do lado do servidor, comparando-a com o valor recebido. Depois, o S3 armazena o objeto se os valores corresponderem. Se os dois valores não corresponderem, o Amazon S3 reprovará a solicitação com um erro `BadDigest`. A soma de verificação do objeto também é armazenada nos metadados do objeto que você usará posteriormente para validar a integridade dos dados do objeto.
**Exemplos de chamada de carregamento fracionado**
Para este exemplo, suponha que você esteja gerando um upload fracionado para um arquivo de 100 GB. Nesse caso, você teria as seguintes chamadas de API para todo o processo. Haveria um total de 1.002 chamadas de API.
+ Uma chamada `[CreateMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)` para iniciar o processo.
+ Mil chamadas `[UploadPart](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)` individuais, cada uma fazendo upload de uma parte de 100 MB, para um tamanho total de 100 GB.
+ Uma chamada `[CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)` para concluir o processo.
**Listagens de multipart upload**
Você pode listar as partes de um multipart upload específico ou de todos os multipart uploads em andamento. A operação de listagem de partes retorna as informações das partes que você carregou em um upload fracionado específico. Para cada solicitação de listagem de partes, o Amazon S3 retorna informações das partes do multipart upload especificado, até no máximo 1.000 partes. Se houver mais de 1.000 partes no upload fracionado, você deverá enviar uma série de solicitações de listagem para recuperar todas as partes. Observe que a lista de partes retornada não inclui aquelas cujo carregamento não foi concluído. Usando a operação *list multipart uploads* (listar carregamentos fracionados), você pode obter uma lista daqueles que estão em andamento.
Um multipart upload em andamento é um upload que você iniciou, mas que ainda não concluiu nem interrompeu. Cada solicitação retorna no máximo 1.000 multipart uploads. Se houver mais de 1.000 carregamento fracionados em andamento, você precisará enviar solicitações adicionais para recuperar os carregamento fracionados restantes. Use a listagem retornada apenas para verificação.
**Importante**
Não use o resultado dessa listagem ao enviar uma solicitação *complete multipart upload* (concluir carregamento fracionado). Em vez disso, mantenha sua própria lista de números de parte que você especificou ao carregar as partes e os valores correspondentes de ETag que o Amazon S3 retorna.
## Somas de verificação com operações de carregamento fracionado
Ao carregar um objeto no Amazon S3, você pode especificar um algoritmo de soma de verificação a ser usado pelo Amazon S3. Por padrão, o AWS SDK e o console do S3 usam um algoritmo para todos os uploads de objetos, que você pode substituir. Se você estiver usando um SDK mais antigo e o objeto carregado não tiver uma soma de verificação especificada, o Amazon S3 usará automaticamente o algoritmo de soma de verificação CRC-64/NVME (`CRC64NVME`). (Essa também é a opção recomendada para uma verificação eficiente da integridade dos dados.) Ao usar o CRC-64/NVME, o Amazon S3 calcula a soma de verificação do objeto inteiro após a conclusão do upload fracionado ou de parte única. O algoritmo de soma de verificação CRC-64/NVME é usado para calcular uma soma de verificação direta do objeto inteiro ou uma soma de verificação das somas de verificação de cada parte.
Depois que você faz upload de um objeto no S3 usando o upload fracionado, o Amazon S3 calcula o valor da soma de verificação de cada parte ou do objeto inteiro e armazena os valores. Você pode usar a API do S3 ou o AWS SDK para recuperar o valor da soma de verificação das seguintes maneiras:
+ Para partes individuais, você pode usar [https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) ou [https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html). Se quiser recuperar os valores da soma de verificação para partes individuais de uploads fracionados enquanto ainda estão em andamento, você pode usar [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html).
+ Para o objeto inteiro, você pode usar [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html). Se você quiser realizar um upload fracionado com uma soma de verificação de objeto inteiro, use [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload) e [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload) especificando o tipo de soma de verificação do objeto inteiro. Para validar o valor da soma de verificação do objeto inteiro ou para confirmar qual tipo de soma de verificação está sendo usado no upload fracionado, use [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html).
**Importante**
Se você estiver usando um upload fracionado com **somas de verificação**, os números de cada parte do upload (no upload fracionado) deverão ser consecutivos e começar com 1. Ao usar **Checksums**, se tentar concluir uma solicitação de upload fracionado com números de parte não consecutivos, o Amazon S3 gerará um erro `HTTP 500 Internal Server`.
Consulte mais informações sobre como as somas de verificação funcionam com objetos de carregamento fracionado em [Verificar a integridade do objeto no Amazon S3](checking-object-integrity.md).
Para conferir um procedimento completo que demonstra como fazer upload de um objeto usando o upload fracionado com uma soma de verificação adicional, consulte [Tutorial: Fazer upload de um objeto por meio do carregamento fracionado e conferir a integridade dos dados](tutorial-s3-mpu-additional-checksums.md).
## Operações simultâneas de multipart upload
Em um ambiente de desenvolvimento distribuído, é possível que sua aplicação inicie várias atualizações no mesmo objeto ao mesmo tempo. Seu aplicativo pode iniciar vários multipart uploads usando a mesma chave de objeto. Para cada um desses uploads, sua aplicação pode fazer upload das partes e enviar uma solicitação de conclusão de upload ao Amazon S3 para criar o objeto. Quando os buckets têm o versionamento do S3 habilitado, a conclusão de um carregamento fracionado sempre criará uma versão. Ao iniciar vários uploads multiparte que usam a mesma chave de objeto em um bucket habilitado para versionamento, a versão atual do objeto é determinada pelo upload iniciado mais recentemente (`createdDate`).
Por exemplo, você inicia uma solicitação `CreateMultipartUpload` para um objeto às 10h. Depois, você envia uma segunda solicitação `CreateMultipartUpload` para o mesmo objeto às 11h. Como a segunda solicitação foi enviada mais recentemente, o objeto carregado pela solicitação das 11h se torna a versão atual, mesmo que o primeiro upload seja concluído após o segundo. Para os buckets que não têm o versionamento habilitado, é possível que qualquer outra solicitação recebida entre o momento em que um upload fracionado é inicializado e sua conclusão tenha precedência.
Outro exemplo de quando uma solicitação de upload fracionado simultânea pode ter precedência é se outra operação excluir uma chave depois que você iniciar um upload fracionado com essa chave. Antes de concluir a operação, a resposta do upload fracionado concluído poderá indicar a criação bem-sucedida de um objeto sem você nunca ter visto o objeto.
## Impedir o upload de objetos com nomes de chave idênticos durante carregamentos fracionados
É possível conferir a existência de um objeto no bucket antes de criá-lo usando uma gravação condicional nas operações de upload. Isso pode evitar a substituição de dados existentes. As gravações condicionais confirmarão que não há nenhum objeto com o mesmo nome de chave no bucket durante o upload.
É possível usar gravações condicionais para solicitações [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) ou [CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html).
Para ter mais informações sobre solicitações condicionais, consulte [Adicionar condições prévias às operações do S3 com solicitações condicionais](conditional-requests.md).
## Multipart upload e definição de preço
Depois que você iniciar um multipart upload, o Amazon S3 reterá todas as partes até você concluir ou interromper o upload. Durante todo o ciclo de vida, você será cobrado por armazenamento, largura de banda e solicitações desse multipart upload e das partes associadas.
Essas partes são cobradas de acordo com a classe de armazenamento especificada no upload das partes. No entanto, você não receberá cobrança por essas partes se elas forem carregadas nas classes S3 Glacier Flexible Retrieval ou S3 Glacier Deep Archive. As partes fracionadas em andamento para uma solicitação PUT na classe de armazenamento S3 Glacier Flexible Retrieval são cobradas como armazenamento de preparação da classe S3 Glacier Flexible Retrieval de acordo com as taxas de armazenamento da classe S3 Standard até que o upload seja concluído. Além disso, tanto `CreateMultipartUpload` quanto `UploadPart` são cobradas de acordo com as taxas da classe S3 Standard. Somente a solicitação `CompleteMultipartUpload` é cobrada de acordo com a taxa da classe S3 Glacier Flexible Retrieval. De maneira semelhante, as partes fracionadas em andamento para uma PUT na classe de armazenamento S3 Glacier Deep Archive são cobradas como armazenamento de preparação da classe S3 Glacier Flexible Retrieval de acordo com as taxas de armazenamento da classe S3 Standard até que o upload seja concluído. Apenas a solicitação `CompleteMultipartUpload` é cobrada de acordo com as taxas da classe S3 Glacier Deep Archive.
Se você interromper o upload fracionado, o Amazon S3 excluirá os artefatos de upload e todas as partes carregadas. Você não receberá cobrança por esses artefatos. Não há cobrança de exclusão antecipada pela exclusão de carregamentos fracionados incompletos, independentemente da classe de armazenamento especificada. Para obter mais informações sobre a definição de preços, consulte [Definição de preços do Amazon S3](https://aws.amazon.com/s3/pricing/).
**nota**
Para minimizar os custos de armazenamento, recomendamos que você configure uma regra de ciclo de vida para excluir uploads incompletos de várias partes após um determinado número de dias usando a ação `AbortIncompleteMultipartUpload`. Para obter mais informações sobre como criar uma regra de ciclo de vida para excluir uploads incompletos de várias partes, consulte [Configurando uma política de ciclo de vida de bucket para anular multipart uploads incompletos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html).
## Suporte de API para multipart upload
As seções a seguir na *Referência de APIs do Amazon Simple Storage Service* descrevem a API REST para multipart upload.
Para conferir um passo a passo sobre upload multiparte que utiliza funções do AWS Lambda, consulte [Uploading large objects to Amazon S3 using multipart upload and transfer acceleration](https://aws.amazon.com/blogs/compute/uploading-large-objects-to-amazon-s3-using-multipart-upload-and-transfer-acceleration/).
+ [Criar carregamento fracionado](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)
+ [Carregar parte](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)
+ [Carregar parte (copiar)](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html)
+ [Concluir multipart upload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)
+ [Anular carregamento fracionado](https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html)
+ [Listar partes](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html)
+ [Listar carregamentos fracionados](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html)
## AWS Command Line InterfaceSuporte da para carregamento fracionado
Os tópicos a seguir na AWS Command Line Interface descrevem as operações de carregamento fracionado.
+ [Iniciar multipart upload](https://docs.aws.amazon.com/cli/latest/reference/s3api/create-multipart-upload.html)
+ [Carregar parte](https://docs.aws.amazon.com/cli/latest/reference/s3api/upload-part.html)
+ [Carregar parte (copiar)](https://docs.aws.amazon.com/cli/latest/reference/s3api/upload-part-copy.html)
+ [Concluir multipart upload](https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html)
+ [Anular carregamento fracionado](https://docs.aws.amazon.com/cli/latest/reference/s3api/abort-multipart-upload.html)
+ [Listar partes](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html)
+ [Listar carregamentos fracionados](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-multipart-uploads.html)
## AWSSuporte do SDK para upload fracionado
Você pode usar AWS SDKs para fazer upload de um objeto em partes. Para obter uma lista dos AWS SDKs compatíveis com a ação da API, consulte:
+ [Criar carregamento fracionado](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)
+ [Carregar parte](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)
+ [Carregar parte (copiar)](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html)
+ [Concluir multipart upload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)
+ [Anular carregamento fracionado](https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html)
+ [Listar partes](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html)
+ [Listar carregamentos fracionados](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html)
## API de multipart upload e permissões
Você deve ter as permissões necessárias para usar as operações do multipart upload. É possível usar listas de controle de acesso (ACLs), a política de bucket ou a política de usuário para conceder permissões às pessoas para realizar essas operações. A tabela a seguir lista as permissões necessárias para várias operações de multipart upload ao usar ACLs, uma política de bucket ou uma política de usuário.
| Ação | Permissões obrigatórias |
| --- | --- |
| Criar multipart upload | Você deve ter permissão para realizar a ação `s3:PutObject` em um objeto a fim de criar uma solicitação de upload fracionado. O proprietário do bucket pode permitir que outros principais realizem a ação `s3:PutObject`. |
| Iniciar multipart upload | Você deve ter permissão para realizar a ação `s3:PutObject` em um objeto a fim de inicializar um upload fracionado. O proprietário do bucket pode permitir que outros principais realizem a ação `s3:PutObject`. |
| Iniciador | O elemento de contêiner que identifica quem iniciou o multipart upload. Se o iniciador for uma Conta da AWS, esse elemento fornecerá as mesmas informações que o elemento Owner (Proprietário). Se o iniciador for um usuário do IAM, esse elemento fornecerá o ARN e o nome da exibição do usuário. |
| Carregar parte | Você deve ter permissão para realizar a ação `s3:PutObject` em um objeto para fazer upload de uma parte. O proprietário do bucket deve permitir que o iniciador realize a ação `s3:PutObject` em um objeto para que o iniciador possa fazer upload de uma parte desse objeto. |
| Carregar parte (Copiar) | Você deve ter permissão para realizar a ação `s3:PutObject` em um objeto para fazer upload de uma parte. Como você está fazendo upload de uma parte a partir de um objeto existente, deverá ter permissão `s3:GetObject` no objeto de origem. Para iniciador fazer upload de uma parte para um objeto, o proprietário do bucket deve permitir que o iniciador realize a ação `s3:PutObject` no objeto. |
| Concluir carregamento fracionado | Você deve ter permissão para realizar a ação `s3:PutObject` em um objeto para concluir o multipart upload. O proprietário do bucket deve permitir que o iniciador realize a ação `s3:PutObject` em um objeto para que o iniciador possa concluir um multipart upload desse objeto. |
| Parar o multipart upload | Você deve ter permissão para realizar a ação `s3:AbortMultipartUpload` em um objeto para interromper um multipart upload. Por padrão, o proprietário do bucket e o inicializador do upload fracionado têm permissão para executar essa ação como parte das políticas do IAM e de buckets do S3. Se o iniciador for um usuário do IAM, a Conta da AWS desse usuário também terá permissão para interromper o carregamento fracionado. Com as políticas de endpoint da VPC, o inicializador do upload fracionado não recebe automaticamente a permissão para executar a ação `s3:AbortMultipartUpload`. Além desses padrões, o proprietário do bucket pode permitir que outras entidades principais executem a ação `s3:AbortMultipartUpload` em um objeto. O proprietário do bucket pode negar que qualquer principal realize a ação `s3:AbortMultipartUpload`. |
| Listar partes | Você deve ter permissão para realizar a ação `s3:ListMultipartUploadParts` para listar partes em um multipart upload. Por padrão, o proprietário do bucket tem permissão para listar as partes de qualquer multipart upload para o bucket. O iniciador do multipart upload tem permissão para listar partes do multipart upload específico. Se o iniciador do carregamento fracionado for um usuário do IAM, a Conta da AWS que controla o usuário do IAM também terá permissão para listar partes desse carregamento. Além desses padrões, o proprietário do bucket pode permitir que outros principais executem a ação `s3:ListMultipartUploadParts` em um objeto. O proprietário do bucket também pode negar que qualquer principal realize a ação `s3:ListMultipartUploadParts`. |
| Listar multipart uploads | Você deve ter permissão para realizar a ação `s3:ListBucketMultipartUploads` em um bucket para listar multipart uploads em andamento no bucket. Além desse padrão, o proprietário do bucket pode permitir que outros principais executem a ação `s3:ListBucketMultipartUploads` no bucket. |
| AWS KMSPermissões relacionadas a criptografia e descriptografia do | Para executar um upload fracionado com criptografia usando uma chave do AWS Key Management Service (AWS KMS), o solicitante deve ter as seguintes permissões: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonS3/latest/userguide/mpuoverview.html) Essas permissões são necessárias porque o Amazon S3 precisa descriptografar e ler os dados de partes de arquivos criptografados antes de concluir o multipart upload. A permissão `kms:Decrypt` e a criptografia do lado do servidor com chaves de criptografia fornecidas pelo cliente também são necessárias para obter o valor da soma de verificação de um objeto. Se você não tiver essas permissões necessárias ao usar a API [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html), o objeto será criado sem um valor de soma de verificação. Se o seu usuário ou perfil do IAM estiver na mesma Conta da AWS que a chave do KMS, valide que você tem permissões nas políticas de chave e do IAM. Se o seu usuário ou a sua função do IAM pertencer a uma conta diferente da chave do KMS, será necessário ter as permissões na política da chave e no usuário ou na função do IAM. |
| SSE-C (criptografia do lado do servidor com chaves fornecidas pelo cliente) | Ao usar a API [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html), você deve fornecer a SSE-C (criptografia do lado do servidor com chaves de criptografia fornecidas pelo cliente), ou seu objeto será criado sem uma soma de verificação e nenhum valor de soma de verificação será retornado. |
Para obter informações sobre a relação entre permissões de ACL e permissões em políticas de acesso, consulte [Mapeamento das permissões da ACL e das permissões da política de acesso](acl-overview.md#acl-access-policy-permission-mapping). Para obter informações sobre os usuários do IAM e as práticas recomendadas, consulte [Identidades do IAM (usuários, grupos de usuários e perfis)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) no *Guia do usuário do IAM*.
## Somas de verificação com operações de carregamento fracionado
Há três APIs do Amazon S3 que são usadas para realizar o upload fracionado: [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html), [https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html) e [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html). A tabela a seguir indica quais cabeçalhos e valores de soma de verificação devem ser fornecidos para cada uma das APIs:
| Algoritmo da soma de verificação | Tipo de soma de verificação | `CreateMultipartUpload` | `UploadPart` | `CompleteMultipartUpoad` |
| --- | --- | --- | --- | --- |
| CRC-64/NVME (`CRC64NVME`) | Objeto inteiro | Cabeçalhos obrigatórios: `x-amz-checksum-algorithm` | Cabeçalhos opcionais: `x-amz-checksum-crc64nvme` | Cabeçalhos opcionais: `x-amz-checksum-algorithm` `x-amz-crc64` |
| CRC-32 (`CRC32`) CRC 32-C (`CRC32C`) | Objeto inteiro | Cabeçalhos obrigatórios: `x-amz-checksum-algorithm` `x-amz-checksum-type` | Cabeçalhos opcionais: `x-amz-checksum-crc64nvme` | Cabeçalhos opcionais: `x-amz-checksum-algorithm` `x-amz-crc32` `x-amz-crc32c` |
| CRC-32 (`CRC32`) CRC-32C (`CRC32C`) SHA-1 (`SHA1`) SHA-256 (`SHA256`) | Composto | Cabeçalhos obrigatórios: `x-amz-checksum-algorithm` | Cabeçalhos obrigatórios: `x-amz-checksum-crc32` `x-amz-checksum-crc32c` `x-amz-checksum-sha1` `x-amz-checksum-sha256` | Cabeçalhos obrigatórios: Todas as somas de verificação ao nível da parte precisam ser incluídas na solicitação `CompleteMultiPartUpload`. Cabeçalhos opcionais: `x-amz-crc32` `x-amz-crc32c` `x-amz-sha1` `x-amz-sha256` |
**Topics**
+ [Processo multipart upload](#mpu-process)
+ [Somas de verificação com operações de carregamento fracionado](#mpuchecksums)
+ [Operações simultâneas de multipart upload](#distributedmpupload)
+ [Impedir o upload de objetos com nomes de chave idênticos durante carregamentos fracionados](#multipart-upload-objects-with-same-key-name)
+ [Multipart upload e definição de preço](#mpuploadpricing)
+ [Suporte de API para multipart upload](#apisupportformpu)
+ [AWS Command Line InterfaceSuporte da para carregamento fracionado](#clisupportformpu)
+ [AWSSuporte do SDK para upload fracionado](#sdksupportformpu)
+ [API de multipart upload e permissões](#mpuAndPermissions)
+ [Somas de verificação com operações de carregamento fracionado](#Checksums-mpu-operations)
+ [Configurar uma política de ciclo de vida de bucket para anular uploads incompletos de várias partes](mpu-abort-incomplete-mpu-lifecycle-config.md)
+ [Fazer upload de um objeto usando multipart upload](mpu-upload-object.md)
+ [Carregar um diretório usando a classe TransferUtility .NET de alto nível](HLuploadDirDotNet.md)
+ [Listar multipart uploads](list-mpu.md)
+ [Monitorar um carregamento fracionado com os SDKs da AWS](track-mpu.md)
+ [Abortar um multipart upload](abort-mpu.md)
+ [Copiar um objeto usando multipart upload](CopyingObjectsMPUapi.md)
+ [Tutorial: Fazer upload de um objeto por meio do carregamento fracionado e conferir a integridade dos dados](tutorial-s3-mpu-additional-checksums.md)
+ [Limites do multipart upload do Amazon S3](qfacts.md)
# Configurar uma política de ciclo de vida de bucket para anular uploads incompletos de várias partes
Recomendamos que você configure uma regra de ciclo de vida usando a ação `AbortIncompleteMultipartUpload` para minimizar os custos de armazenamento. Para obter mais informações sobre como anular um multipart upload, consulte [Abortar um multipart upload](abort-mpu.md).
O Amazon S3 é compatível com uma regra de ciclo de vida de bucket que pode ser usada para fazer com que o Amazon S3 interrompa multipart uploads que não forem concluídos dentro de um número especificado de dias após a inicialização. Quando um multipart upload não é concluído dentro do prazo especificado, ele se torna elegível para uma operação de anulação. O Amazon S3 interrompe o multipart upload e exclui todas as partes associadas a ele. Essa regra se aplica tanto aos uploads multiparte existentes quanto aos que você criar posteriormente.
Veja a seguir um exemplo de configuração de ciclo de vida que especifica uma regra com a ação `AbortIncompleteMultipartUpload`.
```
sample-rule
Enabled
7
```
No exemplo, a regra não especifica um valor para o elemento `Prefix` (o [prefixo do nome da chave de objeto](https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#keyprefix)). Portanto, a regra se aplica a todos os objetos no bucket para o qual você iniciou multipart uploads. Multipart uploads que foram iniciados e não concluídos dentro de sete dias tornam-se elegíveis para uma operação de anulação. A ação de anulação não tem efeito em multipart uploads concluídos.
Para obter mais informações sobre a configuração do ciclo de vida de bucket, consulte [Gerenciar o ciclo de vida dos objetos](object-lifecycle-mgmt.md).
**nota**
Se o multipart upload for concluído durante o período de dias especificado na regra, a ação de ciclo de vida `AbortIncompleteMultipartUpload` não se aplicará (ou seja, o Amazon S3 não executará nenhuma ação). Além disso, essa ação não se aplica a objetos. Nenhum objeto é excluído por essa ação do ciclo de vida. Além disso, você não incorrerá em cobranças de exclusão antecipada do ciclo de vida do S3 ao remover qualquer parte incompleta do upload de várias partes.
## Usar o console do S3
Para gerenciar multipart uploads incompletos automaticamente, use o console do S3 para criar uma regra de ciclo de vida para expirar bytes de multipart uploads incompletos em um bucket após determinado número de dias. O procedimento a seguir mostra como adicionar uma regra de ciclo de vida para excluir multipart uploads incompletos depois de 7 dias. Para obter mais informações sobre como adicionar regras de ciclo de vida, consulte [Definir uma configuração do Ciclo de Vida do S3 em um bucket](how-to-set-lifecycle-configuration-intro.md).
**Como adicionar uma regra de ciclo de vida para anular multipart uploads incompletos há mais de 7 dias**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Na lista **Buckets**, escolha o nome do bucket para o qual você deseja criar uma regra de ciclo de vida.
1. Escolha a guia **Management (Gerenciamento)** e escolha **Create lifecycle rule (Criar regra de ciclo de vida)**.
1. Em **Lifecycle rule name (Nome da regra do ciclo de vida)**, insira um nome para sua regra.
O nome deve ser exclusivo dentro do bucket.
1. Escolha o escopo da regra do ciclo de vida:
+ Para criar uma regra de ciclo de vida para todos os objetos com um prefixo específico, escolha **Limit the scope of this rule using one or more filters** (Limitar o escopo desta regra usando um ou mais filtros) e insira o prefixo no campo **Prefix** (Prefixo).
+ Para criar uma regra de ciclo de vida para todos os objetos no bucket, escolha **This rule applies to **all** objects in the bucket** (Esta regra se aplica a todos os objetos no bucket) e escolha **I acknowledge that this rule applies to all objects in the bucket** (Eu reconheço que essa regra se aplica a todos os objetos no bucket).
1. Em **Lifecycle rule actions** (Ações da regra de ciclo de vida), selecione **Delete expired object delete markers or incomplete multipart uploads** (Excluir marcadores de exclusão de objetos expirados ou multipart uploads incompletos).
1. Em **Delete expired object delete markers or incomplete multipart uploads** (Excluir marcadores de exclusão de objetos expirados ou multipart uploads incompletos), escolha **Delete incomplete multipart uploads** (Excluir multipart uploads incompletos).
1. No campo **Number of days** (Número de dias), insira o número de dias depois dos quais os multipart uploads incompletos devem ser excluídos (por exemplo, 7 dias).
1. Escolha **Criar regra**.
## Como usar o AWS CLI
O comando `put-bucket-lifecycle-configuration` da AWS Command Line Interface (AWS CLI) a seguir adiciona a configuração de ciclo de vida para o bucket especificado. Para usar esse comando, substitua `user input placeholders` por suas informações.
```
aws s3api put-bucket-lifecycle-configuration \
--bucket amzn-s3-demo-bucket \
--lifecycle-configuration filename-containing-lifecycle-configuration
```
O exemplo a seguir mostra como adicionar uma regra de ciclo de vida para anular multipart uploads incompletos usando a AWS CLI. Ele inclui um exemplo de configuração de ciclo de vida JSON para anular multipart uploads incompletos há mais de 7 dias.
Para usar os comandos da CLI neste exemplo, substitua `user input placeholders` pelas suas informações.
**Como adicionar uma regra de ciclo de vida para anular multipart uploads incompletos**
1. Configurar a AWS CLI. Consulte instruções em [Developing with Amazon S3 using the AWS CLI](https://docs.aws.amazon.com/AmazonS3/latest/API/setup-aws-cli.html) na *Referência de API do Amazon S3*.
1. Salve o seguinte exemplo de configuração de ciclo de vida em um arquivo (por exemplo, *`lifecycle.json`*``). Esse exemplo de configuração especifica um prefixo vazio, portanto aplica-se a todos os objetos no bucket. Para restringir a configuração a um subconjunto de objetos, especifique um prefixo.
```
{
"Rules": [
{
"ID": "Test Rule",
"Status": "Enabled",
"Filter": {
"Prefix": ""
},
"AbortIncompleteMultipartUpload": {
"DaysAfterInitiation": 7
}
}
]
}
```
1. Execute o comando da CLI a seguir para definir essa configuração de ciclo de vida em seu bucket.
```
aws s3api put-bucket-lifecycle-configuration \
--bucket amzn-s3-demo-bucket \
--lifecycle-configuration file://lifecycle.json
```
1. Para verificar se a configuração de ciclo de vida foi definida no bucket, recupere a configuração de ciclo de vida usando o comando `get-bucket-lifecycle` a seguir.
```
aws s3api get-bucket-lifecycle \
--bucket amzn-s3-demo-bucket
```
1. Para excluir a configuração de ciclo de vida, use o comando `delete-bucket-lifecycle` a seguir.
```
aws s3api delete-bucket-lifecycle \
--bucket amzn-s3-demo-bucket
```
# Fazer upload de um objeto usando multipart upload
Você pode usar o multipart upload para fazer upload programático de um único objeto para o Amazon S3. Cada objeto é carregado como um conjunto de partes. Cada parte é uma parte contígua de dados do objeto. O upload dessas partes de objetos pode ser feito de maneira independente e em qualquer ordem. Se a transmissão de alguma parte falhar, você poderá retransmitir essa parte sem afetar outras partes. Depois que todas as partes do objeto forem carregadas, o Amazon S3 montará essas partes e criará o objeto. Usuários anônimos não podem iniciar carregamentos fracionados.
Consulte um procedimento completo sobre o upload de um objeto com carregamento fracionado e com uma soma de verificação adicional em [Tutorial: Fazer upload de um objeto por meio do carregamento fracionado e conferir a integridade dos dados](tutorial-s3-mpu-additional-checksums.md).
A seção a seguir mostra como usar o carregamento fracionado com a AWS Command Line Interface e os SDKs da AWS.
## Usar o console do S3
Você pode fazer upload de qualquer tipo de arquivo (imagens, backups, dados, filmes etc.) para um bucket do S3. O tamanho máximo de arquivo que você pode carregar usando o console do Amazon S3 é de 160 GB. Para fazer upload de um arquivo com mais de 160 GB, use a AWS Command Line Interface (AWS CLI), AWS SDKs ou a API REST do Amazon S3.
Para obter instruções sobre como fazer upload de um objeto pelo Console de gerenciamento da AWS, consulte [Fazer upload de objetos](upload-objects.md).
## Usar a AWS CLI
O conteúdo a seguir descreve as operações do Amazon S3 para carregamento fracionado usando a AWS CLI.
+ [Iniciar multipart upload](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/create-multipart-upload.html)
+ [Carregar parte](https://docs.aws.amazon.com/cli/latest/reference/s3api/upload-part.html)
+ [Carregar parte (copiar)](https://docs.aws.amazon.com/cli/latest/reference/s3api/upload-part-copy.html)
+ [Concluir multipart upload](https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html)
+ [Anular carregamento fracionado](https://docs.aws.amazon.com/cli/latest/reference/s3api/abort-multipart-upload.html)
+ [Listar partes](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html)
+ [Listar carregamentos fracionados](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-multipart-uploads.html)
## Uso da API REST
As seções a seguir na *Referência de APIs do Amazon Simple Storage Service* descrevem a API REST para multipart upload.
+ [Iniciar multipart upload](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)
+ [Carregar parte](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html)
+ [Concluir carregamento fracionado](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadComplete.html)
+ [Parar o multipart upload](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadAbort.html)
+ [Listar partes](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadListParts.html)
+ [Listar carregamentos fracionados](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadListMPUpload.html)
## Uso dos AWS SDKs (API de alto nível)
Alguns AWS SDKs expõem uma API de alto nível que simplifica o upload de várias partes combinando as diferentes operações de API necessárias para concluir um upload de várias partes em uma única operação. Para obter mais informações, consulte [Carregar e copiar objetos usando upload fracionado no Amazon S3](mpuoverview.md).
Se precisar pausar e retomar uploads de várias partes, variar os tamanhos das partes durante o upload ou se você não souber o tamanho necessário dos dados com antecedência, use os métodos da API de baixo nível. Os métodos de API de baixo nível para uploads de várias partes oferecem funcionalidades adicionais. Consulte mais informações em [Uso dos AWS SDKs (API de baixo nível)](#mpu-upload-low-level).
------
#### [ Java ]
Para ver exemplos de multipart upload com o AWS SDK para Java, consulte [Upload or download large files to and from Amazon S3 using an AWS SDK](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_Scenario_UsingLargeFiles_section.html) na *Referência de API do Amazon S3*.
------
#### [ .NET ]
Para fazer upload de um arquivo para um bucket do S3, use a classe `TransferUtility`. Ao fazer o upload de dados de um arquivo, você deve fornecer o nome da chave do objeto. Caso contrário, a API usará o nome do arquivo no lugar do nome da chave. Ao fazer o upload de dados de um fluxo, você deve fornecer o nome da chave do objeto.
Para definir opções de upload avançadas, como o tamanho da parte, o número de threads ao fazer upload das partes simultaneamente, os metadados, a classe de armazenamento, ou ACL, use a classe `TransferUtilityUploadRequest`.
**nota**
Quando você está usando um streaming na fonte dos dados, a classe `TransferUtility` não faz uploads simultâneos.
O exemplo de C\$1 a seguir faz upload de um arquivo em um bucket do Amazon S3 em várias partes. Ele mostra como usar várias sobrecargas de `TransferUtility.Upload` para fazer upload de um arquivo. Cada chamada sucessiva para upload substitui o upload anterior. Para obter informações sobre como configurar e executar exemplos de código, consulte [Conceitos básicos do AWS SDK for .NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) no *Guia do desenvolvedor do AWS SDK for .NET*.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Transfer;
using System;
using System.IO;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class UploadFileMPUHighLevelAPITest
{
private const string bucketName = "*** provide bucket name ***";
private const string keyName = "*** provide a name for the uploaded object ***";
private const string filePath = "*** provide the full path name of the file to upload ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
UploadFileAsync().Wait();
}
private static async Task UploadFileAsync()
{
try
{
var fileTransferUtility =
new TransferUtility(s3Client);
// Option 1. Upload a file. The file name is used as the object key name.
await fileTransferUtility.UploadAsync(filePath, bucketName);
Console.WriteLine("Upload 1 completed");
// Option 2. Specify object key name explicitly.
await fileTransferUtility.UploadAsync(filePath, bucketName, keyName);
Console.WriteLine("Upload 2 completed");
// Option 3. Upload data from a type of System.IO.Stream.
using (var fileToUpload =
new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
await fileTransferUtility.UploadAsync(fileToUpload,
bucketName, keyName);
}
Console.WriteLine("Upload 3 completed");
// Option 4. Specify advanced settings.
var fileTransferUtilityRequest = new TransferUtilityUploadRequest
{
BucketName = bucketName,
FilePath = filePath,
StorageClass = S3StorageClass.StandardInfrequentAccess,
PartSize = 6291456, // 6 MB.
Key = keyName,
CannedACL = S3CannedACL.PublicRead
};
fileTransferUtilityRequest.Metadata.Add("param1", "Value1");
fileTransferUtilityRequest.Metadata.Add("param2", "Value2");
await fileTransferUtility.UploadAsync(fileTransferUtilityRequest);
Console.WriteLine("Upload 4 completed");
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
------
#### [ JavaScript ]
**Example**
Faça upload de um arquivo grande.
```
import { S3Client } from "@aws-sdk/client-s3";
import { Upload } from "@aws-sdk/lib-storage";
import {
ProgressBar,
logger,
} from "@aws-doc-sdk-examples/lib/utils/util-log.js";
const twentyFiveMB = 25 * 1024 * 1024;
export const createString = (size = twentyFiveMB) => {
return "x".repeat(size);
};
/**
* Create a 25MB file and upload it in parts to the specified
* Amazon S3 bucket.
* @param {{ bucketName: string, key: string }}
*/
export const main = async ({ bucketName, key }) => {
const str = createString();
const buffer = Buffer.from(str, "utf8");
const progressBar = new ProgressBar({
description: `Uploading "${key}" to "${bucketName}"`,
barLength: 30,
});
try {
const upload = new Upload({
client: new S3Client({}),
params: {
Bucket: bucketName,
Key: key,
Body: buffer,
},
});
upload.on("httpUploadProgress", ({ loaded, total }) => {
progressBar.update({ current: loaded, total });
});
await upload.done();
} catch (caught) {
if (caught instanceof Error && caught.name === "AbortError") {
logger.error(`Multipart upload was aborted. ${caught.message}`);
} else {
throw caught;
}
}
};
```
**Example**
Baixe um arquivo grande.
```
import { fileURLToPath } from "node:url";
import { GetObjectCommand, NoSuchKey, S3Client } from "@aws-sdk/client-s3";
import { createWriteStream, rmSync } from "node:fs";
const s3Client = new S3Client({});
const oneMB = 1024 * 1024;
export const getObjectRange = ({ bucket, key, start, end }) => {
const command = new GetObjectCommand({
Bucket: bucket,
Key: key,
Range: `bytes=${start}-${end}`,
});
return s3Client.send(command);
};
/**
* @param {string | undefined} contentRange
*/
export const getRangeAndLength = (contentRange) => {
const [range, length] = contentRange.split("/");
const [start, end] = range.split("-");
return {
start: Number.parseInt(start),
end: Number.parseInt(end),
length: Number.parseInt(length),
};
};
export const isComplete = ({ end, length }) => end === length - 1;
const downloadInChunks = async ({ bucket, key }) => {
const writeStream = createWriteStream(
fileURLToPath(new URL(`./${key}`, import.meta.url)),
).on("error", (err) => console.error(err));
let rangeAndLength = { start: -1, end: -1, length: -1 };
while (!isComplete(rangeAndLength)) {
const { end } = rangeAndLength;
const nextRange = { start: end + 1, end: end + oneMB };
const { ContentRange, Body } = await getObjectRange({
bucket,
key,
...nextRange,
});
console.log(`Downloaded bytes ${nextRange.start} to ${nextRange.end}`);
writeStream.write(await Body.transformToByteArray());
rangeAndLength = getRangeAndLength(ContentRange);
}
};
/**
* Download a large object from and Amazon S3 bucket.
*
* When downloading a large file, you might want to break it down into
* smaller pieces. Amazon S3 accepts a Range header to specify the start
* and end of the byte range to be downloaded.
*
* @param {{ bucketName: string, key: string }}
*/
export const main = async ({ bucketName, key }) => {
try {
await downloadInChunks({
bucket: bucketName,
key: key,
});
} catch (caught) {
if (caught instanceof NoSuchKey) {
console.error(`Failed to download object. No such key "${key}".`);
rmSync(key);
}
}
};
```
------
#### [ Go ]
Se quiser ter mais informações sobre o exemplo de código Go para carregamento fracionado, consulte [Carregue ou baixe arquivos grandes de e para o Amazon S3 usando um AWS SDK](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_Scenario_UsingLargeFiles_section.html).
**Example**
Faça upload de um objeto grande usando um gerenciador de uploads para dividir os dados em partes e fazer upload delas simultaneamente.
```
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"log"
"os"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/feature/s3/manager"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/aws/aws-sdk-go-v2/service/s3/types"
"github.com/aws/smithy-go"
)
// BucketBasics encapsulates the Amazon Simple Storage Service (Amazon S3) actions
// used in the examples.
// It contains S3Client, an Amazon S3 service client that is used to perform bucket
// and object actions.
type BucketBasics struct {
S3Client *s3.Client
}
```
```
// UploadLargeObject uses an upload manager to upload data to an object in a bucket.
// The upload manager breaks large data into parts and uploads the parts concurrently.
func (basics BucketBasics) UploadLargeObject(ctx context.Context, bucketName string, objectKey string, largeObject []byte) error {
largeBuffer := bytes.NewReader(largeObject)
var partMiBs int64 = 10
uploader := manager.NewUploader(basics.S3Client, func(u *manager.Uploader) {
u.PartSize = partMiBs * 1024 * 1024
})
_, err := uploader.Upload(ctx, &s3.PutObjectInput{
Bucket: aws.String(bucketName),
Key: aws.String(objectKey),
Body: largeBuffer,
})
if err != nil {
var apiErr smithy.APIError
if errors.As(err, &apiErr) && apiErr.ErrorCode() == "EntityTooLarge" {
log.Printf("Error while uploading object to %s. The object is too large.\n"+
"The maximum size for a multipart upload is 5TB.", bucketName)
} else {
log.Printf("Couldn't upload large object to %v:%v. Here's why: %v\n",
bucketName, objectKey, err)
}
} else {
err = s3.NewObjectExistsWaiter(basics.S3Client).Wait(
ctx, &s3.HeadObjectInput{Bucket: aws.String(bucketName), Key: aws.String(objectKey)}, time.Minute)
if err != nil {
log.Printf("Failed attempt to wait for object %s to exist.\n", objectKey)
}
}
return err
}
```
**Example**
Faça download de um objeto grande usando um gerenciador de downloads para obter os dados em partes e baixá-las simultaneamente.
```
// DownloadLargeObject uses a download manager to download an object from a bucket.
// The download manager gets the data in parts and writes them to a buffer until all of
// the data has been downloaded.
func (basics BucketBasics) DownloadLargeObject(ctx context.Context, bucketName string, objectKey string) ([]byte, error) {
var partMiBs int64 = 10
downloader := manager.NewDownloader(basics.S3Client, func(d *manager.Downloader) {
d.PartSize = partMiBs * 1024 * 1024
})
buffer := manager.NewWriteAtBuffer([]byte{})
_, err := downloader.Download(ctx, buffer, &s3.GetObjectInput{
Bucket: aws.String(bucketName),
Key: aws.String(objectKey),
})
if err != nil {
log.Printf("Couldn't download large object from %v:%v. Here's why: %v\n",
bucketName, objectKey, err)
}
return buffer.Bytes(), err
}
```
------
#### [ PHP ]
Este tópico explica como usar a classe `Aws\S3\Model\MultipartUpload\UploadBuilder` de alto nível do AWS SDK para PHP para multipart uploads de arquivos. Para obter mais informações sobre a API do AWS SDK for Ruby, acesse [AWS SDK for Ruby Version 2](https://docs.aws.amazon.com/sdkforruby/api/index.html).
O exemplo de PHP a seguir faz upload de um arquivo em um bucket do Amazon S3. O exemplo demonstra como definir parâmetros para o objeto `MultipartUploader`.
```
require 'vendor/autoload.php';
use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Prepare the upload parameters.
$uploader = new MultipartUploader($s3, '/path/to/large/file.zip', [
'bucket' => $bucket,
'key' => $keyname
]);
// Perform the upload.
try {
$result = $uploader->upload();
echo "Upload complete: {$result['ObjectURL']}" . PHP_EOL;
} catch (MultipartUploadException $e) {
echo $e->getMessage() . PHP_EOL;
}
```
------
#### [ Python ]
O exemplo a seguir carrega um objeto usando a API do Python de multipart upload de alto nível (a classe `TransferManager`).
```
import sys
import threading
import boto3
from boto3.s3.transfer import TransferConfig
MB = 1024 * 1024
s3 = boto3.resource("s3")
class TransferCallback:
"""
Handle callbacks from the transfer manager.
The transfer manager periodically calls the __call__ method throughout
the upload and download process so that it can take action, such as
displaying progress to the user and collecting data about the transfer.
"""
def __init__(self, target_size):
self._target_size = target_size
self._total_transferred = 0
self._lock = threading.Lock()
self.thread_info = {}
def __call__(self, bytes_transferred):
"""
The callback method that is called by the transfer manager.
Display progress during file transfer and collect per-thread transfer
data. This method can be called by multiple threads, so shared instance
data is protected by a thread lock.
"""
thread = threading.current_thread()
with self._lock:
self._total_transferred += bytes_transferred
if thread.ident not in self.thread_info.keys():
self.thread_info[thread.ident] = bytes_transferred
else:
self.thread_info[thread.ident] += bytes_transferred
target = self._target_size * MB
sys.stdout.write(
f"\r{self._total_transferred} of {target} transferred "
f"({(self._total_transferred / target) * 100:.2f}%)."
)
sys.stdout.flush()
def upload_with_default_configuration(
local_file_path, bucket_name, object_key, file_size_mb
):
"""
Upload a file from a local folder to an Amazon S3 bucket, using the default
configuration.
"""
transfer_callback = TransferCallback(file_size_mb)
s3.Bucket(bucket_name).upload_file(
local_file_path, object_key, Callback=transfer_callback
)
return transfer_callback.thread_info
def upload_with_chunksize_and_meta(
local_file_path, bucket_name, object_key, file_size_mb, metadata=None
):
"""
Upload a file from a local folder to an Amazon S3 bucket, setting a
multipart chunk size and adding metadata to the Amazon S3 object.
The multipart chunk size controls the size of the chunks of data that are
sent in the request. A smaller chunk size typically results in the transfer
manager using more threads for the upload.
The metadata is a set of key-value pairs that are stored with the object
in Amazon S3.
"""
transfer_callback = TransferCallback(file_size_mb)
config = TransferConfig(multipart_chunksize=1 * MB)
extra_args = {"Metadata": metadata} if metadata else None
s3.Bucket(bucket_name).upload_file(
local_file_path,
object_key,
Config=config,
ExtraArgs=extra_args,
Callback=transfer_callback,
)
return transfer_callback.thread_info
def upload_with_high_threshold(local_file_path, bucket_name, object_key, file_size_mb):
"""
Upload a file from a local folder to an Amazon S3 bucket, setting a
multipart threshold larger than the size of the file.
Setting a multipart threshold larger than the size of the file results
in the transfer manager sending the file as a standard upload instead of
a multipart upload.
"""
transfer_callback = TransferCallback(file_size_mb)
config = TransferConfig(multipart_threshold=file_size_mb * 2 * MB)
s3.Bucket(bucket_name).upload_file(
local_file_path, object_key, Config=config, Callback=transfer_callback
)
return transfer_callback.thread_info
def upload_with_sse(
local_file_path, bucket_name, object_key, file_size_mb, sse_key=None
):
"""
Upload a file from a local folder to an Amazon S3 bucket, adding server-side
encryption with customer-provided encryption keys to the object.
When this kind of encryption is specified, Amazon S3 encrypts the object
at rest and allows downloads only when the expected encryption key is
provided in the download request.
"""
transfer_callback = TransferCallback(file_size_mb)
if sse_key:
extra_args = {"SSECustomerAlgorithm": "AES256", "SSECustomerKey": sse_key}
else:
extra_args = None
s3.Bucket(bucket_name).upload_file(
local_file_path, object_key, ExtraArgs=extra_args, Callback=transfer_callback
)
return transfer_callback.thread_info
def download_with_default_configuration(
bucket_name, object_key, download_file_path, file_size_mb
):
"""
Download a file from an Amazon S3 bucket to a local folder, using the
default configuration.
"""
transfer_callback = TransferCallback(file_size_mb)
s3.Bucket(bucket_name).Object(object_key).download_file(
download_file_path, Callback=transfer_callback
)
return transfer_callback.thread_info
def download_with_single_thread(
bucket_name, object_key, download_file_path, file_size_mb
):
"""
Download a file from an Amazon S3 bucket to a local folder, using a
single thread.
"""
transfer_callback = TransferCallback(file_size_mb)
config = TransferConfig(use_threads=False)
s3.Bucket(bucket_name).Object(object_key).download_file(
download_file_path, Config=config, Callback=transfer_callback
)
return transfer_callback.thread_info
def download_with_high_threshold(
bucket_name, object_key, download_file_path, file_size_mb
):
"""
Download a file from an Amazon S3 bucket to a local folder, setting a
multipart threshold larger than the size of the file.
Setting a multipart threshold larger than the size of the file results
in the transfer manager sending the file as a standard download instead
of a multipart download.
"""
transfer_callback = TransferCallback(file_size_mb)
config = TransferConfig(multipart_threshold=file_size_mb * 2 * MB)
s3.Bucket(bucket_name).Object(object_key).download_file(
download_file_path, Config=config, Callback=transfer_callback
)
return transfer_callback.thread_info
def download_with_sse(
bucket_name, object_key, download_file_path, file_size_mb, sse_key
):
"""
Download a file from an Amazon S3 bucket to a local folder, adding a
customer-provided encryption key to the request.
When this kind of encryption is specified, Amazon S3 encrypts the object
at rest and allows downloads only when the expected encryption key is
provided in the download request.
"""
transfer_callback = TransferCallback(file_size_mb)
if sse_key:
extra_args = {"SSECustomerAlgorithm": "AES256", "SSECustomerKey": sse_key}
else:
extra_args = None
s3.Bucket(bucket_name).Object(object_key).download_file(
download_file_path, ExtraArgs=extra_args, Callback=transfer_callback
)
return transfer_callback.thread_info
```
------
## Uso dos AWS SDKs (API de baixo nível)
O AWS SDK expõe uma API de baixo nível que se assemelha à API REST do Amazon S3 para carregamentos fracionados (consulte [Carregar e copiar objetos usando upload fracionado no Amazon S3](mpuoverview.md)). Use a API de baixo nível quando precisar pausar e retomar carregamentos fracionados, variar os tamanhos das partes durante o carregamento ou não souber o tamanho dos dados com antecedência. Quando esses requisitos não existirem, use a API de alto nível (consulte [Uso dos AWS SDKs (API de alto nível)](#multipart-upload-high-level)).
------
#### [ Java ]
O exemplo a seguir mostra como usar as classes Java de baixo nível para fazer upload de um arquivo. Ele realiza as seguintes etapas:
+ Inicia um multipart upload usando o método `AmazonS3Client.initiateMultipartUpload()`, e transmite a um objeto `InitiateMultipartUploadRequest`.
+ Salva o ID de upload retornado pelo método `AmazonS3Client.initiateMultipartUpload()`. Você fornece esse ID de upload para cada operação de multipart upload subsequente.
+ Faz upload das partes do objeto. Para cada parte, chame o método `AmazonS3Client.uploadPart()`. Você fornece informações sobre o upload da parte usando um objeto `UploadPartRequest`.
+ Para cada parte, você salva a ETag da resposta do método `AmazonS3Client.uploadPart()` em uma lista. Você usa os valores de ETag para concluir o multipart upload.
+ Chama o método `AmazonS3Client.completeMultipartUpload()` para concluir o multipart upload.
**Example**
Consulte instruções sobre como criar e testar uma amostra funcional em [Getting Started](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html) no Guia do desenvolvedor do AWS SDK para Java.
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.*;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class LowLevelMultipartUpload {
public static void main(String[] args) throws IOException {
Regions clientRegion = Regions.DEFAULT_REGION;
String bucketName = "*** Bucket name ***";
String keyName = "*** Key name ***";
String filePath = "*** Path to file to upload ***";
File file = new File(filePath);
long contentLength = file.length();
long partSize = 5 * 1024 * 1024; // Set part size to 5 MB.
try {
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withRegion(clientRegion)
.withCredentials(new ProfileCredentialsProvider())
.build();
// Create a list of ETag objects. You retrieve ETags for each object part
// uploaded,
// then, after each individual part has been uploaded, pass the list of ETags to
// the request to complete the upload.
List partETags = new ArrayList();
// Initiate the multipart upload.
InitiateMultipartUploadRequest initRequest = new InitiateMultipartUploadRequest(bucketName, keyName);
InitiateMultipartUploadResult initResponse = s3Client.initiateMultipartUpload(initRequest);
// Upload the file parts.
long filePosition = 0;
for (int i = 1; filePosition < contentLength; i++) {
// Because the last part could be less than 5 MB, adjust the part size as
// needed.
partSize = Math.min(partSize, (contentLength - filePosition));
// Create the request to upload a part.
UploadPartRequest uploadRequest = new UploadPartRequest()
.withBucketName(bucketName)
.withKey(keyName)
.withUploadId(initResponse.getUploadId())
.withPartNumber(i)
.withFileOffset(filePosition)
.withFile(file)
.withPartSize(partSize);
// Upload the part and add the response's ETag to our list.
UploadPartResult uploadResult = s3Client.uploadPart(uploadRequest);
partETags.add(uploadResult.getPartETag());
filePosition += partSize;
}
// Complete the multipart upload.
CompleteMultipartUploadRequest compRequest = new CompleteMultipartUploadRequest(bucketName, keyName,
initResponse.getUploadId(), partETags);
s3Client.completeMultipartUpload(compRequest);
} catch (AmazonServiceException e) {
// The call was transmitted successfully, but Amazon S3 couldn't process
// it, so it returned an error response.
e.printStackTrace();
} catch (SdkClientException e) {
// Amazon S3 couldn't be contacted for a response, or the client
// couldn't parse the response from Amazon S3.
e.printStackTrace();
}
}
}
```
------
#### [ .NET ]
O exemplo do C\$1 a seguir mostra como usar a API de multipart upload do SDK para .NET de nível baixo para fazer upload de um arquivo para um bucket do S3. Para obter informações sobre multipart uploads do Amazon S3, consulte [Carregar e copiar objetos usando upload fracionado no Amazon S3](mpuoverview.md).
**nota**
Ao usar a SDK para .NET API para fazer upload de objetos grandes, um tempo limite pode ocorrer mesmo quando os dados são gravados para o fluxo de solicitação. Você pode definir um tempo limite explícito usando o `UploadPartRequest`.
O exemplo do C\$1 a seguir faz upload de um arquivo para um bucket do S3 usando a API de multipart upload de nível baixo. Para obter informações sobre como configurar e executar exemplos de código, consulte [Conceitos básicos do AWS SDK for .NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) no *Guia do desenvolvedor do AWS SDK for .NET*.
```
using Amazon;
using Amazon.Runtime;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class UploadFileMPULowLevelAPITest
{
private const string bucketName = "*** provide bucket name ***";
private const string keyName = "*** provide a name for the uploaded object ***";
private const string filePath = "*** provide the full path name of the file to upload ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
Console.WriteLine("Uploading an object");
UploadObjectAsync().Wait();
}
private static async Task UploadObjectAsync()
{
// Create list to store upload part responses.
List uploadResponses = new List();
// Setup information required to initiate the multipart upload.
InitiateMultipartUploadRequest initiateRequest = new InitiateMultipartUploadRequest
{
BucketName = bucketName,
Key = keyName
};
// Initiate the upload.
InitiateMultipartUploadResponse initResponse =
await s3Client.InitiateMultipartUploadAsync(initiateRequest);
// Upload parts.
long contentLength = new FileInfo(filePath).Length;
long partSize = 5 * (long)Math.Pow(2, 20); // 5 MB
try
{
Console.WriteLine("Uploading parts");
long filePosition = 0;
for (int i = 1; filePosition < contentLength; i++)
{
UploadPartRequest uploadRequest = new UploadPartRequest
{
BucketName = bucketName,
Key = keyName,
UploadId = initResponse.UploadId,
PartNumber = i,
PartSize = partSize,
FilePosition = filePosition,
FilePath = filePath
};
// Track upload progress.
uploadRequest.StreamTransferProgress +=
new EventHandler(UploadPartProgressEventCallback);
// Upload a part and add the response to our list.
uploadResponses.Add(await s3Client.UploadPartAsync(uploadRequest));
filePosition += partSize;
}
// Setup to complete the upload.
CompleteMultipartUploadRequest completeRequest = new CompleteMultipartUploadRequest
{
BucketName = bucketName,
Key = keyName,
UploadId = initResponse.UploadId
};
completeRequest.AddPartETags(uploadResponses);
// Complete the upload.
CompleteMultipartUploadResponse completeUploadResponse =
await s3Client.CompleteMultipartUploadAsync(completeRequest);
}
catch (Exception exception)
{
Console.WriteLine("An AmazonS3Exception was thrown: { 0}", exception.Message);
// Abort the upload.
AbortMultipartUploadRequest abortMPURequest = new AbortMultipartUploadRequest
{
BucketName = bucketName,
Key = keyName,
UploadId = initResponse.UploadId
};
await s3Client.AbortMultipartUploadAsync(abortMPURequest);
}
}
public static void UploadPartProgressEventCallback(object sender, StreamTransferProgressArgs e)
{
// Process event.
Console.WriteLine("{0}/{1}", e.TransferredBytes, e.TotalBytes);
}
}
}
```
------
#### [ PHP ]
Este tópico mostra como usar o método de baixo nível `uploadPart`, da versão 3 do AWS SDK para PHP, para carregar um arquivo em várias partes. Para obter mais informações sobre a API do AWS SDK for Ruby, acesse [AWS SDK for Ruby Version 2](https://docs.aws.amazon.com/sdkforruby/api/index.html).
O exemplo de PHP a seguir faz upload de um arquivo para um bucket do Amazon S3 usando o multipart upload da API de baixo nível do PHP.
```
require 'vendor/autoload.php';
use Aws\S3\Exception\S3Exception;
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';
$filename = '*** Path to and Name of the File to Upload ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
$result = $s3->createMultipartUpload([
'Bucket' => $bucket,
'Key' => $keyname,
'StorageClass' => 'REDUCED_REDUNDANCY',
'Metadata' => [
'param1' => 'value 1',
'param2' => 'value 2',
'param3' => 'value 3'
]
]);
$uploadId = $result['UploadId'];
// Upload the file in parts.
try {
$file = fopen($filename, 'r');
$partNumber = 1;
while (!feof($file)) {
$result = $s3->uploadPart([
'Bucket' => $bucket,
'Key' => $keyname,
'UploadId' => $uploadId,
'PartNumber' => $partNumber,
'Body' => fread($file, 5 * 1024 * 1024),
]);
$parts['Parts'][$partNumber] = [
'PartNumber' => $partNumber,
'ETag' => $result['ETag'],
];
$partNumber++;
echo "Uploading part $partNumber of $filename." . PHP_EOL;
}
fclose($file);
} catch (S3Exception $e) {
$result = $s3->abortMultipartUpload([
'Bucket' => $bucket,
'Key' => $keyname,
'UploadId' => $uploadId
]);
echo "Upload of $filename failed." . PHP_EOL;
}
// Complete the multipart upload.
$result = $s3->completeMultipartUpload([
'Bucket' => $bucket,
'Key' => $keyname,
'UploadId' => $uploadId,
'MultipartUpload' => $parts,
]);
$url = $result['Location'];
echo "Uploaded $filename to $url." . PHP_EOL;
```
------
## Usar a AWS SDK para Ruby
O AWS SDK para Ruby versão 3 é compatível com carregamentos fracionados do Amazon S3 de duas formas. Para a primeira opção, é possível usar uploads de arquivos gerenciados. Para obter mais informações, consulte [Uploading Files to Amazon S3](https://aws.amazon.com/blogs/developer/uploading-files-to-amazon-s3/) no *Blog do desenvolvedor da AWS*. O upload de arquivos gerenciado é o método recomendado para fazer upload de arquivos em um bucket. Eles fornecem os seguintes benefícios:
+ Gerenciam multipart uploads para objetos com mais de 15 MB.
+ Abrem corretamente arquivos em modo binário para evitar problemas de codificação.
+ Usam vários threads para upload de partes de grandes objetos em paralelo.
Como alternativa, você pode usar as seguintes operações de cliente do multipart upload diretamente:
+ [create\$1multipart\$1upload](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#create_multipart_upload-instance_method): inicia um multipart upload e retorna um ID de upload.
+ [upload\$1part](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#upload_part-instance_method): faz upload de uma parte em um multipart upload.
+ [upload\$1part\$1copy](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#upload_part_copy-instance_method):f az upload de uma parte copiando dados de um objeto existente como a fonte de dados.
+ [complete\$1multipart\$1upload](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#complete_multipart_upload-instance_method): conclui um multipart upload montando as partes obtidas por upload anteriormente.
+ [abort\$1multipart\$1upload](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#abort_multipart_upload-instance_method): interrompe um multipart upload.
# Carregar um diretório usando a classe TransferUtility .NET de alto nível
Você pode usar a classe `TransferUtility` para fazer upload de um diretório inteiro. Por padrão, a API faz upload somente dos arquivos na raiz do diretório especificado. No entanto, você pode especificar um upload recursivo dos arquivos em todos os subdiretórios.
Para selecionar arquivos no diretório especificado, com base nos critérios de filtragem, especifique expressões de filtragem. Por exemplo, para fazer upload somente dos arquivos `PDF` de um diretório, especifique a expressão de filtragem `"*.pdf"`.
Ao fazer upload de arquivos de um diretório, você não especifica os nomes da chave para os objetos resultantes. O Amazon S3 cria os nomes de chave usando o caminho original do arquivo. Por exemplo, suponha que você tem um diretório denominado `c:\myfolder` com a seguinte estrutura:
**Example**
```
1. C:\myfolder
2. \a.txt
3. \b.pdf
4. \media\
5. An.mp3
```
quando você faz upload desse diretório, o Amazon S3 usa os seguintes nomes de chave:
**Example**
```
1. a.txt
2. b.pdf
3. media/An.mp3
```
**Example**
O exemplo de C\$1 a seguir faz upload de um diretório em um bucket do Amazon S3. Ele mostra como usar várias sobrecargas de `TransferUtility.UploadDirectory` para fazer upload do diretório. Cada chamada sucessiva para upload substitui o upload anterior. Para obter informações sobre como configurar e executar exemplos de código, consulte [Conceitos básicos do AWS SDK for .NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) no *Guia do desenvolvedor do AWS SDK for .NET*.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Transfer;
using System;
using System.IO;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class UploadDirMPUHighLevelAPITest
{
private const string existingBucketName = "*** bucket name ***";
private const string directoryPath = @"*** directory path ***";
// The example uploads only .txt files.
private const string wildCard = "*.txt";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
UploadDirAsync().Wait();
}
private static async Task UploadDirAsync()
{
try
{
var directoryTransferUtility =
new TransferUtility(s3Client);
// 1. Upload a directory.
await directoryTransferUtility.UploadDirectoryAsync(directoryPath,
existingBucketName);
Console.WriteLine("Upload statement 1 completed");
// 2. Upload only the .txt files from a directory
// and search recursively.
await directoryTransferUtility.UploadDirectoryAsync(
directoryPath,
existingBucketName,
wildCard,
SearchOption.AllDirectories);
Console.WriteLine("Upload statement 2 completed");
// 3. The same as Step 2 and some optional configuration.
// Search recursively for .txt files to upload.
var request = new TransferUtilityUploadDirectoryRequest
{
BucketName = existingBucketName,
Directory = directoryPath,
SearchOption = SearchOption.AllDirectories,
SearchPattern = wildCard
};
await directoryTransferUtility.UploadDirectoryAsync(request);
Console.WriteLine("Upload statement 3 completed");
}
catch (AmazonS3Exception e)
{
Console.WriteLine(
"Error encountered ***. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine(
"Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
# Listar multipart uploads
É possível usar a AWS CLI, a API REST ou os SDKs da AWS para recuperar uma lista de carregamentos fracionados em andamento no Amazon S3. Você pode usar o multipart upload para fazer upload programático de um único objeto para o Amazon S3. Carregamentos fracionados movem objetos para o Amazon S3 movendo uma parte dos dados de um objeto por vez. Consulte mais informações gerais sobre carregamentos fracionados em [Carregar e copiar objetos usando upload fracionado no Amazon S3](mpuoverview.md).
Consulte um procedimento completo sobre o upload de um objeto com carregamento fracionado e com uma soma de verificação adicional em [Tutorial: Fazer upload de um objeto por meio do carregamento fracionado e conferir a integridade dos dados](tutorial-s3-mpu-additional-checksums.md).
A seção a seguir mostra como listar carregamentos fracionados em andamento com a AWS Command Line Interface, a API REST do Amazon S3 e os SDKs da AWS.
## Listagem de carregamentos fracionados usando a AWS CLI
As seções a seguir na AWS Command Line Interface descrevem as operações de listagem de carregamentos fracionados.
+ [list-parts](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/list-parts.html): liste as partes enviadas por upload de um multipart upload específico.
+ [list-multipart-uploads](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-multipart-uploads.html): liste multipart uploads em andamento.
# Listar multipart uploads usando a API REST
As seções a seguir na *Referência de APIs do Amazon Simple Storage Service* descrevem a API REST para listagem de multipart uploads:
+ [ListParts](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html)‐lista as partes enviadas por upload de um multipart upload específico.
+ [ListMultipartUploads](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html) lista multipart uploads em andamento.
## Listagem de uploads fracionados usando o AWS SDK (API de baixo nível)
------
#### [ Java ]
Para listar todos os multipart uploads em andamento em um bucket usando o AWS SDK para Java, você pode usar as classes de API de baixo nível para:
**Processo de listagem de multipart uploads da API de baixo nível**
| | |
| --- |--- |
| 1 | Crie uma instância da classe `ListMultipartUploadsRequest` e forneça o nome do bucket. |
| 2 | Executar o método `listMultipartUploads` da S3Client. O método retorna uma instância da classe `ListMultipartUploadsResponse` que fornece informações sobre os multipart uploads em andamento. |
Para ver exemplos de como listar multipart uploads com o AWS SDK para Java, consulte [List multipart uploads](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_ListMultipartUploads_section.html) na *Referência de API do Amazon S3*.
------
#### [ .NET ]
Para listar todos os multipart uploads em andamento em um bucket específico, use a classe SDK para .NET da API de multipart upload do `ListMultipartUploadsRequest` de nível baixo. O `AmazonS3Client.ListMultipartUploads` método retorna uma instância da classe `ListMultipartUploadsResponse` que fornece informações sobre multipart uploads em andamento.
Um multipart upload em andamento é um multipart upload que foi iniciado com o uso da solicitação para iniciar o multipart upload, mas que ainda não foi concluído ou parado. Para obter mais informações sobre multipart uploads do Amazon S3, consulte [Carregar e copiar objetos usando upload fracionado no Amazon S3](mpuoverview.md).
O exemplo do C\$1 a seguir mostra como usar o SDK para .NET para listar todos os multipart uploads em andamento em um bucket. Para obter informações sobre como configurar e executar exemplos de código, consulte [Conceitos básicos do AWS SDK for .NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) no *Guia do desenvolvedor do AWS SDK for .NET*.
```
ListMultipartUploadsRequest request = new ListMultipartUploadsRequest
{
BucketName = bucketName // Bucket receiving the uploads.
};
ListMultipartUploadsResponse response = await AmazonS3Client.ListMultipartUploadsAsync(request);
```
------
#### [ PHP ]
Este tópico mostra como usar as classes da API de baixo nível da versão 3 do AWS SDK para PHP para listar todos os multipart uploads em andamento em um bucket. Para obter mais informações sobre a API do AWS SDK for Ruby, acesse [AWS SDK for Ruby Version 2](https://docs.aws.amazon.com/sdkforruby/api/index.html).
O exemplo de PHP a seguir demonstra a listagem de todos os multipart uploads em andamento em um bucket.
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Retrieve a list of the current multipart uploads.
$result = $s3->listMultipartUploads([
'Bucket' => $bucket
]);
// Write the list of uploads to the page.
print_r($result->toArray());
```
------
# Monitorar um carregamento fracionado com os SDKs da AWS
É possível monitorar o progresso do upload de um objeto para o Amazon S3 com uma interface de escuta. A API de carregamento fracionado de alto nível fornece essa interface de escuta, chamada `ProgressListener`. Os eventos de progresso ocorrem periodicamente e notificam o listener que os bytes foram transferidos. Consulte mais informações gerais sobre carregamentos fracionados em [Carregar e copiar objetos usando upload fracionado no Amazon S3](mpuoverview.md).
Consulte um procedimento completo sobre o upload de um objeto com carregamento fracionado e com uma soma de verificação adicional em [Tutorial: Fazer upload de um objeto por meio do carregamento fracionado e conferir a integridade dos dados](tutorial-s3-mpu-additional-checksums.md).
A seção a seguir mostra como monitorar um carregamento fracionado com os SDKs da AWS.
------
#### [ Java ]
**Example**
O código Java a seguir faz upload de um arquivo e usa `ExecutionInterceptor` para rastrear o progresso do upload. Consulte instruções sobre como criar e testar uma amostra funcional em [Getting Started](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html) no Guia do desenvolvedor do AWS SDK para Java 2.x.
```
import java.nio.file.Paths;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.interceptor.Context;
import software.amazon.awssdk.core.interceptor.ExecutionAttributes;
import software.amazon.awssdk.core.interceptor.ExecutionInterceptor;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
public class TrackMPUProgressUsingHighLevelAPI {
static class ProgressListener implements ExecutionInterceptor {
private long transferredBytes = 0;
@Override
public void beforeTransmission(Context.BeforeTransmission context, ExecutionAttributes executionAttributes) {
if (context.httpRequest().firstMatchingHeader("Content-Length").isPresent()) {
String contentLength = context.httpRequest().firstMatchingHeader("Content-Length").get();
long partSize = Long.parseLong(contentLength);
transferredBytes += partSize;
System.out.println("Transferred bytes: " + transferredBytes);
}
}
}
public static void main(String[] args) throws Exception {
String existingBucketName = "*** Provide bucket name ***";
String keyName = "*** Provide object key ***";
String filePath = "*** file to upload ***";
S3AsyncClient s3Client = S3AsyncClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create())
.overrideConfiguration(c -> c.addExecutionInterceptor(new ProgressListener()))
.build();
// For more advanced uploads, you can create a request object
// and supply additional request parameters (ex: progress listeners,
// canned ACLs, etc.)
PutObjectRequest request = PutObjectRequest.builder()
.bucket(existingBucketName)
.key(keyName)
.build();
AsyncRequestBody requestBody = AsyncRequestBody.fromFile(Paths.get(filePath));
// You can ask the upload for its progress, or you can
// add a ProgressListener to your request to receive notifications
// when bytes are transferred.
// S3AsyncClient processes all transfers asynchronously,
// so this call will return immediately.
var upload = s3Client.putObject(request, requestBody);
try {
// You can block and wait for the upload to finish
upload.join();
} catch (Exception exception) {
System.out.println("Unable to upload file, upload aborted.");
exception.printStackTrace();
} finally {
s3Client.close();
}
}
}
```
------
#### [ .NET ]
O seguinte exemplo do C\$1 faz upload de um arquivo em um bucket do S3 usando a classe `TransferUtility` e monitora o andamento do upload. Para obter informações sobre como configurar e executar exemplos de código, consulte [Conceitos básicos do AWS SDK for .NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) no *Guia do desenvolvedor do AWS SDK for .NET*.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Transfer;
using System;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class TrackMPUUsingHighLevelAPITest
{
private const string bucketName = "*** provide the bucket name ***";
private const string keyName = "*** provide the name for the uploaded object ***";
private const string filePath = " *** provide the full path name of the file to upload **";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
TrackMPUAsync().Wait();
}
private static async Task TrackMPUAsync()
{
try
{
var fileTransferUtility = new TransferUtility(s3Client);
// Use TransferUtilityUploadRequest to configure options.
// In this example we subscribe to an event.
var uploadRequest =
new TransferUtilityUploadRequest
{
BucketName = bucketName,
FilePath = filePath,
Key = keyName
};
uploadRequest.UploadProgressEvent +=
new EventHandler
(uploadRequest_UploadPartProgressEvent);
await fileTransferUtility.UploadAsync(uploadRequest);
Console.WriteLine("Upload completed");
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
static void uploadRequest_UploadPartProgressEvent(object sender, UploadProgressArgs e)
{
// Process event.
Console.WriteLine("{0}/{1}", e.TransferredBytes, e.TotalBytes);
}
}
}
```
------
# Abortar um multipart upload
Após iniciar um multipart upload, você começa a fazer upload de partes. O Amazon S3 armazena essas partes, cria o objeto somente após o carregamento de todas as partes e envia uma solicitação para concluir o carregamento fracionado. Ao receber a solicitação para concluir o multipart upload, o Amazon S3 monta as partes e cria um objeto. Se você não enviar a solicitação de conclusão do carregamento fracionado, o S3 não montará as partes e não criará nenhum objeto. Se você não quiser concluir um carregamento fracionado após o upload das partes, anule o carregamento fracionado.
Você é cobrado por todo o armazenamento associado a partes enviadas por upload. É recomendável sempre concluir ou interromper o carregamento fracionado para remover todas as partes carregadas. Para obter mais informações sobre os preços da , consulte [Multipart upload e definição de preço](mpuoverview.md#mpuploadpricing).
Você também pode interromper um upload incompleto de várias partes usando uma configuração de ciclo de vida do bucket. Para obter mais informações, consulte [Configurar uma política de ciclo de vida de bucket para anular uploads incompletos de várias partes](mpu-abort-incomplete-mpu-lifecycle-config.md).
A seção a seguir mostra como interromper um carregamento fracionado em andamento no Amazon S3 usando a AWS Command Line Interface, a API REST ou os SDKs da AWS.
## Como usar o AWS CLI
Para obter mais informações sobre o uso da AWS CLI para interromper um upload fracionado, consulte [abort-multipart-upload](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/abort-multipart-upload.html) na *Referência de comandos da AWS CLI*.
## Uso da API REST
Para obter mais informações sobre o uso da API REST para interromper um multipart upload, consulte [AbortMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html) na *Referência da API do Amazon Simple Storage Service*.
## Uso dos AWS SDKs (API de alto nível)
------
#### [ Java ]
Para interromper o andamento de multipart uploads usando o AWS SDK para Java, é possível cancelar os uploads que foram iniciados antes de uma data especificada e ainda estão em andamento. Um upload é considerado como em andamento depois que você o inicia até ser concluído ou parado.
Para interromper os multipart uploads, você pode:
| | |
| --- |--- |
| 1 | Criar uma instância da S3Client. |
| 2 | Use os métodos de cancelamento do cliente passando o nome do bucket e outros parâmetros necessários. |
**nota**
Você também pode parar um multipart upload específico. Para obter mais informações, consulte [Uso dos AWS SDKs (API de baixo nível)](#abort-mpu-low-level).
Para ver exemplos de como cancelar multipart uploads com o AWS SDK para Java, consulte [Cancel a multipart upload](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_AbortMultipartUpload_section.html) na *Referência de API do Amazon S3*.
------
#### [ .NET ]
O exemplo do C\$1 a seguir interrompe todos os multipart uploads em andamento que foram iniciados em um bucket específico há uma semana. Para obter informações sobre como configurar e executar exemplos de código, consulte [Conceitos básicos do AWS SDK for .NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) no *Guia do desenvolvedor do AWS SDK for .NET*.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Transfer;
using System;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class AbortMPUUsingHighLevelAPITest
{
private const string bucketName = "*** provide bucket name ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
AbortMPUAsync().Wait();
}
private static async Task AbortMPUAsync()
{
try
{
var transferUtility = new TransferUtility(s3Client);
// Abort all in-progress uploads initiated before the specified date.
await transferUtility.AbortMultipartUploadsAsync(
bucketName, DateTime.Now.AddDays(-7));
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
**nota**
Você também pode parar um multipart upload específico. Para obter mais informações, consulte [Uso dos AWS SDKs (API de baixo nível)](#abort-mpu-low-level).
------
## Uso dos AWS SDKs (API de baixo nível)
É possível interromper um multipart upload em andamento chamando o método `AmazonS3.abortMultipartUpload`. Esse método exclui todas as partes que foram carregadas no Amazon S3 e libera os recursos. Você deve fornecer o ID do upload, o nome do bucket e o nome da chave. O código Java de exemplo a seguir demonstra como interromper um multipart upload em andamento.
Para parar um multipart upload, é preciso fornecer o ID de upload e nomes do bucket e da chave usados no upload. Após parar um multipart upload, não é possível usar o ID de upload para fazer upload de partes adicionais. Para obter mais informações sobre multipart uploads do Amazon S3, consulte [Carregar e copiar objetos usando upload fracionado no Amazon S3](mpuoverview.md).
------
#### [ Java ]
Para interromper um multipart upload específico em andamento usando o AWS SDK para Java, use a API de baixo nível para cancelar o upload fornecendo o nome do bucket, a chave do objeto e o ID do upload.
**nota**
Em vez de cancelar um multipart upload específico, você pode interromper todos os multipart iniciados antes de uma determinada hora que ainda estiverem em andamento. Essa operação de limpeza é útil para interromper multipart uploads antigos que você iniciou, mas não concluiu ou parou. Para obter mais informações, consulte [Uso dos AWS SDKs (API de alto nível)](#abort-mpu-high-level).
Para ver exemplos de como cancelar um multipart upload específico com o AWS SDK para Java, consulte [Cancel a multipart upload](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_AbortMultipartUpload_section.html) na *Referência de API do Amazon S3*.
------
#### [ .NET ]
O exemplo do C\$1 a seguir mostra como parar um multipart upload. Para um exemplo do C\$1 completo que inclui o código seguinte, consulte [Uso dos AWS SDKs (API de baixo nível)](mpu-upload-object.md#mpu-upload-low-level).
```
AbortMultipartUploadRequest abortMPURequest = new AbortMultipartUploadRequest
{
BucketName = existingBucketName,
Key = keyName,
UploadId = initResponse.UploadId
};
await AmazonS3Client.AbortMultipartUploadAsync(abortMPURequest);
```
Você também pode anular todos os multipart uploads em andamento que foram iniciados antes de um horário específico. Essa operação de limpeza é útil para anular os multipart uploads que não foram concluídos nem anulados. Para obter mais informações, consulte [Uso dos AWS SDKs (API de alto nível)](#abort-mpu-high-level).
------
#### [ PHP ]
Este exemplo descreve como usar uma classe da versão 3 do AWS SDK para PHP para anular um carregamento fracionado que está em andamento. Para obter mais informações sobre a API do AWS SDK for Ruby, acesse [AWS SDK for Ruby Version 2](https://docs.aws.amazon.com/sdkforruby/api/index.html). O exemplo do método `abortMultipartUpload()`.
Para obter mais informações sobre a API do AWS SDK for Ruby, acesse [AWS SDK for Ruby Version 2](https://docs.aws.amazon.com/sdkforruby/api/index.html).
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';
$uploadId = '*** Upload ID of upload to Abort ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Abort the multipart upload.
$s3->abortMultipartUpload([
'Bucket' => $bucket,
'Key' => $keyname,
'UploadId' => $uploadId,
]);
```
------
# Copiar um objeto usando multipart upload
O carregamento fracionado permite copiar objetos como um conjunto de partes. Os exemplos nesta seção mostram como copiar objetos maiores que 5 GB usando a API de multipart upload. Consulte informações sobre carregamentos fracionados em [Carregar e copiar objetos usando upload fracionado no Amazon S3](mpuoverview.md).
É possível copiar objetos com menos de 5 GB em uma única operação sem usar a API de carregamento fracionado. É possível copiar objetos com menos de 5 GB usando o Console de gerenciamento da AWS, a AWS CLI, a API REST ou SDKs da AWS. Para obter mais informações, consulte [Copiar, mover e renomear objetos](copy-object.md).
Consulte um procedimento completo sobre o upload de um objeto com carregamento fracionado e com uma soma de verificação adicional em [Tutorial: Fazer upload de um objeto por meio do carregamento fracionado e conferir a integridade dos dados](tutorial-s3-mpu-additional-checksums.md).
A seção a seguir mostra como copiar um objeto com carregamento fracionado usando a API REST ou SDKs da AWS.
## Uso da API REST
As seções a seguir na *Referência de APIs do Amazon Simple Storage Service* descrevem a API REST para multipart upload. Para copiar um objeto existente, use a API para upload de parte (cópia) e especifique o objeto de origem adicionando o cabeçalho de solicitação `x-amz-copy-source` na solicitação.
+ [Iniciar multipart upload](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)
+ [Carregar parte](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html)
+ [Carregar parte (copiar)](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPartCopy.html)
+ [Concluir multipart upload](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadComplete.html)
+ [Anular carregamento fracionado](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadAbort.html)
+ [Listar partes](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadListParts.html)
+ [Listar carregamentos fracionados](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadListMPUpload.html)
Use essas APIs para fazer suas próprias solicitações REST ou use um dos SDKs que fornecemos. Para obter mais informações sobre como usar o multipart upload com a AWS CLI, consulte [Usar a AWS CLI](mpu-upload-object.md#UsingCLImpUpload). Para obter mais informações sobre o recurso SDKs, consulte [AWSSuporte do SDK para upload fracionado](mpuoverview.md#sdksupportformpu).
## Uso da SDKs AWS
Para copiar um objeto usando a API de baixo nível, faça o seguinte:
+ Inicie um multipart upload chamando o método `AmazonS3Client.initiateMultipartUpload()`.
+ Salve o ID de upload do objeto de resposta retornado pelo método `AmazonS3Client.initiateMultipartUpload()`. Você fornece esse ID de upload para cada operação do upload de parte.
+ Copie todas as partes. Para cada parte que você precisar copiar, crie uma nova instância da classe `CopyPartRequest`. Forneça as informações da parte, incluindo a origem e os nomes do bucket de destino, as chaves de objeto de origem e de destino, o ID de upload, os locais dos primeiros e últimos bytes da parte, e o número da parte.
+ Salve as respostas das chamadas de método `AmazonS3Client.copyPart()`. Cada resposta inclui o valor `ETag` e o número da parte para a parte cujo upload foi feito. Você precisa dessas informações para concluir o multipart upload.
+ Chame o método `AmazonS3Client.completeMultipartUpload()` para concluir a operação de cópia.
------
#### [ Java ]
Para obter exemplos de como copiar objetos usando o multipart upload com o AWS SDK para Java, consulte [Copy part of an object from another object](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_UploadPartCopy_section.html) na *Referência de API do Amazon S3*.
------
#### [ .NET ]
O exemplo em C\$1 a seguir mostra como usar o SDK para .NET para copiar um objeto do Amazon S3 com mais de 5 GB de um local de origem para outro, como de um bucket para outro. Para copiar objetos menores que 5 GB, use um procedimento de cópia de operação única descrita em [Usar SDKs da AWS](copy-object.md#CopyingObjectsUsingSDKs). Para obter mais informações sobre multipart uploads do Amazon S3, consulte [Carregar e copiar objetos usando upload fracionado no Amazon S3](mpuoverview.md).
Este exemplo mostra como copiar um objeto do Amazon S3 com mais de 5 GB de um bucket do S3 para outro usando a API de carregamento fracionado do SDK para .NET.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class CopyObjectUsingMPUapiTest
{
private const string sourceBucket = "*** provide the name of the bucket with source object ***";
private const string targetBucket = "*** provide the name of the bucket to copy the object to ***";
private const string sourceObjectKey = "*** provide the name of object to copy ***";
private const string targetObjectKey = "*** provide the name of the object copy ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
Console.WriteLine("Copying an object");
MPUCopyObjectAsync().Wait();
}
private static async Task MPUCopyObjectAsync()
{
// Create a list to store the upload part responses.
List uploadResponses = new List();
List copyResponses = new List();
// Setup information required to initiate the multipart upload.
InitiateMultipartUploadRequest initiateRequest =
new InitiateMultipartUploadRequest
{
BucketName = targetBucket,
Key = targetObjectKey
};
// Initiate the upload.
InitiateMultipartUploadResponse initResponse =
await s3Client.InitiateMultipartUploadAsync(initiateRequest);
// Save the upload ID.
String uploadId = initResponse.UploadId;
try
{
// Get the size of the object.
GetObjectMetadataRequest metadataRequest = new GetObjectMetadataRequest
{
BucketName = sourceBucket,
Key = sourceObjectKey
};
GetObjectMetadataResponse metadataResponse =
await s3Client.GetObjectMetadataAsync(metadataRequest);
long objectSize = metadataResponse.ContentLength; // Length in bytes.
// Copy the parts.
long partSize = 5 * (long)Math.Pow(2, 20); // Part size is 5 MB.
long bytePosition = 0;
for (int i = 1; bytePosition < objectSize; i++)
{
CopyPartRequest copyRequest = new CopyPartRequest
{
DestinationBucket = targetBucket,
DestinationKey = targetObjectKey,
SourceBucket = sourceBucket,
SourceKey = sourceObjectKey,
UploadId = uploadId,
FirstByte = bytePosition,
LastByte = bytePosition + partSize - 1 >= objectSize ? objectSize - 1 : bytePosition + partSize - 1,
PartNumber = i
};
copyResponses.Add(await s3Client.CopyPartAsync(copyRequest));
bytePosition += partSize;
}
// Set up to complete the copy.
CompleteMultipartUploadRequest completeRequest =
new CompleteMultipartUploadRequest
{
BucketName = targetBucket,
Key = targetObjectKey,
UploadId = initResponse.UploadId
};
completeRequest.AddPartETags(copyResponses);
// Complete the copy.
CompleteMultipartUploadResponse completeUploadResponse =
await s3Client.CompleteMultipartUploadAsync(completeRequest);
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
------
# Tutorial: Fazer upload de um objeto por meio do carregamento fracionado e conferir a integridade dos dados
O multipart upload permite que você faça upload de um único objeto como um conjunto de partes. Cada parte é uma parte contígua de dados do objeto. O upload dessas partes de objetos pode ser feito de maneira independente e em qualquer ordem. Se a transmissão de alguma parte falhar, você poderá retransmitir essa parte sem afetar outras partes. Depois que todas as partes do objeto forem carregadas, o Amazon S3 montará essas partes e criará o objeto. Geralmente, quando seu objeto alcança 100 MB de tamanho, você deve considerar o uso de multipart uploads em vez de fazer upload do objeto em uma única operação. Para obter mais informações sobre multipart uploads, consulte [Carregar e copiar objetos usando upload fracionado no Amazon S3](mpuoverview.md). Para ver os limites relacionados a carregamentos fracionados, consulte [Limites do multipart upload do Amazon S3](qfacts.md).
É possível usar somas de verificação para verificar se os ativos não são alterados quando copiados. A execução de uma soma de verificação consiste em usar um algoritmo para iterar sequencialmente sobre cada byte em um arquivo. O Amazon S3 oferece várias opções de soma de verificação para conferir a integridade dos dados. Recomendamos que você execute essas verificações de integridade como prática recomendada de durabilidade e para garantir que cada byte seja transferido sem alteração. O Amazon S3 também é compatível com os seguintes algoritmos: SHA-1, SHA-256, CRC32 e CRC32C. O Amazon S3 usa um ou mais desses algoritmos para calcular um valor de soma de verificação adicional e armazená-lo como parte dos metadados do objeto. Para ter mais informações sobre somas de verificação, consulte [Verificar a integridade do objeto no Amazon S3](checking-object-integrity.md).
**Objetivo**
Neste tutorial, você aprenderá a fazer upload de um objeto no Amazon S3 usando um carregamento fracionado e uma soma de verificação SHA-256 adicional por meio da AWS Command Line Interface (AWS CLI). Você também aprenderá a conferir a integridade dos dados do objeto calculando o hash MD5 e a soma de verificação SHA-256 do objeto carregado.
**Topics**
+ [Pré-requisitos](#mpu-prerequisites)
+ [Etapa 1: criar um arquivo grande](#create-large-file-step1)
+ [Etapa 2: dividir o arquivo em vários arquivos](#split-large-file-step2)
+ [Etapa 3: criar o carregamento fracionado com uma soma de verificação adicional](#create-multipart-upload-step3)
+ [Etapa 4: fazer upload das partes do carregamento fracionado](#upload-parts-step4)
+ [Etapa 5: listar todas as partes do carregamento fracionado](#list-parts-step5)
+ [Etapa 6: concluir o carregamento fracionado](#complete-multipart-upload-step6)
+ [Etapa 7: confirmar se o objeto foi carregado no bucket](#confirm-upload-step7)
+ [Etapa 8: verificar a integridade do objeto com uma soma de verificação MD5](#verify-object-integrity-step8)
+ [Etapa 9: verificar a integridade do objeto com uma soma de verificação adicional](#verify-object-integrity-sha256-step9)
+ [Etapa 10: Limpar os recursos](#clean-up-step10)
## Pré-requisitos
+ Antes de iniciar este tutorial, confira se você tem acesso a um bucket do Amazon S3 para o qual possa fazer upload. Para obter mais informações, consulte [Criar um bucket de uso geral](create-bucket-overview.md).
+ É necessário ter a AWS CLI instalada e configurada. Se você ainda não tiver a AWS CLI instalada, consulte [Install or update to the latest version of the AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/getting-started-install.html) no *Guia do usuário da AWS Command Line Interface*.
+ Também é possível executar comandos da AWS CLI pelo console usando o AWS CloudShell. O AWS CloudShell é um shell pré-autenticado e baseado em navegador que você pode iniciar diretamente do Console de gerenciamento da AWS. Para ter mais informações, consulte [What is CloudShell?](https://docs.aws.amazon.com//cloudshell/latest/userguide/welcome.html) e [Getting started with AWS CloudShell](https://docs.aws.amazon.com//cloudshell/latest/userguide/getting-started.html) no *Guia do usuário do AWS CloudShell*.
## Etapa 1: criar um arquivo grande
Se você já tiver um arquivo pronto para upload, poderá usá-lo para este tutorial. Caso contrário, crie um arquivo de 15 MB usando as etapas a seguir. Para ver os limites relacionados a carregamentos fracionados, consulte [Limites do multipart upload do Amazon S3](qfacts.md).
**Como criar um arquivo grande**
Use um dos seguintes comandos para criar o arquivo, dependendo do sistema operacional que estiver usando.
**Linux ou macOS**
Para criar um arquivo de 15 MB, abra o terminal local e execute o seguinte comando:
```
dd if=/dev/urandom of=census-data.bin bs=1M count=15
```
Esse comando cria um arquivo de 15 MB denominado `census-data.bin` preenchido com bytes aleatórios.
**Windows**
Para criar um arquivo de 15 MB, abra o terminal local e execute o seguinte comando:
```
fsutil file createnew census-data.bin 15728640
```
Esse comando cria um arquivo denominado `census-data.bin` com um tamanho de 15 MB de dados arbitrários (15.728.640 bytes).
## Etapa 2: dividir o arquivo em vários arquivos
Para realizar o carregamento fracionado, é necessário dividir o arquivo grande em partes menores. Depois, é possível fazer upload das partes menores usando o processo de carregamento fracionado. Esta etapa demonstra como dividir em partes menores o arquivo grande criado na [Etapa 1](#create-large-file-step1). O exemplo a seguir usa um arquivo de 15 MB denominado `census-data.bin`.
**Como dividir um arquivo grande em partes**
**Linux ou macOS**
Para dividir o arquivo grande em partes de 5 MB, use o comando `split`. Abra o terminal e execute o seguinte:
```
split -b 5M -d census-data.bin census-part
```
Esse comando divide `census-data.bin` em partes de 5 MB denominadas `census-part**`, em que `**` é um sufixo numérico de `00`.
**Windows**
Para dividir o arquivo grande, use o PowerShell. Abra o [PowerShell](https://learn.microsoft.com/en-us/powershell/) e execute o seguinte script:
```
$inputFile = "census-data.bin"
$outputFilePrefix = "census-part"
$chunkSize = 5MB
$fs = [System.IO.File]::OpenRead($inputFile)
$buffer = New-Object byte[] $chunkSize
$fileNumber = 0
while ($fs.Position -lt $fs.Length) {
$bytesRead = $fs.Read($buffer, 0, $chunkSize)
$outputFile = "{0}{1:D2}" -f $outputFilePrefix, $fileNumber
$fileStream = [System.IO.File]::Create($outputFile)
$fileStream.Write($buffer, 0, $bytesRead)
$fileStream.Close()
$fileNumber++
}
$fs.Close()
```
O script do PowerShell lê o arquivo grande em partes de 5 MB e grava cada uma em um novo arquivo com um sufixo numérico.
Depois de executar o comando apropriado, você deverá ver as partes no diretório no qual executou o comando. Cada parte terá um sufixo correspondente ao número da parte, por exemplo:
```
census-part00 census-part01 census-part02
```
## Etapa 3: criar o carregamento fracionado com uma soma de verificação adicional
Para iniciar o processo de carregamento fracionado, é necessário criar a solicitação de carregamento fracionado. Essa etapa envolve iniciar o carregamento fracionado e especificar uma soma de verificação adicional para a integridade dos dados. O exemplo a seguir usa a soma de verificação SHA-256. Se você quiser fornecer metadados que descrevam o objeto que está sendo carregado, deverá fornecê-los na solicitação para iniciar o carregamento fracionado.
**nota**
Nesta etapa e nas etapas subsequentes, este tutorial usa o algoritmo adicional SHA-256. Também é possível usar outra soma de verificação adicional para essas etapas, como CRC32, CRC32C ou SHA-1. Se você usar um algoritmo diferente, deverá usá-lo em todas as etapas do tutorial.
**Como iniciar o carregamento fracionado**
No terminal, use o comando `create-multipart-upload` a seguir para iniciar um carregamento fracionado para o bucket. Substitua `amzn-s3-demo-bucket1` pelo nome do bucket real. Além disso, substitua o `census_data_file` pelo nome do arquivo escolhido. Esse nome de arquivo torna-se a chave do objeto quando o upload é concluído.
```
aws s3api create-multipart-upload --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --checksum-algorithm sha256
```
Se a solicitação for bem-sucedida, você verá uma saída JSON como a seguinte:
```
{
"ServerSideEncryption": "AES256",
"ChecksumAlgorithm": "SHA256",
"Bucket": "amzn-s3-demo-bucket1",
"Key": "census_data_file",
"UploadId": "cNV6KCSNANFZapz1LUGPC5XwUVi1n6yUoIeSP138sNOKPeMhpKQRrbT9k0ePmgoOTCj9K83T4e2Gb5hQvNoNpCKqyb8m3.oyYgQNZD6FNJLBZluOIUyRE.qM5yhDTdhz"
}
```
**nota**
Quando você envia uma solicitação para iniciar um multipart upload, o Amazon S3 retorna uma resposta com um ID de upload, que é um identificador exclusivo do seu multipart upload. É necessário incluir esse ID de upload sempre que fizer upload de partes, listar as partes, concluir um upload ou interromper um upload. Será necessário usar os valores `UploadId`, `Key` e `Bucket` para as etapas posteriores; portanto, lembre-se de salvá-los.
Além disso, se você estiver usando um carregamento fracionado com somas de verificação adicionais, os números das partes deverão ser consecutivos. Se você usar números de parte não consecutivos, a solicitação `complete-multipart-upload` poderá gerar um HTTP `500 Internal Server Error`.
## Etapa 4: fazer upload das partes do carregamento fracionado
Nesta etapa, você fará upload das partes do carregamento fracionado no bucket do S3. Use o comando `upload-part` para fazer upload de cada parte individualmente. Esse processo requer a especificação do ID do upload, do número da parte e do arquivo a ser carregado para cada parte.
**Como fazer upload das partes**
1. Ao fazer upload de uma parte, além do ID do upload, é necessário especificar o número da parte usando o argumento `--part-number`. Você pode escolher qualquer número de parte entre 1 e 10.000. Um número de parte identifica com exclusividade a parte e sua posição no objeto do qual você está fazendo upload. O número da parte que você escolher não precisa estar em uma sequência consecutiva (por exemplo, pode ser 1, 2 ou 3). Se você fizer upload de uma nova parte usando o mesmo número da parte anteriormente carregada, a parte anteriormente carregada será substituída.
1. Use o comando `upload-part` para fazer upload de cada parte do carregamento fracionado. O `--upload-id` é o mesmo que estava na saída criada pelo comando `create-multipart-upload` na [Etapa 3](#create-multipart-upload-step3). Para fazer upload da primeira parte dos dados, use o seguinte comando:
```
aws s3api upload-part --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --part-number 1 --body census-part00 --upload-id "cNV6KCSNANFZapz1LUGPC5XwUVi1n6yUoIeSP138sNOKPeMhpKQRrbT9k0ePmgoOTCj9K83T4e2Gb5hQvNoNpCKqyb8m3.oyYgQNZD6FNJLBZluOIUyRE.qM5yhDTdhz" --checksum-algorithm SHA256
```
Após a conclusão de cada comando `upload-part`, você deverá ver uma saída como a seguinte:
```
{
"ServerSideEncryption": "AES256",
"ETag": "\"e611693805e812ef37f96c9937605e69\"",
"ChecksumSHA256": "QLl8R4i4+SaJlrl8ZIcutc5TbZtwt2NwB8lTXkd3GH0="
}
```
1. Para as partes subsequentes, aumente o número da parte apropriadamente:
```
aws s3api upload-part --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --part-number --body --upload-id "" --checksum-algorithm SHA256
```
Por exemplo, use o seguinte comando para fazer upload da segunda parte:
```
aws s3api upload-part --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --part-number 2 --body census-part01 --upload-id "cNV6KCSNANFZapz1LUGPC5XwUVi1n6yUoIeSP138sNOKPeMhpKQRrbT9k0ePmgoOTCj9K83T4e2Gb5hQvNoNpCKqyb8m3.oyYgQNZD6FNJLBZluOIUyRE.qM5yhDTdhz" --checksum-algorithm SHA256
```
O Amazon S3 exibe uma tag de entidade (ETag) e somas de verificação adicionais para cada parte carregada como cabeçalho na resposta.
1. Continue usando o comando `upload-part` até fazer upload de todas as partes do objeto.
## Etapa 5: listar todas as partes do carregamento fracionado
Para concluir o carregamento fracionado, você precisará de uma lista de todas as partes que foram carregadas para esse carregamento fracionado específico. A saída do comando `list-parts` fornece algumas informações, como nome do bucket, chave, ID do upload, número da parte, ETag, somas de verificação adicionais etc. É útil salvar essa saída em um arquivo para que você possa usá-la na próxima etapa ao concluir o processo de carregamento fracionado. É possível criar um arquivo de saída JSON chamado `parts.json` usando o método a seguir.
**Como criar um arquivo que liste todas as partes**
1. Para gerar um arquivo JSON com os detalhes de todas as partes carregadas, use o comando `list-parts` a seguir. Substitua ***amzn-s3-demo-bucket1*** pelo nome real do bucket e **** pelo ID de upload recebido na [Etapa 3](#create-multipart-upload-step3). Para ter mais informações sobre o comando `list-parts`, consulte [https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html) no *Guia do usuário da AWS Command Line Interface*.
```
aws s3api list-parts --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --upload-id --query '{Parts: Parts[*].{PartNumber: PartNumber, ETag: ETag, ChecksumSHA256: ChecksumSHA256}}' --output json > parts.json
```
Um novo arquivo chamado `parts.json` é gerado. O arquivo contém as informações em formato JSON de todas as partes carregadas. O arquivo `parts.json` inclui informações essenciais para cada parte do carregamento fracionado, como os números de parte e os valores de ETag correspondentes, os quais são necessários para concluir o processo de carregamento fracionado.
1. Abra `parts.json` usando qualquer editor de texto ou pelo terminal. Veja a saída de exemplo:
```
{
"Parts": [
{
"PartNumber": 1,
"ETag": "\"3c3097f89e2a2fece47ac54b243c9d97\"",
"ChecksumSHA256": "fTPVHfyNHdv5VkR4S3EewdyioXECv7JBxN+d4FXYYTw="
},
{
"PartNumber": 2,
"ETag": "\"03c71cc160261b20ab74f6d2c476b450\"",
"ChecksumSHA256": "VDWTa8enjOvULBAO3W2a6C+5/7ZnNjrnLApa1QVc3FE="
},
{
"PartNumber": 3,
"ETag": "\"81ae0937404429a97967dffa7eb4affb\"",
"ChecksumSHA256": "cVVkXehUlzcwrBrXgPIM+EKQXPUvWist8mlUTCs4bg8="
}
]
}
```
## Etapa 6: concluir o carregamento fracionado
Depois de fazer upload de todas as partes do carregamento fracionado e listá-las, a etapa final é concluir o carregamento fracionado. Essa etapa mescla todas as partes carregadas em um único objeto no bucket do S3.
**nota**
É possível calcular a soma de verificação do objeto antes de chamar `complete-multipart-upload` incluindo `--checksum-sha256` na solicitação. Se as somas de verificação não coincidirem, o Amazon S3 rejeitará a solicitação. Consulte mais informações em [https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html) no *Guia de Usuário AWS Command Line Interface*.
**Como concluir o carregamento fracionado**
Para finalizar o carregamento fracionado, use o comando `complete-multipart-upload`. Esse comando requer o arquivo `parts.json` criado na [Etapa 5](#list-parts-step5), o nome do bucket e o ID do upload. Substitua **<*amzn-s3-demo-bucket1*>** pelo nome do bucket e **** pelo ID do upload de `parts.json`.
```
aws s3api complete-multipart-upload --multipart-upload file://parts.json --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --upload-id
```
Veja a saída de exemplo:
```
{
"ServerSideEncryption": "AES256",
"Location": "https://amzn-s3-demo-bucket1.s3.us-east-2.amazonaws.com/census_data_file",
"Bucket": "amzn-s3-demo-bucket1",
"Key": "census_data_file",
"ETag": "\"f453c6dccca969c457efdf9b1361e291-3\"",
"ChecksumSHA256": "aI8EoktCdotjU8Bq46DrPCxQCGuGcPIhJ51noWs6hvk=-3"
}
```
**nota**
Não exclua ainda os arquivos de parte individuais. Você precisará das partes individuais para poder realizar somas de verificação e conferir a integridade do objeto mesclado.
## Etapa 7: confirmar se o objeto foi carregado no bucket
Depois de concluir o carregamento fracionado, você poderá verificar se o objeto foi carregado com êxito no bucket do S3. Para listar os objetos no bucket e confirmar a presença do arquivo recém-carregado, use o comando `list-objects-v2`
**Como listar o objeto carregado**
Para listar os objetos no bucket, use o bucket de comando `list-objects-v2`. Substitua ***amzn-s3-demo-bucket1*** pelo nome do bucket real.
```
aws s3api list-objects-v2 --bucket amzn-s3-demo-bucket1
```
Esse comando exibe uma lista de objetos no bucket. Procure o arquivo carregado (por exemplo, `census_data_file`) na lista de objetos.
Para ter mais informações, consulte a seção [Examples](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-objects-v2.html) do comando `list-objects-v2` no *Guia do usuário do AWS Command Line Interface*.
## Etapa 8: verificar a integridade do objeto com uma soma de verificação MD5
Ao fazer upload de um objeto, é possível especificar um algoritmo de soma de verificação a ser usado pelo Amazon S3. Por padrão, o Amazon S3 armazena o resumo MD5 de bytes como ETag do objeto. Para carregamentos fracionados, a ETag não é a soma de verificação do objeto completo, mas um composto de somas de verificação de cada parte.
**Como verificar a integridade do objeto usando uma soma de verificação MD5**
1. Para recuperar a ETag do objeto carregado, faça uma solicitação `head-object`:
```
aws s3api head-object --bucket amzn-s3-demo-bucket1 --key census_data_file
```
Veja a saída de exemplo:
```
{
"AcceptRanges": "bytes",
"LastModified": "2024-07-26T19:04:13+00:00",
"ContentLength": 16106127360,
"ETag": "\"f453c6dccca969c457efdf9b1361e291-3\"",
"ContentType": "binary/octet-stream",
"ServerSideEncryption": "AES256",
"Metadata": {}
}
```
Essa ETag tem “-3” anexado ao final. Isso indica que o objeto foi carregado em três partes usando o carregamento fracionado.
1. Depois, calcule a soma de verificação MD5 de cada parte usando o comando `md5sum`. Forneça o caminho correto para os arquivos de parte:
```
md5sum census-part*
```
Veja a saída de exemplo:
```
e611693805e812ef37f96c9937605e69 census-part00
63d2d5da159178785bfd6b6a5c635854 census-part01
95b87c7db852451bb38b3b44a4e6d310 census-part02
```
1. Para esta etapa, combine manualmente os hashes MD5 em uma string. Depois, execute o comando a seguir para converter a string em binário e calcular a soma de verificação MD5 do valor binário:
```
echo "e611693805e812ef37f96c9937605e6963d2d5da159178785bfd6b6a5c63585495b87c7db852451bb38b3b44a4e6d310" | xxd -r -p | md5sum
```
Veja a saída de exemplo:
```
f453c6dccca969c457efdf9b1361e291 -
```
Esse valor de hash deve corresponder ao valor de hash do valor da ETag original na [Etapa 1](#create-large-file-step1), que valida a integridade do objeto `census_data_file`.
Quando você instrui o Amazon S3 a usar somas de verificação adicionais, ele calcula o respectivo valor para cada parte e armazena os valores. Se você quiser recuperar os valores da soma de verificação para partes individuais de carregamentos fracionados ainda em andamento, poderá usar `list-parts`.
Consulte mais informações sobre como as somas de verificação funcionam com objetos de carregamento fracionado em [Verificar a integridade do objeto no Amazon S3](checking-object-integrity.md).
## Etapa 9: verificar a integridade do objeto com uma soma de verificação adicional
Nesta etapa, este tutorial usa o SHA-256 como uma soma de verificação adicional para validar a integridade do objeto. Se você usou uma soma de verificação adicional diferente, use esse valor de soma de verificação.
**Como verificar a integridade do objeto com SHA256**
1. Execute o seguinte comando no terminal, incluindo o argumento `--checksum-mode enabled`, para exibir o valor `ChecksumSHA256` do objeto:
```
aws s3api head-object --bucket amzn-s3-demo-bucket1 --key census_data_file --checksum-mode enabled
```
Veja a saída de exemplo:
```
{
"AcceptRanges": "bytes",
"LastModified": "2024-07-26T19:04:13+00:00",
"ContentLength": 16106127360,
"ChecksumSHA256": "aI8EoktCdotjU8Bq46DrPCxQCGuGcPIhJ51noWs6hvk=-3",
"ETag": "\"f453c6dccca969c457efdf9b1361e291-3\"",
"ContentType": "binary/octet-stream",
"ServerSideEncryption": "AES256",
"Metadata": {}
}
```
1. Use os comandos a seguir para decodificar os valores `ChecksumSHA256` das partes individuais em base64 e salvá-los em um arquivo binário chamado `outfile`. Esses valores podem ser encontrados no arquivo `parts.json`. Substitua as strings base64 de exemplo pelos valores `ChecksumSHA256` reais.
```
echo "QLl8R4i4+SaJlrl8ZIcutc5TbZtwt2NwB8lTXkd3GH0=" | base64 --decode >> outfile
echo "xCdgs1K5Bm4jWETYw/CmGYr+m6O2DcGfpckx5NVokvE=" | base64 --decode >> outfile
echo "f5wsfsa5bB+yXuwzqG1Bst91uYneqGD3CCidpb54mAo=" | base64 --decode >> outfile
```
1. Execute o seguinte comando para calcular a soma de verificação SHA256 do `outfile`:
```
sha256sum outfile
```
Veja a saída de exemplo:
```
688f04a24b42768b6353c06ae3a0eb3c2c50086b8670f221279d67a16b3a86f9 outfile
```
Na próxima etapa, converta o valor do hash em um valor binário. Esse valor binário deve corresponder ao valor `ChecksumSHA256` da [Etapa 1](#create-large-file-step1).
1. Converta a soma de verificação SHA256 da [Etapa 3](#create-multipart-upload-step3) em um valor binário e, depois, codifique-o em base64 para verificar se ele corresponde ao valor `ChecksumSHA256` da [Etapa 1](#create-large-file-step1):
```
echo "688f04a24b42768b6353c06ae3a0eb3c2c50086b8670f221279d67a16b3a86f9" | xxd -r -p | base64
```
Veja a saída de exemplo:
```
aI8EoktCdotjU8Bq46DrPCxQCGuGcPIhJ51noWs6hvk=
```
Essa saída deve confirmar se a saída base64 corresponde ao valor `ChecksumSHA256` da saída do comando `head-object`. Se a saída corresponder ao valor da soma de verificação, o objeto será válido.
**Importante**
Quando você instrui o Amazon S3 a usar somas de verificação adicionais, ele calcula os respectivos valores para cada parte e armazena esses valores.
Se você quiser recuperar os valores da soma de verificação para partes individuais de carregamentos fracionados ainda em andamento, poderá usar o comando `list-parts`.
## Etapa 10: Limpar os recursos
Se você quiser limpar os arquivos criados neste tutorial, use o método a seguir. Para obter instruções sobre como excluir os arquivos carregados no bucket do S3, consulte [Excluir objetos do Amazon S3](DeletingObjects.md).
**Exclua os arquivos locais criados na [Etapa 1](#create-large-file-step1):**
Para remover os arquivos criados para o carregamento fracionado, execute o seguinte comando no diretório de trabalho:
```
rm census-data.bin census-part* outfile parts.json
```
# Limites do multipart upload do Amazon S3
O multipart upload permite que você faça upload de um único objeto como um conjunto de partes. Cada parte é uma parte contígua de dados do objeto. Depois que todas as partes do objeto forem carregadas, o Amazon S3 montará essas partes e criará o objeto. Geralmente, quando seu objeto alcança 100 MB de tamanho, você deve considerar o uso de multipart uploads em vez de fazer upload do objeto em uma única operação. Para obter mais informações sobre multipart uploads, consulte [Carregar e copiar objetos usando upload fracionado no Amazon S3](mpuoverview.md).
A tabela a seguir fornece especificações básicas do multipart upload. Isso inclui tamanho máximo do objeto, número máximo de partes, tamanho máximo das partes etc. Não há limite de tamanho mínimo na última parte do carregamento fracionado.
| Item | Especificação |
| --- | --- |
| Tamanho máximo do objeto | 48,8 TiB |
| Número máximo de partes por upload | 10.000 |
| Números de parte | 1 a 10.000 (inclusive) |
| Tamanho da parte | 5 MiB a 5 GiB. Não há limite de tamanho mínimo na última parte do carregamento fracionado. |
| Número máximo de partes retornadas em uma solicitação de listagem de partes | 1000 |
| Número máximo de multipart uploads retornados em uma solicitação de listagem de multipart uploads | 1000 |