**Cette page est réservée aux clients existants du service Amazon Glacier utilisant Vaults et l'API REST d'origine datant de 2012.**
Si vous recherchez des solutions de stockage d'archives, nous vous recommandons d'utiliser les classes de stockage Amazon Glacier dans Amazon S3, S3 Glacier Instant Retrieval, S3 Glacier Flexible Retrieval et S3 Glacier Deep Archive. Pour en savoir plus sur ces options de stockage, consultez les [classes de stockage Amazon Glacier](https://aws.amazon.com/s3/storage-classes/glacier/).
Amazon Glacier (service autonome d'origine basé sur un coffre-fort) n'accepte plus de nouveaux clients. Amazon Glacier est un service autonome doté de son propre service APIs qui stocke les données dans des coffres-forts et qui se distingue des classes de stockage Amazon S3 et Amazon S3 Glacier. Vos données existantes resteront sécurisées et accessibles indéfiniment dans Amazon Glacier. Aucune migration n'est requise. Pour un stockage d'archivage à long terme et à faible coût AWS , nous [recommandons les classes de stockage Amazon S3 Glacier](https://aws.amazon.com/s3/storage-classes/glacier/), qui offrent une expérience client supérieure avec des compartiments S3, une Région AWS disponibilité totale APIs, des coûts réduits et AWS une intégration des services. Si vous souhaitez des fonctionnalités améliorées, envisagez de migrer vers les classes de stockage Amazon S3 Glacier en suivant nos [conseils relatifs aux AWS solutions pour le transfert de données depuis les coffres-forts Amazon Glacier vers les classes de stockage Amazon S3 Glacier](https://aws.amazon.com/solutions/guidance/data-transfer-from-amazon-s3-glacier-vaults-to-amazon-s3/).
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation des archives dans Amazon Glacier
Une archive est un objet, comme une photo, une vidéo ou un document, que vous stockez dans un coffre. Il s'agit d'une unité de stockage de base dans Amazon Glacier (Amazon Glacier). Chaque archive est associée à un ID unique et une description en option. Lorsque vous chargez une archive, Amazon Glacier renvoie une réponse qui inclut un ID d'archive. Cet identifiant d'archive est unique dans la AWS région dans laquelle l'archive est stockée. L'ID suivant est un exemple d'ID d'archive.
```
TJgHcrOSfAkV6hdPqOATYfp_0ZaxL1pIBOc02iZ0gDPMr2ig-nhwd_PafstsdIf6HSrjHnP-3p6LCJClYytFT_CBhT9CwNxbRaM5MetS3I-GqwxI3Y8QtgbJbhEQPs0mJ3KExample
```
IDs Les archives ont une longueur de 138 octets. Lorsque vous chargez une archive, vous pouvez indiquer une description facultative. Avec l'ID de l'archive vous pouvez extraire l'archive mais pas sa description.
**Important**
Amazon Glacier fournit une console de gestion. Vous pouvez utiliser la console pour créer et supprimer des coffres. Cependant, toutes les autres interactions avec Amazon Glacier nécessitent que vous utilisiez la AWS Command Line Interface (CLI) ou que vous écriviez du code. Par exemple, pour télécharger des données, telles que des photos, des vidéos et d'autres documents, vous devez utiliser le code AWS CLI ou écrire du code pour effectuer des demandes, en utilisant directement l'API REST ou en utilisant Amazon SDKs. Pour plus d'informations sur l'utilisation d'Amazon Glacier avec le AWS CLI, consultez la section [AWS CLI Référence d'Amazon Glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html). Pour installer le AWS CLI, rendez-vous sur [AWS Command Line Interface](https://aws.amazon.com/cli/).
**Topics**
+ [Opérations d'archivage dans Amazon Glacier](#archive-operations-quick-intro)
+ [Conservation des métadonnées d'archive côté client](#client-side-key-map-concept)
+ [Téléchargement d'une archive dans Amazon Glacier](uploading-an-archive.md)
+ [Téléchargement d'une archive dans Amazon Glacier](downloading-an-archive.md)
+ [Supprimer une archive dans Amazon Glacier](deleting-an-archive.md)
## Opérations d'archivage dans Amazon Glacier
Amazon Glacier prend en charge les opérations d'archivage de base suivantes : chargement, téléchargement et suppression. Le téléchargement d'une archive est une opération asynchrone.
### Téléchargement d'une archive dans Amazon Glacier
Vous pouvez charger une archive en une seule opération ou en plusieurs parties. L'appel d'API qui vous permet de charger une archive en plusieurs parties s'appelle le chargement partitionné. Pour de plus amples informations, veuillez consulter [Téléchargement d'une archive dans Amazon Glacier](uploading-an-archive.md).
**Important**
Amazon Glacier fournit une console de gestion. Vous pouvez utiliser la console pour créer et supprimer des coffres. Cependant, toutes les autres interactions avec Amazon Glacier nécessitent que vous utilisiez la AWS Command Line Interface (CLI) ou que vous écriviez du code. Par exemple, pour télécharger des données, telles que des photos, des vidéos et d'autres documents, vous devez utiliser le code AWS CLI ou écrire du code pour effectuer des demandes, en utilisant directement l'API REST ou en utilisant Amazon SDKs. Pour plus d'informations sur l'utilisation d'Amazon Glacier avec le AWS CLI, consultez la section [AWS CLI Référence d'Amazon Glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html). Pour installer le AWS CLI, rendez-vous sur [AWS Command Line Interface](https://aws.amazon.com/cli/).
### Trouver un identifiant d'archive dans Amazon Glacier
Vous pouvez obtenir l'ID de l'archive en téléchargeant l'inventaire du coffre qui contient l'archive. Pour plus d'informations sur le téléchargement de l'inventaire de coffre, consultez la page [Téléchargement d'un inventaire de coffre-fort dans Amazon Glacier](vault-inventory.md).
### Téléchargement d'une archive dans Amazon Glacier
Le téléchargement d'une archive est une opération asynchrone. Vous devez commencer par lancer une tâche de téléchargement d'une archive spécifique. Après avoir reçu la demande de travail, Amazon Glacier prépare votre archive pour le téléchargement. Une fois la tâche terminée, vous pouvez télécharger vos données archivées. En raison de la nature asynchrone de la tâche, vous pouvez demander à Amazon Glacier d'envoyer une notification à une rubrique Amazon Simple Notification Service (Amazon SNS) une fois la tâche terminée. Vous pouvez spécifier une rubrique SNS pour chaque demande de tâche individuelle ou configurer votre coffre pour envoyer une notification lorsque des événements spécifiques se produisent. Pour en savoir plus sur le téléchargement d'une archive, consultez [Téléchargement d'une archive dans Amazon Glacier](downloading-an-archive.md).
### Supprimer une archive dans Amazon Glacier
Amazon Glacier fournit un appel d'API que vous pouvez utiliser pour supprimer une archive à la fois. Pour de plus amples informations, veuillez consulter [Supprimer une archive dans Amazon Glacier](deleting-an-archive.md).
### Mettre à jour une archive dans Amazon Glacier
Une fois que vous avez chargé une archive, vous ne pouvez pas mettre à jour son contenu ou sa description. Le seul moyen dont vous disposez pour mettre à jour le contenu de l'archive ou sa description est de supprimer l'archive et de charger une autre archive. Notez que chaque fois que vous chargez une archive, Amazon Glacier vous renvoie un identifiant d'archive unique.
## Conservation des métadonnées d'archive côté client
À l'exception de la description facultative de l'archive, Amazon Glacier ne prend en charge aucune métadonnée supplémentaire pour les archives. Lorsque vous chargez une archive, Amazon Glacier attribue un identifiant, une séquence opaque de caractères, à partir de laquelle vous ne pouvez pas déduire le sens de l'archive. Vous pouvez conserver les métadonnées relatives aux archives côté client. Les métadonnées peuvent inclure le nom de l'archive et d'autres informations utiles sur l'archive.
**Note**
Si vous êtes un client Amazon Simple Storage Service (Amazon S3), vous savez que lorsque vous chargez un objet dans un compartiment, vous pouvez lui attribuer une clé d'objet, par exemple `MyDocument.txt` ou `SomePhoto.jpg`. Dans Amazon Glacier, vous ne pouvez pas attribuer de clé d'objet aux archives que vous chargez.
Si vous gérez des métadonnées d'archives côté client, notez qu'Amazon Glacier gère un inventaire des coffres-forts qui inclut les archives IDs et toutes les descriptions que vous avez fournies lors du chargement de l'archive. Vous pouvez parfois télécharger l'inventaire de coffre pour régler les problèmes de la base de données côté client que vous tenez à jour pour les métadonnées d'archive. Cependant, Amazon Glacier fait l'inventaire des coffres-forts environ tous les jours. Lorsque vous demandez un inventaire de coffre, Amazon Glacier renvoie le dernier inventaire qu'il a préparé, un instantané à un moment donné.
# Téléchargement d'une archive dans Amazon Glacier
Amazon Glacier (Amazon Glacier) fournit une console de gestion que vous pouvez utiliser pour créer et supprimer des coffres-forts. Toutefois, vous ne pouvez pas télécharger d'archives sur Amazon Glacier à l'aide de la console de gestion. Pour télécharger des données, telles que des photos, des vidéos et d'autres documents, vous devez utiliser le code AWS CLI ou écrire du code pour effectuer des demandes, en utilisant directement l'API REST ou en utilisant Amazon SDKs.
Pour plus d'informations sur l'utilisation d'Amazon Glacier avec le AWS CLI, consultez la [AWS CLI section Référence d'Amazon Glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html). Pour installer le AWS CLI, rendez-vous sur [AWS Command Line Interface](https://aws.amazon.com/cli/). Les rubriques suivantes **relatives au chargement** décrivent comment charger des archives sur Amazon Glacier à l'aide du SDK Amazon pour Java, du SDK Amazon pour .NET et de l'API REST.
**Topics**
+ [Options de téléchargement d'une archive sur Amazon Glacier](#uploading-an-archive-overview)
+ [Chargement d'une archive en une seule opération](uploading-archive-single-operation.md)
+ [Chargement d'archives volumineuses en plusieurs parties (chargement partitionné)](uploading-archive-mpu.md)
## Options de téléchargement d'une archive sur Amazon Glacier
En fonction de la taille des données que vous chargez, Amazon Glacier propose les options suivantes :
+ **Charger des archives en une seule opération** : vous pouvez charger des archives de 1 octet à 4 Go en une seule opération. Toutefois, nous encourageons les clients d'Amazon Glacier à utiliser le téléchargement partitionné pour charger des archives de plus de 100 Mo. Pour de plus amples informations, veuillez consulter [Chargement d'une archive en une seule opération](uploading-archive-single-operation.md).
+ **Charger des archives en plusieurs parties** : l'API de chargement partitionné vous permet de charger des archives volumineuses, d'une taille maximale d'environ 40 000 Go (10 000 \$1 4 Go).
L'appel d'API de chargement partitionné est conçu pour améliorer l'expérience de chargement pour les archives plus volumineuses. Vous pouvez charger des archives en plusieurs parties. Ces parties peuvent être chargées indépendamment, dans n'importe quel ordre, et en parallèle. En cas d'échec du chargement d'une partie, vous ne devez recharger que cette partie, et non la totalité de l'archive. Vous pouvez utiliser le chargement partitionné pour les archives dont la taille est comprise entre 1 octet et environ 40 000 Go. Pour de plus amples informations, veuillez consulter [Chargement d'archives volumineuses en plusieurs parties (chargement partitionné)](uploading-archive-mpu.md).
**Important**
L'inventaire du coffre Amazon Glacier n'est mis à jour qu'une fois par jour. Lorsque vous chargez une archive, elle est ajoutée à votre coffre, mais elle n'est pas visible (dans la console ou dans votre liste d'inventaire de coffre téléchargé) tant que l'inventaire de coffre n'est pas mis à jour.
### Utilisation du AWS Snowball Edge service
AWS Snowball Edge accélère le transfert de grandes quantités de données vers et depuis des appareils appartenant à Amazon, AWS en contournant Internet. Pour plus d'informations, consultez la page de détails de [AWS Snowball Edge](https://aws.amazon.com/snowball).
Pour télécharger des données existantes vers Amazon Glacier (Amazon Glacier), vous pouvez envisager d'utiliser l'un des types d' AWS Snowball Edge appareils pour importer des données dans Amazon S3, puis de les déplacer vers la classe de stockage Amazon Glacier à des fins d'archivage selon les règles du cycle de vie. Lorsque vous transférez des objets Amazon S3 vers la classe de stockage Amazon Glacier, Amazon S3 utilise Amazon Glacier en interne pour un stockage durable à moindre coût. Bien que les objets soient stockés dans Amazon Glacier, ils restent des objets Amazon S3 que vous gérez dans Amazon S3, et vous ne pouvez pas y accéder directement via Amazon Glacier.
Pour plus d'informations sur la configuration du cycle de vie d'Amazon S3 et la transition des objets vers la classe de stockage Amazon Glacier, consultez la section [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) dans le guide de *l'utilisateur d'Amazon Simple Storage Service*.
# Chargement d'une archive en une seule opération
Comme il est décrit dans [Téléchargement d'une archive dans Amazon Glacier](uploading-an-archive.md), vous pouvez charger de petites archives en une seule opération. Toutefois, nous encourageons les clients d'Amazon Glacier (Amazon Glacier) à utiliser le téléchargement partitionné pour charger des archives de plus de 100 Mo.
**Topics**
+ [Chargement d'une archive en une seule opération à l'aide du AWS Command Line Interface](uploading-an-archive-single-op-using-cli.md)
+ [Chargement d'une archive en une seule opération à l'aide du AWS SDK pour Java](uploading-an-archive-single-op-using-java.md)
+ [Téléchargement d'une archive en une seule opération à l'aide du AWS SDK pour .NET dans Amazon Glacier](uploading-an-archive-single-op-using-dotnet.md)
+ [Chargement d'une archive en une seule opération à l'aide de l'API REST](uploading-an-archive-single-op-using-rest.md)
# Chargement d'une archive en une seule opération à l'aide du AWS Command Line Interface
Vous pouvez charger une archive dans Amazon Glacier (Amazon Glacier) à l'aide du AWS Command Line Interface (AWS CLI).
**Topics**
+ [(Prérequis) Configuration du AWS CLI](#Creating-Vaults-CLI-Setup)
+ [Exemple : Chargez une archive à l'aide du AWS CLI](#Uploading-Archives-CLI-Implementation)
## (Prérequis) Configuration du AWS CLI
1. Téléchargez et configurez l’interface AWS CLI. Pour obtenir des instructions, consultez les rubriques suivantes dans le *Guide de l’utilisateur de l’interface AWS Command Line Interface * :
[Installation du AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html)
[Configuration du AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)
1. Vérifiez votre AWS CLI configuration en saisissant les commandes suivantes à l'invite de commande. Ces commandes ne fournissent pas directement d'informations d'identification, par conséquent ce sont les informations du profil par défaut qui sont utilisées.
+ Essayez d'utiliser la commande help.
```
aws help
```
+ Pour obtenir la liste des coffres-forts Amazon Glacier sur le compte configuré, utilisez la `list-vaults` commande. *123456789012*Remplacez-le par votre Compte AWS identifiant.
```
aws glacier list-vaults --account-id 123456789012
```
+ Pour voir les données de configuration actuelles pour le AWS CLI, utilisez la `aws configure list` commande.
```
aws configure list
```
## Exemple : Chargez une archive à l'aide du AWS CLI
Pour charger une archive, vous devez avoir créé un coffre. Pour plus d'informations sur la création de coffres, consultez [Création d'un coffre-fort dans Amazon Glacier](creating-vaults.md).
1. Utilisez la commande `upload-archive` pour ajouter une archive à un coffre existant. Dans l'exemple ci-dessous, remplacez les valeurs des paramètres `vault name` et `account ID`. Pour le paramètre `body`, indiquez le chemin du fichier que vous souhaitez charger.
```
aws glacier upload-archive --vault-name awsexamplevault --account-id 123456789012 --body archive.zip
```
1. Sortie attendue :
```
{
"archiveId": "kKB7ymWJVpPSwhGP6ycSOAekp9ZYe_--zM_mw6k76ZFGEIWQX-ybtRDvc2VkPSDtfKmQrj0IRQLSGsNuDp-AJVlu2ccmDSyDUmZwKbwbpAdGATGDiB3hHO0bjbGehXTcApVud_wyDw",
"checksum": "969fb39823836d81f0cc028195fcdbcbbe76cdde932d4646fa7de5f21e18aa67",
"location": "/123456789012/vaults/awsexamplevault/archives/kKB7ymWJVpPSwhGP6ycSOAekp9ZYe_--zM_mw6k76ZFGEIWQX-ybtRDvc2VkPSDtfKmQrj0IRQLSGsNuDp-AJVlu2ccmDSyDUmZwKbwbpAdGATGDiB3hHO0bjbGehXTcApVud_wyDw"
}
```
Une fois terminée, la commande affiche l'ID de l'archive, la somme de contrôle et l'emplacement dans Amazon Glacier. Pour plus d'informations sur la commande upload-archive, consultez [upload-archive](https://docs.aws.amazon.com/cli/latest/reference/glacier/upload-archive.html) dans le *guide de référence des commandes AWS CLI *.
# Chargement d'une archive en une seule opération à l'aide du AWS SDK pour Java
Les niveaux de [haut et de bas niveau APIs](using-aws-sdk.md) fournis par le SDK Amazon pour Java fournissent une méthode pour télécharger une archive.
**Topics**
+ [Téléchargement d'une archive à l'aide de l'API de haut niveau du AWS SDK pour Java](#uploading-an-archive-single-op-high-level-using-java)
+ [Chargement d'une archive en une seule opération à l'aide de l'API de bas niveau du AWS SDK pour Java](#uploading-an-archive-single-op-low-level-using-java)
## Téléchargement d'une archive à l'aide de l'API de haut niveau du AWS SDK pour Java
La classe `ArchiveTransferManager` de l'API de haut niveau fournit la méthode `upload`, qui permet de charger une archive dans un coffre.
**Note**
Vous pouvez utiliser la méthode `upload` pour charger des archives petites ou volumineuses. Selon la taille de l'archive que vous chargez, cette méthode détermine si vous devez charger l'archive en une seule opération ou si vous devez utiliser l'API de chargement partitionné pour charger l'archive en plusieurs parties.
### Exemple : téléchargement d'une archive à l'aide de l'API de haut niveau du AWS SDK pour Java
L'exemple de code Java suivant charge une archive sur un coffre (`examplevault`) dans la région USA Ouest (Oregon) (`us-west-2`). Pour obtenir la liste des AWS régions et des points de terminaison pris en charge, consultez[Accès à Amazon Glacier](amazon-glacier-accessing.md).
Pour step-by-step obtenir des instructions sur la façon d'exécuter cet exemple, consultez[Exécution d'exemples Java pour Amazon Glacier à l'aide d'Eclipse](using-aws-sdk-for-java.md#setting-up-and-testing-sdk-java). Vous devez mettre à jour le code tel qu'il est présenté avec le nom du coffre sur lequel vous souhaitez effectuer le chargement et le nom du fichier à charger.
**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);
}
}
}
```
## Chargement d'une archive en une seule opération à l'aide de l'API de bas niveau du AWS SDK pour Java
L'API de bas niveau fournit des méthodes pour toutes les opérations d'archivage. Voici les étapes de chargement d'une archive à l'aide du kit AWS SDK pour Java.
1. Créez une instance de la classe `AmazonGlacierClient` (le client).
Vous devez spécifier AWS la région dans laquelle vous souhaitez télécharger l'archive. Toutes les opérations que vous effectuez à l'aide de ce client s'appliquent à cette AWS région.
1. Fournissez les informations de demande en créant une instance de la classe `UploadArchiveRequest`.
Outre les données que vous souhaitez télécharger, vous devez fournir un total de contrôle (hachage d'arborescence SHA-256) de la charge utile, le nom du coffre, la longueur du contenu des données et votre ID de compte.
Si vous n'indiquez pas d'ID de compte, l'ID de compte associé aux informations d'identification que vous avez indiquées pour signer la demande est pris en compte. Pour de plus amples informations, veuillez consulter [Utilisation du AWS SDK pour Java avec Amazon Glacier](using-aws-sdk-for-java.md).
1. Exécutez la méthode `uploadArchive` en fournissant l'objet de demande comme paramètre.
En réponse, Amazon Glacier (Amazon Glacier) renvoie l'ID d'archive de l'archive récemment téléchargée.
L'extrait de code Java suivant illustre les étapes précédentes.
```
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());
```
### Exemple : téléchargement d'une archive en une seule opération à l'aide de l'API de bas niveau du AWS SDK pour Java
L'exemple de code Java suivant utilise le AWS SDK pour Java pour télécharger une archive dans un coffre (`examplevault`). Pour step-by-step obtenir des instructions sur la façon d'exécuter cet exemple, consultez[Exécution d'exemples Java pour Amazon Glacier à l'aide d'Eclipse](using-aws-sdk-for-java.md#setting-up-and-testing-sdk-java). Vous devez mettre à jour le code tel qu'il est présenté avec le nom du coffre sur lequel vous souhaitez effectuer le chargement et le nom du fichier à charger.
```
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);
}
}
}
```
# Téléchargement d'une archive en une seule opération à l'aide du AWS SDK pour .NET dans Amazon Glacier
Les niveaux de [haut et de bas niveau APIs](using-aws-sdk.md) fournis par le SDK Amazon pour .NET fournissent une méthode permettant de télécharger une archive en une seule opération.
**Topics**
+ [Téléchargement d'une archive à l'aide de l'API de haut niveau du AWS SDK pour .NET](#uploading-an-archive-single-op-highlevel-using-dotnet)
+ [Chargement d'une archive en une seule opération à l'aide de l'API de bas niveau du AWS SDK pour .NET](#uploading-an-archive-single-op-lowlevel-using-dotnet)
## Téléchargement d'une archive à l'aide de l'API de haut niveau du AWS SDK pour .NET
La classe `ArchiveTransferManager` de l'API de haut niveau fournit la méthode `Upload` qui permet de charger une archive dans un coffre.
**Note**
Vous pouvez utiliser la méthode `Upload` pour charger des fichiers petits ou volumineux. Selon la taille du fichier que vous chargez, cette méthode détermine si vous devez effectuer cette opération en une seule fois ou si vous devez utiliser l'API de chargement partitionné pour charger le fichier en plusieurs parties.
### Exemple : téléchargement d'une archive à l'aide de l'API de haut niveau du AWS SDK pour .NET
L'exemple de code C\$1 suivant charge une archive sur un coffre (`examplevault`) dans la région USA Ouest (Oregon).
Pour step-by-step obtenir des instructions sur la façon d'exécuter cet exemple, reportez-vous à[Exemples de code en cours d'exécution](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet). Vous devez mettre à jour le code tel qu'il est présenté avec le nom du fichier que vous souhaitez charger.
**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();
}
}
}
```
## Chargement d'une archive en une seule opération à l'aide de l'API de bas niveau du AWS SDK pour .NET
L'API de bas niveau fournit des méthodes pour toutes les opérations d'archivage. Voici les étapes de chargement d'une archive à l'aide du kit AWS SDK pour .NET.
1. Créez une instance de la classe `AmazonGlacierClient` (le client).
Vous devez spécifier AWS la région dans laquelle vous souhaitez télécharger l'archive. Toutes les opérations que vous effectuez à l'aide de ce client s'appliquent à cette AWS région.
1. Fournissez les informations de demande en créant une instance de la classe `UploadArchiveRequest`.
Outre les données que vous souhaitez télécharger, vous devrez fournir un total de contrôle (hachage d'arborescence SHA-256) de la charge utile, le nom du coffre et votre ID de compte.
Si vous n'indiquez pas d'ID de compte, l'ID de compte associé aux informations d'identification que vous avez indiquées pour signer la demande est pris en compte. Pour de plus amples informations, veuillez consulter [Utilisation du AWS SDK pour .NET avec Amazon Glacier](using-aws-sdk-for-dot-net.md).
1. Exécutez la méthode `UploadArchive` en fournissant l'objet de demande comme paramètre.
En réponse, Amazon Glacier renvoie l'ID d'archive de l'archive récemment téléchargée.
### Exemple : téléchargement d'une archive en une seule opération à l'aide de l'API de bas niveau du AWS SDK pour .NET
L'exemple de code C\$1 suivant présente les étapes précédentes. L'exemple utilise le AWS SDK pour .NET pour télécharger une archive dans un coffre (`examplevault`).
**Note**
Pour plus d'informations sur l'API REST sous-jacente pour charger une archive en une seule demande, consultez [Chargement d'archive (POST archive)](api-archive-post.md).
Pour step-by-step obtenir des instructions sur la façon d'exécuter cet exemple, reportez-vous à[Exemples de code en cours d'exécution](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet). Vous devez mettre à jour le code tel qu'il est présenté avec le nom du fichier que vous souhaitez charger.
**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;
}
}
}
}
```
# Chargement d'une archive en une seule opération à l'aide de l'API REST
Vous pouvez utiliser l'appel de l'API de chargement d'archive pour charger une archive en une seule opération. Pour de plus amples informations, veuillez consulter [Chargement d'archive (POST archive)](api-archive-post.md).
# Chargement d'archives volumineuses en plusieurs parties (chargement partitionné)
**Topics**
+ [Processus de chargement partitionné](#MPUprocess)
+ [En bref](#qfacts)
+ [Téléchargement d'archives volumineuses à l'aide du AWS CLI](uploading-an-archive-mpu-using-cli.md)
+ [Chargement d'archives volumineuses en plusieurs parties à l'aide du kit SDK Amazon pour Java](uploading-an-archive-mpu-using-java.md)
+ [Téléchargement d'archives volumineuses à l'aide du AWS SDK pour .NET](uploading-an-archive-mpu-using-dotnet.md)
+ [Chargement d'archives volumineuses en plusieurs parties à l'aide de l'API REST](uploading-an-archive-mpu-using-rest.md)
## Processus de chargement partitionné
Comme décrit dans[Téléchargement d'une archive dans Amazon Glacier](uploading-an-archive.md), nous encourageons les clients d'Amazon Glacier (Amazon Glacier) à utiliser le téléchargement partitionné pour charger des archives de plus de 100 mégaoctets (MiB).
1. **Lancement du chargement partitionné**
Lorsque vous envoyez une demande pour lancer un téléchargement partitionné, Amazon Glacier renvoie un ID de téléchargement partitionné, qui est un identifiant unique pour votre téléchargement partitionné. Cet ID sera requis pour toute opération de chargement partitionné suivante. Cet identifiant n'expire pas pendant au moins 24 heures après qu'Amazon Glacier ait terminé la tâche.
Dans votre demande de lancement d'un chargement partitionné, vous devez spécifier la taille des parties en nombre d'octets. Chacune des parties que vous chargez, à l'exception de la dernière partie, doit correspondre à cette taille.
**Note**
Vous n'avez pas besoin de connaître la taille globale de l'archive lorsque vous utilisez le chargement partitionné. Cela signifie que vous pouvez utiliser des téléchargements partiels dans les cas où vous ne connaissez pas la taille de l'archive lorsque vous commencez à charger l'archive. Vous devez juste définir la taille des parties au moment du lancement d'un chargement partitionné.
Dans la demande de lancement de chargement partitionné, vous pouvez également fournir une description facultative de l'archive.
1. **Chargement des parties**
Pour chaque demande de chargement de partie, vous devez inclure l'ID de chargement partitionné que vous avez obtenu à l'étape 1. Dans la demande, vous devez également spécifier la plage de contenu, en octets, en identifiant la position de la partie dans l'archive finale. Amazon Glacier utilise ensuite les informations relatives à la plage de contenus pour assembler l'archive dans le bon ordre. Etant donné que vous indiquez la plage de contenu de chaque partie que vous chargez, il détermine la position de chaque partie dans l'assemblage final de l'archive ; par conséquent, vous pouvez charger les parties dans n'importe quel ordre. Vous pouvez également charger différentes parties en parallèle. Si vous chargez une nouvelle partie en utilisant la même plage de contenu que celle définie pour une partie précédemment chargée, cette dernière est remplacée.
1. **Achèvement (ou arrêt) du chargement partitionné**
Après avoir chargé toutes les parties d'une archive, utilisez l'opération d'achèvement. Là encore, vous devez spécifier l'ID de chargement dans votre demande. Amazon Glacier crée une archive en concaténant les parties par ordre croissant en fonction de la plage de contenu que vous avez fournie. La réponse d'Amazon Glacier à une demande de téléchargement partitionné complet inclut un ID d'archive pour l'archive nouvellement créée. Si vous avez fourni une description d'archive facultative dans la demande Initiate Multipart Upload, Amazon Glacier l'associe à l'archive assemblée. Lorsque votre opération d'achèvement de chargement partitionné aboutit, vous ne pouvez pas faire référence à l'ID de chargement partitionné. Cela signifie que vous ne pouvez pas accéder aux parties associées à l'ID de chargement partitionné.
Si vous arrêtez un chargement partitionné, vous ne pouvez pas charger de parties supplémentaires en utilisant cet ID de chargement partitionné. L'ensemble du stockage consommé par les parties associées au chargement partitionné arrêté est libéré. Si des parties étaient en cours de chargement, ces opérations peuvent encore réussir ou échouer même après un arrêt.
### Opérations supplémentaires de chargement partitionné
Amazon Glacier (Amazon Glacier) fournit les appels d'API de téléchargement partitionné supplémentaires suivants.
+ **Affichage des parties** : cette opération vous permet d'afficher la liste des parties d'un chargement partitionné spécifique. Elle renvoie des informations sur les parties que vous chargées dans le cadre d'un chargement partitionné. Pour chaque demande de pièces de liste, Amazon Glacier renvoie des informations portant sur un maximum de 1 000 pièces. S'il existe d'autres parties à afficher pour le chargement partitionné, le résultat est paginé et la réponse renvoyée inclut un marqueur à partir duquel poursuivre l'affichage de la liste. Vous devez envoyer des demandes supplémentaires pour extraire les parties suivantes. Notez que la liste des parties renvoyée n'inclut pas les parties dont le chargement n'est pas terminé.
+ **Affichage des chargements partitionnés** : cette opération vous permet d'obtenir la liste des chargements partitionnés en cours. Un chargement partitionné en cours est un chargement que vous avez lancé, mais que vous n’avez pas encore terminé ou arrêté. Pour chaque demande d'affichage des chargements partitionnés, Amazon Glacier renvoie jusqu'à 1 000 chargements partitionnés. S'il existe d'autres chargements partitionnés à afficher, le résultat est paginé et la réponse renvoyée inclut un marqueur à partir duquel poursuivre l'affichage de la liste. Vous devez envoyer des demandes supplémentaires pour extraire les chargements partitionnés restants.
## En bref
Le tableau suivant fournit les principales spécifications du chargement partitionné.
| Élément | Spécification |
| --- | --- |
| Taille maximale d'archive | 10 000 x 4 gibioctets (Gio) |
| Nombre maximum de parties par chargement | 10 000 |
| Taille de partie | De 1 Mio à 4 Gio ; la dernière partie peut être inférieure à 1 Mio. Vous spécifiez la valeur de taille en octets. La taille de la partie doit être un mébioctet (1 024 kibioctets [Kio]) multiplié par une puissance de 2. Par exemple, `1048576` (1 Mio), `2097152` (2 Mio), `4194304` (4 Mio), `8388608` (8 Mio). |
| Nombre maximum de parties renvoyées pour une demande de liste des parties | 1 000 |
| Nombre maximum de chargements partitionnés renvoyés dans le cadre d'une demande d'affichage de chargements partitionnés | 1 000 |
# Téléchargement d'archives volumineuses à l'aide du AWS CLI
Vous pouvez charger une archive dans Amazon Glacier (Amazon Glacier) à l'aide du AWS Command Line Interface (AWS CLI). Pour améliorer l'expérience de chargement des archives volumineuses, Amazon Glacier fournit plusieurs opérations d'API pour prendre en charge les téléchargements partitionnés. Grâce à ces opérations d'API, vous pouvez charger les archives en plusieurs parties. Ces parties peuvent être chargées indépendamment, dans n'importe quel ordre, et en parallèle. Si le chargement d'une partie échoue, vous devez uniquement recharger cette partie, pas l'archive entière. Vous pouvez utiliser le chargement partitionné pour les archives dont la taille est comprise entre 1 octet et environ 40 000 gibioctets (Gio).
Pour plus d'informations sur les téléchargements partitionnés sur Amazon Glacier, consultez. [Chargement d'archives volumineuses en plusieurs parties (chargement partitionné)](uploading-archive-mpu.md)
**Topics**
+ [(Prérequis) Configuration du AWS CLI](#Creating-Vaults-CLI-Setup)
+ [(Prérequis) Installation de Python](#Uploading-Archives-mpu-CLI-Install-Python)
+ [(Prérequis) Création d'un coffre-fort Amazon Glacier](#Uploading-Archives-mpu-CLI-Create-Vault)
+ [Exemple : téléchargement partiel d'archives volumineuses à l'aide du AWS CLI](#Uploading-Archives-mpu-CLI-Implementation)
## (Prérequis) Configuration du AWS CLI
1. Téléchargez et configurez l’interface AWS CLI. Pour obtenir des instructions, consultez les rubriques suivantes dans le *Guide de l’utilisateur de l’interface AWS Command Line Interface * :
[Installation du AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html)
[Configuration du AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)
1. Vérifiez votre AWS CLI configuration en saisissant les commandes suivantes à l'invite de commande. Ces commandes ne fournissent pas directement d'informations d'identification, par conséquent ce sont les informations du profil par défaut qui sont utilisées.
+ Essayez d'utiliser la commande help.
```
aws help
```
+ Pour obtenir la liste des coffres-forts Amazon Glacier sur le compte configuré, utilisez la `list-vaults` commande. *123456789012*Remplacez-le par votre Compte AWS identifiant.
```
aws glacier list-vaults --account-id 123456789012
```
+ Pour voir les données de configuration actuelles pour le AWS CLI, utilisez la `aws configure list` commande.
```
aws configure list
```
## (Prérequis) Installation de Python
Pour terminer un téléchargement en plusieurs parties, vous devez calculer le hachage SHA256 arborescent de l'archive que vous chargez. Cela est différent du calcul du hachage SHA256 arborescent du fichier que vous souhaitez télécharger. Pour calculer le hachage SHA256 arborescent de l'archive que vous téléchargez, vous pouvez utiliser Java C\$1 (avec .NET) ou. Python Dans cet exemple, vous allez utiliser Python. Pour savoir comment utiliser Java ou C\$1, consultez [Calcul des totaux de contrôle](checksum-calculations.md).
Pour plus d'informations sur l'installation de Python, consultez [Install ou update Python](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html#installation) dans le *Guide du développeur Boto3*.
## (Prérequis) Création d'un coffre-fort Amazon Glacier
Pour utiliser l'exemple suivant, vous devez avoir créé au moins un coffre-fort Amazon Glacier. Pour plus d'informations sur la création de coffres, consultez [Création d'un coffre-fort dans Amazon Glacier](creating-vaults.md).
## Exemple : téléchargement partiel d'archives volumineuses à l'aide du AWS CLI
Dans cet exemple, vous allez créer un fichier et le charger en plusieurs parties sur Amazon Glacierà l'aide d'opérations d'API de chargement partitionné.
**Important**
Avant de commencer cette procédure, assurez-vous d'avoir effectué toutes les étapes prérequises. Pour télécharger une archive, vous devez avoir créé un coffre, le AWS CLI configurer et être prêt à utiliser Java le langage C\$1 ou Python à calculer un hachage SHA256 arborescent.
La procédure suivante utilise les `complete-multipart-upload` AWS CLI commandes `initiate-multipart-upload``upload-multipart-part`, et.
Pour obtenir des informations plus détaillées sur chacun de ces commandes, consultez [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) et [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) dans le *guide de référence des commandes AWS CLI *.
1. Utilisez la commande [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) pour créer une ressource de chargement partitionné. Dans votre demande, spécifiez la taille des parties en nombre d'octets. Chacune des parties que vous chargez, à l'exception de la dernière, doit avoir cette taille. Vous n'avez pas besoin de connaître la taille globale de l'archive lorsque vous lancez un chargement. Cependant, vous aurez besoin de connaître la taille totale, en octets, de chaque partie pour effectuer le chargement à l'étape finale.
Dans la commande ci-dessous, remplacez les valeurs des paramètres `--vault-name` et `--account-ID` par vos propres informations. Cette commande indique que vous allez charger une archive avec des parties d'une taille d'1 mébioctet (Mio) (1 024 x 1024 octets) par fichier. Remplacez la valeur de ce paramètre `--part-size` si nécessaire.
```
aws glacier initiate-multipart-upload --vault-name awsexamplevault --part-size 1048576 --account-id 123456789012
```
Sortie attendue :
```
{
"location": "/123456789012/vaults/awsexamplevault/multipart-uploads/uploadId",
"uploadId": "uploadId"
}
```
Une fois terminée, la commande affiche l'ID de téléchargement partitionné et l'emplacement de la ressource de téléchargement partitionné dans Amazon Glacier. Cet ID de chargement vous servira dans les prochaines étapes.
1. Pour cet exemple, vous pouvez utiliser les commandes suivantes pour créer un fichier de 4,4 Mio, le scinder en fragments de 1 Mio et charger chacun de ces fragments. Pour charger vos propres fichiers, vous pouvez suivre une procédure similaire en scindant vos données en fragments et en chargeant chaque partie.
**Linux ou macOS**
La commande suivante crée un fichier de 4,4 Mio, nommé `file_to_upload`, sur Linux ou macOS.
```
mkfile -n 9000b file_to_upload
```
**Windows**
La commande suivante crée un fichier de 4,4 Mio, nommé `file_to_upload`, sur Windows.
```
fsutil file createnew file_to_upload 4608000
```
1. Vous allez ensuite scinder ce fichier en fragments de 1 Mio.
```
split -b 1048576 file_to_upload chunk
```
Vous disposez maintenant des cinq fragments suivants. Les quatre premiers font 1 Mio, et le dernier environ 400 kibioctets (Kio).
```
chunkaa
chunkab
chunkac
chunkad
chunkae
```
1. Utilisez la commande [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) pour charger une partie d'une archive. Vous pouvez charger les parties de l'archive dans n'importe quel ordre. Vous pouvez également les charger en parallèle. Vous pouvez charger jusqu'à 10 000 parties pour un chargement partitionné.
Dans la commande suivante, remplacez les valeurs des paramètres `--vault-name`, `--account-ID` et `--upload-id`. L'ID de chargement doit correspondre à l'ID indiqué comme sortie de la commande `initiate-multipart-upload`. Le paramètre `--range` indique que vous allez charger une partie dont la taille est de 1 Mio (1 024 x 1 024 octets). Cette taille doit correspondre à celle que vous avez spécifiée dans la commande `initiate-multipart-upload`. Ajustez cette valeur de taille si nécessaire. Le paramètre `--body` indique le nom de la partie que vous chargez actuellement.
```
aws glacier upload-multipart-part --body chunkaa --range='bytes 0-1048575/*' --vault-name awsexamplevault --account-id 123456789012 --upload-id upload_ID
```
En cas de succès, la commande génère une sortie contenant le total de contrôle de la partie chargée.
1. Exécutez une nouvelle fois la commande `upload-multipart-part` pour charger les parties restantes de votre chargement partitionné. Mettez à jour les valeurs des paramètres `--range` et `–-body` pour chaque commande de sorte qu'elles correspondent à la partie que vous chargez.
```
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
```
**Note**
La valeur du paramètre `--range` de la commande finale est inférieure, car notre chargement fait moins de 1 Mio. En cas de succès, chaque commande génère une sortie contenant le total de contrôle de chaque partie chargée.
1. Ensuite, vous allez assembler l'archive et terminer le chargement. Vous devez inclure la taille totale et le hachage SHA256 arborescent de l'archive.
Pour calculer le hachage SHA256 arborescent de l'archive, vous pouvez utiliser Java C\$1 ou. Python Dans cet exemple, vous allez utiliser Python. Pour savoir comment utiliser Java ou C\$1, consultez [Calcul des totaux de contrôle](checksum-calculations.md).
Créez le fichier Python `checksum.py` et insérez le code suivant. Si nécessaire, remplacez le nom du fichier d'origine.
```
from botocore.utils import calculate_tree_hash
checksum = calculate_tree_hash(open('file_to_upload', 'rb'))
print(checksum)
```
1. Exécutez `checksum.py` pour calculer le hachage de SHA256 l'arbre. Le hachage suivant peut ne pas correspondre à votre sortie.
```
$ python3 checksum.py
$ 3d760edb291bfc9d90d35809243de092aea4c47b308290ad12d084f69988ae0c
```
1. Utilisez la commande [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) pour terminer le chargement de l'archive. Remplacez les valeurs des paramètres `--vault-name`, `--account-ID`, `--upload-ID` et `--checksum`. La valeur du paramètre `--archive` indique la taille totale, en octets, de l'archive. Cette valeur doit correspondre à la somme des tailles des différentes parties que vous avez chargées. Remplacez cette valeur si nécessaire.
```
aws glacier complete-multipart-upload --archive-size 4608000 --vault-name awsexamplevault --account-id 123456789012 --upload-id upload_ID --checksum checksum
```
Une fois terminée, la commande affiche l'ID, la somme de contrôle et l'emplacement de l'archive dans Amazon Glacier.
# Chargement d'archives volumineuses en plusieurs parties à l'aide du kit SDK Amazon pour Java
Les niveaux de [haut et de bas niveau APIs](using-aws-sdk.md) fournis par le SDK Amazon pour Java fournissent une méthode pour télécharger une archive volumineuse ([Téléchargement d'une archive dans Amazon Glacier](uploading-an-archive.md)voir).
+ L'API de haut niveau fournit une méthode que vous pouvez utiliser pour charger des archives de n'importe quelle taille. Selon le fichier que vous chargez, la méthode télécharge une archive en une seule opération ou utilise le support de téléchargement partitionné d'Amazon Glacier (Amazon Glacier) pour charger l'archive en plusieurs parties.
+ L'API de bas niveau est mappée étroitement à l'implémentation REST sous-jacente. Par conséquent, elle fournit une méthode pour charger des archives plus petites en une seule opération et un groupe de méthodes qui prennent en charge le chargement partitionné en plusieurs parties pour les archives plus volumineuses. Cette section explique le chargement des archives volumineuses en plusieurs parties à l'aide de l'API de bas niveau.
Pour plus d'informations sur le haut niveau et le bas niveau APIs, consultez[Utilisation du AWS SDK pour Java avec Amazon Glacier](using-aws-sdk-for-java.md).
**Topics**
+ [Téléchargement partiel d'archives volumineuses à l'aide de l'API de haut niveau du AWS SDK pour Java](#uploading-an-archive-in-parts-highlevel-using-java)
+ [Téléchargez des archives volumineuses en plusieurs parties à l'aide de l'API de bas niveau du AWS SDK pour Java](#uploading-an-archive-mpu-using-java-lowlevel)
## Téléchargement partiel d'archives volumineuses à l'aide de l'API de haut niveau du AWS SDK pour Java
Vous utilisez les mêmes méthodes de l'API de haut niveau pour charger les archives petites ou volumineuses. En fonction de la taille de l'archive, les méthodes d'API de haut niveau décident de charger l'archive en une seule opération ou d'utiliser l'API de téléchargement en plusieurs parties fournie par Amazon Glacier. Pour de plus amples informations, veuillez consulter [Téléchargement d'une archive à l'aide de l'API de haut niveau du AWS SDK pour Java](uploading-an-archive-single-op-using-java.md#uploading-an-archive-single-op-high-level-using-java).
## Téléchargez des archives volumineuses en plusieurs parties à l'aide de l'API de bas niveau du AWS SDK pour Java
Pour bénéficier d'un contrôle précis du chargement, vous pouvez utiliser l'API de bas niveau afin de configurer la demande et traiter la réponse. Voici les étapes pour charger des archives volumineuses en plusieurs parties à l'aide du kit AWS SDK pour Java.
1. Créez une instance de la classe `AmazonGlacierClient` (le client).
Vous devez spécifier AWS la région dans laquelle vous souhaitez enregistrer l'archive. Toutes les opérations que vous effectuez à l'aide de ce client s'appliquent à cette AWS région.
1. Lancez un téléchargement partitionné en appelant la méthode `initiateMultipartUpload`.
Vous devez fournir le nom du coffre dans lequel vous souhaitez charger l'archive, spécifier la taille des parties de l'archive à charger et indiquer éventuellement une description. Vous fournissez ces informations en créant une instance de la classe `InitiateMultipartUploadRequest`. En réponse, Amazon Glacier renvoie un ID de chargement.
1. Chargez les parties en appelant la méthode `uploadMultipartPart`.
Pour chaque partie que vous chargez, vous devez fournir le nom du coffre, la plage d'octets dans l'archive assemblée finale qui sera chargée dans cette partie, le total de contrôle des données de la partie et l'ID du chargement.
1. Terminez le chargement partitionné en appelant la méthode `completeMultipartUpload`.
Vous devez fournir l'ID de chargement, le total de contrôle de l'archive entière, la taille de l'archive (taille combinée de toutes les parties que avez chargées) et le nom du coffre. Amazon Glacier construit l'archive à partir des parties chargées et renvoie un ID d'archive.
### Exemple : téléchargement d'une archive volumineuse en plusieurs parties à l'aide du AWS SDK pour Java
L'exemple de code Java suivant utilise le AWS SDK pour Java pour télécharger une archive dans un coffre (`examplevault`). Pour step-by-step obtenir des instructions sur la façon d'exécuter cet exemple, reportez-vous à[Exécution d'exemples Java pour Amazon Glacier à l'aide d'Eclipse](using-aws-sdk-for-java.md#setting-up-and-testing-sdk-java). Vous devez mettre à jour le code tel qu'il est présenté avec le nom du fichier que vous souhaitez charger.
**Note**
Cet exemple concerne des tailles de partie comprises entre 1 Mo et 1 Go. Toutefois, Amazon Glacier prend en charge des tailles de partie pouvant aller jusqu'à 4 Go.
**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();
}
}
```
# Téléchargement d'archives volumineuses à l'aide du AWS SDK pour .NET
Les niveaux de [haut et de bas niveau APIs](using-aws-sdk.md) fournis par le SDK Amazon pour .NET fournissent une méthode pour télécharger des archives volumineuses en plusieurs parties ([Téléchargement d'une archive dans Amazon Glacier](uploading-an-archive.md)voir).
+ L'API de haut niveau fournit une méthode que vous pouvez utiliser pour charger des archives de n'importe quelle taille. Selon le fichier que vous chargez, la méthode télécharge l'archive en une seule opération ou utilise le support de téléchargement en plusieurs parties d'Amazon Glacier (Amazon Glacier) pour télécharger l'archive en plusieurs parties.
+ L'API de bas niveau est mappée étroitement à l'implémentation REST sous-jacente. Par conséquent, elle fournit une méthode pour charger des archives plus petites en une seule opération et un groupe de méthodes qui prennent en charge le chargement partitionné en plusieurs parties pour les archives plus volumineuses. Cette section explique le chargement des archives volumineuses en plusieurs parties à l'aide de l'API de bas niveau.
Pour plus d'informations sur le haut niveau et le bas niveau APIs, consultez[Utilisation du AWS SDK pour .NET avec Amazon Glacier](using-aws-sdk-for-dot-net.md).
**Topics**
+ [Téléchargement partiel d'archives volumineuses à l'aide de l'API de haut niveau du AWS SDK pour .NET](#uploading-an-archive-in-parts-highlevel-using-dotnet)
+ [Téléchargement partiel d'archives volumineuses à l'aide de l'API de bas niveau du AWS SDK pour .NET](#uploading-an-archive-in-parts-lowlevel-using-dotnet)
## Téléchargement partiel d'archives volumineuses à l'aide de l'API de haut niveau du AWS SDK pour .NET
Vous utilisez les mêmes méthodes de l'API de haut niveau pour charger les archives petites ou volumineuses. En fonction de la taille de l'archive, les méthodes d'API de haut niveau décident de charger l'archive en une seule opération ou d'utiliser l'API de téléchargement en plusieurs parties fournie par Amazon Glacier. Pour de plus amples informations, veuillez consulter [Téléchargement d'une archive à l'aide de l'API de haut niveau du AWS SDK pour .NET](uploading-an-archive-single-op-using-dotnet.md#uploading-an-archive-single-op-highlevel-using-dotnet).
## Téléchargement partiel d'archives volumineuses à l'aide de l'API de bas niveau du AWS SDK pour .NET
Pour bénéficier d'un contrôle précis du chargement, vous pouvez utiliser l'API de bas niveau afin de configurer la demande et traiter la réponse. Voici les étapes pour charger des archives volumineuses en plusieurs parties à l'aide du kit AWS SDK pour .NET.
1. Créez une instance de la classe `AmazonGlacierClient` (le client).
Vous devez spécifier AWS la région dans laquelle vous souhaitez enregistrer l'archive. Toutes les opérations que vous effectuez à l'aide de ce client s'appliquent à cette AWS région.
1. Lancez un téléchargement partitionné en appelant la méthode `InitiateMultipartUpload`.
Vous devez fournir le nom du coffre dans lequel vous souhaitez charger l'archive, spécifier la taille des parties de l'archive à charger et indiquer éventuellement une description. Vous fournissez ces informations en créant une instance de la classe `InitiateMultipartUploadRequest`. En réponse, Amazon Glacier renvoie un ID de chargement.
1. Chargez les parties en appelant la méthode `UploadMultipartPart`.
Pour chaque partie que vous chargez, vous devez fournir le nom du coffre, la plage d'octets dans l'archive assemblée finale qui sera chargée dans cette partie, le total de contrôle des données de la partie et l'ID du chargement.
1. Terminez le chargement partitionné en appelant la méthode `CompleteMultipartUpload`.
Vous devez fournir l'ID de chargement, le total de contrôle de l'archive entière, la taille de l'archive (taille combinée de toutes les parties que avez chargées) et le nom du coffre. Amazon Glacier construit l'archive à partir des parties chargées et renvoie un ID d'archive.
### Exemple : Chargement d'une archive volumineuse en plusieurs parties à l'aide du kit SDK Amazon pour .NET
L'exemple de code C\$1 suivant utilise le AWS SDK pour .NET pour télécharger une archive dans un coffre (`examplevault`). Pour step-by-step obtenir des instructions sur la façon d'exécuter cet exemple, reportez-vous à[Exemples de code en cours d'exécution](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet). Vous devez mettre à jour le code tel qu'il est présenté avec le nom d'un fichier que vous souhaitez charger.
**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;
}
}
}
```
# Chargement d'archives volumineuses en plusieurs parties à l'aide de l'API REST
Comme indiqué dans [Chargement d'archives volumineuses en plusieurs parties (chargement partitionné)](uploading-archive-mpu.md), le chargement partitionné fait référence à un ensemble d'opérations qui vous permettent de charger une archive en plusieurs parties et d'effectuer des opérations connexes. Pour plus d'informations sur ces opérations, consultez les rubriques de référence API suivantes :
+ [Lancement de chargement partitionné (POST multipart-uploads)](api-multipart-initiate-upload.md)
+ [Partie chargement (PUT uploadID)](api-upload-part.md)
+ [Achèvement du chargement partitionné (POST uploadID)](api-multipart-complete-upload.md)
+ [Annulation de chargement partitionné (DELETE uploadID)](api-multipart-abort-upload.md)
+ [Répertorier les parties (GET uploadID)](api-multipart-list-parts.md)
+ [Afficher la liste des chargements partitionnés (GET multipart-uploads)](api-multipart-list-uploads.md)
# Téléchargement d'une archive dans Amazon Glacier
Amazon Glacier fournit une console de gestion que vous pouvez utiliser pour créer et supprimer des coffres-forts. Cependant, vous ne pouvez pas télécharger d'archives depuis Amazon Glacier à l'aide de la console de gestion. Pour télécharger des données, telles que des photos, des vidéos et d'autres documents, vous devez soit utiliser le AWS Command Line Interface (AWS CLI), soit écrire du code pour effectuer des requêtes, en utilisant soit directement l'API REST, soit en utilisant le AWS SDKs.
Pour plus d'informations sur l'utilisation d'Amazon Glacier avec le AWS CLI, consultez la [AWS CLI référence relative à Amazon Glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html). Pour installer le AWS CLI, voir [AWS Command Line Interface](https://aws.amazon.com/cli/). Les rubriques suivantes décrivent comment télécharger des archives sur Amazon Glacier à l'aide de l'API REST Amazon Glacier AWS SDK pour Java, de AWS SDK pour .NET, et de l'API REST Amazon Glacier.
**Topics**
+ [Récupération des archives Amazon Glacier](downloading-an-archive-two-steps.md)
+ [Téléchargement d'une archive dans Amazon Glacier à l'aide du AWS SDK pour Java](downloading-an-archive-using-java.md)
+ [Téléchargement d'une archive dans Amazon Glacier à l'aide du AWS SDK pour .NET](downloading-an-archive-using-dotnet.md)
+ [Téléchargement d'une archive volumineuse à l'aide du traitement parallèle avec Python](downloading-large-archive-parallel-python.md)
+ [Téléchargement d'une archive à l'aide de l'API REST](downloading-an-archive-using-rest.md)
+ [Téléchargement d'une archive dans Amazon Glacier à l'aide du AWS CLI](downloading-an-archive-using-cli.md)
# Récupération des archives Amazon Glacier
La récupération d'une archive depuis Amazon Glacier est une opération asynchrone au cours de laquelle vous lancez d'abord une tâche, puis vous téléchargez le résultat une fois la tâche terminée. Pour lancer une tâche de récupération d'archives, vous devez utiliser l'opération d'[Lancement d'une tâche (POST jobs)](api-initiate-job-post.md)API REST ou l'équivalent dans le AWS CLI, ou le AWS SDKs.
**Topics**
+ [Options de récupération des archives](#api-downloading-an-archive-two-steps-retrieval-options)
+ [Récupération d'une plage d'archives](#downloading-an-archive-range)
La récupération d'une archive depuis Amazon Glacier est un processus en deux étapes. Ce qui suit est un aperçu de ce processus.
**Pour récupérer une archive**
1. Lancez une tâche d’extraction d’archive.
1. Obtenez l'ID de l'archive que vous souhaitez extraire. Vous pouvez obtenir l'ID de l'archive à partir d'un inventaire du coffre. Vous pouvez obtenir l'ID de l'archive avec l'API REST AWS CLI, ou AWS SDKs. Pour de plus amples informations, veuillez consulter [Téléchargement d'un inventaire de coffre-fort dans Amazon Glacier](vault-inventory.md).
1. Lancez une tâche qui demande à Amazon Glacier de préparer une archive complète ou une partie de l'archive pour un téléchargement ultérieur à l'aide de cette [Lancement d'une tâche (POST jobs)](api-initiate-job-post.md) opération.
Lorsque vous lancez une tâche, Amazon Glacier renvoie un ID de tâche dans la réponse et exécute la tâche de manière asynchrone. (Vous ne pouvez pas télécharger la sortie de la tâche tant que celle-ci n'est pas terminée, comme indiqué à l'étape 2.)
**Important**
Pour les extractions de type Standard uniquement, une politique d'extraction de données peut entraîner l'échec de votre demande `Initiate Job` avec une exception `PolicyEnforcedException`. Pour plus d'informations sur les stratégies d'extraction de données, consultez la section [Politiques de récupération des données Amazon Glacier](data-retrieval-policy.md). Pour plus d'informations sur l'exception `PolicyEnforcedException`, consultez la section [Réponses d’erreur](api-error-responses.md).
Si nécessaire, vous pouvez restaurer de larges segments des données stockées dans Amazon Glacier. Pour plus d'informations sur la restauration des données à partir des classes de stockage Amazon Glacier, consultez la section [Classes de stockage pour les objets d'archivage]( https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html#sc-glacier) dans le *guide de l'utilisateur d'Amazon Simple Storage Service*.
1. Une fois la tâche terminée, téléchargez les octets à l'aide de l'opération [Génération de sortie de tâche (GET output)](api-job-output-get.md).
Vous pouvez télécharger tous les octets ou spécifier une plage d'octets afin de télécharger une seule partie de la sortie de la tâche. Pour les sorties plus volumineuses, le téléchargement en plusieurs parties s'avère utile en cas d'échec du téléchargement, par exemple en raison d'une défaillance réseau. Si vous générez la sortie de la tâche dans le cadre d'une seule demande et qu'une défaillance réseau se produit, vous devez redémarrer le téléchargement de la sortie depuis le début. En revanche, si vous téléchargez la sortie en plusieurs parties et qu'une défaillance se produit, vous devez uniquement redémarrer le téléchargement de la partie et non celui de la sortie entière.
Amazon Glacier doit terminer une tâche avant que vous puissiez obtenir sa sortie. Après son achèvement, une tâche n'expire pas avant au moins 24 heures, ce qui signifie que vous disposez d'un délai de 24 heures pour télécharger la sortie une fois la tâche terminée. La restauration peut expirer à tout moment 24 heures après la fin de la tâche. Pour déterminer si votre tâche est terminée, vérifiez son état en utilisant l'une des options suivantes :
+ **Attendez une notification de fin de tâche** : vous pouvez spécifier une rubrique Amazon Simple Notification Service (Amazon SNS) sur laquelle Amazon Glacier pourra publier une notification une fois la tâche terminée. Amazon Glacier envoie une notification uniquement une fois la tâche terminée.
Vous pouvez spécifier une rubrique Amazon SNS pour une tâche au moment où vous la lancez. En plus de spécifier une rubrique Amazon SNS dans votre demande d'emploi, si votre coffre-fort contient des notifications définies pour les événements de récupération d'archives, Amazon Glacier publie également une notification à cette rubrique SNS. Pour de plus amples informations, veuillez consulter [Configuration des notifications de coffre-fort dans Amazon Glacier](configuring-notifications.md).
+ **Demander des informations sur les offres d'emploi de manière explicite** : vous pouvez également utiliser l'opération d'`Describe Job`API Amazon Glacier ([Description de la tâche (GET JobID)](api-describe-job-get.md)) pour demander régulièrement des informations sur les offres d'emploi. Cependant, nous vous recommandons d'utiliser des notifications Amazon SNS.
**Note**
Les informations que vous obtenez en utilisant une notification Amazon SNS sont identiques à celles obtenues en appelant l'opération d'API `Describe Job`.
## Options de récupération des archives
Lorsque vous lancez une tâche en vue d'extraire une archive, vous pouvez spécifier l'une des options d'exaction suivantes, en fonction de vos exigences en matière de temps d'accès et de coûts. Pour plus d'informations sur les tarifs de récupération, consultez la section Tarification [d'Amazon Glacier](https://aws.amazon.com/s3/glacier/pricing/).
+ **Expedited** : les extractions de type Expedited vous permettent d'accéder rapidement à vos données stockées dans la classe de stockage S3 Glacier Flexible Retrieval ou au niveau Accès aux archives S3 Intelligent-Tiering lorsque des demandes urgentes occasionnelles de restauration d'archives se présentent. Pour toutes les archives à l'exception des plus volumineuses (plus de 250 Mo), les données auxquelles vous accédez à l'aide des extractions Expedited sont généralement disponibles dans un délai compris entre 1 et 5 minutes. La capacité provisionnée garantit que la capacité des récupérations rapides est disponible lorsque vous en avez besoin. Pour de plus amples informations, veuillez consulter [Capacité provisionnée](#api-downloading-an-archive-two-steps-retrieval-expedited-capacity).
+ **Standard** : les extractions de type Standard vous permettent d'accéder à vos archives en plusieurs heures. Les extractions Standard prennent généralement entre 3 et 5 heures. Standard constitue l’option par défaut pour les demandes de récupération qui ne spécifient pas l’option de récupération.
+ **En vrac** : les extractions en masse constituent l'option la moins coûteuse d'Amazon Glacier. Vous pouvez l'utiliser pour récupérer de grandes quantités, voire des pétaoctets, de données à moindre coût par jour. Les extractions Bulk prennent généralement entre 5 et 12 heures.
Le tableau suivant récapitule les options de récupération d’archive. Pour plus d’informations sur la tarification, consultez [Tarification Amazon Glacier](https://aws.amazon.com/s3/glacier/pricing/).
| Service | Accéléré | Standard | Volume |
| --- | --- | --- | --- |
| Amazon Glacier | 1 à 5 minutes | 3 à 5 heures | 5 à 12 heures |
Pour effectuer une ou une `Bulk` extraction `Expedited``Standard`, définissez l'élément de requête dans la `Tier` demande d'opération de l'[https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOSTrestore.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOSTrestore.html)API REST sur l'option que vous souhaitez, ou sur l'équivalent dans le AWS Command Line Interface (AWS CLI) ou AWS SDKs. Si vous avez acheté une capacité provisionnée, toutes les récupérations rapides de type Expedited sont automatiquement transmises par le biais de votre capacité provisionnée.
### Capacité provisionnée
La capacité provisionnée vous permet de disposer d'une capacité d'extraction pour les extractions de type Expedited lorsque vous en avez besoin. Chaque unité de capacité permet d'effectuer au moins trois extractions accélérées toutes les 5 minutes et fournit un débit de récupération allant jusqu'à 150 mégaoctets par seconde (). MBps
Si votre charge de travail nécessite un accès extrêmement fiable et prévisible à un sous-ensemble de vos données en quelques minutes, nous vous recommandons d'acheter de la capacité d'extraction provisionnée. Sans capacité provisionnée, les extractions de type Expedited sont généralement acceptées, sauf dans les rares cas où la demande est particulièrement élevée. Toutefois, si vous avez besoin d'un accès aux récupérations rapides en toutes circonstances, vous devez acheter la capacité de récupération provisionnée.
#### Achat d'une capacité allouée
Vous pouvez acheter des unités de capacité provisionnées à l'aide de la console Amazon Glacier, de l'opération de l'[Acheter la capacité provisionnée (POST provisioned-capacity)](api-PurchaseProvisionedCapacity.md)API REST AWS SDKs, du ou du AWS CLI. Pour obtenir des informations sur la tarification de la capacité allouée, consultez la section [Tarification d'Amazon Glacier](https://aws.amazon.com/s3/glacier/pricing/).
Une unité de capacité provisionnée a une durée d'un mois à partir de la date et de l'heure d'achat.
Si la date de début est le 31e jour du mois, la date d'expiration correspond au dernier jour du mois suivant. Par exemple, si la date de début est le 31 août, la date d'expiration est le 30 septembre. Si la date de début est le 31 janvier, la date d'expiration est le 28 février.
**Pour acheter de la capacité provisionnée à l'aide de la console Amazon Glacier**
1. Connectez-vous à la console Amazon Glacier AWS Management Console et ouvrez-la [https://console.aws.amazon.com/glacier/chez](https://console.aws.amazon.com/glacier/home) vous.
1. Dans le panneau de navigation de gauche, choisissez **Paramètres d'extraction de données**.
1. Sous **Unités de capacité provisionnées (PCUs)**, choisissez **Acheter un PCU**. La boîte de dialogue **Acheter la PCU** s'affiche.
1. Si vous souhaitez acheter de la capacité provisionnée, saisissez **confirm** dans la zone **Confirmer l'achat**.
1. Choisissez **Acheter la PCU**.
## Récupération d'une plage d'archives
Lorsque vous extrayez une archive d’Amazon Glacier, vous pouvez éventuellement spécifier une plage, ou une partie, de l’archive à extraire. Le comportement par défaut consiste à extraire la totalité de l’archive. La spécification d'une plage d'octets peut vous être utile lorsque vous souhaitez effectuer les actions suivantes :
+ **Gérez vos téléchargements de données** : Amazon Glacier autorise le téléchargement des données récupérées pendant 24 heures après la fin de la demande de récupération. Par conséquent, vous souhaiterez peut-être extraire uniquement certaines parties de l'archive afin de pouvoir gérer le programme des téléchargements dans la fenêtre de téléchargement définie.
+ **Extraire une partie ciblée d'une archive volumineuse** : par exemple, supposez que vous avez regroupé un grand nombre de fichiers, que vous les avez chargés sous la forme d'une archive unique et que vous souhaitez à présent extraire une partie des fichiers. Dans ce cas, vous pouvez spécifier une plage de l'archive qui contient les fichiers qui vous intéressent en utilisant une demande d'extraction. Vous pouvez aussi lancer plusieurs demandes d'extraction, chacune d'elles définissant une plage d'un ou de plusieurs fichiers.
Lors du lancement d'une tâche d'extraction à l'aide d'extractions par plage, vous devez fournir une plage alignée en termes de méga-octet. En d'autres termes, la plage d'octets peut commencer à zéro (début de l'archive) ou à n'importe quel intervalle d'1 Mo suivant (1 Mo, 2 Mo, 3 Mo, etc.).
La fin de la section peut correspondre à la fin de votre archive ou être indiquée, là encore, selon tout intervalle de 1 Mo supérieur à celui de départ. Par ailleurs, si vous souhaitez obtenir des valeurs de total de contrôle lorsque vous téléchargez les données (une fois que la tâche d'extraction est terminée), la plage que vous demandez lors du lancement de la tâche doit également être alignée avec le hachage d'arborescence. Vous pouvez utiliser des totaux de contrôle pour vérifier que les données n'ont pas été endommagées pendant la transmission. Pour plus d'informations sur l'alignement en termes de méga-octets et l'alignement avec le hachage d'arborescence, consultez la section [Réception des totaux de contrôle lors du téléchargement de données](checksum-calculations-range.md).
# Téléchargement d'une archive dans Amazon Glacier à l'aide du AWS SDK pour Java
Le [haut niveau et le bas niveau APIs](using-aws-sdk.md) fournis par le SDK Amazon pour Java fournissent une méthode pour télécharger une archive.
**Topics**
+ [Téléchargement d'une archive à l'aide de l'API de haut niveau du AWS SDK pour Java](#downloading-an-archive-using-java-highlevel-api)
+ [Téléchargement d'une archive à l'aide de l'API de bas niveau du AWS SDK pour Java](#downloading-an-archive-using-java-lowlevel-api)
## Téléchargement d'une archive à l'aide de l'API de haut niveau du AWS SDK pour Java
La classe `ArchiveTransferManager` de l'API de haut niveau fournit la méthode `download` que vous pouvez utiliser pour télécharger une archive.
**Important**
La classe `ArchiveTransferManager` crée une rubrique Amazon Simple Notification Service (Amazon SNS) et une file d'attente Amazon Simple Queue Service (Amazon SQS) qui est abonnée à cette rubrique. Elle lance ensuite la tâche d'extraction d'archive et interroge la file d'attente pour que l'archive soit disponible. Une fois que l'archive est disponible, le téléchargement commence. Pour plus d'informations sur les délais d'extraction, consultez [Options de récupération des archives](downloading-an-archive-two-steps.md#api-downloading-an-archive-two-steps-retrieval-options).
### Exemple : téléchargement d'une archive à l'aide de l'API de haut niveau du AWS SDK pour Java
L'exemple de code Java suivant télécharge une archive à partir d'un coffre (`examplevault`) de la région USA Ouest (Oregon) (`us-west-2`).
Pour step-by-step obtenir des instructions relatives à l'exécution de cet exemple, consultez[Exécution d'exemples Java pour Amazon Glacier à l'aide d'Eclipse](using-aws-sdk-for-java.md#setting-up-and-testing-sdk-java). Vous devez mettre à jour le code avec un ID d'archive existant et le chemin d'accès au fichier local où vous souhaitez enregistrer l'archive téléchargée, comme illustré ci-après.
**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);
}
}
}
```
## Téléchargement d'une archive à l'aide de l'API de bas niveau du AWS SDK pour Java
Voici les étapes d'extraction d'un inventaire de coffre à l'aide de l'API de bas niveau du kit AWS SDK pour Java :
1. Créez une instance de la classe `AmazonGlacierClient` (le client).
Vous devez spécifier AWS la région à partir de laquelle vous souhaitez télécharger l'archive. Toutes les opérations que vous effectuez à l'aide de ce client s'appliquent à cette AWS région.
1. Lancez une tâche `archive-retrieval` en exécutant la méthode `initiateJob`.
Vous fournissez des informations sur la tâche, telles que l'ID d'archive de l'archive que vous souhaitez télécharger et la rubrique Amazon SNS facultative sur laquelle vous souhaitez qu'Amazon Glacier (Amazon Glacier) publie un message de fin de tâche, en créant une instance de la `InitiateJobRequest` classe. Amazon Glacier renvoie un numéro de tâche en réponse. La réponse est disponible dans une instance de la classe `InitiateJobResult`.
```
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();
```
Vous pouvez éventuellement spécifier une plage d'octets pour demander à Amazon Glacier de préparer uniquement une partie de l'archive. Par exemple, vous pouvez mettre à jour la demande précédente en ajoutant l'instruction suivante pour demander à Amazon Glacier de ne préparer que la partie 1 Mo à 2 Mo de l'archive.
```
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. Attendez que la tâche se termine.
Vous devez attendre que la sortie de la tâche soit prête pour pouvoir effectuer le téléchargement. Si vous avez défini une configuration de notification dans le coffre identifiant une rubrique Amazon Simple Notification Service (Amazon SNS) ou si vous avez spécifié une rubrique Amazon SNS lorsque vous avez lancé une tâche, Amazon Glacier envoie un message à cette rubrique une fois la tâche terminée.
Vous pouvez également interroger Amazon Glacier en appelant la `describeJob` méthode pour déterminer l'état d'achèvement de la tâche. Toutefois, l'approche recommandée consiste à utiliser une rubrique Amazon SNS pour la notification.
1. Téléchargez la sortie de la tâche (données archivées) en exécutant la méthode `getJobOutput`.
Vous indiquez les informations sur la demande, telles que l'ID de la tâche et le nom du coffre, en créant une instance de la classe `GetJobOutputRequest`. La sortie renvoyée par Amazon Glacier est disponible dans l'`GetJobOutputResult`objet.
```
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.
```
L'extrait de code précédent télécharge la totalité de la sortie de la tâche. Vous pouvez éventuellement extraire une partie de la sortie ou télécharger la totalité de la sortie en plusieurs parties en spécifiant la plage d'octets dans votre demande `GetJobOutputRequest`.
```
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 ****");
```
En réponse à votre `GetJobOutput` appel, Amazon Glacier renvoie la somme de contrôle de la partie des données que vous avez téléchargée, si certaines conditions sont remplies. Pour de plus amples informations, veuillez consulter [Réception des totaux de contrôle lors du téléchargement de données](checksum-calculations-range.md).
Pour vérifier que le téléchargement ne comporte aucune erreur, vous pouvez ensuite calculer la somme de contrôle côté client et la comparer à la somme de contrôle envoyée par Amazon Glacier dans la réponse.
Pour une tâche de récupération d'archives avec la plage optionnelle spécifiée, lorsque vous obtenez la description de la tâche, elle inclut la somme de contrôle de la plage que vous récupérez (). SHA256 TreeHash Vous pouvez utiliser cette valeur pour mieux vérifier la précision de la totalité de la plage d'octets que vous téléchargez plus tard. Par exemple, si vous lancez une tâche pour extraire une plage d'une archive alignée sur le hachage d'arborescence, que vous téléchargez la sortie en plusieurs parties et que chacune de vos demandes `GetJobOutput` renvoie un total de contrôle, vous pouvez ensuite calculer le total de contrôle de chaque partie téléchargée côté client, puis calculer le hachage d'arborescence. Vous pouvez le comparer à la somme de contrôle renvoyée par Amazon Glacier en réponse à votre demande de travail de description afin de vérifier que l'ensemble de la plage d'octets que vous avez téléchargée est identique à la plage d'octets stockée dans Amazon Glacier.
Pour obtenir un exemple pratique, consultez [Exemple 2 : extraction d'une archive à l'aide de l'API de bas niveau de la sortie AWS SDK pour Java—Download in Chunks](#downloading-an-archive-with-range-using-java-example).
### Exemple 1 : extraction d'une archive à l'aide de l'API de bas niveau du AWS SDK pour Java
L'exemple de code Java suivant télécharge une archive à partir du coffre spécifié. Une fois la tâche terminée, l'exemple télécharge la totalité de la sortie dans un seul appel `getJobOutput`. Pour obtenir un exemple de téléchargement d'une sortie en plusieurs parties, consultez la section [Exemple 2 : extraction d'une archive à l'aide de l'API de bas niveau de la sortie AWS SDK pour Java—Download in Chunks](#downloading-an-archive-with-range-using-java-example).
L’exemple exécute les tâches suivantes :
+ Création d'une rubrique Amazon Simple Notification Service (Amazon SNS).
Amazon Glacier envoie une notification à cette rubrique une fois le travail terminé.
+ Création d'une file d'attente Amazon Simple Queue Service (Amazon SQS).
L'exemple attache une stratégie à la file d'attente pour permettre à la rubrique Amazon SNS de publier des messages dans la file d'attente.
+ Lancement d'une tâche de téléchargement de l'archive spécifiée.
Dans la demande de travail, le sujet Amazon SNS créé est spécifié afin qu'Amazon Glacier puisse publier une notification sur le sujet une fois le travail terminé.
+ Recherche périodiquement un message contenant l'ID de la tâche dans la file d'attente Amazon SQS.
Si un message est présent, l'exemple analyse le JSON et vérifie si la tâche s'est correctement déroulée. Si tel est le cas, il télécharge l'archive.
+ Nettoyage par la suppression de la rubrique Amazon SNS et de la file d'attente Amazon SQS qu'il a créées.
```
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));
}
}
```
### Exemple 2 : extraction d'une archive à l'aide de l'API de bas niveau de la sortie AWS SDK pour Java—Download in Chunks
L'exemple de code Java suivant extrait une archive d'Amazon Glacier. L'exemple de code télécharge la sortie de la tâche en plusieurs parties en spécifiant une plage d'octets dans un objet `GetJobOutputRequest`.
```
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));
}
}
```
# Téléchargement d'une archive dans Amazon Glacier à l'aide du AWS SDK pour .NET
Le [haut niveau et le bas niveau APIs](using-aws-sdk.md) fournis par le SDK Amazon pour .NET fournissent une méthode pour télécharger une archive.
**Topics**
+ [Téléchargement d'une archive à l'aide de l'API de haut niveau du AWS SDK pour .NET](#downloading-an-archive-using-dotnet-highlevel-api)
+ [Téléchargement d'une archive à l'aide de l'API de bas niveau du AWS SDK pour .NET](#downloading-an-archive-using-dotnet-lowlevel-api)
## Téléchargement d'une archive à l'aide de l'API de haut niveau du AWS SDK pour .NET
La classe `ArchiveTransferManager` de l'API de haut niveau fournit la méthode `Download` que vous pouvez utiliser pour télécharger une archive.
**Important**
La classe `ArchiveTransferManager` crée une rubrique Amazon Simple Notification Service (Amazon SNS) et une file d'attente Amazon Simple Queue Service (Amazon SQS) qui est abonnée à cette rubrique. Elle lance ensuite la tâche d'extraction d'archive et interroge la file d'attente pour que l'archive soit disponible. Une fois que l'archive est disponible, le téléchargement commence. Pour plus d'informations sur les délais d'extraction, consultez [Options de récupération des archives](downloading-an-archive-two-steps.md#api-downloading-an-archive-two-steps-retrieval-options)
### Exemple : téléchargement d'une archive à l'aide de l'API de haut niveau du AWS SDK pour .NET
L'exemple de code C\$1 suivant télécharge une archive à partir d'un coffre (`examplevault`) de la région USA Ouest (Oregon).
Pour step-by-step obtenir des instructions sur la façon d'exécuter cet exemple, consultez[Exemples de code en cours d'exécution](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet). Vous devez mettre à jour le code avec un ID d'archive existant et le chemin d'accès au fichier local où vous souhaitez enregistrer l'archive téléchargée, comme illustré ci-après.
```
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);
}
}
}
}
```
## Téléchargement d'une archive à l'aide de l'API de bas niveau du AWS SDK pour .NET
Voici les étapes à suivre pour télécharger une archive Amazon Glacier (Amazon Glacier) à l'aide de l'API de bas niveau du AWS SDK pour .NET.
1. Créez une instance de la classe `AmazonGlacierClient` (le client).
Vous devez spécifier AWS la région à partir de laquelle vous souhaitez télécharger l'archive. Toutes les opérations que vous effectuez à l'aide de ce client s'appliquent à cette AWS région.
1. Lancez une tâche `archive-retrieval` en exécutant la méthode `InitiateJob`.
Vous fournissez des informations sur la tâche, telles que l'ID d'archive de l'archive que vous souhaitez télécharger et la rubrique Amazon SNS facultative sur laquelle vous souhaitez qu'Amazon Glacier publie un message de fin de tâche, en créant une instance de la `InitiateJobRequest` classe. Amazon Glacier renvoie un numéro de tâche en réponse. La réponse est disponible dans une instance de la classe `InitiateJobResponse`.
```
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;
```
Vous pouvez éventuellement spécifier une plage d'octets pour demander à Amazon Glacier de préparer uniquement une partie de l'archive, comme indiqué dans la demande suivante. La demande indique à Amazon Glacier de préparer uniquement la partie de 1 Mo à 2 Mo de l'archive.
```
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. Attendez que la tâche se termine.
Vous devez attendre que la sortie de la tâche soit prête pour pouvoir effectuer le téléchargement. Si vous avez défini une configuration de notification dans le coffre identifiant une rubrique Amazon Simple Notification Service (Amazon SNS) ou si vous avez spécifié une rubrique Amazon SNS lorsque vous avez lancé une tâche, Amazon Glacier envoie un message à cette rubrique une fois la tâche terminée. L'exemple de code présenté dans la section suivante utilise Amazon SNS pour qu'Amazon Glacier publie un message.
Vous pouvez également interroger Amazon Glacier en appelant la `DescribeJob` méthode pour déterminer l'état d'achèvement de la tâche. Toutefois, l'approche recommandée consiste à utiliser une rubrique Amazon SNS pour la notification.
1. Téléchargez la sortie de la tâche (données archivées) en exécutant la méthode `GetJobOutput`.
Vous indiquez les informations sur la demande, telles que l'ID de la tâche et le nom du coffre, en créant une instance de la classe `GetJobOutputRequest`. La sortie renvoyée par Amazon Glacier est disponible dans l'`GetJobOutputResponse`objet.
```
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);
}
}
```
L'extrait de code précédent télécharge la totalité de la sortie de la tâche. Vous pouvez éventuellement extraire une partie de la sortie ou télécharger la totalité de la sortie en plusieurs parties en spécifiant la plage d'octets dans votre demande `GetJobOutputRequest`.
```
GetJobOutputRequest getJobOutputRequest = new GetJobOutputRequest()
{
JobId = jobId,
VaultName = vaultName
};
getJobOutputRequest.SetRange(0, 1048575); // Download only the first 1 MB chunk of the output.
```
En réponse à votre `GetJobOutput` appel, Amazon Glacier renvoie la somme de contrôle de la partie des données que vous avez téléchargée, si certaines conditions sont remplies. Pour de plus amples informations, veuillez consulter [Réception des totaux de contrôle lors du téléchargement de données](checksum-calculations-range.md).
Pour vérifier que le téléchargement ne comporte aucune erreur, vous pouvez ensuite calculer la somme de contrôle côté client et la comparer à la somme de contrôle envoyée par Amazon Glacier dans la réponse.
Pour une tâche de récupération d'archives dont la plage facultative est spécifiée, lorsque vous obtenez la description de la tâche, celle-ci inclut la somme de contrôle de la plage que vous récupérez (SHA256TreeHash). Vous pouvez utiliser cette valeur pour vérifier davantage l'exactitude de l'ensemble de la plage d'octets que vous téléchargerez ultérieurement. Par exemple, si vous lancez une tâche pour extraire une plage d'une archive alignée sur le hachage d'arborescence, que vous téléchargez la sortie en plusieurs parties et que chacune de vos demandes `GetJobOutput` renvoie un total de contrôle, vous pouvez ensuite calculer le total de contrôle de chaque partie téléchargée côté client, puis calculer le hachage d'arborescence. Vous pouvez le comparer à la somme de contrôle renvoyée par Amazon Glacier en réponse à votre demande de travail de description afin de vérifier que l'ensemble de la plage d'octets que vous avez téléchargée est identique à la plage d'octets stockée dans Amazon Glacier.
Pour obtenir un exemple pratique, consultez [Exemple 2 : extraction d'une archive à l'aide de l'API de bas niveau de la sortie AWS SDK pour .NET—Download in Chunks](#creating-vaults-sdk-dotnet-example2).
### Exemple 1 : extraction d'une archive à l'aide de l'API de bas niveau du AWS SDK pour .NET
L'exemple de code C\$1 suivant télécharge une archive à partir du coffre spécifié. Une fois la tâche terminée, l'exemple télécharge la totalité de la sortie dans un seul appel `GetJobOutput`. Pour obtenir un exemple de téléchargement d'une sortie en plusieurs parties, consultez la section [Exemple 2 : extraction d'une archive à l'aide de l'API de bas niveau de la sortie AWS SDK pour .NET—Download in Chunks](#creating-vaults-sdk-dotnet-example2).
L’exemple exécute les tâches suivantes :
+ Configuration d'une rubrique Amazon Simple Notification Service (Amazon SNS).
Amazon Glacier envoie une notification à cette rubrique une fois le travail terminé.
+ Configuration d'une file d'attente Amazon Simple Queue Service (Amazon SQS).
L'exemple attache une politique à la file d'attente pour permettre à la rubrique Amazon SNS de publier des messages.
+ Lancement d'une tâche de téléchargement de l'archive spécifiée.
Dans la demande de travail, l'exemple indique le sujet Amazon SNS afin qu'Amazon Glacier puisse envoyer un message une fois le travail terminé.
+ Recherche périodique d'un message dans la file d'attente Amazon SQS.
Si un message est présent, l'exemple analyse le JSON et vérifie si la tâche s'est correctement déroulée. Si tel est le cas, il télécharge l'archive. L'exemple de code utilise la bibliothèque JSON.NET (consultez le document [JSON.NET](http://json.codeplex.com/)) pour analyser le JSON.
+ Nettoyage par la suppression de la rubrique Amazon SNS et de la file d'attente Amazon SQS qu'il a créées.
```
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);
}
}
}
}
```
### Exemple 2 : extraction d'une archive à l'aide de l'API de bas niveau de la sortie AWS SDK pour .NET—Download in Chunks
L'exemple de code C\$1 suivant extrait une archive d'Amazon Glacier. L'exemple de code télécharge la sortie de la tâche en plusieurs parties en spécifiant la plage d'octets dans un objet `GetJobOutputRequest`.
```
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);
}
}
}
}
```
# Téléchargement d'une archive volumineuse à l'aide du traitement parallèle avec Python
Cette rubrique explique comment télécharger une archive volumineuse depuis Amazon S3 Glacier (S3 Glacier) à l'aide du traitement parallèle avec Python. Cette approche vous permet de télécharger de manière fiable des archives de toutes tailles en les divisant en petits morceaux pouvant être traités indépendamment.
## Présentation de
Le script Python fourni dans cet exemple exécute les tâches suivantes :
1. Configure les AWS ressources nécessaires (rubrique Amazon SNS et files d'attente Amazon SQS) pour les notifications
1. Lance une tâche de récupération d'archives avec Amazon Glacier
1. Surveille une file d'attente Amazon SQS pour détecter les notifications de fin de tâche
1. Divise la grande archive en morceaux faciles à gérer
1. Télécharge des segments en parallèle à l'aide de plusieurs threads de travail
1. Enregistre chaque morceau sur le disque pour un réassemblage ultérieur
## Conditions préalables
Avant de commencer, assurez-vous d'avoir :
+ Python 3.6 ou version ultérieure installé
+ AWS SDK pour Python (Boto3) installé
+ AWS informations d'identification configurées avec les autorisations appropriées pour Amazon Glacier, Amazon SNS et Amazon SQS
+ Espace disque suffisant pour stocker les fragments d'archive téléchargés
## Exemple : téléchargement d'une archive à l'aide du traitement parallèle avec Python
Le script Python suivant montre comment télécharger une archive volumineuse depuis Amazon Glacier à l'aide du traitement parallèle :
```
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)
```
## Utilisation du script
Pour utiliser ce script, procédez comme suit :
1. Remplacez les valeurs d'espace réservé dans le script par vos informations spécifiques :
+ *output\$1file\$1path*: répertoire dans lequel les fichiers partiels seront enregistrés
+ *vault\$1name*: nom de votre coffre-fort S3 Glacier
+ *notify\$1queue\$1name*: nom de la file d'attente de notifications de tâches
+ *chunk\$1download\$1queue\$1name*: nom de la file d'attente de téléchargement des tronçons
+ *sns\$1topic\$1name*: nom de la rubrique SNS
+ *region*: AWS région dans laquelle se trouve votre coffre-fort
+ *archive\$1id*: ID de l'archive à récupérer
1. Exécutez le script :
```
python download_large_archive.py
```
1. Une fois tous les fragments téléchargés, vous pouvez les combiner dans un seul fichier à l'aide d'une commande telle que :
```
cat /path/to/chunks/*.chunk > complete_archive.file
```
## Importantes considérations
Lorsque vous utilisez ce script, tenez compte des points suivants :
+ L'extraction des archives depuis S3 Glacier peut prendre plusieurs heures, selon le niveau de récupération sélectionné.
+ Le script s'exécute indéfiniment, interrogeant continuellement les files d'attente. Vous souhaiterez peut-être ajouter une condition de résiliation en fonction de vos besoins spécifiques.
+ Assurez-vous de disposer de suffisamment d'espace disque pour stocker tous les fragments de votre archive.
+ Si le script est interrompu, vous pouvez le redémarrer `retrieve_archive=False` pour continuer à télécharger des fragments sans lancer une nouvelle tâche de récupération.
+ Ajustez les *workers* paramètres *chunk\$1size* et en fonction de la bande passante de votre réseau et des ressources système.
+ AWS Les frais standard s'appliquent pour les extractions Amazon S3, Amazon SNS et l'utilisation d'Amazon SQS.
# Téléchargement d'une archive à l'aide de l'API REST
**Pour télécharger une archive à l'aide de l'API REST**
Le téléchargement d'une archive est un processus en deux étapes.
1. Lancez une tâche de type `archive-retrieval`. Pour de plus amples informations, veuillez consulter [Lancement d'une tâche (POST jobs)](api-initiate-job-post.md).
1. Une fois la tâche terminée, téléchargez les données de l'archive. Pour de plus amples informations, veuillez consulter [Génération de sortie de tâche (GET output)](api-job-output-get.md).
# Téléchargement d'une archive dans Amazon Glacier à l'aide du AWS CLI
Vous pouvez télécharger des archives dans Amazon Glacier (Amazon Glacier) à l'aide du AWS Command Line Interface (AWS CLI).
**Topics**
+ [(Prérequis) Configuration du AWS CLI](#Creating-Vaults-CLI-Setup)
+ [Exemple : télécharger une archive à l'aide du AWS CLI](#Downloading-Archives-CLI-Implementation)
## (Prérequis) Configuration du AWS CLI
1. Téléchargez et configurez l’interface AWS CLI. Pour obtenir des instructions, consultez les rubriques suivantes dans le *Guide de l’utilisateur de l’interface AWS Command Line Interface * :
[Installation du AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html)
[Configuration du AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)
1. Vérifiez votre AWS CLI configuration en saisissant les commandes suivantes à l'invite de commande. Ces commandes ne fournissent pas directement d'informations d'identification, par conséquent ce sont les informations du profil par défaut qui sont utilisées.
+ Essayez d'utiliser la commande help.
```
aws help
```
+ Pour obtenir la liste des coffres-forts Amazon Glacier sur le compte configuré, utilisez la `list-vaults` commande. *123456789012*Remplacez-le par votre Compte AWS identifiant.
```
aws glacier list-vaults --account-id 123456789012
```
+ Pour voir les données de configuration actuelles pour le AWS CLI, utilisez la `aws configure list` commande.
```
aws configure list
```
## Exemple : télécharger une archive à l'aide du AWS CLI
**Note**
Pour télécharger vos archives, vous devez connaître leur ID. Suivez les étapes 1 à 4 pour récupérer les ID de vos archives. Si vous connaissez déjà les ID des archives que vous souhaitez télécharger, passez à l'étape 5.
1. Utilisez la commande `initiate-job` pour démarrer une tâche d'extraction d'inventaire. Le rapport d'inventaire répertorie les ID de vos archives.
```
aws glacier initiate-job --vault-name awsexamplevault --account-id 111122223333 --job-parameters="{\"Type\":\"inventory-retrieval\"}"
```
Sortie attendue :
```
{
"location": "/111122223333/vaults/awsexamplevault/jobs/*** jobid ***",
"jobId": "*** jobid ***"
}
```
1. Utilisez la commande `describe-job` pour vérifier le statut de la précédente commande de tâche ``.
```
aws glacier describe-job --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid ***
```
Sortie attendue :
```
{
"InventoryRetrievalParameters": {
"Format": "JSON"
},
"VaultARN": "*** vault arn ***",
"Completed": false,
"JobId": "*** jobid ***",
"Action": "InventoryRetrieval",
"CreationDate": "*** job creation date ***",
"StatusCode": "InProgress"
}
```
1. Attendez que la tâche se termine.
Vous devez attendre que la sortie de la tâche soit prête pour pouvoir effectuer le téléchargement. Si vous avez défini une configuration de notification sur le coffre-fort ou si vous avez spécifié une rubrique Amazon Simple Notification Service (Amazon SNS) lorsque vous avez lancé la tâche, Amazon Glacier envoie un message à la rubrique une fois la tâche terminée.
Vous pouvez définir la configuration des notifications pour des événements spécifiques concernant le coffre. Pour de plus amples informations, veuillez consulter [Configuration des notifications de coffre-fort dans Amazon Glacier](configuring-notifications.md). Amazon Glacier envoie un message à la rubrique SNS spécifiée chaque fois que l'événement spécifique se produit.
1. Une fois l'opération terminée, utilisez la commande `get-job-output` pour télécharger le travail d’extraction dans le fichier `output.json`. Ce fichier contient les ID de vos archives.
```
aws glacier get-job-output --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid *** output.json
```
Cette commande produit un fichier avec les champs suivants.
```
{
"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. Utilisez la commande `initiate-job` pour démarrer le processus d'extraction de chaque archive d'un coffre. Vous devez attribuer au paramètre de tâche la valeur `archive-retrieval` comme indiqué ci-dessous.
```
aws glacier initiate-job --vault-name awsexamplevault --account-id 111122223333 --job-parameters="{\"Type\":\"archive-retrieval\",\"ArchiveId\":\"*** archiveId ***\"}"
```
1. Attendez que la tâche `archive-retrieval` se termine. Utilisez la commande `describe-job` pour vérifier le statut de la commande précédente.
```
aws glacier describe-job --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid ***
```
1. Une fois la tâche ci-dessus terminée, utilisez la commande `get-job-output` pour télécharger l'archive.
```
aws glacier get-job-output --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid *** output_file_name
```
# Supprimer une archive dans Amazon Glacier
Vous ne pouvez pas supprimer une archive à l'aide de la console de gestion Amazon Glacier (Amazon Glacier). Pour supprimer une archive, vous devez utiliser la AWS Command Line Interface (CLI) ou écrire du code pour effectuer une demande de suppression en utilisant directement l'API REST ou les bibliothèques wrapper AWS SDK pour Java et .NET. Les rubriques suivantes expliquent comment utiliser les bibliothèques wrapper AWS SDK pour Java et .NET, l'API REST et le AWS CLI.
**Topics**
+ [Suppression d'une archive dans Amazon Glacier à l'aide du AWS SDK pour Java](deleting-an-archive-using-java.md)
+ [Suppression d'une archive dans Amazon Glacier à l'aide du AWS SDK pour .NET](deleting-an-archive-using-dot-net.md)
+ [Suppression d'une archive Amazon Glacier à l'aide de l'API REST](deleting-an-archive-using-rest.md)
+ [Suppression d'une archive dans Amazon Glacier à l'aide du AWS Command Line Interface](deleting-an-archive-using-cli.md)
Vous pouvez supprimer une archive à la fois à partir d'un coffre. Pour supprimer l'archive, vous devez fournir son ID d'archive dans votre demande de suppression. Vous pouvez obtenir l'ID de l'archive en téléchargeant l'inventaire du coffre qui contient l'archive. Pour plus d'informations sur le téléchargement de l'inventaire de coffre, consultez la page [Téléchargement d'un inventaire de coffre-fort dans Amazon Glacier](vault-inventory.md).
Une fois que vous avez supprimé une archive, vous pouvez toujours faire une demande de lancement d'une tâche afin d'extraire l'archive supprimée, mais la tâche d'extraction de l'archive échouera.
Les extractions d'archives en cours pour un ID d'archivage lorsque vous supprimez l'archive peuvent ou non selon les scénarios suivants :
+ Si la tâche de récupération des archives prépare activement les données pour le téléchargement lorsqu'Amazon Glacier reçoit la demande de suppression de l'archive, l'opération de récupération des archives risque d'échouer.
+ Si la tâche de récupération de l'archive a correctement préparé l'archive pour le téléchargement lorsqu'Amazon Glacier reçoit la demande de suppression de l'archive, vous pourrez télécharger le résultat.
Pour plus d'informations sur l'extraction de l'archive, consultez la section [Téléchargement d'une archive dans Amazon Glacier](downloading-an-archive.md).
Cette opération est idempotente. La suppression d'une archive déjà supprimée n'entraîne pas d'erreur.
Une fois que vous avez supprimé une archive, si vous téléchargez immédiatement l'inventaire du coffre, l'archive supprimée peut être incluse dans la liste, car Amazon Glacier prépare l'inventaire du coffre-fort une fois par jour uniquement.
**Note**
Pour la suppression automatique des archives du coffre-fort, consultez [Suppression automatique des archives du coffre-fort dans Amazon S3 Glacier](https://aws.amazon.com/solutions/guidance/automated-deletion-of-vault-archives-in-amazon-s3-glacier/).
# Suppression d'une archive dans Amazon Glacier à l'aide du AWS SDK pour Java
Voici les étapes à suivre pour supprimer une archive à l'aide de l'API de AWS SDK pour Java bas niveau.
1. Créez une instance de la classe `AmazonGlacierClient` (le client).
Vous devez spécifier une AWS région dans laquelle l'archive que vous souhaitez supprimer est stockée. Toutes les opérations que vous effectuez à l'aide de ce client s'appliquent à cette AWS région.
1. Fournissez les informations de demande en créant une instance de la classe `DeleteArchiveRequest`.
Vous devez fournir un ID d'archive, un nom de coffre et votre ID de compte. Si vous n'indiquez pas d'ID de compte, l'ID de compte associé aux informations d'identification que vous avez indiquées pour signer la demande est pris en compte. Pour de plus amples informations, veuillez consulter [Utilisation du AWS SDK pour Java avec Amazon Glacier](using-aws-sdk-for-java.md).
1. Exécutez la méthode `deleteArchive` en fournissant l'objet de demande comme paramètre.
L'extrait de code Java suivant illustre les étapes précédentes.
```
AmazonGlacierClient client;
DeleteArchiveRequest request = new DeleteArchiveRequest()
.withVaultName("*** provide a vault name ***")
.withArchiveId("*** provide an archive ID ***");
client.deleteArchive(request);
```
**Note**
Pour obtenir des informations sur l'API REST sous-jacente, consultez la section [Suppression d'une archive (DELETE archive)](api-archive-delete.md).
## Exemple : suppression d'une archive à l'aide du AWS SDK pour Java
L'exemple de code Java suivant utilise le AWS SDK pour Java pour supprimer une archive. Pour step-by-step obtenir des instructions sur la façon d'exécuter cet exemple, consultez[Exécution d'exemples Java pour Amazon Glacier à l'aide d'Eclipse](using-aws-sdk-for-java.md#setting-up-and-testing-sdk-java). Vous devez mettre à jour le code tel qu'il est présenté avec le nom du coffre et l'ID de l'archive à supprimer.
**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);
}
}
}
```
# Suppression d'une archive dans Amazon Glacier à l'aide du AWS SDK pour .NET
Les niveaux de [haut et de bas niveau APIs](using-aws-sdk.md) fournis par le SDK Amazon pour .NET fournissent une méthode pour supprimer une archive.
**Topics**
+ [Suppression d'une archive à l'aide de l'API de haut niveau du AWS SDK pour .NET](#delete-archive-using-dot-net-high-level)
+ [Supprimer une archive à l'aide de l'API de bas niveau AWS SDK pour .NET](#delete-archive-using-dot-net-low-level)
## Suppression d'une archive à l'aide de l'API de haut niveau du AWS SDK pour .NET
La classe `ArchiveTransferManager` de l'API de haut niveau comporte la méthode `DeleteArchive` qui sert à supprimer une archive.
### Exemple : suppression d'une archive à l'aide de l'API de haut niveau du AWS SDK pour .NET
L'exemple de code C\$1 suivant utilise l'API de haut niveau de AWS SDK pour .NET pour supprimer une archive. Pour step-by-step obtenir des instructions sur la façon d'exécuter cet exemple, reportez-vous à[Exemples de code en cours d'exécution](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet). Vous devez mettre à jour le code tel qu'il est présenté avec l'ID de l'archive à supprimer.
**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();
}
}
}
```
## Supprimer une archive à l'aide de l'API de bas niveau AWS SDK pour .NET
Voici les étapes pour supprimer une archive à l'aide du kit AWS SDK pour .NET :
1. Créez une instance de la classe `AmazonGlacierClient` (le client).
Vous devez spécifier une AWS région dans laquelle l'archive que vous souhaitez supprimer est stockée. Toutes les opérations que vous effectuez à l'aide de ce client s'appliquent à cette AWS région.
1. Fournissez les informations de demande en créant une instance de la classe `DeleteArchiveRequest`.
Vous devez fournir un ID d'archive, un nom de coffre et votre ID de compte. Si vous n'indiquez pas d'ID de compte, l'ID de compte associé aux informations d'identification que vous avez indiquées pour signer la demande est pris en compte. Pour de plus amples informations, veuillez consulter [Utilisation du AWS SDKs avec Amazon Glacier](using-aws-sdk.md).
1. Exécutez la méthode `DeleteArchive` en fournissant l'objet de demande comme paramètre.
### Exemple : suppression d'une archive à l'aide de l'API de bas niveau du AWS SDK pour .NET
L'exemple de code C\$1 suivant illustre les étapes précédentes. L'exemple utilise l'API de bas niveau du AWS SDK pour .NET pour supprimer une archive.
**Note**
Pour obtenir des informations sur l'API REST sous-jacente, consultez la section [Suppression d'une archive (DELETE archive)](api-archive-delete.md).
Pour step-by-step obtenir des instructions sur la façon d'exécuter cet exemple, reportez-vous à[Exemples de code en cours d'exécution](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet). Vous devez mettre à jour le code tel qu'il est présenté avec l'ID de l'archive à supprimer.
**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);
}
}
}
```
# Suppression d'une archive Amazon Glacier à l'aide de l'API REST
Vous pouvez utiliser l'API de suppression d'archive pour supprimer une archive.
+ Pour plus d'informations sur l'API de suppression d'archive, consultez la page [Suppression d'une archive (DELETE archive)](api-archive-delete.md).
+ Pour plus d'informations sur l'utilisation de l'API REST, consultez [Référence d'API pour Amazon Glacier](amazon-glacier-api.md).
# Suppression d'une archive dans Amazon Glacier à l'aide du AWS Command Line Interface
Vous pouvez supprimer des archives dans Amazon Glacier (Amazon Glacier) à l'aide du AWS Command Line Interface (AWS CLI).
**Topics**
+ [(Prérequis) Configuration du AWS CLI](#Creating-Vaults-CLI-Setup)
+ [Exemple : suppression d'une archive à l'aide du AWS CLI](#Deleting-Archives-CLI-Implementation)
## (Prérequis) Configuration du AWS CLI
1. Téléchargez et configurez l’interface AWS CLI. Pour obtenir des instructions, consultez les rubriques suivantes dans le *Guide de l’utilisateur de l’interface AWS Command Line Interface * :
[Installation du AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html)
[Configuration du AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)
1. Vérifiez votre AWS CLI configuration en saisissant les commandes suivantes à l'invite de commande. Ces commandes ne fournissent pas directement d'informations d'identification, par conséquent ce sont les informations du profil par défaut qui sont utilisées.
+ Essayez d'utiliser la commande help.
```
aws help
```
+ Pour obtenir la liste des coffres-forts Amazon Glacier sur le compte configuré, utilisez la `list-vaults` commande. *123456789012*Remplacez-le par votre Compte AWS identifiant.
```
aws glacier list-vaults --account-id 123456789012
```
+ Pour voir les données de configuration actuelles pour le AWS CLI, utilisez la `aws configure list` commande.
```
aws configure list
```
## Exemple : suppression d'une archive à l'aide du AWS CLI
1. Utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-job.html](https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-job.html) pour démarrer une tâche d’extraction d'inventaire.
```
aws glacier initiate-job --vault-name awsexamplevault --account-id 111122223333 --job-parameters="{\"Type\":\"inventory-retrieval\"}"
```
Sortie attendue :
```
{
"location": "/111122223333/vaults/awsexamplevault/jobs/*** jobid ***",
"jobId": "*** jobid ***"
}
```
1. Utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/glacier/describe-job.html](https://docs.aws.amazon.com/cli/latest/reference/glacier/describe-job.html) pour vérifier le statut de la tâche d'extraction précédente.
```
aws glacier describe-job --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid ***
```
Sortie attendue :
```
{
"InventoryRetrievalParameters": {
"Format": "JSON"
},
"VaultARN": "*** vault arn ***",
"Completed": false,
"JobId": "*** jobid ***",
"Action": "InventoryRetrieval",
"CreationDate": "*** job creation date ***",
"StatusCode": "InProgress"
}
```
1. Attendez que la tâche se termine.
Vous devez attendre que la sortie de la tâche soit prête pour pouvoir effectuer le téléchargement. Si vous avez défini une configuration de notification sur le coffre-fort ou si vous avez spécifié une rubrique Amazon Simple Notification Service (Amazon SNS) lorsque vous avez lancé la tâche, Amazon Glacier envoie un message à la rubrique une fois la tâche terminée.
Vous pouvez définir la configuration des notifications pour des événements spécifiques concernant le coffre. Pour de plus amples informations, veuillez consulter [Configuration des notifications de coffre-fort dans Amazon Glacier](configuring-notifications.md). Amazon Glacier envoie un message à la rubrique SNS spécifiée chaque fois que l'événement spécifique se produit.
1. Une fois l'opération terminée, utilisez la commande [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) pour télécharger le travail d’extraction dans le fichier `output.json`.
```
aws glacier get-job-output --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid *** output.json
```
Cette commande produit un fichier avec les champs suivants.
```
{
"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. Utilisez la commande `delete-archive` pour supprimer chaque archive d'un coffre jusqu'à ce qu'il n’en reste aucune.
```
aws glacier delete-archive --vault-name awsexamplevault --account-id 111122223333 --archive-id *** archiveid ***
```