**Questa pagina è riservata ai clienti esistenti del servizio Amazon Glacier che utilizzano Vaults e l'API REST originale del 2012.** Se stai cercando soluzioni di archiviazione, ti consigliamo di utilizzare le classi di storage Amazon 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 di [Amazon Glacier](https://aws.amazon.com/s3/storage-classes/glacier/). Amazon Glacier (servizio autonomo originale basato su vault) non accetta più nuovi clienti. Amazon Glacier è un servizio APIs autonomo che archivia i dati in vault ed è distinto dalle classi di storage Amazon S3 e Amazon S3 Glacier. I dati esistenti rimarranno sicuri e accessibili in Amazon Glacier a tempo indeterminato. Non è richiesta alcuna migrazione. Per uno storage di archiviazione a lungo termine a basso costo, AWS consiglia le classi di storage [Amazon S3 Glacier](https://aws.amazon.com/s3/storage-classes/glacier/), che offrono un'esperienza cliente superiore con disponibilità Regione AWS completa, costi inferiori e integrazione dei servizi APIs basata su bucket S3. AWS Se desideri funzionalità avanzate, prendi in considerazione la migrazione alle classi di storage Amazon S3 Glacier utilizzando la [AWS nostra Solutions Guidance per il trasferimento di dati dai vault Amazon Glacier alle classi di storage Amazon S3 Glacier](https://aws.amazon.com/solutions/guidance/data-transfer-from-amazon-s3-glacier-vaults-to-amazon-s3/). 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 (caricamento in più parti) **Topics** + [Processo di caricamento in più parti](#MPUprocess) + [Dati rapidi](#qfacts) + [Caricamento di archivi di grandi dimensioni utilizzando AWS CLI](uploading-an-archive-mpu-using-cli.md) + [Caricamento in parti di archivi di grandi dimensioni mediante Amazon SDK per Java](uploading-an-archive-mpu-using-java.md) + [Caricamento di archivi di grandi dimensioni utilizzando AWS SDK per .NET](uploading-an-archive-mpu-using-dotnet.md) + [Caricamento in parti di archivi di grandi dimensioni mediante l'API REST](uploading-an-archive-mpu-using-rest.md) ## Processo di caricamento in più parti Come descritto in[Caricamento di un archivio in Amazon Glacier](uploading-an-archive.md), incoraggiamo i clienti di Amazon Glacier (Amazon Glacier) a utilizzare Multipart Upload per caricare archivi superiori a 100 mebibyte (MiB). 1. **Avvio del caricamento in più parti** Quando invii una richiesta per avviare un caricamento in più parti, Amazon Glacier restituisce un ID di caricamento multiparte, che è un identificatore univoco per il caricamento multiparte. Questo ID è necessario per qualsiasi operazione di caricamento in più parti successiva Questo ID non scade per almeno 24 ore dopo il completamento del lavoro da parte di Amazon Glacier. Nella richiesta di avviare un caricamento in più parti, specificare la dimensione della parte in numero di byte. Ogni parte che carichi, tranne l'ultima, deve essere di quella dimensione. **Nota** Non è necessario conoscere la dimensione globale dell'archivio quando si utilizza il caricamento in più parti. Ciò significa che è possibile utilizzare caricamenti in più parti nei casi in cui non si conosce la dimensione dell'archivio quando si avvia il caricamento dell'archivio. Devi solo decidere la dimensione della parte al momento in cui inizi il caricamento in più parti. Nella richiesta Initiate Multipart Upload, puoi anche fornire una descrizione facoltativa dell'archivio. 1. **Caricamento delle parti** Per ogni richiesta di caricamento, devi includere l'ID di caricamento in più parti ottenuto nella fase 1. Nella richiesta, devi anche specificare l'intervallo di contenuto in byte che identifica la posizione della parte nell'archivio finale. Amazon Glacier utilizza successivamente le informazioni sull'intervallo di contenuti per assemblare l'archivio nella sequenza corretta. Poiché fornisci l'intervallo di contenuto per ogni parte che carichi, questo determina la posizione della parte nell'assemblaggio finale dell'archivio e di conseguenza puoi caricare le parti in qualsiasi ordine. Puoi anche caricare le parti in parallelo. Se carichi una nuova parte che utilizza lo stesso intervallo di contenuto di una parte caricata in precedenza, quest'ultima viene sovrascritta. 1. **Completamento (o arresto) del caricamento in più parti** Dopo il caricamento di tutte le parti dell'archivio, devi eseguire l'operazione di completamento. Anche in questo caso, devi specificare l'ID di caricamento nella tua richiesta. Amazon Glacier crea un archivio concatenando le parti in ordine crescente in base all'intervallo di contenuti fornito. La risposta di Amazon Glacier a una richiesta di caricamento multiparte completo include un ID di archivio per l'archivio appena creato. Se hai fornito una descrizione opzionale dell'archivio nella richiesta Initiate Multipart Upload, Amazon Glacier la associa all'archivio assemblato. Una volta completato un caricamento in più parti, non puoi fare riferimento all'ID di caricamento in più parti. Ciò significa che non puoi accedere alle parti associate a quell'ID. Se arresti un caricamento in più parti, non puoi caricare altre parti utilizzando quell'ID. Tutto lo spazio di archiviazione utilizzato dalle parti associate al caricamento in più parti arrestato viene liberato. Se eventuali caricamenti di parti erano in corso, possono essere eseguiti correttamente o meno anche dopo l'arresto. ### Operazioni di caricamento in più parti supplementari Amazon Glacier (Amazon Glacier) fornisce le seguenti chiamate API di caricamento multiparte aggiuntive. + **List Parts**: questa operazione ti consente di elencare le parti di un determinato caricamento in più parti e restituisce informazioni sulle parti che hai caricato nell'ambito di tale caricamento. Per ogni richiesta di parti di un elenco, Amazon Glacier restituisce informazioni per un massimo di 1.000 parti. Se vi sono altre parti da elencare per il caricamento in più parti, viene eseguita la paginazione del risultato e la risposta include un contrassegno che segnala il punto da cui continuare l'elenco. Per recuperare le parti successive, devi inviare ulteriori richieste. Tenere presente che l'elenco di parti restituito non include le parti per le quali non è stato completato il caricamento. + **List Multipart Uploads**: questa operazione consente di ottenere un elenco dei caricamenti in più parti in corso. Un caricamento in più parti in corso è un caricamento avviato, ma non ancora completato o annullato. Per ogni richiesta List Multipart Uploads, Amazon Glacier restituisce fino a 1.000 caricamenti in più parti. Se vi sono altri caricamenti in più parti da elencare, viene eseguita la paginazione dei risultati e la risposta include un contrassegno che segnala il punto da cui continuare l'elenco. Per recuperare i caricamenti in più parti rimanenti, devi inviare ulteriori richieste. ## Dati rapidi La tabella riportata di seguito fornisce le specifiche di base di un caricamento in più parti. | Elemento | Specifica | | --- | --- | | Dimensione massima dell'archivio | 10.000 x 4 gibibyte (GiB) | | Numero massimo di parti per caricamento | 10.000 | | Dimensione parte | Da 1 MiB a 4 GiB, l'ultima parte può essere < 1 MiB. Devi specificare la dimensione in byte. La dimensione della parte deve essere un mebibyte (1024 kibibyte [KiB]) moltiplicato per una potenza di 2. Ad esempio, `1048576` (1 MiB), `2097152` (2 MiB), `4194304` (4 MiB), `8388608` (8 MiB). | | Numero massimo di parti restituite per una richiesta di elenco delle parti | 1.000 | | Numero massimo di caricamenti in più parti restituiti per una richiesta di elenco dei caricamenti in più parti | 1.000 | # Caricamento di archivi di grandi dimensioni utilizzando AWS CLI Puoi caricare un archivio in Amazon Glacier (Amazon Glacier) utilizzando (). AWS Command Line Interface AWS CLI Per migliorare l'esperienza di caricamento per archivi di grandi dimensioni, Amazon Glacier fornisce diverse operazioni API per supportare caricamenti multiparte. Utilizzando queste operazioni API, puoi caricare gli archivi in parti. Queste parti possono essere caricate in modo indipendente, in qualsiasi ordine e in parallelo. Se il caricamento di una parte non ha esito positivo, è sufficiente caricare di nuovo quella parte e non l'intero archivio. Puoi utilizzare i caricamenti in più parti per archivi con una dimensione compresa tra 1 byte e 40.000 gibibyte (GiB). Per ulteriori informazioni sui caricamenti multiparte di Amazon Glacier, consulta. [Caricamento in parti di archivi di grandi dimensioni (caricamento in più parti)](uploading-archive-mpu.md) **Topics** + [(Prerequisito) Configurazione di AWS CLI](#Creating-Vaults-CLI-Setup) + [(Prerequisito) Installa Python](#Uploading-Archives-mpu-CLI-Install-Python) + [(Prerequisito) Creare un Amazon Glacier Vault](#Uploading-Archives-mpu-CLI-Create-Vault) + [Esempio: caricamento di archivi di grandi dimensioni in parti utilizzando il AWS CLI](#Uploading-Archives-mpu-CLI-Implementation) ## (Prerequisito) Configurazione di AWS CLI 1. Scarica e configura la AWS CLI. Per le istruzioni, consulta i seguenti argomenti nella *Guida per l'utente dell'AWS Command Line Interface *: [Installazione di AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) [Configurazione di AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) 1. Verifica la AWS CLI configurazione inserendo i seguenti comandi al prompt dei comandi. Poiché entrambi questi comandi non forniscono credenziali in modo esplicito, vengono utilizzate le credenziali del profilo predefinito. + Prova a utilizzare il comando help. ``` aws help ``` + Per ottenere un elenco dei vault Amazon Glacier sull'account configurato, usa il comando. `list-vaults` Sostituiscilo *123456789012* con il tuo ID. Account AWS ``` aws glacier list-vaults --account-id 123456789012 ``` + Per vedere i dati di configurazione correnti per AWS CLI, usa il `aws configure list` comando. ``` aws configure list ``` ## (Prerequisito) Installa Python Per completare un caricamento in più parti, devi calcolare l'hash SHA256 dell'albero dell'archivio che stai caricando. Questa operazione è diversa dal calcolo dell'hash SHA256 ad albero del file che desideri caricare. Per calcolare l'hash dell' SHA256 albero dell'archivio che stai caricando, puoi usare C\$1 (Javacon.NET) o. Python In questo esempio verrà utilizzato Python. Per istruzioni sull'uso di Java o C\$1, consulta [Calcolo di checksum](checksum-calculations.md). Per informazioni sull'installazione di Python, consulta la pagina [Installazione o aggiornamento di Python](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html#installation) nella *Guida per lo sviluppatore di Boto3*. ## (Prerequisito) Creare un Amazon Glacier Vault Per utilizzare l'esempio seguente, devi avere almeno un vault Amazon Glacier creato. Per ulteriori informazioni sulla creazione di vault, consulta [Creazione di un vault in Amazon Glacier](creating-vaults.md). ## Esempio: caricamento di archivi di grandi dimensioni in parti utilizzando il AWS CLI In questo esempio, creerai un file e utilizzerai operazioni API di caricamento in più parti per caricare questo file, in parti su Amazon Glacier. **Importante** Prima di intraprendere questa procedura, accertati di avere eseguito tutti i passaggi necessari. Per caricare un archivio, è necessario aver creato un archivio, AWS CLI configurarlo ed essere pronti a utilizzare Java C\$1 o Python a calcolare l'hash di un SHA256 albero. La procedura seguente utilizza i comandi `initiate-multipart-upload` e`upload-multipart-part`. `complete-multipart-upload` AWS CLI Per ulteriori informazioni dettagliate su ognuno di questi comandi, consulta [https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-multipart-upload.html](https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-multipart-upload.html), [https://docs.aws.amazon.com/cli/latest/reference/glacier/upload-multipart-part.html](https://docs.aws.amazon.com/cli/latest/reference/glacier/upload-multipart-part.html) e [https://docs.aws.amazon.com/cli/latest/reference/glacier/complete-multipart-upload.html](https://docs.aws.amazon.com/cli/latest/reference/glacier/complete-multipart-upload.html) nella *Guida di riferimento ai comandi AWS CLI *. 1. Usa il comando [https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-multipart-upload.html](https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-multipart-upload.html) per creare una risorsa di caricamento in più parti. Nella richiesta, specifica la dimensione della parte in numero di byte. Ogni parte che carichi, tranne l'ultima, deve essere di quella dimensione. Non è necessario conoscere la dimensione globale dell'archivio quando si avvia un caricamento. Tuttavia, avrai bisogno della dimensione totale, in byte, di ogni parte per completare il caricamento nella fase finale. Nel comando seguente, sostituisci i valori per i parametri `--vault-name` e `--account-ID` con le tue informazioni. Questo comando specifica che caricherai un archivio con una dimensione parziale di 1 mebibyte (MiB) (1024 x 1024 byte) per file. Se necessario, sostituisci il valore di questo parametro `--part-size`. ``` aws glacier initiate-multipart-upload --vault-name awsexamplevault --part-size 1048576 --account-id 123456789012 ``` Output previsto: ``` { "location": "/123456789012/vaults/awsexamplevault/multipart-uploads/uploadId", "uploadId": "uploadId" } ``` Al termine, il comando restituirà l'ID e la posizione di caricamento della risorsa di caricamento multiparte in Amazon Glacier. Sarà necessario usare questo ID di caricamento nei passaggi successivi. 1. Per questo esempio, è possibile utilizzare i seguenti comandi per creare un file da 4,4 MiB, dividerlo in blocchi da 1 MiB e caricare ogni blocco. Per caricare i propri file, è possibile seguire una procedura simile suddividendo i dati in blocchi e caricando ogni parte. **Linux o macOS:** Il comando seguente crea un file da 4,4 MiB, denominato `file_to_upload`, su Linux o macOS. ``` mkfile -n 9000b file_to_upload ``` **Windows** Il comando seguente crea un file da 4,4 MiB, denominato `file_to_upload`, su Windows. ``` fsutil file createnew file_to_upload 4608000 ``` 1. Successivamente, dividerai questo file in blocchi da 1 MiB. ``` split -b 1048576 file_to_upload chunk ``` Ora hai le seguenti cinque parti. Le prime quattro sono da 1 MiB e l'ultima è di circa 400 kibibyte (KiB). ``` chunkaa chunkab chunkac chunkad chunkae ``` 1. Usa il comandi [https://docs.aws.amazon.com/cli/latest/reference/glacier/upload-multipart-part.html](https://docs.aws.amazon.com/cli/latest/reference/glacier/upload-multipart-part.html) per caricare una parte di un archivio. Puoi caricare gli archivi in parti in un qualsiasi ordine. Puoi anche caricare le parti in parallelo. In un caricamento in più parti è consentito caricare fino a 10.000 parti. Nel comando seguente, sostituisci i valori per i parametri `--vault-name`, `--account-ID` e `--upload-id`. L'ID di caricamento deve corrispondere all'ID fornito come output del comando `initiate-multipart-upload`. Il parametro `--range` specifica che caricherai una parte con una dimensione di 1 MiB (1024 x 1024 byte). Questa dimensione deve corrispondere a quella specificata nel comando `initiate-multipart-upload`. Regola il valore della dimensione, se necessario. Il parametro `--body` specifica il nome della parte che stai caricando. ``` aws glacier upload-multipart-part --body chunkaa --range='bytes 0-1048575/*' --vault-name awsexamplevault --account-id 123456789012 --upload-id upload_ID ``` In caso di successo, il comando produrrà un output contenente il checksum per la parte caricata. 1. Esegui nuovamente il comando `upload-multipart-part` per caricare le parti rimanenti del caricamento in più parti. Aggiorna i valori dei parametri `--range` e `–-body` per ogni comando in modo che corrispondano alla parte che stai caricando. ``` aws glacier upload-multipart-part --body chunkab --range='bytes 1048576-2097151/*' --vault-name awsexamplevault --account-id 123456789012 --upload-id upload_ID ``` ``` aws glacier upload-multipart-part --body chunkac --range='bytes 2097152-3145727/*' --vault-name awsexamplevault --account-id 123456789012 --upload-id upload_ID ``` ``` aws glacier upload-multipart-part --body chunkad --range='bytes 3145728-4194303/*' --vault-name awsexamplevault --account-id 123456789012 --upload-id upload_ID ``` ``` aws glacier upload-multipart-part --body chunkae --range='bytes 4194304-4607999/*' --vault-name awsexamplevault --account-id 123456789012 --upload-id upload_ID ``` **Nota** Il valore del parametro `--range` del comando finale è inferiore perché la parte finale del nostro caricamento è inferiore a 1 MiB. In caso di successo, ogni comando produrrà un output contenente il checksum per ogni parte caricata. 1. Successivamente, assemblerai l'archivio e completerai il caricamento. È necessario includere la dimensione totale e l'hash SHA256 dell'albero dell'archivio. Per calcolare l'hash ad SHA256 albero dell'archivio, puoi usare Java C\$1 o. Python In questo esempio verrà utilizzato Python. Per istruzioni sull'uso di Java o C\$1, consulta [Calcolo di checksum](checksum-calculations.md). Crea il file `checksum.py` di Python e inserisci il codice seguente. Se necessario, sostituisci il nome del file originale. ``` from botocore.utils import calculate_tree_hash checksum = calculate_tree_hash(open('file_to_upload', 'rb')) print(checksum) ``` 1. Esegui `checksum.py` per calcolare l'hash dell' SHA256 albero. Il seguente hash potrebbe non corrispondere al tuo output. ``` $ python3 checksum.py $ 3d760edb291bfc9d90d35809243de092aea4c47b308290ad12d084f69988ae0c ``` 1. Usa il comando [https://docs.aws.amazon.com/cli/latest/reference/glacier/complete-multipart-upload.html](https://docs.aws.amazon.com/cli/latest/reference/glacier/complete-multipart-upload.html) per completare il caricamento dell'archivio. Sostituisci i valori per i parametri `--vault-name`, `--account-ID`, `--upload-ID` e `--checksum`. Il valore del parametro `--archive` specifica la dimensione totale, in byte, dell'archivio. Questo valore deve essere la somma di tutte le dimensioni delle singole parti caricate. Se necessario, sostituisci questo valore. ``` aws glacier complete-multipart-upload --archive-size 4608000 --vault-name awsexamplevault --account-id 123456789012 --upload-id upload_ID --checksum checksum ``` Al termine, il comando restituirà l'ID, il checksum e la posizione dell'archivio in Amazon Glacier. # Caricamento in parti di archivi di grandi dimensioni mediante Amazon SDK per Java Sia il [livello alto che quello di basso livello APIs](using-aws-sdk.md) forniti da Amazon SDK for Java forniscono un metodo per caricare un archivio di grandi dimensioni (vedi). [Caricamento di un archivio in Amazon Glacier](uploading-an-archive.md) + L'API di alto livello fornisce un metodo che puoi utilizzare per caricare archivi di qualsiasi dimensione. A seconda del file che stai caricando, il metodo carica un archivio in un'unica operazione o utilizza il supporto per il caricamento multiparte in Amazon Glacier (Amazon 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 sul livello alto e su quello di basso livello, consulta. APIs [Utilizzo di AWS SDK per Java con Amazon Glacier](using-aws-sdk-for-java.md) **Topics** + [Caricamento di archivi di grandi dimensioni in parti utilizzando l'API di alto livello di AWS SDK per Java](#uploading-an-archive-in-parts-highlevel-using-java) + [Carica archivi di grandi dimensioni in parti utilizzando l'API di basso livello di AWS SDK per Java](#uploading-an-archive-mpu-using-java-lowlevel) ## Caricamento di archivi di grandi dimensioni in parti utilizzando l'API di alto livello di AWS SDK per Java Per caricare archivi di piccole o grandi dimensioni, utilizzi gli stessi metodi dell'API di alto livello. In base alle dimensioni dell'archivio, i metodi API di alto livello decidono se caricare l'archivio in un'unica operazione o utilizzare l'API di caricamento multiparte fornita da Amazon Glacier. Per ulteriori informazioni, consulta [Caricamento di un archivio utilizzando l'API di alto livello di AWS SDK per Java](uploading-an-archive-single-op-using-java.md#uploading-an-archive-single-op-high-level-using-java). ## Carica archivi di grandi dimensioni in parti utilizzando l'API di basso livello di AWS SDK per 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 per Java. 1. Crea un'istanza della classe `AmazonGlacierClient` (client). È necessario specificare una AWS regione in cui si desidera salvare l'archivio. Tutte le operazioni eseguite utilizzando questo client si applicano a quella AWS regione. 1. Avvia il caricamento in più parti chiamando il metodo `initiateMultipartUpload`. Devi fornire il nome della 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, Amazon Glacier restituisce un ID di caricamento. 1. Carica le parti chiamando il metodo `uploadMultipartPart`. Per ogni parte caricata, devi fornire il nome della 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. 1. 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 della vault. Amazon Glacier crea l'archivio a partire dalle parti caricate e restituisce un ID di archivio. ### Esempio: caricamento di un archivio di grandi dimensioni in un componente utilizzando AWS SDK per Java Il seguente esempio di codice Java utilizza AWS SDK per Java per caricare un archivio in un vault ()`examplevault`. Per step-by-step istruzioni su come eseguire questo esempio, vedere[Esecuzione di esempi Java per Amazon Glacier con Eclipse](using-aws-sdk-for-java.md#setting-up-and-testing-sdk-java). 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 Amazon Glacier supporta dimensioni di parte fino a 4 GB. **Example** ``` 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 binaryChecksums = new LinkedList(); 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(); } } ``` # Caricamento di archivi di grandi dimensioni utilizzando AWS SDK per .NET Sia il [livello alto che quello di basso livello APIs](using-aws-sdk.md) forniti da Amazon SDK for .NET forniscono un metodo per caricare archivi di grandi dimensioni in parti (vedi). [Caricamento di un archivio in Amazon Glacier](uploading-an-archive.md) + L'API di alto livello fornisce un metodo che puoi utilizzare per caricare archivi di qualsiasi dimensione. A seconda del file che stai caricando, il metodo carica l'archivio in un'unica operazione o utilizza il supporto di caricamento multiparte in Amazon Glacier (Amazon 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 sul livello alto e su quello di basso livello, consulta. APIs [Utilizzo di AWS SDK per .NET con Amazon Glacier](using-aws-sdk-for-dot-net.md) **Topics** + [Caricamento di archivi di grandi dimensioni in parti utilizzando l'API di alto livello di AWS SDK per .NET](#uploading-an-archive-in-parts-highlevel-using-dotnet) + [Caricamento di archivi di grandi dimensioni in parti utilizzando l'API di basso livello di AWS SDK per .NET](#uploading-an-archive-in-parts-lowlevel-using-dotnet) ## Caricamento di archivi di grandi dimensioni in parti utilizzando l'API di alto livello di AWS SDK per .NET Per caricare archivi di piccole o grandi dimensioni, utilizzi gli stessi metodi dell'API di alto livello. In base alle dimensioni dell'archivio, i metodi API di alto livello decidono se caricare l'archivio in un'unica operazione o utilizzare l'API di caricamento multiparte fornita da Amazon Glacier. Per ulteriori informazioni, consulta [Caricamento di un archivio utilizzando l'API di alto livello di AWS SDK per .NET](uploading-an-archive-single-op-using-dotnet.md#uploading-an-archive-single-op-highlevel-using-dotnet). ## Caricamento di archivi di grandi dimensioni in parti utilizzando l'API di basso livello di AWS SDK per .NET 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 per .NET. 1. Crea un'istanza della classe `AmazonGlacierClient` (client). È necessario specificare una AWS regione in cui si desidera salvare l'archivio. Tutte le operazioni eseguite utilizzando questo client si applicano a quella AWS regione. 1. Avvia il caricamento in più parti chiamando il metodo `InitiateMultipartUpload`. Devi fornire il nome della 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, Amazon Glacier restituisce un ID di caricamento. 1. Carica le parti chiamando il metodo `UploadMultipartPart`. Per ogni parte caricata, devi fornire il nome della 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. 1. 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 della vault. Amazon Glacier crea l'archivio a partire dalle parti caricate e restituisce un ID di archivio. ### Esempio: caricamento in parti di un archivio di grandi dimensioni mediante Amazon SDK per .NET Il seguente esempio di codice C\$1 utilizza il AWS SDK per .NET per caricare un archivio in un vault (). `examplevault` Per step-by-step istruzioni su come eseguire questo esempio, consulta. [Esecuzione di esempi di codice](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet) Devi aggiornare il codice con il nome del file che intendi caricare come indicato. **Example** ``` using System; using System.Collections.Generic; using System.IO; using Amazon.Glacier; using Amazon.Glacier.Model; using Amazon.Runtime; namespace glacier.amazon.com.rproxy.govskope.ca.docsamples { class ArchiveUploadMPU { static string vaultName = "examplevault"; static string archiveToUpload = "*** Provide file name (with full path) to upload ***"; static long partSize = 4194304; // 4 MB. public static void Main(string[] args) { AmazonGlacierClient client; List partChecksumList = new List(); try { using (client = new AmazonGlacierClient(Amazon.RegionEndpoint.USWest2)) { Console.WriteLine("Uploading an archive."); string uploadId = InitiateMultipartUpload(client); partChecksumList = UploadParts(uploadId, client); string archiveId = CompleteMPU(uploadId, client, partChecksumList); Console.WriteLine("Archive ID: {0}", archiveId); } Console.WriteLine("Operations successful. To continue, press Enter"); Console.ReadKey(); } catch (AmazonGlacierException e) { Console.WriteLine(e.Message); } catch (AmazonServiceException e) { Console.WriteLine(e.Message); } catch (Exception e) { Console.WriteLine(e.Message); } Console.WriteLine("To continue, press Enter"); Console.ReadKey(); } static string InitiateMultipartUpload(AmazonGlacierClient client) { InitiateMultipartUploadRequest initiateMPUrequest = new InitiateMultipartUploadRequest() { VaultName = vaultName, PartSize = partSize, ArchiveDescription = "Test doc uploaded using MPU." }; InitiateMultipartUploadResponse initiateMPUresponse = client.InitiateMultipartUpload(initiateMPUrequest); return initiateMPUresponse.UploadId; } static List UploadParts(string uploadID, AmazonGlacierClient client) { List partChecksumList = new List(); long currentPosition = 0; var buffer = new byte[Convert.ToInt32(partSize)]; long fileLength = new FileInfo(archiveToUpload).Length; using (FileStream fileToUpload = new FileStream(archiveToUpload, FileMode.Open, FileAccess.Read)) { while (fileToUpload.Position < fileLength) { Stream uploadPartStream = GlacierUtils.CreatePartStream(fileToUpload, partSize); string checksum = TreeHashGenerator.CalculateTreeHash(uploadPartStream); partChecksumList.Add(checksum); // Upload part. UploadMultipartPartRequest uploadMPUrequest = new UploadMultipartPartRequest() { VaultName = vaultName, Body = uploadPartStream, Checksum = checksum, UploadId = uploadID }; uploadMPUrequest.SetRange(currentPosition, currentPosition + uploadPartStream.Length - 1); client.UploadMultipartPart(uploadMPUrequest); currentPosition = currentPosition + uploadPartStream.Length; } } return partChecksumList; } static string CompleteMPU(string uploadID, AmazonGlacierClient client, List partChecksumList) { long fileLength = new FileInfo(archiveToUpload).Length; CompleteMultipartUploadRequest completeMPUrequest = new CompleteMultipartUploadRequest() { UploadId = uploadID, ArchiveSize = fileLength.ToString(), Checksum = TreeHashGenerator.CalculateTreeHash(partChecksumList), VaultName = vaultName }; CompleteMultipartUploadResponse completeMPUresponse = client.CompleteMultipartUpload(completeMPUrequest); return completeMPUresponse.ArchiveId; } } } ``` # Caricamento in parti di archivi di grandi dimensioni mediante l'API REST Come descritto in [Caricamento in parti di archivi di grandi dimensioni (caricamento in più parti)](uploading-archive-mpu.md), il caricamento in più parti fa riferimento a un set di operazioni che consentono di caricare un archivio in parti e di eseguire operazioni correlate. Per ulteriori informazioni su queste operazioni, consulta i seguenti argomenti di riferimento dell'API: + [Initiate Multipart Upload (POST multipart-uploads)](api-multipart-initiate-upload.md) + [Upload Part (PUT uploadID)](api-upload-part.md) + [Complete Multipart Upload (POST uploadID)](api-multipart-complete-upload.md) + [Abort Multipart Upload (DELETE uploadID)](api-multipart-abort-upload.md) + [List Parts (GET uploadID)](api-multipart-list-parts.md) + [List Multipart Uploads (GET multipart-uploads)](api-multipart-list-uploads.md)