**此页面仅适用于使用文件库和 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 是一项独立的服务 APIs ，拥有自己的服务，可将数据存储在文件库中，不同于亚马逊 S3 和 Amazon S3 Glacier 存储类别。在 Amazon Glacier 中，您现有的数据将确保安全，并且可以无限期地访问。无需进行迁移。对于低成本、长期的存档存储， AWS 建议[使用 Amazon S3 Glacier 存储类别，这些存储类别](https://aws.amazon.com/s3/storage-classes/glacier/)基于S3存储桶 APIs、完全 AWS 区域 可用性、更低的成本和 AWS 服务集成，可提供卓越的客户体验。如果您希望加强功能，可以考虑使用我们的 [AWS 将数据从 Amazon Glacier 文件库传输到 Amazon S3 Glacier 存储类别的解决方案指南](https://aws.amazon.com/solutions/guidance/data-transfer-from-amazon-s3-glacier-vaults-to-amazon-s3/)，迁移到 Amazon S3 Glacier 存储类别。
本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 在 Amazon Glacier 中处理文件库
文件库是用于存储档案的容器。在创建文件库时，您可以指定文件库名称以及您要在其中创建文件库的 AWS 区域。有关 Amazon Glacier 支持的 AWS 区域列表，请参阅《AWS 一般参考》**中的 [Amazon Glacier 端点和配额](https://docs.aws.amazon.com/general/latest/gr/glacier-service.html)。
您可以在文件库中存储无限多个档案。
**重要**
Amazon Glacier 确实提供了一个控制台。但任何档案操作（例如上传、下载或删除）均要求您使用 AWS Command Line Interface（AWS CLI）或编写代码。档案操作没有控制台支持。例如，要上传照片、视频和其他文档等数据，您必须使用 AWS CLI 或编写代码发起请求（可直接利用 REST API 或使用 AWS SDK）。
要安装 AWS CLI，请参阅 [AWS Command Line Interface](https://aws.amazon.com/cli/)。有关将 Amazon Glacier 与 AWS CLI 配合使用的更多信息，请参阅 [Amazon Glacier 的 AWS CLI 参考](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html)。有关使用 AWS CLI 将档案上传到 Amazon Glacier 的示例，请参阅[结合使用 Amazon Glacier 与 AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-glacier.html)。
**Topics**
+ [
## Amazon Glacier 中的文件库操作
](#vault-operations-quick-intro)
+ [
# 在 Amazon Glacier 中创建文件库
](creating-vaults.md)
+ [
# 在 Amazon Glacier 中检索文件库元数据
](retrieving-vault-info.md)
+ [
# 在 Amazon Glacier 中下载文件库清单
](vault-inventory.md)
+ [
# 在 Amazon Glacier 中配置文件库通知
](configuring-notifications.md)
+ [
# 在 Amazon Glacier 中删除文件库
](deleting-vaults.md)
+ [
# 标记 Amazon Glacier 文件库
](tagging-vaults.md)
+ [
# Amazon Glacier 文件库锁定
](vault-lock.md)
## Amazon Glacier 中的文件库操作
Amazon Glacier 支持各种文件库操作。文件库操作取决于特定 AWS 区域。换而言之，创建文件库时，您在特定 AWS 区域中创建。在您列出文件库时，Amazon Glacier 会从您在请求中指定的 AWS 区域返回文件库列表。
### 创建和删除文件库
AWS 账户 最多可以为每个 AWS 区域创建 1000 个文件库。有关 Amazon Glacier 支持的 AWS 区域列表，请参阅《AWS 一般参考》**中的 [Amazon Glacier 端点和配额](https://docs.aws.amazon.com/general/latest/gr/glacier-service.html)。
仅当自 Amazon Glacier 计算的上次清单起文件库中没有任何档案，并且自上次清单盘点以来没有对文件库执行过任何写入操作时，您才能删除文件库。
**注意**
Amazon Glacier 每 24 小时会定期为每个文件库准备一份清单。由于清单可能没有反映最新信息，因此，Amazon Glacier 会通过检查自上次文件库清单盘点以来是否执行过任何写入操作来确保文件库确实是空的。
有关更多信息，请参阅[在 Amazon Glacier 中创建文件库](creating-vaults.md)和[在 Amazon Glacier 中删除文件库](deleting-vaults.md)。
### 检索文件库元数据
您可以检索文件库信息，例如文件库的创建日期、文件库中的档案数，以及文件库中所有档案的总大小。Amazon Glacier 提供了 API 调用，供您检索您的账户内特定 AWS 区域中特定文件库或所有文件库的此信息。有关更多信息，请参阅[在 Amazon Glacier 中检索文件库元数据](retrieving-vault-info.md)。
### 下载文件库清单
*文件库清单*指的是文件库中的档案列表。对于列表中的每个档案，清单都提供了档案信息，例如档案 ID、创建日期和大小。从您将第一个档案上传到文件库的日期开始，Amazon Glacier 大约每天都会更新一次文件库清单。文件库清单必须存在，您才能下载它。
下载文件库清单是一种异步操作。您必须先启动下载清单的任务。收到任务请求后，Amazon Glacier 会为下载准备清单。任务完成后，您可以下载清单数据。
鉴于任务具有异步性，您可以使用 Amazon Simple Notification Service（Amazon SNS）通知在任务完成时通知您。您可以为每个任务请求指定 Amazon SNS 主题，或者将您的文件库配置为在特定文件库事件发生时发送通知。
Amazon Glacier 每 24 小时会定期为每个文件库准备一份清单。如果在上次清单盘点后没有对文件库执行过添加或删除档案的操作，则不会更新清单日期。
当您为文件库清单启动任务时，Amazon Glacier 返回其最近一次生成的清单，该清单是时间点快照，而不是实时数据。您可能没有发现为每个档案上传操作检索文件库清单有什么好处。但是，假设您在客户端维护数据库，且该数据库中包含与您上传到 Amazon Glacier 的档案关联的元数据。此时，您可能会发现，文件库清单存对于将您数据库中的信息与实际文件库清单进行协调很有用。
有关检索文件库清单的更多信息，请参阅[在 Amazon Glacier 中下载文件库清单](vault-inventory.md)。
### 配置文件库通知
从 Amazon Glacier 检索任何内容（例如文件库中的档案或文件库清单）是一个分为两步的过程。首先，启动一项任务。任务完成后，下载输出。要了解您的任务何时完成，您可以使用 Amazon Glacier 通知。Amazon Glacier 会将通知消息发送到您提供的 Amazon Simple Notification Service（Amazon SNS）主题。
您可以配置文件库通知，并确定文件库事件以及要在事件发生时通知的 Amazon SNS 主题。每当有文件库事件发生时，Amazon Glacier 都会向指定的 Amazon SNS 主题发送通知。有关更多信息，请参阅[在 Amazon Glacier 中配置文件库通知](configuring-notifications.md)。
# 在 Amazon Glacier 中创建文件库
创建文件库的操作会向您账户中的文件库集合添加文件库。一个 AWS 账户最多可以为每个 AWS 区域创建 1000 个文件库。有关 Amazon Glacier（Amazon Glacier）支持的 AWS 区域的列表，请参阅《AWS 一般参考》**中的[区域和端点](https://docs.aws.amazon.com/general/latest/gr/rande.html#glacier_region)。
创建文件库时，您必须提供文件库名称。以下是文件库的命名要求：
+ 名称长度在 1 和 255 个字符之间。
+ 允许的字符包括 a-z、A-Z、0-9、'-'（下划线）、'\$1'（连字符）和 '.'（半角句点）。
文件库名称在一个账户以及创建文件库所在的 AWS 区域内必须是唯一的。即，一个账户可以在不同的 AWS 区域创建名称相同的文件库，但不能在同一 AWS 区域创建名称相同的文件库。
**Topics**
+ [
# 使用适用于 Java 的 AWS SDK 在 Amazon Glacier 中创建文件库
](creating-vaults-sdk-java.md)
+ [
# 在 Amazon Glacier 中创建文件库使用 适用于 .NET 的 AWS SDK
](creating-vaults-dotnet-sdk.md)
+ [
# 使用 REST API 在 Amazon Glacier 中创建文件库
](creating-vaults-rest-api.md)
+ [
# 使用 Amazon Glacier 控制台创建文件库
](creating-vaults-console.md)
+ [
# 使用 AWS Command Line Interface在 Amazon Glacier 中创建文件库
](creating-vaults-cli.md)
# 使用适用于 Java 的 AWS SDK 在 Amazon Glacier 中创建文件库
该低级 API 为所有文件库操作提供了方法，包括创建和删除文件库、获取文件库描述，以及获取特定 AWS 区域创建的文件库的列表。以下是使用适用于 Java 的 AWS SDK 创建文件库的步骤。
1. 创建 `AmazonGlacierClient` 类（客户端）的实例。
您需要指定要创建文件库的 AWS 区域。您使用此客户端执行的所有操作都会应用到该 AWS 区域。
1. 通过创建一个 `CreateVaultRequest` 类的实例提供请求信息。
Amazon Glacier（Amazon Glacier）要求您提供文件库名称和您的账户 ID。如果您不提供账户 ID，则系统会使用与您提供来对请求签名的证书相关联的账户 ID。有关更多信息，请参阅[适用于 Java 的 AWS SDK 与 Amazon Glacier 搭配使用](using-aws-sdk-for-java.md)。
1. 以参数形式提供请求对象，运行 `createVault` 方法。
Amazon Glacier 返回的响应在 `CreateVaultResult` 对象中提供。
以下 Java 代码段说明了前面的步骤。该代码段在 `us-west-2` 区域创建了文件库。它打印的 `Location` 是文件库的相对 URI，该 URI 包括您的账户 ID、AWS 区域和文件库名称。
```
AmazonGlacierClient client = new AmazonGlacierClient(credentials);
client.setEndpoint("https://glacier.us-west-2.amazonaws.com");
CreateVaultRequest request = new CreateVaultRequest()
.withVaultName("*** provide vault name ***");
CreateVaultResult result = client.createVault(request);
System.out.println("Created vault successfully: " + result.getLocation());
```
**注意**
有关底层 REST API 的信息，请参阅[创建文件库（PUT vault）](api-vault-put.md)。
## 示例：使用适用于 Java 的 AWS SDK 创建文件库
以下 Java 代码示例在 `us-west-2` 区域创建了文件库（有关 AWS 区域的更多信息，请参阅[访问 Amazon Glacier](amazon-glacier-accessing.md)）。此外，该代码示例还检索了文件库信息，列出了同一 AWS 区域的所有文件库，然后删除了创建的文件库。
有关如何运行以下示例的分步说明，请参阅[使用 Eclipse 运行 Amazon Glacier 的 Java 示例](using-aws-sdk-for-java.md#setting-up-and-testing-sdk-java)。
**Example**
```
import java.io.IOException;
import java.util.List;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.glacier.AmazonGlacierClient;
import com.amazonaws.services.glacier.model.CreateVaultRequest;
import com.amazonaws.services.glacier.model.CreateVaultResult;
import com.amazonaws.services.glacier.model.DeleteVaultRequest;
import com.amazonaws.services.glacier.model.DescribeVaultOutput;
import com.amazonaws.services.glacier.model.DescribeVaultRequest;
import com.amazonaws.services.glacier.model.DescribeVaultResult;
import com.amazonaws.services.glacier.model.ListVaultsRequest;
import com.amazonaws.services.glacier.model.ListVaultsResult;
public class AmazonGlacierVaultOperations {
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/");
String vaultName = "examplevaultfordelete";
try {
createVault(client, vaultName);
describeVault(client, vaultName);
listVaults(client);
deleteVault(client, vaultName);
} catch (Exception e) {
System.err.println("Vault operation failed." + e.getMessage());
}
}
private static void createVault(AmazonGlacierClient client, String vaultName) {
CreateVaultRequest createVaultRequest = new CreateVaultRequest()
.withVaultName(vaultName);
CreateVaultResult createVaultResult = client.createVault(createVaultRequest);
System.out.println("Created vault successfully: " + createVaultResult.getLocation());
}
private static void describeVault(AmazonGlacierClient client, String vaultName) {
DescribeVaultRequest describeVaultRequest = new DescribeVaultRequest()
.withVaultName(vaultName);
DescribeVaultResult describeVaultResult = client.describeVault(describeVaultRequest);
System.out.println("Describing the vault: " + vaultName);
System.out.print(
"CreationDate: " + describeVaultResult.getCreationDate() +
"\nLastInventoryDate: " + describeVaultResult.getLastInventoryDate() +
"\nNumberOfArchives: " + describeVaultResult.getNumberOfArchives() +
"\nSizeInBytes: " + describeVaultResult.getSizeInBytes() +
"\nVaultARN: " + describeVaultResult.getVaultARN() +
"\nVaultName: " + describeVaultResult.getVaultName());
}
private static void listVaults(AmazonGlacierClient client) {
ListVaultsRequest listVaultsRequest = new ListVaultsRequest();
ListVaultsResult listVaultsResult = client.listVaults(listVaultsRequest);
List vaultList = listVaultsResult.getVaultList();
System.out.println("\nDescribing all vaults (vault list):");
for (DescribeVaultOutput vault : vaultList) {
System.out.println(
"\nCreationDate: " + vault.getCreationDate() +
"\nLastInventoryDate: " + vault.getLastInventoryDate() +
"\nNumberOfArchives: " + vault.getNumberOfArchives() +
"\nSizeInBytes: " + vault.getSizeInBytes() +
"\nVaultARN: " + vault.getVaultARN() +
"\nVaultName: " + vault.getVaultName());
}
}
private static void deleteVault(AmazonGlacierClient client, String vaultName) {
DeleteVaultRequest request = new DeleteVaultRequest()
.withVaultName(vaultName);
client.deleteVault(request);
System.out.println("Deleted vault: " + vaultName);
}
}
```
# 在 Amazon Glacier 中创建文件库使用 适用于 .NET 的 AWS SDK
适用于.NET 的 Amazon SDK APIs 提供的[高级和低级](using-aws-sdk.md)都提供了一种创建文件库的方法。
**Topics**
+ [
## 使用的高级别 API 创建文件库 适用于 .NET 的 AWS SDK
](#create-vault-dotnet-highlevel)
+ [
## 使用的低级 API 创建文件库 适用于 .NET 的 AWS SDK
](#create-vault-dotnet-lowlevel)
## 使用的高级别 API 创建文件库 适用于 .NET 的 AWS SDK
高级 API 的 `ArchiveTransferManager` 类提供了您可以用来在 AWS 区域创建文件库的 `CreateVault` 方法。
### 示例：使用高级 API 进行文件库操作 适用于 .NET 的 AWS SDK
以下 C\$1 代码示例在美国西部（俄勒冈州）区域创建了文件库，然后删除了该文件库。有关可以在其中创建文件库 AWS 区域 的列表，请参阅[访问 Amazon Glacier](amazon-glacier-accessing.md)。
有关如何运行以下示例的 step-by-step说明，请参阅[运行代码示例](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.ca.docsamples
{
class VaultCreateDescribeListVaultsDeleteHighLevel
{
static string vaultName = "*** Provide vault name ***";
public static void Main(string[] args)
{
try
{
var manager = new ArchiveTransferManager(Amazon.RegionEndpoint.USWest2);
manager.CreateVault(vaultName);
Console.WriteLine("Vault created. To delete the vault, press Enter");
Console.ReadKey();
manager.DeleteVault(vaultName);
Console.WriteLine("\nVault deleted. 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 创建文件库 适用于 .NET 的 AWS SDK
低级 API 为所有文件库操作提供了方法，包括创建和删除文件库、获取文件库描述以及获取在特定文件库中创建的文件库的列表。 AWS 区域以下是使用 适用于 .NET 的 AWS SDK创建文件库的步骤。
1. 创建 `AmazonGlacierClient` 类（客户端）的实例。
您需要指定要 AWS 区域 在其中创建文件库的。您使用此客户端执行的所有操作都会应用到该 AWS 区域。
1. 通过创建一个 `CreateVaultRequest` 类的实例提供请求信息。
Amazon Glacier（Amazon Glacier）要求您提供文件库名称和您的账户 ID。如果您不提供账户 ID，则系统会使用与您提供来对请求签名的证书相关联的账户 ID。有关更多信息，请参阅[将适用于 .NET 的 AWS SDK 与 Amazon Glacier 结合使用](using-aws-sdk-for-dot-net.md)。
1. 以参数形式提供请求对象，运行 `CreateVault` 方法。
Amazon Glacier 返回的响应在 `CreateVaultResponse` 对象中提供。
### 示例：使用的低级 API 进行文件库操作 适用于 .NET 的 AWS SDK
以下 C\$1 示例说明了前面的步骤。此示例可在美国西部（俄勒冈州）区域创建文件库。此外，该代码示例还会检索文件库信息，列出同一个文件库中的所有文件库 AWS 区域，然后删除创建的文件库。`Location`打印的是文件库的相对 URI，其中包括您的账户 ID AWS 区域、和文件库名称。
**注意**
有关底层 REST API 的信息，请参阅[创建文件库（PUT vault）](api-vault-put.md)。
有关如何运行以下示例的 step-by-step说明，请参阅[运行代码示例](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet)。您需要更新文件库名称旁显示的代码。
**Example**
```
using System;
using Amazon.Glacier;
using Amazon.Glacier.Model;
using Amazon.Runtime;
namespace glacier.amazon.com.rproxy.govskope.ca.docsamples
{
class VaultCreateDescribeListVaultsDelete
{
static string vaultName = "*** Provide vault name ***";
static AmazonGlacierClient client;
public static void Main(string[] args)
{
try
{
using (client = new AmazonGlacierClient(Amazon.RegionEndpoint.USWest2))
{
Console.WriteLine("Creating a vault.");
CreateAVault();
DescribeVault();
GetVaultsList();
Console.WriteLine("\nVault created. Now press Enter to delete the vault...");
Console.ReadKey();
DeleteVault();
}
}
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 CreateAVault()
{
CreateVaultRequest request = new CreateVaultRequest()
{
VaultName = vaultName
};
CreateVaultResponse response = client.CreateVault(request);
Console.WriteLine("Vault created: {0}\n", response.Location);
}
static void DescribeVault()
{
DescribeVaultRequest describeVaultRequest = new DescribeVaultRequest()
{
VaultName = vaultName
};
DescribeVaultResponse describeVaultResponse = client.DescribeVault(describeVaultRequest);
Console.WriteLine("\nVault description...");
Console.WriteLine(
"\nVaultName: " + describeVaultResponse.VaultName +
"\nVaultARN: " + describeVaultResponse.VaultARN +
"\nVaultCreationDate: " + describeVaultResponse.CreationDate +
"\nNumberOfArchives: " + describeVaultResponse.NumberOfArchives +
"\nSizeInBytes: " + describeVaultResponse.SizeInBytes +
"\nLastInventoryDate: " + describeVaultResponse.LastInventoryDate
);
}
static void GetVaultsList()
{
string lastMarker = null;
Console.WriteLine("\n List of vaults in your account in the specific region ...");
do
{
ListVaultsRequest request = new ListVaultsRequest()
{
Marker = lastMarker
};
ListVaultsResponse response = client.ListVaults(request);
foreach (DescribeVaultOutput output in response.VaultList)
{
Console.WriteLine("Vault Name: {0} \tCreation Date: {1} \t #of archives: {2}",
output.VaultName, output.CreationDate, output.NumberOfArchives);
}
lastMarker = response.Marker;
} while (lastMarker != null);
}
static void DeleteVault()
{
DeleteVaultRequest request = new DeleteVaultRequest()
{
VaultName = vaultName
};
DeleteVaultResponse response = client.DeleteVault(request);
}
}
}
```
# 使用 REST API 在 Amazon Glacier 中创建文件库
要使用 REST API 创建文件库，请参阅[创建文件库（PUT vault）](api-vault-put.md)。
# 使用 Amazon Glacier 控制台创建文件库
要使用 Amazon Glacier（Amazon Glacier）控制台创建文件库，请参阅《入门》教程**中的[步骤 2：在 Amazon Glacier 中创建文件库](getting-started-create-vault.md)。
# 使用 AWS Command Line Interface在 Amazon Glacier 中创建文件库
按照以下步骤使用 AWS Command Line Interface（AWS CLI）在 Amazon Glacier（Amazon Glacier）中创建文件库。
**Topics**
+ [
## （先决条件）设置 AWS CLI
](#Creating-Vaults-CLI-Setup)
+ [
## 示例：使用 AWS CLI 创建文件库
](#Creating-Vaults-CLI-Implementation)
## （先决条件）设置 AWS CLI
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 CLI 的当前配置数据，请使用 `aws configure list` 命令。
```
aws configure list
```
## 示例：使用 AWS CLI 创建文件库
1. 使用 `create-vault` 命令在账户 *111122223333* 下创建一个名为 *awsexamplevault* 的文件库。
```
aws glacier create-vault --vault-name awsexamplevault --account-id 111122223333
```
预期输出：
```
{
"location": "/111122223333/vaults/awsexamplevault"
}
```
1. 使用 `describe-vault` 命令验证创建。
```
aws glacier describe-vault --vault-name awsexamplevault --account-id 111122223333
```
# 在 Amazon Glacier 中检索文件库元数据
您可以检索文件库信息，例如文件库的创建日期、文件库中的档案数，以及文件库中所有档案的总大小。Amazon Glacier（Amazon Glacier）提供 API 调用，供您检索账户中特定文件库或特定 AWS 区域内所有文件库的这些信息。
如果您检索文件库列表，Amazon Glacier 将返回按文件库名称的 ASCII 值排序的列表。该列表最多包含 1000 个文件库。您应始终检查响应，以查看是否有继续该列表的标记；如果没有更多项目，则标记字段为 `null`。您可以选择性地限制响应中返回的文件库数。如果实际的文件库数大于响应中返回的文件库数，则结果会分页。您需要发送附加请求来获取下一组文件库。
**Topics**
+ [
# 使用 Amazon Glacier 检索文件库元数据 适用于 Java 的 AWS SDK
](retrieving-vault-info-sdk-java.md)
+ [
# 使用 Amazon Glacier 中检索文件库元数据 适用于 .NET 的 AWS SDK
](retrieving-vault-info-sdk-dotnet.md)
+ [
# 使用 REST API 检索文件库元数据
](listing-vaults-rest-api.md)
+ [
# 使用 AWS Command Line Interface在 Amazon Glacier 中检索文件库元数据
](retrieving-vault-info-cli.md)
# 使用 Amazon Glacier 检索文件库元数据 适用于 Java 的 AWS SDK
**Topics**
+ [
## 检索文件库的文件库元数据
](#retrieve-vault-info-sdk-java-lowlevel-one-vault)
+ [
## 检索一个区域所有文件库的文件库元数据
](#retrieve-vault-info-sdk-java-lowlevel-all-vaults)
+ [
## 示例：使用适用于 Java 的 Amazon SDK 检索文件库元数据
](#retrieving-vault-info-sdk-java-example)
## 检索文件库的文件库元数据
您可以检索特定文件库或特定 AWS 区域内所有文件库的元数据。以下是使用适用于 Java 的 Amazon SDK 低级 API 检索特定文件库的文件库元数据的步骤。
1. 创建 `AmazonGlacierClient` 类（客户端）的实例。
您需要指定文件库所在的 AWS 区域。您使用此客户端执行的所有操作都适用于该 AWS 区域。
1. 通过创建一个 `DescribeVaultRequest` 类的实例提供请求信息。
Amazon Glacier（Amazon Glacier）要求您提供文件库名称和您的账户 ID。如果您不提供账户 ID，则系统会使用与您提供来对请求签名的证书相关联的账户 ID。有关更多信息，请参阅[适用于 Java 的 AWS SDK 与 Amazon Glacier 搭配使用](using-aws-sdk-for-java.md)。
1. 以参数形式提供请求对象，运行 `describeVault` 方法。
Amazon Glacier 返回的文件库元数据信息在 `DescribeVaultResult` 对象中提供。
以下 Java 代码段说明了前面的步骤。
```
DescribeVaultRequest request = new DescribeVaultRequest()
.withVaultName("*** provide vault name***");
DescribeVaultResult result = client.describeVault(request);
System.out.print(
"\nCreationDate: " + result.getCreationDate() +
"\nLastInventoryDate: " + result.getLastInventoryDate() +
"\nNumberOfArchives: " + result.getNumberOfArchives() +
"\nSizeInBytes: " + result.getSizeInBytes() +
"\nVaultARN: " + result.getVaultARN() +
"\nVaultName: " + result.getVaultName());
```
**注意**
有关底层 REST API 的信息，请参阅[描述文件库（GET vault）](api-vault-get.md)。
## 检索一个区域所有文件库的文件库元数据
您还可以使用该`listVaults`方法检索特定 AWS 区域中所有文件库的元数据。
以下 Java 代码段会检索 `us-west-2` 区域的文件库的列表。该请求会将响应中返回的文件库数限制为 5 个。然后，该代码段会进行一系列`listVaults`调用，以从该 AWS 地区检索整个保管库列表。
```
AmazonGlacierClient client;
client.setEndpoint("https://glacier.us-west-2.amazonaws.com/");
String marker = null;
do {
ListVaultsRequest request = new ListVaultsRequest()
.withLimit("5")
.withMarker(marker);
ListVaultsResult listVaultsResult = client.listVaults(request);
List vaultList = listVaultsResult.getVaultList();
marker = listVaultsResult.getMarker();
for (DescribeVaultOutput vault : vaultList) {
System.out.println(
"\nCreationDate: " + vault.getCreationDate() +
"\nLastInventoryDate: " + vault.getLastInventoryDate() +
"\nNumberOfArchives: " + vault.getNumberOfArchives() +
"\nSizeInBytes: " + vault.getSizeInBytes() +
"\nVaultARN: " + vault.getVaultARN() +
"\nVaultName: " + vault.getVaultName());
}
} while (marker != null);
```
在前面的代码段中，如果您在请求中未指定 `Limit` 值，则 Amazon Glacier 最多返回 Amazon Glacier API 设置的 10 个文件库。如果有更多文件库要列出，则响应 `marker` 字段会包含文件库的Amazon 资源名称（ARN），新请求会从该名称处继续列表；否则，`marker` 字段为空。
请注意，列表中返回的每个文件库的信息与您通过调用特定文件库的 `describeVault` 方法获取的信息相同。
**注意**
`listVaults` 方法会调用底层 REST API（请参阅[列出文件库（GET vaults）](api-vaults-get.md)）。
## 示例：使用适用于 Java 的 Amazon SDK 检索文件库元数据
有关工作代码示例，请参阅[示例：使用适用于 Java 的 AWS SDK 创建文件库](creating-vaults-sdk-java.md#creating-vaults-sdk-java-example)。该 Java 代码示例会创建文件库并检索文件库元数据。
# 使用 Amazon Glacier 中检索文件库元数据 适用于 .NET 的 AWS SDK
**Topics**
+ [
## 检索文件库的文件库元数据
](#retrieve-vault-info-sdk-dotnet-lowlevel-one-vault)
+ [
## 检索一个区域所有文件库的文件库元数据
](#retrieve-vault-info-sdk-dotnet-lowlevel-all-vaults)
+ [
## 示例：使用的低级 API 检索文件库元数据 适用于 .NET 的 AWS SDK
](#creating-vaults-sdk-dotnet-example)
## 检索文件库的文件库元数据
您可以检索特定文件库或特定 AWS 区域内所有文件库的元数据。以下是使用 适用于 .NET 的 AWS SDK低级 API 检索特定文件库的文件库元数据的步骤。
1. 创建 `AmazonGlacierClient` 类（客户端）的实例。
您需要指定文件库所在的 AWS 区域。您使用此客户端执行的所有操作都适用于该 AWS 区域。
1. 通过创建一个 `DescribeVaultRequest` 类的实例提供请求信息。
Amazon Glacier（Amazon Glacier）要求您提供文件库名称和您的账户 ID。如果您不提供账户 ID，则系统会使用与您提供来对请求签名的证书相关联的账户 ID。有关更多信息，请参阅[将适用于 .NET 的 AWS SDK 与 Amazon Glacier 结合使用](using-aws-sdk-for-dot-net.md)。
1. 以参数形式提供请求对象，运行 `DescribeVault` 方法。
Amazon Glacier 返回的文件库元数据信息在 `DescribeVaultResult` 对象中提供。
以下 C\$1 代码段说明了前面的步骤。此代码段检索美国西部（俄勒冈州）区域中现有文件库的元数据信息。
```
AmazonGlacierClient client;
client = new AmazonGlacierClient(Amazon.RegionEndpoint.USWest2);
DescribeVaultRequest describeVaultRequest = new DescribeVaultRequest()
{
VaultName = "*** Provide vault name ***"
};
DescribeVaultResponse describeVaultResponse = client.DescribeVault(describeVaultRequest);
Console.WriteLine("\nVault description...");
Console.WriteLine(
"\nVaultName: " + describeVaultResponse.VaultName +
"\nVaultARN: " + describeVaultResponse.VaultARN +
"\nVaultCreationDate: " + describeVaultResponse.CreationDate +
"\nNumberOfArchives: " + describeVaultResponse.NumberOfArchives +
"\nSizeInBytes: " + describeVaultResponse.SizeInBytes +
"\nLastInventoryDate: " + describeVaultResponse.LastInventoryDate
);
```
**注意**
有关底层 REST API 的信息，请参阅[描述文件库（GET vault）](api-vault-get.md)。
## 检索一个区域所有文件库的文件库元数据
您还可以使用该`ListVaults`方法检索特定 AWS 区域中所有文件库的元数据。
以下 C\$1 代码段检索美国西部（俄勒冈州）区域中的文件库的列表。该请求会将响应中返回的文件库数限制为 5 个。然后，该代码段会进行一系列`ListVaults`调用，以从该 AWS 地区检索整个保管库列表。
```
AmazonGlacierClient client;
client = new AmazonGlacierClient(Amazon.RegionEndpoint.USWest2);
string lastMarker = null;
Console.WriteLine("\n List of vaults in your account in the specific AWS Region ...");
do
{
ListVaultsRequest request = new ListVaultsRequest()
{
Limit = 5,
Marker = lastMarker
};
ListVaultsResponse response = client.ListVaults(request);
foreach (DescribeVaultOutput output in response.VaultList)
{
Console.WriteLine("Vault Name: {0} \tCreation Date: {1} \t #of archives: {2}",
output.VaultName, output.CreationDate, output.NumberOfArchives);
}
lastMarker = response.Marker;
} while (lastMarker != null);
```
在前面的代码段中，如果您在请求中未指定 `Limit` 值，则 Amazon Glacier 最多返回 Amazon Glacier API 设置的 10 个文件库。
请注意，列表中返回的每个文件库的信息与您通过调用特定文件库的 `DescribeVault` 方法获取的信息相同。
**注意**
`ListVaults` 方法会调用底层 REST API（请参阅[列出文件库（GET vaults）](api-vaults-get.md)）。
## 示例：使用的低级 API 检索文件库元数据 适用于 .NET 的 AWS SDK
有关工作代码示例，请参阅[示例：使用的低级 API 进行文件库操作 适用于 .NET 的 AWS SDK](creating-vaults-dotnet-sdk.md#vault-operations-example-dotnet-lowlevel)。该 C\$1 代码示例会创建文件库并检索文件库元数据。
# 使用 REST API 检索文件库元数据
要使用 REST API 列出文件库，请参阅[列出文件库（GET vaults）](api-vaults-get.md)。要描述一个文件库，请参阅[描述文件库（GET vault）](api-vault-get.md)。
# 使用 AWS Command Line Interface在 Amazon Glacier 中检索文件库元数据
此示例演示如何使用 AWS Command Line Interface（AWS CLI）在 Amazon Glacier（Amazon Glacier）中检索文件库信息和元数据。
**Topics**
+ [
## （先决条件）设置 AWS CLI
](#Creating-Vaults-CLI-Setup)
+ [
## 示例：使用 AWS CLI 检索文件库元数据
](#Retrieving-Vault-Metadata-CLI-Implementation)
## （先决条件）设置 AWS CLI
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 CLI 的当前配置数据，请使用 `aws configure list` 命令。
```
aws configure list
```
## 示例：使用 AWS CLI 检索文件库元数据
+ 使用 `describe-vault` 命令描述账户 *111122223333* 下名为 *awsexamplevault* 的文件库。
```
aws glacier describe-vault --vault-name awsexamplevault --account-id 111122223333
```
# 在 Amazon Glacier 中下载文件库清单
您向文件库上传第一个档案后，Amazon Glacier（Amazon Glacier）会自动创建文件库清单，然后大约每天更新一次。Amazon Glacier 创建第一份清单后，通常需要经过半天（最多一天）时间，该清单才可供检索。您可以通过以下流程（该流程分为两个步骤）从 Amazon Glacier 检索文件库清单：
1. 使用[启动任务（POST jobs）](api-initiate-job-post.md)操作启动清单检索任务。
**重要**
数据检索策略可能导致您启动检索任务的请求失败，并发生 `PolicyEnforcedException` 异常。有关数据检索策略的更多信息，请参阅 [Amazon Glacier 数据检索策略](data-retrieval-policy.md)。有关 `PolicyEnforcedException` 异常的更多信息，请参阅[错误响应](api-error-responses.md)。
1. 在任务完成后，使用[获取任务输出（GET output）](api-job-output-get.md)操作下载字节。
例如，检索档案或文件库清单的操作要求您首先启动检索任务。任务请求会异步运行。当您启动检索任务时，Amazon Glacier 会创建任务并在响应中返回任务 ID。Amazon Glacier 完成任务时，您可以获取任务输出（归档字节或文件库清单数据）。
任务必须先完成，然后，您才能获取其输出。要确定任务的状态，您有以下选择：
+ **等待任务完成通知** – 您可以指定 Amazon Glacier 在完成任务后可以向其发布通知的 Amazon Simple Notification Service（Amazon SNS）主题。您可以使用以下方法指定 Amazon SNS 主题：
+ 为每个任务指定 Amazon SNS 主题。
启动任务时，您可以选择性地指定 Amazon SNS 主题。
+ 设置文件库的通知配置。
您可以设置文件库的特定事件的通知配置（参阅[在 Amazon Glacier 中配置文件库通知](configuring-notifications.md)）。只要发生特定事件，Amazon Glacier 就会向指定的 SNS 主题发送消息。
如果您设置了文件库的通知配置，并且在启动任务时也指定了 Amazon SNS 主题，则 Amazon Glacier 会向这两个主题发送任务完成消息。
您可以将 SNS 主题配置为通过电子邮件通知您或者将消息存储在应用程序可以轮询的 Amazon Simple Queue Service（Amazon SQS）中。当该队列中出现消息时，您可以检查任务是否已成功完成，然后下载任务输出。
+ **显式请求任务信息** – Amazon Glacier 也提供了描述任务操作（[描述任务（GET JobID）](api-describe-job-get.md)），该操作可让您轮询任务信息。您可以定期发送此请求，以获取任务信息。但是，使用 Amazon SNS 通知才是推荐的选择。
**注意**
您通过 SNS 通知获取的信息与通过调用描述任务获取的信息相同。
**Topics**
+ [
## 关于清单
](#vault-inventory-about)
+ [
# 在 Amazon Glacier 中下载文件库清单使用 适用于 Java 的 AWS SDK
](retrieving-vault-inventory-java.md)
+ [
# 使用 Amazon Glacier 下载文件库清单 适用于 .NET 的 AWS SDK
](retrieving-vault-inventory-sdk-dotnet.md)
+ [
# 使用 REST API 下载文件库清单
](retrieving-vault-inventory-rest-api.md)
+ [
# 使用 Amazon Glacier 下载文件库清单 AWS Command Line Interface
](retrieving-vault-inventory-cli.md)
## 关于清单
从您第一次将档案上传到文件库的日期开始，Amazon Glacier 至少每天都会更新一次文件库清单。如果在上次清单盘点后没有对文件库执行过添加或删除档案的操作，则不会更新清单日期。当您启动文件库库存任务时，Amazon Glacier 会返回其生成的最后一个库存，即 point-in-time快照而不是实时数据。请注意，Amazon Glacier 为文件库创建第一份清单后，通常需要经过半天（最多一天）时间，该清单才可用于检索操作。
您可能没有发现为每个档案上传操作检索文件库清单有什么好处。但是，假设您在客户端维护数据库，且该客户端关联了您上传到 Amazon Glacier 的档案的元数据。此时，您可能会发现，文件库清单对于根据需要将您数据库中的信息与实际文件库清单进行协调很有用。您可以通过筛选存档创建日期或设置配额，来限制检索的清单项目数。有关限制清单检索的更多信息，请参阅[确定清单检索范围](api-initiate-job-post.md#api-initiate-job-post-vault-inventory-list-filtering)。
清单可以按两种格式返回：逗号分隔值（CSV）或 JSON。启动清单任务时，您可以选择性地指定格式。默认格式为 JSON。有关清单任务输出中返回的数据字段的更多信息，请参阅“获取任务输出 API”**的[响应正文](api-job-output-get.md#api-job-output-get-responses-elements)。
# 在 Amazon Glacier 中下载文件库清单使用 适用于 Java 的 AWS SDK
以下是使用 适用于 Java 的 AWS SDK低级 API 检索文件库清单的步骤。该高级 API 不支持检索文件库清单。
1. 创建 `AmazonGlacierClient` 类（客户端）的实例。
您需要指定文件库所在的 AWS 区域。您使用此客户端执行的所有操作都适用于该 AWS 区域。
1. 通过执行 `initiateJob` 方法启动清单检索任务。
通过在 `initiateJob` 对象中提供任务信息来运行 `InitiateJobRequest`。
**注意**
请注意，如果文件库的清单操作尚未完成，则会返回错误。Amazon Glacier（Amazon Glacier）每 24 小时会定期为每个文件库准备一份清单。
作为响应，Amazon Glacier 返回任务 ID。该响应位于一个 `InitiateJobResult` 类的实例中。
```
InitiateJobRequest initJobRequest = new InitiateJobRequest()
.withVaultName("*** provide vault name ***")
.withJobParameters(
new JobParameters()
.withType("inventory-retrieval")
.withSNSTopic("*** provide SNS topic ARN ****")
);
InitiateJobResult initJobResult = client.initiateJob(initJobRequest);
String jobId = initJobResult.getJobId();
```
1. 等待任务完成。
您必须等到任务输出已作好供您下载的准备。如果您在文件库中设置了通知配置，或者在启动任务时指定了 Amazon Simple Notification Service（Amazon SNS）主题，则 Amazon Glacier 会在完成任务后向该主题发送消息。
此外，您还可以通过调用 `describeJob` 方法轮询 Amazon Glacier 来确定任务完成状态。但是，使用 Amazon SNS 主题进行通知才是推荐的方法。以下部分给出的代码示例使用适用于 Amazon Glacier 的 Amazon SNS 来发布消息。
1. 通过执行 `getJobOutput` 方法下载任务输出（文件库清单数据）。
您可以通过创建一个 `GetJobOutputRequest` 类的实例来提供您的账户 ID、任务 ID 和文件库名称。如果您不提供账户 ID，则系统会使用与您提供来对请求签名的证书相关联的账户 ID。有关更多信息，请参阅[适用于 Java 的 AWS SDK 与 Amazon Glacier 搭配使用](using-aws-sdk-for-java.md)。
Amazon Glacier 返回的输出位于 `GetJobOutputResult` 对象中。
```
GetJobOutputRequest jobOutputRequest = new GetJobOutputRequest()
.withVaultName("*** provide vault name ***")
.withJobId("*** provide job ID ***");
GetJobOutputResult jobOutputResult = client.getJobOutput(jobOutputRequest);
// jobOutputResult.getBody(); provides the output stream.
```
**注意**
有关任务相关的底层 REST API 的信息，请参阅[任务操作](job-operations.md)。
## 示例：使用适用于 Java 的 Amazon SDK 检索文件库清单
以下 Java 代码示例会检索指定文件库的文件库清单。
该示例执行以下任务：
+ 创建 Amazon Simple Notification Service（Amazon SNS）主题。
完成任务后，Amazon Glacier 会向此主题发送通知。
+ 创建 Amazon Simple Queue Service（Amazon SQS）队列。
该示例会向该队列附加策略，以使 Amazon SNS 主题能够向该队列发布消息。
+ 启动任务以下载指定的档案。
在任务请求中，指定了创建的 Amazon SNS 主题，以便 Amazon Glacier 可以在完成任务后向该主题发布通知。
+ 检查 Amazon SQS 队列是否有包含该任务 ID 的消息。
如果有消息，则分析 JSON，并检查任务是否已成功完成。如果已成功完成，则下载档案。
+ 通过删除它创建的 Amazon SNS 主题和 Amazon SQS 队列清除相关数据。
```
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
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.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 AmazonGlacierDownloadInventoryWithSQSPolling {
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("Inventory 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 queueAttributes = new HashMap();
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("inventory-retrieval")
.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.getFactory();
while (!messageFound) {
List 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();
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);
FileWriter fstream = new FileWriter(fileName);
BufferedWriter out = new BufferedWriter(fstream);
BufferedReader in = new BufferedReader(new InputStreamReader(getJobOutputResult.getBody()));
String inputLine;
try {
while ((inputLine = in.readLine()) != null) {
out.write(inputLine);
}
}catch(IOException e) {
throw new AmazonClientException("Unable to save archive", e);
}finally{
try {in.close();} catch (Exception e) {}
try {out.close();} catch (Exception e) {}
}
System.out.println("Retrieved inventory to " + fileName);
}
private static void cleanUp() {
snsClient.unsubscribe(new UnsubscribeRequest(snsSubscriptionARN));
snsClient.deleteTopic(new DeleteTopicRequest(snsTopicARN));
sqsClient.deleteQueue(new DeleteQueueRequest(sqsQueueURL));
}
}
```
# 使用 Amazon Glacier 下载文件库清单 适用于 .NET 的 AWS SDK
以下是使用 适用于 .NET 的 AWS SDK低级 API 检索文件库清单的步骤。该高级 API 不支持检索文件库清单。
1. 创建 `AmazonGlacierClient` 类（客户端）的实例。
您需要指定文件库所在的 AWS 区域。您使用此客户端执行的所有操作都适用于该 AWS 区域。
1. 通过执行 `InitiateJob` 方法启动清单检索任务。
您在 `InitiateJobRequest` 对象中提供任务信息。作为响应，Amazon Glacier（Amazon Glacier）返回任务 ID。该响应位于一个 `InitiateJobResponse` 类的实例中。
```
AmazonGlacierClient client;
client = new AmazonGlacierClient(Amazon.RegionEndpoint.USWest2);
InitiateJobRequest initJobRequest = new InitiateJobRequest()
{
VaultName = vaultName,
JobParameters = new JobParameters()
{
Type = "inventory-retrieval",
SNSTopic = "*** Provide Amazon SNS topic arn ***",
}
};
InitiateJobResponse initJobResponse = client.InitiateJob(initJobRequest);
string jobId = initJobResponse.JobId;
```
1. 等待任务完成。
您必须等到任务输出已作好供您下载的准备。如果您在文件库中设置了标识 Amazon Simple Notification Service（Amazon SNS）主题的通知配置，或者在启动任务时指定了 Amazon SNS 主题，则 Amazon Glacier 会在完成任务后向该主题发送消息。以下部分给出的代码示例使用适用于 Amazon Glacier 的 Amazon SNS 来发布消息。
此外，您还可以通过调用 `DescribeJob` 方法轮询 Amazon Glacier 来确定任务完成状态。尽管如此，使用 Amazon SNS 主题进行通知才是推荐的方法。
1. 通过执行 `GetJobOutput` 方法下载任务输出（文件库清单数据）。
您可以通过创建一个 `GetJobOutputRequest` 类的实例来提供您的账户 ID、文件库名称和任务 ID 信息。如果您不提供账户 ID，则系统会使用与您提供来对请求签名的证书相关联的账户 ID。有关更多信息，请参阅[将适用于 .NET 的 AWS SDK 与 Amazon Glacier 结合使用](using-aws-sdk-for-dot-net.md)。
Amazon Glacier 返回的输出位于 `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);
}
}
```
**注意**
有关任务相关的底层 REST API 的信息，请参阅[任务操作](job-operations.md)。
## 示例：使用文件库的低级 API 检索文件库库存 适用于 .NET 的 AWS SDK
以下 C\$1 代码示例会检索指定文件库的文件库清单。
该示例执行以下任务：
+ 设置 Amazon SNS 主题。
完成任务后，Amazon Glacier 会向此主题发送通知。
+ 设置 Amazon SQS 队列。
该示例会向该队列附加策略，以使 Amazon SNS 主题能够发布消息。
+ 启动任务以下载指定的档案。
在任务请求中，该示例会指定 Amazon SNS 主题，以便 Amazon Glacier 可以在完成任务后发送消息。
+ 定期检查 Amazon SQS 队列是否有消息。
如果有消息，则分析 JSON，并检查任务是否已成功完成。如果已成功完成，则下载档案。该代码示例使用 JSON.NET 库（请参阅 [JSON.NET](http://json.codeplex.com/)）来分析 JSON。
+ 通过删除它创建的 Amazon SNS 主题和 Amazon SQS 队列清除相关数据。
**Example**
```
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;
namespace glacier.amazon.com.rproxy.govskope.ca.docsamples
{
class VaultInventoryJobLowLevelUsingSNSSQS
{
static string topicArn;
static string queueUrl;
static string queueArn;
static string vaultName = "*** Provide vault name ***";
static string fileName = "*** Provide file name and path where to store inventory ***";
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("Retrieve Inventory List");
GetVaultInventory(client);
}
Console.WriteLine("Operations successful.");
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); }
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 { "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
{
{ QueueAttributeName.Policy, policy }
}
});
}
static void GetVaultInventory(AmazonGlacierClient client)
{
// Initiate job.
InitiateJobRequest initJobRequest = new InitiateJobRequest()
{
VaultName = vaultName,
JobParameters = new JobParameters()
{
Type = "inventory-retrieval",
Description = "This job is to download a vault inventory.",
SNSTopic = topicArn,
}
};
InitiateJobResponse initJobResponse = client.InitiateJob(initJobRequest);
string jobId = initJobResponse.JobId;
// Check queue for a message and if job completed successfully, download inventory.
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 outerLayer = JsonConvert.DeserializeObject>(message.Body);
Dictionary fields = JsonConvert.DeserializeObject>(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 inventory.");
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);
}
}
}
}
```
# 使用 REST API 下载文件库清单
**使用 REST API 下载文件库清单**
下载文件库清单是一个分为两个步骤的流程。
1. 启动 `inventory-retrieval` 类型的任务。有关更多信息，请参阅[启动任务（POST jobs）](api-initiate-job-post.md)。
1. 任务完成后，下载清单数据。有关更多信息，请参阅[获取任务输出（GET output）](api-job-output-get.md)。
# 使用 Amazon Glacier 下载文件库清单 AWS Command Line Interface
按照以下步骤操作，使用 AWS Command Line Interface （AWS CLI）在 Amazon Glacier（Amazon Glacier）中下载文件库清单。
**Topics**
+ [
## （先决条件）设置 AWS CLI
](#Creating-Vaults-CLI-Setup)
+ [
## 示例：使用下载文件库清单 AWS CLI
](#Retrieving-Vault-Inventory-CLI-Implementation)
## （先决条件）设置 AWS CLI
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 账户 身份证替换。
```
aws glacier list-vaults --account-id 123456789012
```
+ 要查看的当前配置数据 AWS CLI，请使用`aws configure list`命令。
```
aws configure list
```
## 示例：使用下载文件库清单 AWS CLI
1. 使用 `initiate-job` 命令启动清单检索任务。
```
aws glacier initiate-job --vault-name awsexamplevault --account-id 111122223333 --job-parameters='{"Type": "inventory-retrieval"}'
```
预期输出：
```
{
"location": "/111122223333/vaults/awsexamplevault/jobs/*** jobid ***",
"jobId": "*** jobid ***"
}
```
1. 使用 `describe-job` 命令检查上一个检索任务的状态。
```
aws glacier describe-job --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid ***
```
预期输出：
```
{
"InventoryRetrievalParameters": {
"Format": "JSON"
},
"VaultARN": "*** vault arn ***",
"Completed": false,
"JobId": "*** jobid ***",
"Action": "InventoryRetrieval",
"CreationDate": "*** job creation date ***",
"StatusCode": "InProgress"
}
```
1. 等待任务完成。
您必须等到任务输出已作好供您下载的准备。Amazon Glacier 完成任务后，任务 ID 至少在 24 小时内都不会过期。如果您在文件库中设置了通知配置，或者在启动任务时指定了 Amazon Simple Notification Service（Amazon SNS）主题，则 Amazon Glacier 会在完成任务后向该主题发送消息。
您可以设置文件库的特定事件的通知配置。有关更多信息，请参阅[在 Amazon Glacier 中配置文件库通知](configuring-notifications.md)。只要发生特定事件，Amazon Glacier 就会向指定的 SNS 主题发送消息。
1. 完成后，使用 `get-job-output` 命令将检索任务下载到文件 `output.json`。
```
aws glacier get-job-output --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid *** output.json
```
此命令会生成一个包含以下字段的文件。
```
{
"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":
...
]}
```
# 在 Amazon Glacier 中配置文件库通知
从 Amazon Glacier 检索任何内容（例如文件库中的档案或文件库清单）是一个分为两步的过程。
1. 启动检索任务。
1. 任务完成后，下载任务输出。
您可以在文件库上设置通知配置，以便在任务完成时向 Amazon Simple Notification Service（Amazon SNS）主题发送消息。
**Topics**
+ [
## 在 Amazon Glacier 中配置文件库通知：一般概念
](#configuring-notifications.general)
+ [
# 在 Amazon Glacier 中使用配置文件库通知 适用于 Java 的 AWS SDK
](configuring-notifications-sdk-java.md)
+ [
# 在 Amazon Glacier 中使用配置文件库通知 适用于 .NET 的 AWS SDK
](configuring-notifications-sdk-dotnet.md)
+ [
# 使用 REST API 在 Amazon Glacier 中配置文件库通知
](configuring-notifications-rest-api.md)
+ [
# 使用 Amazon Glacier 控制台配置文件库通知
](configuring-notifications-console.md)
+ [
# 使用配置文件库通知 AWS Command Line Interface
](configuring-notifications-cli.md)
## 在 Amazon Glacier 中配置文件库通知：一般概念
Amazon Glacier 检索任务请求是异步执行的。您必须等到 Amazon Glacier 完成任务，然后才能获取其输出。您可以定期轮询 Amazon Glacier 以确定任务状态，但这不是最佳方法。Amazon Glacier 还支持通知。任务完成后，任务可以将消息发布到 Amazon Simple Notification Service（Amazon SNS）主题。要使用此功能，您必须在文件库上设置通知配置。在配置中，您可以标识一个或多个事件，以及您希望 Amazon Glacier 在事件发生时向其发送消息的 Amazon SNS 主题。
Amazon Glacier 定义了与任务完成特别有关的事件（`ArchiveRetrievalCompleted`、`InventoryRetrievalCompleted`），您可以将这些事件添加到文件库的通知配置中。当特定任务完成时，Amazon Glacier 会向 SNS 主题发布通知消息。
通知配置是 JSON 文档，如以下示例所示。
```
{
"SNSTopic": "arn:aws:sns:us-west-2:012345678901:mytopic",
"Events": ["ArchiveRetrievalCompleted", "InventoryRetrievalCompleted"]
}
```
请注意，对于一个文件库，您只能配置一个 Amazon SNS 主题。
**注意**
向文件库添加通知配置会使 Amazon Glacier 在通知配置中指定的事件每次发生时都发送通知。此外，您还可以选择性地在每个任务启动请求中指定 Amazon SNS 主题。如果您在文件库中添加了通知配置，并且在您的启动任务请求中也指定了 Amazon SNS 主题，则 Amazon Glacier 会发送这两种通知。
Amazon Glacier 发送的任务完成消息包括任务类型（`InventoryRetrieval`、`ArchiveRetrieval`）、任务完成状态、SNS 主题名称、任务状态代码和文件库 ARN 等信息。以下是 Amazon Glacier 在 `InventoryRetrieval` 任务完成后发送到 SNS 主题的示例通知。
```
{
"Action": "InventoryRetrieval",
"ArchiveId": null,
"ArchiveSizeInBytes": null,
"Completed": true,
"CompletionDate": "2012-06-12T22:20:40.790Z",
"CreationDate": "2012-06-12T22:20:36.814Z",
"InventorySizeInBytes":11693,
"JobDescription": "my retrieval job",
"JobId":"HkF9p6o7yjhFx-K3CGl6fuSm6VzW9T7esGQfco8nUXVYwS0jlb5gq1JZ55yHgt5vP54ZShjoQzQVVh7vEXAMPLEjobID",
"SHA256TreeHash":null,
"SNSTopic": "arn:aws:sns:us-west-2:012345678901:mytopic",
"StatusCode":"Succeeded",
"StatusMessage": "Succeeded",
"VaultARN": "arn:aws:glacier:us-west-2:012345678901:vaults/examplevault"
}
```
此外，如果 `Completed` 字段为 true，则您还必须检查 `StatusCode` 以查看任务是成功完成了还是失败了。
**注意**
请注意，Amazon SNS 主题必须允许文件库发布通知。默认情况下，只有 Amazon SNS 主题拥有者才能向主题发布消息。但是，如果 Amazon SNS 主题和文件库归其他人所有 AWS 账户，则必须将 Amazon SNS 主题配置为接受文件库中的出版物。您可以在 Amazon SNS 控制台中配置 Amazon SNS 主题策略。
有关 Amazon SNS 的更多信息，请参阅 [Amazon SNS 入门](https://docs.aws.amazon.com/sns/latest/gsg/Welcome.html)。
# 在 Amazon Glacier 中使用配置文件库通知 适用于 Java 的 AWS SDK
以下是使用 适用于 Java 的 AWS SDK低级 API 在文件库中配置通知的步骤。
1. 创建 `AmazonGlacierClient` 类（客户端）的实例。
您需要指定文件库所在的 AWS 区域。您使用此客户端执行的所有操作都适用于该 AWS 区域。
1. 通过创建一个 `SetVaultNotificationsRequest` 类的实例提供通知配置信息。
您需要提供文件库名称、通知配置信息和账户 ID。在指定通知配置时，您可以提供一个现有的 Amazon SNS 主题的 Amazon 资源名称（ARN），以及您希望获得其通知的一个或多个事件。有关受支持的事件的列表，请参阅[设置文件库通知配置（PUT notification-configuration）](api-vault-notifications-put.md)。
1. 以参数形式提供请求对象，运行 `setVaultNotifications` 方法。
以下 Java 代码段说明了前面的步骤。该代码段在文件库中设置了通知配置。当 `ArchiveRetrievalCompleted` 事件或 `InventoryRetrievalCompleted` 事件发生时，该配置会请求 Amazon Glacier（Amazon Glacier）向指定的 Amazon SNS 主题发送通知。
```
SetVaultNotificationsRequest request = new SetVaultNotificationsRequest()
.withAccountId("-")
.withVaultName("*** provide vault name ***")
.withVaultNotificationConfig(
new VaultNotificationConfig()
.withSNSTopic("*** provide SNS topic ARN ***")
.withEvents("ArchiveRetrievalCompleted", "InventoryRetrievalCompleted")
);
client.setVaultNotifications(request);
```
**注意**
有关底层 REST API 的信息，请参阅[文件库操作](vault-operations.md)。
## 示例：使用在文件库上设置通知配置 适用于 Java 的 AWS SDK
以下 Java 代码示例设置了文件库的通知配置并删除了配置，然后恢复了配置。有关如何运行以下示例的 step-by-step说明，请参阅[适用于 Java 的 AWS SDK 与 Amazon Glacier 搭配使用](using-aws-sdk-for-java.md)。
**Example**
```
import java.io.IOException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.glacier.AmazonGlacierClient;
import com.amazonaws.services.glacier.model.DeleteVaultNotificationsRequest;
import com.amazonaws.services.glacier.model.GetVaultNotificationsRequest;
import com.amazonaws.services.glacier.model.GetVaultNotificationsResult;
import com.amazonaws.services.glacier.model.SetVaultNotificationsRequest;
import com.amazonaws.services.glacier.model.VaultNotificationConfig;
public class AmazonGlacierVaultNotifications {
public static AmazonGlacierClient client;
public static String vaultName = "*** provide vault name ****";
public static String snsTopicARN = "*** provide sns topic ARN ***";
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 {
System.out.println("Adding notification configuration to the vault.");
setVaultNotifications();
getVaultNotifications();
deleteVaultNotifications();
} catch (Exception e) {
System.err.println("Vault operations failed." + e.getMessage());
}
}
private static void setVaultNotifications() {
VaultNotificationConfig config = new VaultNotificationConfig()
.withSNSTopic(snsTopicARN)
.withEvents("ArchiveRetrievalCompleted", "InventoryRetrievalCompleted");
SetVaultNotificationsRequest request = new SetVaultNotificationsRequest()
.withVaultName(vaultName)
.withVaultNotificationConfig(config);
client.setVaultNotifications(request);
System.out.println("Notification configured for vault: " + vaultName);
}
private static void getVaultNotifications() {
VaultNotificationConfig notificationConfig = null;
GetVaultNotificationsRequest request = new GetVaultNotificationsRequest()
.withVaultName(vaultName);
GetVaultNotificationsResult result = client.getVaultNotifications(request);
notificationConfig = result.getVaultNotificationConfig();
System.out.println("Notifications configuration for vault: "
+ vaultName);
System.out.println("Topic: " + notificationConfig.getSNSTopic());
System.out.println("Events: " + notificationConfig.getEvents());
}
private static void deleteVaultNotifications() {
DeleteVaultNotificationsRequest request = new DeleteVaultNotificationsRequest()
.withVaultName(vaultName);
client.deleteVaultNotifications(request);
System.out.println("Notifications configuration deleted for vault: " + vaultName);
}
}
```
# 在 Amazon Glacier 中使用配置文件库通知 适用于 .NET 的 AWS SDK
以下是使用 适用于 .NET 的 AWS SDK低级 API 在文件库中配置通知的步骤。
1. 创建 `AmazonGlacierClient` 类（客户端）的实例。
您需要指定文件库所在的 AWS 区域。您使用此客户端执行的所有操作都适用于该 AWS 区域。
1. 通过创建一个 `SetVaultNotificationsRequest` 类的实例提供通知配置信息。
您需要提供文件库名称、通知配置信息和账户 ID。如果您不提供账户 ID，则系统会使用与您提供来对请求签名的证书相关联的账户 ID。有关更多信息，请参阅[将适用于 .NET 的 AWS SDK 与 Amazon Glacier 结合使用](using-aws-sdk-for-dot-net.md)。
在指定通知配置时，您可以提供一个现有的 Amazon SNS 主题的 Amazon 资源名称（ARN），以及您希望获得其通知的一个或多个事件。有关受支持的事件的列表，请参阅[设置文件库通知配置（PUT notification-configuration）](api-vault-notifications-put.md)。
1. 以参数形式提供请求对象，运行 `SetVaultNotifications` 方法。
1. 在文件库中设置通知配置后，您可以通过调用 `GetVaultNotifications` 方法检索配置信息，也可以通过调用客户端提供的 `DeleteVaultNotifications` 方法删除它。
## 示例：使用在文件库上设置通知配置 适用于 .NET 的 AWS SDK
以下 C\$1 代码示例说明了前面的步骤。该示例在美国西部（俄勒冈州）区域的文件库（“`examplevault`”）中设置了通知配置并检索了配置，然后删除了配置。当 `ArchiveRetrievalCompleted` 事件或 `InventoryRetrievalCompleted` 事件发生时，该配置会请求 Amazon Glacier（Amazon Glacier）向指定的 Amazon SNS 主题发送通知。
**注意**
有关底层 REST API 的信息，请参阅[文件库操作](vault-operations.md)。
有关运行以下示例的 step-by-step说明，请参阅[运行代码示例](using-aws-sdk-for-dot-net.md#setting-up-and-testing-sdk-dotnet)。您需要更新该代码并提供现有的文件库名称和 Amazon SNS 主题。
**Example**
```
using System;
using System.Collections.Generic;
using Amazon.Glacier;
using Amazon.Glacier.Model;
using Amazon.Runtime;
namespace glacier.amazon.com.rproxy.govskope.ca.docsamples
{
class VaultNotificationSetGetDelete
{
static string vaultName = "examplevault";
static string snsTopicARN = "*** Provide Amazon SNS topic ARN ***";
static IAmazonGlacier client;
public static void Main(string[] args)
{
try
{
using (client = new AmazonGlacierClient(Amazon.RegionEndpoint.USWest2))
{
Console.WriteLine("Adding notification configuration to the vault.");
SetVaultNotificationConfig();
GetVaultNotificationConfig();
Console.WriteLine("To delete vault notification configuration, press Enter");
Console.ReadKey();
DeleteVaultNotificationConfig();
}
}
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 SetVaultNotificationConfig()
{
SetVaultNotificationsRequest request = new SetVaultNotificationsRequest()
{
VaultName = vaultName,
VaultNotificationConfig = new VaultNotificationConfig()
{
Events = new List() { "ArchiveRetrievalCompleted", "InventoryRetrievalCompleted" },
SNSTopic = snsTopicARN
}
};
SetVaultNotificationsResponse response = client.SetVaultNotifications(request);
}
static void GetVaultNotificationConfig()
{
GetVaultNotificationsRequest request = new GetVaultNotificationsRequest()
{
VaultName = vaultName,
AccountId = "-"
};
GetVaultNotificationsResponse response = client.GetVaultNotifications(request);
Console.WriteLine("SNS Topic ARN: {0}", response.VaultNotificationConfig.SNSTopic);
foreach (string s in response.VaultNotificationConfig.Events)
Console.WriteLine("Event : {0}", s);
}
static void DeleteVaultNotificationConfig()
{
DeleteVaultNotificationsRequest request = new DeleteVaultNotificationsRequest()
{
VaultName = vaultName
};
DeleteVaultNotificationsResponse response = client.DeleteVaultNotifications(request);
}
}
}
```
# 使用 REST API 在 Amazon Glacier 中配置文件库通知
要使用 REST API 配置文件库通知，请参阅[设置文件库通知配置（PUT notification-configuration）](api-vault-notifications-put.md)。此外，您还可以获取文件库通知（[获取文件库通知（GET notification-configuration）](api-vault-notifications-get.md)）以及删除文件库通知（[删除文件库通知（DELETE notification-configuration）](api-vault-notifications-delete.md)）。
# 使用 Amazon Glacier 控制台配置文件库通知
此部分描述了如何使用 Amazon Glacier 控制台配置文件库通知。在配置通知时，您可以指定向 Amazon Simple Notification Service (Amazon SNS) 主题发送通知的任务完成事件。除了为文件库配置通知以外，您还可以指定您在启动任务时要向其发布通知的主题。如果您的文件库已配置为针对特定的事件发送通知，并且您还在任务启动请求中配置了通知，则系统会发送两份通知。
**配置文件库通知**
1. 登录 AWS 管理控制台 并在家中打开 Amazon Glacier [https://console.aws.amazon.com/glacier/主](https://console.aws.amazon.com/glacier/home)机。
1. 在左侧导航窗格中，选择**文件库**。
1. 在**文件库**列表中，选择一个文件库。
1. 在**通知**部分中，选择**编辑**。
1. 在**事件通知**页面上，选择**启用通知**。
1. 在**通知**部分，选择以下 Amazon Simple Notification Service（Amazon SNS）选项之一，然后按照相应的步骤进行操作：
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/amazonglacier/latest/dev/configuring-notifications-console.html)
1. 在**事件**下，选择一个或两个要发送通知的事件：
+ 要仅在档案检索任务完成时才发送通知，请选择**档案检索任务完成**。
+ 要仅在文件库清单任务完成时才发送通知，请选择**文件库清单检索任务完成**。
# 使用配置文件库通知 AWS Command Line Interface
此部分描述了如何使用 AWS Command Line Interface配置文件库通知。配置通知时，您可以指定任务完成事件，这些事件会触发向 Amazon Simple Notification Service（Amazon SNS）主题发送通知。除了为文件库配置通知以外，您还可以指定您在启动任务时要向其发布通知的主题。如果您的文件库已配置为针对特定的事件发送通知，并且您在任务启动请求中指定了通知，则系统会发送两份通知。
按照以下步骤使用 AWS CLI配置文件库通知。
**Topics**
+ [
## （先决条件）设置 AWS CLI
](#Creating-Vaults-CLI-Setup)
+ [
## 示例：使用配置文件库通知 AWS CLI
](#Configure-Vault-Notifications-CLI-Implementation)
## （先决条件）设置 AWS CLI
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 账户 身份证替换。
```
aws glacier list-vaults --account-id 123456789012
```
+ 要查看的当前配置数据 AWS CLI，请使用`aws configure list`命令。
```
aws configure list
```
## 示例：使用配置文件库通知 AWS CLI
1. 使用 `set-vault-notifications` 命令配置在文件库发生特定事件时将发送的通知。默认情况下，您不会收到任何通知。
```
aws glacier set-vault-notifications --vault-name examplevault --account-id 111122223333 --vault-notification-config file://notificationconfig.json
```
1. 通知配置是 JSON 文档，如以下示例所示。
```
{
"SNSTopic": "arn:aws:sns:us-west-2:012345678901:mytopic",
"Events": ["ArchiveRetrievalCompleted", "InventoryRetrievalCompleted"]
}
```
有关对 Amazon Glacier 使用 Amazon SNS 主题的更多信息，请参阅[在 Amazon Glacier 中配置文件库通知：一般概念](configuring-notifications.html#configuring-notifications.general)
有关 Amazon SNS 的更多信息，请参阅 [Amazon SNS 入门](https://docs.aws.amazon.com/sns/latest/gsg/Welcome.html)。
# 在 Amazon Glacier 中删除文件库
只有在自上次计算的清单起文件库中没有任何档案，并且自上次清单盘点以来没有对文件库执行过任何写入操作时，Amazon Glacier（Amazon Glacier）才会删除文件库。有关删除存档的信息，请参阅[删除 Amazon Glacier 中的档案](deleting-an-archive.md)。有关下载文件库清单，请参阅[在 Amazon Glacier 中下载文件库清单](vault-inventory.md)。
**注意**
Amazon Glacier 每 24 小时会定期为每个文件库准备一份清单。由于清单可能没有反映最新信息，因此，Amazon Glacier 会通过检查自上次文件库清单盘点以来是否执行过任何写入操作来确保文件库确实是空的。
**注意**
有关自动删除文件库档案的信息，请参阅[在 Amazon S3 Glacier 中自动删除文件库档案](https://aws.amazon.com/solutions/guidance/automated-deletion-of-vault-archives-in-amazon-s3-glacier/)。
**Topics**
+ [
# 使用适用于 Java 的 AWS SDK 在 Amazon Glacier 中删除文件库
](deleting-vaults-sdk-java.md)
+ [
# 使用适用于 .NET 的 AWS SDK 在 Amazon Glacier 中删除文件库
](deleting-vaults-sdk-dotnet.md)
+ [
# 使用 REST API 在 Amazon Glacier 中删除文件库
](deleting-vault-rest-api.md)
+ [
# 使用 Amazon Glacier 控制台删除空文件库
](deleting-vaults-console.md)
+ [
# 在 Amazon Glacier 中删除文件库使用 AWS Command Line Interface
](deleting-vaults-cli.md)
# 使用适用于 Java 的 AWS SDK 在 Amazon Glacier 中删除文件库
以下是使用适用于 Java 的 AWS SDK 低级 API 删除文件库的步骤。
1. 创建 `AmazonGlacierClient` 类（客户端）的实例。
您需要指定要从中删除文件库的 AWS 区域。您使用此客户端执行的所有操作都会应用到该 AWS 区域。
1. 通过创建一个 `DeleteVaultRequest` 类的实例提供请求信息。
您需要提供文件库名称和账户 ID。如果您不提供账户 ID，则系统会使用与您提供来对请求签名的证书相关联的账户 ID。有关更多信息，请参阅[适用于 Java 的 AWS SDK 与 Amazon Glacier 搭配使用](using-aws-sdk-for-java.md)。
1. 以参数形式提供请求对象，运行 `deleteVault` 方法。
Amazon Glacier（Amazon Glacier）只会删除空文件库。有关更多信息，请参阅[删除文件库（DELETE vault）](api-vault-delete.md)。
以下 Java 代码段说明了前面的步骤。
```
try {
DeleteVaultRequest request = new DeleteVaultRequest()
.withVaultName("*** provide vault name ***");
client.deleteVault(request);
System.out.println("Deleted vault: " + vaultName);
} catch (Exception e) {
System.err.println(e.getMessage());
}
```
**注意**
有关底层 REST API 的信息，请参阅[删除文件库（DELETE vault）](api-vault-delete.md)。
## 示例：使用适用于 Java 的 AWS SDK 删除文件库
有关工作代码示例，请参阅[示例：使用适用于 Java 的 AWS SDK 创建文件库](creating-vaults-sdk-java.md#creating-vaults-sdk-java-example)。该 Java 代码示例显示了基本文件库操作，包括创建和删除文件库。
# 使用适用于 .NET 的 AWS SDK 在 Amazon Glacier 中删除文件库
适用于 .NET 的 Amazon SDK 提供的[高级和低级 API](using-aws-sdk.md) 都提供了删除文件库的方法。
**Topics**
+ [
## 使用适用于 .NET 的 AWS SDK 高级 API 删除文件库
](#deleting-vault-sdk-dotnet-high-level)
+ [
## 使用适用于 .NET 的 AWS SDK 低级 API 删除文件库
](#deleting-vault-sdk-dotnet-low-level)
## 使用适用于 .NET 的 AWS SDK 高级 API 删除文件库
该高级 API 的 `ArchiveTransferManager` 类提供了您可以用来删除文件库的 `DeleteVault` 方法。
### 示例：使用适用于 .NET 的 AWS SDK 高级 API 删除文件库
有关工作代码示例，请参阅[示例：使用高级 API 进行文件库操作 适用于 .NET 的 AWS SDK](creating-vaults-dotnet-sdk.md#vault-operations-example-dotnet-highlevel)。该 C\$1 代码示例显示了基本文件库操作，包括创建和删除文件库。
## 使用适用于 .NET 的 AWS SDK 低级 API 删除文件库
以下是使用适用于 .NET 的 AWS SDK 删除文件库的步骤。
1. 创建 `AmazonGlacierClient` 类（客户端）的实例。
您需要指定要从中删除文件库的 AWS 区域。您使用此客户端执行的所有操作都会应用到该 AWS 区域。
1. 通过创建一个 `DeleteVaultRequest` 类的实例提供请求信息。
您需要提供文件库名称和账户 ID。如果您不提供账户 ID，则系统会使用与您提供来对请求签名的证书相关联的账户 ID。有关更多信息，请参阅[将适用于 .NET 的 AWS SDK 与 Amazon Glacier 结合使用](using-aws-sdk-for-dot-net.md)。
1. 以参数形式提供请求对象，运行 `DeleteVault` 方法。
Amazon Glacier（Amazon Glacier）只会删除空文件库。有关更多信息，请参阅[删除文件库（DELETE vault）](api-vault-delete.md)。
以下 C\$1 代码段说明了前面的步骤。该代码段会检索存在于默认 AWS 区域的文件库的元数据信息。
```
AmazonGlacier client;
client = new AmazonGlacierClient(Amazon.RegionEndpoint.USEast1);
DeleteVaultRequest request = new DeleteVaultRequest()
{
VaultName = "*** provide vault name ***"
};
DeleteVaultResponse response = client.DeleteVault(request);
```
**注意**
有关底层 REST API 的信息，请参阅[删除文件库（DELETE vault）](api-vault-delete.md)。
### 示例：使用适用于 .NET 的 AWS SDK 低级 API 删除文件库
有关工作代码示例，请参阅[示例：使用的低级 API 进行文件库操作 适用于 .NET 的 AWS SDK](creating-vaults-dotnet-sdk.md#vault-operations-example-dotnet-lowlevel)。该 C\$1 代码示例显示了基本文件库操作，包括创建和删除文件库。
# 使用 REST API 在 Amazon Glacier 中删除文件库
要使用 REST API 删除文件库，请参阅[删除文件库（DELETE vault）](api-vault-delete.md)。
# 使用 Amazon Glacier 控制台删除空文件库
**注意**
在删除文件库之前，必须先删除该文件库中的所有现有档案。为此，您可以使用 REST API、 适用于 .NET 的 AWS SDK、或使用 AWS Command Line Interface (AWS CLI) 编写代码来发出删除档案请求。 适用于 Java 的 AWS SDK有关删除档案的信息，请参阅[步骤 5：从 Amazon Glacier 中的文件库删除档案](getting-started-delete-archive.md)。
文件库为空后，可以使用以下步骤将其删除。
**使用 Amazon Glacier 控制台删除空文件库**
1. 登录 AWS 管理控制台 并在亚马逊 Glacier 控制台上打开亚马[逊 Glacier 控制台](https://console.aws.amazon.com/glacier/home)。
1. 在 **“选择区域”** 下，选择文件库 AWS 区域 所在的位置。
1. 在左侧导航窗格中，选择**文件库**。
1. 在**文件库**列表中，选择要删除的文件库名称旁边的选项按钮，然后选择页面顶部的**删除**。
1. 在**删除文件库**对话框中，选择 **删除**以确认要删除文件库。
**重要**
删除文件库的操作无法撤消。
1. 要验证您是否已删除文件库，请打开**文件库**列表并输入您删除的文件库的名称。如果无法找到此文件库，则表示删除成功。
# 在 Amazon Glacier 中删除文件库使用 AWS Command Line Interface
可以使用 AWS Command Line Interface （AWS CLI）删除 Amazon Glacier（Amazon Glacier）中的空文件库和非空文件库。
**Topics**
+ [
## （先决条件）设置 AWS CLI
](#Creating-Vaults-CLI-Setup)
+ [
## 示例：使用删除空文件库 AWS CLI
](#Deleting-Empty-Vaults-CLI-Implementation)
+ [
## 示例：使用删除非空文件库 AWS CLI
](#Deleting-A-Nonempty-Vaults-CLI-Implementation)
## （先决条件）设置 AWS CLI
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 账户 身份证替换。
```
aws glacier list-vaults --account-id 123456789012
```
+ 要查看的当前配置数据 AWS CLI，请使用`aws configure list`命令。
```
aws configure list
```
## 示例：使用删除空文件库 AWS CLI
+ 使用 `delete-vault` 命令删除不包含存档的文件库。
+
```
aws glacier delete-vault --vault-name awsexamplevault --account-id 111122223333
```
## 示例：使用删除非空文件库 AWS CLI
只有在自上次计算的清单起文件库中没有任何档案，并且自上次清单盘点以来没有对文件库执行过任何写入操作时，Amazon Glacier 才会删除文件库。删除非空文件库分为三个步骤： IDs从文件库的库存报告中检索档案，删除每个档案，然后删除文件库。
1. 使用 `initiate-job` 命令启动清单检索任务。
```
aws glacier initiate-job --vault-name awsexamplevault --account-id 111122223333 --job-parameters '{"Type": "inventory-retrieval"}'
```
预期输出：
```
{
"location": "/111122223333/vaults/awsexamplevault/jobs/*** jobid ***",
"jobId": "*** jobid ***"
}
```
1. 使用 `describe-job` 命令检查上一个检索任务的状态。
```
aws glacier describe-job --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid ***
```
预期输出：
```
{
"InventoryRetrievalParameters": {
"Format": "JSON"
},
"VaultARN": "*** vault arn ***",
"Completed": false,
"JobId": "*** jobid ***",
"Action": "InventoryRetrieval",
"CreationDate": "*** job creation date ***",
"StatusCode": "InProgress"
}
```
1. 等待任务完成。
您必须等到任务输出已作好供您下载的准备。如果您在文件库中设置了通知配置，或者在启动任务时指定了 Amazon Simple Notification Service（Amazon SNS）主题，则 Amazon Glacier 会在完成任务后向该主题发送消息。
您可以设置文件库的特定事件的通知配置。有关更多信息，请参阅[在 Amazon Glacier 中配置文件库通知](configuring-notifications.md)。只要发生特定事件，Amazon Glacier 就会向指定的 SNS 主题发送消息。
1. 完成后，使用 `get-job-output` 命令将检索任务下载到文件 `output.json`。
```
aws glacier get-job-output --vault-name awsexamplevault --account-id 111122223333 --job-id *** jobid *** output.json
```
此命令会生成一个包含以下字段的文件。
```
{
"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. 使用 `delete-archive` 命令从文件库中删除每个档案，直到不保留任何档案。
```
aws glacier delete-archive --vault-name awsexamplevault --account-id 111122223333 --archive-id "*** archiveid ***"
```
**注意**
如果您的档案 ID 以连字符或其他特殊字符开头，则需要将其放在引号中才能运行此命令。
1. 使用 `initiate-job` 命令启动新的清单检索任务。
```
aws glacier initiate-job --vault-name awsexamplevault --account-id 111122223333 --job-parameters '{"Type": "inventory-retrieval"}'
```
1. 完成后，使用 `delete-vault` 命令删除不带存档的文件库。
```
aws glacier delete-vault --vault-name awsexamplevault --account-id 111122223333
```
# 标记 Amazon Glacier 文件库
您可以标签形式将自己的元数据分配给 Amazon Glacier 文件库。*标签*是您为文件库定义的键-值对。有关标记的基本信息（包括对标签的限制），请参阅[标记 Amazon Glacier 资源](tagging.md)。
以下主题介绍了如何为文件库添加、列出和删除标签。
**Topics**
+ [
## 使用 Amazon Glacier 控制台标记文件库
](#tagging-console)
+ [
## 使用 AWS CLI 为标记文件库
](#tagging-cli)
+ [
## 使用 Amazon Glacier API 标记文件库
](#tagging-api)
+ [
## 相关部分
](#related-sections-tagging-vaults)
## 使用 Amazon Glacier 控制台标记文件库
可以使用 Amazon Glacier 控制台添加、列出和删除标签，如下列步骤中所述。
**查看文件库的标签**
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon Glacier 控制台：[https://console.aws.amazon.com/glacier/home](https://console.aws.amazon.com/glacier/home)。
1. 在**选择区域**下，从“区域”选择器中选择 AWS 区域。
1. 在左侧导航窗格中，选择**文件库**。
1. 在**文件库**列表中，选择一个文件库。
1. 选择**文件库属性**选项卡。滚动至**标签**部分，查看与文件库关联的标签。
**向文件库添加标签**
一个文件库最多可以关联 50 个标签。与文件库关联的标签必须具有唯一的标签键。
有关标签限制的更多信息，请参阅[标记 Amazon Glacier 资源](https://docs.aws.amazon.com/amazonglacier/latest/dev/tagging.html)。
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon Glacier 控制台：[https://console.aws.amazon.com/glacier/home](https://console.aws.amazon.com/glacier/home)。
1. 在**选择区域**下，从“区域”选择器中选择 AWS 区域。
1. 在左侧导航窗格中，选择**文件库**。
1. 在**文件库**列表中，选择要将标签添加到的文件库的名称。
1. 选择**文件库属性**选项卡。
1. 在**标签**部分中，选择**添加**。此时将显示**添加标签**页面。
1. 在**添加标签**页面的**键**字段中指定标签键，然后也可以选择在**值**字段中指定标签值。
1. 选择**保存更改**。
**编辑标签**
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon Glacier 控制台：[https://console.aws.amazon.com/glacier/home](https://console.aws.amazon.com/glacier/home)。
1. 在**选择区域**下，从“区域”选择器中选择 AWS 区域。
1. 在左侧导航窗格中，选择**文件库**。
1. 在**文件库**列表中，选择文件库名称。
1. 选择**文件库属性**选项卡，然后向下滚动到**标签**部分。
1. 在**标签**下，选中要更改的标签旁边的复选框，然后选择**编辑**。将出现**编辑标签**页面。
1. 更新**键**字段中的标签，也可以选择更新**值**字段中的标签。
1. 选择**保存更改**。
**从文件库中删除标签**
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon Glacier 控制台：[https://console.aws.amazon.com/glacier/home](https://console.aws.amazon.com/glacier/home)。
1. 在**选择区域**下，从“区域”选择器中选择 AWS 区域。
1. 在左侧导航窗格中，选择**文件库**。
1. 在**文件库**列表中，选择要从中删除标签的文件库的名称。
1. 选择**文件库属性**选项卡。向下滚动到**标签**部分。
1. 在**标签**下，选中要删除的标签旁边的复选框，然后选择**删除**。
1. 此时将打开**删除标签**对话框。要确认删除已选择的标签，请选择**删除**。
## 使用 AWS CLI 为标记文件库
按照以下步骤，使用 AWS Command Line Interface（AWS CLI）添加、列出或删除标签。
每个标签由一个键和一个值组成。每个文件库可最多有 50 个标签。
1. 要将标签添加到文件库，请使用 `add-tags-to-vault` 命令。
```
aws glacier add-tags-to-vault --vault-name examplevault --account-id 111122223333 --tags id=1234,date=2020
```
有关此文件库操作的更多信息，请参阅[向文件库添加标签](https://docs.aws.amazon.com/amazonglacier/latest/dev/api-AddTagsToVault.html)。
1. 要列出已附加到文件库的所有标签，请使用 `list-tags-for-vault` 命令。
```
aws glacier list-tags-for-vault --vault-name examplevault --account-id 111122223333
```
有关此文件库操作的更多信息，请参阅[列出文件库的标签](https://docs.aws.amazon.com/amazonglacier/latest/dev/api-ListTagsForVault.html)。
1. 要从已附加到文件库的标签集中删除一个或多个标签，请使用 `remove-tags-from-vault` 命令。
```
aws glacier remove-tags-from-vault --vault-name examplevault --account-id 111122223333 --tag-keys date
```
有关此文件库操作的更多信息，请参阅[删除文件库中的标签](https://docs.aws.amazon.com/amazonglacier/latest/dev/api-RemoveTagsFromVault.html)。
## 使用 Amazon Glacier API 标记文件库
您可以使用 Amazon Glacier API 添加、列出和删除标签。有关示例，请参阅以下文档：
[向文件库添加标签（POST tags add）](api-AddTagsToVault.md)
为指定文件库添加或更新标签。
[列出文件库的标签（GET tags）](api-ListTagsForVault.md)
列出指定文件库的标签。
[从文件库删除标签（POST tags remove）](api-RemoveTagsFromVault.md)
从指定文件库中删除标签。
## 相关部分
+ [标记 Amazon Glacier 资源](tagging.md)
# Amazon Glacier 文件库锁定
以下主题介绍了如何在 Amazon Glacier 中锁定文件库以及如何使用文件库锁定策略。
**Topics**
+ [
## 文件库锁定概述
](#vault-lock-overview)
+ [
# 使用 Amazon Glacier API 锁定文件库
](vault-lock-how-to-api.md)
+ [
# 使用锁定文件库 AWS Command Line Interface
](vault-lock-how-to-cli.md)
+ [
# 使用 Amazon Glacier 控制台锁定文件库
](vault-lock-walkthrough.md)
## 文件库锁定概述
通过 Amazon Glacier 文件库锁定，您可以轻松利用文件库锁定策略对单独的 Amazon Glacier 文件库进行部署并实施合规性控制。您可以在一个文件库锁定策略中指定类似“一次写入，多次读取”（WORM）这样的控制措施，并且可以锁定该策略以防止将来进行编辑。
**重要**
文件库锁定策略被锁定后，将无法再更改或删除该策略。
Amazon Glacier 实施文件库锁定策略中的控制集，以帮助实现合规性目标。例如，您可以使用文件库锁定策略来强制实施数据留存。您可以使用 AWS Identity and Access Management (IAM) 策略语言在文件库锁定策略中部署各种合规性控制。有关文件库锁定策略的更多信息，请参阅[文件库锁定策略](vault-lock-policy.md)。
文件库锁定策略与文件库访问策略不同。但两者都管理对文件库的访问控制权。但是，文件库锁定策略可进行锁定以防止将来更改，从而强有力地实施您的合规性控制措施。您可以使用文件库锁定策略来部署法规和合规性控制措施，这通常需要对数据访问进行严密控制。
**重要**
建议您先创建文件库，完成文件库锁定策略，然后将您的档案上传到文件库，以便将该策略应用于它们。
相反，您可使用文件库访问策略来实施与合规性无关、临时以及需要经常修改的访问控制。文件库锁定策略和文件库访问策略可一起使用。例如，您可在文件库锁定策略中实施基于时间的数据保留规则（拒绝删除），并且在文件库访问策略中为指定的第三方或您的业务合作伙伴授予读取访问权限（允许读取）。
锁定文件库需要执行两个步骤：
1. 通过将文件库锁定策略附加到您的文件库来启动锁定，这会将锁定设置为正在进行状态并返回一个锁定 ID。当策略处于正在进行状态时，在锁定 ID 到期前，您有 24 个小时来验证文件库锁定策略。为防止您的文件库退出正在进行状态，必须在 24 小时内完成文件库锁定流程。否则，您的文件库锁定策略将被删除。
1. 使用锁定 ID 完成锁定过程。如果文件库锁定策略未按预期工作，可停止文件库锁定并从头开始重新启动。有关如何使用 Amazon Glacier API 来锁定文件库的信息，请参阅[使用 Amazon Glacier API 锁定文件库](vault-lock-how-to-api.md)。
# 使用 Amazon Glacier API 锁定文件库
要使用 Amazon Glacier API 锁定文件库，请先使用指定了待部署控件的文件库锁定策略调用[启动文件库锁定（POST lock-policy）](api-InitiateVaultLock.md)。`Initiate Vault Lock` 操作会将策略附加到您的文件库，将文件库锁定转换为进行中状态，并返回一个唯一的锁定 ID。在文件库锁定进入进行中状态后，您有 24 小时的时间来利用从 `Initiate Vault Lock` 调用返回的锁定 ID 调用 [完成文件库锁定（POST lockId）](api-CompleteVaultLock.md)，以便完成锁定。
**重要**
建议您先创建文件库，完成文件库锁定策略，然后将您的档案上传到文件库，以便将该策略应用于它们。
文件库锁定策略在被锁定后即不能更改或删除。
如果您在进入正在进行状态后的 24 个小时内未完成文件库锁定过程，则您的文件库会自动退出正在进行状态，并删除文件库锁定策略。您可以再次调用 `Initiate Vault Lock` 来安装新的文件库锁定策略并转换到正在进行状态。
利用正在进行状态，您有机会在锁定您的文件库锁定策略之前对其进行测试。您的文件库锁定策略在正在进行状态期间将会完全生效，就如同文件库已锁定一样，只不过您可以通过调用 [中止文件库锁定（DELETE lock-policy）](api-AbortVaultLock.md) 来删除该策略。要优化您的策略，可根据需要多次重复 `Abort Vault Lock`/`Initiate Vault Lock` 组合，验证您的文件库锁定策略更改。
在验证文件库锁定策略之后，您可使用最新的锁定 ID 调用 [完成文件库锁定（POST lockId）](api-CompleteVaultLock.md)，以便完成文件库锁定过程。您的文件库会转换为锁定状态（此时，文件库锁定策略不可更改），而且无法再通过调用 `Abort Vault Lock` 进行删除。
## 相关部分
+ [文件库锁定策略](vault-lock-policy.md)
+ [中止文件库锁定（DELETE lock-policy）](api-AbortVaultLock.md)
+ [完成文件库锁定（POST lockId）](api-CompleteVaultLock.md)
+ [获取文件库锁定（GET lock-policy）](api-GetVaultLock.md)
+ [启动文件库锁定（POST lock-policy）](api-InitiateVaultLock.md)
# 使用锁定文件库 AWS Command Line Interface
您可以使用锁定您的保管库 AWS Command Line Interface。这将对指定的文件库实施文件库锁定策略并返回锁定 ID。您必须在 24 小时内完成文件库锁定过程，否则该文件库锁定策略将从文件库中删除。
## （先决条件）设置 AWS CLI
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 账户 身份证替换。
```
aws glacier list-vaults --account-id 123456789012
```
+ 要查看的当前配置数据 AWS CLI，请使用`aws configure list`命令。
```
aws configure list
```
1. 使用 `initiate-vault-lock` 实施文件库锁定策略，并将文件库锁定的锁定状态设置为 `InProgress`。
```
aws glacier initiate-vault-lock --vault-name examplevault --account-id 111122223333 --policy file://lockconfig.json
```
1. 锁定配置是 JSON 文档，如以下示例所示。在使用此命令之前，请将*VAULT\$1ARN*和*Principal*替换为适合您的用例的值。
要查找要锁定的文件库的 ARN，可以使用 `list-vaults` 命令。
```
{"Policy":"{\"Version\":\"2012-10-17\", \"Statement\":[{\"Sid\":\"Define-vault-lock\",\"Effect\":\"Deny\",\"Principal\":{\"AWS\":\"arn:aws:iam::111122223333:root\"},\"Action\":\"glacier:DeleteArchive\",\"Resource\":\"VAULT_ARN\",\"Condition\":{\"NumericLessThanEquals\":{\"glacier:ArchiveAgeinDays\":\"365\"}}}]}"}
```
1. 启动文件库锁定后，您应该会看到 `lockId` 返回的内容。
```
{
"lockId": "LOCK_ID"
}
```
要完成文件库锁定，您必须在 24 小时内运行 `complete-vault-lock`，否则该文件库锁定策略将从文件库中删除。
```
aws glacier complete-vault-lock --vault-name examplevault --account-id 111122223333 --lock-id LOCK_ID
```
## 相关部分
+ 《AWS CLI Command Reference》**中的 [initiate-vault-lock](https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-vault-lock.html)。
+ 《AWS CLI 命令参考》中的 [list-vaults](https://docs.aws.amazon.com/cli/latest/reference/glacier/list-vaults.html)**
+ 《AWS CLI Command Reference》**中的 [complete-vault-lock](https://docs.aws.amazon.com/cli/latest/reference/glacier/complete-vault-lock.html)。
+ [文件库锁定策略](vault-lock-policy.md)
+ [中止文件库锁定（DELETE lock-policy）](api-AbortVaultLock.md)
+ [完成文件库锁定（POST lockId）](api-CompleteVaultLock.md)
+ [获取文件库锁定（GET lock-policy）](api-GetVaultLock.md)
+ [启动文件库锁定（POST lock-policy）](api-InitiateVaultLock.md)
# 使用 Amazon Glacier 控制台锁定文件库
通过 Amazon Glacier 文件库锁定，您可以轻松利用文件库锁定策略对单独的 Amazon Glacier 文件库进行部署并实施合规性控制。有关 Amazon Glacier 文件库锁定的更多信息，请参阅[使用文件库锁定策略进行 Amazon Glacier 访问控制](https://docs.aws.amazon.com/amazonglacier/latest/dev/vault-lock-policy.html)。
**重要**
建议您先创建文件库，完成文件库锁定策略，然后将您的档案上传到文件库，以便将该策略应用于它们。
文件库锁定策略在被锁定后即不能更改或删除。
**使用 Amazon Glacier 控制台对您的文件库启动文件库锁定策略**
通过将文件库锁定策略附加到您的文件库来启动锁定，这会将锁定设置为正在进行状态并返回一个锁定 ID。当策略处于正在进行状态时，在锁定 ID 到期前，您有 24 个小时来验证文件库锁定策略。
1. 登录 AWS 管理控制台 并在家中打开 Amazon Glacier [https://console.aws.amazon.com/glacier/主](https://console.aws.amazon.com/glacier/home)机。
1. 在 **“选择区域”** 下， AWS 区域 从 “区域” 选择器中选择。
1. 在左侧导航窗格中，选择**文件库**。
1. 在**文件库**页面上，选择**创建文件库**。
1. 创建新的文件库。
**重要**
建议您先创建文件库，完成文件库锁定策略，然后将您的档案上传到文件库，以便将该策略应用于它们。
1. 从**文件库**列表中选择您的新文件库。
1. 选择**文件库策略**选项卡。
1. 在**文件库锁定策略**部分，选择**启动文件库锁定策略**。
1. 在**启动文件库锁定策略**页面上，可以使用标准文本框在文本格式的文件库锁定策略中指定记录保留控制措施。
**注意**
您可以在文本格式的文件库锁定策略中指定记录保留控制措施，并通过调用 `Initiate Vault Lock` API 操作或通过 Amazon Glacier 控制台中的交互式用户界面来启动文件库锁定。有关设置文件库锁定策略的格式的信息，请参阅 [Amazon Glacier 文件库锁定策略示例](https://docs.aws.amazon.com/amazonglacier/latest/dev/vault-lock-policy.html#vault-lock-policy-example-deny-delete-archive-age)。
1. 选择**保存更改**。
1. 在**记录文件库锁定 ID** 对话框中，复制您的**锁定 ID** 并将其保存在安全的地方。
**重要**
文件库锁定策略启动后，您有 24 小时的时间来验证该策略并完成锁定过程。要完成锁定过程，必须提供锁定 ID。如果未在 24 小时内提供锁定 ID，则锁定 ID 将过期，并且处于正在进行状态的策略将被删除。
1. 将您的锁定 ID 保存在安全的地方后，选择**关闭**。
1. 在接下来的 24 小时内测试您的文件库锁定策略。如果策略按预期运行，请选择**完成文件库锁定策略**。
1. 在**完成文件库锁定**对话框中，选中该复选框，以确认完成文件库锁定策略过程是不可逆的。
1. 在文本框中输入提供的**锁定 ID**。
1. 选择**完成文件库锁定**。