

 **Esta página es solo para los clientes actuales del servicio Amazon Glacier que utilizan Vaults y la API de REST original de 2012.**

Si busca soluciones de almacenamiento de archivos, se recomienda que utilice las clases de almacenamiento de Amazon Glacier en Amazon S3, S3 Glacier Instant Retrieval, S3 Glacier Flexible Retrieval y S3 Glacier Deep Archive. Para obtener más información sobre estas opciones de almacenamiento, consulte las [clases de almacenamiento de Amazon Glacier](https://aws.amazon.com/s3/storage-classes/glacier/).

Amazon Glacier (servicio original independiente basado en bóveda) ya no acepta nuevos clientes. Amazon Glacier es un servicio independiente propio APIs que almacena datos en almacenes y es distinto de las clases de almacenamiento Amazon S3 y Amazon S3 Glacier. Sus datos actuales permanecerán seguros y accesibles en Amazon Glacier de forma indefinida. No hay que hacer migraciones. Para un almacenamiento de archivos a largo plazo y de bajo costo, AWS recomienda las [clases de almacenamiento Amazon S3 Glacier](https://aws.amazon.com/s3/storage-classes/glacier/), que ofrecen una experiencia de cliente superior con S3 basada en cubos APIs, Región de AWS disponibilidad total, costos más bajos e AWS integración de servicios. Si desea mejorar las capacidades, considere la posibilidad de migrar a las clases de almacenamiento de Amazon S3 Glacier mediante nuestra [AWS Guía de soluciones para la transferencia de datos de los almacenes de Amazon Glacier a las clases de almacenamiento de Amazon S3 Glacier](https://aws.amazon.com/solutions/guidance/data-transfer-from-amazon-s3-glacier-vaults-to-amazon-s3/).

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Uso de archivos en Amazon Glacier
<a name="working-with-archives"></a>

Un archivo es cualquier objeto (por ejemplo, una foto, un vídeo o un documento) que se guarda en un almacén. Es una unidad base de almacenamiento en Amazon Glacier (Amazon Glacier). Cada archivo de almacenamiento tiene un identificador único y una descripción opcional. Al cargar un archivo, Amazon Glacier devuelve una respuesta que incluye un ID de archivo. Este identificador de archivo es único en la AWS región en la que se almacena el archivo. A continuación se muestra un ejemplo de ID de archivo. 

```
TJgHcrOSfAkV6hdPqOATYfp_0ZaxL1pIBOc02iZ0gDPMr2ig-nhwd_PafstsdIf6HSrjHnP-3p6LCJClYytFT_CBhT9CwNxbRaM5MetS3I-GqwxI3Y8QtgbJbhEQPs0mJ3KExample
```

 El archivo IDs tiene una longitud de 138 bytes. Al cargar un archivo, puede proporcionar una descripción opcional. Puede recuperar un archivo mediante su ID, pero no su descripción.

 

**importante**  
Amazon Glacier dispone de una consola de administración. Puede utilizar la consola para crear y eliminar almacenes. Sin embargo, todas las demás interacciones que realice con Amazon Glacier deben hacerse con la AWS Command Line Interface (CLI) o mediante la escritura de código. Por ejemplo, para cargar datos, como fotos, vídeos y otros documentos, debes usar el código AWS CLI o escribir código para realizar las solicitudes, ya sea mediante la API REST directamente o mediante Amazon SDKs. Para obtener más información sobre el uso de Amazon Glacier con AWS CLI, consulte [AWS CLI Reference for Amazon Glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html). Para instalar el AWS CLI, vaya a [AWS Command Line Interface](https://aws.amazon.com/cli/).

**Topics**
+ [

## Operaciones de archivo en Amazon Glacier
](#archive-operations-quick-intro)
+ [

## Mantenimiento de metadatos de archivos en el cliente
](#client-side-key-map-concept)
+ [

# Carga de un archivo en Amazon Glacier
](uploading-an-archive.md)
+ [

# Descarga de un archivo en Amazon Glacier
](downloading-an-archive.md)
+ [

# Eliminación de un archivo en Amazon Glacier
](deleting-an-archive.md)

## Operaciones de archivo en Amazon Glacier
<a name="archive-operations-quick-intro"></a>

Amazon Glacier admite las siguientes operaciones de archivo básicas: cargar, descargar y eliminar. La descarga de un archivo es asíncrona. 

### Carga de un archivo en Amazon Glacier
<a name="uploading-an-archive-quick-intro"></a>

Puede cargar un archivo en una sola operación o cargarlo por partes. La llamada a la API que utiliza para cargar un archivo por partes se conoce como carga multiparte. Para obtener más información, consulte [Carga de un archivo en Amazon Glacier](uploading-an-archive.md).

 

**importante**  
Amazon Glacier dispone de una consola de administración. Puede utilizar la consola para crear y eliminar almacenes. Sin embargo, todas las demás interacciones con Amazon Glacier requieren que utilice la AWS Command Line Interface (CLI) o escriba código. Por ejemplo, para cargar datos, como fotos, vídeos y otros documentos, debes usar el código AWS CLI o escribir código para realizar las solicitudes, ya sea mediante la API REST directamente o mediante Amazon SDKs. Para obtener más información sobre el uso de Amazon Glacier con AWS CLI, consulte [AWS CLI Reference for Amazon Glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html). Para instalar el AWS CLI, vaya a [AWS Command Line Interface](https://aws.amazon.com/cli/).

### Búsqueda de un ID de archivo en Amazon Glacier
<a name="finding-an-archive-id-quick-intro"></a>

Puede obtener el ID de archivo descargando el inventario correspondiente al almacén que contiene el archivo. Para obtener más información acerca de cómo descargar un inventario de almacén, consulte [Descarga de un inventario de almacén en Amazon Glacier](vault-inventory.md).

### Descarga de un archivo en Amazon Glacier
<a name="downloading-an-archive-quick-intro"></a>

La descarga de un archivo es asíncrona. En primer lugar, debe iniciar un trabajo para descargar un archivo específico. Después de recibir la solicitud de trabajo, Amazon Glacier prepara el archivo para descargarlo. Después de que se complete el trabajo, podrá descargar los datos de archivo. Debido a la naturaleza asíncrona del trabajo, puede solicitar a Amazon Glacier que envíe una notificación a un tema de Amazon Simple Notification Service (Amazon SNS) cuando se complete el trabajo. Puede especificar un tema de SNS para cada solicitud de trabajo individual o configurar el almacén para enviar una notificación cuando se producen determinados eventos. Para obtener más información sobre cómo descargar un archivo, consulte [Descarga de un archivo en Amazon Glacier](downloading-an-archive.md).

### Eliminación de un archivo en Amazon Glacier
<a name="deleting-an-archive-quick-intro"></a>

Amazon Glacier ofrece una llamada a la API que puede utilizar para eliminar los archivos de uno en uno. Para obtener más información, consulte [Eliminación de un archivo en Amazon Glacier](deleting-an-archive.md).

### Actualización de un archivo en Amazon Glacier
<a name="updating-an-archive-quick-intro"></a>

Después de cargar un archivo, no puede actualizar su contenido ni su descripción. La única forma en que puede actualizar el contenido del archivo o su descripción es eliminándolo y cargando otro archivo. Tenga en cuenta que cada vez que carga un archivo, Amazon Glacier le devuelve un ID de archivo único.

## Mantenimiento de metadatos de archivos en el cliente
<a name="client-side-key-map-concept"></a>

A excepción de la descripción opcional del archivo, Amazon Glacier no admite metadatos adicionales para los archivos. Cuando carga un archivo, Amazon Glacier asigna un ID, una secuencia de caracteres opaca de la que no se puede deducir nada significativo sobre el archivo. Podría realizar el mantenimiento de los metadatos sobre los archivos en el cliente. Los metadatos pueden incluir el nombre de archivo y otra información significativa sobre él. 

**nota**  
Si es cliente de Amazon Simple Storage Service (Amazon S3), sabe que al cargar un objeto en un bucket puede asignar una clave al objeto, como `MyDocument.txt` o `SomePhoto.jpg`. En Amazon Glacier, no puede asignar una clave de objeto a los archivos que cargue. 

Si mantiene metadatos de archivo del lado del cliente, tenga en cuenta que Amazon Glacier mantiene un inventario de almacén que incluye el archivo IDs y cualquier descripción que haya proporcionado durante la carga del archivo. En ocasiones puede descargar el inventario de almacén para conciliar los problemas en la base de datos en el cliente que mantiene para los metadatos de archivo. No obstante, Amazon Glacier genera un inventario de almacén aproximadamente una vez al día. Al solicitar un inventario de almacén, Amazon Glacier devuelve el último inventario que ha preparado, una instantánea puntual.

# Carga de un archivo en Amazon Glacier
<a name="uploading-an-archive"></a>

Amazon Glacier (Amazon Glacier) dispone de una consola de administración que puede utilizarse para crear y eliminar almacenes. Sin embargo, no puede cargar archivos en Amazon Glacier a través de la consola de administración. Para cargar datos, como fotos, vídeos y otros documentos, debes usar AWS CLI o escribir código para realizar las solicitudes, ya sea mediante la API REST directamente o mediante Amazon SDKs. 

Para obtener información sobre el uso de Amazon Glacier con AWS CLI, consulte [AWS CLI Reference for Amazon Glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html). Para instalar el AWS CLI, vaya a [AWS Command Line Interface](https://aws.amazon.com/cli/). En los siguientes temas sobre la **carga**, se describe cómo cargar archivos en Amazon Glacier mediante Amazon SDK para Java, Amazon SDK para .NET y la API de REST.

**Topics**
+ [

## Opciones para cargar un archivo en Amazon Glacier
](#uploading-an-archive-overview)
+ [

# Carga de un archivo en una única operación
](uploading-archive-single-operation.md)
+ [

# Carga de archivos grandes por partes (carga multiparte)
](uploading-archive-mpu.md)

## Opciones para cargar un archivo en Amazon Glacier
<a name="uploading-an-archive-overview"></a>

En función del tamaño de los datos que suba, Amazon Glacier ofrece las siguientes opciones: 
+ **Carga de archivos en una sola operación:** se pueden cargar archivos con un tamaño comprendido entre 1 byte y hasta 4 GB en una única operación. Sin embargo, recomendamos a nuestros clientes de Amazon Glacier que utilicen la carga multiparte para cargar archivos superiores a 100 MB. Para obtener más información, consulte [Carga de un archivo en una única operación](uploading-archive-single-operation.md).
+ **Carga de archivos por partes:** con la API de carga multiparte, puede cargar archivos grandes, de hasta aproximadamente 40 000 GB (10 000 \$1 4 GB). 

  La llamada a la API de carga multiparte está diseñada para mejorar la experiencia de carga con archivos grandes. Puede cargar archivos por partes. Estas partes se pueden cargar por separado, en cualquier orden y en paralelo. Si se produce un error al cargar una parte, solo tendrá que volver a cargar esa parte, no el archivo completo. Puede usar la carga multiparte con archivos que tengan entre 1 MB y en torno a 40 000 GB de tamaño. Para obtener más información, consulte [Carga de archivos grandes por partes (carga multiparte)](uploading-archive-mpu.md).

**importante**  
El inventario del almacén de Amazon Glacier solo se actualiza una vez al día. Cuando cargue un archivo, no podrá ver inmediatamente que se ha agregado al almacén (en la consola o en la lista de inventarios de almacén descargada) hasta que el inventario del almacén se haya actualizado.

### Uso del AWS Snowball Edge servicio
<a name="using-import-export-service-for-glacier"></a>

AWS Snowball Edge acelera la entrada y salida de grandes cantidades de datos desde dispositivos AWS propiedad de Amazon, sin pasar por Internet. Para obtener más información, consulte la página de detalles de [AWS Snowball Edge](https://aws.amazon.com/snowball). 

Para cargar datos en Amazon Glacier (Amazon Glacier), puede usar uno de los tipos de dispositivo de AWS Snowball Edge para importar datos a Amazon S3 y, después, transferirlos a la clase de almacenamiento de Amazon Glacier para archivarlos con reglas de ciclo de vida. Al transferir objetos de Amazon S3 a la clase de almacenamiento de Amazon Glacier, Amazon S3 utiliza Amazon Glacier internamente para conseguir un almacenamiento duradero a un costo más bajo. Aunque los objetos se almacenan en Amazon Glacier, siguen siendo objetos de Amazon S3 que administra en Amazon S3 y no puede obtener acceso a ellos directamente a través de Amazon Glacier.

Para obtener más información acerca de la configuración del ciclo de vida de Amazon S3 y de la transferencia de objetos a la clase de almacenamiento de Amazon Glacier, consulte [Administración del ciclo de vida de los objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) y [Transición de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/lifecycle-transition-general-considerations.html) en la *Guía del usuario de Amazon Simple Storage Service*.

# Carga de un archivo en una única operación
<a name="uploading-archive-single-operation"></a>

Tal y como se describe en [Carga de un archivo en Amazon Glacier](uploading-an-archive.md), puede cargar archivos más pequeños en una única operación. Sin embargo, recomendamos a nuestros clientes de Amazon Glacier (Amazon Glacier) que utilicen la carga multiparte para cargar archivos superiores a 100 MB. 

**Topics**
+ [

# Carga de un archivo en una sola operación mediante el AWS Command Line Interface
](uploading-an-archive-single-op-using-cli.md)
+ [

# Carga de un archivo en una sola operación mediante el AWS SDK para Java
](uploading-an-archive-single-op-using-java.md)
+ [

# Carga de un archivo en una sola operación mediante Amazon AWS SDK para .NET Glacier
](uploading-an-archive-single-op-using-dotnet.md)
+ [

# Carga de un archivo en una única operación con la API de REST
](uploading-an-archive-single-op-using-rest.md)

# Carga de un archivo en una sola operación mediante el AWS Command Line Interface
<a name="uploading-an-archive-single-op-using-cli"></a>

Puede cargar un archivo en Amazon Glacier (Amazon Glacier) mediante AWS Command Line Interface (AWS CLI).

**Topics**
+ [

## (Requisito previo) Configurar el AWS CLI
](#Creating-Vaults-CLI-Setup)
+ [

## Ejemplo: cargue un archivo mediante el AWS CLI
](#Uploading-Archives-CLI-Implementation)

## (Requisito previo) Configurar el AWS CLI
<a name="Creating-Vaults-CLI-Setup"></a>

1. Descargue y configure la AWS CLI. Para obtener instrucciones, consulte los siguientes temas en la *Guía del usuario de la AWS Command Line Interface *: 

    [Instalación del AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) 

   [Configuración del AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)

1. Compruebe AWS CLI la configuración introduciendo los siguientes comandos en la línea de comandos. Estos comandos no proporcionan las credenciales de forma explícita, por lo que se utilizan las credenciales del perfil predeterminado.
   + Pruebe a usar el comando de ayuda.

     ```
     aws help
     ```
   + Para obtener una lista de los almacenes de Amazon Glacier en la cuenta configurada, use el comando `list-vaults`. *123456789012*Sustitúyala por tu Cuenta de AWS ID.

     ```
     aws glacier list-vaults --account-id 123456789012
     ```
   + Para ver los datos de configuración actuales de AWS CLI, utilice el `aws configure list` comando.

     ```
     aws configure list
     ```

## Ejemplo: cargue un archivo mediante el AWS CLI
<a name="Uploading-Archives-CLI-Implementation"></a>

Para cargar un archivo, debe haber creado un almacén. Para obtener más información acerca de la creación de almacenes, consulte [Creación de un almacén en Amazon Glacier](creating-vaults.md).

1. Use el comando `upload-archive` para agregar un archivo a un almacén existente. En el siguiente ejemplo, reemplace los valores `vault name` y `account ID`. Para el parámetro `body`, especifique una ruta al archivo que quiere cargar.

   ```
   aws glacier upload-archive --vault-name awsexamplevault --account-id 123456789012 --body archive.zip
   ```

1.  Resultado previsto:

   ```
   {
       "archiveId": "kKB7ymWJVpPSwhGP6ycSOAekp9ZYe_--zM_mw6k76ZFGEIWQX-ybtRDvc2VkPSDtfKmQrj0IRQLSGsNuDp-AJVlu2ccmDSyDUmZwKbwbpAdGATGDiB3hHO0bjbGehXTcApVud_wyDw",
       "checksum": "969fb39823836d81f0cc028195fcdbcbbe76cdde932d4646fa7de5f21e18aa67",
       "location": "/123456789012/vaults/awsexamplevault/archives/kKB7ymWJVpPSwhGP6ycSOAekp9ZYe_--zM_mw6k76ZFGEIWQX-ybtRDvc2VkPSDtfKmQrj0IRQLSGsNuDp-AJVlu2ccmDSyDUmZwKbwbpAdGATGDiB3hHO0bjbGehXTcApVud_wyDw"
   }
   ```

   Cuando termine, el comando mostrará el ID del archivo, la suma de comprobación y la ubicación en Amazon Glacier. Para obtener más información sobre el comando upload-archive, consulte [upload-archive](https://docs.aws.amazon.com/cli/latest/reference/glacier/upload-archive.html) en la *Referencia de comandos de la AWS CLI *.

# Carga de un archivo en una sola operación mediante el AWS SDK para Java
<a name="uploading-an-archive-single-op-using-java"></a>

Tanto el [nivel alto como el nivel bajo](using-aws-sdk.md) que APIs proporciona Amazon SDK for Java proporcionan un método para cargar un archivo.

**Topics**
+ [

## Carga de un archivo mediante la API de alto nivel del AWS SDK para Java
](#uploading-an-archive-single-op-high-level-using-java)
+ [

## Carga de un archivo en una sola operación mediante la API de bajo nivel del AWS SDK para Java
](#uploading-an-archive-single-op-low-level-using-java)

## Carga de un archivo mediante la API de alto nivel del AWS SDK para Java
<a name="uploading-an-archive-single-op-high-level-using-java"></a>

La clase `ArchiveTransferManager` de la API de alto nivel le brinda el método `upload`, que le permite cargar un archivo en un almacén.

 

**nota**  
Puede utilizar el método `upload` para cargar archivos grandes o pequeños. En función del tamaño del archivo que se va a cargar, este método determina si la carga se va a efectuar en una sola operación o se va a utilizar una API de carga multiparte para cargar el archivo por partes.

### Ejemplo: cargar un archivo mediante la API de alto nivel del AWS SDK para Java
<a name="upload-archive-high-level-java-example"></a>

En el ejemplo de código Java siguiente, se carga un archivo a un almacén (`examplevault`) de la región Oeste de EE. UU. (Oregón) (`us-west-2`). Para obtener una lista de AWS las regiones y puntos finales compatibles, consulte. [Acceso a Amazon Glacier](amazon-glacier-accessing.md) 

Para step-by-step obtener instrucciones sobre cómo ejecutar este ejemplo, consulte[Ejecución de ejemplos de Java para Amazon Glacier con Eclipse](using-aws-sdk-for-java.md#setting-up-and-testing-sdk-java). Es necesario actualizar el código mostrado con el nombre del almacén donde se va a realizar la carga y el nombre del archivo que se va a cargar.

**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);
        }
    }
}
```

## Carga de un archivo en una sola operación mediante la API de bajo nivel del AWS SDK para Java
<a name="uploading-an-archive-single-op-low-level-using-java"></a>

La API de bajo nivel dispone de métodos para todas las operaciones de archivo. A continuación, se indican los pasos necesarios para cargar un archivo con AWS SDK para Java.

 

1. Cree una instancia de la clase `AmazonGlacierClient` (el cliente). 

   Debe especificar la AWS región en la que desea cargar el archivo. Todas las operaciones que realice con este cliente se aplican a esa AWS región. 

1. Proporcione la información de la solicitud creando una instancia de la clase `UploadArchiveRequest`.

   Además de los datos que desea cargar, debe proporcionar una suma de comprobación (un hash en árbol SHA-256) de la carga, el nombre del almacén, la longitud del contenido de los datos y el ID de la cuenta. 

   Si no proporciona el ID de la cuenta, se presumirá que se trata del ID de cuenta asociado a las credenciales proporcionadas para firmar la solicitud. Para obtener más información, consulte [Uso del AWS SDK para Java con Amazon Glacier](using-aws-sdk-for-java.md). 

1. Ejecute el método `uploadArchive` proporcionando el objeto de solicitud como parámetro. 

   En respuesta, Amazon Glacier (Amazon Glacier) devuelve el ID del archivo que acaba de cargarse. 

En el siguiente fragmento de código Java, se ilustran los pasos anteriores. 

```
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());
```

### Ejemplo: cargar un archivo en una sola operación mediante la API de bajo nivel del AWS SDK para Java
<a name="uploding-single-archive-using-java-example"></a>

El siguiente ejemplo de código Java utiliza el AWS SDK para Java para cargar un archivo en un almacén ()`examplevault`. Para step-by-step obtener instrucciones sobre cómo ejecutar este ejemplo, consulte[Ejecución de ejemplos de Java para Amazon Glacier con Eclipse](using-aws-sdk-for-java.md#setting-up-and-testing-sdk-java). Es necesario actualizar el código mostrado con el nombre del almacén donde se va a realizar la carga y el nombre del archivo que se va a cargar.

```
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);
        }
    }
}
```

# Carga de un archivo en una sola operación mediante Amazon AWS SDK para .NET Glacier
<a name="uploading-an-archive-single-op-using-dotnet"></a>

Tanto el [nivel alto como el nivel bajo](using-aws-sdk.md) que APIs proporciona Amazon SDK para .NET proporcionan un método para cargar un archivo en una sola operación.

**Topics**
+ [

## Carga de un archivo mediante la API de alto nivel del AWS SDK para .NET
](#uploading-an-archive-single-op-highlevel-using-dotnet)
+ [

## Carga de un archivo en una sola operación mediante la API de bajo nivel del AWS SDK para .NET
](#uploading-an-archive-single-op-lowlevel-using-dotnet)

## Carga de un archivo mediante la API de alto nivel del AWS SDK para .NET
<a name="uploading-an-archive-single-op-highlevel-using-dotnet"></a>

La clase `ArchiveTransferManager` de la API de alto nivel le brinda el método `Upload`, que le permite cargar un archivo en un almacén. 

**nota**  
Puede utilizar el método `Upload` para cargar archivos grandes o pequeños. En función del tamaño del archivo que se va a cargar, este método determina si la carga se va a efectuar en una sola operación o se va a utilizar una API de carga multiparte para cargar el archivo por partes.

### Ejemplo: cargar un archivo mediante la API de alto nivel del AWS SDK para .NET
<a name="upload-archive-highlevel-any-size-dotnet"></a>

En el ejemplo de código C\$1 siguiente, se carga un archivo a un almacén (`examplevault`) de la región Oeste de EE. UU. (Oregón). 

Para step-by-step obtener instrucciones sobre cómo ejecutar este ejemplo, consulte[Ejecución de los ejemplos de código](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet). Debe actualizar el código mostrado con el nombre del archivo que quiera cargar.

**Example**  

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

namespace glacier.amazon.com.rproxy.govskope.ca.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();
    }
  }
}
```

## Carga de un archivo en una sola operación mediante la API de bajo nivel del AWS SDK para .NET
<a name="uploading-an-archive-single-op-lowlevel-using-dotnet"></a>

La API de bajo nivel dispone de métodos para todas las operaciones de archivo. A continuación, se indican los pasos necesarios para cargar un archivo con AWS SDK para .NET.

 

1. Cree una instancia de la clase `AmazonGlacierClient` (el cliente). 

   Debe especificar la AWS región en la que desea cargar el archivo. Todas las operaciones que realice con este cliente se aplican a esa AWS región. 

1. Proporcione la información de la solicitud creando una instancia de la clase `UploadArchiveRequest`.

   Además de los datos que desea cargar, debe proporcionar una suma de comprobación (un hash en árbol SHA-256) de la carga, el nombre del almacén y el ID de la cuenta. 

   Si no proporciona el ID de la cuenta, se presumirá que se trata del ID de cuenta asociado a las credenciales proporcionadas para firmar la solicitud. Para obtener más información, consulte [Uso de AWS SDK para .NET con Amazon Glacier](using-aws-sdk-for-dot-net.md). 

1. Ejecute el método `UploadArchive` proporcionando el objeto de solicitud como parámetro. 

   En respuesta, Amazon Glacier devuelve el ID del archivo que acaba de cargarse. 

### Ejemplo: cargar un archivo en una sola operación mediante la API de bajo nivel del AWS SDK para .NET
<a name="upload-archive-single-op-lowlevel-dotnet"></a>

En el siguiente ejemplo de código C\$1, se ilustran los pasos anteriores. En el ejemplo se utiliza AWS SDK para .NET para cargar un archivo en una bóveda ()`examplevault`. 

**nota**  
Para obtener información sobre la API de REST subyacente para cargar un archivo en una única solicitud, consulte [Carga de archivo (POST archivo)](api-archive-post.md).

Para step-by-step obtener instrucciones sobre cómo ejecutar este ejemplo, consulte[Ejecución de los ejemplos de código](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet). Debe actualizar el código mostrado con el nombre del archivo que quiera cargar.

**Example**  

```
using System;
using System.IO;
using Amazon.Glacier;
using Amazon.Glacier.Model;
using Amazon.Runtime;

namespace glacier.amazon.com.rproxy.govskope.ca.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;
      }
    }
  }
}
```

# Carga de un archivo en una única operación con la API de REST
<a name="uploading-an-archive-single-op-using-rest"></a>

Puede utilizar la llamada a la API Upload Archive para cargar un archivo en una única operación. Para obtener más información, consulte [Carga de archivo (POST archivo)](api-archive-post.md).

# Carga de archivos grandes por partes (carga multiparte)
<a name="uploading-archive-mpu"></a>

**Topics**
+ [

## Proceso Multipart Upload
](#MPUprocess)
+ [

## Información relevante
](#qfacts)
+ [

# Carga de archivos de gran tamaño mediante el AWS CLI
](uploading-an-archive-mpu-using-cli.md)
+ [

# Carga de archivos grandes por partes con Amazon SDK for Java
](uploading-an-archive-mpu-using-java.md)
+ [

# Carga de archivos de gran tamaño mediante el AWS SDK para .NET
](uploading-an-archive-mpu-using-dotnet.md)
+ [

# Carga de archivos grandes por partes con la API de REST
](uploading-an-archive-mpu-using-rest.md)

## Proceso Multipart Upload
<a name="MPUprocess"></a>

Tal y como se describe en [Carga de un archivo en Amazon Glacier](uploading-an-archive.md), recomendamos a nuestros clientes de Amazon Glacier (Amazon Glacier) que utilicen la carga multiparte para cargar archivos superiores a 100 mebibytes (MiB). 

1. **Initiate Multipart Upload** 

   Cuando envía una solicitud para iniciar una carga multiparte, Amazon Glacier devuelve un ID de carga multiparte, que es un identificador único de esta. Cualquier operación de carga multiparte que se ejecute posteriormente necesitará este ID, Este ID se mantendrá en vigor al menos 24 horas después de que Amazon Glacier haya finalizado el trabajo. 

   En la solicitud para iniciar una carga multiparte, especifique el tamaño de la parte en número de bytes. Todas las partes que se carguen, salvo la última, deben tener este tamaño.
**nota**  
Cuando se utiliza las cargas multiparte, no es necesario conocer el tamaño total del archivo. Esto significa que puede utilizar cargas multiparte en los casos en que no sepa el tamaño del archivo cuando comience a cargar el archivo. Cuando inicie una carga multiparte, lo único que debe decidir es el tamaño de la parte.

   En la solicitud Initiate Multipart Upload, también puede proporcionar una descripción opcional del archivo. 

1. **Carga de las partes**

   En cada solicitud de carga, debe incluir el ID de la carga multiparte que obtuvo en el paso 1. En la solicitud, también debe especificar el intervalo de contenido en bytes, lo que identificará la posición de la parte en el archivo final. Amazon Glacier utilizará la información del intervalo de contenido más adelante para montar el archivo en el orden correcto. Como usted proporciona el intervalo de contenido con cada parte que carga, esto determina la posición de la parte en el conjunto final del archivo y, por tanto, puede cargar las partes en cualquier orden. También puede cargar las partes en paralelo. Si carga una parte nueva con el mismo intervalo de contenido que una parte que cargó previamente, la parte existente se sobrescribirá. 

1. **Finalización (o detención) de una carga multiparte**

   Después de cargar todas las partes del archivo, puede utilizar la operación de finalización. Una vez más, debe especificar el ID de carga en la solicitud. Amazon Glacier crea un archivo mediante la concatenación de las partes en orden ascendente en función del intervalo de contenido proporcionado. La respuesta de Amazon Glacier a una solicitud Complete Multipart Upload incluye el ID del archivo que se acaba de crear. Si ha proporcionado una descripción opcional del archivo en la solicitud Initiate Multipart Upload, Amazon Glacier asociará esta descripción al archivo montado. Una vez que una carga multiparte se ha realizado correctamente, no se puede consultar su ID. Esto significa que no puede obtener acceso a las partes asociadas con el ID de carga multiparte.

   Si detiene una carga multiparte, no puede cargar ninguna otra parte con el ID de esa carga. Todo el almacenamiento utilizado por las partes asociadas a la carga multiparte detenida quedará libre. Si la carga de alguna de las partes estuviera en curso, todavía se puede ejecutar correctamente o producir un error una vez detenida.

### Otras operaciones de carga multiparte
<a name="additional-mpu-operations"></a>

Amazon Glacier (Amazon Glacier) ofrece las siguientes llamadas adicionales a la API de carga multiparte.

 
+ **List Parts**: con esta operación, puede enumerar las partes de una determinada carga multiparte. Esta operación devuelve información sobre las partes cargadas en una carga multiparte. En cada solicitud de enumeración de las partes, Amazon Glacier devuelve información de hasta 1000 partes. Si hay más partes para mostrar en la carga multiparte, el resultado se pagina y se devuelve un marcador en la respuesta que señala el punto en el que continúa la lista. Para recuperar las partes siguientes, debe enviar otras solicitudes. Tenga en cuenta que la lista de partes que se devuelve no incluye las partes con carga incompleta.
+ **List Multipart Uploads**: con esta operación, puede obtener una lista de las cargas multiparte en curso. Una carga multiparte en curso es una carga iniciada, pero que aún no se ha completado ni parado. En cada solicitud List Multipart Uploads, Amazon Glacier devuelve un máximo de 1000 cargas multiparte. Si hay más cargas multiparte para mostrar, el resultado se pagina y se devuelve un marcador en la respuesta que señala el punto en el que continúa la lista. Para recuperar las cargas multiparte restantes, debe enviar otras solicitudes.

## Información relevante
<a name="qfacts"></a>

En la siguiente tabla se proporcionan las especificaciones principales de la carga multiparte.


| Elemento | Especificación | 
| --- | --- | 
| Tamaño máximo del archivo | 10 000 x 4 gibibytes (GiB)  | 
| Cantidad máxima de partes por cada carga | 10 000 | 
| Tamaño de parte | 1 MiB a 4 GiB, la última parte puede ser <1 MiB. El tamaño debe especificarse en bytes. El tamaño de la parte debe ser de un mebibyte (1024 kibibytes [KiB]) multiplicado por una potencia de 2. Por ejemplo, `1048576` (1 MiB), `2097152` (2 MiB), `4194304` (4 MiB), `8388608` (8 MiB).   | 
| Cantidad máxima de partes devueltas para una solicitud de lista de partes | 1 000  | 
| Cantidad máxima de cargas multipartes devueltas en una solicitud de lista de cargas multipartes | 1 000  | 

# Carga de archivos de gran tamaño mediante el AWS CLI
<a name="uploading-an-archive-mpu-using-cli"></a>

Puede cargar un archivo en Amazon Glacier (Amazon Glacier) mediante AWS Command Line Interface (AWS CLI). Para mejorar la experiencia de carga de archivos más grandes, Amazon Glacier ofrece varias operaciones de API para admitir las cargas multiparte. Al usar estas operaciones de API, puede cargar los archivos por partes. Estas partes se pueden cargar por separado, en cualquier orden y en paralelo. Si se produce un error al cargar una parte, solo tendrá que volver a cargar esa parte, no el archivo completo. Puede usar la carga multiparte con archivos que tengan un tamaño entre 1 byte hasta 40 000 gibibytes (GiB) aproximadamente. 

Para obtener más información acerca de las cargas multiparte de Amazon Glacier, consulte [Carga de archivos grandes por partes (carga multiparte)](uploading-archive-mpu.md).

**Topics**
+ [

## (Requisito previo) Configurar el AWS CLI
](#Creating-Vaults-CLI-Setup)
+ [

## (Requisito previo) Instalación de Python
](#Uploading-Archives-mpu-CLI-Install-Python)
+ [

## (Requisito previo) Creación de un almacén de Amazon Glacier
](#Uploading-Archives-mpu-CLI-Create-Vault)
+ [

## Ejemplo: cargar archivos grandes en partes mediante el AWS CLI
](#Uploading-Archives-mpu-CLI-Implementation)

## (Requisito previo) Configurar el AWS CLI
<a name="Creating-Vaults-CLI-Setup"></a>

1. Descargue y configure la AWS CLI. Para obtener instrucciones, consulte los siguientes temas en la *Guía del usuario de la AWS Command Line Interface *: 

    [Instalación del AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) 

   [Configuración del AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)

1. Compruebe AWS CLI la configuración introduciendo los siguientes comandos en la línea de comandos. Estos comandos no proporcionan las credenciales de forma explícita, por lo que se utilizan las credenciales del perfil predeterminado.
   + Pruebe a usar el comando de ayuda.

     ```
     aws help
     ```
   + Para obtener una lista de los almacenes de Amazon Glacier en la cuenta configurada, use el comando `list-vaults`. *123456789012*Sustitúyala por tu Cuenta de AWS ID.

     ```
     aws glacier list-vaults --account-id 123456789012
     ```
   + Para ver los datos de configuración actuales de AWS CLI, utilice el `aws configure list` comando.

     ```
     aws configure list
     ```

## (Requisito previo) Instalación de Python
<a name="Uploading-Archives-mpu-CLI-Install-Python"></a>

Para completar una carga multiparte, debe calcular el hash de SHA256 árbol del archivo que va a cargar. Hacerlo no es lo mismo que calcular el hash de SHA256 árbol del archivo que quieres subir. Para calcular el hash de SHA256 árbol del archivo que estás cargando, puedes usar Java C\$1 (con.NET) o. Python En este ejemplo, se usará Python. Para obtener instrucciones sobre cómo usar Java o C\$1, consulte [Cálculo de sumas de comprobación](checksum-calculations.md). 

Para obtener más información sobre la instalación de Python, consulte [Instalar o actualizar Python](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html#installation) en la *guía para desarrolladores de Boto3*.

## (Requisito previo) Creación de un almacén de Amazon Glacier
<a name="Uploading-Archives-mpu-CLI-Create-Vault"></a>

Para usar el siguiente ejemplo, debe haber creado al menos un almacén de Amazon Glacier. Para obtener más información acerca de la creación de almacenes, consulte [Creación de un almacén en Amazon Glacier](creating-vaults.md).

## Ejemplo: cargar archivos grandes en partes mediante el AWS CLI
<a name="Uploading-Archives-mpu-CLI-Implementation"></a>

En este ejemplo, creará un archivo y utilizará operaciones de la API de carga multiparte para cargarlo, por partes, en Amazon Glacier.
**importante**  
Antes de comenzar con este procedimiento, asegúrese de haber realizado todos los pasos que sean requisitos previos. Para cargar un archivo, debe crear un almacén, AWS CLI configurarlo y estar preparado para usar Java C\$1 o Python calcular un hash de SHA256 árbol.

En el siguiente procedimiento se utilizan los `complete-multipart-upload` AWS CLI comandos `initiate-multipart-upload``upload-multipart-part`, y. 

Para obtener más detallada sobre cada uno de estos comandos, consulte [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) y [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) en la *Referencia de los comandos de la AWS CLI *.

1. Utilice el comando [https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-multipart-upload.html](https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-multipart-upload.html) para crear un recurso de carga multiparte. En la solicitud, especifique el tamaño de la parte en número de bytes. Todas las partes que se carguen, salvo la última, tendrán este tamaño. Al iniciar una carga, no es necesario saber el tamaño total del archivo. Sin embargo, necesitará el tamaño total (en bytes) de cada una de las partes al completar la carga en el paso final.

   En el siguiente comando, reemplace los valores de los parámetros `--vault-name` y `--account-ID` por su información propia. Este comando especifica que cargará un archivo con un tamaño de parte de 1 mebibyte (MiB) (1024 x 1024 bytes) por archivo. Sustituya el valor del parámetro `--part-size` si es necesario. 

   ```
   aws glacier initiate-multipart-upload --vault-name awsexamplevault --part-size 1048576 --account-id 123456789012
   ```

   Resultado previsto:

   ```
   {
   "location": "/123456789012/vaults/awsexamplevault/multipart-uploads/uploadId",
   "uploadId": "uploadId"
   }
   ```

   Cuando termine, el comando mostrará el ID de carga y la ubicación del recurso de carga multiparte en Amazon Glacier. Este ID de carga se usará en los pasos posteriores.

1. Para este ejemplo, puede usar los siguientes comandos para crear un archivo de 4,4 MiB, dividirlo en fragmentos de 1 MiB y cargar cada uno de los fragmentos. Para cargar sus propios archivos, puede seguir un procedimiento similar: dividir los datos en fragmentos y cargar cada una de las partes. 

   

**Linux o macOS**  
El siguiente comando crea un archivo de 4,4 MiB denominado `file_to_upload` en Linux o macOS.

   ```
   mkfile -n 9000b file_to_upload
   ```

**Windows**  
El siguiente comando crea un archivo de 4,4 MiB denominado `file_to_upload` en Windows.

   ```
   fsutil file createnew file_to_upload 4608000
   ```

1. A continuación, dividirá este archivo en fragmentos de 1 MiB. 

   ```
   split -b 1048576 file_to_upload chunk
   ```

   Ahora tiene los cinco fragmentos siguientes. Los cuatro primeros son de 1 MiB y el último es de aproximadamente 400 kibibytes (KiB). 

   ```
   chunkaa
   chunkab
   chunkac
   chunkad
   chunkae
   ```

1. Use el comando [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) para cargar una parte de un archivo. Las partes de archivo se pueden cargar en cualquier orden. También puede cargarlas en paralelo. En una carga multiparte, se pueden cargar hasta 10 000 partes.

   En el siguiente comando, reemplace los valores de los parámetros `--vault-name`, `--account-ID` y `--upload-id`. El ID de carga debe coincidir con el ID proporcionado como salida del comando `initiate-multipart-upload`. El parámetro `--range` especifica que cargará una parte con un tamaño de 1 MiB (1024 x 1024 bytes). Este tamaño debe coincidir con el especificado en el comando `initiate-multipart-upload`. Ajuste este valor de tamaño si es necesario. El parámetro `--body` especifica el nombre de la parte que está cargando.

   ```
   aws glacier upload-multipart-part --body chunkaa --range='bytes 0-1048575/*' --vault-name awsexamplevault --account-id 123456789012 --upload-id upload_ID
   ```

   Si se ejecuta correctamente, el comando generará un resultado que contiene la suma de comprobación de la parte cargada.

1. Vuelva a ejecutar el comando `upload-multipart-part` para cargar las partes restantes de la carga multiparte. Actualice los valores de los parámetros `--range` y `–-body` de cada comando para que coincidan con la parte que está cargando. 

   ```
   aws glacier upload-multipart-part --body chunkab --range='bytes 1048576-2097151/*' --vault-name awsexamplevault --account-id 123456789012 --upload-id upload_ID
   ```

   ```
   aws glacier upload-multipart-part --body chunkac --range='bytes 2097152-3145727/*' --vault-name awsexamplevault --account-id 123456789012 --upload-id upload_ID
   ```

   ```
   aws glacier upload-multipart-part --body chunkad --range='bytes 3145728-4194303/*' --vault-name awsexamplevault --account-id 123456789012 --upload-id upload_ID
   ```

   ```
   aws glacier upload-multipart-part --body chunkae --range='bytes 4194304-4607999/*' --vault-name awsexamplevault --account-id 123456789012 --upload-id upload_ID
   ```
**nota**  
El valor del parámetro `--range` del comando final es más pequeño porque la parte final de nuestra carga es inferior a 1 MiB. Si se ejecuta correctamente, cada comando generará un resultado que contiene la suma de comprobación de cada parte cargada.

1. A continuación, se ensamblará el archivo y se finalizará la carga. Debe incluir el tamaño total y el hash de SHA256 árbol del archivo.

   Para calcular el hash de SHA256 árbol del archivo, puede usar Java C\$1 oPython. En este ejemplo, se usará Python. Para obtener instrucciones sobre cómo usar Java o C\$1, consulte [Cálculo de sumas de comprobación](checksum-calculations.md).

   Cree el archivo `checksum.py` de Python e inserte el código siguiente. Si es necesario, sustituya el nombre del archivo original.

   ```
   from botocore.utils import calculate_tree_hash
   					
   checksum = calculate_tree_hash(open('file_to_upload', 'rb'))
   print(checksum)
   ```

1. Ejecute `checksum.py` para calcular el hash del SHA256 árbol. Es posible que el hash siguiente no coincida con la salida.

   ```
   $ python3 checksum.py
   $ 3d760edb291bfc9d90d35809243de092aea4c47b308290ad12d084f69988ae0c
   ```

1. Use el comando [https://docs.aws.amazon.com/cli/latest/reference/glacier/complete-multipart-upload.html](https://docs.aws.amazon.com/cli/latest/reference/glacier/complete-multipart-upload.html) para finalizar la carga del archivo. Sustituya los valores de los parámetros `--vault-name`, `--account-ID`, `--upload-ID` y `--checksum`. El valor del parámetro `--archive` especifica el tamaño total del archivo en bytes. Este valor debe ser la suma de todos los tamaños de las partes individuales que ha cargado. Sustituya este valor si es necesario. 

   ```
   aws glacier complete-multipart-upload --archive-size 4608000 --vault-name awsexamplevault --account-id 123456789012 --upload-id upload_ID --checksum checksum
   ```

   Al finalizar, el comando mostrará el ID, la suma de comprobación y la ubicación del archivo en Amazon Glacier. 

# Carga de archivos grandes por partes con Amazon SDK for Java
<a name="uploading-an-archive-mpu-using-java"></a>

Tanto el [nivel alto como el nivel bajo](using-aws-sdk.md) que APIs proporciona Amazon SDK for Java proporcionan un método para cargar un archivo grande (consulte[Carga de un archivo en Amazon Glacier](uploading-an-archive.md)). 

 
+ La API de alto nivel cuenta con un método que le permite cargar archivos de cualquier tamaño. En función del archivo que se vaya a cargar, el método lo carga en una sola operación o usa la compatibilidad de Amazon Glacier (Amazon Glacier) con la carga multiparte para cargar el archivo por partes.
+ La API de bajo nivel se mapea estrechamente a la implementación de REST subyacente. Por lo tanto, proporciona un método para cargar archivos más pequeños en una operación y un grupo de métodos que admiten carga multiparte para archivos más grandes. En esta sección se explica cómo cargar archivos grandes por partes con la API de bajo nivel.

Para obtener más información sobre el nivel alto y el nivel bajo APIs, consulte. [Uso del AWS SDK para Java con Amazon Glacier](using-aws-sdk-for-java.md)

**Topics**
+ [

## Carga de archivos grandes en partes mediante la API de alto nivel del AWS SDK para Java
](#uploading-an-archive-in-parts-highlevel-using-java)
+ [

## Cargue archivos grandes en partes utilizando la API de bajo nivel del AWS SDK para Java
](#uploading-an-archive-mpu-using-java-lowlevel)

## Carga de archivos grandes en partes mediante la API de alto nivel del AWS SDK para Java
<a name="uploading-an-archive-in-parts-highlevel-using-java"></a>

Utilice los mismos métodos de la API de alto nivel para cargar archivos pequeños o grandes. En función del tamaño de archivo, los métodos de la API de alto nivel deciden si se carga el archivo en una sola operación o se utiliza la API de carga multiparte que proporciona Amazon Glacier. Para obtener más información, consulte [Carga de un archivo mediante la API de alto nivel del AWS SDK para Java](uploading-an-archive-single-op-using-java.md#uploading-an-archive-single-op-high-level-using-java).

## Cargue archivos grandes en partes utilizando la API de bajo nivel del AWS SDK para Java
<a name="uploading-an-archive-mpu-using-java-lowlevel"></a>

Para tener un control más detallado de la carga, puede utilizar la API de bajo nivel, donde puede configurar la solicitud y procesar la respuesta. A continuación, se indican los pasos necesarios para cargar archivos grandes por partes con AWS SDK para Java.

 

1. Cree una instancia de la clase `AmazonGlacierClient` (el cliente). 

   Debe especificar una AWS región en la que desee guardar el archivo. Todas las operaciones que realice con este cliente se aplican a esa AWS región. 

1. Inicie una carga multiparte llamando al método `initiateMultipartUpload`.

   Tiene que proporcionar el nombre del almacén en el que quiere cargar el archivo, el tamaño que desea usar para cargar cada parte de archivo y una descripción opcional. Puede facilitar esta información creando una instancia de la clase `InitiateMultipartUploadRequest`. En respuesta, Amazon Glacier devuelve un ID de carga.

1. Cargue las partes llamando al método `uploadMultipartPart`. 

   Por cada parte que cargue, debe indicar el nombre de almacén, el rango de bytes en el archivo montado final que se cargarán en esta parte, la suma de comprobación de los datos de parte y el ID de carga. 

1. Complete la carga multiparte llamando al método `completeMultipartUpload`.

   Debe proporcionar el ID de carga, la suma de comprobación de todo el archivo, el tamaño de archivo (tamaño combinado de todas las partes que ha cargado) y el nombre de almacén. Amazon Glacier construye el archivo a partir de las partes cargadas y devuelve un ID de archivo.

### Ejemplo: carga de un archivo grande en una pieza mediante el AWS SDK para Java
<a name="upload-archive-mpu-java-example"></a>

El siguiente ejemplo de código Java utiliza el AWS SDK para Java para cargar un archivo en un almacén (`examplevault`). Para step-by-step obtener instrucciones sobre cómo ejecutar este ejemplo, consulte[Ejecución de ejemplos de Java para Amazon Glacier con Eclipse](using-aws-sdk-for-java.md#setting-up-and-testing-sdk-java). Debe actualizar el código mostrado con el nombre del archivo que quiera cargar.

 

**nota**  
Este ejemplo es válido para tamaños parte de 1 MB a 1 GB. Sin embargo, Amazon Glacier admite tamaños de partes de hasta 4 GB. 

**Example**  

```
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;

import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.glacier.AmazonGlacierClient;
import com.amazonaws.services.glacier.TreeHashGenerator;
import com.amazonaws.services.glacier.model.CompleteMultipartUploadRequest;
import com.amazonaws.services.glacier.model.CompleteMultipartUploadResult;
import com.amazonaws.services.glacier.model.InitiateMultipartUploadRequest;
import com.amazonaws.services.glacier.model.InitiateMultipartUploadResult;
import com.amazonaws.services.glacier.model.UploadMultipartPartRequest;
import com.amazonaws.services.glacier.model.UploadMultipartPartResult;
import com.amazonaws.util.BinaryUtils;

public class ArchiveMPU {

    public static String vaultName = "examplevault";
    // This example works for part sizes up to 1 GB.
    public static String partSize = "1048576"; // 1 MB.
    public static String archiveFilePath = "*** provide archive file path ***";
    public static AmazonGlacierClient client;
    
    public static void main(String[] args) throws IOException {

    	ProfileCredentialsProvider credentials = new ProfileCredentialsProvider();

        client = new AmazonGlacierClient(credentials);
        client.setEndpoint("https://glacier.us-west-2.amazonaws.com/");

        try {
            System.out.println("Uploading an archive.");
            String uploadId = initiateMultipartUpload();
            String checksum = uploadParts(uploadId);
            String archiveId = CompleteMultiPartUpload(uploadId, checksum);
            System.out.println("Completed an archive. ArchiveId: " + archiveId);
            
        } catch (Exception e) {
            System.err.println(e);
        }

    }
    
    private static String initiateMultipartUpload() {
        // Initiate
        InitiateMultipartUploadRequest request = new InitiateMultipartUploadRequest()
            .withVaultName(vaultName)
            .withArchiveDescription("my archive " + (new Date()))
            .withPartSize(partSize);            
        
        InitiateMultipartUploadResult result = client.initiateMultipartUpload(request);
        
        System.out.println("ArchiveID: " + result.getUploadId());
        return result.getUploadId();
    }

    private static String uploadParts(String uploadId) throws AmazonServiceException, NoSuchAlgorithmException, AmazonClientException, IOException {

        int filePosition = 0;
        long currentPosition = 0;
        byte[] buffer = new byte[Integer.valueOf(partSize)];
        List<byte[]> binaryChecksums = new LinkedList<byte[]>();
        
        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();
    }
}
```

# Carga de archivos de gran tamaño mediante el AWS SDK para .NET
<a name="uploading-an-archive-mpu-using-dotnet"></a>

Tanto el [nivel alto como el nivel bajo](using-aws-sdk.md) que APIs proporciona Amazon SDK para .NET proporcionan un método para cargar archivos grandes en partes (consulte[Carga de un archivo en Amazon Glacier](uploading-an-archive.md)). 

 
+ La API de alto nivel cuenta con un método que le permite cargar archivos de cualquier tamaño. En función del archivo que se vaya a cargar, el método lo carga en una sola operación o usa la compatibilidad de Amazon Glacier (Amazon Glacier) con la carga multiparte para cargar el archivo por partes.
+ La API de bajo nivel se mapea estrechamente a la implementación de REST subyacente. Por lo tanto, proporciona un método para cargar archivos más pequeños en una operación y un grupo de métodos que admiten carga multiparte para archivos más grandes. En esta sección se explica cómo cargar archivos grandes por partes con la API de bajo nivel.

Para obtener más información sobre el nivel alto y el nivel bajo APIs, consulte. [Uso de AWS SDK para .NET con Amazon Glacier](using-aws-sdk-for-dot-net.md)

**Topics**
+ [

## Carga de archivos grandes en partes mediante la API de alto nivel del AWS SDK para .NET
](#uploading-an-archive-in-parts-highlevel-using-dotnet)
+ [

## Carga de archivos grandes en partes mediante la API de bajo nivel del AWS SDK para .NET
](#uploading-an-archive-in-parts-lowlevel-using-dotnet)

## Carga de archivos grandes en partes mediante la API de alto nivel del AWS SDK para .NET
<a name="uploading-an-archive-in-parts-highlevel-using-dotnet"></a>

Utilice los mismos métodos de la API de alto nivel para cargar archivos pequeños o grandes. En función del tamaño de archivo, los métodos de la API de alto nivel deciden si se carga el archivo en una sola operación o se utiliza la API de carga multiparte que proporciona Amazon Glacier. Para obtener más información, consulte [Carga de un archivo mediante la API de alto nivel del AWS SDK para .NET](uploading-an-archive-single-op-using-dotnet.md#uploading-an-archive-single-op-highlevel-using-dotnet).

## Carga de archivos grandes en partes mediante la API de bajo nivel del AWS SDK para .NET
<a name="uploading-an-archive-in-parts-lowlevel-using-dotnet"></a>

Para tener un control más detallado de la carga, puede utilizar la API de bajo nivel, donde puede configurar la solicitud y procesar la respuesta. A continuación, se indican los pasos necesarios para cargar archivos grandes por partes con AWS SDK para .NET.

 

1. Cree una instancia de la clase `AmazonGlacierClient` (el cliente). 

   Debe especificar una AWS región en la que desee guardar el archivo. Todas las operaciones que realice con este cliente se aplican a esa AWS región. 

1. Inicie una carga multiparte llamando al método `InitiateMultipartUpload`.

   Tiene que proporcionar el nombre del almacén en el que quiere cargar el archivo, el tamaño de cada parte y una descripción opcional. Puede facilitar esta información creando una instancia de la clase `InitiateMultipartUploadRequest`. En respuesta, Amazon Glacier devuelve un ID de carga.

1. Cargue las partes llamando al método `UploadMultipartPart`. 

   Por cada parte que cargue, debe indicar el nombre de almacén, el rango de bytes en el archivo montado final que se cargarán en esta parte, la suma de comprobación de los datos de parte y el ID de carga. 

1. Complete la carga multiparte llamando al método `CompleteMultipartUpload`.

   Debe proporcionar el ID de carga, la suma de comprobación de todo el archivo, el tamaño de archivo (tamaño combinado de todas las partes que ha cargado) y el nombre de almacén. Amazon Glacier construye el archivo a partir de las partes cargadas y devuelve un ID de archivo.

### Ejemplo: Cargar un archivo grande por partes con Amazon SDK para .NET
<a name="upload-archive-mpu-dotnet-example"></a>

El siguiente ejemplo de código de C\$1 utiliza el AWS SDK para .NET para cargar un archivo en una bóveda (`examplevault`). Para step-by-step obtener instrucciones sobre cómo ejecutar este ejemplo, consulte[Ejecución de los ejemplos de código](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet). Debe actualizar el código mostrado con el nombre del archivo que quiera cargar.

**Example**  

```
using System;
using System.Collections.Generic;
using System.IO;
using Amazon.Glacier;
using Amazon.Glacier.Model;
using Amazon.Runtime;

namespace glacier.amazon.com.rproxy.govskope.ca.docsamples
{
  class ArchiveUploadMPU
  {
    static string vaultName       = "examplevault";
    static string archiveToUpload = "*** Provide file name (with full path) to upload ***";
    static long partSize          = 4194304; // 4 MB.

    public static void Main(string[] args)
    {
      AmazonGlacierClient client;
      List<string> partChecksumList = new List<string>();
      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<string> UploadParts(string uploadID, AmazonGlacierClient client)
    {
      List<string> partChecksumList = new List<string>();
      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<string> 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;
    }
  }
}
```

# Carga de archivos grandes por partes con la API de REST
<a name="uploading-an-archive-mpu-using-rest"></a>

Tal y como se explica en [Carga de archivos grandes por partes (carga multiparte)](uploading-archive-mpu.md), el término "carga multiparte" hace referencia a un conjunto de operaciones que permiten cargar un archivo por partes y ejecutar operaciones relacionadas. Para obtener más información sobre estas operaciones, consulte los siguientes temas de referencia de las API:

 
+ [Inicio de la carga multiparte (POST cargas-multiparte)](api-multipart-initiate-upload.md)
+ [Carga de partes (PUT uploadID)](api-upload-part.md)
+ [Finalización de una carga multiparte (POST uploadID)](api-multipart-complete-upload.md)
+ [Anulación de la carga multiparte (DELETE uploadID)](api-multipart-abort-upload.md)
+ [Enumeración de partes (GET uploadID)](api-multipart-list-parts.md)
+ [Enumeración de cargas multiparte (GET cargas-multiparte)](api-multipart-list-uploads.md)

# Descarga de un archivo en Amazon Glacier
<a name="downloading-an-archive"></a>

Amazon Glacier proporciona una consola de administración que puede utilizarse para crear y eliminar almacenes. Sin embargo, no puede descargar archivos de Amazon Glacier mediante la consola de administración. Para descargar datos, como fotos, vídeos y otros documentos, debe utilizar AWS Command Line Interface (AWS CLI) o escribir código para realizar las solicitudes, ya sea directamente mediante la API de REST o mediante la AWS SDKs. 

Para obtener información sobre el uso de Amazon Glacier con AWS CLI, consulte la [AWS CLI Referencia de Amazon Glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html). Para instalar el AWS CLI, consulte [AWS Command Line Interface](https://aws.amazon.com/cli/). En los siguientes temas se describe cómo descargar archivos a Amazon Glacier mediante la AWS SDK para Java API REST de Amazon Glacier y la API REST de Amazon Glacier. AWS SDK para .NET

**Topics**
+ [

# Recuperación de archivos de Amazon Glacier
](downloading-an-archive-two-steps.md)
+ [

# Descarga de un archivo en Amazon Glacier mediante el AWS SDK para Java
](downloading-an-archive-using-java.md)
+ [

# Descarga de un archivo en Amazon Glacier mediante AWS SDK para .NET
](downloading-an-archive-using-dotnet.md)
+ [

# Descarga de un archivo grande mediante procesamiento paralelo con Python
](downloading-large-archive-parallel-python.md)
+ [

# Descarga de un archivo con la API de REST
](downloading-an-archive-using-rest.md)
+ [

# Descarga de un archivo en Amazon Glacier mediante AWS CLI
](downloading-an-archive-using-cli.md)

# Recuperación de archivos de Amazon Glacier
<a name="downloading-an-archive-two-steps"></a>

La recuperación de un archivo de Amazon Glacier es una operación asíncrona, en la que primero debe iniciar un trabajo y, después, descargar la salida una vez completado el trabajo. Para iniciar un trabajo de recuperación de archivos, utilice la operación de la API [Inicialización de trabajos (POST trabajos)](api-initiate-job-post.md) REST o su equivalente en el AWS CLI, o el AWS SDKs.

**Topics**
+ [

## Opciones de recuperación de archivos
](#api-downloading-an-archive-two-steps-retrieval-options)
+ [

## Recuperaciones de archivo por rangos
](#downloading-an-archive-range)

El proceso de recuperación de un archivo de Amazon Glacier consta de dos pasos. En el diagrama siguiente se proporciona información general del proceso de implementación:

**Para recuperar un archivo**

1. Se inicia un trabajo de recuperación de archivo.

   1. Obtenga el ID del archivo que desea recuperar. Puede obtener el ID de archivo de un inventario del almacén. Puede obtener el ID del archivo con la API REST AWS CLI, o AWS SDKs. Para obtener más información, consulte [Descarga de un inventario de almacén en Amazon Glacier](vault-inventory.md). 

   1. Inicie un trabajo que solicite a Amazon Glacier que prepare todo un archivo o una parte de este para su posterior descarga mediante la operación [Inicialización de trabajos (POST trabajos)](api-initiate-job-post.md). 

   Cuando inicia un trabajo, Amazon Glacier devuelve un ID de trabajo en la respuesta y ejecuta el trabajo de forma asíncrona. (No puede descargar la salida de trabajo hasta que este se complete, tal como se describe en el paso 2).
**importante**  
En el caso de las recuperaciones estándar únicamente, una política de recuperación de datos puede hacer que se produzca una excepción `PolicyEnforcedException` en la solicitud `Initiate Job`. Para obtener más información sobre las políticas de recuperación de datos, consulte [Políticas de recuperación de datos de Amazon Glacier](data-retrieval-policy.md). Para obtener más información sobre la excepción `PolicyEnforcedException`, consulte [Respuestas de error](api-error-responses.md).

   Cuando sea necesario, puede restaurar grandes segmentos de los datos almacenados en Amazon Glacier. Para obtener información sobre cómo restaurar datos de las clases de almacenamiento de Amazon Glacier, consulte [Clases de almacenamiento para el archivado de objetos]( https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html#sc-glacier) en la *Guía del usuario de Amazon Simple Storage Service*.

1. Una vez completado el trabajo, descargue los bytes mediante la operación [Obtención de la salida del trabajo (GET output)](api-job-output-get.md). 

   Puede descargar todos los bytes o especificar un rango de bytes para descargar solo una parte de la salida del trabajo. En el caso de las salidas más grandes, la descarga de la salida en fragmentos es de ayuda si se produce un error en la descarga, como un error de red. Si obtiene la salida de trabajo en una única solicitud y hay un error de red, tendrá que reiniciar la descarga de la salida desde el principio. Sin embargo, si descargar la salida en fragmentos, en caso de error, solo necesitará reiniciar la descarga de la parte más pequeña y no de toda la salida. 

Amazon Glacier debe completar un trabajo antes de poder obtener su salida. Tras completarse, un trabajo no caduca durante al menos 24 horas, por lo que puede descargar la salida en el periodo de 24 horas después de haberse completado el trabajo. La restauración puede caducar en cualquier momento después de 24 horas desde la finalización del trabajo. Para determinar si el trabajo se ha completado, compruebe su estado con una de las opciones siguientes:
+ **Esperar una notificación de finalización del trabajo:** puede especificar un tema de Amazon Simple Notification Service (Amazon SNS) en el que Amazon Glacier puede publicar una notificación cuando se complete el trabajo. Amazon Glacier envía la notificación únicamente después de haberse completado el trabajo.

  Puede especificar un tema de Amazon SNS para un trabajo cuando lo inicie. Además de especificar un tema de Amazon SNS en su solicitud de trabajo, si su almacén tiene establecida la configuración de notificaciones para los eventos de recuperación de archivo, Amazon Glacier también publica una notificación en ese tema de SNS. Para obtener más información, consulte [Configuración de notificaciones de almacenes en Amazon Glacier](configuring-notifications.md).
+ **Solicitar explícitamente información del trabajo:** también puede usar la operación de la API `Describe Job` de Amazon Glacier ([Descripción del trabajo (GET JobID)](api-describe-job-get.md)) con el fin de sondear información sobre el trabajo de forma periódica. No obstante, le recomendamos que utilice las notificaciones de Amazon SNS.

**nota**  
La información que se obtiene mediante las notificaciones de Amazon SNS es la misma que se obtiene al llamar a la operación de la API `Describe Job`. 

## Opciones de recuperación de archivos
<a name="api-downloading-an-archive-two-steps-retrieval-options"></a>

Al iniciar un trabajo para recuperar un archivo, puede especificar una de las siguientes opciones de recuperación en función de los requisitos de tiempo y costos de acceso. Para obtener información acerca de los precios de recuperación, consulte [Precios de Amazon Glacier](https://aws.amazon.com/s3/glacier/pricing/).
+ **Acelerada:** las recuperaciones rápidas permiten acceder de forma rápida a los datos guardados en la clase de almacenamiento de Amazon Glacier Flexible Retrieval o en el nivel de acceso a archivos de S3 de Agrupación por niveles inteligente cuando se requieran solicitudes urgentes ocasionales para restaurar archivos. En todos los casos, excepto en los archivos de mayor tamaño (más de 250 MB), los datos a los que se accede mediante las recuperaciones rápidas suelen estar disponibles en un plazo de entre 1 y 5 minutos. La capacidad aprovisionada garantiza que la capacidad que necesitan las recuperaciones Expedited estará disponible cuando lo necesite. Para obtener más información, consulte [Capacidad aprovisionada](#api-downloading-an-archive-two-steps-retrieval-expedited-capacity). 
+ **Estándar:** las recuperaciones estándar le permiten acceder a cualquiera de sus archivos en un plazo de varias horas. Las recuperaciones estándar suelen completarse en un plazo de entre 3 y 5 horas. Estándar es la opción predeterminada para las solicitudes de recuperación que no especifican la opción de recuperación.
+ **En bloque:** las recuperaciones en bloque son la opción de recuperación de Amazon Glacier de menor costo, que puede usar para recuperar grandes cantidades de datos, incluso petabytes, de forma económica y en un mismo día. Las recuperaciones en bloque suelen completarse en un plazo de entre 5 y 12 horas.

En la tabla siguiente se resumen las opciones de recuperación de archivos. Para obtener información sobre precios, consulte [Precios de Amazon Glacier](https://aws.amazon.com/s3/glacier/pricing/).


| Servicio | Rápida | Estándar | En bloque | 
| --- | --- | --- | --- | 
|  Amazon Glacier  |  Entre 1 y 5 minutos  |  Entre tres y cinco horas  |  Entre cinco y 12 horas  | 

Para realizar una búsqueda `Expedited``Standard`, o una `Bulk` recuperación, defina el elemento de `Tier` solicitud en la solicitud de operación de la API [https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOSTrestore.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOSTrestore.html)REST con la opción que desee, o su equivalente en AWS Command Line Interface (AWS CLI) o AWS SDKs. Si ha adquirido capacidad aprovisionada, todas las recuperaciones rápidas se realizarán automáticamente con su capacidad aprovisionada. 

### Capacidad aprovisionada
<a name="api-downloading-an-archive-two-steps-retrieval-expedited-capacity"></a>

La capacidad aprovisionada garantiza que la capacidad de recuperación para las recuperaciones rápidas esté disponible cuando la necesite. Cada unidad de capacidad permite realizar al menos tres recuperaciones rápidas cada 5 minutos y proporciona un rendimiento de recuperación de hasta 150 megabytes por segundo (). MBps

Si su carga de trabajo requiere un acceso de confianza y predecible a un subconjunto de sus datos en cuestión de minutos, se recomienda que adquiera capacidad de recuperación aprovisionada. Sin la capacidad aprovisionada, las solicitudes de recuperación rápida se suelen aceptar, salvo en situaciones extraordinarias en las que la demanda sea inusualmente alta. Sin embargo, si necesita obtener acceso a recuperaciones rápidas incondicionalmente, deberá adquirir capacidad de recuperación aprovisionada. 

#### Compra de capacidad aprovisionada
<a name="downloading-an-archive-purchase-provisioned-capacity"></a>

Puede comprar unidades de capacidad aprovisionadas mediante la consola Amazon Glacier, la operación de la API [Adquisición de capacidad aprovisionada (POST capacidad-aprovisionada)](api-PurchaseProvisionedCapacity.md) REST AWS SDKs, o la AWS CLI. Para obtener información acerca de los precios de la capacidad aprovisionada, consulte [Precios de Amazon Glacier](https://aws.amazon.com/s3/glacier/pricing/). 

Una unidad de capacidad aprovisionada dura un mes a partir de la fecha y la hora de la compra.

Si la fecha de inicio es el 31 de un mes, la fecha de vencimiento es el último día del mes siguiente. Por ejemplo, si la fecha de inicio es 31 de agosto, la fecha de vencimiento es 30 de septiembre. Por ejemplo, si la fecha de inicio es 31 de enero, la fecha de vencimiento es 28 de febrero.

**Para comprar capacidad aprovisionada mediante la consola de Amazon Glacier**

1.  Inicie sesión en la consola de Amazon Glacier Consola de administración de AWS y ábrala desde [https://console.aws.amazon.com/glacier/casa](https://console.aws.amazon.com/glacier/home).

1. En el panel de navegación izquierdo, elija **Configuración de recuperación de datos**.

1. En **Unidades de capacidad aprovisionadas (PCUs)**, elija **Comprar PCU**. Aparece el cuadro de diálogo **Comprar PCU**.

1. Si quiere adquirir capacidad aprovisionada, especifique **confirm** en el cuadro **Confirmar compra**.

1.  Elija **Comprar PCU**. 

## Recuperaciones de archivo por rangos
<a name="downloading-an-archive-range"></a>

Cuando recupera un archivo de Amazon Glacier, puede especificar un rango del archivo que se va a recuperar, o una parte de este, si así lo desea. El valor predeterminado es recuperar el archivo completo. La especificación de un rango de bytes puede ser útil si desea hacer lo siguiente:
+ **Administrar las descargas de datos:** Amazon Glacier permite que los datos se descarguen hasta 24 horas después de que se haya completado la solicitud de recuperación. Por lo tanto, puede recuperar solo partes del archivo para que pueda administrar la programación de descargas en el intervalo de descarga indicado.
+ **Recuperar una parte determinada de un archivo grande:** por ejemplo, suponga que ha agregado anteriormente muchos archivos y los ha cargado como uno solo y ahora quiere recuperar algunos de los archivos. En este caso, puede especificar un rango del archivo que contiene aquellos que le interesan mediante una solicitud de recuperación. O bien, puede iniciar varias solicitudes de recuperación, cada una con un rango de uno o más archivos.

Al iniciar un trabajo de recuperaciones por rangos, debe proporcionar un rango esté alineado en megabytes. En otras palabras, el rango de bytes puede comenzar en cero (el principio del archivo) o en cualquier intervalo de 1 MB (1 MB, 2 MB, 3 MB y así sucesivamente) en adelante. 

El final del rango puede ser el final del archivo o cualquier intervalo de 1 MB mayor que el principio del rango. Además, si quiere obtener los valores de suma de comprobación al descargar los datos (una vez completado el trabajo de recuperación), el rango que solicite en el inicio del trabajo también debe estar alineado con un hash en árbol. Puede usar sumas de comprobación para asegurarse de que los datos no han resultado dañados durante la transmisión. Para obtener más información sobre la alineación en megabytes y en hash en árbol, consulte [Recuperación de sumas de comprobación al descargar datos](checksum-calculations-range.md). 

# Descarga de un archivo en Amazon Glacier mediante el AWS SDK para Java
<a name="downloading-an-archive-using-java"></a>

Tanto el [nivel alto como el nivel bajo](using-aws-sdk.md) que APIs proporciona Amazon SDK for Java proporcionan un método para descargar un archivo.

**Topics**
+ [

## Descargar un archivo mediante la API de alto nivel del AWS SDK para Java
](#downloading-an-archive-using-java-highlevel-api)
+ [

## Descargar un archivo mediante la API de bajo nivel del AWS SDK para Java
](#downloading-an-archive-using-java-lowlevel-api)

## Descargar un archivo mediante la API de alto nivel del AWS SDK para Java
<a name="downloading-an-archive-using-java-highlevel-api"></a>

La clase `ArchiveTransferManager` de la API de alto nivel cuenta con el método `download`, que le permite descargar un archivo. 

**importante**  
La clase `ArchiveTransferManager` crea un tema de Amazon Simple Notification Service (Amazon SNS) y una cola de Amazon Simple Queue Service (Amazon SQS) que se suscribe a ese tema. A continuación, inicia el trabajo de recuperación del archivo y sondea la cola para determinar si el archivo se encuentra disponible. Una vez que el archivo está disponible, comienza la descarga. Para obtener más información sobre los tiempos de recuperación, consulte [Opciones de recuperación de archivos](downloading-an-archive-two-steps.md#api-downloading-an-archive-two-steps-retrieval-options).

### Ejemplo: descargar un archivo mediante la API de alto nivel del AWS SDK para Java
<a name="download-archives-java-highlevel-example"></a>

En el ejemplo de código Java siguiente, se descarga un archivo de un almacén (`examplevault`) de la región Oeste de EE. UU. (Oregón) (`us-west-2`).

Para step-by-step obtener instrucciones sobre cómo ejecutar este ejemplo, consulte[Ejecución de ejemplos de Java para Amazon Glacier con Eclipse](using-aws-sdk-for-java.md#setting-up-and-testing-sdk-java). Tiene que actualizar el código mostrado con un ID de archivo existente y la ruta local donde desea guardar el archivo descargado.

**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);
        }
    }
}
```

## Descargar un archivo mediante la API de bajo nivel del AWS SDK para Java
<a name="downloading-an-archive-using-java-lowlevel-api"></a>

A continuación, se indican los pasos necesarios para recuperar un inventario de almacén con la API de bajo nivel de AWS SDK para Java . 

 

1. Cree una instancia de la clase `AmazonGlacierClient` (el cliente). 

   Debe especificar una AWS región desde la que desea descargar el archivo. Todas las operaciones que realice con este cliente se aplican a esa AWS región. 

1. Inicie un trabajo `archive-retrieval` ejecutando el método `initiateJob`.

   Tiene que proporcionar información del trabajo, como el ID del archivo que quiere descargar y el tema de Amazon SNS opcional en el que quiere que Amazon Glacier (Amazon Glacier) publique un mensaje de finalización del trabajo; para ello, debe crear una instancia de la clase `InitiateJobRequest`. Amazon Glacier devuelve un ID de trabajo como respuesta. La respuesta está disponible en una instancia de la clase `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();
   ```

   Si lo desea, puede especificar un intervalo de bytes para solicitar a Amazon Glacier que prepare únicamente una parte del archivo. Por ejemplo, puede actualizar la solicitud anterior agregando la siguiente instrucción para solicitar a Amazon Glacier que prepare únicamente la porción comprendida entre 1 MB y 2 MB del archivo.

    

   ```
   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. Esperar a que el trabajo finalice.

   Debe esperar hasta que la salida del trabajo esté lista para que pueda realizar la descarga. Si configuró las notificaciones en el almacén con la identificación de un tema de​ Amazon Simple Notification Service (Amazon SNS) o especificó un tema de Amazon SNS al iniciar un trabajo, Amazon Glacier envía un mensaje a ese tema cuando complete el trabajo. 

   También puede sondear Amazon Glacier mediante la llamada al método `describeJob` para que determine el estado de finalización del trabajo. No obstante, el enfoque recomendado es utilizar un tema de Amazon SNS para las notificaciones.

1. Descargue la salida del trabajo (los datos del archivo) ejecutando el método `getJobOutput`.

   Tiene que proporcionar la información de la solicitud, como el ID del trabajo y el nombre del almacén, creando una instancia de la clase `GetJobOutputRequest`. La salida que devuelve Amazon Glacier está disponible en el objeto `GetJobOutputResult`. 

    

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

   En el fragmento de código anterior, se descarga toda la salida del trabajo. Si lo desea, puede recuperar únicamente una parte de la salida o descargarla toda en fragmentos más pequeños especificando el intervalo de bytes en `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 respuesta a la llamada a `GetJobOutput`, Amazon Glacier devuelve la suma de comprobación de la parte de los datos descargados, siempre y cuando se cumplan ciertas condiciones. Para obtener más información, consulte [Recuperación de sumas de comprobación al descargar datos](checksum-calculations-range.md).

   Para comprobar que no hay errores en la descarga, puede calcular la suma de comprobación en el cliente y compararla con la suma de comprobación que Amazon Glacier envió en la respuesta. 

   En el caso de un trabajo de recuperación de archivos con el rango opcional especificado, al obtener la descripción del trabajo, se incluye la suma de comprobación del rango que se está recuperando (). SHA256 TreeHash Puede utilizar este valor para comprobar la exactitud del intervalo de bytes que va a descargar más adelante. Por ejemplo, si inicia un trabajo para recuperar un intervalo de archivo alineado con un hash en árbol y luego descarga la salida en fragmentos de forma que cada una de las solicitudes `GetJobOutput` devuelve una suma de comprobación, puede calcular la suma de comprobación de cada parte de la descarga en el cliente y luego calcular el hash en árbol. Puede comparar este dato con la suma de comprobación que Amazon Glacier devuelve en respuesta a la solicitud de descripción del trabajo para asegurarse de que todo el intervalo de bytes descargado es igual que el intervalo de bytes almacenado en Amazon Glacier. 

    Para ver un ejemplo práctico, consulte [Ejemplo 2: Recuperación de un archivo mediante la API de bajo nivel de la salida —Download en AWS SDK para Java fragmentos](#downloading-an-archive-with-range-using-java-example). 

### Ejemplo 1: Recuperación de un archivo mediante la API de bajo nivel del AWS SDK para Java
<a name="downloading-an-archive-using-java-example"></a>

En el siguiente ejemplo de código Java, se descarga un archivo del almacén especificado. Una vez que el trabajo se completa, se descarga toda la salida en una única llamada a `getJobOutput`. Para ver un ejemplo acerca de cómo descargar una salida en fragmentos, consulte [Ejemplo 2: Recuperación de un archivo mediante la API de bajo nivel de la salida —Download en AWS SDK para Java fragmentos](#downloading-an-archive-with-range-using-java-example).

En el ejemplo se realizan las siguientes tareas:

 
+ Se crea un tema de Amazon Simple Notification Service (Amazon SNS).

  Amazon Glacier envía una notificación a este tema cuando se completa el trabajo. 
+ Se crea una cola de Amazon Simple Queue Service (Amazon SQS).

  En el ejemplo, se asocia una política a la cola para permitir que el tema de Amazon SNS publique mensajes en la cola.
+ Se inicia un trabajo para descargar el archivo especificado.

  En la solicitud de trabajo, se especifica el tema de Amazon SNS creado para que Amazon Glacier pueda publicar una notificación en este tema cuando se complete el trabajo.
+ Se comprueba periódicamente si hay algún mensaje que contenga el ID de trabajo en la cola de Amazon SQS.

  Si hay algún mensaje, debe analizar el código JSON y comprobar si el trabajo se completó correctamente. En caso afirmativo, descargue el archivo. 
+ Se realiza una limpieza mediante la eliminación del tema de Amazon SNS y la cola de Amazon SQS que creó.

 

```
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<String, String> queueAttributes = new HashMap<String, String>();
        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<Message> 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));
    }
}
```

### Ejemplo 2: Recuperación de un archivo mediante la API de bajo nivel de la salida —Download en AWS SDK para Java fragmentos
<a name="downloading-an-archive-with-range-using-java-example"></a>

En el siguiente ejemplo de código Java, se recupera un archivo de Amazon Glacier. En el ejemplo de código, se descarga la salida del trabajo en fragmentos especificando el intervalo de bytes en un objeto `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<String, String> queueAttributes = new HashMap<String, String>();
        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<Message> 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));
    }
}
```

# Descarga de un archivo en Amazon Glacier mediante AWS SDK para .NET
<a name="downloading-an-archive-using-dotnet"></a>

Tanto el [nivel alto como el nivel bajo](using-aws-sdk.md) que APIs proporciona Amazon SDK para .NET proporcionan un método para descargar un archivo.

**Topics**
+ [

## Descargar un archivo mediante la API de alto nivel del AWS SDK para .NET
](#downloading-an-archive-using-dotnet-highlevel-api)
+ [

## Descargar un archivo mediante la API de bajo nivel del AWS SDK para .NET
](#downloading-an-archive-using-dotnet-lowlevel-api)

## Descargar un archivo mediante la API de alto nivel del AWS SDK para .NET
<a name="downloading-an-archive-using-dotnet-highlevel-api"></a>

La clase `ArchiveTransferManager` de la API de alto nivel cuenta con el método `Download`, que le permite descargar un archivo. 

**importante**  
La clase `ArchiveTransferManager` crea un tema de Amazon Simple Notification Service (Amazon SNS) y una cola de Amazon Simple Queue Service (Amazon SQS) que se suscribe a ese tema. A continuación, inicia el trabajo de recuperación del archivo y sondea la cola para determinar si el archivo se encuentra disponible. Una vez que el archivo está disponible, comienza la descarga. Para obtener más información sobre los tiempos de recuperación, consulte [Opciones de recuperación de archivos](downloading-an-archive-two-steps.md#api-downloading-an-archive-two-steps-retrieval-options)

### Ejemplo: descargar un archivo mediante la API de alto nivel del AWS SDK para .NET
<a name="download-archives-dotnet-highlevel-example"></a>

En el ejemplo de código C\$1 siguiente, se descarga un archivo de un almacén (`examplevault`) de la región Oeste de EE. UU. (Oregón). 

Para step-by-step obtener instrucciones sobre cómo ejecutar este ejemplo, consulte[Ejecución de los ejemplos de código](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet). Tiene que actualizar el código mostrado con un ID de archivo existente y la ruta local donde desea guardar el archivo descargado.

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

namespace glacier.amazon.com.rproxy.govskope.ca.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);
      }
    }
  }
}
```

## Descargar un archivo mediante la API de bajo nivel del AWS SDK para .NET
<a name="downloading-an-archive-using-dotnet-lowlevel-api"></a>

Estos son los pasos para descargar un archivo de Amazon Glacier (Amazon Glacier) con la API de bajo nivel de AWS SDK para .NET. 

1. Cree una instancia de la clase `AmazonGlacierClient` (el cliente). 

   Debe especificar una AWS región desde la que desea descargar el archivo. Todas las operaciones que realice con este cliente se aplican a esa AWS región.

1. Inicie un trabajo `archive-retrieval` ejecutando el método `InitiateJob`.

   Tiene que proporcionar información del trabajo, como el ID del archivo que quiere descargar y el tema de Amazon SNS opcional en el que quiere que Amazon Glacier publique un mensaje de finalización del trabajo; para ello, debe crear una instancia de la clase `InitiateJobRequest`. Amazon Glacier devuelve un ID de trabajo como respuesta. La respuesta está disponible en una instancia de la clase `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;
   ```

   Si lo desea, puede especificar un intervalo de bytes para solicitar que Amazon Glacier prepare únicamente una parte del archivo, tal y como se muestra en la siguiente solicitud. La solicitud especifica que Amazon Glacier solo debe preparar la parte del archivo entre 1 MB y 2 MB.

   ```
   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. Esperar a que el trabajo finalice.

   Debe esperar hasta que la salida del trabajo esté lista para que pueda realizar la descarga. Si configuró las notificaciones en el almacén con la identificación de un tema de​ Amazon Simple Notification Service (Amazon SNS) o especificó un tema de Amazon SNS al iniciar un trabajo, Amazon Glacier envía un mensaje a ese tema cuando complete el trabajo. En el ejemplo de código de la siguiente sección, se utiliza Amazon SNS para que Amazon Glacier publique un mensaje.

   También puede sondear Amazon Glacier mediante la llamada al método `DescribeJob` para que determine el estado de finalización del trabajo. No obstante, el enfoque recomendado es utilizar un tema de Amazon SNS para las notificaciones. 

1. Descargue la salida del trabajo (los datos del archivo) ejecutando el método `GetJobOutput`.

   Tiene que proporcionar la información de la solicitud, como el ID del trabajo y el nombre del almacén, creando una instancia de la clase `GetJobOutputRequest`. La salida que devuelve Amazon Glacier está disponible en el objeto `GetJobOutputResponse`. 

   ```
   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);
     }
   }
   ```

   En el fragmento de código anterior, se descarga toda la salida del trabajo. Si lo desea, puede recuperar únicamente una parte de la salida o descargarla toda en fragmentos más pequeños especificando el intervalo de bytes en `GetJobOutputRequest`. 

   ```
   GetJobOutputRequest getJobOutputRequest = new GetJobOutputRequest()
   {
     JobId = jobId,
     VaultName = vaultName
   };
   getJobOutputRequest.SetRange(0, 1048575); // Download only the first 1 MB chunk of the output.
   ```

   En respuesta a la llamada a `GetJobOutput`, Amazon Glacier devuelve la suma de comprobación de la parte de los datos descargados, siempre y cuando se cumplan ciertas condiciones. Para obtener más información, consulte [Recuperación de sumas de comprobación al descargar datos](checksum-calculations-range.md).

   Para comprobar que no hay errores en la descarga, puede calcular la suma de comprobación en el cliente y compararla con la suma de comprobación que Amazon Glacier envió en la respuesta. 

   Para un trabajo de recuperación de archivos con el rango opcional especificado, al obtener la descripción del trabajo, se incluye la suma de comprobación del rango que se está recuperando (SHA256TreeHash). Puede utilizar este valor para comprobar aún más la precisión de todo el rango de bytes que vaya a descargar más adelante. Por ejemplo, si inicia un trabajo para recuperar un intervalo de archivo alineado con un hash en árbol y luego descarga la salida en fragmentos de forma que cada una de las solicitudes `GetJobOutput` devuelve una suma de comprobación, puede calcular la suma de comprobación de cada parte de la descarga en el cliente y luego calcular el hash en árbol. Puede comparar este dato con la suma de comprobación que Amazon Glacier devuelve en respuesta a la solicitud de descripción del trabajo para asegurarse de que todo el intervalo de bytes descargado es igual que el intervalo de bytes almacenado en Amazon Glacier. 

   

   Para ver un ejemplo práctico, consulte [Ejemplo 2: Recuperación de un archivo mediante la API de bajo nivel de la salida —Download en AWS SDK para .NET fragmentos](#creating-vaults-sdk-dotnet-example2).

### Ejemplo 1: Recuperación de un archivo mediante la API de bajo nivel del AWS SDK para .NET
<a name="creating-vaults-sdk-dotnet-example-retrieve"></a>

En el siguiente ejemplo de código C\$1, se descarga un archivo del almacén especificado. Una vez que el trabajo se completa, se descarga toda la salida en una única llamada a `GetJobOutput`. Para ver un ejemplo acerca de cómo descargar una salida en fragmentos, consulte [Ejemplo 2: Recuperación de un archivo mediante la API de bajo nivel de la salida —Download en AWS SDK para .NET fragmentos](#creating-vaults-sdk-dotnet-example2).

En el ejemplo se realizan las siguientes tareas:
+ Se configura un tema de Amazon Simple Notification Service (Amazon SNS). 

  Amazon Glacier envía una notificación a este tema cuando se completa el trabajo. 
+ Se configura una cola de Amazon Simple Queue Service (Amazon SQS). 

  En el ejemplo, se asocia una política a la cola para permitir que el tema de Amazon SNS publique mensajes. 
+ Se inicia un trabajo para descargar el archivo especificado.

  En la solicitud de trabajo, el ejemplo especifica el tema de Amazon SNS para que Amazon Glacier pueda enviar un mensaje cuando se complete el trabajo.
+ Se comprueba periódicamente si hay mensajes en la cola de Amazon SQS. 

  Si hay algún mensaje, debe analizar el código JSON y comprobar si el trabajo se completó correctamente. En caso afirmativo, descargue el archivo. En el ejemplo de código, se utiliza la biblioteca de JSON.NET (consulte [JSON.NET](http://json.codeplex.com/)) para analizar el código JSON.
+ Se realiza una limpieza mediante la eliminación del tema de Amazon SNS y la cola de Amazon SQS que se crearon.

```
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.ca.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<string> { "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<string, string>
          {
              { 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<string, string> outerLayer = JsonConvert.DeserializeObject<Dictionary<string, string>>(message.Body);
        Dictionary<string, object> fields = JsonConvert.DeserializeObject<Dictionary<string, object>>(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);
      }
    }
  }
}
```

### Ejemplo 2: Recuperación de un archivo mediante la API de bajo nivel de la salida —Download en AWS SDK para .NET fragmentos
<a name="creating-vaults-sdk-dotnet-example2"></a>

En el siguiente ejemplo de código C\$1 se recupera un archivo de Amazon Glacier. En el ejemplo de código, se descarga la salida del trabajo en fragmentos especificando el intervalo de bytes en un objeto `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.ca.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<string> { "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<string, string>
          {
              { 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<string, string> outerLayer = JsonConvert.DeserializeObject<Dictionary<string, string>>(message.Body);
            Dictionary<string, object> fields = JsonConvert.DeserializeObject<Dictionary<string, object>>(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);
      }
    }
  }
}
```

# Descarga de un archivo grande mediante procesamiento paralelo con Python
<a name="downloading-large-archive-parallel-python"></a>

En este tema se describe cómo descargar archivos de gran tamaño de Amazon S3 Glacier (S3 Glacier) mediante el procesamiento en paralelo con Python. Este enfoque le permite descargar archivos de cualquier tamaño de forma fiable al dividirlos en partes más pequeñas que se pueden procesar de forma independiente.

## Descripción general de
<a name="downloading-large-archive-python-overview"></a>

El script Python que se proporciona en este ejemplo se realizan las siguientes tareas:

1. Configura los AWS recursos necesarios (tema de Amazon SNS y colas de Amazon SQS) para las notificaciones

1. Iniciar un trabajo de recuperación de archivo con Amazon Glacier

1. Supervisa una cola de Amazon SQS en busca de notificaciones de finalización de trabajo

1. Divide el archivo grande en partes manejables

1. Descarga fragmentos en paralelo mediante varios subprocesos de trabajo

1. Guarda cada fragmento en el disco para volver a ensamblarlo más tarde

## Requisitos previos
<a name="downloading-large-archive-python-prerequisites"></a>

Antes de empezar, asegúrese de que tiene lo siguiente:
+ Versión 3.6 o posterior de Python instalada
+ AWS SDK para Python (Boto3) instalado
+ AWS credenciales configuradas con los permisos adecuados para Amazon Glacier, Amazon SNS y Amazon SQS
+ Espacio en disco suficiente para almacenar los fragmentos de archivo descargados

## Ejemplo: descarga de un archivo mediante procesamiento paralelo con Python
<a name="downloading-large-archive-python-code"></a>

El siguiente script de Python muestra cómo descargar un archivo grande de Amazon Glacier mediante el procesamiento paralelo:

```
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)
```

## Uso del script
<a name="downloading-large-archive-python-usage"></a>

Para utilizar este script, siga estos pasos:

1. Sustituya los valores de los marcadores de posición en el script con su información específica:
   + *output\$1file\$1path*: directorio donde se guardarán los archivos fragmentados
   + *vault\$1name*: Nombre de su almacén de S3 Glacier
   + *notify\$1queue\$1name*: Nombre de la cola de notificaciones de trabajos
   + *chunk\$1download\$1queue\$1name*: Nombre de la cola de descarga de fragmentos
   + *sns\$1topic\$1name*: Nombre del tema de SNS
   + *region*: AWS región en la que se encuentra su almacén
   + *archive\$1id*: ID del archivo que se va a recuperar

1. Ejecute el script :

   ```
   python download_large_archive.py
   ```

1. Una vez descargados todos los fragmentos, puedes combinarlos en un solo archivo mediante un comando como el siguiente:

   ```
   cat /path/to/chunks/*.chunk > complete_archive.file
   ```

## Consideraciones importantes
<a name="downloading-large-archive-python-considerations"></a>

Cuando utilice este script, tenga en cuenta lo siguiente:
+ La recuperación de archivo de S3 Glacier puede tardar varias horas, según el nivel de recuperación seleccionado.
+ El script se ejecuta indefinidamente y sondea las colas de forma continua. Es posible que desee agregar una condición de rescisión en función de sus requisitos específicos.
+ Asegúrese de tener suficiente espacio en disco para almacenar todos los fragmentos del archivo.
+ Si el script se interrumpe, puede reiniciarlo `retrieve_archive=False` para seguir descargando fragmentos sin iniciar un nuevo trabajo de recuperación.
+ Ajuste los *workers* parámetros *chunk\$1size* y en función del ancho de banda de la red y de los recursos del sistema.
+  AWS Se aplican cargos estándar por las recuperaciones de Amazon S3, Amazon SNS y el uso de Amazon SQS.

# Descarga de un archivo con la API de REST
<a name="downloading-an-archive-using-rest"></a>

**Para descargar un archivo con la API de REST**

El proceso de descarga de un archivo consta de dos pasos.

1. Inicie un trabajo del tipo `archive-retrieval`. Para obtener más información, consulte [Inicialización de trabajos (POST trabajos)](api-initiate-job-post.md).

1. Una vez que se complete el trabajo, descargue los datos del archivo. Para obtener más información, consulte [Obtención de la salida del trabajo (GET output)](api-job-output-get.md).

# Descarga de un archivo en Amazon Glacier mediante AWS CLI
<a name="downloading-an-archive-using-cli"></a>

Puede descargar archivos en Amazon Glacier (Amazon Glacier) mediante AWS Command Line Interface (AWS CLI).

**Topics**
+ [

## (Requisito previo) Configurar el AWS CLI
](#Creating-Vaults-CLI-Setup)
+ [

## Ejemplo: descargar un archivo mediante el AWS CLI
](#Downloading-Archives-CLI-Implementation)

## (Requisito previo) Configurar el AWS CLI
<a name="Creating-Vaults-CLI-Setup"></a>

1. Descargue y configure la AWS CLI. Para obtener instrucciones, consulte los siguientes temas en la *Guía del usuario de la AWS Command Line Interface *: 

    [Instalación del AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) 

   [Configuración del AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)

1. Compruebe AWS CLI la configuración introduciendo los siguientes comandos en la línea de comandos. Estos comandos no proporcionan las credenciales de forma explícita, por lo que se utilizan las credenciales del perfil predeterminado.
   + Pruebe a usar el comando de ayuda.

     ```
     aws help
     ```
   + Para obtener una lista de los almacenes de Amazon Glacier en la cuenta configurada, use el comando `list-vaults`. *123456789012*Sustitúyala por tu Cuenta de AWS ID.

     ```
     aws glacier list-vaults --account-id 123456789012
     ```
   + Para ver los datos de configuración actuales de AWS CLI, utilice el `aws configure list` comando.

     ```
     aws configure list
     ```

## Ejemplo: descargar un archivo mediante el AWS CLI
<a name="Downloading-Archives-CLI-Implementation"></a>
**nota**  
Para descargar sus archivos, debe saber cuáles son sus ID. Con los pasos del 1 al 4 se recuperarán los ID de archivo. Si ya conoce los ID de los archivos que quiere descargar, vaya al paso 5.

1. Utilice el comando `initiate-job` para comenzar un trabajo de recuperación de inventario. El informe de inventario enumerará sus ID de archivo.

   ```
   aws glacier initiate-job --vault-name awsexamplevault --account-id 111122223333 --job-parameters="{\"Type\":\"inventory-retrieval\"}"
   ```

    Resultado previsto:

   ```
   {
       "location": "/111122223333/vaults/awsexamplevault/jobs/*** jobid ***", 
       "jobId": "*** jobid ***"
   }
   ```

1. Utilice el comando `describe-job` para comprobar el estado del comando ``job anterior.

   ```
   aws glacier describe-job --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid ***
   ```

    Resultado previsto:

   ```
   {
       "InventoryRetrievalParameters": {
           "Format": "JSON"
       }, 
       "VaultARN": "*** vault arn ***", 
       "Completed": false, 
       "JobId": "*** jobid ***", 
       "Action": "InventoryRetrieval", 
       "CreationDate": "*** job creation date ***", 
       "StatusCode": "InProgress"
   }
   ```

1. Esperar a que el trabajo finalice.

   Debe esperar hasta que la salida del trabajo esté lista para que pueda realizar la descarga. Si configuró las notificaciones en el almacén o especificó un tema de Amazon Simple Notification Service (Amazon SNS) al comenzar el trabajo, Amazon Glacier envía un mensaje a ese tema cuando complete el trabajo. 

   Puede configurar las notificaciones de determinados eventos en el almacén. Para obtener más información, consulte [Configuración de notificaciones de almacenes en Amazon Glacier](configuring-notifications.md). Amazon Glacier envía un mensaje al tema de SNS especificado siempre que se produzca ese evento específico.

1. Cuando haya finalizado, utilice el comando `get-job-output` para descargar el trabajo de recuperación en el archivo `output.json`. Este archivo contendrá sus ID de archivo. 

   ```
   aws glacier get-job-output --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid *** output.json
   ```

   Este comando genera un archivo con los siguientes campos.

   ```
   {
   "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. Utilice el comando `initiate-job` para iniciar el proceso de recuperación de cada archivo de un almacén. Deberá especificar el parámetro de trabajo como `archive-retrieval`, tal como se muestra a continuación.

   ```
   aws glacier initiate-job --vault-name awsexamplevault --account-id 111122223333 --job-parameters="{\"Type\":\"archive-retrieval\",\"ArchiveId\":\"*** archiveId ***\"}"
   ```

1. Espere a que el trabajo `archive-retrieval` finalice. Utilice el comando `describe-job` para comprobar el estado del comando anterior.

   ```
   aws glacier describe-job --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid ***
   ```

1. Cuando se complete el trabajo anterior, use el comando `get-job-output` para descargar su archivo.

   ```
   aws glacier get-job-output --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid *** output_file_name
   ```

# Eliminación de un archivo en Amazon Glacier
<a name="deleting-an-archive"></a>

No se pueden eliminar archivos con la consola de administración de Amazon Glacier (Amazon Glacier). Para eliminar un archivo, debe usar la AWS Command Line Interface (CLI) o escribir código para realizar una solicitud de eliminación utilizando directamente la API REST o AWS SDK para Java las bibliotecas contenedor.NET. En los siguientes temas se explica cómo utilizar las bibliotecas contenedoras AWS SDK para Java y de.NET, la API REST y la. AWS CLI

**Topics**
+ [

# Eliminación de un archivo en Amazon Glacier con AWS SDK para Java
](deleting-an-archive-using-java.md)
+ [

# Eliminar un archivo en Amazon Glacier mediante AWS SDK para .NET
](deleting-an-archive-using-dot-net.md)
+ [

# Eliminación de un archivo de Amazon Glacier con la API de REST
](deleting-an-archive-using-rest.md)
+ [

# Eliminar un archivo en Amazon Glacier mediante el AWS Command Line Interface
](deleting-an-archive-using-cli.md)

Puede eliminar los archivos de uno en uno en un almacén. Para eliminar un archivo, debe proporcionar su ID en la solicitud de eliminación. Puede obtener el ID de archivo descargando el inventario correspondiente al almacén que contiene el archivo. Para obtener más información acerca de cómo descargar un inventario de almacén, consulte [Descarga de un inventario de almacén en Amazon Glacier](vault-inventory.md). 

Después de eliminar un archivo, podrá seguir realizando una solicitud correcta para iniciar un trabajo con el fin de recuperar el archivo eliminado, pero se producirá un error en el trabajo de recuperación de archivo. 

Las recuperaciones de archivo que están en curso de un ID de archivo cuando se elimina el archivo podrían realizarse o no correctamente según los escenarios siguientes:

 
+ Si el trabajo de recuperación del archivo está preparando activamente los datos para su descarga cuando Amazon Glacier recibe la solicitud de eliminación del archivo, puede que se produzca un error en la operación de recuperación. 
+ Si el trabajo de recuperación del archivo ya ha preparado correctamente el archivo para su descarga cuando Amazon Glacier recibe la solicitud para eliminar el archivo, podrá descargar la salida. 

Para obtener más información sobre la recuperación de archivos, consulte [Descarga de un archivo en Amazon Glacier](downloading-an-archive.md). 

Esta operación es idempotente. La eliminación de un archivo que ya ha sido eliminado no producirá un error. 

Después de eliminar un archivo, si descarga inmediatamente el inventario del almacén, puede que este incluya el archivo eliminado en la lista porque Amazon Glacier prepara dicho inventario solo una vez al día.

**nota**  
Para obtener información sobre la eliminación automática de archivos de almacenes, consulte [Eliminación automática de archivos de almacenes en Amazon S3 Glacier](https://aws.amazon.com/solutions/guidance/automated-deletion-of-vault-archives-in-amazon-s3-glacier/).

# Eliminación de un archivo en Amazon Glacier con AWS SDK para Java
<a name="deleting-an-archive-using-java"></a>

A continuación se indican los pasos que hay que seguir para eliminar un archivo mediante la API de bajo nivel de AWS SDK para Java.

 

1. Cree una instancia de la clase `AmazonGlacierClient` (el cliente). 

   Debe especificar la región de AWS en la que está almacenado el archivo que quiere eliminar. Todas las operaciones que realice con este cliente se aplican a esa región de AWS. 

1. Proporcione la información de la solicitud creando una instancia de la clase `DeleteArchiveRequest`.

   Debe proporcionar el ID del archivo, el nombre del almacén y el ID de la cuenta. Si no proporciona el ID de la cuenta, se presumirá que se trata del ID de cuenta asociado a las credenciales proporcionadas para firmar la solicitud. Para obtener más información, consulte [Uso del AWS SDK para Java con Amazon Glacier](using-aws-sdk-for-java.md).

1. Ejecute el método `deleteArchive` proporcionando el objeto de solicitud como parámetro. 

En el siguiente fragmento de código Java, se ilustran los pasos anteriores.

```
AmazonGlacierClient client;

DeleteArchiveRequest request = new DeleteArchiveRequest()
    .withVaultName("*** provide a vault name ***")
    .withArchiveId("*** provide an archive ID ***");

client.deleteArchive(request);
```

 

**nota**  
Para obtener información acerca de la API de REST subyacente, consulte [Eliminación de archivo (DELETE archivo)](api-archive-delete.md).

## Ejemplo: eliminación de un archivo con AWS SDK para Java
<a name="deleting-an-archive-using-java-example"></a>

En el ejemplo de código Java siguiente, se utiliza AWS SDK para Java para eliminar un archivo. Para obtener instrucciones paso a paso sobre cómo ejecutar este ejemplo, consulte [Ejecución de ejemplos de Java para Amazon Glacier con Eclipse](using-aws-sdk-for-java.md#setting-up-and-testing-sdk-java). Debe actualizar el código mostrado con un nombre de almacén y el ID del archivo que quiere eliminar.

**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);
        }
    }
}
```

# Eliminar un archivo en Amazon Glacier mediante AWS SDK para .NET
<a name="deleting-an-archive-using-dot-net"></a>

Tanto el [nivel alto como el nivel bajo](using-aws-sdk.md) que APIs proporciona Amazon SDK para .NET proporcionan un método para eliminar un archivo.

**Topics**
+ [

## Eliminar un archivo mediante la API de alto nivel del AWS SDK para .NET
](#delete-archive-using-dot-net-high-level)
+ [

## Eliminar un archivo mediante la API de bajo nivel AWS SDK para .NET
](#delete-archive-using-dot-net-low-level)

## Eliminar un archivo mediante la API de alto nivel del AWS SDK para .NET
<a name="delete-archive-using-dot-net-high-level"></a>

La clase `ArchiveTransferManager` de la API de alto nivel cuenta con el método `DeleteArchive`, que le permite eliminar un archivo. 

### Ejemplo: eliminar un archivo mediante la API de alto nivel del AWS SDK para .NET
<a name="delete-archive-dot-net-high-level-example"></a>

El siguiente ejemplo de código en C\$1 utiliza la API de alto nivel del AWS SDK para .NET para eliminar un archivo. Para step-by-step obtener instrucciones sobre cómo ejecutar este ejemplo, consulte[Ejecución de los ejemplos de código](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet). Debe actualizar el código mostrado con el ID del archivo que quiere eliminar.

**Example**  

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

namespace glacier.amazon.com.rproxy.govskope.ca.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();
    }
  }
}
```

## Eliminar un archivo mediante la API de bajo nivel AWS SDK para .NET
<a name="delete-archive-using-dot-net-low-level"></a>

A continuación, se indican los pasos que hay que seguir para eliminar un archivo mediante AWS SDK para .NET.

 

1. Cree una instancia de la clase `AmazonGlacierClient` (el cliente). 

   Debe especificar una AWS región en la que se almacena el archivo que desea eliminar. Todas las operaciones que realice con este cliente se aplican a esa AWS región. 

1. Proporcione la información de la solicitud creando una instancia de la clase `DeleteArchiveRequest`.

   Debe proporcionar el ID del archivo, el nombre del almacén y el ID de la cuenta. Si no proporciona el ID de la cuenta, se presumirá que se trata del ID de cuenta asociado a las credenciales proporcionadas para firmar la solicitud. Para obtener más información, consulte [Uso del AWS SDKs con Amazon Glacier](using-aws-sdk.md).

1. Ejecute el método `DeleteArchive` proporcionando el objeto de solicitud como parámetro. 

### Ejemplo: eliminar un archivo mediante la API de bajo nivel del AWS SDK para .NET
<a name="delete-archive-dot-net-low-level-example"></a>

En el siguiente ejemplo de código C\$1, se ilustran los pasos anteriores. En el ejemplo se utiliza la API de bajo nivel del AWS SDK para .NET para eliminar un archivo.

**nota**  
Para obtener información acerca de la API de REST subyacente, consulte [Eliminación de archivo (DELETE archivo)](api-archive-delete.md).

 Para step-by-step obtener instrucciones sobre cómo ejecutar este ejemplo, consulte[Ejecución de los ejemplos de código](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet). Debe actualizar el código mostrado con el ID del archivo que quiere eliminar.

**Example**  

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

namespace glacier.amazon.com.rproxy.govskope.ca.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);
    }
  }
}
```

# Eliminación de un archivo de Amazon Glacier con la API de REST
<a name="deleting-an-archive-using-rest"></a>

Puede utilizar la API Delete Archive para eliminar un archivo. 
+ Para obtener información sobre la API Delete Archive, consulte [Eliminación de archivo (DELETE archivo)](api-archive-delete.md).
+ Para obtener más información acerca del uso de la API de REST, consulte [Referencia de la API para Amazon Glacier](amazon-glacier-api.md). 

# Eliminar un archivo en Amazon Glacier mediante el AWS Command Line Interface
<a name="deleting-an-archive-using-cli"></a>

Puede eliminar archivos en Amazon Glacier (Amazon Glacier) mediante AWS Command Line Interface (AWS CLI).

**Topics**
+ [

## (Requisito previo) Configurar el AWS CLI
](#Creating-Vaults-CLI-Setup)
+ [

## Ejemplo: eliminar un archivo mediante el AWS CLI
](#Deleting-Archives-CLI-Implementation)

## (Requisito previo) Configurar el AWS CLI
<a name="Creating-Vaults-CLI-Setup"></a>

1. Descargue y configure la AWS CLI. Para obtener instrucciones, consulte los siguientes temas en la *Guía del usuario de la AWS Command Line Interface *: 

    [Instalación del AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) 

   [Configuración del AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)

1. Compruebe AWS CLI la configuración introduciendo los siguientes comandos en la línea de comandos. Estos comandos no proporcionan las credenciales de forma explícita, por lo que se utilizan las credenciales del perfil predeterminado.
   + Pruebe a usar el comando de ayuda.

     ```
     aws help
     ```
   + Para obtener una lista de los almacenes de Amazon Glacier en la cuenta configurada, use el comando `list-vaults`. *123456789012*Sustitúyala por tu Cuenta de AWS ID.

     ```
     aws glacier list-vaults --account-id 123456789012
     ```
   + Para ver los datos de configuración actuales de AWS CLI, utilice el `aws configure list` comando.

     ```
     aws configure list
     ```

## Ejemplo: eliminar un archivo mediante el AWS CLI
<a name="Deleting-Archives-CLI-Implementation"></a>

1. Utilice el comando [https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-job.html](https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-job.html) para comenzar un trabajo de recuperación de inventario.

   ```
   aws glacier initiate-job --vault-name awsexamplevault --account-id 111122223333 --job-parameters="{\"Type\":\"inventory-retrieval\"}"
   ```

    Resultado previsto:

   ```
   {
       "location": "/111122223333/vaults/awsexamplevault/jobs/*** jobid ***", 
       "jobId": "*** jobid ***"
   }
   ```

1. Utilice el comando [https://docs.aws.amazon.com/cli/latest/reference/glacier/describe-job.html](https://docs.aws.amazon.com/cli/latest/reference/glacier/describe-job.html) para comprobar el estado del trabajo de recuperación anterior.

   ```
   aws glacier describe-job --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid ***
   ```

    Resultado previsto:

   ```
   {
       "InventoryRetrievalParameters": {
           "Format": "JSON"
       }, 
       "VaultARN": "*** vault arn ***", 
       "Completed": false, 
       "JobId": "*** jobid ***", 
       "Action": "InventoryRetrieval", 
       "CreationDate": "*** job creation date ***", 
       "StatusCode": "InProgress"
   }
   ```

1. Esperar a que el trabajo finalice.

   Debe esperar hasta que la salida del trabajo esté lista para que pueda realizar la descarga. Si configuró las notificaciones en el almacén o especificó un tema de Amazon Simple Notification Service (Amazon SNS) al comenzar el trabajo, Amazon Glacier envía un mensaje a ese tema cuando complete el trabajo. 

   Puede configurar las notificaciones de determinados eventos en el almacén. Para obtener más información, consulte [Configuración de notificaciones de almacenes en Amazon Glacier](configuring-notifications.md). Amazon Glacier envía un mensaje al tema de SNS especificado siempre que se produzca ese evento específico.

1. Cuando haya finalizado, utilice el comando [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) para descargar el trabajo de recuperación en el archivo `output.json`.

   ```
   aws glacier get-job-output --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid *** output.json
   ```

   Este comando genera un archivo con los siguientes campos.

   ```
   {
   "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. Utilice el comando `delete-archive` para eliminar todos los archivos de un almacén hasta que no quede ninguno.

   ```
   aws glacier delete-archive --vault-name awsexamplevault --account-id 111122223333 --archive-id *** archiveid ***
   ```