**Diese Seite ist nur für Bestandskunden des Amazon Glacier-Service bestimmt, die Vaults und die ursprüngliche REST-API von 2012 verwenden.** Wenn Sie nach Archivspeicherlösungen suchen, empfehlen wir die Verwendung der Amazon Glacier-Speicherklassen in Amazon S3, S3 Glacier Instant Retrieval, S3 Glacier Flexible Retrieval und S3 Glacier Deep Archive. Weitere Informationen zu diesen Speicheroptionen finden Sie unter [Amazon Glacier-Speicherklassen](https://aws.amazon.com/s3/storage-classes/glacier/). Amazon Glacier (ursprünglicher eigenständiger, auf Tresor basierender Service) akzeptiert keine Neukunden mehr. Amazon Glacier ist ein eigenständiger Service APIs , der Daten in Tresoren speichert und sich von den Speicherklassen Amazon S3 und Amazon S3 Glacier unterscheidet. Ihre vorhandenen Daten bleiben in Amazon Glacier auf unbestimmte Zeit sicher und zugänglich. Es ist keine Migration erforderlich. Für kostengünstige, langfristige Archivierungsspeicherung AWS empfiehlt sich die [Amazon S3 Glacier-Speicherklasse](https://aws.amazon.com/s3/storage-classes/glacier/), die mit S3-Bucket-Basis, voller AWS-Region Verfügbarkeit APIs, geringeren Kosten und AWS Serviceintegration ein hervorragendes Kundenerlebnis bieten. Wenn Sie erweiterte Funktionen wünschen, sollten Sie eine Migration zu Amazon S3 Glacier-Speicherklassen in Betracht ziehen, indem Sie unseren [AWS Lösungsleitfaden für die Übertragung von Daten aus Amazon Glacier-Tresoren in Amazon S3 Glacier-Speicherklassen](https://aws.amazon.com/solutions/guidance/data-transfer-from-amazon-s3-glacier-vaults-to-amazon-s3/) verwenden. Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Hochladen von großen Archiven in Teilen (Multipart Upload) **Topics** + [Mehrteiliger Upload](#MPUprocess) + [Kurzinfo](#qfacts) + [Hochladen großer Archive mit dem AWS CLI](uploading-an-archive-mpu-using-cli.md) + [Hochladen von großen Archiven in Teilen mit dem Amazon-SDK für Java](uploading-an-archive-mpu-using-java.md) + [Hochladen großer Archive mit dem AWS SDK für .NET](uploading-an-archive-mpu-using-dotnet.md) + [Hochladen von großen Archiven in Teilen mit der REST-API](uploading-an-archive-mpu-using-rest.md) ## Mehrteiliger Upload Wie unter beschrieben[Hochladen eines Archivs in Amazon Glacier](uploading-an-archive.md), empfehlen wir Kunden von Amazon Glacier (Amazon Glacier), Multipart Upload zu verwenden, um Archive mit mehr als 100 Mebibyte (MiB) hochzuladen. 1. **Initiieren eines mehrteiligen Uploads** Wenn Sie eine Anfrage zur Initiierung eines mehrteiligen Uploads senden, gibt Amazon Glacier eine mehrteilige Upload-ID zurück, die eine eindeutige Kennung für Ihren mehrteiligen Upload ist. Diese ID ist bei allen darauf folgenden mehrteiligen Upload-Vorgängen erforderlich. Diese ID läuft mindestens 24 Stunden nach Abschluss des Auftrags durch Amazon Glacier nicht ab. Geben Sie in der Anforderung, mit der Sie den mehrteiligen Upload starten, die Größe der einzelnen Teile in Bytes an. Mit Ausnahme des letzten Teils muss jeder der hochzuladenden Teile diese Größe aufweisen. **Anmerkung** Es ist nicht notwendig, dass Ihnen die Gesamtgröße des Archivs bekannt ist, wenn Sie mehrteilige Uploads verwenden. Das bedeutet, dass Sie mehrteilige Uploads verwenden können, wenn Sie die Archivgröße beim Hochladen des Archivs nicht kennen. Sie müssen lediglich beim Start des mehrteiligen Uploads die Größe der Teile festlegen. Bei der Anforderung zur Initiierung des mehrteiligen Uploads können Sie optional auch eine Beschreibung des Archivs angeben. 1. **Teile hochladen** Bei jeder Anforderung zum Hochladen eines Teils müssen Sie die ID für den mehrteiligen Upload angeben, die Sie in Schritt 1 erhalten haben. Die Anforderung muss außerdem Informationen zum Inhaltsbereich (in Bytes) enthalten, durch die die Position des Teils im fertigen Archiv identifiziert wird. Amazon Glacier verwendet später die Inhaltsbereichsinformationen, um das Archiv in der richtigen Reihenfolge zusammenzustellen. Da Sie den Inhaltsbereich für jedes hochzuladende Teil angeben, ist dessen Position im abschließend zusammengesetzten Archiv genau gekennzeichnet. Darum können Sie die Teile in beliebiger Reihenfolge hochladen. Sie können Teile auch parallel hochladen. Wenn Sie einen neuen Teil mit denselben Informationen zum Inhaltsbereich hochladen wie für einen bereits hochgeladenen Teil, wird der zuvor hochgeladene Teil überschrieben. 1. **Abschließen (oder Beenden) eines mehrteiligen Uploads** Nachdem Sie alle Archivteile hochgeladen haben, schließen Sie den Vorgang ab. Auch hier müssen Sie die Upload-ID in Ihrer Anforderung angeben. Amazon Glacier erstellt ein Archiv, indem Teile auf der Grundlage des von Ihnen angegebenen Inhaltsbereichs in aufsteigender Reihenfolge verkettet werden. Die Antwort von Amazon Glacier auf eine Complete Multipart Upload-Anfrage enthält eine Archiv-ID für das neu erstellte Archiv. Wenn Sie in der Anfrage zum Initiate Multipart Upload eine optionale Archivbeschreibung angegeben haben, ordnet Amazon Glacier diese dem zusammengestellten Archiv zu. Wenn Sie einen mehrteiligen Upload erfolgreich abgeschlossen haben, können Sie nicht mehr auf die ID für den mehrteiligen Upload verweisen. Sie können also nicht auf Teile zugreifen, die mit der ID für den mehrteiligen Upload assoziiert sind. Wenn Sie einen mehrteiligen Upload beenden, können Sie keine weiteren Teile mit der ID für diesen mehrteiligen Upload hochladen. Der Speicherplatz, der von den Teilen beansprucht wurde, die mit dem beendeten mehrteiligen Upload zusammenhängen, wird daraufhin freigegeben. Wenn der mehrteilige Upload beendet wird, während Teile hochgeladen werden, können diese Uploads auch nach dem Beenden erfolgreich abgeschlossen werden oder fehlschlagen. ### Zusätzliche Operationen für den mehrteiligen Upload Amazon Glacier (Amazon Glacier) bietet die folgenden zusätzlichen mehrteiligen Upload-API-Aufrufe. + **List Parts**: Mit diesem Vorgang können Sie alle Teile eines bestimmten mehrteiligen Uploads auflisten. Dabei werden Informationen zu den Teilen zurückgegeben, die Sie bei einem mehrteiligen Upload hochgeladen haben. Für jede Anfrage zur Ersatzteilliste sendet Amazon Glacier Informationen für bis zu 1.000 Teile zurück. Wenn eine größere Anzahl von Teilen für den mehrteiligen Upload aufzuführen ist, werden die Ergebnisse in Seiten unterteilt und die Antwort enthält eine Markierung an der Stelle, an der die Liste fortgesetzt werden muss. Sie müssen weitere Anforderungen senden, um die nachfolgenden Teile abzurufen. Beachten Sie, dass die zurückgegebene Teileauflistung keine Teile enthält, die noch nicht vollständig hochgeladen wurden. + **List Multipart Uploads**: Mit dieser Operation können Sie eine Liste aller mehrteiligen Uploads in Bearbeitung erhalten. Ein mehrteiliger Upload in Verarbeitung ist ein Upload, den Sie gestartet haben, der aber noch nicht abgeschlossen ist oder abgebrochen wurde. Auf jede Anforderung zum Auflisten der mehrteiligen Uploads gibt Amazon Glacier bis zu 1.000 mehrteilige Uploads zurück. Wenn eine größere Anzahl von mehrteiligen Uploads aufzuführen ist, werden die Ergebnisse in Seiten unterteilt und die Antwort enthält eine Markierung an der Stelle, an der die Liste fortgesetzt werden muss. Sie müssen weitere Anforderungen senden, um die verbleibenden mehrteiligen Uploads abzurufen. ## Kurzinfo Die folgende Tabelle enthält die Core-Spezifikationen für den mehrteiligen Upload. | Item | Spezifikation | | --- | --- | | Maximale Archivgröße | 10 000 x 4 GiB (Gibibytes) | | Maximale Anzahl von Teilen pro Upload | 10.000 | | Teilegröße | 1 MiB bis 4 GiB, der letzte Teil kann < 1 MiB sein. Sie geben die Größe in Bytes an. Die Größe der Teile muss ein Mebibyte (1 024 Kibibyte [KiB]) multipliziert mit einer Potenz von 2 sein. Zum Beispiel `1048576` (1 MiB), `2097152` (2 MiB), `4194304` (4 MiB), `8388608` (8 MiB). | | Maximale Anzahl der zurückgegebenen Teile bei einer Anforderung zum Auflisten der Teile | 1.000 | | Maximale Anzahl der zurückgegebenen mehrteiligen Uploads bei einer Anforderung zum Auflisten mehrteiliger Uploads | 1.000 | # Hochladen großer Archive mit dem AWS CLI Sie können ein Archiv in Amazon Glacier (Amazon Glacier) hochladen, indem Sie AWS Command Line Interface (AWS CLI) verwenden. Um das Upload-Erlebnis für größere Archive zu verbessern, bietet Amazon Glacier mehrere API-Operationen zur Unterstützung mehrteiliger Uploads. Mithilfe dieser API-Operationen können Sie Archive in Teilen hochladen. Diese Teile können unabhängig voneinander in beliebiger Reihenfolge und parallel hochgeladen werden. Wenn der Upload eines Teils fehlschlägt, müssen Sie nur diesen Teil und nicht das gesamte Archiv erneut hochladen. Sie können mehrteilige Uploads für Archive mit einer Größe von 1 Byte bis zu ca. 40 000 Gibibytes (GiB) verwenden. Weitere Informationen zu mehrteiligen Amazon Glacier-Uploads finden Sie unter. [Hochladen von großen Archiven in Teilen (Multipart Upload)](uploading-archive-mpu.md) **Topics** + [(Voraussetzung) Einrichtung des AWS CLI](#Creating-Vaults-CLI-Setup) + [(Voraussetzung) Installieren von Python](#Uploading-Archives-mpu-CLI-Install-Python) + [(Voraussetzung) Erstellen Sie einen Amazon Glacier Vault](#Uploading-Archives-mpu-CLI-Create-Vault) + [Beispiel: Teilweises Hochladen großer Archive mithilfe von AWS CLI](#Uploading-Archives-mpu-CLI-Implementation) ## (Voraussetzung) Einrichtung des AWS CLI 1. Herunterladen und Konfigurieren von AWS CLI. Eine Anleitung finden Sie unter den folgenden Themen im *AWS Command Line Interface -Benutzerhandbuch*: [Installation des AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) [Konfiguration des AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) 1. Überprüfen Sie Ihr AWS CLI Setup, indem Sie die folgenden Befehle an der Befehlszeile eingeben. Diese Befehle stellen nicht explizit Anmeldeinformationen bereit, daher werden die Anmeldeinformationen des Standardprofils verwendet. + Versuchen Sie, den Befehl help zu verwenden. ``` aws help ``` + Verwenden Sie den `list-vaults` Befehl, um eine Liste der Amazon Glacier-Tresore für das konfigurierte Konto abzurufen. Ersetzen Sie es *123456789012* durch Ihre AWS-Konto ID. ``` aws glacier list-vaults --account-id 123456789012 ``` + Verwenden Sie den `aws configure list` Befehl AWS CLI, um die aktuellen Konfigurationsdaten für zu sehen. ``` aws configure list ``` ## (Voraussetzung) Installieren von Python Um einen mehrteiligen Upload abzuschließen, müssen Sie den SHA256 Tree-Hash des Archivs berechnen, das Sie hochladen. Dies unterscheidet sich von der Berechnung des SHA256 Baumhashs der Datei, die Sie hochladen möchten. Um den SHA256 Baumhash des Archivs zu berechnen, das Sie hochladen, können Sie C\$1 (mit.NET) oder verwendenJava. Python In diesem Beispiel verwenden Sie Python. Anweisungen zur Verwendung von Java oder C\$1 finden Sie unter [Berechnen von Prüfsummen](checksum-calculations.md). Informationen über das Installieren von Python finden Sie unter [Installieren von Python](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html#installation) im *Boto3-Benutzerhandbuch*. ## (Voraussetzung) Erstellen Sie einen Amazon Glacier Vault Um das folgende Beispiel verwenden zu können, muss mindestens ein Amazon Glacier-Tresor erstellt worden sein. Weitere Informationen zum Erstellen von Tresoren finden Sie unter [Einen Tresor in Amazon Glacier erstellen](creating-vaults.md). ## Beispiel: Teilweises Hochladen großer Archive mithilfe von AWS CLI In diesem Beispiel erstellen Sie eine Datei und verwenden API-Operationen für mehrteilige Uploads, um diese Datei in mehreren Teilen in Amazon Glacier hochzuladen. **Wichtig** Bevor Sie mit diesem Verfahren beginnen, stellen Sie sicher, dass alle Voraussetzungen erfüllt sind. Um ein Archiv hochzuladen, müssen Sie einen Tresor erstellt und AWS CLI konfiguriert haben und bereit seinJava, C\$1 zu verwenden oder einen Python SHA256 Tree-Hash zu berechnen. Das folgende Verfahren verwendet die `complete-multipart-upload` AWS CLI Befehle `initiate-multipart-upload``upload-multipart-part`, und. Ausführliche Informationen zu diesen Befehlen finden Sie unter [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) und [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) in der *AWS CLI -Befehlsreferenz*. 1. Verwenden Sie den [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)-Befehl, um eine Ressource für den mehrteiligen Upload zu erstellen. Geben Sie in der Anforderung die Größe der einzelnen Teile in Bytes an. Mit Ausnahme des letzten Teils muss jeder der hochzuladenden Teile diese Größe aufweisen. Sie müssen beim Initiieren eines mehrteiligen Uploads die Gesamtgröße des Archivs nicht kennen. Sie benötigen jedoch die Gesamtgröße jedes Teils in Byte, wenn Sie den Upload im letzten Schritt abschließen. Ersetzen Sie im folgenden Befehl die Werte für die Parameter `--vault-name` und `--account-ID` durch Ihre eigenen Informationen. Dieser Befehl gibt an, dass Sie ein Archiv mit einer Teilegröße von 1 Mebibyte (MiB) (1 024 x 1 024 Byte) pro Datei hochladen. Ersetzen Sie diesen `--part-size`-Parameterwert bei Bedarf. ``` aws glacier initiate-multipart-upload --vault-name awsexamplevault --part-size 1048576 --account-id 123456789012 ``` Erwartete Ausgabe: ``` { "location": "/123456789012/vaults/awsexamplevault/multipart-uploads/uploadId", "uploadId": "uploadId" } ``` Wenn der Befehl fertig ist, gibt er die Upload-ID und den Speicherort der mehrteiligen Upload-Ressource in Amazon Glacier aus. Sie verwenden diese Upload-ID in den nachfolgenden Schritten. 1. In diesem Beispiel können Sie die folgenden Befehle verwenden, um eine Datei mit 4,4 MiB zu erstellen, sie in Blöcke von 1 MiB aufzuteilen und die einzelnen Blöcke hochzuladen. Um Ihre eigenen Dateien hochzuladen, können Sie die Daten mit diesem Verfahren in Blöcke aufteilen und die einzelnen Teile hochladen. **Linux oder macOS** Der folgende Befehl erstellt eine 4,4 MiB große Datei mit dem Namen `file_to_upload` unter Linux oder macOS. ``` mkfile -n 9000b file_to_upload ``` **Windows** Der folgende Befehl erstellt eine 4,4 MiB große Datei mit dem Namen `file_to_upload` unter Windows. ``` fsutil file createnew file_to_upload 4608000 ``` 1. Als Nächstes teilen Sie diese Datei in Blöcke von 1 MiB auf. ``` split -b 1048576 file_to_upload chunk ``` Sie haben nun die folgenden fünf Blöcke. Die ersten vier sind 1 MiB groß, der letzte ist ungefähr 400 Kibibyte (KiB) groß. ``` chunkaa chunkab chunkac chunkad chunkae ``` 1. Verwenden Sie den [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)-Befehl, um einen Teil eines Archivs hochzuladen. Sie können die Archivteile in beliebiger Reihenfolge hochladen. Sie können die Teile auch parallel hochladen. Sie können bis zu 10 000 Teile für einen mehrteiligen Upload hochladen. Ersetzen Sie im folgenden Befehl die Werte für die Parameter `--vault-name`, `--account-ID` und `--upload-id`. Die Upload-ID muss mit der ID übereinstimmen, die in der Ausgabe des `initiate-multipart-upload`-Befehls angegeben wurde. Der `--range`-Parameter gibt an, dass Sie einen Teil mit einer Größe von 1 MiB (1 024 x 1 024 Byte) hochladen. Diese Größe muss mit der Größe übereinstimmen, die Sie im `initiate-multipart-upload`-Befehl angegeben haben. Passen Sie diesen Größenwert bei Bedarf an. Der `--body`-Parameter gibt den Namen des Teils an, den Sie hochladen. ``` aws glacier upload-multipart-part --body chunkaa --range='bytes 0-1048575/*' --vault-name awsexamplevault --account-id 123456789012 --upload-id upload_ID ``` Bei erfolgreicher Ausführung erzeugt der Befehl eine Ausgabe, die die Prüfsumme für den hochgeladenen Teil enthält. 1. Führen Sie den `upload-multipart-part`-Befehl erneut aus, um die verbleibenden Teile Ihres mehrteiligen Uploads hochzuladen. Aktualisieren Sie die Parameterwerte für `--range` und `–-body` in jeden Befehl so, dass sie mit dem Teil übereinstimmen, den Sie hochladen. ``` 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 ``` **Anmerkung** Der `--range`-Parameterwert des letzten Befehls ist kleiner, da der letzte Teil des Uploads kleiner als 1 MiB ist. Bei erfolgreicher Ausführung erzeugt jeder Befehl eine Ausgabe, die die Prüfsumme für den hochgeladenen Teil enthält. 1. Als Nächstes stellen Sie das Archiv zusammen und schließen den Upload ab. Sie müssen die Gesamtgröße und den SHA256 Baumhash des Archivs angeben. Um den SHA256 Baumhash des Archivs zu berechnen, können Sie C\$1 oder Python verwendenJava. In diesem Beispiel verwenden Sie Python. Anweisungen zur Verwendung von Java oder C\$1 finden Sie unter [Berechnen von Prüfsummen](checksum-calculations.md). Erstellen Sie die Python-Datei `checksum.py` und fügen Sie den folgenden Code ein. Falls erforderlich, ersetzen Sie den Namen der Originaldatei. ``` from botocore.utils import calculate_tree_hash checksum = calculate_tree_hash(open('file_to_upload', 'rb')) print(checksum) ``` 1. Führen Sie `checksum.py` den Befehl aus, um den SHA256 Baumhash zu berechnen. Der folgende Hash stimmt möglicherweise nicht mit Ihrer Ausgabe überein. ``` $ python3 checksum.py $ 3d760edb291bfc9d90d35809243de092aea4c47b308290ad12d084f69988ae0c ``` 1. Verwenden Sie den [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)-Befehl, um den Upload des Archivs abzuschließen. Ersetzen Sie die Werte für die Parameter `--vault-name`, `--account-ID`, `--upload-ID` und `--checksum`. Der `--archive`-Parameterwert gibt die Gesamtgröße des Archivs in Byte an. Dieser Wert muss die Summe aller Größen der einzelnen Teile sein, die Sie hochgeladen haben. Ersetzen Sie diesen Wert bei Bedarf. ``` aws glacier complete-multipart-upload --archive-size 4608000 --vault-name awsexamplevault --account-id 123456789012 --upload-id upload_ID --checksum checksum ``` Wenn der Befehl fertig ist, gibt er die ID, die Prüfsumme und den Speicherort des Archivs in Amazon Glacier aus. # Hochladen von großen Archiven in Teilen mit dem Amazon-SDK für Java Sowohl die [High-Level- als auch die Low-Level-Version](using-aws-sdk.md), die vom Amazon SDK for Java APIs bereitgestellt werden, bieten eine Methode zum Hochladen eines großen Archivs (siehe[Hochladen eines Archivs in Amazon Glacier](uploading-an-archive.md)). + Die High-Level-API bietet eine Methode, mit der Sie ein Archiv jeder Größe hochladen können. Abhängig von der Datei, die Sie hochladen, lädt die Methode entweder ein Archiv in einem einzigen Vorgang hoch oder verwendet die Unterstützung für mehrteiliges Hochladen in Amazon Glacier (Amazon Glacier), um das Archiv in Teilen hochzuladen. + Die Low-Level-API wird eng auf die zugrundeliegende REST-Implementierung abgebildet. Dem entsprechend wird eine Methode zum Hochladen kleiner Archive in einer Operation bereitgestellt und eine Gruppen von Methoden, die den mehrteiligen Upload größerer Archive unterstützen. In diesem Abschnitt wird das Hochladen großer Archive in Teilen mithilfe der Low-Level-API beschrieben. Weitere Informationen zur High-Level- und APIs Low-Level-Version finden Sie unter. [Verwenden von AWS SDK für Java mit Amazon Glacier](using-aws-sdk-for-java.md) **Topics** + [Teilweises Hochladen großer Archive mithilfe der High-Level-API von AWS SDK für Java](#uploading-an-archive-in-parts-highlevel-using-java) + [Laden Sie große Archive in Teilen hoch, indem Sie die Low-Level-API von AWS SDK für Java](#uploading-an-archive-mpu-using-java-lowlevel) ## Teilweises Hochladen großer Archive mithilfe der High-Level-API von AWS SDK für Java Sie verwenden die gleichen Methoden der High-Level-API für den Upload kleiner und großer Archive. Basierend auf der Archivgröße entscheiden die High-Level-API-Methoden, ob das Archiv in einem einzigen Vorgang hochgeladen oder die von Amazon Glacier bereitgestellte mehrteilige Upload-API verwendet wird. Weitere Informationen finden Sie unter [Hochladen eines Archivs mithilfe der High-Level-API von AWS SDK für Java](uploading-an-archive-single-op-using-java.md#uploading-an-archive-single-op-high-level-using-java). ## Laden Sie große Archive in Teilen hoch, indem Sie die Low-Level-API von AWS SDK für Java Zur präzisen Steuerung des Uploads können Sie das Low-Level-API verwenden, über das Sie die Anfrage konfigurieren und die Antwort bearbeiten können. Im Folgenden werden die Schritte zum Hochladen großer Archive in Teilen mit dem AWS SDK für Java beschrieben. 1. Erstellen einer Instance der `AmazonGlacierClient`-Klasse (Client). Sie müssen eine AWS Region angeben, in der Sie das Archiv speichern möchten. Alle Operationen, die Sie mit diesem Client ausführen, gelten für diese AWS Region. 1. Initiieren eines mehrteiligen Uploads durch Aufrufen der Methode `initiateMultipartUpload`. Sie müssen den Namen des Tresors, in den Sie das Archiv hochladen möchten, die Größe der Teile, die Sie verwenden möchten, um Archivteile hochzuladen, und optional eine Beschreibung angeben. Diese Informationen stellen Sie bereit, indem Sie eine Instance der `InitiateMultipartUploadRequest`-Klasse erstellen. Als Antwort gibt Amazon Glacier eine Upload-ID zurück. 1. Laden Sie Teile durch den Aufruf der `uploadMultipartPart`-Methode hoch. Für jeden hochgeladenen Teil müssen folgende Angaben gemacht werden: der Tresorname und Byte-Bereich im endgültig zusammengestellten Archiv, das in diesem Teil hochgeladen wird, sowie die Prüfsumme der Teildaten und die Upload-ID. 1. Führen Sie den mehrteiligen Upload aus, indem Sie die Methode `completeMultipartUpload` aufrufen. Sie müssen die Upload-ID, die Prüfsumme des gesamten Archivs, die Archivgröße (kombinierte Größe aller hochgeladenen Teile) und den Tresornamen bereitstellen. Amazon Glacier erstellt das Archiv aus den hochgeladenen Teilen und gibt eine Archiv-ID zurück. ### Beispiel: Hochladen eines großen Archivs in ein Bauteil mithilfe der AWS SDK für Java Das folgende Java-Codebeispiel verwendet den AWS SDK für Java , um ein Archiv in einen Tresor hochzuladen (`examplevault`). step-by-stepAnweisungen zur Ausführung dieses Beispiels finden Sie unter[Ausführen von Java-Beispielen für Amazon Glacier mit Eclipse](using-aws-sdk-for-java.md#setting-up-and-testing-sdk-java). Sie müssen den Code wie gezeigt mit dem Namen der hochzuladenden Datei aktualisieren. **Anmerkung** Dieses Beispiel gilt für Teilgrößen von 1 MB bis 1 GB. Allerdings unterstützt Amazon Glacier Teilgrößen bis zu 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(); } } ``` # Hochladen großer Archive mit dem AWS SDK für .NET Sowohl die [High-Level- als auch die Low-Level-Version](using-aws-sdk.md), die vom Amazon SDK for .NET APIs bereitgestellt werden, bieten eine Methode, um große Archive in Teilen hochzuladen (siehe[Hochladen eines Archivs in Amazon Glacier](uploading-an-archive.md)). + Die High-Level-API bietet eine Methode, mit der Sie ein Archiv jeder Größe hochladen können. Abhängig von der Datei, die Sie hochladen, lädt die Methode entweder das Archiv in einem einzigen Vorgang hoch oder verwendet die Unterstützung für mehrteiliges Hochladen in Amazon Glacier (Amazon Glacier), um das Archiv in Teilen hochzuladen. + Die Low-Level-API wird eng auf die zugrundeliegende REST-Implementierung abgebildet. Dem entsprechend wird eine Methode zum Hochladen kleiner Archive in einer Operation bereitgestellt und eine Gruppen von Methoden, die den mehrteiligen Upload größerer Archive unterstützen. In diesem Abschnitt wird das Hochladen großer Archive in Teilen mithilfe der Low-Level-API beschrieben. Weitere Informationen zur High-Level- und APIs Low-Level-Version finden Sie unter. [Verwenden von AWS SDK für .NET mit Amazon Glacier](using-aws-sdk-for-dot-net.md) **Topics** + [Teilweises Hochladen großer Archive mithilfe der High-Level-API von AWS SDK für .NET](#uploading-an-archive-in-parts-highlevel-using-dotnet) + [Teilweises Hochladen großer Archive mithilfe der Low-Level-API von AWS SDK für .NET](#uploading-an-archive-in-parts-lowlevel-using-dotnet) ## Teilweises Hochladen großer Archive mithilfe der High-Level-API von AWS SDK für .NET Sie verwenden die gleichen Methoden der High-Level-API für den Upload kleiner und großer Archive. Basierend auf der Archivgröße entscheiden die High-Level-API-Methoden, ob das Archiv in einem einzigen Vorgang hochgeladen oder die von Amazon Glacier bereitgestellte mehrteilige Upload-API verwendet wird. Weitere Informationen finden Sie unter [Hochladen eines Archivs mithilfe der High-Level-API von AWS SDK für .NET](uploading-an-archive-single-op-using-dotnet.md#uploading-an-archive-single-op-highlevel-using-dotnet). ## Teilweises Hochladen großer Archive mithilfe der Low-Level-API von AWS SDK für .NET Zur präzisen Steuerung des Uploads können Sie das Low-Level-API verwenden, über das Sie die Anfrage konfigurieren und die Antwort bearbeiten können. Im Folgenden werden die Schritte zum Hochladen großer Archive in Teilen mit dem AWS SDK für .NET beschrieben. 1. Erstellen einer Instance der `AmazonGlacierClient`-Klasse (Client). Sie müssen eine AWS Region angeben, in der Sie das Archiv speichern möchten. Alle Operationen, die Sie mit diesem Client ausführen, gelten für diese AWS Region. 1. Initiieren eines mehrteiligen Uploads durch Aufrufen der Methode `InitiateMultipartUpload`. Sie müssen den Namen des Tresors, in den Sie das Archiv hochladen möchten, die Größe der Teile, die Sie verwenden möchten, um Archivteile hochzuladen, und optional eine Beschreibung angeben. Diese Informationen stellen Sie bereit, indem Sie eine Instance der `InitiateMultipartUploadRequest`-Klasse erstellen. Als Antwort gibt Amazon Glacier eine Upload-ID zurück. 1. Laden Sie Teile durch den Aufruf der `UploadMultipartPart`-Methode hoch. Für jeden hochgeladenen Teil müssen folgende Angaben gemacht werden: der Tresorname und Byte-Bereich im endgültig zusammengestellten Archiv, das in diesem Teil hochgeladen wird, sowie die Prüfsumme der Teildaten und die Upload-ID. 1. Führen Sie den mehrteiligen Upload aus, indem Sie die Methode `CompleteMultipartUpload` aufrufen. Sie müssen die Upload-ID, die Prüfsumme des gesamten Archivs, die Archivgröße (kombinierte Größe aller hochgeladenen Teile) und den Tresornamen bereitstellen. Amazon Glacier erstellt das Archiv aus den hochgeladenen Teilen und gibt eine Archiv-ID zurück. ### Beispiel: Hochladen eines großen Archivs in Teilen mithilfe des Amazon-SDK für .NET Das folgende C\$1-Codebeispiel verwendet den AWS SDK für .NET , um ein Archiv in einen Tresor hochzuladen ()`examplevault`. step-by-stepAnweisungen zur Ausführung dieses Beispiels finden Sie unter[Ausführen von Codebeispielen](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet). Sie müssen den Code wie gezeigt mit dem Namen einer hochzuladenden Datei aktualisieren. **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.us.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; } } } ``` # Hochladen von großen Archiven in Teilen mit der REST-API Wie unter [Hochladen von großen Archiven in Teilen (Multipart Upload)](uploading-archive-mpu.md) beschrieben, bezieht sich der Begriff "mehrteiliger Upload" auf einen Satz von -Operationen, mit denen Sie ein Archiv in Teilen hochladen und damit zusammenhängende Operationen ausführen können. Weitere Informationen zu diesen Operationen finden Sie unter folgenden API-Referenzthemen: + [Mehrteiligen Upload initiieren (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)