Fazer upload de arquivos grandes em partes usando o Amazon SDK para Java - Amazon S3 Glacier
Fazer upload de arquivos grandes em partes usando a API de nível superior do AWS SDK for JavaFazer upload de arquivos grandes em partes usando a API de nível inferior do AWS SDK for Java

Esta página é somente para clientes existentes do serviço S3 Glacier que usam o Vaults e o original de 2012. REST API

Se você estiver procurando por soluções de armazenamento de arquivamento, sugerimos usar as classes de armazenamento S3 Glacier no Amazon S3, S3 Glacier Instant Retrieval, S3 Glacier Flexible Retrieval e S3 Glacier Deep Archive. Para saber mais sobre essas opções de armazenamento, consulte Classes de armazenamento S3 Glacier e Armazenamento de dados de longo prazo usando classes de armazenamento S3 Glacier no Guia do usuário do Amazon S3. Essas classes de armazenamento usam o Amazon S3API, estão disponíveis em todas as regiões e podem ser gerenciadas no console do Amazon S3. Eles oferecem recursos como análise de custos de armazenamento, lente de armazenamento, recursos avançados de criptografia opcional e muito mais.

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

Fazer upload de arquivos grandes em partes usando o Amazon SDK para Java

Tanto as APIs de nível superior quanto as nível inferior fornecidas pelo Amazon SDK para Java fornecem um método para carregar um grande arquivo (consulte Carregando um arquivo no Amazon S3 Glacier).

  • A API de nível superior fornece um método que você pode usar para fazer upload de arquivos de qualquer tamanho. Dependendo do arquivo que você estiver fazendo upload, o método faz upload de um arquivo em uma única operação ou usa o suporte a multipartes no Amazon S3 Glacier para fazer upload do arquivo em partes.

  • A API de nível inferior é mapeada junto à implementação de REST subjacente. Dessa forma, ela fornece um método para fazer upload de arquivos menores em uma operação e um grupo de métodos que dão suporte a multipart upload para arquivos maiores. Esta seção explica como fazer upload de arquivos grandes em partes usando a API de nível inferior.

Para obter mais informações sobre as APIs de níveis superior e inferior, consulte Como usar o Amazon S3 Glacier com a AWS SDK for Java.

Fazer upload de arquivos grandes em partes usando a API de nível superior do AWS SDK for Java

Você pode usar os mesmos métodos da API de nível superior para fazer upload de arquivos grandes ou pequenos. Com base no tamanho do arquivo, os métodos da API de nível superior decidem se é necessário fazer upload do arquivo em uma única operação ou usar API upload multipartes fornecida pelo S3 Glacier. Para obter mais informações, consulte Fazer upload de um arquivo usando a API de nível superior do AWS SDK for Java.

Fazer upload de arquivos grandes em partes usando a API de nível inferior do AWS SDK for Java

Para controle granular do upload, você pode usar a API de nível inferior, em que pode configurar a solicitação e processar a resposta. Estas são as etapas para fazer upload de arquivos grandes em partes usando o AWS SDK for Java.

  1. Crie uma instância da classe AmazonGlacierClient (o cliente).

    Especifique uma Região AWS onde deseja salvar o arquivo. Todas as operações realizadas por você usando esse cliente se aplicam a essa região AWS.

  2. Inicie multipart upload chamando o método initiateMultipartUpload.

    Você precisa fornecer o nome do cofre no qual deseja fazer upload do arquivo, o tamanho da parte que deseja usar para fazer upload das partes do arquivo e uma descrição opcional. Você precisa fornecer essas informações criando uma instância da classe InitiateMultipartUploadRequest. Em resposta, o S3 Glacier retorna um ID de upload.

  3. Faça upload de partes chamando o método uploadMultipartPart.

    Para cada parte cujo upload faz, você precisa fornecer o nome do cofre, o intervalo de bytes no arquivo montado final cujo upload será feito nessa parte, a soma de verificação dos dados da parte e o ID de upload.

  4. Conclua multipart upload chamando o método completeMultipartUpload.

    Você precisa fornecer o ID de upload, a soma de verificação de todo o arquivo, o tamanho do arquivo (tamanho combinado de todas as partes cujo upload você fez) e o nome do cofre. O S3 Glacier cria o arquivo a partir das partes carregadas e retorna um ID de arquivo.

Exemplo: fazer upload de um arquivo grande em partes usando o AWS SDK for Java

O exemplo de código do Java a seguir usa o AWS SDK for Java para fazer upload de um arquivo em um cofre (examplevault). Para instruções detalhadas sobre como executar esse exemplo, consulte Executar exemplos do Java para o Amazon S3 Glacier usando o Eclipse. É preciso atualizar o código conforme mostrado com o nome do arquivo cujo upload deseja fazer.

nota

Este exemplo é válido para tamanhos de parte de 1 MB a 1 GB. No entanto, o Amazon Glacier dá suporte a tamanhos de parte de até 4 GB. 

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;

import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.glacier.AmazonGlacierClient;
import com.amazonaws.services.glacier.TreeHashGenerator;
import com.amazonaws.services.glacier.model.CompleteMultipartUploadRequest;
import com.amazonaws.services.glacier.model.CompleteMultipartUploadResult;
import com.amazonaws.services.glacier.model.InitiateMultipartUploadRequest;
import com.amazonaws.services.glacier.model.InitiateMultipartUploadResult;
import com.amazonaws.services.glacier.model.UploadMultipartPartRequest;
import com.amazonaws.services.glacier.model.UploadMultipartPartResult;
import com.amazonaws.util.BinaryUtils;

public class ArchiveMPU {

    public static String vaultName = "examplevault";
    // This example works for part sizes up to 1 GB.
    public static String partSize = "1048576"; // 1 MB.
    public static String archiveFilePath = "*** provide archive file path ***";
    public static AmazonGlacierClient client;
    
    public static void main(String[] args) throws IOException {

    	ProfileCredentialsProvider credentials = new ProfileCredentialsProvider();

        client = new AmazonGlacierClient(credentials);
        client.setEndpoint("https://glacier.us-west-2.amazonaws.com/");

        try {
            System.out.println("Uploading an archive.");
            String uploadId = initiateMultipartUpload();
            String checksum = uploadParts(uploadId);
            String archiveId = CompleteMultiPartUpload(uploadId, checksum);
            System.out.println("Completed an archive. ArchiveId: " + archiveId);
            
        } catch (Exception e) {
            System.err.println(e);
        }

    }
    
    private static String initiateMultipartUpload() {
        // Initiate
        InitiateMultipartUploadRequest request = new InitiateMultipartUploadRequest()
            .withVaultName(vaultName)
            .withArchiveDescription("my archive " + (new Date()))
            .withPartSize(partSize);            
        
        InitiateMultipartUploadResult result = client.initiateMultipartUpload(request);
        
        System.out.println("ArchiveID: " + result.getUploadId());
        return result.getUploadId();
    }

    private static String uploadParts(String uploadId) throws AmazonServiceException, NoSuchAlgorithmException, AmazonClientException, IOException {

        int filePosition = 0;
        long currentPosition = 0;
        byte[] buffer = new byte[Integer.valueOf(partSize)];
        List<byte[]> binaryChecksums = new LinkedList<byte[]>();
        
        File file = new File(archiveFilePath);
        FileInputStream fileToUpload = new FileInputStream(file);
        String contentRange;
        int read = 0;
        while (currentPosition < file.length())
        {
            read = fileToUpload.read(buffer, filePosition, buffer.length);
            if (read == -1) { break; }
            byte[] bytesRead = Arrays.copyOf(buffer, read);

            contentRange = String.format("bytes %s-%s/*", currentPosition, currentPosition + read - 1);
            String checksum = TreeHashGenerator.calculateTreeHash(new ByteArrayInputStream(bytesRead));
            byte[] binaryChecksum = BinaryUtils.fromHex(checksum);
            binaryChecksums.add(binaryChecksum);
            System.out.println(contentRange);
                        
            //Upload part.
            UploadMultipartPartRequest partRequest = new UploadMultipartPartRequest()
            .withVaultName(vaultName)
            .withBody(new ByteArrayInputStream(bytesRead))
            .withChecksum(checksum)
            .withRange(contentRange)
            .withUploadId(uploadId);               
        
            UploadMultipartPartResult partResult = client.uploadMultipartPart(partRequest);
            System.out.println("Part uploaded, checksum: " + partResult.getChecksum());
            
            currentPosition = currentPosition + read;
        }
        fileToUpload.close();
        String checksum = TreeHashGenerator.calculateTreeHash(binaryChecksums);
        return checksum;
    }

    private static String CompleteMultiPartUpload(String uploadId, String checksum) throws NoSuchAlgorithmException, IOException {
        
        File file = new File(archiveFilePath);

        CompleteMultipartUploadRequest compRequest = new CompleteMultipartUploadRequest()
            .withVaultName(vaultName)
            .withUploadId(uploadId)
            .withChecksum(checksum)
            .withArchiveSize(String.valueOf(file.length()));
        
        CompleteMultipartUploadResult compResult = client.completeMultipartUpload(compRequest);
        return compResult.getLocation();
    }
}