**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.
# Arbeiten mit Archiven in Amazon Glacier
Als Archiv wird jedes beliebige Objekt bezeichnet, wie z. B. ein Foto, Video oder Dokument, das Sie in einem Tresor speichern. Es ist eine Basisspeichereinheit in Amazon Glacier (Amazon Glacier). Jedes Archiv besitzt eine eindeutige ID und optional eine Beschreibung. Wenn Sie ein Archiv hochladen, gibt Amazon Glacier eine Antwort zurück, die eine Archiv-ID enthält. Diese Archiv-ID ist in der AWS Region, in der das Archiv gespeichert ist, eindeutig. Es folgt ein Beispiel für eine Archiv-ID.
```
TJgHcrOSfAkV6hdPqOATYfp_0ZaxL1pIBOc02iZ0gDPMr2ig-nhwd_PafstsdIf6HSrjHnP-3p6LCJClYytFT_CBhT9CwNxbRaM5MetS3I-GqwxI3Y8QtgbJbhEQPs0mJ3KExample
```
IDs Die Archive sind 138 Byte lang. Wenn Sie ein Archiv hochladen, können Sie optional eine Beschreibung angeben. Sie können ein Archiv mithilfe seiner ID, aber nicht mithilfe seiner Beschreibung abrufen.
**Wichtig**
Amazon Glacier bietet eine Verwaltungskonsole. Sie können mit der Konsole Tresore erstellen und löschen. Für alle anderen Interaktionen mit Amazon Glacier müssen Sie jedoch die AWS Command Line Interface (CLI) verwenden oder Code schreiben. Um beispielsweise Daten wie Fotos, Videos und andere Dokumente hochzuladen, müssen Sie entweder den Code verwenden AWS CLI oder Code schreiben, um Anfragen zu stellen, entweder direkt über die REST-API oder über Amazon SDKs. Weitere Informationen zur Verwendung von Amazon Glacier mit dem AWS CLI finden Sie unter [AWS CLI Referenz für Amazon Glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html). Um das zu installieren AWS CLI, gehen Sie zu [AWS Command Line Interface](https://aws.amazon.com/cli/).
**Topics**
+ [Archivierungsvorgänge in Amazon Glacier](#archive-operations-quick-intro)
+ [Pflegen von clientseitigen Archivmetadaten](#client-side-key-map-concept)
+ [Hochladen eines Archivs in Amazon Glacier](uploading-an-archive.md)
+ [Ein Archiv in Amazon Glacier herunterladen](downloading-an-archive.md)
+ [Löschen eines Archivs in Amazon Glacier](deleting-an-archive.md)
## Archivierungsvorgänge in Amazon Glacier
Amazon Glacier unterstützt die folgenden grundlegenden Archivierungsvorgänge: Hochladen, Herunterladen und Löschen. Das Herunterladen eines Archivs ist ein asynchroner Vorgang.
### Hochladen eines Archivs in Amazon Glacier
Sie können ein Archiv in einer einzigen Operation oder in Teilen hochladen. Der API-Aufruf, den Sie verwenden, um ein Archiv in Teilen hochzuladen, wird als „mehrteiliger Upload“ bezeichnet. Weitere Informationen finden Sie unter [Hochladen eines Archivs in Amazon Glacier](uploading-an-archive.md).
**Wichtig**
Amazon Glacier bietet eine Verwaltungskonsole. Sie können mit der Konsole Tresore erstellen und löschen. Für alle anderen Interaktionen mit Amazon Glacier müssen Sie jedoch die AWS Command Line Interface (CLI) verwenden oder Code schreiben. Um beispielsweise Daten wie Fotos, Videos und andere Dokumente hochzuladen, müssen Sie entweder den Code verwenden AWS CLI oder Code schreiben, um Anfragen zu stellen, entweder direkt über die REST-API oder über Amazon SDKs. Weitere Informationen zur Verwendung von Amazon Glacier mit dem AWS CLI finden Sie unter [AWS CLI Referenz für Amazon Glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html). Um das zu installieren AWS CLI, gehen Sie zu [AWS Command Line Interface](https://aws.amazon.com/cli/).
### Suchen einer Archiv-ID in Amazon Glacier
Sie können die Archiv-ID ermitteln, indem Sie den Tresorbestand für den Tresor, in dem sich Archiv befindet, herunterladen. Weitere Informationen zum Herunterladen des Tresorbestands finden Sie unter [Ein Tresor-Inventar in Amazon Glacier herunterladen](vault-inventory.md).
### Ein Archiv in Amazon Glacier herunterladen
Das Herunterladen eines Archivs ist ein asynchroner Vorgang. Sie müssen zunächst einen Auftrag initiieren, um ein bestimmtes Archiv herunterzuladen. Nach Erhalt der Jobanfrage bereitet Amazon Glacier Ihr Archiv für den Download vor. Sie können Ihre Archivdaten herunterladen, nachdem der Auftrag abgeschlossen ist. Da der Job asynchron ist, können Sie Amazon Glacier bitten, nach Abschluss des Auftrags eine Benachrichtigung an ein Amazon Simple Notification Service (Amazon SNS) -Thema zu senden. Sie können ein SNS-Thema für jede einzelne Auftragsanfrage angeben oder Ihren Tresor so konfigurieren, dass eine Benachrichtigung gesendet wird, wenn bestimmte Tresorereignisse eintreten. Weitere Informationen über das Herunterladen von Archiven finden Sie unter [Ein Archiv in Amazon Glacier herunterladen](downloading-an-archive.md).
### Löschen eines Archivs in Amazon Glacier
Amazon Glacier bietet einen API-Aufruf, mit dem Sie jeweils ein Archiv löschen können. Weitere Informationen finden Sie unter [Löschen eines Archivs in Amazon Glacier](deleting-an-archive.md).
### Aktualisieren eines Archivs in Amazon Glacier
Nachdem ein Archiv hochgeladen wurde, kann weder sein Inhalt noch seine Beschreibung aktualisiert werden. Sie können den Inhalt oder die Beschreibung des Archivs nur aktualisieren, indem Sie das Archiv löschen und ein anderes Archiv hochladen. Beachten Sie, dass Amazon Glacier Ihnen jedes Mal, wenn Sie ein Archiv hochladen, eine eindeutige Archiv-ID zurückgibt.
## Pflegen von clientseitigen Archivmetadaten
Mit Ausnahme der optionalen Archivbeschreibung unterstützt Amazon Glacier keine zusätzlichen Metadaten für die Archive. Wenn Sie ein Archiv hochladen, weist Amazon Glacier eine ID zu, eine undurchsichtige Zeichenfolge, aus der Sie keine Bedeutung für das Archiv ableiten können. Es bietet sich darum an, clientseitig Metadaten für die Archive zu erstellen. Die Metadaten können den Archivnamen und weitere sinnvolle Informationen über das Archiv umfassen.
**Anmerkung**
Wenn Sie eine Kunde von Amazon Simple Storage Service (Amazon S3), dann wissen Sie, dass Sie einem Objekt, wenn Sie es in einen Bucket hochladen, einen Objektschlüssel wie z. B. `MyDocument.txt` oder `SomePhoto.jpg` zuweisen können. In Amazon Glacier können Sie den Archiven, die Sie hochladen, keinen Objektschlüssel zuweisen.
Wenn Sie clientseitige Archivmetadaten verwalten, beachten Sie, dass Amazon Glacier ein Tresorinventar verwaltet, das das Archiv IDs und alle Beschreibungen enthält, die Sie beim Archiv-Upload angegeben haben. Sie können den Tresorbestand gelegentlich herunterladen, um alle Informationen in Ihrer kundenseitigen Datenbank, die Sie für die Archivmetadaten pflegen, abzugleichen. Amazon Glacier führt jedoch ungefähr täglich ein Tresorinventar durch. Wenn Sie ein Tresorinventar anfordern, gibt Amazon Glacier das letzte erstellte Inventar zurück, ein Point-in-Time-Snapshot.
# Hochladen eines Archivs in Amazon Glacier
Amazon Glacier (Amazon Glacier) bietet eine Verwaltungskonsole, mit der Sie Tresore erstellen und löschen können. Sie können jedoch keine Archive mit der Management-Konsole auf Amazon Glacier hochladen. Um Daten wie Fotos, Videos und andere Dokumente hochzuladen, müssen Sie entweder den Code verwenden AWS CLI oder Code schreiben, um Anfragen zu stellen, entweder direkt über die REST-API oder über Amazon SDKs.
Informationen zur Verwendung von Amazon Glacier mit dem AWS CLI finden Sie unter [AWS CLI Referenz für Amazon Glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html). Um das zu installieren AWS CLI, gehen Sie zu [AWS Command Line Interface](https://aws.amazon.com/cli/). **In den folgenden Themen zum Hochladen wird beschrieben, wie Archive mithilfe des Amazon SDK for Java, des Amazon SDK for .NET und der REST-API auf Amazon Glacier hochgeladen werden.**
**Topics**
+ [Optionen für das Hochladen eines Archivs auf Amazon Glacier](#uploading-an-archive-overview)
+ [Hochladen eines Archivs in einer einzigen Operation](uploading-archive-single-operation.md)
+ [Hochladen von großen Archiven in Teilen (Multipart Upload)](uploading-archive-mpu.md)
## Optionen für das Hochladen eines Archivs auf Amazon Glacier
Abhängig von der Größe der Daten, die Sie hochladen, bietet Amazon Glacier die folgenden Optionen:
+ **Archive in einer einzelnen Operation hochladen**: Sie können Archive mit einer Größe zwischen 1 Byte und 4 GB in einem Vorgang hochladen. Wir empfehlen Amazon Glacier-Kunden jedoch, den mehrteiligen Upload zu verwenden, um Archive mit mehr als 100 MB hochzuladen. Weitere Informationen finden Sie unter [Hochladen eines Archivs in einer einzigen Operation](uploading-archive-single-operation.md).
+ **Archive in Teilen hochladen**: Mit der API für den mehrteiligen Upload können Sie große Archive mit bis zu 40 000 GB (10 000 \$1 4 GB) hochladen.
Die API-Funktion für den mehrteiligen Upload soll die Benutzererfahrung beim Hochladen größerer Archive verbessern. Sie können Archive in mehreren 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 GB verwenden. Weitere Informationen finden Sie unter [Hochladen von großen Archiven in Teilen (Multipart Upload)](uploading-archive-mpu.md).
**Wichtig**
Das Amazon Glacier-Tresor-Inventar wird nur einmal täglich aktualisiert. Wenn Sie ein Archiv hochladen, wird das dem Tresor neu hinzugefügte Archiv nicht sofort angezeigt (in der Konsole und in der heruntergeladenen Tresorbestandsliste), sondern erst nach der Aktualisierung des Tresorbestands.
### Den AWS Snowball Edge Service nutzen
AWS Snowball Edge beschleunigt das Verschieben großer Datenmengen in und aus AWS Geräten von Amazon unter Umgehung des Internets. Weitere Informationen erhalten Sie auf der Detailseite von [AWS Snowball Edge](https://aws.amazon.com/snowball).
Um vorhandene Daten auf Amazon Glacier (Amazon Glacier) hochzuladen, könnten Sie erwägen, einen der AWS Snowball Edge Gerätetypen zum Importieren von Daten in Amazon S3 zu verwenden und sie dann zur Archivierung mithilfe von Lebenszyklusregeln in die Amazon Glacier-Speicherklasse zu verschieben. Wenn Sie Amazon S3-Objekte auf die Amazon Glacier-Speicherklasse umstellen, verwendet Amazon S3 intern Amazon Glacier für dauerhaften Speicher zu geringeren Kosten. Obwohl die Objekte in Amazon Glacier gespeichert sind, bleiben sie Amazon S3-Objekte, die Sie in Amazon S3 verwalten. Sie haben direkt über Amazon Glacier keinen Zugriff auf diese Objekte.
Weitere Informationen zur Amazon S3 S3-Lebenszykluskonfiguration und zur Übertragung von Objekten in die Amazon Glacier-Speicherklasse finden Sie unter [Object Lifecycle Management](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) and [Transitioning Objects](https://docs.aws.amazon.com/AmazonS3/latest/userguide/lifecycle-transition-general-considerations.html) im *Amazon Simple Storage Service-Benutzerhandbuch*.
# Hochladen eines Archivs in einer einzigen Operation
Wie in [Hochladen eines Archivs in Amazon Glacier](uploading-an-archive.md) beschrieben, können Sie kleinere Archive in einer einzigen Operation hochladen. Wir empfehlen Kunden von Amazon Glacier (Amazon Glacier) jedoch, Multipart Upload zu verwenden, um Archive mit mehr als 100 MB hochzuladen.
**Topics**
+ [Hochladen eines Archivs in einem einzigen Vorgang mit dem AWS Command Line Interface](uploading-an-archive-single-op-using-cli.md)
+ [Hochladen eines Archivs in einem einzigen Vorgang mit dem AWS SDK für Java](uploading-an-archive-single-op-using-java.md)
+ [Hochladen eines Archivs in einem einzigen Vorgang mit dem AWS SDK für .NET in Amazon Glacier](uploading-an-archive-single-op-using-dotnet.md)
+ [Hochladen eines Archivs in einer einzigen Operation mit der REST-API](uploading-an-archive-single-op-using-rest.md)
# Hochladen eines Archivs in einem einzigen Vorgang mit dem AWS Command Line Interface
Sie können ein Archiv in Amazon Glacier (Amazon Glacier) hochladen, indem Sie AWS Command Line Interface (AWS CLI) verwenden.
**Topics**
+ [(Voraussetzung) Einrichtung des AWS CLI](#Creating-Vaults-CLI-Setup)
+ [Beispiel: Laden Sie ein Archiv hoch mit dem AWS CLI](#Uploading-Archives-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 Eingabeaufforderung 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
```
## Beispiel: Laden Sie ein Archiv hoch mit dem AWS CLI
Zum Hochladen eines Archivs müssen Sie einen Tresor erstellt haben. Weitere Informationen zum Erstellen von Tresoren finden Sie unter [Einen Tresor in Amazon Glacier erstellen](creating-vaults.md).
1. Verwenden Sie den `upload-archive`-Befehl, um einem vorhandenen Tresor ein Archiv hinzuzufügen. Ersetzen Sie im folgenden Beispiel `vault name` und `account ID`. Geben Sie für den `body`-Parameter einen Pfad zu der Datei an, die Sie hochladen möchten.
```
aws glacier upload-archive --vault-name awsexamplevault --account-id 123456789012 --body archive.zip
```
1. Erwartete Ausgabe:
```
{
"archiveId": "kKB7ymWJVpPSwhGP6ycSOAekp9ZYe_--zM_mw6k76ZFGEIWQX-ybtRDvc2VkPSDtfKmQrj0IRQLSGsNuDp-AJVlu2ccmDSyDUmZwKbwbpAdGATGDiB3hHO0bjbGehXTcApVud_wyDw",
"checksum": "969fb39823836d81f0cc028195fcdbcbbe76cdde932d4646fa7de5f21e18aa67",
"location": "/123456789012/vaults/awsexamplevault/archives/kKB7ymWJVpPSwhGP6ycSOAekp9ZYe_--zM_mw6k76ZFGEIWQX-ybtRDvc2VkPSDtfKmQrj0IRQLSGsNuDp-AJVlu2ccmDSyDUmZwKbwbpAdGATGDiB3hHO0bjbGehXTcApVud_wyDw"
}
```
Wenn der Befehl fertig ist, gibt er die Archiv-ID, die Prüfsumme und den Speicherort in Amazon Glacier aus. Weitere Informationen zum Befehl „upload-archive“ finden Sie unter [upload-archive](https://docs.aws.amazon.com/cli/latest/reference/glacier/upload-archive.html) in der *AWS CLI -Befehlsreferenz*.
# Hochladen eines Archivs in einem einzigen Vorgang mit dem AWS 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 Archivs.
**Topics**
+ [Hochladen eines Archivs mithilfe der High-Level-API von AWS SDK für Java](#uploading-an-archive-single-op-high-level-using-java)
+ [Hochladen eines Archivs in einem einzigen Vorgang mithilfe der Low-Level-API von AWS SDK für Java](#uploading-an-archive-single-op-low-level-using-java)
## Hochladen eines Archivs mithilfe der High-Level-API von AWS SDK für Java
Die `ArchiveTransferManager`-Klasse der High-Level-API bietet die `upload`-Methode, mit der Sie ein Archiv in einen Tresor hochladen können.
**Anmerkung**
Sie können die `upload`-Methode zum Hochladen von kleinen und großen Archiven verwenden. Die Größe des hochzuladenden Archivs entscheidet bei dieser Methode darüber, ob das Archiv in einem einzigen Vorgang hochgeladen wird oder ob die API für mehrteilige Uploads verwendet wird, um das Archiv in mehreren Teilen hochzuladen.
### Beispiel: Hochladen eines Archivs mithilfe der High-Level-API von AWS SDK für Java
Mit dem folgenden Java-Beispielcode wird ein Archiv in einen Tresor (`examplevault`) in der Region „USA West (Oregon)“ (`us-west-2`) hochgeladen. Eine Liste der unterstützten AWS Regionen und Endpunkte finden Sie unter. [Zugriff auf Amazon Glacier](amazon-glacier-accessing.md)
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 aktualisieren und dabei den Namen des Tresors, in den Sie das Archiv hochladen möchten, und den Namen der hochzuladenden Datei angeben.
**Example**
```
import java.io.File;
import java.io.IOException;
import java.util.Date;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.glacier.AmazonGlacierClient;
import com.amazonaws.services.glacier.transfer.ArchiveTransferManager;
import com.amazonaws.services.glacier.transfer.UploadResult;
public class ArchiveUploadHighLevel {
public static String vaultName = "*** provide vault name ***";
public static String archiveToUpload = "*** provide name of file to upload ***";
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 {
ArchiveTransferManager atm = new ArchiveTransferManager(client, credentials);
UploadResult result = atm.upload(vaultName, "my archive " + (new Date()), new File(archiveToUpload));
System.out.println("Archive ID: " + result.getArchiveId());
} catch (Exception e)
{
System.err.println(e);
}
}
}
```
## Hochladen eines Archivs in einem einzigen Vorgang mithilfe der Low-Level-API von AWS SDK für Java
Die Low-Level-API bietet Methoden für alle Archivvorgänge. Im Folgenden werden die Schritte zum Hochladen eines Archivs mit AWS SDK für Java beschrieben.
1. Erstellen einer Instance der `AmazonGlacierClient`-Klasse (Client).
Sie müssen eine AWS Region angeben, in die Sie das Archiv hochladen möchten. Alle Operationen, die Sie mit diesem Client ausführen, gelten für diese AWS Region.
1. Um die Anforderungsinformationen bereitzustellen, erstellen Sie eine Instance der `UploadArchiveRequest`-Klasse.
Zusätzlich zu den hochzuladenden Daten müssen Sie eine Prüfsumme (SHA-256-Struktur-Hash) für die Nutzlast, den Tresornamen, die Inhaltslänge der Daten und Ihre Konto-ID angeben.
Wenn Sie keine Konto-ID angeben, wird die Konto-ID übernommen, die den Anmeldeinformationen zugeordnet ist, die Sie zum Signieren der Anforderung verwenden. Weitere Informationen finden Sie unter [Verwenden von AWS SDK für Java mit Amazon Glacier](using-aws-sdk-for-java.md).
1. Führen Sie die `uploadArchive`-Methode aus, indem das Anforderungsobjekt als Parameter festgelegt wird.
Als Antwort gibt Amazon Glacier (Amazon Glacier) eine Archiv-ID des neu hochgeladenen Archivs zurück.
Der folgende Java-Codeausschnitt veranschaulicht die vorherigen Schritte.
```
AmazonGlacierClient client;
UploadArchiveRequest request = new UploadArchiveRequest()
.withVaultName("*** provide vault name ***")
.withChecksum(checksum)
.withBody(new ByteArrayInputStream(body))
.withContentLength((long)body.length);
UploadArchiveResult uploadArchiveResult = client.uploadArchive(request);
System.out.println("Location (includes ArchiveID): " + uploadArchiveResult.getLocation());
```
### Beispiel: Hochladen eines Archivs in einem einzigen Vorgang mithilfe der Low-Level-API von 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 aktualisieren und dabei den Namen des Tresors, in den Sie das Archiv hochladen möchten, und den Namen der hochzuladenden Datei angeben.
```
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.glacier.AmazonGlacierClient;
import com.amazonaws.services.glacier.TreeHashGenerator;
import com.amazonaws.services.glacier.model.UploadArchiveRequest;
import com.amazonaws.services.glacier.model.UploadArchiveResult;
public class ArchiveUploadLowLevel {
public static String vaultName = "*** provide vault name ****";
public static String archiveFilePath = "*** provide to file upload ****";
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-east-1.amazonaws.com/");
try {
// First open file and read.
File file = new File(archiveFilePath);
InputStream is = new FileInputStream(file);
byte[] body = new byte[(int) file.length()];
is.read(body);
// Send request.
UploadArchiveRequest request = new UploadArchiveRequest()
.withVaultName(vaultName)
.withChecksum(TreeHashGenerator.calculateTreeHash(new File(archiveFilePath)))
.withBody(new ByteArrayInputStream(body))
.withContentLength((long)body.length);
UploadArchiveResult uploadArchiveResult = client.uploadArchive(request);
System.out.println("ArchiveID: " + uploadArchiveResult.getArchiveId());
} catch (Exception e)
{
System.err.println("Archive not uploaded.");
System.err.println(e);
}
}
}
```
# Hochladen eines Archivs in einem einzigen Vorgang mit dem AWS SDK für .NET in Amazon Glacier
Sowohl die vom Amazon SDK for .NET APIs bereitgestellte [High-Level- als auch die Low-Level-Version](using-aws-sdk.md) bieten eine Methode, um ein Archiv in einem einzigen Vorgang hochzuladen.
**Topics**
+ [Hochladen eines Archivs mithilfe der High-Level-API von AWS SDK für .NET](#uploading-an-archive-single-op-highlevel-using-dotnet)
+ [Hochladen eines Archivs in einem einzigen Vorgang mithilfe der Low-Level-API von AWS SDK für .NET](#uploading-an-archive-single-op-lowlevel-using-dotnet)
## Hochladen eines Archivs mithilfe der High-Level-API von AWS SDK für .NET
Die `ArchiveTransferManager`-Klasse der High-Level-API bietet die `Upload`-Methode, mit der Sie ein Archiv in einen Tresor hochladen können.
**Anmerkung**
Sie können die `Upload`-Methode zum Hochladen von kleinen und großen Dateien verwenden. Die Größe der hochzuladenden Datei entscheidet bei dieser Methode darüber, ob die Datei in einer einziger Operationen hochgeladen wird oder ob die API für mehrteilige Uploads verwendet wird, um die Datei in mehreren Teilen hochzuladen.
### Beispiel: Hochladen eines Archivs mithilfe der High-Level-API von AWS SDK für .NET
Mit dem folgenden C\$1-Beispielcode wird ein Archiv in einen Tresor (`examplevault`) in der Region „USA West (Oregon)“ hochgeladen.
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 der hochzuladenden Datei aktualisieren.
**Example**
```
using System;
using Amazon.Glacier;
using Amazon.Glacier.Transfer;
using Amazon.Runtime;
namespace glacier.amazon.com.rproxy.govskope.us.docsamples
{
class ArchiveUploadHighLevel
{
static string vaultName = "examplevault";
static string archiveToUpload = "*** Provide file name (with full path) to upload ***";
public static void Main(string[] args)
{
try
{
var manager = new ArchiveTransferManager(Amazon.RegionEndpoint.USWest2);
// Upload an archive.
string archiveId = manager.Upload(vaultName, "upload archive test", archiveToUpload).ArchiveId;
Console.WriteLine("Archive ID: (Copy and save this ID for use in other examples.) : {0}", archiveId);
Console.WriteLine("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();
}
}
}
```
## Hochladen eines Archivs in einem einzigen Vorgang mithilfe der Low-Level-API von AWS SDK für .NET
Die Low-Level-API bietet Methoden für alle Archivvorgänge. Im Folgenden werden die Schritte zum Hochladen eines Archivs mit AWS SDK für .NET beschrieben.
1. Erstellen einer Instance der `AmazonGlacierClient`-Klasse (Client).
Sie müssen eine AWS Region angeben, in die Sie das Archiv hochladen möchten. Alle Operationen, die Sie mit diesem Client ausführen, gelten für diese AWS Region.
1. Um die Anforderungsinformationen bereitzustellen, erstellen Sie eine Instance der `UploadArchiveRequest`-Klasse.
Zusätzlich zu den hochzuladenden Daten müssen Sie eine Prüfsumme (SHA-256-Struktur-Hash) für die Nutzlast, den Tresornamen und Ihre Konto-ID angeben.
Wenn Sie keine Konto-ID angeben, wird die Konto-ID übernommen, die den Anmeldeinformationen zugeordnet ist, die Sie zum Signieren der Anforderung verwenden. Weitere Informationen finden Sie unter [Verwenden von AWS SDK für .NET mit Amazon Glacier](using-aws-sdk-for-dot-net.md).
1. Führen Sie die `UploadArchive`-Methode aus, indem das Anforderungsobjekt als Parameter festgelegt wird.
Als Antwort gibt Amazon Glacier eine Archiv-ID des neu hochgeladenen Archivs zurück.
### Beispiel: Hochladen eines Archivs in einem einzigen Vorgang mithilfe der Low-Level-API von AWS SDK für .NET
Im folgenden C\$1-Codebeispiel werden die vorstehenden Schritte veranschaulicht. Das Beispiel verwendet den AWS SDK für .NET , um ein Archiv in einen Tresor hochzuladen ()`examplevault`.
**Anmerkung**
Weitere Informationen zur zugrunde liegenden REST-API für das Hochladen eines Archivs in einer einzigen Anforderung finden Sie unter [Upload Archive (POST archive)](api-archive-post.md).
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 der hochzuladenden Datei aktualisieren.
**Example**
```
using System;
using System.IO;
using Amazon.Glacier;
using Amazon.Glacier.Model;
using Amazon.Runtime;
namespace glacier.amazon.com.rproxy.govskope.us.docsamples
{
class ArchiveUploadSingleOpLowLevel
{
static string vaultName = "examplevault";
static string archiveToUpload = "*** Provide file name (with full path) to upload ***";
public static void Main(string[] args)
{
AmazonGlacierClient client;
try
{
using (client = new AmazonGlacierClient(Amazon.RegionEndpoint.USWest2))
{
Console.WriteLine("Uploading an archive.");
string archiveId = UploadAnArchive(client);
Console.WriteLine("Archive ID: {0}", archiveId);
}
}
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 UploadAnArchive(AmazonGlacierClient client)
{
using (FileStream fileStream = new FileStream(archiveToUpload, FileMode.Open, FileAccess.Read))
{
string treeHash = TreeHashGenerator.CalculateTreeHash(fileStream);
UploadArchiveRequest request = new UploadArchiveRequest()
{
VaultName = vaultName,
Body = fileStream,
Checksum = treeHash
};
UploadArchiveResponse response = client.UploadArchive(request);
string archiveID = response.ArchiveId;
return archiveID;
}
}
}
}
```
# Hochladen eines Archivs in einer einzigen Operation mit der REST-API
Sie können mit dem API-Aufruf "Upload Archive (Archiv hochladen)" ein Archiv in einer einzigen Operation hochladen. Weitere Informationen finden Sie unter [Upload Archive (POST archive)](api-archive-post.md).
# 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)
# Ein Archiv in Amazon Glacier herunterladen
Amazon Glacier bietet eine Verwaltungskonsole, mit der Sie Tresore erstellen und löschen können. Sie können jedoch keine Archive von Amazon Glacier mithilfe der Managementkonsole herunterladen. Um Daten wie Fotos, Videos und andere Dokumente herunterzuladen, müssen Sie entweder die AWS Command Line Interface (AWS CLI) verwenden oder Code schreiben, um Anfragen zu stellen, entweder direkt über die REST-API oder über die AWS SDKs.
Informationen zur Verwendung von Amazon Glacier mit dem AWS CLI finden Sie in der [AWS CLI Referenz für Amazon Glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html). Informationen zur Installation von AWS CLI finden Sie unter [AWS Command Line Interface](https://aws.amazon.com/cli/). In den folgenden Themen wird beschrieben, wie Archive mithilfe der AWS SDK für Java Amazon Glacier REST-API auf Amazon Glacier heruntergeladen werden. AWS SDK für .NET
**Topics**
+ [Amazon Glacier-Archive abrufen](downloading-an-archive-two-steps.md)
+ [Herunterladen eines Archivs in Amazon Glacier mit dem AWS SDK für Java](downloading-an-archive-using-java.md)
+ [Herunterladen eines Archivs in Amazon Glacier mit dem AWS SDK für .NET](downloading-an-archive-using-dotnet.md)
+ [Herunterladen eines großen Archivs mithilfe der Parallelverarbeitung mit Python](downloading-large-archive-parallel-python.md)
+ [Herunterladen eines Archivs mit der REST-API](downloading-an-archive-using-rest.md)
+ [Herunterladen eines Archivs in Amazon Glacier mit dem AWS CLI](downloading-an-archive-using-cli.md)
# Amazon Glacier-Archive abrufen
Das Abrufen eines Archivs von Amazon Glacier ist ein asynchroner Vorgang, bei dem Sie zuerst einen Job initiieren und dann die Ausgabe herunterladen, nachdem der Job abgeschlossen ist. Um einen Job zum Abrufen von Archiven zu initiieren, verwenden Sie den [Initiate Job (POST jobs)](api-initiate-job-post.md) REST-API-Vorgang oder einen gleichwertigen Vorgang in der AWS CLI, oder der. AWS SDKs
**Topics**
+ [Archiv-Abrufoptionen](#api-downloading-an-archive-two-steps-retrieval-options)
+ [Abrufen von Archivbereichen](#downloading-an-archive-range)
Das Abrufen eines Archivs von Amazon Glacier erfolgt in zwei Schritten. Im Folgenden finden Sie eine Übersicht über diesen Prozess.
**So rufen Sie ein Archiv ab**
1. Initiieren eines Auftrags zum Abrufen eines Archivs
1. Ermitteln Sie die ID des Archivs, das Sie abrufen möchten. Sie finden die Archiv-ID in einer Inventarliste des Tresors. Sie können die Archiv-ID mit der REST-API, AWS CLI, oder abrufen AWS SDKs. Weitere Informationen finden Sie unter [Ein Tresor-Inventar in Amazon Glacier herunterladen](vault-inventory.md).
1. Initiieren Sie mithilfe des [Initiate Job (POST jobs)](api-initiate-job-post.md) Vorgangs einen Job, der Amazon Glacier auffordert, ein ganzes Archiv oder einen Teil des Archivs für den späteren Download vorzubereiten.
Wenn Sie einen Job initiieren, gibt Amazon Glacier in der Antwort eine Job-ID zurück und führt den Job asynchron aus. (Sie können die Auftragsausgabe erst herunterladen, nachdem der Auftrag wie in Schritt 2 beschrieben abgeschlossen wurde.)
**Wichtig**
Bei Standardabrufen kann eine Richtlinie für den Datenabruf dazu führen, dass die `Initiate Job`-Anforderung zu einer `PolicyEnforcedException`-Ausnahme führt und fehlschlägt. Weitere Informationen zu Datenabrufrichtlinien finden Sie unter [Amazon Glacier-Richtlinien für den Datenabruf](data-retrieval-policy.md). Weitere Informationen zur `PolicyEnforcedException`-Ausnahme finden Sie unter [Fehlermeldungen](api-error-responses.md).
Bei Bedarf können Sie große Segmente der in Amazon Glacier gespeicherten Daten wiederherstellen. Weitere Informationen zum Wiederherstellen von Daten aus den Amazon Glacier-Speicherklassen finden Sie unter [Speicherklassen für die Archivierung von Objekten]( https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html#sc-glacier) im *Amazon Simple Storage Service-Benutzerhandbuch*.
1. Laden Sie nach Abschluss des Auftrags die Bytes mit der Operation [Get Job Output (GET output)](api-job-output-get.md) herunter.
Sie können alle Bytes herunterladen oder einen Bytebereich festlegen, sodass nur ein Teil der Auftragsausgabe heruntergeladen wird. Bei einer größeren Ausgabemenge bietet es sich an, die Ausgabe in Datenblöcken herunterzuladen, um Fehlern beim Herunterladen, wie z. B. durch einen Ausfall des Netzwerks, vorzubeugen. Wenn Sie eine einzige Anforderung zum Abrufen der gesamten Auftragsausgabe übermitteln, sind Sie bei Netzwerkausfällen gezwungen, den Vorgang zum Herunterladen der Ausgabe von Anfang an neu zu starten. Wenn Sie die Ausgabe jedoch in Datenblöcken herunterladen, müssen Sie bei einem Fehler nur den betroffenen Teil der Ausgabe und nicht die gesamten Ausgabedaten erneut herunterladen.
Amazon Glacier muss einen Auftrag abschließen, bevor Sie seine Ausgabe abrufen können. Nachdem ein Auftrag abgeschlossen wurde, bleibt er 24 Stunden lang verfügbar. Sie haben also 24 Stunden Zeit, um nach Beendigung des Auftrags die Ausgabe herunterzuladen. Die Wiederherstellung kann jederzeit innerhalb von 24 Stunden nach Abschluss des Auftrags ablaufen. Verwenden Sie eine der folgenden Optionen, um den Status des Auftrags zu überprüfen und festzustellen, ob der Auftrag abgeschlossen ist:
+ **Warten Sie auf eine Benachrichtigung über den Abschluss des** Auftrags — Sie können ein Amazon Simple Notification Service (Amazon SNS) -Thema angeben, zu dem Amazon Glacier nach Abschluss des Auftrags eine Benachrichtigung senden kann. Amazon Glacier sendet erst dann eine Benachrichtigung, wenn der Auftrag abgeschlossen ist.
Beim Initiieren eines Auftrags können Sie ein Amazon-SNS-Thema für den Auftrag angeben. Zusätzlich zur Angabe eines Amazon SNS SNS-Themas in Ihrer Jobanfrage veröffentlicht Amazon Glacier auch eine Benachrichtigung zu diesem SNS-Thema, wenn Ihr Tresor Benachrichtigungen für Archivabrufereignisse eingerichtet hat. Weitere Informationen finden Sie unter [Konfiguration von Tresor-Benachrichtigungen in Amazon Glacier](configuring-notifications.md).
+ **Jobinformationen explizit anfordern** — Sie können auch die Amazon `Describe Job` Glacier-API-Operation ([Describe Job (GET JobID)](api-describe-job-get.md)) verwenden, um regelmäßig Jobinformationen abzufragen. Wir empfehlen jedoch die Verwendung von Amazon-SNS-Benachrichtigungen.
**Anmerkung**
Die Informationen, die Sie in der Amazon-SNS-Benachrichtigung erhalten, sind identisch mit den Informationen, die Sie durch Aufrufen des `Describe Job`-API-Vorgangs erhalten.
## Archiv-Abrufoptionen
Entsprechend den Anforderungen im Hinblick auf Zugriffszeit und Kosten können Sie beim Initiieren eines Auftrags zum Abrufen eines Archivs die folgenden Einstellungen festlegen. Informationen zu den Abrufpreisen finden Sie unter [Amazon Glacier-Preise](https://aws.amazon.com/s3/glacier/pricing/).
+ **Expedited** – Hiermit können Sie schnell auf Ihre Daten zugreifen, die in der Speicherklasse „S3 Glacier Flexible Retrieval“ oder der S3-Intelligent-Tiering-Archivzugriffsebene gespeichert sind, wenn gelegentliche dringende Anforderungen für die Wiederherstellung von Archiven erforderlich sind. Daten, die unter Verwendung von „Expedited“ abgerufen werden, stehen normalerweise innerhalb von 1 bis 5 Minuten zur Verfügung, außer wenn es sich um sehr große Archive (über 250 MB) handelt. Die bereitgestellte Kapazität stellt sicher, dass für Expedited-Abrufe Abrufkapazität verfügbar ist, wenn Sie sie benötigen. Weitere Informationen finden Sie unter [Bereitgestellte Kapazität](#api-downloading-an-archive-two-steps-retrieval-expedited-capacity).
+ **Standard** – Standardabrufe ermöglichen Ihnen den Zugriff auf alle Ihre Archive innerhalb einiger Stunden. Standardabrufe werden in der Regel innerhalb von 3 bis 5 Stunden ausgeführt. Standard ist die Standardoption für Abrufanforderungen, in denen keine Abrufoption angegeben ist.
+ **Massenabrufe** — Massenabrufe sind die kostengünstigste Amazon Glacier-Abruf-Option, mit der Sie große Datenmengen, sogar Petabyte, kostengünstig an einem Tag abrufen können. Bulk-Abrufe werden in der Regel innerhalb von 5 bis 12 Stunden ausgeführt.
Die folgende Tabelle fasst die Archivabrufoptionen zusammen. Informationen zu Preisen finden Sie unter [Amazon Glacier -Preise](https://aws.amazon.com/s3/glacier/pricing/).
| Service | Expedited (Beschleunigt) | Standard | Bulk (Masse) |
| --- | --- | --- | --- |
| Amazon Glacier | 1-5 Minuten | 3-5 Stunden | 5-12 Stunden |
Um einen`Expedited`, oder `Bulk` -Abruf `Standard` durchzuführen, setzen Sie das `Tier` Anforderungselement in der [https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOSTrestore.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOSTrestore.html)REST-API-Operationsanforderung auf die gewünschte Option oder die entsprechende Option in () oder. AWS Command Line Interface AWS CLI AWS SDKs Wenn Sie bereitgestellte Durchsatzkapazität gekauft haben, werden alle Expedited-Abrufe automatisch über Ihre bereitgestellte Kapazität erledigt.
### Bereitgestellte Kapazität
Die bereitgestellte Kapazität hilft sicherzustellen, dass für Expedited-Abrufe Abrufkapazität verfügbar ist, wenn Sie sie benötigen. Jede Kapazitätseinheit sorgt dafür, dass mindestens drei beschleunigte Abrufe alle 5 Minuten ausgeführt werden können und bietet einen Abrufdurchsatz von bis zu 150 Megabyte pro Sekunde (). MBps
Sie sollten bereitgestellte Abrufkapazität kaufen, wenn Ihre Workload einen sehr zuverlässigen und vorhersehbaren Zugriff auf eine Untermenge Ihrer Daten innerhalb von Minuten erforderlich macht. Ohne bereitgestellte Kapazität werden Expedited-Abrufe normalerweise akzeptiert, außer in seltenen Situationen unüblich hoher Nachfrage. Wenn Sie unbedingt Zugriff auf Expedited-Abrufe benötigen, müssen Sie auf alle Fälle eine bereitgestellte Abrufkapazität kaufen.
#### Kaufen von bereitgestellter Durchsatzkapazität
Sie können bereitgestellte Kapazitätseinheiten erwerben, indem Sie die Amazon Glacier-Konsole, den [Purchase Provisioned Capacity (POST provisioned-capacity)](api-PurchaseProvisionedCapacity.md) REST-API-Vorgang AWS SDKs, den oder den AWS CLI verwenden. Preisinformationen für bereitgestellte Kapazität finden Sie unter [Amazon Glacier Pricing](https://aws.amazon.com/s3/glacier/pricing/).
Eine bereitgestellte Kapazitätseinheit ist ab dem Datum und der Uhrzeit des Kaufs einen Monat lang gültig.
Wenn das Startdatum der 31. Tag eines Monats ist, dann ist der letzte Tag des nächsten Monats das Ablaufdatum. Beispiel: Ist das Startdatum der 31. August, dann ist der 30. September das Ablaufdatum. Ist das Startdatum der 31. Januar, dann ist der 28. Februar das Ablaufdatum.
**So erwerben Sie bereitgestellte Kapazität mithilfe der Amazon Glacier-Konsole**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon Glacier-Konsole zu [https://console.aws.amazon.com/glacier/Hause](https://console.aws.amazon.com/glacier/home).
1. Wählen Sie im Navigationsbereich auf der linken Seite **Datenabruf-Einstellungen** aus.
1. Wählen Sie unter **Bereitgestellte Kapazitätseinheiten (PCUs)** die Option **PCU kaufen** aus. Das Dialogfeld **PCU kaufen** wird angezeigt.
1. Wenn Sie bereitgestellte Kapazität erwerben möchten, geben Sie **confirm** im Feld **Kauf bestätigen** ein.
1. Wählen Sie **PCU kaufen** aus.
## Abrufen von Archivbereichen
Beim Abrufen eines Archivs von Amazon Glacier haben Sie die Möglichkeit, nur einen bestimmten Bereich bzw. einen Teil des Archivs abzurufen. In der Standardeinstellung wird das vollständige Archiv abgerufen. In den folgenden Fällen ist es von Vorteil einen bestimmten Bereich von Bytes anzugeben:
+ **Verwalten Sie Ihre Datendownloads** — Amazon Glacier ermöglicht das Herunterladen von abgerufenen Daten für 24 Stunden, nachdem die Abrufanforderung abgeschlossen ist. Sie können also einzelne Bereiche des Archivs separat herunterladen, um den gesamten Download-Vorgang über den verfügbaren Zeitraum zu verteilen.
+ **Abrufen eines bestimmten Teils eines großen Archivs**: Es kann beispielsweise vorkommen, dass Sie in der Vergangenheit viele Dateien aggregiert und zusammen in ein einziges Archiv hochgeladen haben, jetzt aber nur eine kleine Auswahl der Dateien abrufen möchten. In diesem Fall können Sie einen Bereich des Archivs angeben, der die gewünschten Dateien enthält, und eine Abrufanforderung übermitteln. Sie können allerdings auch mehrere Abrufanforderungen initiieren, die jeweils für einen Bereich mit einer oder mehreren Dateien gelten.
Beim Initiieren eines Abrufauftrags für bestimmte Bereiche müssen Sie sich bei der Angabe des Bereichs auf Megabytes beziehen. Das heißt, dass der Bytebereich bei null (am Anfang des Archivs) oder bei jedem nachfolgenden vollen Megabytewert beginnen kann (1 MB, 2 MB, 3 MB usw.).
Das Ende des Bereichs kann entweder das Ende Ihres Archivs oder ein beliebiges 1-MB-Intervall sein, das größer als der Anfang Ihres Bereichs ist. Wenn Sie beim Herunterladen der Daten Prüfsummenwerte erhalten möchten (nach Beendigung des Abrufauftrags), muss der Bereich, den Sie bei der Auftragsinitiierung anfordern, außerdem mit dem Struktur-Hash abgeglichen werden. Mithilfe von Prüfsummen können Sie sicherstellen, dass die Daten bei der Übertragung nicht beschädigt wurden. Weitere Informationen zum Megabyte- und Struktur-Hash-Abgleich finden Sie unter [Erhalten von Prüfsummen bei Daten-Download](checksum-calculations-range.md).
# Herunterladen eines Archivs in Amazon Glacier mit dem AWS 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 Herunterladen eines Archivs.
**Topics**
+ [Herunterladen eines Archivs mithilfe der High-Level-API von AWS SDK für Java](#downloading-an-archive-using-java-highlevel-api)
+ [Herunterladen eines Archivs mithilfe der Low-Level-API von AWS SDK für Java](#downloading-an-archive-using-java-lowlevel-api)
## Herunterladen eines Archivs mithilfe der High-Level-API von AWS SDK für Java
Die `ArchiveTransferManager`-Klasse der High-Level-API bietet die `download`-Methode, mit der Sie ein Archiv herunterladen können.
**Wichtig**
Die `ArchiveTransferManager`-Klasse erstellt ein Amazon Simple Notification Service (Amazon SNS)-Thema und eine Amazon Simple Queue Service (Amazon SQS)-Warteschlange, die dieses Thema abonniert hat. Die Klasse initiiert daraufhin den Abrufauftrag für das Archiv und fragt die Warteschlange für das Archiv nach der Verfügbarkeit ab. Wenn das Archiv verfügbar ist, beginnt der Download. Weitere Informationen zu Abrufzeiten finden Sie unter [Archiv-Abrufoptionen](downloading-an-archive-two-steps.md#api-downloading-an-archive-two-steps-retrieval-options).
### Beispiel: Herunterladen eines Archivs mithilfe der High-Level-API von AWS SDK für Java
Mit dem folgenden Java-Beispielcode wird ein Archiv aus einem Tresor („`examplevault`“) in der Region „USA West (Oregon)“ („`us-west-2`“) heruntergeladen.
step-by-stepAnweisungen zum Ausführen 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 einer vorhandenen Archiv-ID und dem lokalen Dateipfad zum Speicherort des heruntergeladenen Archivs aktualisieren.
**Example**
```
import java.io.File;
import java.io.IOException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.glacier.AmazonGlacierClient;
import com.amazonaws.services.glacier.transfer.ArchiveTransferManager;
import com.amazonaws.services.sns.AmazonSNSClient;
import com.amazonaws.services.sqs.AmazonSQSClient;
public class ArchiveDownloadHighLevel {
public static String vaultName = "examplevault";
public static String archiveId = "*** provide archive ID ***";
public static String downloadFilePath = "*** provide location to download archive ***";
public static AmazonGlacierClient glacierClient;
public static AmazonSQSClient sqsClient;
public static AmazonSNSClient snsClient;
public static void main(String[] args) throws IOException {
ProfileCredentialsProvider credentials = new ProfileCredentialsProvider();
glacierClient = new AmazonGlacierClient(credentials);
sqsClient = new AmazonSQSClient(credentials);
snsClient = new AmazonSNSClient(credentials);
glacierClient.setEndpoint("glacier.us-west-2.amazonaws.com");
sqsClient.setEndpoint("sqs.us-west-2.amazonaws.com");
snsClient.setEndpoint("sns.us-west-2.amazonaws.com");
try {
ArchiveTransferManager atm = new ArchiveTransferManager(glacierClient, sqsClient, snsClient);
atm.download(vaultName, archiveId, new File(downloadFilePath));
System.out.println("Downloaded file to " + downloadFilePath);
} catch (Exception e)
{
System.err.println(e);
}
}
}
```
## Herunterladen eines Archivs mithilfe der Low-Level-API von AWS SDK für Java
Nachfolgend werden die Schritte zum Abrufen eines Tresorbestands mithilfe der Low-Level-API für AWS SDK für Java beschrieben.
1. Erstellen einer Instance der `AmazonGlacierClient`-Klasse (Client).
Sie müssen eine AWS Region angeben, aus der Sie das Archiv herunterladen möchten. Alle Operationen, die Sie mit diesem Client ausführen, gelten für diese AWS Region.
1. Initiieren eines mehrteiligen `archive-retrieval`-Auftrags durch Ausführen der `initiateJob`-Methode.
Sie geben Jobinformationen an, z. B. die Archiv-ID des Archivs, das Sie herunterladen möchten, und das optionale Amazon SNS SNS-Thema, zu dem Amazon Glacier (Amazon Glacier) eine Nachricht zum Abschluss des Auftrags veröffentlichen soll, indem Sie eine Instanz der `InitiateJobRequest` Klasse erstellen. Amazon Glacier gibt als Antwort eine Job-ID zurück. Die Antwort ist in einer Instance der `InitiateJobResult`-Klasse verfügbar.
```
JobParameters jobParameters = new JobParameters()
.withArchiveId("*** provide an archive id ***")
.withDescription("archive retrieval")
.withRetrievalByteRange("*** provide a retrieval range***") // optional
.withType("archive-retrieval");
InitiateJobResult initiateJobResult = client.initiateJob(new InitiateJobRequest()
.withJobParameters(jobParameters)
.withVaultName(vaultName));
String jobId = initiateJobResult.getJobId();
```
Sie können optional einen Bytebereich angeben, um Amazon Glacier aufzufordern, nur einen Teil des Archivs vorzubereiten. Sie können beispielsweise die vorherige Anforderung aktualisieren, indem Sie die folgende Anweisung hinzufügen und von Amazon Glacier nur die Vorbereitung des 1 bis 2 MB großen Archivteils anfordern.
```
int ONE_MEG = 1048576;
String retrievalByteRange = String.format("%s-%s", ONE_MEG, 2*ONE_MEG -1);
JobParameters jobParameters = new JobParameters()
.withType("archive-retrieval")
.withArchiveId(archiveId)
.withRetrievalByteRange(retrievalByteRange)
.withSNSTopic(snsTopicARN);
InitiateJobResult initiateJobResult = client.initiateJob(new InitiateJobRequest()
.withJobParameters(jobParameters)
.withVaultName(vaultName));
String jobId = initiateJobResult.getJobId();
```
1. Warten Sie, bis der -Auftrag abgeschlossen wurde.
Sie müssen warten, bis die Ausgabe des Auftrags zum Download bereit ist. Wenn Sie entweder im Tresor eine Benachrichtigungskonfiguration eingerichtet haben, die ein Amazon Simple Notification Service (Amazon SNS) -Thema identifiziert, oder ein Amazon SNS-Thema angegeben haben, als Sie einen Job initiiert haben, sendet Amazon Glacier nach Abschluss des Jobs eine Nachricht an dieses Thema.
Sie können Amazon Glacier auch abfragen, indem Sie die `describeJob` Methode aufrufen, um den Status der Auftragsabwicklung zu ermitteln. Allerdings wird die Verwendung eines Amazon-SNS-Themas für Benachrichtigungen empfohlen.
1. Laden Sie die Auftragsausgabe (Archivdaten) herunter, indem Sie die `getJobOutput`-Methode ausführen.
Sie erstellen eine Instance der `GetJobOutputRequest`-Klasse, um die Informationen in der Anforderung, wie beispielsweise die Auftrags-ID und den Tresornamen, bereitzustellen. Die Ausgabe, die Amazon Glacier zurückgibt, ist im `GetJobOutputResult` Objekt verfügbar.
```
GetJobOutputRequest jobOutputRequest = new GetJobOutputRequest()
.withJobId("*** provide a job ID ***")
.withVaultName("*** provide a vault name ****");
GetJobOutputResult jobOutputResult = client.getJobOutput(jobOutputRequest);
// jobOutputResult.getBody() // Provides the input stream.
```
Mit dem vorherigen Codeabschnitt wird die gesamte Auftragsausgabe heruntergeladen. Sie können optional nur einen Teil der Ausgabe abrufen oder die gesamte Ausgabe in kleineren Datenblöcken herunterladen, indem Sie den Bytebereich für `GetJobOutputRequest` angeben.
```
GetJobOutputRequest jobOutputRequest = new GetJobOutputRequest()
.withJobId("*** provide a job ID ***")
.withRange("bytes=0-1048575") // Download only the first 1 MB of the output.
.withVaultName("*** provide a vault name ****");
```
Als Antwort auf Ihren `GetJobOutput` Anruf gibt Amazon Glacier die Prüfsumme des Teils der Daten zurück, den Sie heruntergeladen haben, sofern bestimmte Bedingungen erfüllt sind. Weitere Informationen finden Sie unter [Erhalten von Prüfsummen bei Daten-Download](checksum-calculations-range.md).
Um sicherzustellen, dass der Download fehlerfrei ist, können Sie dann die Prüfsumme auf der Clientseite berechnen und mit der Prüfsumme vergleichen, die Amazon Glacier in der Antwort gesendet hat.
Bei einem Job zum Abrufen von Archiven mit dem angegebenen optionalen Bereich enthält die Jobbeschreibung die Prüfsumme des Bereichs, den Sie abrufen (). SHA256 TreeHash Mit diesem Wert können Sie die Genauigkeit des gesamten später herunterzuladenden Byte-Bereichs weiter überprüfen. Sie können beispielsweise einen Auftrag initiieren, durch den zuerst ein mit dem Struktur-Hash abgeglichener Bereich abgerufen und dann die Ausgabe in Datenblöcken so heruntergeladen wird, dass für jede der `GetJobOutput`-Anforderungen eine Prüfsumme zurückgegeben wird. Anschließend können Sie die Prüfsumme für jeden auf der Clientseite heruntergeladenen Teil und schließlich das Struktur-Hash berechnen. Sie können sie mit der Prüfsumme vergleichen, die Amazon Glacier als Antwort auf Ihre Anfrage zur Beschreibung des Jobs zurückgibt, um sicherzustellen, dass der gesamte Bytebereich, den Sie heruntergeladen haben, mit dem Bytebereich übereinstimmt, der in Amazon Glacier gespeichert ist.
Ein funktionierendes Beispiel finden Sie unter [Beispiel 2: Abrufen eines Archivs mithilfe der Low-Level-API von AWS SDK für Java—Output in Chunks herunterladen](#downloading-an-archive-with-range-using-java-example).
### Beispiel 1: Abrufen eines Archivs mithilfe der Low-Level-API von AWS SDK für Java
Mit dem folgenden Java-Beispielcode wird ein Archiv aus dem angegebenen Tresor heruntergeladen. Nachdem der Auftrag abgeschlossen ist, lädt der Beispielcode die gesamte Ausgabe in einem einzigen `getJobOutput`-Aufruf herunter. Ein Beispiel für das Herunterladen der Ausgabe in Datenblöcken finden Sie unter [Beispiel 2: Abrufen eines Archivs mithilfe der Low-Level-API von AWS SDK für Java—Output in Chunks herunterladen](#downloading-an-archive-with-range-using-java-example).
Das Beispiel führt die folgenden Aufgaben durch:
+ Erstellt ein Amazon Simple Notification Service (Amazon SNS)-Thema.
Amazon Glacier sendet nach Abschluss des Auftrags eine Benachrichtigung zu diesem Thema.
+ Erstellt eine Amazon Simple Queue Service (Amazon SQS)-Warteschlange.
Im Beispiel wird der Warteschlange eine Richtlinie angefügt, damit das Amazon-SNS-Thema Nachrichten in der Warteschlange veröffentlichen kann.
+ Initiiert einen Auftrag zum Herunterladen des angegebenen Archivs.
In der Jobanfrage ist das Amazon SNS SNS-Thema angegeben, das erstellt wurde, sodass Amazon Glacier nach Abschluss des Jobs eine Benachrichtigung zu dem Thema veröffentlichen kann.
+ Prüft die Amazon-SQS-Warteschlange regelmäßig auf Nachrichten, die die Auftrags-ID enthalten.
Ist eine Nachricht vorhanden, parsen Sie das JSON und prüfen Sie, ob der Auftrag erfolgreich abgeschlossen wurde. Wenn eine Nachricht enthalten ist, laden Sie das Archiv herunter.
+ Bereinigt das System durch Löschen des Amazon-SNS-Themas und der erstellten Amazon-SQS-Warteschlange.
```
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.codehaus.jackson.JsonFactory;
import org.codehaus.jackson.JsonNode;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.JsonParser;
import org.codehaus.jackson.map.ObjectMapper;
import com.amazonaws.AmazonClientException;
import com.amazonaws.auth.policy.Policy;
import com.amazonaws.auth.policy.Principal;
import com.amazonaws.auth.policy.Resource;
import com.amazonaws.auth.policy.Statement;
import com.amazonaws.auth.policy.Statement.Effect;
import com.amazonaws.auth.policy.actions.SQSActions;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.glacier.AmazonGlacierClient;
import com.amazonaws.services.glacier.model.GetJobOutputRequest;
import com.amazonaws.services.glacier.model.GetJobOutputResult;
import com.amazonaws.services.glacier.model.InitiateJobRequest;
import com.amazonaws.services.glacier.model.InitiateJobResult;
import com.amazonaws.services.glacier.model.JobParameters;
import com.amazonaws.services.sns.AmazonSNSClient;
import com.amazonaws.services.sns.model.CreateTopicRequest;
import com.amazonaws.services.sns.model.CreateTopicResult;
import com.amazonaws.services.sns.model.DeleteTopicRequest;
import com.amazonaws.services.sns.model.SubscribeRequest;
import com.amazonaws.services.sns.model.SubscribeResult;
import com.amazonaws.services.sns.model.UnsubscribeRequest;
import com.amazonaws.services.sqs.AmazonSQSClient;
import com.amazonaws.services.sqs.model.CreateQueueRequest;
import com.amazonaws.services.sqs.model.CreateQueueResult;
import com.amazonaws.services.sqs.model.DeleteQueueRequest;
import com.amazonaws.services.sqs.model.GetQueueAttributesRequest;
import com.amazonaws.services.sqs.model.GetQueueAttributesResult;
import com.amazonaws.services.sqs.model.Message;
import com.amazonaws.services.sqs.model.ReceiveMessageRequest;
import com.amazonaws.services.sqs.model.SetQueueAttributesRequest;
public class AmazonGlacierDownloadArchiveWithSQSPolling {
public static String archiveId = "*** provide archive ID ****";
public static String vaultName = "*** provide vault name ***";
public static String snsTopicName = "*** provide topic name ***";
public static String sqsQueueName = "*** provide queue name ***";
public static String sqsQueueARN;
public static String sqsQueueURL;
public static String snsTopicARN;
public static String snsSubscriptionARN;
public static String fileName = "*** provide file name ***";
public static String region = "*** region ***";
public static long sleepTime = 600;
public static AmazonGlacierClient client;
public static AmazonSQSClient sqsClient;
public static AmazonSNSClient snsClient;
public static void main(String[] args) throws IOException {
ProfileCredentialsProvider credentials = new ProfileCredentialsProvider();
client = new AmazonGlacierClient(credentials);
client.setEndpoint("https://glacier." + region + ".amazonaws.com");
sqsClient = new AmazonSQSClient(credentials);
sqsClient.setEndpoint("https://sqs." + region + ".amazonaws.com");
snsClient = new AmazonSNSClient(credentials);
snsClient.setEndpoint("https://sns." + region + ".amazonaws.com");
try {
setupSQS();
setupSNS();
String jobId = initiateJobRequest();
System.out.println("Jobid = " + jobId);
Boolean success = waitForJobToComplete(jobId, sqsQueueURL);
if (!success) { throw new Exception("Job did not complete successfully."); }
downloadJobOutput(jobId);
cleanUp();
} catch (Exception e) {
System.err.println("Archive retrieval failed.");
System.err.println(e);
}
}
private static void setupSQS() {
CreateQueueRequest request = new CreateQueueRequest()
.withQueueName(sqsQueueName);
CreateQueueResult result = sqsClient.createQueue(request);
sqsQueueURL = result.getQueueUrl();
GetQueueAttributesRequest qRequest = new GetQueueAttributesRequest()
.withQueueUrl(sqsQueueURL)
.withAttributeNames("QueueArn");
GetQueueAttributesResult qResult = sqsClient.getQueueAttributes(qRequest);
sqsQueueARN = qResult.getAttributes().get("QueueArn");
Policy sqsPolicy =
new Policy().withStatements(
new Statement(Effect.Allow)
.withPrincipals(Principal.AllUsers)
.withActions(SQSActions.SendMessage)
.withResources(new Resource(sqsQueueARN)));
Map queueAttributes = new HashMap();
queueAttributes.put("Policy", sqsPolicy.toJson());
sqsClient.setQueueAttributes(new SetQueueAttributesRequest(sqsQueueURL, queueAttributes));
}
private static void setupSNS() {
CreateTopicRequest request = new CreateTopicRequest()
.withName(snsTopicName);
CreateTopicResult result = snsClient.createTopic(request);
snsTopicARN = result.getTopicArn();
SubscribeRequest request2 = new SubscribeRequest()
.withTopicArn(snsTopicARN)
.withEndpoint(sqsQueueARN)
.withProtocol("sqs");
SubscribeResult result2 = snsClient.subscribe(request2);
snsSubscriptionARN = result2.getSubscriptionArn();
}
private static String initiateJobRequest() {
JobParameters jobParameters = new JobParameters()
.withType("archive-retrieval")
.withArchiveId(archiveId)
.withSNSTopic(snsTopicARN);
InitiateJobRequest request = new InitiateJobRequest()
.withVaultName(vaultName)
.withJobParameters(jobParameters);
InitiateJobResult response = client.initiateJob(request);
return response.getJobId();
}
private static Boolean waitForJobToComplete(String jobId, String sqsQueueUrl) throws InterruptedException, JsonParseException, IOException {
Boolean messageFound = false;
Boolean jobSuccessful = false;
ObjectMapper mapper = new ObjectMapper();
JsonFactory factory = mapper.getJsonFactory();
while (!messageFound) {
List msgs = sqsClient.receiveMessage(
new ReceiveMessageRequest(sqsQueueUrl).withMaxNumberOfMessages(10)).getMessages();
if (msgs.size() > 0) {
for (Message m : msgs) {
JsonParser jpMessage = factory.createJsonParser(m.getBody());
JsonNode jobMessageNode = mapper.readTree(jpMessage);
String jobMessage = jobMessageNode.get("Message").getTextValue();
JsonParser jpDesc = factory.createJsonParser(jobMessage);
JsonNode jobDescNode = mapper.readTree(jpDesc);
String retrievedJobId = jobDescNode.get("JobId").getTextValue();
String statusCode = jobDescNode.get("StatusCode").getTextValue();
if (retrievedJobId.equals(jobId)) {
messageFound = true;
if (statusCode.equals("Succeeded")) {
jobSuccessful = true;
}
}
}
} else {
Thread.sleep(sleepTime * 1000);
}
}
return (messageFound && jobSuccessful);
}
private static void downloadJobOutput(String jobId) throws IOException {
GetJobOutputRequest getJobOutputRequest = new GetJobOutputRequest()
.withVaultName(vaultName)
.withJobId(jobId);
GetJobOutputResult getJobOutputResult = client.getJobOutput(getJobOutputRequest);
InputStream input = new BufferedInputStream(getJobOutputResult.getBody());
OutputStream output = null;
try {
output = new BufferedOutputStream(new FileOutputStream(fileName));
byte[] buffer = new byte[1024 * 1024];
int bytesRead = 0;
do {
bytesRead = input.read(buffer);
if (bytesRead <= 0) break;
output.write(buffer, 0, bytesRead);
} while (bytesRead > 0);
} catch (IOException e) {
throw new AmazonClientException("Unable to save archive", e);
} finally {
try {input.close();} catch (Exception e) {}
try {output.close();} catch (Exception e) {}
}
System.out.println("Retrieved archive to " + fileName);
}
private static void cleanUp() {
snsClient.unsubscribe(new UnsubscribeRequest(snsSubscriptionARN));
snsClient.deleteTopic(new DeleteTopicRequest(snsTopicARN));
sqsClient.deleteQueue(new DeleteQueueRequest(sqsQueueURL));
}
}
```
### Beispiel 2: Abrufen eines Archivs mithilfe der Low-Level-API von AWS SDK für Java—Output in Chunks herunterladen
Das folgende Java-Codebeispiel ruft ein Archiv von Amazon Glacier ab. Der Beispielcode gibt den abzurufenden Bytebereich in einem `GetJobOutputRequest`-Objekt an und lädt die Auftragsausgabe in Datenblöcken herunter.
```
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.amazonaws.auth.policy.Policy;
import com.amazonaws.auth.policy.Principal;
import com.amazonaws.auth.policy.Resource;
import com.amazonaws.auth.policy.Statement;
import com.amazonaws.auth.policy.Statement.Effect;
import com.amazonaws.auth.policy.actions.SQSActions;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.glacier.AmazonGlacierClient;
import com.amazonaws.services.glacier.TreeHashGenerator;
import com.amazonaws.services.glacier.model.GetJobOutputRequest;
import com.amazonaws.services.glacier.model.GetJobOutputResult;
import com.amazonaws.services.glacier.model.InitiateJobRequest;
import com.amazonaws.services.glacier.model.InitiateJobResult;
import com.amazonaws.services.glacier.model.JobParameters;
import com.amazonaws.services.sns.AmazonSNSClient;
import com.amazonaws.services.sns.model.CreateTopicRequest;
import com.amazonaws.services.sns.model.CreateTopicResult;
import com.amazonaws.services.sns.model.DeleteTopicRequest;
import com.amazonaws.services.sns.model.SubscribeRequest;
import com.amazonaws.services.sns.model.SubscribeResult;
import com.amazonaws.services.sns.model.UnsubscribeRequest;
import com.amazonaws.services.sqs.AmazonSQSClient;
import com.amazonaws.services.sqs.model.CreateQueueRequest;
import com.amazonaws.services.sqs.model.CreateQueueResult;
import com.amazonaws.services.sqs.model.DeleteQueueRequest;
import com.amazonaws.services.sqs.model.GetQueueAttributesRequest;
import com.amazonaws.services.sqs.model.GetQueueAttributesResult;
import com.amazonaws.services.sqs.model.Message;
import com.amazonaws.services.sqs.model.ReceiveMessageRequest;
import com.amazonaws.services.sqs.model.SetQueueAttributesRequest;
public class ArchiveDownloadLowLevelWithRange {
public static String vaultName = "*** provide vault name ***";
public static String archiveId = "*** provide archive id ***";
public static String snsTopicName = "glacier-temp-sns-topic";
public static String sqsQueueName = "glacier-temp-sqs-queue";
public static long downloadChunkSize = 4194304; // 4 MB
public static String sqsQueueARN;
public static String sqsQueueURL;
public static String snsTopicARN;
public static String snsSubscriptionARN;
public static String fileName = "*** provide file name to save archive to ***";
public static String region = "*** region ***";
public static long sleepTime = 600;
public static AmazonGlacierClient client;
public static AmazonSQSClient sqsClient;
public static AmazonSNSClient snsClient;
public static void main(String[] args) throws IOException {
ProfileCredentialsProvider credentials = new ProfileCredentialsProvider();
client = new AmazonGlacierClient(credentials);
client.setEndpoint("https://glacier." + region + ".amazonaws.com");
sqsClient = new AmazonSQSClient(credentials);
sqsClient.setEndpoint("https://sqs." + region + ".amazonaws.com");
snsClient = new AmazonSNSClient(credentials);
snsClient.setEndpoint("https://sns." + region + ".amazonaws.com");
try {
setupSQS();
setupSNS();
String jobId = initiateJobRequest();
System.out.println("Jobid = " + jobId);
long archiveSizeInBytes = waitForJobToComplete(jobId, sqsQueueURL);
if (archiveSizeInBytes==-1) { throw new Exception("Job did not complete successfully."); }
downloadJobOutput(jobId, archiveSizeInBytes);
cleanUp();
} catch (Exception e) {
System.err.println("Archive retrieval failed.");
System.err.println(e);
}
}
private static void setupSQS() {
CreateQueueRequest request = new CreateQueueRequest()
.withQueueName(sqsQueueName);
CreateQueueResult result = sqsClient.createQueue(request);
sqsQueueURL = result.getQueueUrl();
GetQueueAttributesRequest qRequest = new GetQueueAttributesRequest()
.withQueueUrl(sqsQueueURL)
.withAttributeNames("QueueArn");
GetQueueAttributesResult qResult = sqsClient.getQueueAttributes(qRequest);
sqsQueueARN = qResult.getAttributes().get("QueueArn");
Policy sqsPolicy =
new Policy().withStatements(
new Statement(Effect.Allow)
.withPrincipals(Principal.AllUsers)
.withActions(SQSActions.SendMessage)
.withResources(new Resource(sqsQueueARN)));
Map queueAttributes = new HashMap();
queueAttributes.put("Policy", sqsPolicy.toJson());
sqsClient.setQueueAttributes(new SetQueueAttributesRequest(sqsQueueURL, queueAttributes));
}
private static void setupSNS() {
CreateTopicRequest request = new CreateTopicRequest()
.withName(snsTopicName);
CreateTopicResult result = snsClient.createTopic(request);
snsTopicARN = result.getTopicArn();
SubscribeRequest request2 = new SubscribeRequest()
.withTopicArn(snsTopicARN)
.withEndpoint(sqsQueueARN)
.withProtocol("sqs");
SubscribeResult result2 = snsClient.subscribe(request2);
snsSubscriptionARN = result2.getSubscriptionArn();
}
private static String initiateJobRequest() {
JobParameters jobParameters = new JobParameters()
.withType("archive-retrieval")
.withArchiveId(archiveId)
.withSNSTopic(snsTopicARN);
InitiateJobRequest request = new InitiateJobRequest()
.withVaultName(vaultName)
.withJobParameters(jobParameters);
InitiateJobResult response = client.initiateJob(request);
return response.getJobId();
}
private static long waitForJobToComplete(String jobId, String sqsQueueUrl) throws InterruptedException, JsonParseException, IOException {
Boolean messageFound = false;
Boolean jobSuccessful = false;
long archiveSizeInBytes = -1;
ObjectMapper mapper = new ObjectMapper();
JsonFactory factory = mapper.getFactory();
while (!messageFound) {
List msgs = sqsClient.receiveMessage(
new ReceiveMessageRequest(sqsQueueUrl).withMaxNumberOfMessages(10)).getMessages();
if (msgs.size() > 0) {
for (Message m : msgs) {
JsonParser jpMessage = factory.createJsonParser(m.getBody());
JsonNode jobMessageNode = mapper.readTree(jpMessage);
String jobMessage = jobMessageNode.get("Message").textValue();
JsonParser jpDesc = factory.createJsonParser(jobMessage);
JsonNode jobDescNode = mapper.readTree(jpDesc);
String retrievedJobId = jobDescNode.get("JobId").textValue();
String statusCode = jobDescNode.get("StatusCode").textValue();
archiveSizeInBytes = jobDescNode.get("ArchiveSizeInBytes").longValue();
if (retrievedJobId.equals(jobId)) {
messageFound = true;
if (statusCode.equals("Succeeded")) {
jobSuccessful = true;
}
}
}
} else {
Thread.sleep(sleepTime * 1000);
}
}
return (messageFound && jobSuccessful) ? archiveSizeInBytes : -1;
}
private static void downloadJobOutput(String jobId, long archiveSizeInBytes) throws IOException {
if (archiveSizeInBytes < 0) {
System.err.println("Nothing to download.");
return;
}
System.out.println("archiveSizeInBytes: " + archiveSizeInBytes);
FileOutputStream fstream = new FileOutputStream(fileName);
long startRange = 0;
long endRange = (downloadChunkSize > archiveSizeInBytes) ? archiveSizeInBytes -1 : downloadChunkSize - 1;
do {
GetJobOutputRequest getJobOutputRequest = new GetJobOutputRequest()
.withVaultName(vaultName)
.withRange("bytes=" + startRange + "-" + endRange)
.withJobId(jobId);
GetJobOutputResult getJobOutputResult = client.getJobOutput(getJobOutputRequest);
BufferedInputStream is = new BufferedInputStream(getJobOutputResult.getBody());
byte[] buffer = new byte[(int)(endRange - startRange + 1)];
System.out.println("Checksum received: " + getJobOutputResult.getChecksum());
System.out.println("Content range " + getJobOutputResult.getContentRange());
int totalRead = 0;
while (totalRead < buffer.length) {
int bytesRemaining = buffer.length - totalRead;
int read = is.read(buffer, totalRead, bytesRemaining);
if (read > 0) {
totalRead = totalRead + read;
} else {
break;
}
}
System.out.println("Calculated checksum: " + TreeHashGenerator.calculateTreeHash(new ByteArrayInputStream(buffer)));
System.out.println("read = " + totalRead);
fstream.write(buffer);
startRange = startRange + (long)totalRead;
endRange = ((endRange + downloadChunkSize) > archiveSizeInBytes) ? archiveSizeInBytes : (endRange + downloadChunkSize);
is.close();
} while (endRange <= archiveSizeInBytes && startRange < archiveSizeInBytes);
fstream.close();
System.out.println("Retrieved file to " + fileName);
}
private static void cleanUp() {
snsClient.unsubscribe(new UnsubscribeRequest(snsSubscriptionARN));
snsClient.deleteTopic(new DeleteTopicRequest(snsTopicARN));
sqsClient.deleteQueue(new DeleteQueueRequest(sqsQueueURL));
}
}
```
# Herunterladen eines Archivs in Amazon Glacier 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 zum Herunterladen eines Archivs.
**Topics**
+ [Herunterladen eines Archivs mithilfe der High-Level-API von AWS SDK für .NET](#downloading-an-archive-using-dotnet-highlevel-api)
+ [Herunterladen eines Archivs mithilfe der Low-Level-API von AWS SDK für .NET](#downloading-an-archive-using-dotnet-lowlevel-api)
## Herunterladen eines Archivs mithilfe der High-Level-API von AWS SDK für .NET
Die `ArchiveTransferManager`-Klasse der High-Level-API bietet die `Download`-Methode, mit der Sie ein Archiv herunterladen können.
**Wichtig**
Die `ArchiveTransferManager`-Klasse erstellt ein Amazon Simple Notification Service (Amazon SNS)-Thema und eine Amazon Simple Queue Service (Amazon SQS)-Warteschlange, die dieses Thema abonniert hat. Die Klasse initiiert daraufhin den Abrufauftrag für das Archiv und fragt die Warteschlange für das Archiv nach der Verfügbarkeit ab. Wenn das Archiv verfügbar ist, beginnt der Download. Weitere Informationen zu Abrufzeiten finden Sie unter [Archiv-Abrufoptionen](downloading-an-archive-two-steps.md#api-downloading-an-archive-two-steps-retrieval-options).
### Beispiel: Herunterladen eines Archivs mithilfe der High-Level-API von AWS SDK für .NET
Mit dem folgenden C\$1-Beispielcode wird ein Archiv aus einem Tresor („`examplevault`“) in der Region „USA West (Oregon)“ heruntergeladen.
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 einer vorhandenen Archiv-ID und dem lokalen Dateipfad zum Speicherort des heruntergeladenen Archivs aktualisieren.
```
using System;
using Amazon.Glacier;
using Amazon.Glacier.Transfer;
using Amazon.Runtime;
namespace glacier.amazon.com.rproxy.govskope.us.docsamples
{
class ArchiveDownloadHighLevel
{
static string vaultName = "examplevault";
static string archiveId = "*** Provide archive ID ***";
static string downloadFilePath = "*** Provide the file name and path to where to store the download ***";
public static void Main(string[] args)
{
try
{
var manager = new ArchiveTransferManager(Amazon.RegionEndpoint.USWest2);
var options = new DownloadOptions();
options.StreamTransferProgress += ArchiveDownloadHighLevel.progress;
// Download an archive.
Console.WriteLine("Intiating the archive retrieval job and then polling SQS queue for the archive to be available.");
Console.WriteLine("Once the archive is available, downloading will begin.");
manager.Download(vaultName, archiveId, downloadFilePath, options);
Console.WriteLine("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 int currentPercentage = -1;
static void progress(object sender, StreamTransferProgressArgs args)
{
if (args.PercentDone != currentPercentage)
{
currentPercentage = args.PercentDone;
Console.WriteLine("Downloaded {0}%", args.PercentDone);
}
}
}
}
```
## Herunterladen eines Archivs mithilfe der Low-Level-API von AWS SDK für .NET
Im Folgenden finden Sie die Schritte zum Herunterladen eines Amazon Glacier-Archivs (Amazon Glacier) mithilfe der Low-Level-API von. AWS SDK für .NET
1. Erstellen einer Instance der `AmazonGlacierClient`-Klasse (Client).
Sie müssen eine AWS Region angeben, aus der Sie das Archiv herunterladen möchten. Alle Operationen, die Sie mit diesem Client ausführen, gelten für diese AWS Region.
1. Initiieren eines mehrteiligen `archive-retrieval`-Auftrags durch Ausführen der `InitiateJob`-Methode.
Sie geben Jobinformationen an, z. B. die Archiv-ID des Archivs, das Sie herunterladen möchten, und das optionale Amazon SNS SNS-Thema, zu dem Amazon Glacier eine Nachricht über den Abschluss des Auftrags senden soll, indem Sie eine Instanz der `InitiateJobRequest` Klasse erstellen. Amazon Glacier gibt als Antwort eine Job-ID zurück. Die Antwort ist in einer Instance der `InitiateJobResponse`-Klasse verfügbar.
```
AmazonGlacierClient client;
client = new AmazonGlacierClient(Amazon.RegionEndpoint.USWest2);
InitiateJobRequest initJobRequest = new InitiateJobRequest()
{
VaultName = vaultName,
JobParameters = new JobParameters()
{
Type = "archive-retrieval",
ArchiveId = "*** Provide archive id ***",
SNSTopic = "*** Provide Amazon SNS topic ARN ***",
}
};
InitiateJobResponse initJobResponse = client.InitiateJob(initJobRequest);
string jobId = initJobResponse.JobId;
```
Sie können optional einen Bytebereich angeben, um Amazon Glacier aufzufordern, nur einen Teil des Archivs vorzubereiten, wie in der folgenden Anfrage gezeigt. In der Anfrage wird angegeben, dass Amazon Glacier nur den Teil des Archivs mit einer Größe von 1 MB bis 2 MB vorbereitet.
```
AmazonGlacierClient client;
client = new AmazonGlacierClient(Amazon.RegionEndpoint.USWest2);
InitiateJobRequest initJobRequest = new InitiateJobRequest()
{
VaultName = vaultName,
JobParameters = new JobParameters()
{
Type = "archive-retrieval",
ArchiveId = "*** Provide archive id ***",
SNSTopic = "*** Provide Amazon SNS topic ARN ***",
}
};
// Specify byte range.
int ONE_MEG = 1048576;
initJobRequest.JobParameters.RetrievalByteRange = string.Format("{0}-{1}", ONE_MEG, 2 * ONE_MEG -1);
InitiateJobResponse initJobResponse = client.InitiateJob(initJobRequest);
string jobId = initJobResponse.JobId;
```
1. Warten Sie, bis der -Auftrag abgeschlossen wurde.
Sie müssen warten, bis die Ausgabe des Auftrags zum Download bereit ist. Wenn Sie entweder im Tresor eine Benachrichtigungskonfiguration eingerichtet haben, die ein Amazon Simple Notification Service (Amazon SNS) -Thema identifiziert, oder ein Amazon SNS-Thema angegeben haben, als Sie einen Job initiiert haben, sendet Amazon Glacier nach Abschluss des Jobs eine Nachricht an dieses Thema. Das Codebeispiel im folgenden Abschnitt verwendet Amazon SNS for Amazon Glacier, um eine Nachricht zu veröffentlichen.
Sie können Amazon Glacier auch abfragen, indem Sie die `DescribeJob` Methode aufrufen, um den Status der Auftragsabwicklung zu ermitteln. Allerdings wird die Verwendung eines Amazon-SNS-Themas für Benachrichtigungen empfohlen.
1. Laden Sie die Auftragsausgabe (Archivdaten) herunter, indem Sie die `GetJobOutput`-Methode ausführen.
Sie erstellen eine Instance der `GetJobOutputRequest`-Klasse, um die Informationen in der Anforderung, wie beispielsweise die Auftrags-ID und den Tresornamen, bereitzustellen. Die Ausgabe, die Amazon Glacier zurückgibt, ist im `GetJobOutputResponse` Objekt verfügbar.
```
GetJobOutputRequest getJobOutputRequest = new GetJobOutputRequest()
{
JobId = jobId,
VaultName = vaultName
};
GetJobOutputResponse getJobOutputResponse = client.GetJobOutput(getJobOutputRequest);
using (Stream webStream = getJobOutputResponse.Body)
{
using (Stream fileToSave = File.OpenWrite(fileName))
{
CopyStream(webStream, fileToSave);
}
}
```
Mit dem vorherigen Codeabschnitt wird die gesamte Auftragsausgabe heruntergeladen. Sie können optional nur einen Teil der Ausgabe abrufen oder die gesamte Ausgabe in kleineren Datenblöcken herunterladen, indem Sie den Bytebereich für `GetJobOutputRequest` angeben.
```
GetJobOutputRequest getJobOutputRequest = new GetJobOutputRequest()
{
JobId = jobId,
VaultName = vaultName
};
getJobOutputRequest.SetRange(0, 1048575); // Download only the first 1 MB chunk of the output.
```
Als Antwort auf Ihren `GetJobOutput` Anruf gibt Amazon Glacier die Prüfsumme des Teils der Daten zurück, den Sie heruntergeladen haben, sofern bestimmte Bedingungen erfüllt sind. Weitere Informationen finden Sie unter [Erhalten von Prüfsummen bei Daten-Download](checksum-calculations-range.md).
Um sicherzustellen, dass der Download fehlerfrei ist, können Sie dann die Prüfsumme auf der Clientseite berechnen und sie mit der Prüfsumme vergleichen, die Amazon Glacier in der Antwort gesendet hat.
Bei einem Job zum Abrufen von Archiven mit dem angegebenen optionalen Bereich enthält die Jobbeschreibung beim Abrufen der Jobbeschreibung die Prüfsumme des Bereichs, den Sie abrufen (SHA256TreeHash). Sie können diesen Wert verwenden, um die Richtigkeit des gesamten Bytebereichs, den Sie später herunterladen, weiter zu überprüfen. Sie können beispielsweise einen Auftrag initiieren, durch den zuerst ein mit dem Struktur-Hash abgeglichener Bereich abgerufen und dann die Ausgabe in Datenblöcken so heruntergeladen wird, dass für jede der `GetJobOutput`-Anforderungen eine Prüfsumme zurückgegeben wird. Anschließend können Sie die Prüfsumme für jeden auf der Clientseite heruntergeladenen Teil und schließlich das Struktur-Hash berechnen. Sie können sie mit der Prüfsumme vergleichen, die Amazon Glacier als Antwort auf Ihre Anfrage zur Beschreibung des Jobs zurückgibt, um sicherzustellen, dass der gesamte Bytebereich, den Sie heruntergeladen haben, mit dem Bytebereich übereinstimmt, der in Amazon Glacier gespeichert ist.
Ein funktionierendes Beispiel finden Sie unter [Beispiel 2: Abrufen eines Archivs mithilfe der Low-Level-API von AWS SDK für .NET—Download Output in Chunks](#creating-vaults-sdk-dotnet-example2).
### Beispiel 1: Abrufen eines Archivs mithilfe der Low-Level-API von AWS SDK für .NET
Mit dem folgenden C\$1-Beispielcode wird ein Archiv aus dem angegebenen Tresor heruntergeladen. Nachdem der Auftrag abgeschlossen ist, lädt der Beispielcode die gesamte Ausgabe in einem einzigen `GetJobOutput`-Aufruf herunter. Ein Beispiel für das Herunterladen der Ausgabe in Datenblöcken finden Sie unter [Beispiel 2: Abrufen eines Archivs mithilfe der Low-Level-API von AWS SDK für .NET—Download Output in Chunks](#creating-vaults-sdk-dotnet-example2).
Das Beispiel führt die folgenden Aufgaben durch:
+ Richtet ein Amazon Simple Notification Service (Amazon SNS)-Thema ein.
Amazon Glacier sendet nach Abschluss des Auftrags eine Benachrichtigung zu diesem Thema.
+ Richtet eine Amazon Simple Queue Service (Amazon SQS)-Warteschlange ein.
Im Beispiel wird der Warteschlange eine Richtlinie angefügt, damit das Amazon-SNS-Thema Nachrichten veröffentlichen kann.
+ Initiiert einen Auftrag zum Herunterladen des angegebenen Archivs.
In der Jobanfrage gibt das Beispiel das Amazon SNS SNS-Thema an, sodass Amazon Glacier nach Abschluss des Auftrags eine Nachricht senden kann.
+ Überprüft regelmäßig die Amazon-SQS-Warteschlange auf Nachrichten.
Ist eine Nachricht vorhanden, parsen Sie das JSON und prüfen Sie, ob der Auftrag erfolgreich abgeschlossen wurde. Wenn eine Nachricht enthalten ist, laden Sie das Archiv herunter. Im Codebeispiel wird die JSON.NET-Bibliothek (siehe [JSON.NET](http://json.codeplex.com/)) zum Analysieren von JSON verwendet.
+ Bereinigt das System durch Löschen des Amazon-SNS-Themas und der erstellten Amazon-SQS-Warteschlange.
```
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using Amazon.Glacier;
using Amazon.Glacier.Model;
using Amazon.Runtime;
using Amazon.SimpleNotificationService;
using Amazon.SimpleNotificationService.Model;
using Amazon.SQS;
using Amazon.SQS.Model;
using Newtonsoft.Json;
namespace glacier.amazon.com.rproxy.govskope.us.docsamples
{
class ArchiveDownloadLowLevelUsingSNSSQS
{
static string topicArn;
static string queueUrl;
static string queueArn;
static string vaultName = "*** Provide vault name ***";
static string archiveID = "*** Provide archive ID ***";
static string fileName = "*** Provide the file name and path to where to store downloaded archive ***";
static AmazonSimpleNotificationServiceClient snsClient;
static AmazonSQSClient sqsClient;
const string SQS_POLICY =
"{" +
" \"Version\" : \"2012-10-17\",&TCX5-2025-waiver;" +
" \"Statement\" : [" +
" {" +
" \"Sid\" : \"sns-rule\"," +
" \"Effect\" : \"Allow\"," +
" \"Principal\" : {\"Service\" : \"sns.amazonaws.com\" }," +
" \"Action\" : \"sqs:SendMessage\"," +
" \"Resource\" : \"{QueueArn}\"," +
" \"Condition\" : {" +
" \"ArnLike\" : {" +
" \"aws:SourceArn\" : \"{TopicArn}\"" +
" }" +
" }" +
" }" +
" ]" +
"}";
public static void Main(string[] args)
{
AmazonGlacierClient client;
try
{
using (client = new AmazonGlacierClient(Amazon.RegionEndpoint.USWest2))
{
Console.WriteLine("Setup SNS topic and SQS queue.");
SetupTopicAndQueue();
Console.WriteLine("To continue, press Enter"); Console.ReadKey();
Console.WriteLine("Retrieving...");
RetrieveArchive(client);
}
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); }
finally
{
// Delete SNS topic and SQS queue.
snsClient.DeleteTopic(new DeleteTopicRequest() { TopicArn = topicArn });
sqsClient.DeleteQueue(new DeleteQueueRequest() { QueueUrl = queueUrl });
}
}
static void SetupTopicAndQueue()
{
snsClient = new AmazonSimpleNotificationServiceClient(Amazon.RegionEndpoint.USWest2);
sqsClient = new AmazonSQSClient(Amazon.RegionEndpoint.USWest2);
long ticks = DateTime.Now.Ticks;
topicArn = snsClient.CreateTopic(new CreateTopicRequest { Name = "GlacierDownload-" + ticks }).TopicArn;
Console.Write("topicArn: "); Console.WriteLine(topicArn);
CreateQueueRequest createQueueRequest = new CreateQueueRequest();
createQueueRequest.QueueName = "GlacierDownload-" + ticks;
CreateQueueResponse createQueueResponse = sqsClient.CreateQueue(createQueueRequest);
queueUrl = createQueueResponse.QueueUrl;
Console.Write("QueueURL: "); Console.WriteLine(queueUrl);
GetQueueAttributesRequest getQueueAttributesRequest = new GetQueueAttributesRequest();
getQueueAttributesRequest.AttributeNames = new List { "QueueArn" };
getQueueAttributesRequest.QueueUrl = queueUrl;
GetQueueAttributesResponse response = sqsClient.GetQueueAttributes(getQueueAttributesRequest);
queueArn = response.QueueARN;
Console.Write("QueueArn: "); Console.WriteLine(queueArn);
// Setup the Amazon SNS topic to publish to the SQS queue.
snsClient.Subscribe(new SubscribeRequest()
{
Protocol = "sqs",
Endpoint = queueArn,
TopicArn = topicArn
});
// Add policy to the queue so SNS can send messages to the queue.
var policy = SQS_POLICY.Replace("{TopicArn}", topicArn).Replace("{QueueArn}", queueArn);
sqsClient.SetQueueAttributes(new SetQueueAttributesRequest()
{
QueueUrl = queueUrl,
Attributes = new Dictionary
{
{ QueueAttributeName.Policy, policy }
}
});
}
static void RetrieveArchive(AmazonGlacierClient client)
{
// Initiate job.
InitiateJobRequest initJobRequest = new InitiateJobRequest()
{
VaultName = vaultName,
JobParameters = new JobParameters()
{
Type = "archive-retrieval",
ArchiveId = archiveID,
Description = "This job is to download archive.",
SNSTopic = topicArn,
}
};
InitiateJobResponse initJobResponse = client.InitiateJob(initJobRequest);
string jobId = initJobResponse.JobId;
// Check queue for a message and if job completed successfully, download archive.
ProcessQueue(jobId, client);
}
private static void ProcessQueue(string jobId, AmazonGlacierClient client)
{
ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest() { QueueUrl = queueUrl, MaxNumberOfMessages = 1 };
bool jobDone = false;
while (!jobDone)
{
Console.WriteLine("Poll SQS queue");
ReceiveMessageResponse receiveMessageResponse = sqsClient.ReceiveMessage(receiveMessageRequest);
if (receiveMessageResponse.Messages.Count == 0)
{
Thread.Sleep(10000 * 60);
continue;
}
Console.WriteLine("Got message");
Message message = receiveMessageResponse.Messages[0];
Dictionary outerLayer = JsonConvert.DeserializeObject>(message.Body);
Dictionary fields = JsonConvert.DeserializeObject>(outerLayer["Message"]);
string statusCode = fields["StatusCode"] as string;
if (string.Equals(statusCode, GlacierUtils.JOB_STATUS_SUCCEEDED, StringComparison.InvariantCultureIgnoreCase))
{
Console.WriteLine("Downloading job output");
DownloadOutput(jobId, client); // Save job output to the specified file location.
}
else if (string.Equals(statusCode, GlacierUtils.JOB_STATUS_FAILED, StringComparison.InvariantCultureIgnoreCase))
Console.WriteLine("Job failed... cannot download the archive.");
jobDone = true;
sqsClient.DeleteMessage(new DeleteMessageRequest() { QueueUrl = queueUrl, ReceiptHandle = message.ReceiptHandle });
}
}
private static void DownloadOutput(string jobId, AmazonGlacierClient client)
{
GetJobOutputRequest getJobOutputRequest = new GetJobOutputRequest()
{
JobId = jobId,
VaultName = vaultName
};
GetJobOutputResponse getJobOutputResponse = client.GetJobOutput(getJobOutputRequest);
using (Stream webStream = getJobOutputResponse.Body)
{
using (Stream fileToSave = File.OpenWrite(fileName))
{
CopyStream(webStream, fileToSave);
}
}
}
public static void CopyStream(Stream input, Stream output)
{
byte[] buffer = new byte[65536];
int length;
while ((length = input.Read(buffer, 0, buffer.Length)) > 0)
{
output.Write(buffer, 0, length);
}
}
}
}
```
### Beispiel 2: Abrufen eines Archivs mithilfe der Low-Level-API von AWS SDK für .NET—Download Output in Chunks
Das folgende C\$1-Codebeispiel ruft ein Archiv von Amazon Glacier ab. Der Beispielcode gibt den abzurufenden Bytebereich in einem `GetJobOutputRequest`-Objekt an und lädt die Auftragsausgabe in Datenblöcken herunter.
```
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using Amazon.Glacier;
using Amazon.Glacier.Model;
using Amazon.Glacier.Transfer;
using Amazon.Runtime;
using Amazon.SimpleNotificationService;
using Amazon.SimpleNotificationService.Model;
using Amazon.SQS;
using Amazon.SQS.Model;
using Newtonsoft.Json;
using System.Collections.Specialized;
namespace glacier.amazon.com.rproxy.govskope.us.docsamples
{
class ArchiveDownloadLowLevelUsingSQLSNSOutputUsingRange
{
static string topicArn;
static string queueUrl;
static string queueArn;
static string vaultName = "*** Provide vault name ***";
static string archiveId = "*** Provide archive ID ***";
static string fileName = "*** Provide the file name and path to where to store downloaded archive ***";
static AmazonSimpleNotificationServiceClient snsClient;
static AmazonSQSClient sqsClient;
const string SQS_POLICY =
"{" +
" \"Version\" : \"2012-10-17\",&TCX5-2025-waiver;" +
" \"Statement\" : [" +
" {" +
" \"Sid\" : \"sns-rule\"," +
" \"Effect\" : \"Allow\"," +
" \"Principal\" : {\"AWS\" : \"arn:aws:iam::123456789012:root\" }," +
" \"Action\" : \"sqs:SendMessage\"," +
" \"Resource\" : \"{QuernArn}\"," +
" \"Condition\" : {" +
" \"ArnLike\" : {" +
" \"aws:SourceArn\" : \"{TopicArn}\"" +
" }" +
" }" +
" }" +
" ]" +
"}";
public static void Main(string[] args)
{
AmazonGlacierClient client;
try
{
using (client = new AmazonGlacierClient(Amazon.RegionEndpoint.USWest2))
{
Console.WriteLine("Setup SNS topic and SQS queue.");
SetupTopicAndQueue();
Console.WriteLine("To continue, press Enter"); Console.ReadKey();
Console.WriteLine("Download archive");
DownloadAnArchive(archiveId, client);
}
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); }
finally
{
// Delete SNS topic and SQS queue.
snsClient.DeleteTopic(new DeleteTopicRequest() { TopicArn = topicArn });
sqsClient.DeleteQueue(new DeleteQueueRequest() { QueueUrl = queueUrl });
}
}
static void SetupTopicAndQueue()
{
long ticks = DateTime.Now.Ticks;
// Setup SNS topic.
snsClient = new AmazonSimpleNotificationServiceClient(Amazon.RegionEndpoint.USWest2);
sqsClient = new AmazonSQSClient(Amazon.RegionEndpoint.USWest2);
topicArn = snsClient.CreateTopic(new CreateTopicRequest { Name = "GlacierDownload-" + ticks }).TopicArn;
Console.Write("topicArn: "); Console.WriteLine(topicArn);
CreateQueueRequest createQueueRequest = new CreateQueueRequest();
createQueueRequest.QueueName = "GlacierDownload-" + ticks;
CreateQueueResponse createQueueResponse = sqsClient.CreateQueue(createQueueRequest);
queueUrl = createQueueResponse.QueueUrl;
Console.Write("QueueURL: "); Console.WriteLine(queueUrl);
GetQueueAttributesRequest getQueueAttributesRequest = new GetQueueAttributesRequest();
getQueueAttributesRequest.AttributeNames = new List { "QueueArn" };
getQueueAttributesRequest.QueueUrl = queueUrl;
GetQueueAttributesResponse response = sqsClient.GetQueueAttributes(getQueueAttributesRequest);
queueArn = response.QueueARN;
Console.Write("QueueArn: "); Console.WriteLine(queueArn);
// Setup the Amazon SNS topic to publish to the SQS queue.
snsClient.Subscribe(new SubscribeRequest()
{
Protocol = "sqs",
Endpoint = queueArn,
TopicArn = topicArn
});
// Add the policy to the queue so SNS can send messages to the queue.
var policy = SQS_POLICY.Replace("{TopicArn}", topicArn).Replace("{QuernArn}", queueArn);
sqsClient.SetQueueAttributes(new SetQueueAttributesRequest()
{
QueueUrl = queueUrl,
Attributes = new Dictionary
{
{ QueueAttributeName.Policy, policy }
}
});
}
static void DownloadAnArchive(string archiveId, AmazonGlacierClient client)
{
// Initiate job.
InitiateJobRequest initJobRequest = new InitiateJobRequest()
{
VaultName = vaultName,
JobParameters = new JobParameters()
{
Type = "archive-retrieval",
ArchiveId = archiveId,
Description = "This job is to download the archive.",
SNSTopic = topicArn,
}
};
InitiateJobResponse initJobResponse = client.InitiateJob(initJobRequest);
string jobId = initJobResponse.JobId;
// Check queue for a message and if job completed successfully, download archive.
ProcessQueue(jobId, client);
}
private static void ProcessQueue(string jobId, AmazonGlacierClient client)
{
var receiveMessageRequest = new ReceiveMessageRequest() { QueueUrl = queueUrl, MaxNumberOfMessages = 1 };
bool jobDone = false;
while (!jobDone)
{
Console.WriteLine("Poll SQS queue");
ReceiveMessageResponse receiveMessageResponse = sqsClient.ReceiveMessage(receiveMessageRequest);
if (receiveMessageResponse.Messages.Count == 0)
{
Thread.Sleep(10000 * 60);
continue;
}
Console.WriteLine("Got message");
Message message = receiveMessageResponse.Messages[0];
Dictionary outerLayer = JsonConvert.DeserializeObject>(message.Body);
Dictionary fields = JsonConvert.DeserializeObject>(outerLayer["Message"]);
string statusCode = fields["StatusCode"] as string;
if (string.Equals(statusCode, GlacierUtils.JOB_STATUS_SUCCEEDED, StringComparison.InvariantCultureIgnoreCase))
{
long archiveSize = Convert.ToInt64(fields["ArchiveSizeInBytes"]);
Console.WriteLine("Downloading job output");
DownloadOutput(jobId, archiveSize, client); // This where we save job output to the specified file location.
}
else if (string.Equals(statusCode, GlacierUtils.JOB_STATUS_FAILED, StringComparison.InvariantCultureIgnoreCase))
Console.WriteLine("Job failed... cannot download the archive.");
jobDone = true;
sqsClient.DeleteMessage(new DeleteMessageRequest() { QueueUrl = queueUrl, ReceiptHandle = message.ReceiptHandle });
}
}
private static void DownloadOutput(string jobId, long archiveSize, AmazonGlacierClient client)
{
long partSize = 4 * (long)Math.Pow(2, 20); // 4 MB.
using (Stream fileToSave = new FileStream(fileName, FileMode.Create, FileAccess.Write))
{
long currentPosition = 0;
do
{
GetJobOutputRequest getJobOutputRequest = new GetJobOutputRequest()
{
JobId = jobId,
VaultName = vaultName
};
long endPosition = currentPosition + partSize - 1;
if (endPosition > archiveSize)
endPosition = archiveSize;
getJobOutputRequest.SetRange(currentPosition, endPosition);
GetJobOutputResponse getJobOutputResponse = client.GetJobOutput(getJobOutputRequest);
using (Stream webStream = getJobOutputResponse.Body)
{
CopyStream(webStream, fileToSave);
}
currentPosition += partSize;
} while (currentPosition < archiveSize);
}
}
public static void CopyStream(Stream input, Stream output)
{
byte[] buffer = new byte[65536];
int length;
while ((length = input.Read(buffer, 0, buffer.Length)) > 0)
{
output.Write(buffer, 0, length);
}
}
}
}
```
# Herunterladen eines großen Archivs mithilfe der Parallelverarbeitung mit Python
In diesem Thema wird beschrieben, wie Sie mithilfe der Parallelverarbeitung mit Python ein großes Archiv von Amazon S3 Glacier (S3 Glacier) herunterladen. Mit diesem Ansatz können Sie Archive jeder Größe zuverlässig herunterladen, indem Sie sie in kleinere Teile aufteilen, die unabhängig voneinander verarbeitet werden können.
## -Übersicht
Das in diesem Beispiel bereitgestellte Python-Skript führt die folgenden Aufgaben aus:
1. Richtet die erforderlichen AWS Ressourcen (Amazon SNS SNS-Thema und Amazon SQS SQS-Warteschlangen) für Benachrichtigungen ein
1. Initiiert einen Job zum Abrufen von Archiven mit Amazon Glacier
1. Überwacht eine Amazon SQS SQS-Warteschlange für Benachrichtigungen über den Abschluss von Jobs
1. Teilt das große Archiv in verwaltbare Teile auf
1. Lädt Chunks parallel unter Verwendung mehrerer Worker-Threads herunter
1. Speichert jeden Chunk auf der Festplatte, damit er später wieder zusammengebaut werden kann
## Voraussetzungen
Bevor Sie beginnen, stellen Sie sicher, dass Sie über Folgendes verfügen:
+ Python 3.6 oder höher installiert
+ AWS SDK for Python (Boto3) installiert
+ AWS Anmeldeinformationen, die mit den entsprechenden Berechtigungen für Amazon Glacier, Amazon SNS und Amazon SQS konfiguriert sind
+ Ausreichend Festplattenspeicher zum Speichern der heruntergeladenen Archivblöcke
## Beispiel: Herunterladen eines Archivs mithilfe von Parallelverarbeitung mit Python
Das folgende Python-Skript veranschaulicht, wie ein großes Archiv mithilfe von Parallelverarbeitung von Amazon Glacier heruntergeladen wird:
```
import boto3
import time
import json
import jmespath
import re
import concurrent.futures
import os
output_file_path = "output_directory_path"
vault_name = "vault_name"
chunk_size = 1000000000 #1gb - size of chunks for parallel download.
notify_queue_name = 'GlacierJobCompleteNotifyQueue' # SQS queue for Glacier recall notification
chunk_download_queue_name='GlacierChunkReadyNotifyQueue' # SQS queue for chunks
sns_topic_name = 'GlacierRecallJobCompleted' # the SNS topic to be notified when Glacier archive is restored.
chunk_queue_visibility_timeout = 7200 # 2 hours - this may need to be adjusted.
region = 'us-east-1'
archive_id = "archive_id_to_restore"
retrieve_archive = True # set to false if you do not want to restore from Glacier - useful for restarting or parallel processing of the chunk queue.
workers = 12 # the number of parallel worker threads for downloading chunks.
def setup_queues_and_topic():
sqs = boto3.client('sqs')
sns = boto3.client('sns')
# Create the SNS topic
topic_response = sns.create_topic(
Name=sns_topic_name
)
topic_arn = topic_response['TopicArn']
print("Creating the SNS topic " + topic_arn)
# Create the notification queue
notify_queue_response = sqs.create_queue(
QueueName=notify_queue_name,
Attributes={
'VisibilityTimeout': '300', # 5 minutes
'ReceiveMessageWaitTimeSeconds': '20' # Enable long polling
}
)
notify_queue_url = notify_queue_response['QueueUrl']
print("Creating the archive-retrieval notification queue " + notify_queue_url)
# Create the chunk download queue
chunk_queue_response = sqs.create_queue(
QueueName=chunk_download_queue_name,
Attributes={
'VisibilityTimeout': str(chunk_queue_visibility_timeout), # 5 minutes
'ReceiveMessageWaitTimeSeconds': '0'
}
)
chunk_queue_url = chunk_queue_response['QueueUrl']
print("Creating the chunk ready notification queue " + chunk_queue_url)
# Get the ARN for the notification queue
notify_queue_attributes = sqs.get_queue_attributes(
QueueUrl=notify_queue_url,
AttributeNames=['QueueArn']
)
notify_queue_arn = notify_queue_attributes['Attributes']['QueueArn']
# Set up the SNS topic policy on the notification queue
queue_policy = {
"Version": "2012-10-17",
"Statement": [{
"Sid": "allow-sns-messages",
"Effect": "Allow",
"Principal": {"AWS": "*"},
"Action": "SQS:SendMessage",
"Resource": notify_queue_arn,
"Condition": {
"ArnEquals": {
"aws:SourceArn": topic_arn
}
}
}]
}
# Set the queue policy
sqs.set_queue_attributes(
QueueUrl=notify_queue_url,
Attributes={
'Policy': json.dumps(queue_policy)
}
)
# Subscribe the notification queue to the SNS topic
sns.subscribe(
TopicArn=topic_arn,
Protocol='sqs',
Endpoint=notify_queue_arn
)
return {
'topic_arn': topic_arn,
'notify_queue_url': notify_queue_url,
'chunk_queue_url': chunk_queue_url
}
def split_and_send_chunks(archive_size, job_id,chunk_queue_url):
ranges = []
current = 0
chunk_number = 0
while current < archive_size:
chunk_number += 1
next_range = min(current + chunk_size - 1, archive_size - 1)
ranges.append((current, next_range, chunk_number))
current = next_range + 1
# Send messages to SQS queue
for start, end, chunk_number in ranges:
body = {"start": start, "end": end, "job_id": job_id, "chunk_number": chunk_number}
body = json.dumps(body)
print("Sending SQS message for range:" + str(body))
response = sqs.send_message(
QueueUrl=chunk_queue_url,
MessageBody=str(body)
)
def GetJobOutputChunks(job_id, byterange, chunk_number):
glacier = boto3.client('glacier')
response = glacier.get_job_output(
vaultName=vault_name,
jobId=job_id,
range=byterange,
)
with open(os.path.join(output_file_path,str(chunk_number)+".chunk"), 'wb') as output_file:
output_file.write(response['body'].read())
return response
def ReceiveArchiveReadyMessages(notify_queue_url,chunk_queue_url):
response = sqs.receive_message(
QueueUrl=notify_queue_url,
AttributeNames=['All'],
MaxNumberOfMessages=1,
WaitTimeSeconds=20,
MessageAttributeNames=['Message']
)
print("Polling archive retrieval job ready queue...")
# Checking that there is a Messages key before proceeding. No 'Messages' key likely means the queue is empty
if 'Messages' in response:
print("Received a message from the archive retrieval job queue")
jsonresponse = response
# Loading the string into JSON and checking that ArchiveSizeInBytes key is present before continuing.
jsonresponse=json.loads(jsonresponse['Messages'][0]['Body'])
jsonresponse=json.loads(jsonresponse['Message'])
if 'ArchiveSizeInBytes' in jsonresponse:
receipt_handle = response['Messages'][0]['ReceiptHandle']
if jsonresponse['ArchiveSizeInBytes']:
archive_size = jsonresponse['ArchiveSizeInBytes']
print(f'Received message: {response}')
if archive_size > chunk_size:
split_and_send_chunks(archive_size, jsonresponse['JobId'],chunk_queue_url)
sqs.delete_message(
QueueUrl=notify_queue_url,
ReceiptHandle=receipt_handle)
else:
print("No ArchiveSizeInBytes value found in message")
print(response)
else:
print('No messages available in the queue at this time.')
time.sleep(1)
def ReceiveArchiveChunkMessages(chunk_queue_url):
response = sqs.receive_message(
QueueUrl=chunk_queue_url,
AttributeNames=['All'],
MaxNumberOfMessages=1,
WaitTimeSeconds=0,
MessageAttributeNames=['Message']
)
print("Polling archive chunk queue...")
print(response)
# Checking that there is a Messages key before proceeding. No 'Messages' key likely means the queue is empty
if 'Messages' in response:
jsonresponse = response
# Loading the string into JSON and checking that ArchiveSizeInBytes key is present before continuing.
jsonresponse=json.loads(jsonresponse['Messages'][0]['Body'])
if 'job_id' in jsonresponse: #checking that there is a job id before continuing
job_id = jsonresponse['job_id']
byterange = "bytes="+str(jsonresponse['start']) + '-' + str(jsonresponse['end'])
chunk_number = jsonresponse['chunk_number']
receipt_handle = response['Messages'][0]['ReceiptHandle']
if jsonresponse['job_id']:
print(f'Received message: {response}')
GetJobOutputChunks(job_id,byterange,chunk_number)
sqs.delete_message(
QueueUrl=chunk_queue_url,
ReceiptHandle=receipt_handle)
else:
print('No messages available in the chunk queue at this time.')
def initiate_archive_retrieval(archive_id, topic_arn):
glacier = boto3.client('glacier')
job_parameters = {
"Type": "archive-retrieval",
"ArchiveId": archive_id,
"Description": "Archive retrieval job",
"SNSTopic": topic_arn,
"Tier": "Bulk" # You can change this to "Standard" or "Expedited" based on your needs
}
try:
response = glacier.initiate_job(
vaultName=vault_name,
jobParameters=job_parameters
)
print("Archive retrieval job initiated:")
print(f"Job ID: {response['jobId']}")
print(f"Job parameters: {job_parameters}")
print(f"Complete response: {json.dumps(response, indent=2)}")
return response['jobId']
except Exception as e:
print(f"Error initiating archive retrieval job: {str(e)}")
raise
def run_async_tasks(chunk_queue_url, workers):
max_workers = workers # Set the desired maximum number of concurrent tasks
with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
for _ in range(max_workers):
executor.submit(ReceiveArchiveChunkMessages, chunk_queue_url)
# One time setup of the necessary queues and topics.
queue_and_topic_atts = setup_queues_and_topic()
topic_arn = queue_and_topic_atts['topic_arn']
notify_queue_url = queue_and_topic_atts['notify_queue_url']
chunk_queue_url = queue_and_topic_atts['chunk_queue_url']
if retrieve_archive:
print("Retrieving the defined archive... The topic arn we will notify when recalling the archive is: "+topic_arn)
job_id = initiate_archive_retrieval(archive_id, topic_arn)
else:
print("Retrieve archive is false, polling queues and downloading only.")
while True:
ReceiveArchiveReadyMessages(notify_queue_url,chunk_queue_url)
run_async_tasks(chunk_queue_url,workers)
```
## Verwenden des Skripts
Gehen Sie wie folgt vor, um dieses Skript zu verwenden:
1. Ersetzen Sie die Platzhalterwerte im Skript durch Ihre spezifischen Informationen:
+ *output\$1file\$1path*: Verzeichnis, in dem Chunk-Dateien gespeichert werden
+ *vault\$1name*: Name Ihres S3 Glacier-Tresors
+ *notify\$1queue\$1name*: Name für die Warteschlange für Jobbenachrichtigungen
+ *chunk\$1download\$1queue\$1name*: Name für die Chunk-Download-Warteschlange
+ *sns\$1topic\$1name*: Name für das SNS-Thema
+ *region*: AWS Region, in der sich Ihr Tresor befindet
+ *archive\$1id*: ID des abzurufenden Archivs
1. Führen Sie das Skript aus:
```
python download_large_archive.py
```
1. Nachdem alle Chunks heruntergeladen wurden, können Sie sie mit einem Befehl wie dem folgenden zu einer einzigen Datei kombinieren:
```
cat /path/to/chunks/*.chunk > complete_archive.file
```
## Wichtige Überlegungen
Beachten Sie bei der Verwendung dieses Skripts Folgendes:
+ Das Abrufen von Archiven aus S3 Glacier kann je nach ausgewählter Abrufstufe mehrere Stunden dauern.
+ Das Skript wird auf unbestimmte Zeit ausgeführt und fragt kontinuierlich die Warteschlangen ab. Möglicherweise möchten Sie eine Kündigungsbedingung hinzufügen, die Ihren spezifischen Anforderungen entspricht.
+ Stellen Sie sicher, dass Sie über ausreichend Festplattenspeicher verfügen, um alle Teile Ihres Archivs zu speichern.
+ Wenn das Skript unterbrochen wird, können Sie es mit neu starten, `retrieve_archive=False` um mit dem Herunterladen von Chunks fortzufahren, ohne einen neuen Abrufjob zu starten.
+ Passen Sie die *workers* Parameter *chunk\$1size* und an Ihre Netzwerkbandbreite und Systemressourcen an.
+ Für Amazon S3-Abrufe, Amazon SNS- und Amazon SQS SQS-Nutzung AWS fallen Standardgebühren an.
# Herunterladen eines Archivs mit der REST-API
**So laden Sie ein Archiv mit der REST-API herunter**
Das Herunterladen eines Archivs ist ein zweistufiger Prozess.
1. Initiieren Sie einen Auftrag des Typs `archive-retrieval`. Weitere Informationen finden Sie unter [Initiate Job (POST jobs)](api-initiate-job-post.md).
1. Laden Sie die Archivdaten herunter, wenn der Auftrag abgeschlossen wurde. Weitere Informationen finden Sie unter [Get Job Output (GET output)](api-job-output-get.md).
# Herunterladen eines Archivs in Amazon Glacier mit dem AWS CLI
Sie können Archive in Amazon Glacier (Amazon Glacier) mit AWS Command Line Interface (AWS CLI) herunterladen.
**Topics**
+ [(Voraussetzung) Einrichtung des AWS CLI](#Creating-Vaults-CLI-Setup)
+ [Beispiel: Laden Sie ein Archiv herunter mit dem AWS CLI](#Downloading-Archives-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
```
## Beispiel: Laden Sie ein Archiv herunter mit dem AWS CLI
**Anmerkung**
Um Ihre Archive herunterzuladen, müssen Sie die Archiv-IDs kennen. Mit den Schritten 1–4 werden die Archiv-IDs abgerufen. Wenn Sie IDs der Archive, die Sie herunterladen möchten, bereits kennen, fahren Sie mit Schritt 5 fort.
1. Verwenden Sie den `initiate-job`-Befehl, um einen Inventarabrufauftrag zu starten. Im Inventarbericht werden die Archiv-IDs aufgeführt.
```
aws glacier initiate-job --vault-name awsexamplevault --account-id 111122223333 --job-parameters="{\"Type\":\"inventory-retrieval\"}"
```
Erwartete Ausgabe:
```
{
"location": "/111122223333/vaults/awsexamplevault/jobs/*** jobid ***",
"jobId": "*** jobid ***"
}
```
1. Verwenden Sie den `describe-job`-Befehl, um den Status des vorherigen ``-Auftragsbefehls zu überprüfen.
```
aws glacier describe-job --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid ***
```
Erwartete Ausgabe:
```
{
"InventoryRetrievalParameters": {
"Format": "JSON"
},
"VaultARN": "*** vault arn ***",
"Completed": false,
"JobId": "*** jobid ***",
"Action": "InventoryRetrieval",
"CreationDate": "*** job creation date ***",
"StatusCode": "InProgress"
}
```
1. Warten Sie, bis der -Auftrag abgeschlossen wurde.
Sie müssen warten, bis die Ausgabe des Auftrags zum Download bereit ist. Wenn Sie beim Initiieren des Jobs eine Benachrichtigungskonfiguration für den Tresor festgelegt oder ein Amazon Simple Notification Service (Amazon SNS) -Thema angegeben haben, sendet Amazon Glacier nach Abschluss des Jobs eine Nachricht an das Thema.
Sie können Benachrichtigungskonfiguration für bestimmte Ereignisse auf dem Tresor einrichten. Weitere Informationen finden Sie unter [Konfiguration von Tresor-Benachrichtigungen in Amazon Glacier](configuring-notifications.md). Amazon Glacier sendet bei jedem Eintreten eines bestimmten Ereignisses eine Nachricht an das angegebene SNS-Thema.
1. Nach Abschluss laden Sie die Abrufaufgabe mit dem `get-job-output`-Befehl in die Datei „`output.json`“ herunter. Diese Datei enthält Ihre Archiv-IDs.
```
aws glacier get-job-output --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid *** output.json
```
Dieser Befehl erzeugt eine Datei mit den folgenden Feldern.
```
{
"VaultARN":"arn:aws:glacier:region:111122223333:vaults/awsexamplevault",
"InventoryDate":"*** job completion date ***",
"ArchiveList":[
{"ArchiveId":"*** archiveid ***",
"ArchiveDescription":*** archive description (if set) ***,
"CreationDate":"*** archive creation date ***",
"Size":"*** archive size (in bytes) ***",
"SHA256TreeHash":"*** archive hash ***"
}
{"ArchiveId":
...
]}
```
1. Verwenden Sie den `initiate-job`-Befehl, um den Abrufvorgang für jedes Archiv aus einem Tresor zu starten. Sie müssen als Auftragsparameter `archive-retrieval` wie unten dargestellt angeben.
```
aws glacier initiate-job --vault-name awsexamplevault --account-id 111122223333 --job-parameters="{\"Type\":\"archive-retrieval\",\"ArchiveId\":\"*** archiveId ***\"}"
```
1. Warten Sie, bis der `archive-retrieval`-Auftrag abgeschlossen wurde. Verwenden Sie den `describe-job`-Befehl, um den Status des vorherigen Befehls zu überprüfen.
```
aws glacier describe-job --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid ***
```
1. Wenn der oben beschriebene Auftrag abgeschlossen ist, verwenden Sie den `get-job-output`-Befehl, um Ihr Archiv herunterzuladen.
```
aws glacier get-job-output --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid *** output_file_name
```
# Löschen eines Archivs in Amazon Glacier
Sie können ein Archiv nicht mit der Amazon Glacier (Amazon Glacier) -Managementkonsole löschen. Um ein Archiv zu löschen, müssen Sie die AWS Command Line Interface (CLI) verwenden oder Code schreiben, um eine Löschanforderung entweder direkt über die REST-API oder über die und.NET-Wrapper-Bibliotheken zu stellen. AWS SDK für Java In den folgenden Themen wird erklärt, wie Sie die AWS SDK für Java und .NET-Wrapper-Bibliotheken, die REST-API und die verwenden. AWS CLI
**Topics**
+ [Löschen eines Archivs in Amazon Glacier mithilfe der AWS SDK für Java](deleting-an-archive-using-java.md)
+ [Löschen eines Archivs in Amazon Glacier mithilfe der AWS SDK für .NET](deleting-an-archive-using-dot-net.md)
+ [Löschen eines Amazon Glacier-Archivs mithilfe der REST-API](deleting-an-archive-using-rest.md)
+ [Löschen eines Archivs in Amazon Glacier mithilfe der AWS Command Line Interface](deleting-an-archive-using-cli.md)
Sie können zu einem gegebenen Zeitpunkt jeweils nur ein Archiv aus einem Tresor löschen. Zum Löschen des Archivs müssen Sie dessen Archiv-ID in Ihrer Löschanfrage angeben. Sie können die Archiv-ID ermitteln, indem Sie den Tresorbestand für den Tresor, in dem sich Archiv befindet, herunterladen. Weitere Informationen zum Herunterladen des Tresorbestands finden Sie unter [Ein Tresor-Inventar in Amazon Glacier herunterladen](vault-inventory.md).
Nach der Löschung eines Archivs kann noch eine erfolgreiche Anforderung zur Initiierung eines Auftrags zum Abrufen des gelöschten Archivs möglich sein, der betreffende Auftrag schlägt jedoch fehl.
Wenn Sie ein Archiv löschen und währenddessen noch ein Abruf des Archivs über die Archiv-ID bearbeitet wird, kann der Abruf den folgenden Szenarien entsprechend fehlschlagen oder gelingen:
+ Wenn der Archivabruf-Job die Daten aktiv für den Download vorbereitet, wenn Amazon Glacier die Anfrage zum Löschen von Archiven empfängt, schlägt der Archivierungsabruf möglicherweise fehl.
+ Wenn der Archivabruf-Job das Archiv erfolgreich für den Download vorbereitet hat, als Amazon Glacier die Anfrage zum Löschen des Archivs empfängt, können Sie die Ausgabe herunterladen.
Weitere Informationen zum Archivabruf finden Sie unter [Ein Archiv in Amazon Glacier herunterladen](downloading-an-archive.md).
Dieser Vorgang ist idempotent. Das Löschen eines bereits gelöschten Archivs erzeugt keinen Fehler.
Wenn Sie nach dem Löschen eines Archivs das Tresorinventar sofort herunterladen, wird das gelöschte Archiv möglicherweise in die Liste aufgenommen, da Amazon Glacier das Tresorinventar nur etwa einmal täglich erstellt.
**Anmerkung**
Informationen zum automatisierten Löschen von Tresorarchiven finden Sie unter [Automatisiertes Löschen von Tresorarchiven in Amazon S3 Glacier](https://aws.amazon.com/solutions/guidance/automated-deletion-of-vault-archives-in-amazon-s3-glacier/).
# Löschen eines Archivs in Amazon Glacier mithilfe der AWS SDK für Java
Im Folgenden werden die Schritte zum Löschen eines Archivs mithilfe der AWS SDK für Java Low-Level-API beschrieben.
1. Erstellen einer Instance der `AmazonGlacierClient`-Klasse (Client).
Sie müssen eine AWS Region angeben, in der das Archiv, das Sie löschen möchten, gespeichert ist. Alle Operationen, die Sie mit diesem Client ausführen, gelten für diese AWS Region.
1. Um die Anforderungsinformationen bereitzustellen, erstellen Sie eine Instance der `DeleteArchiveRequest`-Klasse.
Sie müssen eine Archiv-ID, einen Tresornamen und Ihre Konto-ID angeben. Wenn Sie keine Konto-ID angeben, wird die Konto-ID übernommen, die den Anmeldeinformationen zugeordnet ist, die Sie zum Signieren der Anforderung verwenden. Weitere Informationen finden Sie unter [Verwenden von AWS SDK für Java mit Amazon Glacier](using-aws-sdk-for-java.md).
1. Führen Sie die `deleteArchive`-Methode aus, indem das Anforderungsobjekt als Parameter festgelegt wird.
Der folgende Java-Codeausschnitt veranschaulicht die vorherigen Schritte.
```
AmazonGlacierClient client;
DeleteArchiveRequest request = new DeleteArchiveRequest()
.withVaultName("*** provide a vault name ***")
.withArchiveId("*** provide an archive ID ***");
client.deleteArchive(request);
```
**Anmerkung**
Weitere Informationen zur zugrunde liegenden REST-API finden Sie unter [Delete Archive (DELETE archive)](api-archive-delete.md).
## Beispiel: Löschen eines Archivs mit dem AWS SDK für Java
Das folgende Java-Codebeispiel verwendet den AWS SDK für Java , um ein Archiv zu löschen. 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 einem Tresornamen und der Archiv-ID des zu löschenden Archivs aktualisieren.
**Example**
```
import java.io.IOException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.glacier.AmazonGlacierClient;
import com.amazonaws.services.glacier.model.DeleteArchiveRequest;
public class ArchiveDelete {
public static String vaultName = "*** provide vault name ****";
public static String archiveId = "*** provide archive ID***";
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-east-1.amazonaws.com/");
try {
// Delete the archive.
client.deleteArchive(new DeleteArchiveRequest()
.withVaultName(vaultName)
.withArchiveId(archiveId));
System.out.println("Deleted archive successfully.");
} catch (Exception e) {
System.err.println("Archive not deleted.");
System.err.println(e);
}
}
}
```
# Löschen eines Archivs in Amazon Glacier mithilfe der 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 zum Löschen eines Archivs.
**Topics**
+ [Löschen eines Archivs mithilfe der High-Level-API von AWS SDK für .NET](#delete-archive-using-dot-net-high-level)
+ [Löschen eines Archivs mithilfe der Low-Level-API AWS SDK für .NET](#delete-archive-using-dot-net-low-level)
## Löschen eines Archivs mithilfe der High-Level-API von AWS SDK für .NET
Die `ArchiveTransferManager`-Klasse der High-Level-API bietet die `DeleteArchive`-Methode, mit der Sie ein Archiv löschen können.
### Beispiel: Löschen eines Archivs mithilfe der High-Level-API von AWS SDK für .NET
Das folgende C\$1-Codebeispiel verwendet die High-Level-API von AWS SDK für .NET , um ein Archiv zu löschen. 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 der Archiv-ID des zu löschenden Archivs aktualisieren.
**Example**
```
using System;
using Amazon.Glacier;
using Amazon.Glacier.Transfer;
using Amazon.Runtime;
namespace glacier.amazon.com.rproxy.govskope.us.docsamples
{
class ArchiveDeleteHighLevel
{
static string vaultName = "examplevault";
static string archiveId = "*** Provide archive ID ***";
public static void Main(string[] args)
{
try
{
var manager = new ArchiveTransferManager(Amazon.RegionEndpoint.USWest2);
manager.DeleteArchive(vaultName, archiveId);
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();
}
}
}
```
## Löschen eines Archivs mithilfe der Low-Level-API AWS SDK für .NET
Im Folgenden werden die Schritte zum Löschen eines Archivs mit AWS SDK für .NET beschrieben.
1. Erstellen einer Instance der `AmazonGlacierClient`-Klasse (Client).
Sie müssen eine AWS Region angeben, in der das Archiv, das Sie löschen möchten, gespeichert ist. Alle Operationen, die Sie mit diesem Client ausführen, gelten für diese AWS Region.
1. Um die Anforderungsinformationen bereitzustellen, erstellen Sie eine Instance der `DeleteArchiveRequest`-Klasse.
Sie müssen eine Archiv-ID, einen Tresornamen und Ihre Konto-ID angeben. Wenn Sie keine Konto-ID angeben, wird die Konto-ID übernommen, die den Anmeldeinformationen zugeordnet ist, die Sie zum Signieren der Anforderung verwenden. Weitere Informationen finden Sie unter [Verwenden von AWS SDKs mit Amazon Glacier](using-aws-sdk.md).
1. Führen Sie die `DeleteArchive`-Methode aus, indem das Anforderungsobjekt als Parameter festgelegt wird.
### Beispiel: Löschen eines Archivs mithilfe der Low-Level-API von AWS SDK für .NET
Im folgenden C\$1-Codebeispiel werden die vorstehenden Schritte veranschaulicht. Das Beispiel verwendet die Low-Level-API von, um ein AWS SDK für .NET Archiv zu löschen.
**Anmerkung**
Weitere Informationen zur zugrunde liegenden REST-API finden Sie unter [Delete Archive (DELETE archive)](api-archive-delete.md).
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 der Archiv-ID des zu löschenden Archivs aktualisieren.
**Example**
```
using System;
using Amazon.Glacier;
using Amazon.Glacier.Model;
using Amazon.Runtime;
namespace glacier.amazon.com.rproxy.govskope.us.docsamples
{
class ArchiveDeleteLowLevel
{
static string vaultName = "examplevault";
static string archiveId = "*** Provide archive ID ***";
public static void Main(string[] args)
{
AmazonGlacierClient client;
try
{
using (client = new AmazonGlacierClient(Amazon.RegionEndpoint.USWest2))
{
Console.WriteLine("Deleting the archive");
DeleteAnArchive(client);
}
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 void DeleteAnArchive(AmazonGlacierClient client)
{
DeleteArchiveRequest request = new DeleteArchiveRequest()
{
VaultName = vaultName,
ArchiveId = archiveId
};
DeleteArchiveResponse response = client.DeleteArchive(request);
}
}
}
```
# Löschen eines Amazon Glacier-Archivs mithilfe der REST-API
Sie können die API zum Löschen von Archiven verwenden, um ein Archiv zu löschen.
+ Informationen zur API zum Löschen von Archiven finden Sie unter [Delete Archive (DELETE archive)](api-archive-delete.md).
+ Weitere Informationen zur Verwendung der REST-API finden Sie unter [API-Referenz für Amazon Glacier](amazon-glacier-api.md).
# Löschen eines Archivs in Amazon Glacier mithilfe der AWS Command Line Interface
Sie können Archive in Amazon Glacier (Amazon Glacier) mit AWS Command Line Interface (AWS CLI) löschen.
**Topics**
+ [(Voraussetzung) Einrichtung des AWS CLI](#Creating-Vaults-CLI-Setup)
+ [Beispiel: Löschen eines Archivs mit dem AWS CLI](#Deleting-Archives-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
```
## Beispiel: Löschen eines Archivs mit dem AWS CLI
1. Verwenden Sie den [https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-job.html](https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-job.html)-Befehl, um eine Lagerabrufaufgabe zu starten.
```
aws glacier initiate-job --vault-name awsexamplevault --account-id 111122223333 --job-parameters="{\"Type\":\"inventory-retrieval\"}"
```
Erwartete Ausgabe:
```
{
"location": "/111122223333/vaults/awsexamplevault/jobs/*** jobid ***",
"jobId": "*** jobid ***"
}
```
1. Verwenden Sie den [https://docs.aws.amazon.com/cli/latest/reference/glacier/describe-job.html](https://docs.aws.amazon.com/cli/latest/reference/glacier/describe-job.html)-Befehl, um den Status der vorherigen Abrufaufgabe zu überprüfen.
```
aws glacier describe-job --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid ***
```
Erwartete Ausgabe:
```
{
"InventoryRetrievalParameters": {
"Format": "JSON"
},
"VaultARN": "*** vault arn ***",
"Completed": false,
"JobId": "*** jobid ***",
"Action": "InventoryRetrieval",
"CreationDate": "*** job creation date ***",
"StatusCode": "InProgress"
}
```
1. Warten Sie, bis der -Auftrag abgeschlossen wurde.
Sie müssen warten, bis die Ausgabe des Auftrags zum Download bereit ist. Wenn Sie beim Initiieren des Jobs eine Benachrichtigungskonfiguration für den Tresor festgelegt oder ein Amazon Simple Notification Service (Amazon SNS) -Thema angegeben haben, sendet Amazon Glacier nach Abschluss des Jobs eine Nachricht an das Thema.
Sie können Benachrichtigungskonfiguration für bestimmte Ereignisse auf dem Tresor einrichten. Weitere Informationen finden Sie unter [Konfiguration von Tresor-Benachrichtigungen in Amazon Glacier](configuring-notifications.md). Amazon Glacier sendet bei jedem Eintreten eines bestimmten Ereignisses eine Nachricht an das angegebene SNS-Thema.
1. Nach Abschluss laden Sie die Abrufaufgabe mit dem [https://docs.aws.amazon.com/cli/latest/reference/glacier/get-job-output.html](https://docs.aws.amazon.com/cli/latest/reference/glacier/get-job-output.html)-Befehl in die Datei „`output.json`“ herunter.
```
aws glacier get-job-output --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid *** output.json
```
Dieser Befehl erzeugt eine Datei mit den folgenden Feldern.
```
{
"VaultARN":"arn:aws:glacier:region:111122223333:vaults/awsexamplevault",
"InventoryDate":"*** job completion date ***",
"ArchiveList":[
{"ArchiveId":"*** archiveid ***",
"ArchiveDescription":*** archive description (if set) ***,
"CreationDate":"*** archive creation date ***",
"Size":"*** archive size (in bytes) ***",
"SHA256TreeHash":"*** archive hash ***"
}
{"ArchiveId":
...
]}
```
1. Verwenden Sie den `delete-archive`-Befehl, um jedes Archiv aus einem Tresor zu löschen, bis kein Archiv übrig bleibt.
```
aws glacier delete-archive --vault-name awsexamplevault --account-id 111122223333 --archive-id *** archiveid ***
```