**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.

# Étape 3 : télécharger une archive dans un coffre-fort d'Amazon Glacier
<a name="getting-started-upload-archive"></a>

Dans cette étape, vous allez charger un exemple d'archive sur le coffre que vous avez créé à l'étape précédente (voir [Étape 2 : créer un coffre-fort dans Amazon Glacier](getting-started-create-vault.md)). Selon la plateforme de développement que vous utilisez, choisissez l'un des liens figurant à la fin de cette section.

**Important**  
Toute opération liée aux archives, telle que le chargement, le téléchargement ou la suppression, nécessite d'utiliser l' AWS Command Line Interface (CLI) ou d'écrire du code. Il n'y a aucune prise en charge de la console pour les opérations d'archivage. Par exemple, pour télécharger des données, telles que des photos, des vidéos et d'autres documents, vous devez soit utiliser le AWS CLI code pour effectuer des demandes, soit en utilisant directement l'API REST, soit en utilisant le AWS SDKs.   
Pour installer le AWS CLI, voir [AWS Command Line Interface](https://aws.amazon.com/cli/). Pour plus d'informations sur l'utilisation d'Amazon Glacier avec le AWS CLI, consultez la section [AWS CLI Référence relative à Amazon Glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html). Pour des exemples d'utilisation du AWS CLI pour télécharger des archives sur Amazon Glacier, consultez la section [Utilisation d'Amazon Glacier avec le AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-glacier.html). 

Une archive est un objet, comme une photo, une vidéo ou un document, que vous stockez dans un coffre. Une archive est l’unité de stockage de base dans Amazon Glacier. Vous pouvez charger une archive dans une seule demande. Pour les archives volumineuses, Amazon Glacier fournit une opération d'API de téléchargement en plusieurs parties qui vous permet de télécharger une archive en plusieurs parties. 

Dans cette section de mise en route, vous chargez un exemple d'archive dans une seule demande. Pour cet exercice, vous spécifiez un fichier dont la taille est plus petite. Pour les fichiers plus volumineux, le chargement partitionné est plus approprié. Pour de plus amples informations, veuillez consulter [Chargement d'archives volumineuses en plusieurs parties (chargement partitionné)](uploading-archive-mpu.md).

**Topics**
+ [Téléchargez une archive dans un coffre-fort d'Amazon Glacier à l'aide du AWS SDK pour Java](getting-started-upload-archive-java.md)
+ [Téléchargez une archive dans un coffre-fort d'Amazon Glacier à l'aide du AWS SDK pour .NET](getting-started-upload-archive-dotnet.md)

# Téléchargez une archive dans un coffre-fort d'Amazon Glacier à l'aide du AWS SDK pour Java
<a name="getting-started-upload-archive-java"></a>

L'exemple de code Java suivant utilise l'API de haut niveau du AWS SDK pour Java pour télécharger un exemple d'archive dans le coffre-fort. Dans l'exemple de code, notez les éléments suivants : 
+ L' exemple crée une instance de la classe `AmazonGlacierClient`. 
+ L'exemple utilise l'opération d'API `upload` de la classe `ArchiveTransferManager` issue de l'API de haut niveau d' AWS SDK pour Java. 
+ L'exemple utilise la région USA Ouest (Oregon) (`us-west-2`).

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 d'archive que vous souhaitez charger.

**Note**  
Amazon Glacier conserve un inventaire de toutes les archives de vos coffres-forts. Lorsque vous chargez l'archive dans l'exemple suivant, elle ne s'affiche pas dans un coffre dans la console de gestion tant que l'inventaire du coffre n'a pas été mis à jour. Cette mise à jour a lieu habituellement une fois par jour. 

**SDK pour Java 2.x**  
 Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/glacier#code-examples). 

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.glacier.GlacierClient;
import software.amazon.awssdk.services.glacier.model.UploadArchiveRequest;
import software.amazon.awssdk.services.glacier.model.UploadArchiveResponse;
import software.amazon.awssdk.services.glacier.model.GlacierException;
import java.io.File;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * Before running this Java V2 code example, set up your development
 * environment, including your credentials.
 *
 * For more information, see the following documentation topic:
 *
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class UploadArchive {

    static final int ONE_MB = 1024 * 1024;

    public static void main(String[] args) {
        final String usage = """

                Usage:   <strPath> <vaultName>\s

                Where:
                   strPath - The path to the archive to upload (for example, C:\\AWS\\test.pdf).
                   vaultName - The name of the vault.
                """;

        if (args.length != 2) {
            System.out.println(usage);
            System.exit(1);
        }

        String strPath = args[0];
        String vaultName = args[1];
        File myFile = new File(strPath);
        Path path = Paths.get(strPath);
        GlacierClient glacier = GlacierClient.builder()
                .region(Region.US_EAST_1)
                .build();

        String archiveId = uploadContent(glacier, path, vaultName, myFile);
        System.out.println("The ID of the archived item is " + archiveId);
        glacier.close();
    }

    public static String uploadContent(GlacierClient glacier, Path path, String vaultName, File myFile) {
        // Get an SHA-256 tree hash value.
        String checkVal = computeSHA256(myFile);
        try {
            UploadArchiveRequest uploadRequest = UploadArchiveRequest.builder()
                    .vaultName(vaultName)
                    .checksum(checkVal)
                    .build();

            UploadArchiveResponse res = glacier.uploadArchive(uploadRequest, path);
            return res.archiveId();

        } catch (GlacierException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return "";
    }

    private static String computeSHA256(File inputFile) {
        try {
            byte[] treeHash = computeSHA256TreeHash(inputFile);
            System.out.printf("SHA-256 tree hash = %s\n", toHex(treeHash));
            return toHex(treeHash);

        } catch (IOException ioe) {
            System.err.format("Exception when reading from file %s: %s", inputFile, ioe.getMessage());
            System.exit(-1);

        } catch (NoSuchAlgorithmException nsae) {
            System.err.format("Cannot locate MessageDigest algorithm for SHA-256: %s", nsae.getMessage());
            System.exit(-1);
        }
        return "";
    }

    public static byte[] computeSHA256TreeHash(File inputFile) throws IOException,
            NoSuchAlgorithmException {

        byte[][] chunkSHA256Hashes = getChunkSHA256Hashes(inputFile);
        return computeSHA256TreeHash(chunkSHA256Hashes);
    }

    /**
     * Computes an SHA256 checksum for each 1 MB chunk of the input file. This
     * includes the checksum for the last chunk, even if it's smaller than 1 MB.
     */
    public static byte[][] getChunkSHA256Hashes(File file) throws IOException,
            NoSuchAlgorithmException {

        MessageDigest md = MessageDigest.getInstance("SHA-256");
        long numChunks = file.length() / ONE_MB;
        if (file.length() % ONE_MB > 0) {
            numChunks++;
        }

        if (numChunks == 0) {
            return new byte[][] { md.digest() };
        }

        byte[][] chunkSHA256Hashes = new byte[(int) numChunks][];
        FileInputStream fileStream = null;

        try {
            fileStream = new FileInputStream(file);
            byte[] buff = new byte[ONE_MB];

            int bytesRead;
            int idx = 0;

            while ((bytesRead = fileStream.read(buff, 0, ONE_MB)) > 0) {
                md.reset();
                md.update(buff, 0, bytesRead);
                chunkSHA256Hashes[idx++] = md.digest();
            }

            return chunkSHA256Hashes;

        } finally {
            if (fileStream != null) {
                try {
                    fileStream.close();
                } catch (IOException ioe) {
                    System.err.printf("Exception while closing %s.\n %s", file.getName(),
                            ioe.getMessage());
                }
            }
        }
    }

    /**
     * Computes the SHA-256 tree hash for the passed array of 1 MB chunk
     * checksums.
     */
    public static byte[] computeSHA256TreeHash(byte[][] chunkSHA256Hashes)
            throws NoSuchAlgorithmException {

        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[][] prevLvlHashes = chunkSHA256Hashes;
        while (prevLvlHashes.length > 1) {
            int len = prevLvlHashes.length / 2;
            if (prevLvlHashes.length % 2 != 0) {
                len++;
            }

            byte[][] currLvlHashes = new byte[len][];
            int j = 0;
            for (int i = 0; i < prevLvlHashes.length; i = i + 2, j++) {

                // If there are at least two elements remaining.
                if (prevLvlHashes.length - i > 1) {

                    // Calculate a digest of the concatenated nodes.
                    md.reset();
                    md.update(prevLvlHashes[i]);
                    md.update(prevLvlHashes[i + 1]);
                    currLvlHashes[j] = md.digest();

                } else { // Take care of the remaining odd chunk
                    currLvlHashes[j] = prevLvlHashes[i];
                }
            }

            prevLvlHashes = currLvlHashes;
        }

        return prevLvlHashes[0];
    }

    /**
     * Returns the hexadecimal representation of the input byte array
     */
    public static String toHex(byte[] data) {
        StringBuilder sb = new StringBuilder(data.length * 2);
        for (byte datum : data) {
            String hex = Integer.toHexString(datum & 0xFF);

            if (hex.length() == 1) {
                // Append leading zero.
                sb.append("0");
            }
            sb.append(hex);
        }
        return sb.toString().toLowerCase();
    }
}
```
+  Pour plus de détails sur l'API, reportez-vous [UploadArchive](https://docs.aws.amazon.com/goto/SdkForJavaV2/glacier-2012-06-01/UploadArchive)à la section *Référence des AWS SDK for Java 2.x API*. 

# Téléchargez une archive dans un coffre-fort d'Amazon Glacier à l'aide du AWS SDK pour .NET
<a name="getting-started-upload-archive-dotnet"></a>

L'exemple de code C\$1 suivant utilise l'API de haut niveau du AWS SDK pour .NET pour télécharger un exemple d'archive dans le coffre-fort. Dans l'exemple de code, notez les éléments suivants :

 
+ L'exemple crée une instance de la `ArchiveTransferManager` classe pour le point de terminaison Amazon Glacier Region spécifié.
+ Cet exemple utilise la région USA Ouest (Oregon) (`us-west-2`). 
+ L'exemple utilise l'opération d'API `Upload` de la classe `ArchiveTransferManager` pour charger votre archive. Pour les petites archives, cette opération télécharge l'archive directement sur Amazon Glacier. Pour les archives plus volumineuses, cette opération utilise l'opération d'API de téléchargement en plusieurs parties dans Amazon Glacier pour diviser le téléchargement en plusieurs parties afin de mieux corriger les erreurs, si des erreurs se produisent lors de la diffusion des données vers Amazon Glacier.

Pour step-by-step obtenir des instructions sur la façon d'exécuter l'exemple suivant, 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 tel qu'il est présenté avec le nom de votre coffre et le nom du fichier d'archive à charger.  

**Note**  
Amazon Glacier conserve un inventaire de toutes les archives de vos coffres-forts. Lorsque vous chargez l'archive dans l'exemple suivant, elle n'apparaît pas dans un coffre dans la console de gestion tant que l'inventaire du coffre n'a pas été mis à jour. Cette mise à jour a lieu habituellement une fois par jour. 

**Example — Téléchargement d'une archive à l'aide de l'API de haut niveau du AWS SDK pour .NET**  <a name="GS_ExampleUploadArchiveDotNet"></a>

```
using System;
using Amazon.Glacier;
using Amazon.Glacier.Transfer;
using Amazon.Runtime;

namespace glacier.amazon.com.rproxy.govskope.ca.docsamples
{
    class ArchiveUploadHighLevel_GettingStarted
    {
        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, "getting started archive test", archiveToUpload).ArchiveId;
                Console.WriteLine("Copy and save the following Archive ID for the next step."); 
                Console.WriteLine("Archive ID: {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();
        }
    }
}
```