**此頁面僅適用於使用 Vaults 和 2012 年原始 REST API 的 Amazon Glacier 服務的現有客戶。**

如果您要尋找封存儲存解決方案，建議您在 Amazon Glacier Instant Retrieval、S3 Glacier Flexible Retrieval 和 S3 Glacier Deep Archive 中使用 Amazon Glacier 儲存類別。 Amazon S3 若要進一步了解這些儲存選項，請參閱 [Amazon Glacier 儲存類別](https://aws.amazon.com/s3/storage-classes/glacier/)。

Amazon Glacier （原始獨立保存庫型服務） 不再接受新客戶。Amazon Glacier 是一項獨立服務，具有自己的 APIs，可將資料存放在保存庫中，並與 Amazon S3 和 Amazon S3 Glacier 儲存類別不同。您現有的資料將在 Amazon Glacier 中無限期保持安全且可存取。不需要遷移。對於低成本、長期的封存儲存， AWS 建議使用 [Amazon S3 Glacier 儲存類別](https://aws.amazon.com/s3/storage-classes/glacier/)，透過 S3 儲存貯體型 APIs、完整 AWS 區域 可用性、降低成本 AWS 和服務整合，提供卓越的客戶體驗。如果您想要增強功能，請考慮使用我們的解決方案指南，將資料從 Amazon S3 Glacier 保存庫傳輸至 Amazon S3 Glacier 儲存類別，以遷移至 Amazon S3 Glacier 儲存類別。 [AWS Amazon Glacier Amazon S3 ](https://aws.amazon.com/solutions/guidance/data-transfer-from-amazon-s3-glacier-vaults-to-amazon-s3/)

本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# 範例：使用適用於 Java 的 Amazon 開發套件，以部分形式上傳大型封存
<a name="uploading-an-archive-mpu-using-java"></a>

適用於 Java 的 Amazon 開發套件提供的[高階和低階 API](using-aws-sdk.md) 都提供了上傳大型封存的方法 (請參閱 [在 Amazon Glacier 中上傳封存](uploading-an-archive.md))。

 
+ 高階的 API 提供了一種可用來上傳任何大小的封存的方法。根據您上傳的檔案， 方法會在單一操作中上傳封存，或使用 Amazon Glacier (Amazon Glacier) 中的分段上傳支援來分段上傳封存。
+ 低階 API 對應接近底層 REST 實作。因此，它提供一個方法，在一個操作中上傳較小的封存，以及一組方法，可支援分段上傳以上傳較大封存。本節說明使用低階 API 以部分形式上傳大型封存。

如需高階和低階的 API 的更多資訊，請參閱 [適用於 Java 的 AWS SDK 搭配 Amazon Glacier 使用](using-aws-sdk-for-java.md)。

**Topics**
+ [使用 的高階 API 分段上傳大型封存 適用於 Java 的 AWS SDK](#uploading-an-archive-in-parts-highlevel-using-java)
+ [使用 的低階 API 分段上傳大型封存 適用於 Java 的 AWS SDK](#uploading-an-archive-mpu-using-java-lowlevel)

## 使用 的高階 API 分段上傳大型封存 適用於 Java 的 AWS SDK
<a name="uploading-an-archive-in-parts-highlevel-using-java"></a>

您可以使用高階 API 的相同方法來上傳小型或大型封存。根據封存大小，高階 API 方法會決定在單一操作中上傳封存，還是使用 Amazon Glacier 提供的分段上傳 API。如需詳細資訊，請參閱[使用 的高階 API 上傳封存 適用於 Java 的 AWS SDK](uploading-an-archive-single-op-using-java.md#uploading-an-archive-single-op-high-level-using-java)。

## 使用 的低階 API 分段上傳大型封存 適用於 Java 的 AWS SDK
<a name="uploading-an-archive-mpu-using-java-lowlevel"></a>

對於精細控制上傳，您可以使用低階 API，您可以設定請求和處理回應。以下是使用 適用於 Java 的 AWS SDK以部分形式上傳大型封存的步驟。

 

1. 建立 `AmazonGlacierClient` 類別的執行個體 (用戶端)。

   您需要指定要儲存封存 AWS 的區域。您使用此用戶端執行的所有操作都會套用到該 AWS 區域。

1. 呼叫 `initiateMultipartUpload` 方法以啟動分段上傳。

   您需要提供要上傳存檔的文件庫名稱、要用於上傳存檔部分的部分大小以及可選說明。您可以透過建立 `InitiateMultipartUploadRequest` 類別的執行個體，來提供這項資訊。在回應中，Amazon Glacier 會傳回上傳 ID。

1. 透過呼叫 `uploadMultipartPart` 方法上傳部分。

   對於您上載的每個部分，您需要提供文件庫名稱、在該部分中上傳的最終組合的存檔中的位元組範圍、部分資料的檢查總和和上傳 ID。

1. 呼叫 `completeMultipartUpload` 方法以計算分段上傳。

   您需要提供上傳 ID、整個封存的檢查總和、封存大小 (您上傳的所有部分的組合大小) 和保存庫名稱。Amazon Glacier 會從上傳的組件建構封存，並傳回封存 ID。

### 範例：使用 在組件中上傳大型封存 適用於 Java 的 AWS SDK
<a name="upload-archive-mpu-java-example"></a>

下列 Java 程式碼範例使用 適用於 Java 的 AWS SDK 將封存上傳至保存庫 (`examplevault`)。如需執行此範例的逐步說明，請參閱 [使用 Eclipse 執行 Amazon Glacier 的 Java 範例](using-aws-sdk-for-java.md#setting-up-and-testing-sdk-java)。您必須如所示，使用要上傳的檔案名稱更新程式碼。

 

**注意**  
此範例對從 1 MB 到 1 GB 的部分大小有效。不過，Amazon Glacier 支援部分大小最多 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();
    }
}
```