Caricamento in parti di archivi di grandi dimensioni mediante Amazon SDK per Java - Amazon S3 Glacier
Caricamento in parti di archivi di grandi dimensioni mediante l'API di alto livello del kit AWS SDK for JavaCaricamento in parti di archivi di grandi dimensioni mediante l'API di basso livello del kit AWS SDK for Java

Questa pagina è riservata ai clienti esistenti del servizio S3 Glacier che utilizzano Vaults e l'originale del 2012. REST API

Se stai cercando soluzioni di archiviazione, ti consigliamo di utilizzare le classi di storage S3 Glacier in Amazon S3, S3 Glacier Instant Retrieval, S3 Glacier Flexible Retrieval e S3 Glacier Deep Archive. Per ulteriori informazioni su queste opzioni di storage, consulta le classi di storage S3 Glacier e lo storage dei dati a lungo termine con le classi di storage S3 Glacier nella Amazon S3 User Guide. Queste classi di storage utilizzano Amazon S3API, sono disponibili in tutte le regioni e possono essere gestite all'interno della console Amazon S3. Offrono funzionalità come Storage Cost Analysis, Storage Lens, funzionalità di crittografia opzionali avanzate e altro ancora.

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Caricamento in parti di archivi di grandi dimensioni mediante Amazon SDK per Java

Le API di alto e basso livello fornite da Amazon SDK per Java forniscono un metodo per caricare un archivio di grandi dimensioni (consulta Caricamento di un archivio in Amazon S3 Glacier).

  • L'API di alto livello fornisce un metodo che puoi utilizzare per caricare archivi di qualsiasi dimensione. A seconda del file che devi caricare, il metodo carica un archivio in un'unica operazione oppure utilizza il supporto di caricamento in più parti di Amazon S3 Glacier (S3 Glacier) per caricare l'archivio in parti.

  • L'API di basso livello esegue la mappatura all'implementazione REST sottostante. Di conseguenza, fornisce un metodo per caricare archivi di dimensioni ridotte in un'unica operazione e un gruppo di metodi che supportano il caricamento in più parti per gli archivi di grandi dimensioni. Questa sezione illustra il caricamento in parti di archivi di grandi dimensioni mediante l'API di basso livello.

Per ulteriori informazioni sulle API di alto livello e di basso livello, consulta Utilizzo di AWS SDK for Java con Amazon S3 Glacier.

Caricamento in parti di archivi di grandi dimensioni mediante l'API di alto livello del kit AWS SDK for Java

Per caricare archivi di piccole o grandi dimensioni, utilizzi gli stessi metodi dell'API di alto livello. In base alla dimensione dell'archivio, questi metodi determinano se l'archivio deve essere caricato in un'unica operazione oppure mediante un caricamento in più parti con l'API corrispondente di S3 Glacier. Per ulteriori informazioni, consulta Caricamento di un archivio mediante l'API di alto livello del kit AWS SDK for Java.

Caricamento in parti di archivi di grandi dimensioni mediante l'API di basso livello del kit AWS SDK for Java

Per un controllo granulare del caricamento, puoi utilizzare l'API di basso livello, che consente di configurare la richiesta ed elaborare la risposta. Di seguito è riportata la procedura per caricare archivi di grandi dimensioni in parti utilizzando il kit AWS SDK for Java.

  1. Crea un'istanza della classe AmazonGlacierClient (client).

    Devi specificare la regione AWS in cui intendi salvare l'archivio. Tutte le operazioni che esegui utilizzando questo client si applicano a quella regione AWS.

  2. Avvia il caricamento in più parti chiamando il metodo initiateMultipartUpload.

    Devi fornire il nome del vault in cui desideri caricare l'archivio, la dimensione di parte da utilizzare per caricare le parti dell'archivio ed eventualmente una descrizione. Queste informazioni devono essere specificate quando si crea un'istanza della classe InitiateMultipartUploadRequest. In risposta, S3 Glacier restituisce un ID di caricamento.

  3. Carica le parti chiamando il metodo uploadMultipartPart.

    Per ogni parte caricata, devi fornire il nome del vault, l'intervallo di byte nell'archivio assemblato finale che sarà caricato nella parte, il checksum dei dati della parte e l'ID di caricamento.

  4. Completa il caricamento in più parti chiamando il metodo completeMultipartUpload.

    Devi fornire l'ID di caricamento, il checksum dell'intero archivio, la dimensione dell'archivio (la dimensione combinata di tutte le parti caricate) e il nome del vault. S3 Glacier costruisce l'archivio a partire dalle parti caricate e restituisce un ID archivio.

Esempio: caricamento in parti di un archivio di grandi dimensioni mediante il kit AWS SDK for Java

L'esempio di codice Java seguente utilizza il kit AWS SDK for Java per caricare un archivio in un vault (examplevault). Per istruzioni dettagliate su come eseguire questo esempio, consulta Esecuzione di esempi Java per Amazon S3 Glacier mediante Eclipse. Devi aggiornare il codice con il nome del file che intendi caricare come indicato.

Nota

Questo esempio è valido per dimensioni di parte comprese tra 1 MB e 1 GB. Nota tuttavia che S3 Glacier supporta dimensioni di parte fino a 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();
    }
}