**이 페이지는 볼트와 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 스토리지 클래스로 마이그레이션하는 것이 좋습니다.

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

# 3단계: 아카이브를 Amazon Glacier의 볼트에 업로드
<a name="getting-started-upload-archive"></a>

이번 단계에서는 샘플 아카이브를 이전 단계에서 생성한 볼트에 업로드합니다([2단계: Amazon Glacier에서 볼트 생성](getting-started-create-vault.md) 섹션 참조). 사용하는 개발 플랫폼에 따라 이번 섹션 끝에 있는 링크 중 하나를 클릭합니다.

**중요**  
업로드, 다운로드, 삭제 등 아카이브 작업에서는 AWS Command Line Interface (CLI)를 사용하거나 코드를 작성해야 합니다. 콘솔은 아카이브 작업을 지원하지 않습니다. 예를 들어 사진, 비디오 및 기타 문서와 같은 데이터를 업로드하려면 AWS CLI 를 사용하거나 REST API를 직접 사용하거나 AWS SDKs를 사용하여 요청 코드를 작성해야 합니다.  
를 설치하려면 단원을 AWS CLI참조하십시오[AWS Command Line Interface](https://aws.amazon.com/cli/). 에서 Amazon Glacier를 사용하는 방법에 대한 자세한 내용은 Amazon Glacier 참조 AWS CLI를 참조하세요. [AWS CLI Amazon Glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html) 를 사용하여 Amazon Glacier AWS CLI 에 아카이브를 업로드하는 예제는 [에서 Amazon Glacier 사용을 참조하세요 AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-glacier.html).

아카이브란 사진, 동영상, 문서 등 볼트에 저장되는 모든 객체를 말합니다. 아카이브는 Amazon Glacier에서 스토리지의 기본 단위입니다. 아카이브는 단일 요청으로 업로드할 수 있습니다. 대용량 아카이브일 경우에는 Amazon Glacier가 아카이브를 여러 파트로 나누어 업로드할 수 있도록 멀티파트 업로드 API 작업을 제공합니다.

이 섹션에서는 단일 요청으로 샘플 아카이브를 업로드합니다. 또한 크기가 작은 파일을 지정합니다. 파일 용량이 커지면 멀티파트 업로드가 적합합니다. 자세한 내용은 [대용량 아카이브를 여러 파트로 나누어 업로드(멀티파트 업로드)](uploading-archive-mpu.md) 단원을 참조하십시오.

**Topics**
+ [를 사용하여 Amazon Glacier의 볼트에 아카이브 업로드 AWS SDK for Java](getting-started-upload-archive-java.md)
+ [를 사용하여 Amazon Glacier의 볼트에 아카이브 업로드 AWS SDK for .NET](getting-started-upload-archive-dotnet.md)

# 를 사용하여 Amazon Glacier의 볼트에 아카이브 업로드 AWS SDK for Java
<a name="getting-started-upload-archive-java"></a>

다음 Java 코드 예제에서는의 상위 수준 API AWS SDK for Java 를 사용하여 샘플 아카이브를 볼트에 업로드합니다. 코드 예제에서 다음 사항에 유의합니다.
+ 코드 예제는 `AmazonGlacierClient` 클래스 인스턴스를 생성합니다.
+ 이 예시는 AWS SDK for Java의 하이레벨 API에서 `ArchiveTransferManager` 클래스의 `upload` API 작업을 사용합니다.
+ 이 예시는 미국 서부(오레곤) 리전(`us-west-2`)을 사용합니다.

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

**참고**  
Amazon Glacier는 모든 아카이브 인벤토리를 볼트에 저장합니다. 하지만 다음 예제에서 아카이브를 업로드하더라도 볼트 인벤토리가 업데이트되기 전까지는 관리 콘솔의 볼트에 업로드된 아카이브가 표시되지 않습니다. 볼트 인벤토리의 업데이트는 일반적으로 1일 1회 실행됩니다.

**SDK for Java 2.x**  
 GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/glacier#code-examples)에서 전체 예제를 찾고 설정 및 실행하는 방법을 배워보세요.

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

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

    static final int ONE_MB = 1024 * 1024;

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

                Usage:   <strPath> <vaultName>\s

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            int bytesRead;
            int idx = 0;

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

            return chunkSHA256Hashes;

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

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

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

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

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

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

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

            prevLvlHashes = currLvlHashes;
        }

        return prevLvlHashes[0];
    }

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

            if (hex.length() == 1) {
                // Append leading zero.
                sb.append("0");
            }
            sb.append(hex);
        }
        return sb.toString().toLowerCase();
    }
}
```
+  API 세부 정보는AWS SDK for Java 2.x API 참조의 [UploadArchive](https://docs.aws.amazon.com/goto/SdkForJavaV2/glacier-2012-06-01/UploadArchive)를 참조하세요.**

# 를 사용하여 Amazon Glacier의 볼트에 아카이브 업로드 AWS SDK for .NET
<a name="getting-started-upload-archive-dotnet"></a>

다음 C\$1 코드 예제에서는의 상위 수준 API AWS SDK for .NET 를 사용하여 샘플 아카이브를 볼트에 업로드합니다. 코드 예제에서 다음 사항에 유의합니다.

 
+ 이 예는 지정된 Amazon Glacier 리전 엔드포인트에 대한 `ArchiveTransferManager` 클래스 인스턴스를 생성합니다.
+ 이 코드 예는 미국 서부(오리건) 리전(`us-west-2`)을 사용합니다.
+ 이 코드 예는 `ArchiveTransferManager` 클래스의 `Upload` API 작업을 사용하여 아카이브를 업로드합니다. 아카이브 크기가 작은 경우에는 이 작업으로 아카이브를 직접 Amazon Glacier에 업로드합니다. 아카이브 크기가 큰 경우에는 이 작업에서 Amazon Glacier의 멀티파트 업로드 API 작업을 사용해 업로드를 여러 파트로 분할하기 때문에 데이터를 Amazon Glacier에 스트리밍하는 도중 오류가 발생하더라도 더욱 쉽게 복구할 수 있습니다.

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

**참고**  
Amazon Glacier는 모든 아카이브 인벤토리를 볼트에 저장합니다. 다음 예시에서 아카이브를 업로드하더라도 볼트 인벤토리가 업데이트되기 전까지는 관리 콘솔의 볼트에 아카이브가 나타나지 않습니다. 볼트 인벤토리의 업데이트는 일반적으로 1일 1회 실행됩니다.

**Example -의 상위 수준 API를 사용하여 아카이브 업로드 AWS SDK for .NET**  <a name="GS_ExampleUploadArchiveDotNet"></a>

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

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

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