

 **이 페이지는 볼트와 2012년부터 원래 REST API를 사용하는 Amazon Glacier 서비스의 기존 고객만 사용할 수 있습니다.**

아카이브 스토리지 솔루션을 찾고 있다면 Amazon S3의 Amazon Glacier 스토리지 클래스, S3 Glacier Instant Retrieval, S3 Glacier Flexible Retrieval 및 S3 Glacier Deep Archive를 사용하는 것이 좋습니다. 이러한 스토리지 옵션에 대한 자세한 내용은 [Amazon Glacier 스토리지 클래스](https://aws.amazon.com/s3/storage-classes/glacier/)를 참조하세요.

Amazon Glacier(기존 독립 실행형 볼트 기반 서비스)는 더 이상 신규 고객을 받지 않습니다. Amazon Glacier는 데이터를 볼트에 저장하고 Amazon S3 및 Amazon S3 Glacier 스토리지 클래스와 구별되는 자체 API를 갖춘 독립 실행형 서비스입니다. 기존 데이터는 Amazon Glacier에서 무기한으로 안전하게 보관되며 액세스 가능합니다. 마이그레이션은 필요하지 않습니다. 저비용 장기 아카이브 스토리지의 경우는 [S3 버킷 기반 API, 전체 가용성, 저렴한 비용 및 서비스 통합을 통해 우수한 고객 경험을 제공하는 Amazon S3 Glacier 스토리지 클래스](https://aws.amazon.com/s3/storage-classes/glacier/)를 AWS 권장합니다. S3 APIs AWS 리전 AWS 향상된 기능을 원하는 경우 [Amazon Glacier 볼트에서 Amazon S3 Glacier 스토리지 클래스로 데이터를 전송하기 위한AWS 솔루션 지침](https://aws.amazon.com/solutions/guidance/data-transfer-from-amazon-s3-glacier-vaults-to-amazon-s3/)을 사용하여 Amazon S3 Glacier 스토리지 클래스로 마이그레이션하는 것이 좋습니다.

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

# Amazon Glacier에 아카이브 업로드
<a name="uploading-an-archive"></a>

Amazon Glacier(Amazon Glacier)는 볼트 생성 및 삭제에 사용할 수 있는 관리 콘솔을 제공합니다. 하지만 관리 콘솔을 사용해서 아카이브를 Amazon Glacier에 업로드할 수는 없습니다. 사진, 동영상 및 기타 문서와 같은 데이터를 업로드하려면 REST API를 직접 AWS CLI 사용하거나 Amazon SDKs를 사용하여를 사용하거나 코드를 작성하여 요청해야 합니다.

에서 Amazon Glacier를 사용하는 AWS CLI방법에 대한 자세한 내용은 [AWS CLI Amazon Glacier 참조를 참조하세요](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html). 를 설치하려면 로 AWS CLI이동합니다[AWS Command Line Interface](https://aws.amazon.com/cli/). 다음의 **업로드** 토픽에서는 Amazon SDK for Java, Amazon SDK for .NET 및 REST API를 사용하여 아카이브를 Amazon Glacier에 업로드하는 방법을 설명합니다.

**Topics**
+ [Amazon Glacier에 아카이브를 업로드하기 위한 옵션](#uploading-an-archive-overview)
+ [아카이브의 단일 작업 업로드](uploading-archive-single-operation.md)
+ [대용량 아카이브를 여러 파트로 나누어 업로드(멀티파트 업로드)](uploading-archive-mpu.md)

## Amazon Glacier에 아카이브를 업로드하기 위한 옵션
<a name="uploading-an-archive-overview"></a>

Amazon Glacier는 업로드하는 데이터의 크기에 따라 다음과 같은 옵션을 제공합니다.
+ **아카이브의 단일 작업 업로드**: 크기가 1바이트에서 최대 4GB인 아카이브는 단일 작업으로 업로드할 수 있습니다. 하지만 Amazon Glacier 고객이 100MB가 넘는 대용량 아카이브를 업로드할 때는 멀티파트 업로드 기능을 사용할 것을 권장합니다. 자세한 내용은 [아카이브의 단일 작업 업로드](uploading-archive-single-operation.md) 단원을 참조하십시오.
+ **아카이브의 멀티파트 업로드**: 최대 40,000GB(10,000\$14GB)의 대용량 아카이브는 멀티파트 업로드 API를 사용하여 업로드할 수 있습니다.

  멀티파트 업로드 API 호출은 대용량 아카이브의 업로드 경험을 개선할 목적으로 설계되었습니다. 여기에서는 아카이브를 여러 파트로 나누어 업로드할 수 있습니다. 이러한 파트들은 순서에 상관없이 각각 병렬 방식으로 업로드됩니다. 멀티파트 업로드가 오류로 중단되더라도 전체 아카이브가 아니라 중단된 파트만 다시 업로드하면 됩니다. 멀티파트 업로드는 크기가 1바이트에서 약 40,000GB에 이르는 아카이브에 사용할 수 있습니다. 자세한 내용은 [대용량 아카이브를 여러 파트로 나누어 업로드(멀티파트 업로드)](uploading-archive-mpu.md) 단원을 참조하십시오.

**중요**  
Amazon Glacier 볼트 인벤토리는 하루 한 번 업데이트됩니다. 따라서 아카이브를 업로드한다고 해서 새로운 아카이브가 볼트에 바로 추가되어 콘솔이나 다운로드한 볼트 인벤토리 목록에 표시되지는 않습니다. 먼저 볼트 인벤토리가 업데이트되어야 합니다.

### AWS Snowball Edge 서비스 사용
<a name="using-import-export-service-for-glacier"></a>

AWS Snowball Edge 는 인터넷을 우회하여 Amazon 소유 디바이스를 AWS 사용하여 대량의 데이터를 송수신하는 속도를 높입니다. 자세한 내용은 [AWS Snowball Edge](https://aws.amazon.com/snowball) 세부 정보 페이지를 참조하세요.

기존 데이터를 Amazon Glacier(Amazon Glacier)에 업로드하려면 AWS Snowball Edge 디바이스 유형 중 하나를 사용해서 데이터를 Amazon S3로 가져온 다음, 수명 주기 규칙을 사용하여 아카이브용 Amazon Glacier 스토리지 클래스로 이동하는 것을 고려해 볼 수 있습니다. Amazon S3 객체를 Amazon Glacier 스토리지 클래스로 전환하면, Amazon S3가 내부적으로 Amazon Glacier를 사용하여 보다 저렴한 비용으로 내구성 있는 보관이 가능합니다. 객체가 Amazon Glacier에 저장되어 있지만 이들은 여전히 사용자가 Amazon S3에서 관리하는 Amazon S3 객체이며, 사용자가 Amazon Glacier를 통해 직접 액세스할 수는 없습니다.

Amazon S3 수명 주기 구성 및 Amazon Glacier 스토리지 클래스로의 객체 전환에 대한 자세한 내용은 *Amazon Simple Storage Service 사용 설명서*의 [객체 수명 주기 관리](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) 및 [객체 전환](https://docs.aws.amazon.com/AmazonS3/latest/userguide/lifecycle-transition-general-considerations.html)을 참조하세요.

# 아카이브의 단일 작업 업로드
<a name="uploading-archive-single-operation"></a>

[Amazon Glacier에 아카이브 업로드](uploading-an-archive.md) 섹션에서 설명한 것과 같이 더 작은 크기의 아카이브도 단일 작업으로 업로드할 수 있습니다. 하지만 Amazon Glacier(Amazon Glacier) 고객이 100MB가 넘는 대용량 아카이브를 업로드할 때는 멀티파트 업로드 기능을 사용하는 것이 권장됩니다.

**Topics**
+ [를 사용하여 아카이브를 단일 작업으로 업로드 AWS Command Line Interface](uploading-an-archive-single-op-using-cli.md)
+ [를 사용하여 아카이브를 단일 작업으로 업로드 AWS SDK for Java](uploading-an-archive-single-op-using-java.md)
+ [Amazon Glacier에서를 사용하여 아카이브를 단일 작업 AWS SDK for .NET 으로 업로드](uploading-an-archive-single-op-using-dotnet.md)
+ [REST API를 사용하여 아카이브의 단일 작업 업로드](uploading-an-archive-single-op-using-rest.md)

# 를 사용하여 아카이브를 단일 작업으로 업로드 AWS Command Line Interface
<a name="uploading-an-archive-single-op-using-cli"></a>

 AWS Command Line Interface ()를 사용하여 Amazon Glacier(Amazon Glacier)에 아카이브를 업로드할 수 있습니다AWS CLI.

**Topics**
+ [(사전 조건) 설정 AWS CLI](#Creating-Vaults-CLI-Setup)
+ [예:를 사용하여 아카이브 업로드 AWS CLI](#Uploading-Archives-CLI-Implementation)

## (사전 조건) 설정 AWS CLI
<a name="Creating-Vaults-CLI-Setup"></a>

1.  AWS CLI를 다운로드하고 구성합니다. 관련 지침은 *AWS Command Line Interface 사용 설명서*에서 다음 토픽을 참조하세요.

    [설치 AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) 

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

1. 명령 프롬프트에 다음 명령을 입력하여 AWS CLI 설정을 확인합니다. 이러한 명령은 명시적으로 자격 증명을 제공하지 않으므로 기본 프로파일의 자격 증명이 사용됩니다.
   + help 명령을 사용해 보십시오.

     ```
     aws help
     ```
   + 구성된 계정의 Amazon Glacier 볼트 목록을 가져오려면 `list-vaults` 명령을 사용합니다. *123456789012*을 AWS 계정 ID로 바꿉니다.

     ```
     aws glacier list-vaults --account-id 123456789012
     ```
   + 에 대한 현재 구성 데이터를 보려면 `aws configure list` 명령을 AWS CLI사용합니다.

     ```
     aws configure list
     ```

## 예:를 사용하여 아카이브 업로드 AWS CLI
<a name="Uploading-Archives-CLI-Implementation"></a>

아카이브를 업로드하려면 반드시 볼트를 생성해야 합니다. 볼트 생성에 대한 자세한 내용은 [Amazon Glacier에 볼트 생성](creating-vaults.md) 섹션을 참조하세요.

1. `upload-archive` 명령을 사용하여 기존 볼트에 아카이브를 추가합니다. 아래 예시에서는 `vault name` 및 `account ID`를 바꿉니다. `body` 파라미터에서 업로드하려는 파일의 경로를 지정합니다.

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

1.  예상 결과:

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

   완료되면 명령이 아카이브 ID, 체크섬 및 Amazon Glacier 내의 위치를 출력합니다. upload-archive 명령에 대한 자세한 내용은 *AWS CLI 명령 참조*의 [upload-archive](https://docs.aws.amazon.com/cli/latest/reference/glacier/upload-archive.html)를 참조하세요.

# 를 사용하여 아카이브를 단일 작업으로 업로드 AWS SDK for Java
<a name="uploading-an-archive-single-op-using-java"></a>

Amazon SDK for Java에서 제공하는 [하이레벨 및 로우레벨 API](using-aws-sdk.md) 둘 모두는 아카이브를 업로드하는 방법을 제공합니다.

**Topics**
+ [의 상위 수준 API를 사용하여 아카이브 업로드 AWS SDK for Java](#uploading-an-archive-single-op-high-level-using-java)
+ [의 하위 수준 API를 사용하여 단일 작업으로 아카이브 업로드 AWS SDK for Java](#uploading-an-archive-single-op-low-level-using-java)

## 의 상위 수준 API를 사용하여 아카이브 업로드 AWS SDK for Java
<a name="uploading-an-archive-single-op-high-level-using-java"></a>

하이레벨 API의 `ArchiveTransferManager` 클래스는 아카이브를 볼트에 업로드하는 데 사용할 수 있는 `upload` 메서드를 제공합니다.

 

**참고**  
`upload` 메서드는 작든 크든 상관없이 모든 아카이브를 업로드하는 데 사용됩니다. 이 메서드는 업로드하는 아카이브 크기에 따라 아카이브를 단일 작업으로 업로드할지, 혹은 멀티파트 업로드 API를 사용해 아카이브를 여러 파트로 나누어 업로드할지 결정합니다.

### 예:의 상위 수준 API를 사용하여 아카이브 업로드 AWS SDK for Java
<a name="upload-archive-high-level-java-example"></a>

다음은 미국 서부(오레곤) 리전(`us-west-2`)의 볼트(`examplevault`)에 아카이브를 업로드하는 Java 코드 예시입니다. 지원되는 AWS 리전 및 엔드포인트 목록은 섹션을 참조하세요[Amazon Glacier 액세스](amazon-glacier-accessing.md).

이 예제의 실행 방법에 대한 단계별 지침은 [Eclipse를 사용하여 Amazon Glacier의 Java 예 실행](using-aws-sdk-for-java.md#setting-up-and-testing-sdk-java) 섹션을 참조하세요. 아래와 같이 업로드할 볼트 이름과 파일 이름을 사용해 코드를 업데이트해야 합니다.

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

## 의 하위 수준 API를 사용하여 단일 작업으로 아카이브 업로드 AWS SDK for Java
<a name="uploading-an-archive-single-op-low-level-using-java"></a>

로우레벨 API는 모든 아카이브 작업에 필요한 메서드를 제공합니다. 다음은 AWS SDK for Java를 사용하여 아카이브를 업로드하는 단계입니다.

 

1. `AmazonGlacierClient` 클래스(클라이언트)의 인스턴스를 만듭니다.

   아카이브를 업로드할 AWS 리전을 지정해야 합니다. 이 클라이언트를 사용하여 수행하는 모든 작업은 해당 AWS 리전에 적용됩니다.

1. `UploadArchiveRequest` 클래스 인스턴스를 생성하여 요청 정보를 입력합니다.

   업로드할 데이터 외에도 페이로드의 체크섬(SHA256 트리-해시), 볼트 이름, 데이터의 내용 길이, 계정 ID를 입력해야 합니다.

   계정 ID를 입력하지 않는 경우에는 요청 서명을 위해 입력하는 자격 증명과 연결되어 있는 계정 ID로 간주합니다. 자세한 내용은 [Amazon Glacier AWS SDK for Java 에서 사용](using-aws-sdk-for-java.md) 단원을 참조하십시오.

1. 요청 객체를 파라미터로 입력하여 `uploadArchive` 메서드를 실행합니다.

   그러면 Amazon Glacier(Amazon Glacier)가 응답으로 새롭게 업로드된 아카이브의 ID를 반환합니다.

다음은 위에서 설명한 단계를 나타내는 Java 코드 조각입니다.

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

### 예:의 하위 수준 API를 사용하여 단일 작업으로 아카이브 업로드 AWS SDK for Java
<a name="uploding-single-archive-using-java-example"></a>

다음 Java 코드 예제에서는 AWS SDK for Java 를 사용하여 아카이브를 볼트()에 업로드합니다`examplevault`. 이 예제의 실행 방법에 대한 단계별 지침은 [Eclipse를 사용하여 Amazon Glacier의 Java 예 실행](using-aws-sdk-for-java.md#setting-up-and-testing-sdk-java) 섹션을 참조하세요. 아래와 같이 업로드할 볼트 이름과 파일 이름을 사용해 코드를 업데이트해야 합니다.

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

# Amazon Glacier에서를 사용하여 아카이브를 단일 작업 AWS SDK for .NET 으로 업로드
<a name="uploading-an-archive-single-op-using-dotnet"></a>

.NET용 Amazon SDK에서 제공하는 [하이레벨 및 로우레벨 API](using-aws-sdk.md) 둘 모두는 단일 작업으로 아카이브를 업로드하는 방법을 제공합니다.

**Topics**
+ [의 상위 수준 API를 사용하여 아카이브 업로드 AWS SDK for .NET](#uploading-an-archive-single-op-highlevel-using-dotnet)
+ [의 하위 수준 API를 사용하여 단일 작업으로 아카이브 업로드 AWS SDK for .NET](#uploading-an-archive-single-op-lowlevel-using-dotnet)

## 의 상위 수준 API를 사용하여 아카이브 업로드 AWS SDK for .NET
<a name="uploading-an-archive-single-op-highlevel-using-dotnet"></a>

하이레벨 API의 `ArchiveTransferManager` 클래스는 아카이브를 볼트에 업로드하는 데 사용할 수 있는 `Upload` 메서드를 제공합니다.

**참고**  
`Upload` 메서드는 작든 크든 상관없이 모든 파일을 업로드하는 데 사용됩니다. 이 메서드는 업로드하는 파일 크기에 따라 아카이브를 단일 작업으로 업로드할지, 혹은 멀티파트 업로드 API를 사용해 파일을 여러 파트로 나누어 업로드할지 결정합니다.

### 예:의 상위 수준 API를 사용하여 아카이브 업로드 AWS SDK for .NET
<a name="upload-archive-highlevel-any-size-dotnet"></a>

다음은 미국 서부(오레곤) 리전의 볼트(`examplevault`)에 아카이브를 업로드하는 C\$1 코드 예시입니다.

이 예제의 실행 방법에 대한 단계별 지침은 [코드 예제 실행](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet) 섹션을 참조하세요. 아래와 같이 업로드할 파일 이름을 사용해 코드를 업데이트해야 합니다.

**Example**  

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

namespace glacier.amazon.com.rproxy.govskope.us.docsamples
{
  class ArchiveUploadHighLevel
  {
    static string vaultName = "examplevault"; 
    static string archiveToUpload = "*** Provide file name (with full path) to upload ***";

    public static void Main(string[] args)
    {
       try
      {
         var manager = new ArchiveTransferManager(Amazon.RegionEndpoint.USWest2);
         // Upload an archive.
         string archiveId = manager.Upload(vaultName, "upload archive test", archiveToUpload).ArchiveId;
         Console.WriteLine("Archive ID: (Copy and save this ID for use in other examples.) : {0}", archiveId);
         Console.WriteLine("To continue, press Enter"); 
         Console.ReadKey();
      }
      catch (AmazonGlacierException e) { Console.WriteLine(e.Message); }
      catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
      catch (Exception e) { Console.WriteLine(e.Message); }
      Console.WriteLine("To continue, press Enter");
      Console.ReadKey();
    }
  }
}
```

## 의 하위 수준 API를 사용하여 단일 작업으로 아카이브 업로드 AWS SDK for .NET
<a name="uploading-an-archive-single-op-lowlevel-using-dotnet"></a>

로우레벨 API는 모든 아카이브 작업에 필요한 메서드를 제공합니다. 다음은 AWS SDK for .NET를 사용하여 아카이브를 업로드하는 단계입니다.

 

1. `AmazonGlacierClient` 클래스(클라이언트)의 인스턴스를 만듭니다.

   아카이브를 업로드할 AWS 리전을 지정해야 합니다. 이 클라이언트를 사용하여 수행하는 모든 작업은 해당 AWS 리전에 적용됩니다.

1. `UploadArchiveRequest` 클래스 인스턴스를 생성하여 요청 정보를 입력합니다.

   업로드할 데이터 외에도 페이로드의 체크섬(SHA256 트리-해시), 볼트 이름, 계정 ID 등을 입력해야 합니다.

   계정 ID를 입력하지 않는 경우에는 요청 서명을 위해 입력하는 자격 증명과 연결되어 있는 계정 ID로 간주합니다. 자세한 내용은 [Amazon Glacier와 함께 AWS SDK for .NET 사용](using-aws-sdk-for-dot-net.md) 단원을 참조하십시오.

1. 요청 객체를 파라미터로 입력하여 `UploadArchive` 메서드를 실행합니다.

   Amazon Glacier가 응답으로 새롭게 업로드된 아카이브 ID를 반환합니다.

### 예:의 하위 수준 API를 사용하여 단일 작업으로 아카이브 업로드 AWS SDK for .NET
<a name="upload-archive-single-op-lowlevel-dotnet"></a>

다음 C\$1 코드 예제에서는 이전 단계를 설명합니다. 이 예제에서는 AWS SDK for .NET 를 사용하여 아카이브를 볼트()에 업로드합니다`examplevault`.

**참고**  
아카이브를 단일 작업으로 업로드하는 기본 REST API에 대한 자세한 내용은 [아카이브 업로드(POST archive)](api-archive-post.md) 섹션을 참조하세요.

이 예제의 실행 방법에 대한 단계별 지침은 [코드 예제 실행](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet) 섹션을 참조하세요. 아래와 같이 업로드할 파일 이름을 사용해 코드를 업데이트해야 합니다.

**Example**  

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

namespace glacier.amazon.com.rproxy.govskope.us.docsamples
{
  class ArchiveUploadSingleOpLowLevel
  {
    static string vaultName       = "examplevault";
    static string archiveToUpload = "*** Provide file name (with full path) to upload ***";

    public static void Main(string[] args)
    {
      AmazonGlacierClient client;
      try
      {
         using (client = new AmazonGlacierClient(Amazon.RegionEndpoint.USWest2))
        {
          Console.WriteLine("Uploading an archive.");
          string archiveId = UploadAnArchive(client);
          Console.WriteLine("Archive ID: {0}", archiveId);
        }
      }
      catch (AmazonGlacierException e) { Console.WriteLine(e.Message); }
      catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
      catch (Exception e) { Console.WriteLine(e.Message); }
      Console.WriteLine("To continue, press Enter");
      Console.ReadKey();
    }

    static string UploadAnArchive(AmazonGlacierClient client)
    {
      using (FileStream fileStream = new FileStream(archiveToUpload, FileMode.Open, FileAccess.Read))
      {
        string treeHash = TreeHashGenerator.CalculateTreeHash(fileStream);
        UploadArchiveRequest request = new UploadArchiveRequest()
        {
          VaultName = vaultName,
          Body = fileStream,
          Checksum = treeHash
        };
        UploadArchiveResponse response = client.UploadArchive(request);
        string archiveID = response.ArchiveId;
        return archiveID;
      }
    }
  }
}
```

# REST API를 사용하여 아카이브의 단일 작업 업로드
<a name="uploading-an-archive-single-op-using-rest"></a>

아카이브 업로드 API 호출을 통해 아카이브를 단일 작업으로 업로드할 수 있습니다. 자세한 내용은 [아카이브 업로드(POST archive)](api-archive-post.md) 섹션을 참조하세요.

# 대용량 아카이브를 여러 파트로 나누어 업로드(멀티파트 업로드)
<a name="uploading-archive-mpu"></a>

**Topics**
+ [멀티파트 업로드 프로세스](#MPUprocess)
+ [주요 사양](#qfacts)
+ [를 사용하여 대용량 아카이브 업로드 AWS CLI](uploading-an-archive-mpu-using-cli.md)
+ [Amazon SDK for Java를 사용하여 대용량 아카이브를 파트로 나누어 업로드](uploading-an-archive-mpu-using-java.md)
+ [를 사용하여 대용량 아카이브 업로드 AWS SDK for .NET](uploading-an-archive-mpu-using-dotnet.md)
+ [REST API를 사용하는 대용량 아카이브의 멀티파트 업로드](uploading-an-archive-mpu-using-rest.md)

## 멀티파트 업로드 프로세스
<a name="MPUprocess"></a>

[Amazon Glacier에 아카이브 업로드](uploading-an-archive.md)에서 설명한 바와 같이 Amazon Glacier(Amazon Glacier) 고객이 100메비바이트(MiB)가 넘는 대용량 아카이브를 업로드할 때는 멀티파트 업로드 기능을 사용하는 것을 권장합니다.

1. **멀티파트 업로드 시작** 

   멀티파트 업로드 시작 요청을 전송하면 Amazon Glacier가 멀티파트 업로드를 위한 고유 식별자인 업로드 멀티파트 업로드 ID를 반환합니다. 이후로 멀티파트 업로드 작업을 이어가려면 이 ID가 필요합니다. 이 ID는 Amazon Glacier가 작업을 완료한 후 최소 24시간 동안 만료되지 않습니다.

   멀티파트 업로드를 시작하는 요청에서 파트 크기(바이트 수)를 지정합니다. 마지막 파트를 제외하고 업로드하는 파트는 각각 여기에서 지정하는 크기를 따라야 합니다.
**참고**  
멀티파트 업로드를 사용할 때 전체 아카이브 크기를 알 필요는 없습니다. 즉, 아카이브 업로드를 시작할 때 아카이브 크기를 모르더라도 멀티파트 업로드를 사용할 수 있습니다. 멀티파트 업로드를 시작할 때 파트 크기만 결정하면 됩니다.

   멀티파트 업로드 요청을 시작할 때 선택적으로 아카이브 설명을 입력할 수도 있습니다.

1. **파트 업로드**

   각 파트의 업로드 요청마다 1단계에서 얻은 멀티파트 업로드 ID를 추가해야 합니다. 요청에서 최종 아카이브의 파트 위치를 식별할 수 있도록 내용 범위를 바이트로 지정해야 합니다. Amazon Glacier는 추후에 콘텐츠 범위 정보를 사용하여 아카이브를 적절한 순서로 조립합니다. 업로드하는 파트마다 내용 범위를 입력하면 최종 아카이브 어셈블리에서 파트 위치를 결정하기 때문에 어떤 순서로든 파트를 업로드할 수 있습니다. 또한 병렬 방식으로 파트를 업로드하는 것도 가능합니다. 이전에 업로드한 파트와 동일한 내용 범위로 새로운 파트를 업로드할 경우에는 이전에 업로드한 파트를 덮어쓰게 됩니다.

1. **멀티파트 업로드 완료(또는 중단)**

   아카이브 파트를 모두 업로드한 후에는 완료 작업을 시작합니다. 반드시 요청에 업로드 ID를 지정해야 합니다. Amazon Glacier는 사용자가 제공한 콘텐츠 범위를 바탕으로 오름차순으로 각 부분을 연결하여 아카이브를 생성합니다. 멀티파트 업로드 완료 요청에 대한 Amazon Glacier 응답에는 새로 생성된 아카이브의 아카이브 ID가 포함됩니다. 멀티파트 업로드 시작 요청에서 선택적으로 아카이브 설명을 입력하였다면 Amazon Glacier가 어셈블링된 아카이브에 설명을 연결합니다. 멀티파트 업로드가 성공적으로 완료된 후에는 멀티파트 업로드 ID를 참조할 수 없습니다. 이 말은 멀티파트 업로드 ID로 연결된 파트에 액세스할 수 없다는 것을 의미합니다.

   멀티파트 업로드를 중단한 경우 해당 멀티파트 업로드 ID로는 더 이상 파트를 업로드할 수 없습니다. 중단된 멀티파트 업로드로 연결된 파트가 차지하는 스토리지는 모두 비워집니다. 파트 업로드가 진행 중일 때 진행 중인 파트 업로드는 성공적으로 완료되거나, 혹은 오류로 멈출 수도 있습니다.

### 추가 멀티파트 업로드 작업
<a name="additional-mpu-operations"></a>

Amazon Glacier(Amazon Glacier)는 다음과 같은 멀티파트 업로드 API 직접 호출을 추가적으로 제공합니다.

 
+ **파트 나열**: 이 작업을 사용하면 특정 멀티파트 업로드의 파트를 나열할 수 있습니다. 그러면 멀티파트 업로드로 업로드한 파트의 정보가 반환됩니다. 파트 나열 요청이 있을 때마다 Amazon Glacier는 최대 1,000개까지 파트 정보를 반환합니다. 멀티파트 업로드에 대해 목록을 조회할 파트가 더 있는 경우에는 결과에 페이지 번호가 매겨지고, 응답으로 목록을 계속 이어가는 마커가 반환됩니다. 이후 파트를 가져오려면 추가 요청을 보내야 합니다. 반환된 부분 목록에는 업로드가 완료되지 않은 부분은 포함되지 않습니다.
+ **멀티파트 업로드 나열**: 이 작업을 사용하여 진행 중인 멀티파트 업로드의 목록을 확인할 수 있습니다. 진행 중인 멀티파트 업로드는 시작했지만 아직 완료 또는 중단하지 않은 업로드입니다. 멀티파트 업로드 목록 조회 요청이 있을 때마다 Amazon Glacier는 최대 1,000개까지 멀티파트 업로드를 반환합니다. 목록을 조회할 멀티파트 업로드가 더 있는 경우에는 결과에 페이지 번호가 매겨지고, 응답으로 목록을 계속 이어가는 마커가 반환됩니다. 나머지 멀티파트 업로드를 가져오려면 추가 요청을 보내야 합니다.

## 주요 사양
<a name="qfacts"></a>

다음 표에 멀티파트 업로드의 주요 사양이 나와 있습니다.


| 항목 | 사양 | 
| --- | --- | 
| 최대 아카이브 크기 | 10,000x4기비바이트(GiB)  | 
| 업로드당 최대 파트 개수 | 10,000 | 
| 파트 크기 | 1MiB에서 4GiB까지, 마지막 파트는 1MiB 미만일 수도 있습니다. 크기 값은 바이트 단위로 지정합니다. 파트 크기는 2의 제곱이 곱해진 메비바이트(1024키비바이트[KiB]) 값이어야 합니다. 예를 들어 `1048576`(1MiB), `2097152`(2MiB), `4194304`(4MiB), `8388608`(8MiB)등과 같습니다.  | 
| 파트 목록 조회 요청에 대해 반환되는 최대 파트 개수 | 1,000  | 
| 멀티파트 업로드 나열 요청에서 반환되는 최대 멀티파트 업로드 개수 | 1,000  | 

# 를 사용하여 대용량 아카이브 업로드 AWS CLI
<a name="uploading-an-archive-mpu-using-cli"></a>

 AWS Command Line Interface ()를 사용하여 Amazon Glacier(Amazon Glacier)에 아카이브를 업로드할 수 있습니다AWS CLI. 대규모 아카이브의 업로드 환경을 개선하기 위해, Amazon Glacier는 멀티파트 업로드를 지원하는 여러 API 작업을 제공합니다. 이 API 작업을 사용하여 아카이브를 파트로 나누어 업로드할 수 있습니다. 이러한 파트들은 순서에 상관없이 각각 병렬 방식으로 업로드됩니다. 멀티파트 업로드에 실패하더라도 전체 아카이브가 아니라 실패한 파트만 다시 업로드하면 됩니다. 멀티파트 업로드는 크기가 1바이트에서 약 40,000기비바이트(GiB)에 이르는 아카이브에 사용할 수 있습니다.

Amazon Glacier 멀티파트 업로드에 대한 자세한 내용은 [대용량 아카이브를 여러 파트로 나누어 업로드(멀티파트 업로드)](uploading-archive-mpu.md) 섹션을 참조하세요.

**Topics**
+ [(사전 조건) 설정 AWS CLI](#Creating-Vaults-CLI-Setup)
+ [(요구 사항) Python 설치](#Uploading-Archives-mpu-CLI-Install-Python)
+ [(요구 사항) Amazon Glacier 볼트 생성](#Uploading-Archives-mpu-CLI-Create-Vault)
+ [예:를 사용하여 대용량 아카이브를 파트로 업로드 AWS CLI](#Uploading-Archives-mpu-CLI-Implementation)

## (사전 조건) 설정 AWS CLI
<a name="Creating-Vaults-CLI-Setup"></a>

1.  AWS CLI를 다운로드하고 구성합니다. 관련 지침은 *AWS Command Line Interface 사용 설명서*에서 다음 토픽을 참조하세요.

    [설치 AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) 

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

1. 명령 프롬프트에 다음 명령을 입력하여 AWS CLI 설정을 확인합니다. 이러한 명령은 명시적으로 자격 증명을 제공하지 않으므로 기본 프로파일의 자격 증명이 사용됩니다.
   + help 명령을 사용해 보십시오.

     ```
     aws help
     ```
   + 구성된 계정의 Amazon Glacier 볼트 목록을 가져오려면 `list-vaults` 명령을 사용합니다. *123456789012*을 AWS 계정 ID로 바꿉니다.

     ```
     aws glacier list-vaults --account-id 123456789012
     ```
   + 에 대한 현재 구성 데이터를 보려면 `aws configure list` 명령을 AWS CLI사용합니다.

     ```
     aws configure list
     ```

## (요구 사항) Python 설치
<a name="Uploading-Archives-mpu-CLI-Install-Python"></a>

멀티파트 업로드를 완료하려면 업로드 중인 아카이브의 SHA256 트리 해시를 반드시 계산해야 합니다. 이 작업은 업로드를 원하는 파일의 SHA256 트리 해시를 계산하는 것과 다릅니다. 업로드 중인 아카이브의 SHA256 트리 해시를 계산할 때 Java, C\$1(.NET와 함께) 또는 Python을 사용할 수 있습니다. 이 예시에서는 Python을 사용합니다. Java 또는 C\$1을 사용하는 방법 지침은 [체크섬 계산](checksum-calculations.md) 섹션을 참조하세요.

Python을 설치하는 방법에 대한 자세한 내용은 *Boto3 개발자 가이드*의 [Python 설치 또는 업데이트](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html#installation)를 참조하세요.

## (요구 사항) Amazon Glacier 볼트 생성
<a name="Uploading-Archives-mpu-CLI-Create-Vault"></a>

다음 예시를 사용하려면 적어도 하나 이상의 Amazon Glacier 볼트가 생성되어 있어야 합니다. 볼트 생성에 대한 자세한 내용은 [Amazon Glacier에 볼트 생성](creating-vaults.md) 섹션을 참조하세요.

## 예:를 사용하여 대용량 아카이브를 파트로 업로드 AWS CLI
<a name="Uploading-Archives-mpu-CLI-Implementation"></a>

이 예시에서는 파일을 생성하고 멀티파트 업로드 API 작업을 사용하여 이 파일을 여러 파트로 나누어 Amazon Glacier에 업로드합니다.
**중요**  
이 과정을 시작하기 전에 요구 사항 단계를 모두 수행했는지 확인합니다. 아카이브를 업로드하려면 반드시 볼트가 생성되어 있고 AWS CLI 가 구성되어 있어야 하며 Java, C\$1, 또는 Python을 사용하여 SHA256 트리 해시를 계산할 준비가 되어있어야 합니다.

다음 절차에서는 `initiate-multipart-upload`, `upload-multipart-part`및 `complete-multipart-upload` AWS CLI 명령을 사용합니다.

이 명령에 대한 자세한 내용은 **AWS CLI 명령 참조의 [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), [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) 섹션을 참조하세요.

1. [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) 명령을 사용하여 멀티파트 업로드 리소스를 생성합니다. 요청에서 파트 크기를 바이트 수로 지정합니다. 마지막 파트를 제외하고 사용자가 업로드한 파트는 여기에서 지정하는 크기를 따라야 합니다. 멀티파트 업로드를 시작할 때 전체 아카이브 크기를 알 필요는 없습니다. 하지만 최종 단계에서 업로드를 완료할 때는 각 파트의 총 크기가 바이트로 필요합니다.

   다음 명령에서 `--vault-name` 및 `--account-ID` 파라미터의 값을 사용자의 정보로 바꿉니다. 이 명령은 파트 크기가 파일당 1메비바이트(MiB)(1024 x 1024바이트)인 아카이브를 업로드하도록 지정합니다. 필요한 경우 이 `--part-size` 파라미터 값을 바꾸세요.

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

   예상 결과:

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

   완료되면 이 명령은 멀티파트 업로드 리소스의 업로드 ID와 Amazon Glacier 내의 위치를 출력합니다. 이후 단계에서 이 업로드 ID를 사용합니다.

1. 이 예시에서는 다음 명령을 사용하여 4.4MiB 파일을 만들고 1MiB 청크로 분할한 다음 각 청크를 업로드할 수 있습니다. 자체 파일을 업로드하려면 데이터를 청크로 분할하고 각 파트를 업로드하는 비슷한 절차를 따를 수 있습니다.

   

**Linux 또는 macOS**  
다음 명령은 Linux 또는 macOS에서 `file_to_upload`로 이름이 지정된 4.4MiB 파일을 만듭니다.

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

**Windows**  
다음 명령은 Windows에서 `file_to_upload`로 이름이 지정된 4.4MiB 파일을 만듭니다.

   ```
   fsutil file createnew file_to_upload 4608000
   ```

1. 다음으로 이 파일을 1MiB 청크로 분할합니다.

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

   이제 다음과 같은 다섯 개의 청크가 있습니다. 처음 네 개는 1MiB이고 마지막 한 개는 약 400키비바이트(KiB)입니다.

   ```
   chunkaa
   chunkab
   chunkac
   chunkad
   chunkae
   ```

1. [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) 명령을 사용하여 아카이브의 파트를 업로드합니다. 아카이브를 파트를 어떤 순서로든 업로드할 수 있습니다. 또한 병렬 방식으로 파트를 업로드할 수도 있습니다. 멀티파트 업로드에서 업로드할 수 있는 파트 수는 최대 10,000개입니다.

   다음 명령에서 `--vault-name`, `--account-ID`, 및 `--upload-id` 파라미터 값을 바꿉니다. 업로드 ID는 `initiate-multipart-upload` 명령 출력으로 제공된 ID와 일치해야 합니다. `--range` 파라미터는 크기가 1MiB(1024 x 1024바이트)인 파트를 업로드하도록 지정합니다. 이 크기는 `initiate-multipart-upload` 명령에서 지정한 크기와 일치해야 합니다. 필요한 경우 크기 값을 조정하세요. `--body` 파라미터는 업로드하는 파트의 이름을 지정합니다.

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

   성공하면 명령에서 업로드된 파트의 체크섬이 포함된 출력이 생성됩니다.

1. `upload-multipart-part` 명령을 다시 실행하여 멀티파트 업로드의 나머지 파트를 업로드합니다. 업로드하는 부분과 일치하도록 각 명령의 `--range` 및 `–-body` 매개변수 값을 업데이트합니다.

   ```
   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
   ```
**참고**  
업로드의 마지막 부분이 1MiB 미만이므로 최종 명령의 `--range` 파라미터 값은 그보다 더 작습니다. 성공하면 각 명령에서 업로드된 각 부분에 대한 체크섬이 포함된 출력을 생성합니다.

1. 다음으로 아카이브를 조합하고 업로드를 완료합니다. 아카이브의 전체 크기와 SHA256 트리 해시를 반드시 포함해야 합니다.

   아카이브의 SHA256 트리 해시를 계산하기 위해서 Java, C\$1 또는 Python을 사용할 수 있습니다. 이 예시에서는 Python을 사용합니다. Java 또는 C\$1을 사용하는 방법 지침은 [체크섬 계산](checksum-calculations.md) 섹션을 참조하세요.

   Python 파일 `checksum.py`를 생성하고 다음 코드를 추가합니다. 필요한 경우 원본 파일의 이름을 바꾸세요.

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

1. `checksum.py`를 실행하여 SHA256 트리 해시를 계산합니다. 다음 해시는 출력과 일치하지 않을 수 있습니다.

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

1. [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) 명령을 사용하여 아카이브 업로드를 완료합니다. `--vault-name`, `--account-ID`, `--upload-ID`, 및 `--checksum` 파라미터의 값을 바꿉니다. `--archive` 파라미터 값은 아카이브의 전체 크기를 바이트로 지정합니다. 이 값은 반드시 업로드한 개별 파트 크기의 총합이 되어야 합니다. 필요한 경우 이 값을 바꾸세요.

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

   완료되면 명령이 아카이브의 ID, 체크섬 및 Amazon Glacier 내의 위치를 출력합니다.

# Amazon SDK for Java를 사용하여 대용량 아카이브를 파트로 나누어 업로드
<a name="uploading-an-archive-mpu-using-java"></a>

Amazon SDK for Java에서 제공하는 [하이레벨 및 로우레벨 API](using-aws-sdk.md) 둘 모두는 대규모 아카이브를 업로드하는 방법을 제공합니다([Amazon Glacier에 아카이브 업로드](uploading-an-archive.md) 섹션 참조).

 
+ 하이레벨 API는 모든 크기의 아카이브를 업로드하는 데 사용할 수 있는 방법을 제공합니다. 이 방법은 업로드하는 파일에 따라 아카이브를 단일 작업으로 업로드하거나, 혹은 Amazon Glacier(Amazon Glacier)에서 지원되는 멀티파트 업로드 기능을 사용해 아카이브를 여러 파트로 나누어 업로드합니다.
+ 로우레벨 API는 기본 REST 구현에 가깝게 매핑합니다. 따라서 더욱 작은 크기의 아카이브를 단일 작업으로 업로드하는 방법을 제공하거나, 혹은 대용량 아카이브의 경우 멀티파트 업로드를 지원하는 방법 그룹을 제공합니다. 이 섹션에서는 로우레벨 API를 사용하는 대용량 아카이브의 멀티파트 업로드에 대해서 설명합니다.

하이레벨 및 로우레벨 API에 대한 자세한 내용은 [Amazon Glacier AWS SDK for Java 에서 사용](using-aws-sdk-for-java.md) 섹션을 참조하세요.

**Topics**
+ [의 상위 수준 API를 사용하여 대용량 아카이브를 파트로 업로드 AWS SDK for Java](#uploading-an-archive-in-parts-highlevel-using-java)
+ [의 하위 수준 API를 사용하여 대용량 아카이브를 파트로 업로드 AWS SDK for Java](#uploading-an-archive-mpu-using-java-lowlevel)

## 의 상위 수준 API를 사용하여 대용량 아카이브를 파트로 업로드 AWS SDK for Java
<a name="uploading-an-archive-in-parts-highlevel-using-java"></a>

작든 크든 상관없이 하이레벨 API를 사용하여 아카이브를 업로드하는 방법은 동일합니다. 다만 하이레벨 API 방법은 아카이브 크기에 따라 아카이브를 단일 작업으로 업로드할지 아니면 Amazon Glacier에서 제공하는 멀티파트 업로드 API를 사용할지 결정합니다. 자세한 내용은 [의 상위 수준 API를 사용하여 아카이브 업로드 AWS SDK for Java](uploading-an-archive-single-op-using-java.md#uploading-an-archive-single-op-high-level-using-java) 단원을 참조하십시오.

## 의 하위 수준 API를 사용하여 대용량 아카이브를 파트로 업로드 AWS SDK for Java
<a name="uploading-an-archive-mpu-using-java-lowlevel"></a>

업로드를 세분화하여 제어할 때는 로우레벨 API를 사용하여 요청을 구성하고 응답을 처리할 수 있습니다. 다음은 AWS SDK for Java을 사용하여 대용량 아카이브를 여러 파트로 나누어 업로드하는 단계입니다.

 

1. `AmazonGlacierClient` 클래스(클라이언트)의 인스턴스를 만듭니다.

   아카이브를 저장할 AWS 리전을 지정해야 합니다. 이 클라이언트를 사용하여 수행하는 모든 작업은 해당 AWS 리전에 적용됩니다.

1. `initiateMultipartUpload` 메서드를 호출하여 멀티파트 업로드를 시작합니다.

   아카이브를 업로드할 볼트 이름과 아카이브를 여러 파트로 나누어 업로드하는 데 사용할 파트 크기, 그리고 설명(옵션)을 입력해야 합니다. `InitiateMultipartUploadRequest` 클래스의 인스턴스를 만들어 이 정보를 제공합니다. 그러면 Amazon Glacier가 응답으로 업로드 ID를 반환합니다.

1. `uploadMultipartPart` 메서드를 호출하여 각 파트를 업로드합니다.

   업로드하는 파트마다 볼트 이름, 현재 파트에서 업로드할 최종 아카이브의 바이트 범위, 파트 데이터의 체크섬, 그리고 업로드 ID를 입력해야 합니다.

1. `completeMultipartUpload` 메서드를 호출하여 멀티파트 업로드를 마칩니다.

   이때는 업로드 ID, 전체 아카이브의 체크섬, 아카이브 크기(업로드한 모든 파트의 총 크기), 그리고 볼트 이름을 입력해야 합니다. Amazon Glacier는 업로드된 파트부터 아카이브를 구성하여 아카이브 ID를 반환합니다.

### 예:를 사용하여 대용량 아카이브를 파트에 업로드 AWS SDK for Java
<a name="upload-archive-mpu-java-example"></a>

다음 Java 코드 예제에서는 AWS SDK for Java 를 사용하여 아카이브를 볼트()에 업로드합니다`examplevault`. 이 예제의 실행 방법에 대한 단계별 지침은 [Eclipse를 사용하여 Amazon Glacier의 Java 예 실행](using-aws-sdk-for-java.md#setting-up-and-testing-sdk-java) 섹션을 참조하세요. 아래와 같이 업로드할 파일 이름을 사용해 코드를 업데이트해야 합니다.

 

**참고**  
아래 예제는 파트 크기가 1MB\$11GB일 때 유효합니다. 하지만 Amazon Glacier는 최대 4GB 크기의 파트를 지원합니다.

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

# 를 사용하여 대용량 아카이브 업로드 AWS SDK for .NET
<a name="uploading-an-archive-mpu-using-dotnet"></a>

.NET용 Amazon SDK에서 제공하는 [하이레벨 및 로우레벨 API](using-aws-sdk.md) 둘 모두는 대규모 아카이브를 분할하여 업로드하는 방법을 제공합니다([Amazon Glacier에 아카이브 업로드](uploading-an-archive.md) 섹션 참조).

 
+ 하이레벨 API는 모든 크기의 아카이브를 업로드하는 데 사용할 수 있는 방법을 제공합니다. 이 방법은 업로드하는 파일에 따라 아카이브를 단일 작업으로 업로드하거나, 혹은 Amazon Glacier(Amazon Glacier)에서 지원되는 멀티파트 업로드 기능을 사용해 아카이브를 여러 파트로 나누어 업로드합니다.
+ 로우레벨 API는 기본 REST 구현에 가깝게 매핑합니다. 따라서 더욱 작은 크기의 아카이브를 단일 작업으로 업로드하는 방법을 제공하거나, 혹은 대용량 아카이브의 경우 멀티파트 업로드를 지원하는 방법 그룹을 제공합니다. 이 섹션에서는 로우레벨 API를 사용하는 대용량 아카이브의 멀티파트 업로드에 대해서 설명합니다.

하이레벨 및 로우레벨 API에 대한 자세한 내용은 [Amazon Glacier와 함께 AWS SDK for .NET 사용](using-aws-sdk-for-dot-net.md) 섹션을 참조하세요.

**Topics**
+ [의 상위 수준 API를 사용하여 대용량 아카이브를 파트로 업로드 AWS SDK for .NET](#uploading-an-archive-in-parts-highlevel-using-dotnet)
+ [의 하위 수준 API를 사용하여 대용량 아카이브를 파트로 업로드 AWS SDK for .NET](#uploading-an-archive-in-parts-lowlevel-using-dotnet)

## 의 상위 수준 API를 사용하여 대용량 아카이브를 파트로 업로드 AWS SDK for .NET
<a name="uploading-an-archive-in-parts-highlevel-using-dotnet"></a>

작든 크든 상관없이 하이레벨 API를 사용하여 아카이브를 업로드하는 방법은 동일합니다. 다만 하이레벨 API 방법은 아카이브 크기에 따라 아카이브를 단일 작업으로 업로드할지 아니면 Amazon Glacier에서 제공하는 멀티파트 업로드 API를 사용할지 결정합니다. 자세한 내용은 [의 상위 수준 API를 사용하여 아카이브 업로드 AWS SDK for .NET](uploading-an-archive-single-op-using-dotnet.md#uploading-an-archive-single-op-highlevel-using-dotnet) 단원을 참조하십시오.

## 의 하위 수준 API를 사용하여 대용량 아카이브를 파트로 업로드 AWS SDK for .NET
<a name="uploading-an-archive-in-parts-lowlevel-using-dotnet"></a>

업로드를 세분화하여 제어할 때는 로우레벨 API를 사용하여 요청을 구성하고 응답을 처리할 수 있습니다. 다음은 AWS SDK for .NET을 사용하여 대용량 아카이브를 여러 파트로 나누어 업로드하는 단계입니다.

 

1. `AmazonGlacierClient` 클래스(클라이언트)의 인스턴스를 만듭니다.

   아카이브를 저장할 AWS 리전을 지정해야 합니다. 이 클라이언트를 사용하여 수행하는 모든 작업은 해당 AWS 리전에 적용됩니다.

1. `InitiateMultipartUpload` 메서드를 호출하여 멀티파트 업로드를 시작합니다.

   아카이브를 업로드할 볼트 이름과 아카이브를 여러 파트로 나누어 업로드하는 데 사용할 파트 크기, 그리고 설명(옵션)을 입력해야 합니다. `InitiateMultipartUploadRequest` 클래스의 인스턴스를 만들어 이 정보를 제공합니다. 그러면 Amazon Glacier가 응답으로 업로드 ID를 반환합니다.

1. `UploadMultipartPart` 메서드를 호출하여 각 파트를 업로드합니다.

   업로드하는 파트마다 볼트 이름, 현재 파트에서 업로드할 최종 아카이브의 바이트 범위, 파트 데이터의 체크섬, 그리고 업로드 ID를 입력해야 합니다.

1. `CompleteMultipartUpload` 메서드를 호출하여 멀티파트 업로드를 마칩니다.

   업로드 ID, 전체 아카이브의 체크섬, 아카이브 크기(업로드한 모든 파트의 총 크기), 그리고 볼트 이름을 제공해야 합니다. Amazon Glacier는 업로드된 파트부터 아카이브를 구성하여 아카이브 ID를 반환합니다.

### 예: .NET용 Amazon SDK를 사용하여 대용량 아카이브를 파트로 나누어 업로드
<a name="upload-archive-mpu-dotnet-example"></a>

다음 C\$1 코드 예제에서는 AWS SDK for .NET 를 사용하여 아카이브를 볼트()에 업로드합니다`examplevault`. 이 예제의 실행 방법에 대한 단계별 지침은 [코드 예제 실행](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet) 섹션을 참조하세요. 아래와 같이 업로드할 파일 이름을 사용해 코드를 업데이트해야 합니다.

**Example**  

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

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

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

# REST API를 사용하는 대용량 아카이브의 멀티파트 업로드
<a name="uploading-an-archive-mpu-using-rest"></a>

[대용량 아카이브를 여러 파트로 나누어 업로드(멀티파트 업로드)](uploading-archive-mpu.md)에서 설명한 것과 같이 멀티파트 업로드는 아카이브를 여러 파트로 나누어 업로드하는 작업을 말하며 관련 작업을 수행합니다. 이러한 작업들에 대한 자세한 내용은 API 참조 항목을 참조하세요.

 
+ [멀티파트 업로드 시작(POST multipart-uploads)](api-multipart-initiate-upload.md)
+ [파트 업로드(PUT uploadID)](api-upload-part.md)
+ [멀티파트 업로드 완료(POST uploadID)](api-multipart-complete-upload.md)
+ [멀티파트 업로드 중단(DELETE uploadID)](api-multipart-abort-upload.md)
+ [파트 목록 조회(GET uploadID)](api-multipart-list-parts.md)
+ [멀티파트 업로드 목록 조회(GET multipart-uploads)](api-multipart-list-uploads.md)