# 使用批量操作批量执行对象操作
您可以使用 S3 批量操作对 Amazon S3 对象执行大规模批量操作。S3 批量操作可以对您指定的 Amazon S3 对象列表执行单个操作。单个任务可对数十亿个包含 EB 级数据的对象执行指定操作。Amazon S3 跟踪进度、发送通知并存储所有操作的详细完成报告，从而提供完全托管、可审核的无服务器体验。可以通过 Amazon S3 控制台、AWS Command Line Interface（AWS CLI）、AWS SDK 或 Amazon S3 REST API 使用 S3 批量操作。
使用 S3 批量操作来复制对象、更新对象的服务器端加密，并设置对象标签或访问控制列表（ACL）。您还可以从 S3 Glacier Flexible Retrieval 启动对象还原，或者调用 AWS Lambda 函数以使用您的对象执行自定义操作。您可以对自定义的对象列表执行这些操作，也可以使用 Amazon S3 清单报告来轻松生成对象列表。Amazon S3 批量操作使用的 Amazon S3 API 操作与您已在 Amazon S3 中使用的操作相同。
**注意**
有关将 Amazon S3 Express One Zone 存储类与目录存储桶配合使用的更多信息，请参阅 [S3 Express One Zone](directory-bucket-high-performance.md#s3-express-one-zone) 和[使用目录存储桶](directory-buckets-overview.md)。有关将批量操作与 S3 Express One Zone 和目录存储桶配合使用的更多信息，请参阅[对目录存储桶使用批量操作](directory-buckets-objects-Batch-Ops.md)。
## S3 批量操作基础知识
您可以使用 S3 批量操作对 Amazon S3 对象执行大规模批量操作。S3 批量操作可以对您指定的 Amazon S3 对象列表运行单个操作。
### 术语
本节使用的术语*清单*、*作业*、*操作*和*任务*定义如下：
**清单**
清单是一种 Amazon S3 对象，其中包含您希望 Amazon S3 采取操作的对象键。如果要创建批量操作任务，必须提供清单。用户生成的清单必须包括存储桶名称、对象键以及（可选）每个对象的对象版本。如果您提供用户生成的清单，清单必须采用 Amazon S3 清单报告或 CSV 文件的形式。
还可以让 Amazon S3 根据您在创建任务时指定的对象筛选条件自动生成清单。此选项适用于您使用 Amazon S3 控制台创建的批量操作作业，也适用于您使用 AWS Command Line Interface（AWS CLI）、AWS SDK 或 Amazon S3 REST API 创建的任何作业类型。
**任务**
任务是 S3 批量操作的基本工作单位。任务包含对清单中所列对象运行指定操作所需的全部信息。在您提供此信息并请求任务开始后，任务将对清单中的每个对象执行操作。
**操作**
操作是您希望批量操作任务运行的 API [操作](https://docs.aws.amazon.com/AmazonS3/latest/API/API_Operations.html)的类型，例如复制对象。对于清单中指定的所有对象，每个任务执行单一类型的操作。
**任务**
任务是任务的执行单元。任务表示为了对单个对象执行任务的操作而对 Amazon S3 或 AWS Lambda API 操作进行的单个调用。在任务的生命周期内，S3 批量操作将为清单中指定的每个对象创建一个任务。
### S3 批量操作任务的工作原理
任务是 S3 批量操作的基本工作单位。任务包含要对对象列表运行指定操作所需的全部信息。要创建任务，您需要向 S3 批量操作提供对象列表并指定要对这些对象执行的操作。有关 S3 批量操作支持的操作的信息，请参阅 [S3 分批操作支持的操作](batch-ops-operations.md)。
批量任务将对其*清单* 中包含的每个对象执行指定的操作。清单列出了您希望批处理任务进行处理的对象并将其作为对象存储在存储桶中。您可以使用逗号分隔值（CSV）格式的 [使用 S3 清单对数据进行编目和分析](storage-inventory.md) 报告作为清单，这样便于轻松创建位于存储桶中的大型对象列表。您还可以指定采用简单的 CSV 格式的清单，这样您便可对单个存储桶中包含的对象的自定义列表执行批量操作。
在您创建任务后，Amazon S3 将处理清单中的对象列表并对每个对象运行指定的操作。在任务运行时，您能够通过编程方式或通过 Amazon S3 控制台监控其进度。您还可以对任务进行配置，以便在其完成时生成完成报告。完成报告会描述任务已执行的每个任务的结果。有关监控任务的更多信息，请参阅 [管理 S3 分批操作任务](batch-ops-managing-jobs.md)。
S3 批量操作会产生成本。您需要为创建批量操作作业（包括在完成之前取消的作业）付费。有关更多信息，请参阅 [Amazon S3 定价](https://aws.amazon.com/s3/pricing/)。
默认情况下，S3 批量操作作业可以为所有操作处理多达 40 亿个对象。尤其是，复制、对象标记、对象锁定、调用 AWS Lambda 函数和批量复制作业可以支持多达 200 亿个对象。每个 AWS 账户最多只能有 6 个活动的批量复制作业。要开始创建批量操作任务，请参阅[创建 S3 批量操作任务](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-create-job.html)。
## S3 批量操作教程
以下教程提供了一些批量操作任务的完整端到端过程。
+ [教程：使用 S3 批量操作对视频进行批量转码](tutorial-s3-batchops-lambda-mediaconvert-video.md)
# 授予批处理操作的权限
在创建和运行 S3 分批操作任务之前，您必须授予所需的权限。要创建 Amazon S3 分批操作任务，需要 `s3:CreateJob` 用户权限。创建任务的同一个实体也必须具有 `iam:PassRole` 权限，以便将为此任务指定的 AWS Identity and Access Management（IAM）角色传递到批量操作。
以下各节提供了有关创建 IAM 角色和附加策略的信息。有关指定 IAM 资源的一般信息，请参阅《IAM 用户指南》**中的 [IAM JSON 策略元素：Resource](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_resource.html)。
**Topics**
+ [创建 S3 分批操作 IAM 角色](#batch-ops-iam-role-policies-create)
+ [附加权限策略](#batch-ops-iam-role-policies-perm)
## 创建 S3 分批操作 IAM 角色
Amazon S3 必须具有权限才能代表您执行 S3 分批操作。您通过 AWS Identity and Access Management (IAM) 角色授予这些权限。在创建 S3 批量操作作业时，您可以指定希望该作业使用的 IAM 角色，它可以是现有的 IAM 角色。或者，如果您使用 Amazon S3 控制台创建作业，该角色也可以是 Amazon S3 为您创建的 IAM 角色。
如果您选择让 Amazon S3 为您创建 IAM 角色，则系统会自动创建角色，并将信任和权限策略附加到其上。此信任策略让 S3 批量操作服务主体（`batchoperations.s3.amazonaws.com`）可以代入该角色。根据您为作业指定的设置，权限策略允许执行运行作业所需的所有必要操作。例如，如果您配置某个作业，使之将对象从您 AWS 账户中的一个存储桶复制到另一个存储桶，则权限策略允许执行 `s3:GetObject` 和 `s3:PutObject` 等操作。在提交作业之前，您可以查看角色的信任策略和权限策略。仅当您使用 Amazon S3 控制台创建作业，并将作业配置为使用 S3 生成的带有筛选条件的对象列表或基于复制配置的对象列表时，此选项才可用。当您提交作业后，IAM 角色将保留在您的账户中。您可在以后将该角色重新用于后续作业来执行同一操作，也可以在作业运行完后将其删除。
如果您偏好手动创建 IAM 角色，则本节中的策略示例可以帮助您创建角色。有关创建和配置角色的更多信息，请参阅《IAM 用户指南》**中的 [IAM 角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)。有关按 S3 资源类型列出的 S3 API 操作的权限信息，请参阅 [Amazon S3 API 操作所需的权限](using-with-s3-policy-actions.md)。有关其他示例，请参阅[使用任务标签控制批量操作的权限](batch-ops-job-tags-examples.md)和[使用 S3 分批操作复制对象](batch-ops-examples-copy.md)。
在 IAM 策略中，您还可以使用条件键筛选 S3 分批操作任务的访问权限。有关更多信息和 Amazon S3 特定条件键的完整列表，请参阅《Service Authorization Reference》**中的 [Actions, resources, and condition keys for Amazon S3](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazons3.html)。
有关按 S3 资源类型对 S3 API 操作的权限的更多信息，请参阅 [Amazon S3 API 操作所需的权限](using-with-s3-policy-actions.md)。
以下视频介绍如何使用 Amazon S3 控制台设置批量操作作业的 IAM 权限。
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/qpwHUrwAiUI/)
### 信任策略
要允许 S3 分批操作服务委托人担任 IAM 角色，您可将以下信任策略附加到该角色。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Principal":{
"Service":"batchoperations.s3.amazonaws.com"
},
"Action":"sts:AssumeRole"
}
]
}
```
------
## 附加权限策略
根据操作的类型，您可以附加以下策略之一。
在配置权限之前，请注意以下事项：
+ 不论执行什么操作，Amazon S3 都需要权限来从您的 S3 存储桶读取清单对象并（可选）将报告写入您的存储桶。因此，所有以下策略均包含这些权限。
+ 对于 Amazon S3 清单报告清单，S3 分批操作需要读取 manifest.json 对象以及所有关联的 CSV 数据文件的权限。
+ 当您指定对象的版本 ID 时，只需要版本特定的权限，如 `s3:GetObjectVersion`。
+ 如果您在加密对象上运行 S3 分批操作，则 IAM 角色还必须拥有对用于加密这些对象的 AWS KMS 密钥的访问权限。
+ 如果您提交使用 AWS KMS 加密的清单报告清单，则 IAM 策略必须包含对于 manifest.json 对象以及所有关联 CSV 数据文件的 `"kms:Decrypt"` 和 `"kms:GenerateDataKey"` 权限。
+ 如果批量操作任务在已启用访问控制列表（ACL）且位于其它 AWS 账户内的存储桶中生成清单，则您必须在为该批量任务配置的 IAM 角色的 IAM 策略中授予 `s3:PutObjectAcl` 权限。如果没有包含此权限，则批量任务会失败，并显示错误 `Error occurred when preparing manifest: Failed to write manifest`。
### 复制对象：PutObject
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:PutObject",
"s3:PutObjectAcl",
"s3:PutObjectTagging"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
},
{
"Action": [
"s3:GetObject",
"s3:GetObjectAcl",
"s3:GetObjectTagging",
"s3:ListBucket"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-source-bucket",
"arn:aws:s3:::amzn-s3-demo-source-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
]
}
]
}
```
------
### 替换对象标记：PutObjectTagging
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"s3:PutObjectTagging",
"s3:PutObjectVersionTagging"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect":"Allow",
"Action":[
"s3:PutObject"
],
"Resource":[
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
]
}
]
}
```
------
### 删除对象标记：DeleteObjectTagging
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:DeleteObjectTagging",
"s3:DeleteObjectVersionTagging"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
]
}
]
}
```
------
### 替换访问控制列表：PutObjectAcl
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObjectAcl",
"s3:PutObjectVersionAcl"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
]
}
]
}
```
------
### 还原对象：RestoreObject
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"s3:RestoreObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect":"Allow",
"Action":[
"s3:PutObject"
],
"Resource":[
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
]
}
]
}
```
------
### 应用对象锁定保留：PutObjectRetention
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:GetBucketObjectLockConfiguration",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-destination-bucket"
]
},
{
"Effect": "Allow",
"Action": [
"s3:PutObjectRetention",
"s3:BypassGovernanceRetention"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
]
}
]
}
```
------
### 应用对象锁定法定保留：PutObjectLegalHold
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:GetBucketObjectLockConfiguration",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-destination-bucket"
]
},
{
"Effect": "Allow",
"Action": "s3:PutObjectLegalHold",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
]
}
]
}
```
------
### 复制现有对象：InitiateReplication（使用 S3 生成的清单）
如果您使用和存储 S3 生成的清单，请使用此策略。有关使用批量操作来复制现有对象的更多信息，请参阅[使用批量复制以复制现有对象](s3-batch-replication-batch.md)。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Action":[
"s3:InitiateReplication"
],
"Effect":"Allow",
"Resource":[
"arn:aws:s3:::amzn-s3-demo-source-bucket/*"
]
},
{
"Action":[
"s3:GetReplicationConfiguration",
"s3:PutInventoryConfiguration"
],
"Effect":"Allow",
"Resource":[
"arn:aws:s3:::amzn-s3-demo-source-bucket"
]
},
{
"Action":[
"s3:GetObject",
"s3:GetObjectVersion"
],
"Effect":"Allow",
"Resource":[
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect":"Allow",
"Action":[
"s3:PutObject"
],
"Resource":[
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*",
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
}
]
}
```
------
### 复制现有对象：InitiateReplication（使用用户清单）
如果您使用用户提供的清单，请使用此策略。有关使用批量操作来复制现有对象的更多信息，请参阅[使用批量复制以复制现有对象](s3-batch-replication-batch.md)。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Action":[
"s3:InitiateReplication"
],
"Effect":"Allow",
"Resource":[
"arn:aws:s3:::amzn-s3-demo-source-bucket/*"
]
},
{
"Action":[
"s3:GetObject",
"s3:GetObjectVersion"
],
"Effect":"Allow",
"Resource":[
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect":"Allow",
"Action":[
"s3:PutObject"
],
"Resource":[
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
]
}
]
}
```
------
### 计算校验和：支持 `GetObject`、`GetObjectVersion`、`RestoreObject` 和 `PutObject`
如果您尝试将**计算校验和**操作与 S3 批量操作结合使用，请使用此策略。`GetObject`、`GetObjectVersion` 和 `RestoreObject` 的权限是获取和读取存储数据的字节所必需的。将用户输入占位符替换为您自己的信息。有关**计算校验和**的更多信息，请参阅[在 Amazon S3 中检查静态数据的对象完整性](checking-object-integrity-at-rest.md)。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:RestoreObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket2/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket3/*"
]
}
]
}
```
### 更新对象加密
您必须附加以下权限策略，才能支持批量操作读取清单、更新对象的加密类型以及编写完成报告。要使用此权限策略，请将 *`user input placeholders`* 替换为您自己的信息。有关使用此操作以及您必须向 IAM 主体使用的角色附加的权限的更多信息，请参阅[更新对象加密](batch-ops-update-encryption.md)。
```
{
"Version": "2012-10-17",
"Statement": [{
"Sid": "S3BatchOperationsUpdateEncryption",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:PutObject",
"s3:UpdateObjectEncryption"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket-target"
"arn:aws:s3:::amzn-s3-demo-bucket-target/*"
]
},
{
"Sid": "S3BatchOperationsPolicyForManifestFile",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket-manifest/*"
]
},
{
"Sid": "S3BatchOperationsPolicyForCompletionReport",
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket-completion-report/*"
]
},
{
"Sid": "S3BatchOperationsPolicyManifestGeneration",
"Effect": "Allow",
"Action": [
"s3:PutInventoryConfiguration"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket-target"
]
}
{
"Sid": "AllowKMSOperationsForS3BatchOperations",
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey",
"kms:Encrypt",
"kms:ReEncrypt*"
],
"Resource": [
"arn:aws:kms:us-east-1:111122223333:key/01234567-89ab-cdef-0123-456789abcdef"
]
}
]
}
```
# 创建 S3 批量操作任务
借助 Amazon S3 批量操作，您可以对特定 Amazon S3 对象的列表执行大规模批量操作。本节介绍创建 S3 批量操作任务所需的信息以及 `CreateJob` 请求的结果。它还提供说明，讲解如何通过使用 Amazon S3 控制台、AWS Command Line Interface（AWS CLI）和 适用于 Java 的 AWS SDK 创建批量操作任务。
当您创建 S3 批量操作作业时，可以请求为所有任务或仅失败任务生成完成报告。只要成功调用了至少一个任务，S3 批量操作即会为已完成、已失败或已取消的任务生成报告。有关更多信息，请参阅 [示例：S3 分批操作完成报告](batch-ops-examples-reports.md)。
以下视频简要演示了如何使用 Amazon S3 控制台创建批量操作任务。
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/qpwHUrwAiUI/)
**Topics**
+ [批量操作任务请求元素](#batch-ops-create-job-request-elements)
+ [指定清单](#specify-batchjob-manifest)
+ [自动生成对象列表并将其另存为清单文件](#automatically-generate-manifest-file)
+ [创建清单文件](#create-manifest-file)
+ [使用现有清单](#specify-existing-manifest-file)
+ [创建作业](#to-create-batch-ops-job)
+ [任务响应](#batch-ops-create-job-response-elements)
## 批量操作任务请求元素
要创建 S3 批量操作任务，您必须提供以下信息：
**操作**
指定希望 S3 批量操作对清单中的对象运行的操作。每种操作类型都接受特定于该操作的参数。借助批量操作功能，您可以批量执行操作，其结果与对每个对象逐个执行该操作相同。
**清单**
*清单*是一个 Amazon S3 对象列表，其中包含您希望 Amazon S3 采取操作的对象键。您可以使用以下方法为批量操作任务指定清单。
+ 指示批量操作根据您指定的元数据生成对象列表。您可以将此列表另存为清单文件，并在创建作业时使用它。此选项适用于您使用 Amazon S3 控制台、AWS CLI、AWS SDK 或 Amazon S3 REST API 创建的任何作业类型。
+ 根据现有的复制配置自动生成对象列表。您可以将此列表另存为清单文件，然后再次将其用于将来的作业。
+ 手动创建新的清单文件。
+ 使用现有的清单。
+ 无论您如何指定要处理的对象，清单本身都必须存储在通用存储桶中。批量操作无法从目录存储桶中导入现有清单，也无法将生成的对象列表作为清单保存到目录存储桶。但是，清单中描述的对象可以存储在目录存储桶中。有关更多信息，请参阅[目录存储桶](https://docs.aws.amazon.com//AmazonS3/latest/userguide/directory-buckets-overview.html)。
+ 如果清单中的对象位于受版本控制的存储桶中，指定对象的版本 ID 时，批量操作将在特定版本上执行此操作。如果未指定版本 ID，则批量操作将针对最新对象版本执行该操作。如果您的清单包含版本 ID 字段，则必须为清单中的所有对象提供版本 ID。
有关更多信息，请参阅 [指定清单](#specify-batchjob-manifest)。
**优先级**
使用任务优先级指示此任务相对于在您账户中运行的其他任务的优先级。数字越大，优先级越高。
任务优先级仅相对于为同一账户和区域中的其他任务设置的优先级有意义。您可以选择适合您的编号系统。例如，您可能希望将所有**还原** (`RestoreObject`) 作业的优先级指定为 1，将所有**复制** (`CopyObject`) 作业的优先级指定为 2，并将所有**替换访问控制列表（ACL）**(`PutObjectAcl`) 作业的优先级指定为 3。
S3 批量操作根据优先级编号确定任务的优先级，但不严格保证顺序。因此，任务优先级并不用来确保任何一个任务会在其他任何任务之前开始或完成。如果您需要确保严格的顺序，请等到一个任务完成后，再开始下一个任务。
**RoleArn**
指定将运行任务的 AWS Identity and Access Management (IAM) 角色。您使用的 IAM 角色必须具有足够的权限来执行作业中指定的操作。例如，要运行 `CopyObject` 任务，IAM 角色必须具有针对源存储桶的 `s3:GetObject` 权限和针对目标存储桶的 `s3:PutObject` 权限。该角色还需要读取清单和写入完成报告的权限。
IAM 角色可以是现有角色。或者，如果您使用 Amazon S3 控制台创建作业，则可以是 Amazon S3 自动为您创建的 IAM 角色。有关更多信息，请参阅 [授予批处理操作的权限](batch-ops-iam-role-policies.md)。
有关 IAM 角色的更多信息，请参阅《IAM 用户指南》**中的 [IAM 角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)。有关 Amazon S3 权限的更多信息，请参阅 [Amazon S3 的策略操作](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-actions)。
对目录存储桶执行操作的批量操作任务需要特定的权限。有关更多信息，请参阅[适用于 S3 Express One Zone 的 AWS Identity and Access Management（IAM）](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-security-iam.html)。
**报告**
指定您是否希望 S3 批量操作生成完成报告。如果您请求完成报告，还必须在此元素中提供报告的参数。需要以下信息：
+ 您希望存储报告的存储桶
**注意**
报告必须存储在通用存储桶中。批量操作功能无法将报告保存到目录存储桶中。有关更多信息，请参阅[目录存储桶](https://docs.aws.amazon.com//AmazonS3/latest/userguide/directory-buckets-overview.html)。
+ 报告的格式
+ 您希望报告包含所有任务的详细信息还是只包含失败的任务
+ 可选的前缀字符串
如果提供了 `CreateJob.Report.ExpectedBucketOwner` 字段，则它要求完成报告存储桶拥有者匹配。如果不匹配，则任务失败。
完成报告始终使用具有 Amazon S3 托管式密钥的服务器端加密（SSE-S3）来进行加密。
**标签（可选）**
您可以通过添加*标签*来标记和控制对 S3 批量操作任务的访问。您可以使用标签来标识谁负责批量操作任务，或者控制用户与批量操作任务的交互方式。任务标签的存在可授予或限制用户取消任务、激活处于确认状态的任务或更改任务优先级的能力。例如，您可以授予用户调用 `CreateJob` 操作的权限，前提是使用标签 `"Department=Finance"` 创建此任务。
您可以创建附加了标签的任务，并且可以在创建任务后向任务添加标签。
有关更多信息，请参阅 [使用标签控制访问和标记任务](batch-ops-job-tags.md)。
**Description（可选）**
要跟踪和监控任务，您还可以提供最多包含 256 个字符的描述。只要返回有关任务的信息或在 Amazon S3 控制台中显示任务详细信息，Amazon S3 便会包含此描述。随后您便可以根据自己分配的描述轻松地对任务进行排序和筛选。描述不一定是唯一的，因此您可以使用描述作为类别（例如“每周日志复制任务”）来帮助您跟踪多组相似的任务。
## 指定清单
*清单*是一个 Amazon S3 对象列表，其中包含您希望 Amazon S3 采取操作的对象键。您可以使用以下方法为批量操作任务指定清单。
+ 指示批量操作根据您指定的元数据生成对象列表。您可以将此列表另存为清单，并在创建作业时使用它。此选项适用于您使用 Amazon S3 控制台、AWS CLI、AWS SDK 或 Amazon S3 REST API 创建的任何作业类型。
+ 根据现有的复制配置自动生成对象列表。您可以将此列表另存为清单，然后再次将其用于将来的作业。
+ 手动创建新的清单文件。
+ 使用现有的清单。
**注意**
Amazon S3 批量操作不支持跨区域对象列表生成。
无论您如何指定要处理的对象，清单本身都必须存储在通用存储桶中。批量操作无法从目录存储桶中导入现有清单，也无法将生成的对象列表作为清单保存到目录存储桶。但是，清单中描述的对象可以存储在目录存储桶中。有关更多信息，请参阅[目录存储桶](https://docs.aws.amazon.com//AmazonS3/latest/userguide/directory-buckets-overview.html)。
## 自动生成对象列表并将其另存为清单文件
您可以指示 Amazon S3 根据您指定的元数据自动生成对象列表。您可以将此列表另存为清单，并在创建作业时使用它。此选项适用于您使用 Amazon S3 控制台、AWS CLI、AWS SDK 或 Amazon S3 REST API 创建的任何作业类型。
要自动生成对象列表并将其另存为清单文件，请在作业创建请求中指定以下元素：
+ 有关包含源对象的存储桶的信息，包括存储桶拥有者和 Amazon 资源名称（ARN）。
+ 有关清单输出的信息，包括用于创建清单文件的标志、输出存储桶拥有者、ARN、前缀、文件格式和加密类型。
+ 按对象的创建日期、键名称、大小、加密类型、KMS 密钥 ARN、存储桶密钥和存储类别筛选对象的可选标准。对于复制作业，还可以使用标签来筛选对象。
### 对象筛选标准
要筛选要包含在自动生成的对象列表中的对象的列表，您可以指定以下标准。有关更多信息，请参阅《Amazon S3 API 参考》**中的 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_JobManifestGeneratorFilter.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_JobManifestGeneratorFilter.html)。
**CreatedAfter**
如果提供，则生成的清单仅包含在此时间之后创建的源存储桶对象。
**CreatedBefore**
如果提供，则生成的清单仅包含在此时间之前创建的源存储桶对象。
**EligibleForReplication**
如果提供，则生成的清单仅包含根据源存储桶上的复制配置而符合复制条件的对象。
**KeyNameConstraint**
如果提供，则生成的清单仅包含下面这样的源存储桶对象：其对象密钥与 **MatchAnySubstring**、**MatchAnyPrefix** 和 **MatchAnySuffix** 所指定的字符串约束相匹配。
**MatchAnySubstring** – 如果提供，则当指定的字符串出现在对象密钥字符串中的任何位置时，生成的清单将包含对象。
**MatchAnyPrefix** – 如果提供，则当指定的字符串出现在对象密钥字符串的开头时，生成的清单将包含对象。
**MatchAnySuffix** – 如果提供，则当指定的字符串出现在对象密钥字符串的末尾时，生成的清单将包含对象。
**MatchAnyObjectEncryption**
如果提供，则保存为清单文件的已生成对象列表仅包含采用指定的服务器端加密类型（SSE-S3、SSE-KMS、DSSE-KMS、SSE-C 或 NOT-SSE）的源存储桶对象。如果您选择 SSE-KMS 或 DSSE-KMS，则可以选择通过指定特定的 KMS 密钥 ARN 来进一步筛选结果。如果您选择 SSE-KMS，还可以选择按存储桶密钥启用状态来进一步筛选结果。
**MatchAnyStorageClass**
如果提供，则生成的清单仅包含以指定存储类存储的源存储桶对象。
**ObjectReplicationStatuses**
如果提供，则生成的清单仅包含具有指定复制状态之一的源存储桶对象。
**ObjectSizeGreaterThanBytes**
如果提供，则生成的清单仅包含文件大小大于指定字节数的源存储桶对象。
**ObjectSizeLessThanBytes**
如果提供，则生成的清单仅包含文件大小小于指定字节数的源存储桶对象。
**注意**
您无法克隆大多数将自动生成的对象列表另存为清单的作业。可以克隆批量复制任务，除非它们使用 `KeyNameConstraint`、`MatchAnyStorageClass`、`ObjectSizeGreaterThanBytes` 或 `ObjectSizeLessThanBytes` 清单筛选标准。
指定清单标准的语法因您用于创建任务的方法而异。有关示例，请参阅 [创建作业](#to-create-batch-ops-job)。
## 创建清单文件
要手动创建清单文件，您需要采用 CSV 格式列表的形式，指定清单对象键、ETag（实体键）和可选的版本 ID。清单的内容必须是 URL 编码的。
默认情况下，Amazon S3 自动使用具有 Amazon S3 托管密钥的服务器端加密（SSE-S3）对上传到 Amazon S3 存储桶的清单进行加密。不支持使用具有客户提供密钥（SSE-C）的服务器端加密的清单。仅当使用 CSV 格式的清单报告时，才支持使用具有 AWS Key Management Service（AWS KMS）密钥的服务器端加密（SSE-KMS）的清单。不支持将手动创建的清单与 AWS KMS 一起使用。
您的清单必须包括存储桶名称、对象键以及（可选）每个对象的对象版本。S3 批量操作不使用清单中的任何其他字段。
**注意**
如果清单中的对象位于受版本控制的存储桶中，指定对象的版本 ID 时，批量操作将在特定版本上执行此操作。如果未指定版本 ID，则批量操作将针对最新对象版本执行该操作。如果您的清单包含版本 ID 字段，则必须为清单中的所有对象提供版本 ID。
下面是 CSV 格式的没有版本 ID 的清单示例。
```
amzn-s3-demo-bucket1,objectkey1
amzn-s3-demo-bucket1,objectkey2
amzn-s3-demo-bucket1,objectkey3
amzn-s3-demo-bucket1,photos/jpgs/objectkey4
amzn-s3-demo-bucket1,photos/jpgs/newjersey/objectkey5
amzn-s3-demo-bucket1,object%20key%20with%20spaces
```
下面是 CSV 格式的包含版本 ID 的清单示例。
```
amzn-s3-demo-bucket1,objectkey1,PZ9ibn9D5lP6p298B7S9_ceqx1n5EJ0p
amzn-s3-demo-bucket1,objectkey2,YY_ouuAJByNW1LRBfFMfxMge7XQWxMBF
amzn-s3-demo-bucket1,objectkey3,jbo9_jhdPEyB4RrmOxWS0kU0EoNrU_oI
amzn-s3-demo-bucket1,photos/jpgs/objectkey4,6EqlikJJxLTsHsnbZbSRffn24_eh5Ny4
amzn-s3-demo-bucket1,photos/jpgs/newjersey/objectkey5,imHf3FAiRsvBW_EHB8GOu.NHunHO1gVs
amzn-s3-demo-bucket1,object%20key%20with%20spaces,9HkPvDaZY5MVbMhn6TMn1YTb5ArQAo3w
```
## 使用现有清单
您可以使用以下两种格式之一，指定现有清单来创建批量操作作业：
+ **Amazon S3 清单报告** – 必须是 CSV 格式的 Amazon S3 清单报告。您必须指定与清单报告关联的 `manifest.json` 文件。有关清单报告的更多信息，请参阅 [使用 S3 清单对数据进行编目和分析](storage-inventory.md)。如果清单报告包括版本 ID，S3 批量操作将对特定对象版本进行操作。
**注意**
S3 批量操作支持用 SSE-KMS 加密的 CSV 格式*清单报告*。
如果您提交使用 SSE-KMS 加密的清单报告清单，则 IAM 策略必须包含对于 `manifest.json` 对象以及所有关联 CSV 数据文件的 `"kms:Decrypt"` 和 `"kms:GenerateDataKey"` 权限。
+ **CSV 文件** – 文件中的每一行必须包括存储桶名称和对象键，还可选择包括对象版本。对象键必须进行 URL 编码，如以下示例所示。清单必须包含所有对象的版本 ID 或忽略所有对象的版本 ID。有关 CSV 清单格式的更多信息，请参阅《Amazon Simple Storage Service API 参考》**中的 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_JobManifestSpec.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_JobManifestSpec.html)。
**注意**
S3 批量操作不支持使用 SSE-KMS 加密的 CSV *清单文件*。
**重要**
当您使用手动创建的清单和受版本控制的存储桶时，我们建议您指定对象的版本 ID。创建任务时，S3 批量操作会在运行任务之前解析整个清单。不过，它不会获取存储桶状态的“快照”。
由于清单可以包含数十亿个对象，因此任务可能需要很长时间才能运行完，这可能会影响任务所针对的对象版本。假设您在任务运行时用新版本覆盖某个对象，但未指定该对象的版本 ID。在这种情况下，Amazon S3 将对该对象的最新版本（而不是在创建作业时存在的版本）执行操作。避免此行为的唯一方式是为清单中列出的对象指定版本 ID。
## 创建作业
您可以使用 Amazon S3 控制台、AWS CLI、AWS SDK 或 Amazon S3 REST API 创建 S3 批量操作任务。
有关创建任务请求的更多信息，请参阅 [批量操作任务请求元素](#batch-ops-create-job-request-elements)。
**先决条件**
在创建批量操作任务之前，请确认您已配置相关权限。有关更多信息，请参阅 [授予批处理操作的权限](batch-ops-iam-role-policies.md)。
### 使用 S3 控制台
**使用 S3 控制台创建批量操作作业**
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在 Amazon S3 控制台的左侧导航窗格中选择**批量操作**。
1. 请选择**创建任务**。
1. 在**选择区域和范围**下，选择并查看要在其中创建作业的 AWS 区域。
**注意**
对于复制操作，必须在目标存储桶所在的同一区域中创建任务。对于所有其它操作，必须在与清单中的对象相同的区域中创建任务。
1. 对于**范围**，指定批量操作作业将要处理的对象的列表。
在**对象列表**下，您可以选择使用对象列表生成清单、使用复制配置生成清单或使用现有清单。
+ 如果选择**生成对象列表**，则会根据您指定的源位置和元数据自动生成对象列表。您可以将此列表另存为清单，然后再次将其用于将来的作业。
**注意**
要生成对象列表，您必须拥有 `s3:PutInventoryConfiguration` 权限。源存储桶必须是通用存储桶。
+ 如果您选择**使用现有清单**，则可以从现有清单中导入对象列表。清单是一个 S3 清单报告或 CV 文件，其中列出了您希望批量操作处理的特定对象。
+ 如果选择**使用复制配置**，则可以根据现有的复制配置自动生成对象列表。您可以将此列表另存为清单，然后再次将其用于将来的作业。
对于本示例，选择**生成对象列表**。
1. 对于**源账户**，选择拥有源对象的账户。
1. 在**源**下，输入指向源的路径，例如 `s3://`*amzn-s3-demo-bucket*。
1. 在**对象筛选条件**下，可以使用筛选条件按对象键的任意部分进行筛选，也可以按对象键的末尾进行筛选。**对象键筛选条件**有助于细化清单中要使用的对象的列表。对于**对象元数据筛选条件**，请选择筛选条件以进一步定义要包含在清单中的对象的范围。
1. 在**选择操作**下，选择您希望对清单中列出的所有对象执行的操作类型。如果您的清单引用存储在目录存储桶中的对象，则只能使用复制或调用 AWS Lambda 函数操作。不支持所有其他操作。
1. 选择操作类型后，选择**下一步**。
1. 填写**配置其他选项**的信息。
对于**权限**，请指定您希望作业使用的 AWS Identity and Access Management（IAM）角色。这可以是现有角色，也可以是 Amazon S3 自动为您创建的角色。有关更多信息，请参阅 [授予批处理操作的权限](batch-ops-iam-role-policies.md)。如果您将作业配置为使用带有筛选条件的 S3 生成的对象列表或基于复制配置的对象列表，Amazon S3 可以为您创建角色。
1. 配置完其他选项后，选择**下一步**。
1. 对于**审核**，验证设置。如果需要进行更改，请选择 **Previous**。否则，您可以选择**提交作业**。
### 使用 AWS CLI
要使用 AWS CLI 创建批量操作任务，请根据您是指定现有清单还是自动生成清单，选择以下示例之一。
------
#### [ Specify manifest ]
以下示例说明如何使用 AWS CLI 来创建 S3 批量操作 `S3PutObjectTagging` 任务，以便处理现有清单文件中列出的对象。
**通过指定清单来创建批量操作 `S3PutObjectTagging` 任务**
1. 使用以下命令创建 AWS Identity and Access Management（IAM）角色，然后创建一个 IAM 策略来分配相关权限。以下角色和策略授予 Amazon S3 添加对象标签的权限，您在后续步骤中创建任务时将需要用到该权限。
1. 使用以下示例命令创建 IAM 角色供批量操作使用。要使用此示例命令，请将 `S3BatchJobRole` 替换为要为角色指定的名称。
```
aws iam create-role \
--role-name S3BatchJobRole \
--assume-role-policy-document '{
"Version": "2012-10-17" ,
"Statement":[
{
"Effect":"Allow",
"Principal":{
"Service":"batchoperations.s3.amazonaws.com"
},
"Action":"sts:AssumeRole"
}
]
}'
```
记下角色的 Amazon 资源名称（ARN）。创建任务时，您需要该 ARN。
1. 使用以下示例命令创建具有必要权限的 IAM 策略，并将其附加到您在上一步中创建的 IAM 角色。有关必要权限的更多信息，请参阅[授予批处理操作的权限](batch-ops-iam-role-policies.md)。
**注意**
对目录存储桶执行操作的批量操作任务需要特定的权限。有关更多信息，请参阅[适用于 S3 Express One Zone 的 AWS Identity and Access Management（IAM）](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-security-iam.html)。
要使用此示例命令，请按如下方式替换 `user input placeholders`：
+ 将 `S3BatchJobRole` 替换为您的 IAM 角色的名称。请确保此名称与您之前使用的名称一致。
+ 将 `PutObjectTaggingBatchJobPolicy` 替换为要为 IAM 策略指定的名称。
+ 将 `amzn-s3-demo-destination-bucket` 替换为包含要应用标签的对象的存储桶的名称。
+ 将 *`amzn-s3-demo-manifest-bucket`* 替换为包含清单的存储桶的名称。
+ 将 *`amzn-s3-demo-completion-report-bucket`* 替换为要将完成报告交付到的存储桶的名称。
```
aws iam put-role-policy \
--role-name S3BatchJobRole \
--policy-name PutObjectTaggingBatchJobPolicy \
--policy-document '{
"Version": "2012-10-17" , TCX5-2025-waiver;,
"Statement":[
{
"Effect":"Allow",
"Action":[
"s3:PutObjectTagging",
"s3:PutObjectVersionTagging"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-manifest-bucket",
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect":"Allow",
"Action":[
"s3:PutObject",
"s3:GetBucketLocation"
],
"Resource":[
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket",
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
]
}
]
}'
```
1. 使用以下示例命令创建 `S3PutObjectTagging` 任务。
`manifest.csv` 文件提供存储桶和对象键值的列表。任务将指定的标签应用到清单中标识的对象。`ETag` 是 `manifest.csv` 对象的 ETag，可以从 Amazon S3 控制台获取。此请求指定了 `no-confirmation-required` 参数，这样您就可以运行任务，而不必使用 `update-job-status` 命令进行确认。有关更多信息，请参阅《AWS CLI Command Reference》**中的 [https://docs.aws.amazon.com/cli/latest/reference/s3control/create-job.html](https://docs.aws.amazon.com/cli/latest/reference/s3control/create-job.html)。
要使用此示例命令，请将 `user input placeholders` 替换为您自己的信息。将 *`IAM-role`* 替换为您之前创建的 IAM 角色的 ARN。
```
aws s3control create-job \
--region us-west-2 \
--account-id acct-id \
--operation '{"S3PutObjectTagging": { "TagSet": [{"Key":"keyOne", "Value":"ValueOne"}] }}' \
--manifest '{"Spec":{"Format":"S3BatchOperations_CSV_20180820","Fields":["Bucket","Key"]},"Location":{"ObjectArn":"arn:aws:s3:::amzn-s3-demo-manifest-bucket/manifest.csv","ETag":"60e460c9d1046e73f7dde5043ac3ae85"}}' \
--report '{"Bucket":"arn:aws:s3:::amzn-s3-demo-completion-report-bucket","Prefix":"final-reports", "Format":"Report_CSV_20180820","Enabled":true,"ReportScope":"AllTasks"}' \
--priority 42 \
--role-arn IAM-role \
--client-request-token $(uuidgen) \
--description "job description" \
--no-confirmation-required
```
作为响应，Amazon S3 返回任务 ID（例如 `00e123a4-c0d8-41f4-a0eb-b46f9ba5b07c`）。您需要使用任务 ID 来识别、监控和修改任务。
------
#### [ Generate manifest ]
以下示例说明如何创建 S3 批量操作 `S3DeleteObjectTagging` 任务，该任务会根据您的对象筛选标准自动生成清单。此标准包括创建日期、密钥名称、大小、存储类和标签。
**通过生成清单来创建批量操作 `S3DeleteObjectTagging` 任务**
1. 使用以下命令创建 AWS Identity and Access Management（IAM）角色，然后创建一个 IAM 策略来分配权限。以下角色和策略授予 Amazon S3 删除对象标签的权限，您在后续步骤中创建任务时将需要用到该权限。
1.
使用以下示例命令创建 IAM 角色供批量操作使用。要使用此示例命令，请将 `S3BatchJobRole` 替换为要为角色指定的名称。
```
aws iam create-role \
--role-name S3BatchJobRole \
--assume-role-policy-document '{
"Version": "2012-10-17" , TCX5-2025-waiver;,
"Statement":[
{
"Effect":"Allow",
"Principal":{
"Service":"batchoperations.s3.amazonaws.com"
},
"Action":"sts:AssumeRole"
}
]
}'
```
记下角色的 Amazon 资源名称（ARN）。创建任务时，您需要该 ARN。
1. 使用以下示例命令创建具有必要权限的 IAM 策略，并将其附加到您在上一步中创建的 IAM 角色。有关必要权限的更多信息，请参阅[授予批处理操作的权限](batch-ops-iam-role-policies.md)。
**注意**
对目录存储桶执行操作的批量操作任务需要特定的权限。有关更多信息，请参阅[适用于 S3 Express One Zone 的 AWS Identity and Access Management（IAM）](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-security-iam.html)。
要使用此示例命令，请按如下方式替换 `user input placeholders`：
+ 将 `S3BatchJobRole` 替换为您的 IAM 角色的名称。请确保此名称与您之前使用的名称一致。
+ 将 `DeleteObjectTaggingBatchJobPolicy` 替换为要为 IAM 策略指定的名称。
+ 将 `amzn-s3-demo-destination-bucket` 替换为包含要应用标签的对象的存储桶的名称。
+ 将 `amzn-s3-demo-manifest-bucket` 替换为您想用于保存清单的存储桶的名称。
+ 将 `amzn-s3-demo-completion-report-bucket` 替换为要将完成报告交付到的存储桶的名称。
```
aws iam put-role-policy \
--role-name S3BatchJobRole \
--policy-name DeleteObjectTaggingBatchJobPolicy \
--policy-document '{
"Version": "2012-10-17" , TCX5-2025-waiver;,
"Statement":[
{
"Effect":"Allow",
"Action":[
"s3:DeleteObjectTagging",
"s3:DeleteObjectVersionTagging"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
},
{
"Effect":"Allow",
"Action":[
"s3:PutInventoryConfiguration"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-manifest-bucket",
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect":"Allow",
"Action":[
"s3:PutObject",
"s3:ListBucket"
],
"Resource":[
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket",
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*",
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
}
]
}'
```
1. 使用以下命令创建 `S3DeleteObjectTagging` 任务。
在此示例中，`--report` 部分中的值指定了将生成的任务报告的存储桶、前缀、格式和范围。该 `--manifest-generator` 部分指定了有关包含任务将处理的对象的源存储桶的信息、有关将为任务生成的清单输出列表的信息，以及按创建日期、名称限制、大小和存储类来缩小要包含在清单中的对象范围的筛选标准。该命令还指定任务的优先级、IAM 角色和 AWS 区域。
有关更多信息，请参阅《AWS CLI Command Reference》**中的 [https://docs.aws.amazon.com/cli/latest/reference/s3control/create-job.html](https://docs.aws.amazon.com/cli/latest/reference/s3control/create-job.html)。
要使用此示例命令，请将 `user input placeholders` 替换为您自己的信息。将 *`IAM-role`* 替换为您之前创建的 IAM 角色的 ARN。
```
aws s3control create-job \
--account-id 012345678901 \
--operation '{
"S3DeleteObjectTagging": {}
}' \
--report '{
"Bucket":"arn:aws:s3:::amzn-s3-demo-completion-report-bucket",
"Prefix":"reports",
"Format":"Report_CSV_20180820",
"Enabled":true,
"ReportScope":"AllTasks"
}' \
--manifest-generator '{
"S3JobManifestGenerator": {
"ExpectedBucketOwner": "012345678901",
"SourceBucket": "arn:aws:s3:::amzn-s3-demo-source-bucket",
"EnableManifestOutput": true,
"ManifestOutputLocation": {
"ExpectedManifestBucketOwner": "012345678901",
"Bucket": "arn:aws:s3:::amzn-s3-demo-manifest-bucket",
"ManifestPrefix": "prefix",
"ManifestFormat": "S3InventoryReport_CSV_20211130"
},
"Filter": {
"CreatedAfter": "2023-09-01",
"CreatedBefore": "2023-10-01",
"KeyNameConstraint": {
"MatchAnyPrefix": [
"prefix"
],
"MatchAnySuffix": [
"suffix"
]
},
"ObjectSizeGreaterThanBytes": 100,
"ObjectSizeLessThanBytes": 200,
"MatchAnyStorageClass": [
"STANDARD",
"STANDARD_IA"
]
}
}
}' \
--priority 2 \
--role-arn IAM-role \
--region us-east-1
```
作为响应，Amazon S3 返回任务 ID（例如 `00e123a4-c0d8-41f4-a0eb-b46f9ba5b07c`）。您将需要此任务 ID 来识别、监控或修改任务。
------
### 使用 适用于 Java 的 AWS SDK
要使用适用于 Java 的 AWS SDK 创建批量操作任务，根据您是指定现有清单还是自动生成清单，可以在两种方法之间进行选择：
+ *指定现有清单：*创建 S3 批量操作任务（例如 `S3PutObjectTagging`），以便处理现有清单文件中列出的对象。这种方法要求您提供清单位置、ETag 和格式规范。
+ *自动生成清单：*创建 S3 批量操作任务（例如 `s3PutObjectCopy`），以便根据对象筛选条件（包括创建日期、键名称和大小约束）自动生成清单。
这两种方法都使用 S3Control 客户端来配置任务操作、清单规范、任务报告、IAM 角色和其它任务参数，包括优先级和确认要求。
有关如何使用适用于 Java 的 AWS SDK 创建 S3 批量操作任务的示例，请参阅《Amazon S3 API Reference》**中的 [Create a batch job to copy objects](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_CreateJob_section.html)。
### 使用 REST API
您可以使用 REST API 创建批量操作任务。有关更多信息，请参阅《Amazon Simple Storage Service API 参考》**中的 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateJob.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateJob.html)。
## 任务响应
如果 `CreateJob` 请求成功，Amazon S3 将返回一个任务 ID。任务 ID 是 Amazon S3 自动生成的唯一标识符，以便于您标识批量操作任务并监控其状态。
通过 AWS CLI、AWS SDK 或 REST API 创建任务时，您可以设置 S3 批量操作以开始自动处理任务。任务在准备就绪后立即开始运行，而不是等待后面较高优先级的任务。
当您通过 Amazon S3 控制台创建任务时，在批量操作开始处理该任务之前，您必须查看任务详细信息并确认希望运行它。如果任务保持暂停状态超过 30 天，则它将失败。
# S3 分批操作支持的操作
您可以使用 S3 批量操作对 Amazon S3 对象执行大规模批量操作。S3 批量操作可以对您指定的 Amazon S3 对象列表执行单个操作。单个任务可对数十亿个包含 EB 级数据的对象执行指定操作。Amazon S3 跟踪进度、发送通知并存储所有操作的详细完成报告，从而提供完全托管、可审核的无服务器体验。可以通过 Amazon S3 控制台、AWS CLI、AWS SDK 或 Amazon S3 REST API 使用 S3 批量操作。
S3 批处理操作支持以下操作：
# 复制对象
可以使用 Amazon S3 批量操作对 Amazon S3 对象执行大规模批量操作。批量操作**复制**操作会复制清单中指定的每个对象。可以将对象复制到相同 AWS 区域中的存储桶或不同区域中的存储桶。S3 分批操作支持 Amazon S3 所提供用于复制对象的大部分选项。这些选项包括设置对象元数据、设置权限以及更改对象的存储类。
可以使用**复制**操作来复制现有的未加密对象，并将其作为加密的对象写入到同一存储桶。有关更多信息，请参阅[使用 Amazon S3 分批操作加密对象](https://aws.amazon.com/blogs/storage/encrypting-objects-with-amazon-s3-batch-operations/)。
复制对象时，可以更改用于计算对象校验和的校验和算法。如果对象没有额外的已计算校验和，您还可以通过指定 Amazon S3 要使用的校验和算法来添加一个校验和。有关更多信息，请参阅 [在 Amazon S3 中检查对象完整性](checking-object-integrity.md)。
有关复制 Amazon S3 中的对象以及必需参数和可选参数的更多信息，请参阅本指南中的[复制、移动和重命名对象](copy-object.md)和《Amazon Simple Storage Service API 参考》**中的 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html)。
## 限制和局限性
当您使用批量操作**复制**操作时，以下限制和局限性适用：
+ 所有源对象必须位于一个存储桶中。
+ 所有目标对象必须位于一个存储桶中。
+ 您必须具有源存储桶的读取权限和目标存储桶的写入权限。
+ 复制的对象大小最多为 5 GB。
+ 如果您尝试将对象从 S3 Glacier Flexible Retrieval 或 S3 Glacier Deep Archive 类复制到 S3 Standard 存储类，则必须先还原这些对象。有关更多信息，请参阅 [恢复已归档的对象](restoring-objects.md)。
+ 必须在目标区域（即您打算将对象复制到的区域）中创建批量操作**复制**任务。
+ 除了针对实体标签（ETag）的条件检查和具有客户提供的加密密钥的服务器端加密（SSE-C）之外，所有 `CopyObject` 选项都受支持。
+ 如果目标存储桶不受版本控制，您将覆盖任何具有相同键名称的对象。
+ 不必以对象在清单中出现的相同顺序复制这些对象。对于受版本控制的存储桶，如果保留当前或非当前版本顺序很重要，则首先复制所有非当前版本。然后，在第一个任务完成后，在后续任务中复制当前版本。
+ 不支持将对象复制到低冗余存储（RRS）类。
+ 单个批量操作复制作业可以支持包含多达 200 亿个对象的清单。
# 使用 S3 分批操作复制对象
可以使用 Amazon S3 批量操作对 Amazon S3 对象执行大规模批量操作。可以使用 S3 批量操作创建**复制** (`CopyObject`) 任务，以便在同一账户内复制对象或将对象复制到不同的目标账户。
以下示例说明了如何存储和使用位于不同账户中的清单。第一个示例说明了如何使用 Amazon S3 清单将清单报告发送到目标账户，以便在创建任务期间使用。第二个示例说明了如何在源账户或目标账户中使用逗号分隔值（CSV）清单。第三个示例说明了如何使用**复制**操作为现有对象启用 S3 存储桶密钥，而这些对象已使用具有 AWS Key Management Service（AWS KMS）密钥的服务器端加密（SSE-KMS）进行加密。
**Topics**
+ [使用清单报告跨 AWS 账户 复制对象](specify-batchjob-manifest-xaccount-inventory.md)
+ [使用 CSV 清单跨 AWS 账户 复制对象](specify-batchjob-manifest-xaccount-csv.md)
+ [使用批量操作为 SSE-KMS 启用 S3 存储桶密钥](batch-ops-copy-example-bucket-key.md)
# 使用清单报告跨 AWS 账户 复制对象
可以使用 Amazon S3 批量操作对 Amazon S3 对象执行大规模批量操作。可以使用 S3 批量操作创建**复制** (`CopyObject`) 任务，以便在同一账户内复制对象或将对象复制到不同的目标账户。
可以使用 Amazon S3 清单创建清单报告，然后使用该报告创建要使用 S3 批量操作复制的对象列表（清单）。有关在源账户或目标账户中使用 CSV 清单的信息，请参阅 [使用 CSV 清单跨 AWS 账户 复制对象](specify-batchjob-manifest-xaccount-csv.md)。
Amazon S3 清单生成桶中的对象的清单。生成的列表将发布到输出文件。进行清点的桶称为源桶，其中存储清单报告文件的桶称为目标桶。
Amazon S3 清单报告可配置为传输到另一个 AWS 账户。如果这样做，则在目标账户中创建任务时，将支持 S3 批量操作读取清单报告。
有关 Amazon S3 清单源桶和目标桶的更多信息，请参阅 [源存储桶和目标存储桶](storage-inventory.md#storage-inventory-buckets)。
设置清单的最简单方法是使用 Amazon S3 控制台，不过您也可以使用 Amazon S3 REST API、AWS Command Line Interface (AWS CLI) 或 AWS SDK。
以下控制台过程包含用于设置 S3 分批操作任务的权限的概要步骤。在此过程中，您将对象从源账户复制到目标账户，并将清单报告存储在目标账户中。
**为由不同账户拥有的源桶和目标桶设置 Amazon S3 清单**
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**存储桶**。
1. 确定（或创建）用于存储清单报告的目标清单存储桶。在此过程中，*目标账户* 是同时拥有目标清单桶和对象要复制到的桶的账户。
1. 为源存储桶配置清单报告。有关如何使用控制台配置清单或如何加密清单列表文件的信息，请参阅[配置 Amazon S3 清单](configure-inventory.md)。
配置清单报告时，请指定要将该列表存储在其中的目标存储桶。源桶的清单报告将发布到目标桶。在此过程中，*源账户* 是拥有源桶的账户。
为输出格式选择 **CSV**。
输入目标桶的信息时，请选择 **Buckets in another account（另一个账户中的桶）**。然后，输入目标清单桶的名称。或者，可以输入目标账户的账户 ID。
在保存清单配置后，控制台会显示类似于以下内容的一条消息：
Amazon S3 无法在目标桶上创建桶策略。要求目标桶拥有者添加以下桶策略，以允许 Amazon S3 在该桶中放置数据。
然后，控制台会显示可用于目标桶的桶策略。
1. 复制显示在控制台上的目标桶策略。
1. 在目标账户中，将复制的桶策略添加到存储清单报告所在的目标清单桶。
1. 在目标账户中创建一个基于 S3 分批操作信任策略的角色。有关该信任策略的更多信息，请参阅[信任策略](batch-ops-iam-role-policies.md#batch-ops-iam-role-policies-trust)。
有关创建角色的更多信息，请参阅《IAM 用户指南》**中的[创建向 AWS 服务委派权限的角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html)。
输入角色的名称（以下示例角色使用名称 *`BatchOperationsDestinationRoleCOPY`*）。选择 **S3** 服务，然后选择 **S3 批量操作**使用案例，这会将信任策略应用于该角色。
然后选择 **Create policy (创建策略)** 以将以下策略附加到该角色。要使用此策略，请将 *`user input placeholders`* 替换为您自己的信息。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowBatchOperationsDestinationObjectCOPY",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:PutObjectVersionAcl",
"s3:PutObjectAcl",
"s3:PutObjectVersionTagging",
"s3:PutObjectTagging",
"s3:GetObject",
"s3:GetObjectVersion",
"s3:GetObjectAcl",
"s3:GetObjectTagging",
"s3:GetObjectVersionAcl",
"s3:GetObjectVersionTagging"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-destination-bucket/*",
"arn:aws:s3:::amzn-s3-demo-source-bucket/*",
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
}
]
}
```
------
该角色使用策略授予 `batchoperations.s3.amazonaws.com` 权限来读取目标桶中的清单。该角色还授予 `GET` 源对象存储桶中对象、访问控制列表（ACL）、标签和版本的权限。并且，该角色还授予将对象、ACL、标签和版本 `PUT` 到目标对象存储桶中的权限。
1. 在源账户中，为源存储桶创建存储桶策略，该策略向您在上一步中创建的角色授予 `GET` 源存储桶中对象、ACL、标签和版本的权限。此步骤允许 S3 分批操作通过可信角色获取源桶中的对象。
以下是源账户的桶策略的示例。要使用此策略，请将 *`user input placeholders`* 替换为您自己的信息。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowBatchOperationsSourceObjectCOPY",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/BatchOperationsDestinationRoleCOPY"
},
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:GetObjectAcl",
"s3:GetObjectTagging",
"s3:GetObjectVersionAcl",
"s3:GetObjectVersionTagging"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-source-bucket/*"
}
]
}
```
------
1. 在清单报告可用后，在目标账户中创建一个 S3 批量操作**复制** (`CopyObject`) 任务，并从目标清单存储桶中选择清单报告。您需要您在目标账户中创建的 IAM 角色的 ARN。
有关创建任务的一般信息，请参阅 [创建 S3 批量操作任务](batch-ops-create-job.md)。
有关使用控制台创建任务的信息，请参阅[创建 S3 批量操作任务](batch-ops-create-job.md)。
# 使用 CSV 清单跨 AWS 账户 复制对象
可以使用 Amazon S3 批量操作对 Amazon S3 对象执行大规模批量操作。可以使用 S3 批量操作创建**复制** (`CopyObject`) 任务，以便在同一账户内复制对象或将对象复制到不同的目标账户。
可以使用存储在源账户中的 CSV 清单，通过 S3 批量操作跨 AWS 账户复制对象。要使用 S3 清单报告作为清单，请参阅[使用清单报告跨 AWS 账户 复制对象](specify-batchjob-manifest-xaccount-inventory.md)。
有关清单文件的 CSV 格式的示例，请参阅[创建清单文件](batch-ops-create-job.md#create-manifest-file)。
以下过程显示了当使用 S3 批量操作任务通过存储在源账户中的 CSV 清单文件将对象从源账户复制到目标账户时，如何设置权限。
**使用 CSV 清单跨 AWS 账户复制对象**
1. 在目标账户中创建一个基于 S3 批量操作信任策略的 AWS Identity and Access Management（IAM）角色。在此过程中，*目标账户*是对象要复制到的账户。
有关信任策略的更多信息，请参阅[信任策略](batch-ops-iam-role-policies.md#batch-ops-iam-role-policies-trust)。
有关创建角色的更多信息，请参阅《IAM 用户指南》**中的[创建向 AWS 服务委派权限的角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html)。
如果您使用控制台来创建角色，请输入角色的名称（以下示例角色使用名称 `BatchOperationsDestinationRoleCOPY`）。选择 **S3** 服务，然后选择 **S3 批量操作**使用案例，这会将信任策略应用于该角色。
然后选择 **Create policy (创建策略)** 以将以下策略附加到该角色。要使用此策略，请将 *`user input placeholders`* 替换为您自己的信息。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowBatchOperationsDestinationObjectCOPY",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:PutObjectVersionAcl",
"s3:PutObjectAcl",
"s3:PutObjectVersionTagging",
"s3:PutObjectTagging",
"s3:GetObject",
"s3:GetObjectVersion",
"s3:GetObjectAcl",
"s3:GetObjectTagging",
"s3:GetObjectVersionAcl",
"s3:GetObjectVersionTagging"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-destination-bucket/*",
"arn:aws:s3:::amzn-s3-demo-source-bucket/*",
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
}
]
}
```
------
使用策略，该角色将授予 `batchoperations.s3.amazonaws.com` 权限以读取源清单存储桶中的清单。该角色授予对源对象存储桶中的 `GET` 对象、访问控制列表（ACL）、标签和版本的权限。它还授予对目标对象存储桶中的 `PUT` 对象、ACL、标签和版本的权限。
1. 在源账户中，为包含清单的存储桶创建存储桶策略，来向您在上一步中创建的角色授予对源清单存储桶中 `GET` 对象和版本的权限。
此步骤可让 S3 批量操作通过使用可信角色来读取清单。将存储桶策略应用于包含清单的存储桶。
以下是要应用于源清单存储桶的存储桶策略的示例。要使用此策略，请将 *`user input placeholders`* 替换为您自己的信息。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowBatchOperationsSourceManifestRead",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:user/ConsoleUserCreatingJob",
"arn:aws:iam::111122223333:role/BatchOperationsDestinationRoleCOPY"
]
},
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
}
]
}
```
------
此策略还授予权限来允许要在目标账户中创建任务的控制台用户通过相同的存储桶策略具有源清单存储桶中的相同权限。
1. 在源账户中，为源存储桶创建存储桶策略，该策略向您创建的角色授予对源对象存储桶中 `GET` 对象、ACL、标签和版本的权限。然后，S3 分批操作可以通过可信角色获取源存储桶中的对象。
以下是包含源对象的存储桶的存储桶策略示例。要使用此策略，请将 *`user input placeholders`* 替换为您自己的信息。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowBatchOperationsSourceObjectCOPY",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/BatchOperationsDestinationRoleCOPY"
},
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:GetObjectAcl",
"s3:GetObjectTagging",
"s3:GetObjectVersionAcl",
"s3:GetObjectVersionTagging"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-source-bucket/*"
}
]
}
```
------
1. 在目标账户中创建 S3 分批操作任务。您需要您在目标账户中创建的角色的 Amazon Resource Name (ARN)。有关创建作业的更多信息，请参阅[创建 S3 批量操作任务](batch-ops-create-job.md)。
# 使用批量操作为 SSE-KMS 启用 S3 存储桶密钥
S3 存储桶密钥通过减少从 Amazon S3 到 AWS KMS 的请求流量，降低了具有 AWS Key Management Service（AWS KMS）的服务器端加密（SSE-KMS）的成本。有关更多信息，请参阅[使用 Amazon S3 存储桶密钥降低 SSE-KMS 的成本](bucket-key.md)和[将存储桶配置为将 S3 存储桶密钥与 SSE-KMS 结合使用于新对象](configuring-bucket-key.md)。当您使用 REST API、AWS SDK 或 AWS CLI 执行 `CopyObject` 操作时，可以通过添加带有 `true` 或 `false` 值的 `x-amz-server-side-encryption-bucket-key-enabled` 请求标头，在对象级别启用或禁用 S3 存储桶密钥。
当您使用 `CopyObject` 操作为对象配置 S3 存储桶密钥时，Amazon S3 仅更新该对象的设置。目标存储桶的 S3 存储桶密钥设置不会发生变化。如果您向启用了 S3 存储桶密钥的存储桶提交对于 AWS KMS 加密对象的 `CopyObject` 请求，对象级操作将自动使用 S3 存储桶密钥，则除非您在请求标头中禁用这些密钥。如果您未为对象指定 S3 存储桶密钥，则 Amazon S3 会将目标存储桶的 S3 存储桶密钥设置应用于该对象。
要加密现有 Amazon S3 对象，可以使用 S3 批量操作。您可以使用**批量操作复制操作**复制现有的未加密对象，并将其作为加密对象写回同一存储桶。有关更多信息，请参阅 AWS 存储博客上的 [Encrypting objects with Amazon S3 Batch Operations](https://aws.amazon.com/blogs/storage/encrypting-objects-with-amazon-s3-batch-operations/)。
在以下示例中，使用批量操作**复制**操作在现有对象上启用 S3 存储桶密钥。有关更多信息，请参阅 [在对象级别配置 S3 存储桶密钥](configuring-bucket-key-object.md)。
**Topics**
+ [使用 S3 批量操作通过已启用的 S3 存储桶密钥加密对象的注意事项](#bucket-key-ex-things-to-note)
+ [先决条件](#bucket-key-ex-prerequisites)
+ [第 1 步：使用 Amazon S3 清单获取对象列表](#bucket-key-ex-get-list-of-objects)
+ [第 2 步：使用 S3 Select 筛选对象列表](#bucket-key-ex-filter-object-list-with-s3-select)
+ [第 3 步：设置并运行 S3 分批操作任务](#bucket-key-ex-setup-and-run-job)
## 使用 S3 批量操作通过已启用的 S3 存储桶密钥加密对象的注意事项
使用 S3 批量操作通过已启用的 S3 存储桶密钥加密对象时，请考虑以下问题：
+ 除了与 S3 批量操作代表您执行的操作关联的任何费用之外（包括数据传输、请求等费用），您还需要为 S3 批量操作任务、对象和请求付费。有关更多信息，请参阅 [Amazon S3 定价](https://aws.amazon.com/s3/pricing)。
+ 如果您使用受版本控制的桶，则执行的每个 S3 分批操作任务都会创建对象的新加密版本。另外，无需配置 S3 桶密钥即可维护以前的版本。要删除旧版本，请为非当前版本设置 S3 生命周期过期策略，如 [生命周期配置元素](intro-lifecycle-rules.md)。
+ 复制操作会创建具有新创建日期的新对象，这会影响生命周期操作（如归档）。如果您复制桶中的所有对象，所有新副本均具有相同或相似的创建日期。要进一步识别这些对象并为各种数据子集创建不同的生命周期规则，请考虑使用对象标签。
## 先决条件
在将对象配置为使用 S3 存储桶密钥之前，请查看[启用 S3 存储桶密钥之前需要注意的更改](bucket-key.md#bucket-key-changes)。
要使用此示例，您必须具有 AWS 账户和至少一个 S3 存储桶来存放工作文件和加密的结果。您可能还会发现许多有用的现有 S3 分批操作文档，包括以下主题：
+ [S3 批量操作基础知识](batch-ops.md#batch-ops-basics)
+ [创建 S3 批量操作任务](batch-ops-create-job.md)
+ [S3 分批操作支持的操作](batch-ops-operations.md)
+ [管理 S3 分批操作任务](batch-ops-managing-jobs.md)
## 第 1 步：使用 Amazon S3 清单获取对象列表
要开始操作，请确定包含要加密对象的 S3 Bucket，并获取其内容列表。Amazon S3 清单报告是完成此操作的最方便且最经济的方式。报告提供存储桶中对象的列表及其关联的元数据。在此步骤中，源存储桶是进行清点的存储桶，目标存储桶是您存储清单报告文件的存储桶。有关 Amazon S3 清单源桶和目标桶的更多信息，请参阅 [使用 S3 清单对数据进行编目和分析](storage-inventory.md)。
设置清单最简单的方法是使用 AWS 管理控制台。但您也可以使用 REST API、AWS Command Line Interface (AWS CLI) 或 AWS 开发工具包。执行以下步骤之前，请务必登录控制台，并通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。如果遇到权限拒绝错误，请在目标桶中添加桶策略。有关更多信息，请参阅 [向 S3 清单和 S3 分析功能授予权限](example-bucket-policies.md#example-bucket-policies-s3-inventory-1)。
**使用 S3 清单获取对象列表**
1. 通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**存储桶**，然后选择包含要加密的对象的存储桶。
1. 在 **Management (管理)** 选项卡导航至 **Inventory configurations (清单配置)** 部分，然后选择 **Create inventory configuration (创建清单配置)**。
1. 为您的新清单命名，输入目标 S3 Bucket 的名称，并可选择为 Amazon S3 创建目标前缀，以便在该桶中分配对象。
1. 为 **Output format (输出格式)** 选择 **CSV**。
1. （可选）在**其他字段 – *可选***部分中，选择**加密**以及您感兴趣的任何其他报告字段。将报告发送频率设置为 **Daily（每天）**，以便更快将第一个报告发送到您的桶。
1. 选择 **Create (创建)** 以保存您的配置。
Amazon S3 可能需要长达 48 小时才能交付第一个报告，所以当第一个报告到达时请予以查看。收到第一个报告后，请转入下一步来筛选 S3 清单报告的内容。如果您不再希望接收此桶的清单报告，请删除您的 S3 清单配置。否则，Amazon S3 会继续按每日或每周计划提供报告。
清单列表并非所有对象的单个时间点视图。清单列表是桶项的滚动快照，最终是一致的（例如，列表可能不包含最近添加或删除的对象）。当您使用静态对象或两天乃至更多天之前创建的对象集时，将 S3 清单和 S3 分批操作结合使用效果最佳。要处理最新数据，请使用 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html)（`GET` 存储桶）API 操作来手动构建对象列表。如有需要，请在接下来的几天内重复该过程，或直到清单报告显示所有对象的理想状态。
## 第 2 步：使用 S3 Select 筛选对象列表
收到 S3 清单报告后，可以筛选报告的内容，以仅列出未使用已启用的 S3 存储桶密钥进行加密的对象。如果您希望使用已启用的 S3 存储桶密钥来加密存储桶的所有对象，则可以忽略此步骤。但是，在此阶段筛选 S3 清单报告，则对于先前使用已启用的 S3 存储桶密钥加密的对象，可以节省对其重新加密的时间和费用。
尽管以下步骤介绍的是如何使用 [Amazon S3 Select](https://aws.amazon.com/blogs/aws/s3-glacier-select/) 进行筛选，但也可以使用 [Amazon Athena](https://aws.amazon.com/athena)。要决定使用哪个工具，请查看 S3 清单报告的 `manifest.json` 文件。此文件列出了与该报告关联的数据文件的数量。如果数量较大，请使用 Amazon Athena，因为其运行在多个 S3 对象之间，而 S3 Select 一次仅适用一个对象。有关将 Amazon S3 和 Athena 结合使用的更多信息，请参阅[使用 Amazon Athena 查询 Amazon S3 清单](storage-inventory-athena-query.md)以及 AWS 存储博客文章 [Encrypting objects with Amazon S3 Batch Operations](https://aws.amazon.com/blogs/storage/encrypting-objects-with-amazon-s3-batch-operations) 中的“Using Athena”。
**使用 S3 Select 筛选 S3 清单报告**
1. 打开清单报告中的 `manifest.json` 文件，然后查看 JSON 中的 `fileSchema` 部分。这将通知您的数据运行查询。
以下 JSON 是一个示例 `manifest.json` 文件，用于查看已启用版本控制的桶上的 CSV 格式清单。根据您配置库存报告的方式，您的清单可能会有所不同。
```
{
"sourceBucket": "batchoperationsdemo",
"destinationBucket": "arn:aws:s3:::amzn-s3-demo-destination-bucket",
"version": "2021-05-22",
"creationTimestamp": "1558656000000",
"fileFormat": "CSV",
"fileSchema": "Bucket, Key, VersionId, IsLatest, IsDeleteMarker, BucketKeyStatus",
"files": [
{
"key": "demoinv/batchoperationsdemo/DemoInventory/data/009a40e4-f053-4c16-8c75-6100f8892202.csv.gz",
"size": 72691,
"MD5checksum": "c24c831717a099f0ebe4a9d1c5d3935c"
}
]
}
```
如果桶未激活版本控制，或者您选择运行最新版本报告，则 `fileSchema` 是 `Bucket`、`Key` 和 `BucketKeyStatus`。
如果*激活了*版本控制，根据您设置清单报告的方式，`fileSchema` 可能包括：`Bucket`、`Key`、`VersionId`、`IsLatest`、`IsDeleteMarker`、`BucketKeyStatus`。因此，当您运行查询时，请注意第 1、2、3 和 6 栏。
除了搜索依据字段（即 `BucketKeyStatus`）外，S3 批量操作还需要输入桶、密钥和版本 ID 以执行任务。您不需要 `VersionID` 字段，但在对受版本控制的存储桶进行操作时，指定 `VersionID` 字段很有用。有关更多信息，请参阅 [使用启用版本控制的存储桶中的对象](manage-objects-versioned-bucket.md)。
1. 找到清单报告的数据文件。`manifest.json` 对象列出了**文件夹**下的数据文件。
1. 在 S3 控制台中找到并选择数据文件后，选择 **Actions (操作)**，然后选择 **Query with S3 Select (使用 S3 Select 进行查询)**。
1. 保留预设 **CSV**、**逗号** 和 **GZIP** 字段，然后选择 **Next (下一步)**。
1. 如需在继续操作之前检查清单报告格式，请选择 **Show file preview (显示文件预览)**。
1. 在 SQL 表达式字段中输入要引用的列，然后选择 **Run SQL**（运行 SQL）。以下表达式为未配置 S3 桶密钥的所有对象返回列 1-3。
`select s._1, s._2, s._3 from s3object s where s._6 = 'DISABLED'`
以下是示例结果。
```
batchoperationsdemo,0100059%7Ethumb.jpg,lsrtIxksLu0R0ZkYPL.LhgD5caTYn6vu
batchoperationsdemo,0100074%7Ethumb.jpg,sd2M60g6Fdazoi6D5kNARIE7KzUibmHR
batchoperationsdemo,0100075%7Ethumb.jpg,TLYESLnl1mXD5c4BwiOIinqFrktddkoL
batchoperationsdemo,0200147%7Ethumb.jpg,amufzfMi_fEw0Rs99rxR_HrDFlE.l3Y0
batchoperationsdemo,0301420%7Ethumb.jpg,9qGU2SEscL.C.c_sK89trmXYIwooABSh
batchoperationsdemo,0401524%7Ethumb.jpg,ORnEWNuB1QhHrrYAGFsZhbyvEYJ3DUor
batchoperationsdemo,200907200065HQ%7Ethumb.jpg,d8LgvIVjbDR5mUVwW6pu9ahTfReyn5V4
batchoperationsdemo,200907200076HQ%7Ethumb.jpg,XUT25d7.gK40u_GmnupdaZg3BVx2jN40
batchoperationsdemo,201103190002HQ%7Ethumb.jpg,z.2sVRh0myqVi0BuIrngWlsRPQdb7qOS
```
1. 下载结果，将其保存为 CSV 格式，然后将其作为 S3 分批操作任务的对象列表上传至 Amazon S3。
1. 如果您有多个清单文件，也请对它们运行 **Query with S3 Select (使用 S3 Select 进行查询)**。根据结果的大小，您可以合并列表并运行单个 S3 分批操作任务，或将每个列表作为单独任务运行。要决定要运行的任务数量，请考虑运行每个 S3 批量操作任务的[价格](https://aws.amazon.com/s3/pricing/)。
## 第 3 步：设置并运行 S3 分批操作任务
现在，您有了 S3 对象的筛选 CSV 列表，可以开始 S3 批量操作任务，以使用已启用的 S3 存储桶密钥来加密对象。
*任务*指提供的对象列表（清单）、执行的操作以及指定的参数的统称。使用已启用的 S3 存储桶密钥加密此对象集的最简单方法是使用**复制**操作，并指定与清单中列出的对象相同的目标前缀。在不受版本控制的存储桶中，此操作会覆盖现有对象。在开启了版本控制的存储桶中，此操作将创建对象的较新的加密版本。
作为复制对象的一部分，指定 Amazon S3 应使用 SSE-KMS 加密来为对象进行加密。此任务会复制这些对象，因此，所有对象在完成时都显示更新后的创建日期，无论最初是何时将其添加到 Amazon S3 的。另外，在 S3 分批操作任务中指定对象集的其他属性，包括对象标记和存储类。
**Topics**
+ [设置 IAM 策略](#bucket-key-ex-set-up-iam-policy)
+ [设置分批操作 IAM 角色](#bucket-key-ex-set-up-iam-role)
+ [为现有存储桶启用 S3 存储桶密钥](#bucket-key-ex-enable-s3-bucket-key-on-a-bucket)
+ [创建分批操作任务](#bucket-key-ex-create-job)
+ [运行您的分批操作任务](#bucket-key-ex-run-job)
### 设置 IAM 策略
1. 通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。
1. 在左侧导航窗格中，选择**策略**，然后选择**创建策略**。
1. 选择 **JSON** 选项卡。选择 **Edit Policy (编辑策略)**，然后添加出现在以下代码块中的示例 IAM 策略。
将策略示例复制到 [IAM 控制台](https://console.aws.amazon.com/iam/)后，请替换以下内容：
1. 将 `amzn-s3-demo-source-bucket` 替换为要从中复制对象的源存储桶的名称。
1. 将 `amzn-s3-demo-destination-bucket` 替换为要向其中复制对象的目标存储桶的名称。
1. 将 `amzn-s3-demo-manifest-bucket/manifest-key` 替换为清单对象的名称。
1. 将 `amzn-s3-demo-completion-report-bucket` 替换为要用于保存完成报告的存储桶的名称。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CopyObjectsToEncrypt",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:PutObjectTagging",
"s3:PutObjectAcl",
"s3:PutObjectVersionTagging",
"s3:PutObjectVersionAcl",
"s3:GetObject",
"s3:GetObjectAcl",
"s3:GetObjectTagging",
"s3:GetObjectVersion",
"s3:GetObjectVersionAcl",
"s3:GetObjectVersionTagging"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-source-bucket/*",
"arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
]
},
{
"Sid": "ReadManifest",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-manifest-bucket/manifest-key"
},
{
"Sid": "WriteReport",
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
}
]
}
```
------
1. 选择 **Next: Tags (下一步：标签)**。
1. 添加您想要的所有标签（可选），然后选择 **Next: Review (下一步：审核)**。
1. 添加策略名称，可添加描述，然后选择 **Create Policy (创建策略)**。
1. 选择 **Review policy (查看策略)** 和 **Save changes (保存更改)**。
1. 您的 S3 分批操作策略现已完成，控制台会将您返回到 IAM **Policies (策略)** 页面。筛选策略名称，选择策略名称左侧的按钮，选择 **Policy actions (策略操作)**，然后选择 **Attach (附加)**。
如需将新创建的策略附加到 IAM 角色，请在账户中选择相应的用户、组或角色，然后选择 **Attach policy (附加策略)**。系统会带您返回 IAM 控制台。
### 设置分批操作 IAM 角色
1. 在 [IAM 控制台](https://console.aws.amazon.com/iam/)的导航窗格中，选择**角色**，然后选择**创建角色**。
1. 选择 **AWS 服务**、**S3** 和 **S3 批量操作**。然后选择 **Next: Permissions (下一步：权限)**。
1. 输入您刚刚创建的 IAM **策略**的名称。根据出现的策略名称选中相应名称，然后选择 **Next: Tags (下一步：标签)**。
1. （可选）为本次练习添加标签或将密钥和值字段保留为空。选择 **Next: Review (下一步：审核)**。
1. 输入角色名称，然后接受默认说明或添加您自己的说明。选择 **Create role (创建角色)**。
1. 确保创建任务的用户具有以下示例中的权限。
将 `account-id` 替换为您的 AWS 账户 ID，并将 `IAM-role-name` 替换为您计划应用于稍后将在批量操作任务创建步骤中创建的 IAM 角色的名称。有关更多信息，请参阅 [授予批处理操作的权限](batch-ops-iam-role-policies.md)。
```
{
"Sid": "AddIamPermissions",
"Effect": "Allow",
"Action": [
"iam:GetRole",
"iam:PassRole"
],
"Resource": "arn:aws:iam::account-id:role/IAM-role-name"
}
```
### 为现有存储桶启用 S3 存储桶密钥
1. 通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在**桶**列表中，选择要为其启用 S3 桶密钥的桶。
1. 选择 **Properties (属性)**。
1. 在 **Default encryption (默认加密)** 下，请选择 **Edit (编辑)**。
1. 在**加密类型**下，您可以在 **Amazon S3 托管式密钥（SSE-S3）**和 **AWS Key Management Service 密钥（SSE-KMS）**之间进行选择。
1. 如果您选择了 **AWS Key Management Service 密钥（SSE-KMS）**，则在 **AWS KMS key**下，您可以通过以下选项之一指定 AWS KMS 密钥。
+ 要从可用的 KMS 密钥列表中进行选择，请选择**从您的 AWS KMS 密钥中进行选择**。从可用密钥的列表中，选择与桶位于同一区域的对称加密 KMS 密钥。AWS 托管式密钥（`aws/s3`）和您的客户自主管理型密钥都显示在列表中。
+ 要输入 KMS 密钥 ARN，请选择**输入 AWS KMS 密钥 ARN**，然后在显示的字段中输入您的 KMS 密钥 ARN。
+ 要在 AWS KMS 控制台中创建新的客户自主管理型密钥，请选择**创建 KMS 密钥**。
1. 在 **Bucket Key（桶密钥）**中，选择 **Enable（启用）**，然后选择 **Save changes（保存更改）**。
现在，S3 存储桶密钥已在存储桶级别启用，默认情况下，上传、修改或复制到此存储桶中的对象将继承此加密配置。这包括使用 Amazon S3 批量操作复制的对象。
### 创建分批操作任务
1. 通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在导航窗格中，选择 **Batch Operations (分批操作)**，然后选择 **Create Job (创建任务)**。
1. 选择您存储对象的 **Region (区域)**，然后选择 **CSV** 作为清单类型。
1. 输入路径或导航至您之前从 S3 Select（或 Athena）结果创建的 CSV 清单文件。如果您的清单包含版本 ID，请选中该框。选择 **Next (下一步)**。
1. 选择 **Copy** 操作，然后选择复制目标桶。您可以保持禁用服务器端加密。只要桶目标启用了 S3 桶密钥，复制操作将在目标桶上应用 S3 桶密钥。
1. （可选）根据需要选择存储类和其他参数。您在此步骤中指定的参数将应用于清单中列出的对象执行的所有操作。选择**下一步**。
1. 要配置服务器端加密，请执行以下步骤：
1. 在**服务器端加密**下，选择以下选项之一：
+ 要在将对象存储在 Amazon S3 中时保留适用于对象原定设置服务器端加密的桶设置，请选择**不要指定加密密钥**。只要桶目标启用了 S3 桶密钥，复制操作就将在目标桶上应用 S3 桶密钥。
**注意**
如果指定的目标的桶策略要求在将对象存储到 Amazon S3 之前对其进行加密，则必须指定加密密钥。否则，将对象复制到目标将失败。
+ 要在将对象存储到 Amazon S3 之前对其进行加密，请选择**指定加密密钥**。
1. 在**加密设置**下，如果您选择**指定加密密钥**，则必须选择**使用用于原定设置加密的目标桶设置**或**覆盖用于原定设置加密的目标桶设置**。
1. 如果您选择**覆盖用于原定设置加密的目标桶设置**，则必须配置以下加密设置。
1. 在**加密类型**下，您必须选择 **Amazon S3 托管式密钥（SSE-S3）**或 **AWS Key Management Service 密钥（SSE-KMS）**。SSE-S3 使用最强的数据块密码之一 [即 256 位高级加密标准（AES-256）] 来加密每个对象。SSE-KMS 为您提供了对密钥的更多控制。有关更多信息，请参阅[使用具有 Amazon S3 托管式密钥的服务器端加密（SSE-S3）](UsingServerSideEncryption.md)和[使用具有 AWS KMS 密钥的服务器端加密（SSE-KMS）](UsingKMSEncryption.md)。
1. 如果您选择 **AWS Key Management Service 密钥（SSE-KMS）**，则在 **AWS KMS key**下，您可以通过以下选项之一指定 AWS KMS key。
+ 要从可用 KMS 密钥列表中进行选择，请选择**从您的 AWS KMS keys 中进行选择**，然后选择与桶位于同一区域的对称加密 KMS 密钥。AWS 托管式密钥（`aws/s3`）和您的客户自主管理型密钥都显示在列表中。
+ 要输入 KMS 密钥 ARN，请选择**输入 AWS KMS 密钥 ARN**，然后在显示的字段中输入您的 KMS 密钥 ARN。
+ 要在 AWS KMS 控制台中创建新的客户自主管理型密钥，请选择**创建 KMS 密钥**。
1. 在 **Bucket Key（存储桶密钥）**下，请选择 **Enable（启用）**。复制操作将在目标桶应用 S3 桶密钥。
1. 提供任务说明（或保留默认值），设置其优先级，选择报告类型，然后指定 **Path to completion report destination (完成报告目标的路径)**。
1. 在 **Permissions (权限)** 部分，请确保选择您之前定义的分批操作 IAM 角色。选择 **Next (下一步)**。
1. 在 **Review (审核)** 中验证设置。如果需要进行更改，请选择 **Previous (上一步)**。确认分批操作设置后，选择 **Create job (创建任务)**。
有关更多信息，请参阅 [创建 S3 批量操作任务](batch-ops-create-job.md)。
### 运行您的分批操作任务
安装向导将自动将您返回 Amazon S3 控制台的 S3 分批操作部分。随着 S3 开始此过程，您的新任务将从 **New (新建)** 状态变为 **Preparing (准备中)** 状态。在 Preparing (准备中) 状态下，S3 会读取任务清单，检查是否存在错误，并计算对象数量。
1. 在 Amazon S3 控制台中选择刷新按钮以检查进度。根据清单的大小，读取可能需要几分钟或几小时。
1. S3 读取任务清单后，任务将转移至 **Awaiting your confirmation (待确认)** 状态。选择任务 ID 左侧的选项按钮，然后选择 **Run job (运行任务)**。
1. 检查任务设置，然后选择右下角的 **Run job (运行任务)**。
任务开始运行后，您可以选择刷新按钮通过控制台控制面板视图或选择特定任务来检查进度。
1. 任务完成后，您可以查看 **Successful (成功)** 和 **Failed (失败)** 对象数量以确认所有任务均按预期执行。如果您启用了任务报告，请检查任务报告，了解失败操作的确切原因。
还可以使用 AWS CLI、AWS SDK 或 Amazon S3 REST API 来执行这些步骤。有关追踪任务状态和完成报告的更多信息，请参阅 [跟踪任务状态和完成报告](batch-ops-job-status.md)。
有关说明使用 AWS CLI 和 适用于 Java 的 AWS SDK 对标签进行复制操作的示例，请参阅 [使用用于标记的任务标签创建分批操作任务](batch-ops-tags-create.md)。
# 计算校验和
可以将 S3 批量操作与**计算校验和**操作结合使用，来对存储在 Amazon S3 中的静态对象执行校验和计算。**计算校验和**操作计算对象校验和，可以使用这些校验和来验证数据完整性，而无需下载或还原所存储数据的对象。对于所有支持的校验和算法，可以使用**计算校验和**操作来计算复合和完整对象校验和类型的校验和。
使用**计算校验和**操作，可以通过单个任务请求处理数十亿个对象。无论对象大小如何，此批量操作均与所有 S3 存储类别兼容。要创建**计算校验和**任务，请使用 Amazon S3 控制台、AWS Command Line Interface（AWS CLI）、AWS SDK 或 Amazon S3 REST API。
[启用服务器访问日志记录](https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerLogs.html)后，还可以接收有关**计算校验和**任务的日志条目。完成校验和计算后，**计算校验和**任务操作会发出单独的服务器访问日志事件。这些日志条目遵循标准的 [S3 服务器访问日志记录格式](https://docs.aws.amazon.com/AmazonS3/latest/userguide/LogFormat.html)，并包括操作类型、时间戳、[error codes](https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#ErrorCodeList) 和关联的**计算校验和**任务 ID 等字段。此日志记录提供对对象执行的校验和验证活动的审计跟踪记录，有助于您跟踪和验证数据完整性操作。
**注意**
**计算校验和**操作不支持使用具有客户提供的加密密钥的服务器端加密（SSE-C）进行加密的对象。但是，可以将**计算校验和**操作用于通过使用[具有 S3 托管式密钥的服务器端加密（SSE-S3）](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html)、具有 AWS Key Management Service 的服务器端加密（DSSE-KMS）进行加密的对象。确保您已[授予适当的 AWS KMS 权限](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html#require-sse-kms)来执行**计算校验和**操作。
要开始使用批量操作来进行**计算校验和**操作，您可以：
+ 手动创建新的清单文件。
+ 使用现有的清单。
+ 指示批量操作根据您[在创建任务时指定的](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-create-job.html#specify-batchjob-manifest)对象筛选条件自动生成清单。
然后，提交**计算校验和**任务请求并监控其状态。**计算校验和**任务完成后，您将在指定的目标存储桶中自动收到完成报告。此完成报告包含存储桶中每个对象的校验和信息，可让您验证数据一致性。有关如何使用此报告来检查任务的更多信息，请参阅[跟踪任务状态和完成报告](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-job-status.html)。
有关**计算校验和**功能以及如何在控制台中使用**计算校验和**的更多信息，请参阅[在 Amazon S3 中检查静态数据的对象完整性](checking-object-integrity-at-rest.md)。有关如何向**计算校验和**发送 REST 请求的信息，请参阅《Amazon S3 API Reference》**中的 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DescribeJob.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DescribeJob.html) 和 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateJob.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateJob.html)。
以下各节介绍如何开始将**计算校验和**操作与 S3 批量操作结合使用。
**Topics**
+ [S3 批量操作**计算校验和**注意事项](#batch-ops-compute-checksum-considerations)
+ [S3 批量操作完成报告](#batch-ops-compute-checksum-completion-report)
## S3 批量操作**计算校验和**注意事项
在使用**计算校验和**操作之前，请查看以下注意事项列表：
+ 如果您的清单包含版本 ID 字段，则必须为清单中的所有对象提供版本 ID。如果未指定版本 ID，**计算校验和**请求将针对最新版本的对象执行该操作。
+ 要在[服务器访问日志](https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerLogs.html)中接收**计算校验和**操作详细信息，必须先在源存储桶上[启用服务器访问日志记录](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-server-access-logging.html)，然后指定用于存储日志的目标存储桶。目标存储桶必须也位于源存储桶所在的相同 AWS 区域和 AWS 账户中。配置服务器访问日志记录后，**计算校验和**操作会生成[日志记录](https://docs.aws.amazon.com/AmazonS3/latest/userguide/LogFormat.html#log-record-fields)，其中包含标准字段，例如操作类型、HTTP 状态代码、[S3 错误代码](https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#ErrorCodeList)、时间戳和关联的**计算校验和**作业 ID。**计算校验和**操作异步运行。因此，[日志条目](https://docs.aws.amazon.com/AmazonS3/latest/userguide/LogFormat.html#log-record-fields)在其各个日志条目中使用**计算校验和**任务 ID，而不是请求 ID。
+ 对于存储的对象，生成报告可能需要长达几个小时。
+ 对于以下 S3 Glacier 存储类别，**计算校验和**任务可能需要长达一周的时间才能完成：
+ S3 Glacier Flexible Retrieval
+ S3 Glacier Deep Archive
+ 对于将在其中写入完成报告的存储桶，在运行**计算校验和**操作时，必须使用[存储桶拥有者条件](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-owner-condition.html#bucket-owner-condition-when-to-use)。如果对于提交的任务请求，实际存储桶拥有者与预期存储桶拥有者不匹配，则任务将失败。有关不支持存储桶拥有者条件的 S3 操作的列表，请参阅[限制和局限性](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-owner-condition.html#bucket-owner-condition-restrictions-limitations)。
## S3 批量操作完成报告
当您创建**计算校验和**任务时，可以请求 S3 批量操作完成报告。此 CSV 文件显示对象、成功或失败代码、输出和描述。有关任务跟踪和完成报告的更多信息，请参阅[完成报告](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-job-status.html#batch-ops-completion-report)。
# 删除所有对象标签
可以使用 Amazon S3 批量操作对 Amazon S3 对象执行大规模批量操作。**删除所有对象标签**操作将删除当前与清单中列出的对象关联的所有 Amazon S3 对象标签集。S3 批量操作不支持在保留其它标签的同时删除对象中的标签。
如果清单中的对象位于受版本控制的存储桶中，则可以从对象的特定版本中删除标签集。为此，必须为清单中的每个对象指定版本 ID。如果您没有包括对象的版本 ID，S3 分批操作将从每个对象的最新版本中删除该标签集。有关分批操作清单的更多信息，请参阅 [指定清单](batch-ops-create-job.md#specify-batchjob-manifest)。
有关对象标记的详细信息，请参阅本指南中的[使用标签对对象进行分类](object-tagging.md)，以及《Amazon Simple Storage Service API 参考》**中的 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html)、[https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObjectTagging.html) 和 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjectTagging.html)。
**警告**
运行此任务将删除清单中列出的每个对象上的所有对象标签集。
要使用控制台创建**删除所有对象标签**任务，请参阅[创建 S3 批量操作任务](batch-ops-create-job.md)。
## 限制和局限性
使用批量操作来删除对象标签时，以下限制和局限性适用：
+ 您指定用于运行该任务的 AWS Identity and Access Management（IAM）角色必须有权执行基础 Amazon S3 `DeleteObjectTagging` 操作。有关更多信息，请参阅《Amazon Simple Storage Service API 参考》**中的 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjectTagging.html)。
+ S3 批量操作使用 Amazon S3 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjectTagging.html) 操作从清单中的每个对象移除标签集。适用于基础操作的所有限制也适用于 S3 分批操作任务。
+ 单个删除对象标记作业可以支持包含多达 200 亿个对象的清单。
# 调用 AWS Lambda 函数
可以使用 Amazon S3 批量操作对 Amazon S3 对象执行大规模批量操作。批量操作**调用 AWS Lambda 函数**操作将启动 AWS Lambda 函数，来对清单中列出的对象执行自定义操作。本部分介绍如何创建 Lambda 函数来与 S3 批量操作结合使用，以及如何创建任务来调用该函数。S3 批量操作任务使用 `LambdaInvoke` 操作对清单中列出的每个对象运行 Lambda 函数。
可以使用 Amazon S3 控制台、AWS Command Line Interface（AWS CLI）、AWS SDK 或 Amazon S3 REST API 处理 S3 批量操作。有关使用 Lambda 的更多信息，请参阅《*AWS Lambda 开发人员指南*》中的[入门AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html)。
以下部分说明如何开始将 S3 批量操作与 Lambda 结合使用。
**Topics**
+ [将 Lambda 与批量操作结合使用](#batch-ops-invoke-lambda-using)
+ [创建与 S3 批量操作一起使用的 Lambda 函数](#batch-ops-invoke-lambda-custom-functions)
+ [创建调用 Lambda 函数的 S3 批量操作任务](#batch-ops-invoke-lambda-create-job)
+ [在 Lambda 清单中提供任务级信息](#storing-task-level-information-in-lambda)
+ [S3 批量操作教程](#batch-ops-tutorials-lambda)
## 将 Lambda 与批量操作结合使用
将 S3 批量操作与 AWS Lambda 结合使用时，您必须创建专门用于 S3 批量操作的新 Lambda 函数。您无法在 S3 批量操作中重复使用基于事件的现有 Amazon S3 函数。事件函数只能接收消息；不返回消息。与 S3 批量操作结合使用的 Lambda 函数必须接受并返回消息。有关将 Lambda 与 Amazon S3 事件结合使用的更多信息，请参阅《*AWS Lambda 开发人员指南*》中的[将 AWS Lambda 与 Amazon S3](https://docs.aws.amazon.com/lambda/latest/dg/with-s3.html) 结合使用。
创建调用 Lambda 函数的 S3 批量操作任务。此任务在清单中列出的所有对象上运行相同的 Lambda 函数。在处理清单中的对象时，您可以控制要使用的 Lambda 函数版本。S3 批量操作支持非限定的 Amazon Resource Name（ARN）、别名和特定版本。有关更多信息，请参阅《*AWS Lambda 开发人员指南*》中的[AWS Lambda 版本控制简介](https://docs.aws.amazon.com/lambda/latest/dg/versioning-intro.html)。
如果您提供的 S3 批量操作任务包含使用别名或 `$LATEST` 限定符的函数 ARN，并更新它们各自所指向的版本，S3 批量操作开始调用 Lambda 函数的新版本。如果您希望通过大型任务更新此方法的功能部分，这会非常有用。如果您不希望 S3 批量操作更改所使用的版本，请在创建任务时在 `FunctionARN` 参数中提供特定版本。
使用 S3 批量操作的单个 AWS Lambda 作业可以支持包含多达 200 亿个对象的清单。
### 将 Lambda 和批量操作用于目录存储桶
目录存储桶是一种 Amazon S3 存储桶类型，专为需要一致的个位数毫秒延迟的工作负载或性能至关重要的应用程序而设计。有关更多信息，请参阅[目录存储桶](https://docs.aws.amazon.com//AmazonS3/latest/userguide/directory-buckets-overview.html)。
使用批量操作来调用处理目录存储桶的 Lambda 函数有特殊要求。例如，必须使用更新后的 JSON 架构来构建 Lambda 请求，并在创建任务时指定 [https://docs.aws.amazon.com//AmazonS3/latest/API/API_control_LambdaInvokeOperation.html#AmazonS3-Type-control_LambdaInvokeOperation-InvocationSchemaVersion](https://docs.aws.amazon.com//AmazonS3/latest/API/API_control_LambdaInvokeOperation.html#AmazonS3-Type-control_LambdaInvokeOperation-InvocationSchemaVersion) 2.0（而不是 1.0）。这一更新后的架构可让您为 [https://docs.aws.amazon.com//AmazonS3/latest/API/API_control_LambdaInvokeOperation.html#AmazonS3-Type-control_LambdaInvokeOperation-UserArguments](https://docs.aws.amazon.com//AmazonS3/latest/API/API_control_LambdaInvokeOperation.html#AmazonS3-Type-control_LambdaInvokeOperation-UserArguments) 指定可选的键值对，您可以使用这些键值对修改现有 Lambda 函数的某些参数。有关更多信息，请参阅 AWS 存储博客中的 [Automate object processing in Amazon S3 directory buckets with S3 Batch Operations and AWS Lambda](https://aws.amazon.com/blogs/storage/automate-object-processing-in-amazon-s3-directory-buckets-with-s3-batch-operations-and-aws-lambda/)。
### 响应和结果代码
S3 批量操作使用一个或多个键调用 Lambda 函数，每个键都有一个与之关联的 `TaskID`。S3 批量操作需要 Lambda 函数提供每个键的结果代码。对于在请求中发送的任何任务 ID，如果没有为它们返回每个键的结果代码，则将从 `treatMissingKeysAs` 字段中提供结果代码。`treatMissingKeysAs` 是可选的请求字段，默认为 `TemporaryFailure`。下表包含 `treatMissingKeysAs` 字段的其它可能的结果代码和值。
| 响应代码 | 描述 |
| --- | --- |
| Succeeded | 任务正常完成。如果您请求了任务完成报告，报告中将包含任务的结果字符串。 |
| TemporaryFailure | 任务暂时失败，将在任务完成前重新启动。忽略结果字符串。如果是最后一次重新启动，最终报告将包含错误消息。 |
| PermanentFailure | 任务永久失败。如果您请求了任务完成报告，任务将被标记为 Failed 并包含错误消息字符串。忽略失败任务的结果字符串。 |
## 创建与 S3 批量操作一起使用的 Lambda 函数
此部分提供使用 Lambda 函数必须具有的 AWS Identity and Access Management (IAM) 权限示例。它还包含一个与 S3 批量操作一起使用的示例 Lambda 函数。如果您之前从未创建过 Lambda 函数，请参阅《*AWS Lambda 开发人员指南*》中的[教程：将 AWS Lambda 与 Amazon S3 结合使用](https://docs.aws.amazon.com/lambda/latest/dg/with-s3-example.html)。
您必须创建专门与 S3 批量操作一起使用的 Lambda 函数。您无法重用基于 Amazon S3 事件的现有 Lambda 函数，因为用于 S3 批量操作的 Lambda 函数必须接受并返回特殊数据字段。
**重要**
用 Java 编写的 AWS Lambda 函数接受 [https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/RequestHandler.java](https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/RequestHandler.java) 或 [https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/RequestStreamHandler.java](https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/RequestStreamHandler.java) 处理程序接口。但是，为了支持 S3 批量操作请求和响应格式，AWS Lambda 需要 `RequestStreamHandler` 接口来对请求和响应进行自定义序列化和反序列化。此接口允许 Lambda 将 InputStream 和 OutputStream 传递给 Java `handleRequest` 方法。
将 Lambda 函数与 S3 批量操作结合使用时，请务必使用 `RequestStreamHandler` 接口。如果您使用 `RequestHandler` 接口，则批处理任务会失败，并在完成报告中显示“Lambda 负载中返回无效的 JSON”。
有关更多信息，请参阅《*AWS Lambda 用户指南*》中的[处理程序接口](https://docs.aws.amazon.com//lambda/latest/dg/java-handler.html#java-handler-interfaces)。
### IAM 权限示例
以下是将 Lambda 函数与 S3 批量操作结合使用所需的 IAM 权限示例。
**Example – S3 批量操作信任策略**
以下是您可用于批量操作 IAM 角色的信任策略示例。当您创建任务并授予批量操作代入 IAM 角色的权限时，会指定此 IAM 角色。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "batchoperations.s3.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
**Example – Lambda IAM 策略**
以下是提供 S3 批量操作权限以调用 Lambda 函数和读取输入清单的 IAM 策略示例。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "BatchOperationsLambdaPolicy",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:PutObject",
"lambda:InvokeFunction"
],
"Resource": "*"
}
]
}
```
### 示例请求和响应
本节内容提供 Lambda 函数的请求和响应示例。
**Example 请求**
以下是 Lambda 函数的请求的 JSON 示例。
```
{
"invocationSchemaVersion": "1.0",
"invocationId": "YXNkbGZqYWRmaiBhc2RmdW9hZHNmZGpmaGFzbGtkaGZza2RmaAo",
"job": {
"id": "f3cc4f60-61f6-4a2b-8a21-d07600c373ce"
},
"tasks": [
{
"taskId": "dGFza2lkZ29lc2hlcmUK",
"s3Key": "customerImage1.jpg",
"s3VersionId": "1",
"s3BucketArn": "arn:aws:s3:us-east-1:0123456788:amzn-s3-demo-bucket1"
}
]
}
```
**Example 响应**
以下是 Lambda 函数的响应的 JSON 示例。
```
{
"invocationSchemaVersion": "1.0",
"treatMissingKeysAs" : "PermanentFailure",
"invocationId" : "YXNkbGZqYWRmaiBhc2RmdW9hZHNmZGpmaGFzbGtkaGZza2RmaAo",
"results": [
{
"taskId": "dGFza2lkZ29lc2hlcmUK",
"resultCode": "Succeeded",
"resultString": "[\"Mary Major", \"John Stiles\"]"
}
]
}
```
### S3 批量操作的 Lambda 函数示例
以下示例中，Python Lambda 从受版本控制的对象中移除删除标记。
如示例所示，S3 批量操作中的键采用 URL 编码。要将 Amazon S3 与其他 AWS 服务结合使用，请务必对从 S3 批量操作传递的键进行 URL 解码。
```
import logging
from urllib import parse
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logger.setLevel("INFO")
s3 = boto3.client("s3")
def lambda_handler(event, context):
"""
Removes a delete marker from the specified versioned object.
:param event: The S3 batch event that contains the ID of the delete marker
to remove.
:param context: Context about the event.
:return: A result structure that Amazon S3 uses to interpret the result of the
operation. When the result code is TemporaryFailure, S3 retries the
operation.
"""
# Parse job parameters from Amazon S3 batch operations
invocation_id = event["invocationId"]
invocation_schema_version = event["invocationSchemaVersion"]
results = []
result_code = None
result_string = None
task = event["tasks"][0]
task_id = task["taskId"]
try:
obj_key = parse.unquote_plus(task["s3Key"], encoding="utf-8")
obj_version_id = task["s3VersionId"]
bucket_name = task["s3BucketArn"].split(":")[-1]
logger.info(
"Got task: remove delete marker %s from object %s.", obj_version_id, obj_key
)
try:
# If this call does not raise an error, the object version is not a delete
# marker and should not be deleted.
response = s3.head_object(
Bucket=bucket_name, Key=obj_key, VersionId=obj_version_id
)
result_code = "PermanentFailure"
result_string = (
f"Object {obj_key}, ID {obj_version_id} is not " f"a delete marker."
)
logger.debug(response)
logger.warning(result_string)
except ClientError as error:
delete_marker = error.response["ResponseMetadata"]["HTTPHeaders"].get(
"x-amz-delete-marker", "false"
)
if delete_marker == "true":
logger.info(
"Object %s, version %s is a delete marker.", obj_key, obj_version_id
)
try:
s3.delete_object(
Bucket=bucket_name, Key=obj_key, VersionId=obj_version_id
)
result_code = "Succeeded"
result_string = (
f"Successfully removed delete marker "
f"{obj_version_id} from object {obj_key}."
)
logger.info(result_string)
except ClientError as error:
# Mark request timeout as a temporary failure so it will be retried.
if error.response["Error"]["Code"] == "RequestTimeout":
result_code = "TemporaryFailure"
result_string = (
f"Attempt to remove delete marker from "
f"object {obj_key} timed out."
)
logger.info(result_string)
else:
raise
else:
raise ValueError(
f"The x-amz-delete-marker header is either not "
f"present or is not 'true'."
)
except Exception as error:
# Mark all other exceptions as permanent failures.
result_code = "PermanentFailure"
result_string = str(error)
logger.exception(error)
finally:
results.append(
{
"taskId": task_id,
"resultCode": result_code,
"resultString": result_string,
}
)
return {
"invocationSchemaVersion": invocation_schema_version,
"treatMissingKeysAs": "PermanentFailure",
"invocationId": invocation_id,
"results": results,
}
```
## 创建调用 Lambda 函数的 S3 批量操作任务
创建 S3 批量操作任务以调用 Lambda 函数时，必须提供以下信息：
+ Lambda 函数的 ARN（可能包含函数别名或特定版本号）
+ 具有调用此函数的权限的 IAM 角色
+ 操作参数 `LambdaInvokeFunction`
有关创建 S3 批量操作任务的更多信息，请参阅 [创建 S3 批量操作任务](batch-ops-create-job.md) 和 [S3 分批操作支持的操作](batch-ops-operations.md)。
以下示例使用 AWS CLI 创建用于调用 Lambda 函数的 S3 批量操作任务。要使用此示例，请将 *`user input placeholders`* 替换为您自己的信息。
```
aws s3control create-job
--account-id account-id
--operation '{"LambdaInvoke": { "FunctionArn": "arn:aws:lambda:region:account-id:function:LambdaFunctionName" } }'
--manifest '{"Spec":{"Format":"S3BatchOperations_CSV_20180820","Fields":["Bucket","Key"]},"Location":{"ObjectArn":"arn:aws:s3:::amzn-s3-demo-manifest-bucket","ETag":"ManifestETag"}}'
--report '{"Bucket":"arn:aws:s3:::amzn-s3-demo-bucket","Format":"Report_CSV_20180820","Enabled":true,"Prefix":"ReportPrefix","ReportScope":"AllTasks"}'
--priority 2
--role-arn arn:aws:iam::account-id:role/BatchOperationsRole
--region region
--description "Lambda Function"
```
## 在 Lambda 清单中提供任务级信息
当您将 AWS Lambda 函数与 S3 批量操作结合使用时，对于所运行的各个任务或键，可能会需要附带额外的数据。例如，您可能希望同时提供源对象键和新的对象键。然后，您的 Lambda 函数可以将源键以新名称复制到新 S3 存储桶。默认情况下，通过批量操作，可以仅在任务的输入清单中指定目标存储桶以及源键的列表。下面的示例介绍了如何在清单中包含额外的数据，以便运行更复杂的 Lambda 函数。
要在 S3 批量操作清单中指定各个键的参数以在 Lambda 函数代码中使用，请使用以下 URL 编码的 JSON 格式。`key` 字段采用类似于 Amazon S3 对象键的方式传递到您的 Lambda 函数。但是，Lambda 函数可以解释此字段来包含其它值或多个键，如下示例所示。
**注意**
清单中 `key` 字段的最大字符数为 1024。
**Example – 清单将“Amazon S3 密钥”替换为 JSON 字符串**
必须向 S3 批量操作提供 URL 编码的版本。
```
amzn-s3-demo-bucket,{"origKey": "object1key", "newKey": "newObject1Key"}
amzn-s3-demo-bucket,{"origKey": "object2key", "newKey": "newObject2Key"}
amzn-s3-demo-bucket,{"origKey": "object3key", "newKey": "newObject3Key"}
```
**Example – URL 编码的清单**
必须向 S3 批量操作提供此 URL 编码的版本。非 URL 编码的版本不起作用。
```
amzn-s3-demo-bucket,%7B%22origKey%22%3A%20%22object1key%22%2C%20%22newKey%22%3A%20%22newObject1Key%22%7D
amzn-s3-demo-bucket,%7B%22origKey%22%3A%20%22object2key%22%2C%20%22newKey%22%3A%20%22newObject2Key%22%7D
amzn-s3-demo-bucket,%7B%22origKey%22%3A%20%22object3key%22%2C%20%22newKey%22%3A%20%22newObject3Key%22%7D
```
**Example – 具有清单格式的 Lambda 函数将结果写入任务报告**
这个 URL 编码的清单示例包含以竖线分隔的对象键，供以下 Lambda 函数进行解析。
```
amzn-s3-demo-bucket,object1key%7Clower
amzn-s3-demo-bucket,object2key%7Cupper
amzn-s3-demo-bucket,object3key%7Creverse
amzn-s3-demo-bucket,object4key%7Cdelete
```
此 Lambda 函数显示了如何解析编码到 S3 批量操作清单中的以竖线分隔的任务。该任务指示应用于指定对象的修订操作。
```
import logging
from urllib import parse
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logger.setLevel("INFO")
s3 = boto3.resource("s3")
def lambda_handler(event, context):
"""
Applies the specified revision to the specified object.
:param event: The Amazon S3 batch event that contains the ID of the object to
revise and the revision type to apply.
:param context: Context about the event.
:return: A result structure that Amazon S3 uses to interpret the result of the
operation.
"""
# Parse job parameters from Amazon S3 batch operations
invocation_id = event["invocationId"]
invocation_schema_version = event["invocationSchemaVersion"]
results = []
result_code = None
result_string = None
task = event["tasks"][0]
task_id = task["taskId"]
# The revision type is packed with the object key as a pipe-delimited string.
obj_key, revision = parse.unquote_plus(task["s3Key"], encoding="utf-8").split("|")
bucket_name = task["s3BucketArn"].split(":")[-1]
logger.info("Got task: apply revision %s to %s.", revision, obj_key)
try:
stanza_obj = s3.Bucket(bucket_name).Object(obj_key)
stanza = stanza_obj.get()["Body"].read().decode("utf-8")
if revision == "lower":
stanza = stanza.lower()
elif revision == "upper":
stanza = stanza.upper()
elif revision == "reverse":
stanza = stanza[::-1]
elif revision == "delete":
pass
else:
raise TypeError(f"Can't handle revision type '{revision}'.")
if revision == "delete":
stanza_obj.delete()
result_string = f"Deleted stanza {stanza_obj.key}."
else:
stanza_obj.put(Body=bytes(stanza, "utf-8"))
result_string = (
f"Applied revision type '{revision}' to " f"stanza {stanza_obj.key}."
)
logger.info(result_string)
result_code = "Succeeded"
except ClientError as error:
if error.response["Error"]["Code"] == "NoSuchKey":
result_code = "Succeeded"
result_string = (
f"Stanza {obj_key} not found, assuming it was deleted "
f"in an earlier revision."
)
logger.info(result_string)
else:
result_code = "PermanentFailure"
result_string = (
f"Got exception when applying revision type '{revision}' "
f"to {obj_key}: {error}."
)
logger.exception(result_string)
finally:
results.append(
{
"taskId": task_id,
"resultCode": result_code,
"resultString": result_string,
}
)
return {
"invocationSchemaVersion": invocation_schema_version,
"treatMissingKeysAs": "PermanentFailure",
"invocationId": invocation_id,
"results": results,
}
```
## S3 批量操作教程
以下教程提供了使用 Lambda 的一些批量操作任务的完整端到端过程。在本教程中，您将了解如何将批量操作设置为调用 Lambda 函数，来对存储在 S3 源存储桶中的视频进行批量转码。Lambda 函数调用 AWS Elemental MediaConvert 来对视频进行转码。
+ [教程：使用 S3 批量操作对视频进行批量转码](tutorial-s3-batchops-lambda-mediaconvert-video.md)
# 替换所有对象标签
可以使用 Amazon S3 批量操作对 Amazon S3 对象执行大规模批量操作。**替换所有对象标签**操作将替换清单中列出的每个对象上的对象标签。 对象标签是一个字符串的键/值对，您可用它来存储有关对象的元数据。
要创建**替换所有对象标签**任务，您需要提供要应用的标签集。S3 分批操作将相同的标签集应用于每个对象。您提供的标签集替换已与清单中的对象关联的任何标签集。S3 批量操作不支持在保留现有标签的同时向对象添加标签。
如果清单中的对象位于受版本控制的存储桶中，您可将标签集应用到每个对象的特定版本。为此，请为清单中的每个对象指定版本 ID。如果您没有包括任何对象的版本 ID，则 S3 批量操作将标签集应用到每个对象的最新版本。有关分批操作清单的更多信息，请参阅 [指定清单](batch-ops-create-job.md#specify-batchjob-manifest)。
有关对象标记的更多信息，请参阅本指南中的[使用标签对对象进行分类](object-tagging.md)，并参阅《Amazon Simple Storage Service API 参考》**中的 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html)、[https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObjectTagging.html) 和 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjectTagging.html)。
要使用控制台创建**替换所有对象标签**任务，请参阅[创建 S3 批量操作任务](batch-ops-create-job.md)。
## 限制和局限性
使用批量操作来替换对象标签时，以下限制和局限性适用：
+ 您指定用于运行批量操作任务的 AWS Identity and Access Management（IAM）角色必须有权执行基础 `PutObjectTagging` 操作。有关所需权限的更多信息，请参阅《Amazon Simple Storage Service API 参考》**中的 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html)。
+ S3 批量操作使用 Amazon S3 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html) 操作，来将标签应用到清单中的每个对象。适用于基础操作的所有限制也适用于 S3 分批操作任务。
+ 单个替换所有对象标签作业可以支持包含多达 200 亿个对象的清单。
# 替换访问控制列表（ACL）
可以使用 Amazon S3 批量操作对 Amazon S3 对象执行大规模批量操作。**替换访问控制列表（ACL）**操作会替换在清单中列出的每个对象的访问控制列表（ACL）。使用 ACL，您可以定义谁可以访问某个对象，以及他们可以执行哪些操作。
**注意**
Amazon S3 中的大多数现代使用案例不再需要使用 ACL。我们建议您将 ACL 保持为禁用状态，除非有需要单独控制每个对象的访问权限的情况。禁用 ACL 后，您可以使用策略来控制对存储桶中所有对象的访问权限，无论是谁将对象上传到您的存储桶。有关更多信息，请参阅 [为您的存储桶控制对象所有权和禁用 ACL。](about-object-ownership.md)。
S3 批量操作支持您定义的自定义 ACL 以及 Amazon S3 随预定义的访问权限集提供的标准 ACL。
如果清单中的对象位于受版本控制的存储桶中，您可将 ACL 应用到每个对象的特定版本。为此，请为清单中的每个对象指定版本 ID。如果您没有包括任何对象的版本 ID，S3 批量操作将 ACL 应用到对象的最新版本。
有关 Amazon S3 中 ACL 的更多信息，请参阅[访问控制列表 (ACL) 概述](acl-overview.md)。
**S3 阻止公有访问**
如果您要限制对存储桶中所有对象的公共访问权限，建议您使用 Amazon S3 屏蔽公共访问权限，而不是使用 S3 批量操作来应用 ACL。阻止公有访问可以在各个存储桶或整个账户的范围进行，并且只需一个简单的操作，立即生效。当您的目标是控制对某个存储桶或账户中所有对象的公共访问权限时，此行为使 Amazon S3 屏蔽公共访问权限成为更好的选择。仅当您需要将自定义 ACL 应用到清单中的每个对象时，才使用 S3 批量操作。有关 S3 阻止公有访问的更多信息，请参阅 [阻止对您的 Amazon S3 存储的公有访问](access-control-block-public-access.md)。
**S3 对象所有权**
如果清单中的对象位于存储桶中，而该存储桶对于对象所有权使用**强制存储桶拥有者**设置，则**替换访问控制列表（ACL）**操作只能指定向存储桶拥有者授予完全控制权限的对象 ACL。在这种情况下，**替换访问控制列表（ACL）**操作无法将对象 ACL 权限授予其它 AWS 账户或组。有关更多信息，请参阅 [为您的存储桶控制对象所有权和禁用 ACL。](about-object-ownership.md)。
## 限制和局限性
使用批量操作来替换 ACL 时，以下限制和局限性适用：
+ 您指定用于运行**替换访问控制列表（ACL）**任务的 AWS Identity and Access Management（IAM）角色必须有权执行基础 Amazon S3 `PutObjectAcl` 操作。有关所需权限的更多信息，请参阅《Amazon Simple Storage Service API 参考》**中的 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectAcl.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectAcl.html)。
+ S3 分批操作使用 Amazon S3 `PutObjectAcl` 操作，将指定的 ACL 应用到清单中的每个对象。因此，适用于基础 `PutObjectAcl` 操作的所有限制和局限性也适用于 S3 批量操作**替换访问控制列表（ACL）**任务。
+ 单个替换访问控制列表作业可以支持包含多达 200 亿个对象的清单。
# 使用批量操作还原对象
可以使用 Amazon S3 批量操作对 Amazon S3 对象执行大规模批量操作。**还原**操作启动对清单中列出的已归档 Amazon S3 对象的还原请求。必须先还原以下归档对象，然后才能实时访问这些对象：
+ 在 S3 Glacier Flexible Retrieval 或 S3 Glacier Deep Archive 存储类中归档的对象
+ 通过归档访问层或深度归档访问层中的 S3 Intelligent-Tiering 存储类归档的对象
在 S3 批量操作任务中使用**还原**（[https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_S3InitiateRestoreObjectOperation.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_S3InitiateRestoreObjectOperation.html)）操作，会导致针对在清单中指定的每个对象发出 `RestoreObject` 请求。
**重要**
**还原**任务仅*启动* 还原对象的请求。在为每个对象启动请求后，S3 分批操作将对象的任务报告为完成。还原对象时，Amazon S3 不会更新任务或以其他方式通知您。不过，当对象在 Amazon S3 中可用时，您可以使用 S3 事件通知来接收通知。有关更多信息，请参阅 [Amazon S3 事件通知](EventNotifications.md)。
当您创建**还原**任务时，可以使用以下参数：
**ExpirationInDays**
此参数用于指定 S3 Glacier Flexible Retrieval 或 S3 Glacier Deep Archive 对象在 Amazon S3 中保持可用的时长。以 S3 Glacier Flexible Retrieval 和 S3 Glacier Deep Archive 对象为目标的**还原**任务要求您将 `ExpirationInDays` 设置为 `1` 或更大的值。
在创建以 S3 Intelligent-Tiering 归档访问和深度归档访问层对象为目标的**还原**操作任务时，请勿设置 `ExpirationInDays`。S3 Intelligent-Tiering 归档访问层中的对象不受还原到期的限制，因此指定 `ExpirationInDays` 会导致 `RestoreObject` 请求失败。
**GlacierJobTier**
Amazon S3 可以使用三个不同的检索层之一还原对象：`EXPEDITED`、`STANDARD` 和 `BULK`。但是，S3 分批操作功能仅支持 `STANDARD` 和 `BULK` 检索层。有关各检索层之间的差异的更多信息，请参阅[了解归档检索选项](restoring-objects-retrieval-options.md)。
有关每层定价的更多信息，请参阅 [Amazon S3 定价](https://aws.amazon.com/s3/pricing/)页面上的**请求和数据检索**部分。
## 从 S3 Glacier 和 S3 Intelligent-Tiering 还原时的区别
从 S3 Glacier Flexible Retrieval 或 S3 Glacier Deep Archive 存储类还原归档文件与从归档访问层或深度归档访问层中的 S3 Intelligent-Tiering 存储类恢复文件不同。
+ 当您从 S3 Glacier Flexible Retrieval 或 S3 Glacier Deep Archive 中还原时，将创建对象的临时*副本*。Amazon S3 会在 `ExpirationInDays` 参数中指定的值过期后删除此副本。删除此临时副本后，您必须提交额外的还原请求才能访问该对象。
+ 还原归档的 S3 Intelligent-Tiering 对象时，请*勿*指定 `ExpirationInDays` 参数。当您从 S3 Intelligent-Tiering 归档访问层或深度归档访问层还原对象时，此对象会转换回 S3 Intelligent-Tiering 频繁访问层中。在至少连续 90 天无访问后，对象会自动转换到归档访问层。在至少连续 180 天无访问后，对象会自动移动到深度归档访问层。
+ 批量操作任务既可以在 S3 Glacier Flexible Retrieval 和 S3 Glacier Deep Archive 存储类对象上运行，*也可以*在 S3 Intelligent-Tiering 归档访问和深度归档访问存储层对象上运行。批量操作不能在同一个任务中对两种类型的归档对象进行操作。要还原两种类型的对象，*必须*创建单独的分批操作任务。
## 重叠还原
如果 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_S3InitiateRestoreObjectOperation.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_S3InitiateRestoreObjectOperation.html) 任务尝试还原已处于还原过程中的对象，S3 批量操作的过程如下所示。
如果满足以下任意条件，对象的还原操作将成功：
+ 与已在进行的还原请求相比，此任务的 `ExpirationInDays` 值相同，而其 `GlacierJobTier` 值更快。
+ 之前的还原请求已完成，对象当前已可用。在这种情况下，批量操作会更新已还原对象的过期日期，以便与在正在进行的还原请求中指定的 `ExpirationInDays` 值匹配。
如果满足以下任意条件，对象的还原操作失败：
+ 已在进行的还原请求尚未完成，并且此任务的还原持续时间（由 `ExpirationInDays` 值指定）不同于在正在进行的还原请求中指定的还原持续时间。
+ 此任务的还原层（由 `GlacierJobTier` 值指定）与在正进行的还原请求中指定的还原层速度相同或更慢。
## 限制
`S3InitiateRestoreObjectOperation` 任务具有以下限制：
+ 您必须在与归档对象相同的区域中创建任务。
+ S3 批量操作不支持 `EXPEDITED` 检索层。
+ 单个批量操作还原作业可以支持包含多达 40 亿个对象的清单。
有关还原对象的更多信息，请参阅 [恢复已归档的对象](restoring-objects.md)。
# 更新对象加密
可以使用 Amazon S3 批量操作对 Amazon S3 对象执行大规模批量操作。批量操作 [https://docs.aws.amazon.com//AmazonS3/latest/API/API_control_UpdateObjectEncryptionOperation.html](https://docs.aws.amazon.com//AmazonS3/latest/API/API_control_UpdateObjectEncryptionOperation.html) 操作使用单个请求来更新多个 Amazon S3 对象的服务器端加密类型。单个 `UpdateObjectEncryption` 复制作业可以支持包含多达 200 亿个对象的清单。
通用存储桶支持的所有 Amazon S3 存储类别都支持 `UpdateObjectEncryption` 操作。您可以使用 `UpdateObjectEncryption` 操作来将加密的对象从[具有 Amazon S3 托管式密钥的服务器端加密（SSE-S3）](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingServerSideEncryption.html)更改为 [AWS Key Management Service（AWS KMS）密钥（SSE-KMS）](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingKMSEncryption.html)，或者应用 S3 存储桶密钥。还可以使用 `UpdateObjectEncryption` 操作来更改用于加密数据的客户自主管理型 KMS 密钥，这样您就可以遵守自定义密钥轮换标准。
创建批量操作作业时，可以根据您指定的源位置和筛选条件生成对象列表。可以使用 `MatchAnyObjectEncryption` 筛选条件从存储桶中生成您要更新并包含在清单中的对象的列表。生成的对象列表仅包含具有指定的服务器端加密类型的源存储桶对象。如果您选择 SSE-KMS，则可以选择通过指定特定的 KMS 密钥 ARN 和“存储桶密钥已启用”状态来进一步筛选结果。有关更多信息，请参阅《Amazon S3 API 参考》**中的 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_JobManifestGeneratorFilter.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_JobManifestGeneratorFilter.html) 和 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_SSEKMSFilter.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_SSEKMSFilter.html)。
## 限制和注意事项
当您使用批量操作 `UpdateObjectEncryption` 操作时，以下限制和注意事项适用：
+ `UpdateObjectEncryption` 操作不支持未加密的对象，也不支持使用具有 AWS KMS keys 的双层服务器端加密（DSSE-KMS）或客户提供的加密密钥（SSE-C）进行加密的对象。此外，您不能指定 SSE-S3 加密类型 `UpdateObjectEncryption` 请求。
+ 您可以使用 `UpdateObjectEncryption` 操作来更新存储桶中启用了 S3 版本控制的对象。要更新特定版本的加密类型，您必须在 `UpdateObjectEncryption` 请求中指定版本 ID。如果未指定版本 ID，则 `UpdateObjectEncryption` 请求作用于对象的当前版本。有关 S3 版本控制的更多信息，请参阅[使用 S3 版本控制保留对象的多个版本](Versioning.md)。
+ `UpdateObjectEncryption` 操作对任何应用了 S3 对象锁定保留模式或法定保留的对象都将失败。如果某个对象具有治理模式保留期或法定保留，则在发出 `UpdateObjectEncryption` 请求之前，必须先移除该对象的对象锁定状态。您不能对应用了对象锁定合规模式保留期的对象使用 `UpdateObjectEncryption` 操作。有关 S3 对象锁定的更多信息，请参阅 [使用对象锁定以锁定对象](object-lock.md)。
+ 启用了实时复制功能的源存储桶上的 `UpdateObjectEncryption` 请求不会在目标存储桶中启动副本事件。如果要更改源存储桶和目标存储桶中对象的加密类型，则必须对源存储桶和目标存储桶中的对象发起单独的 `UpdateObjectEncryption` 请求。
+ 默认情况下，所有指定客户自主管理型 KMS 密钥的 `UpdateObjectEncryption` 请求都仅限于存储桶所有者的 AWS 账户拥有的 KMS 密钥。如果您正在使用 AWS Organizations，则可以通过联系 AWS 支持 来请求使用组织内其它成员账户拥有的 AWS KMS keys的能力。
+ 如果您使用 S3 批量复制来跨区域复制数据集，并且您的对象之前已将其服务器端加密类型从 SSE-S3 更新为 SSE-KMS，则您可能需要额外的权限。在源区域存储桶上，您必须拥有 `kms:decrypt` 权限。然后，您将需要针对目标区域中存储桶的 `kms:decrypt` 和 `kms:encrypt` 权限。
+ 在您的 `UpdateObjectEncryption` 请求中提供完整的 KMS 密钥 ARN。您不能使用别名名称或别名 ARN。您可以在 AWS KMS 控制台中或使用 AWS KMS `DescribeKey` API 确定完整的 KMS 密钥 ARN。
有关 `UpdateObjectEncryption` 的更多信息，请参阅[更新现有数据的服务器端加密](update-sse-encryption.md)。
## 所需的权限
要执行 `UpdateObjectEncryption` 操作，请将以下 AWS Identity and Access Management（IAM）策略添加到您的 IAM 主体（用户、角色或组）。要使用此策略，请将 *`amzn-s3-demo-bucket`* 替换为包含您要更新其加密的对象的存储桶名称。将 `amzn-s3-demo-manifest-bucket` 替换为包含清单的存储桶的名称，并将 `amzn-s3-demo-completion-report-bucket` 替换为要存储完成报告的存储桶的名称。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "S3BatchOperationsUpdateEncryption",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:PutObject",
"s3:UpdateObjectEncryption"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket-target"
"arn:aws:s3:::amzn-s3-demo-bucket-target-target/*"
]
},
{
"Sid": "S3BatchOperationsPolicyForManifestFile",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket-manifest/*"
]
},
{
"Sid": "S3BatchOperationsPolicyForCompletionReport",
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket-completion-report/*"
]
},
{
"Sid": "S3BatchOperationsPolicyManifestGeneration",
"Effect": "Allow",
"Action": [
"s3:PutInventoryConfiguration"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket-target"
]
},
{
"Sid": "AllowKMSOperationsForS3BatchOperations",
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey",
"kms:Encrypt",
"kms:ReEncrypt*"
],
"Resource": [ "arn:aws:kms:us-east-1:111122223333:key/01234567-89ab-cdef-0123-456789abcdef"
]
}
]
}
```
有关您必须附加到 S3 批量操作服务主体代表您运行批量操作作业所代入的 IAM 角色的信任策略和权限策略，请参阅[授予批处理操作的权限](batch-ops-iam-role-policies.md)和[更新对象加密](batch-ops-iam-role-policies.md#batch-ops-update-encryption-policies)。
# 创建批量操作作业以更新对象加密
要使用单个请求更新多个 Amazon S3 对象的服务器端加密类型，您可以使用 S3 批量操作。可以通过 Amazon S3 控制台、AWS Command Line Interface（AWS CLI）、AWS SDK 或 Amazon S3 REST API 使用 S3 批量操作。
## 使用 AWS CLI
要运行以下命令，您必须安装并配置 AWS CLI。如果未安装 AWS CLI，请参阅《AWS Command Line Interface 用户指南》**中的[安装或更新最新版本的 AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/getting-started-install.html)。
或者，可以从控制台中使用 AWS CloudShell 运行 AWS CLI 命令。AWS CloudShell 是一个基于浏览器、预先经过身份验证的 Shell，您可以直接从 AWS 管理控制台中启动它。有关更多信息，请参阅《AWS CloudShell 用户指南》**中的 [What is CloudShell?](https://docs.aws.amazon.com//cloudshell/latest/userguide/welcome.html) 和 [Getting started with AWS CloudShell](https://docs.aws.amazon.com//cloudshell/latest/userguide/getting-started.html)。
**Example 1 – 创建一个批量操作作业，该作业将加密的对象从一个 AWS KMS key更新为另一个 KMS 密钥**
以下示例说明如何创建一个 S3 批量操作作业，该作业更新通用存储桶中多个对象的加密设置。此命令创建一个作业，该作业将使用一个 AWS Key Management Service（AWS KMS）密钥加密的对象更改为使用不同的 KMS 密钥。此作业还会生成和保存受影响对象的清单，并创建结果报告。要使用此命令，请将 `user input placeholders` 替换为您自己的信息。
```
aws s3control create-job --account-id account-id \
--no-confirmation-required \
--operation '{"S3UpdateObjectEncryption": { "ObjectEncryption": { "SSEKMS": { "KMSKeyArn": "KMS-key-ARN-to-apply", "BucketKeyEnabled": false } } } }' \
--report '{ "Enabled": true, "Bucket": "report-bucket-ARN", "Format": "Report_CSV_20180820", "Prefix": "report", "ReportScope": "AllTasks" }' \
--manifest-generator '{ "S3JobManifestGenerator": { "ExpectedBucketOwner": "account-id", "SourceBucket": "source-bucket-ARN", "EnableManifestOutput": true, "ManifestOutputLocation": { "Bucket": "manifest-bucket-ARN", "ManifestFormat": "S3InventoryReport_CSV_20211130", "ManifestPrefix": "manifest-prefix" }, "Filter": { "MatchAnyObjectEncryption": [{ "SSEKMS": { "KmsKeyArn": "kms-key-ARN-to-match" } }] } } }' \
--priority 1 \
--role-arn batch-operations-role-ARN
```
为了获得最佳性能，我们建议将 `KmsKeyArn` 筛选条件与其它对象元数据筛选条件（例如 `MatchAnyPrefix`、`CreatedAfter` 或 `MatchAnyStorageClass`）结合使用。
**Example 2 – 创建一个批量操作作业，该作业将 SSE-S3 加密的对象更新为 SSE-KMS**
以下示例说明如何创建一个 S3 批量操作作业，该作业更新通用存储桶中多个对象的加密设置。此命令创建一个作业，该作业将使用具有 Amazon S3 托管式密钥的服务器端加密（SSE-S3）加密的对象更改为使用具有 AWS Key Management Service（AWS KMS）密钥的服务器端加密（SSE-KMS）。此作业还会生成和保存受影响对象的清单，并创建结果报告。要使用此命令，请将 `user input placeholders` 替换为您自己的信息。
```
aws s3control create-job --account-id account-id \
--no-confirmation-required \
--operation '{"S3UpdateObjectEncryption": { "ObjectEncryption": { "SSEKMS": { "KMSKeyArn": "KMS-key-ARN-to-apply", "BucketKeyEnabled": false } } } }' \
--report '{ "Enabled": true, "Bucket": "report-bucket-ARN", "Format": "Report_CSV_20180820", "Prefix": "report", "ReportScope": "AllTasks" }' \
--manifest-generator '{ "S3JobManifestGenerator": { "ExpectedBucketOwner": "account-id", "SourceBucket": "source-bucket-ARN", "EnableManifestOutput": true, "ManifestOutputLocation": { "Bucket": "manifest-bucket-ARN", "ManifestFormat": "S3InventoryReport_CSV_20211130", "ManifestPrefix": "manifest-prefix" }, "Filter": { "MatchAnyObjectEncryption": [{ "SSES3": {} }] } } }' \
--priority 1 \
--role-arn batch-operations-role-ARN
```
为了获得最佳性能，我们建议将 `KmsKeyArn` 筛选条件与其它对象元数据筛选条件（例如 `MatchAnyPrefix`、`CreatedAfter` 或 `MatchAnyStorageClass`）结合使用。
# S3 对象锁定保留
可以使用 Amazon S3 批量操作对 Amazon S3 对象执行大规模批量操作。可以使用**对象锁定保留**操作，通过*监管*模式或*合规*模式来为对象应用保留日期。这些保留模式会应用不同级别的保护。可将任一保留模式应用于任意对象版本。与依法保留类似，保留日期可防止覆盖或删除对象。Amazon S3 存储在对象的元数据中指定的*保留到期日*，并保护指定的对象版本，直到保留期到期。
可以将 S3 批量操作与对象锁定结合使用，以便同时管理许多 Amazon S3 对象的保留日期。可以在清单中指定目标对象的列表，并将该清单提交到批量操作以完成操作。有关更多信息，请参阅 S3 对象锁定[保留期限](object-lock.md#object-lock-retention-periods)。
具有保留日期的任务 S3 分批操作将持续运行，直至达到完成、取消或失败状态。当要通过单个请求添加、更改或移除许多对象的保留日期时，建议使用 S3 批量操作和 S3 对象锁定保留。
在处理清单中的任何密钥之前，分批操作会验证是否已在您的存储桶上启用对象锁定。要执行操作和验证，批量操作需要 AWS Identity and Access Management（IAM）角色中的 `s3:GetBucketObjectLockConfiguration` 和 `s3:PutObjectRetention` 权限，来支持批量操作代表您调用对象锁定。有关更多信息，请参阅 [对象锁定注意事项](object-lock-managing.md)。
有关将此操作与 REST API 结合使用的信息，请参阅《Amazon Simple Storage Service API 参考》**的 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateJob.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateJob.html) 操作中的 `S3PutObjectRetention`。
有关使用此操作的 AWS Command Line Interface（AWS CLI）示例，请参阅[使用 AWS CLI](batch-ops-object-lock-retention.md#batch-ops-cli-object-lock-retention-example)。有关 适用于 Java 的 AWS SDK 示例，请参阅[使用适用于 Java 的 AWS SDK](batch-ops-object-lock-retention.md#batch-ops-examples-java-object-lock-retention)。
## 限制和局限性
使用批量操作来应用对象锁定保留期时，以下限制和局限性适用：
+ S3 批量操作不会进行任何存储桶级别的更改。
+ 必须在执行任务的存储桶上配置版本控制和 S3 对象锁定。
+ 清单中列出的所有对象都必须位于同一个存储桶中。
+ 除非清单中明确指定了版本，否则该操作将适用于最新版本的对象。
+ 您需要在 IAM 角色中拥有 `s3:PutObjectRetention` 权限，才能使用**对象锁定保留**任务。
+ 需要 `s3:GetBucketObjectLockConfiguration` IAM 权限，才能确认为您正在对其执行任务的 S3 存储桶启用了对象锁定。
+ 只能在应用 `COMPLIANCE` 模式保留日期的情况下延长对象的保留期，并且不能缩短此保留期。
+ 单个 S3 对象锁定保留作业可以支持包含多达 200 亿个对象的清单。
# S3 对象锁定依法保留
可以使用 Amazon S3 批量操作对 Amazon S3 对象执行大规模批量操作。可以使用**对象锁定法定保留**操作来对于对象版本实施法定保留。与设置保留期限相似，依法保留可防止对象版本被覆盖或删除。但是，法定保留没有关联的保留期，在移除之前将一直有效。
您可以将 S3 分批操作与对象锁定一起使用，以便同时添加对很多 Amazon S3 对象的依法保留。为此，请在清单中指定目标对象的列表，并将该列表提交给批量操作。S3 批量操作**对象锁定法定保留**任务将持续运行，直至完成、取消或达到失败状态。
在处理清单中的任何对象之前，S3 批量操作会验证是否已在您的 S3 存储桶上启用对象锁定。要执行对象操作和存储桶级别验证，S3 批量操作需要 AWS Identity and Access Management（IAM）角色中的 `s3:PutObjectLegalHold` 和 `s3:GetBucketObjectLockConfiguration`。这些权限可让 S3 批量操作代表您调用 S3 对象锁定。
当您创建 S3 批量操作任务来移除法定保留时，只需将 `Off` 指定为法定保留状态。有关更多信息，请参阅 [对象锁定注意事项](object-lock-managing.md)。
有关如何将此操作与 Amazon S3 REST API 结合使用的信息，请参阅《Amazon Simple Storage Service API 参考》**的 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateJob.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateJob.html) 操作中的 `S3PutObjectLegalHold`。
有关使用此操作的示例，请参阅[使用适用于 Java 的 AWS 开发工具包](batch-ops-legal-hold-off.md#batch-ops-examples-java-object-lock-legalhold)。
## 限制和局限性
使用批量操作来应用或移除对象锁定法定保留时，以下限制和局限性适用：
+ S3 批量操作不会进行任何存储桶级别的更改。
+ 清单中列出的所有对象都必须位于同一个存储桶中。
+ 必须在执行任务的存储桶上配置版本控制和 S3 对象锁定。
+ 除非在清单中明确指定了版本，否则**对象锁定法定保留**操作将适用于最新版本的对象。
+ IAM 角色需要 `s3:PutObjectLegalHold` 权限，才能在对象中添加或移除法定保留。
+ 需要 `s3:GetBucketObjectLockConfiguration` IAM 权限，才能确认为在其中执行任务的 S3 存储桶启用了 S3 对象锁定。
+ 单个 S3 对象锁定法定保留作业可以支持包含多达 200 亿个对象的清单。
+ [复制对象](batch-ops-copy-object.md)
+ [计算校验和](batch-ops-compute-checksums.md)
+ [删除所有对象标签](batch-ops-delete-object-tagging.md)
+ [调用 AWS Lambda 函数](batch-ops-invoke-lambda.md)
+ [替换所有对象标签](batch-ops-put-object-tagging.md)
+ [替换访问控制列表（ACL）](batch-ops-put-object-acl.md)
+ [使用批量操作还原对象](batch-ops-initiate-restore-object.md)
+ [更新对象加密](batch-ops-update-encryption.md)
+ [使用批量复制以复制现有对象](s3-batch-replication-batch.md)
+ [S3 对象锁定保留](batch-ops-retention-date.md)
+ [S3 对象锁定依法保留](batch-ops-legal-hold.md)
# 管理 S3 分批操作任务
Amazon S3 提供一组功能强大的工具，帮助您在创建 S3 分批操作任务后管理任务。本节介绍了可以通过 Amazon S3 控制台、AWS Command Line Interface（AWS CLI）、AWS SDK 或 Amazon S3 REST API 来管理和跟踪任务的操作。
**Topics**
+ [使用 Amazon S3 控制台管理 S3 分批操作任务](#batch-ops-manage-console)
+ [列出任务](batch-ops-list-jobs.md)
+ [查看任务详细信息](batch-ops-job-details.md)
+ [分配任务优先级](batch-ops-job-priority.md)
## 使用 Amazon S3 控制台管理 S3 分批操作任务
使用控制台，您可以管理 S3 分批操作任务。例如，您可以：
+ 查看活动任务和已排队的任务
+ 检查作业的状态
+ 更改工作的优先级
+ 确认并运行任务
+ 克隆任务
+ 取消任务
**要使用控制台管理分批操作**
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**批量操作**。
1. 选择要管理的作业。
# 列出任务
您可以检索 S3 分批操作任务的列表。此列表提供您尚未完成的作业的相关信息，以及您在过去 90 天内完成的作业的相关信息。对于每个作业，列表提供了其详细信息，例如作业 ID、描述、优先级、当前状态以及成功和失败的任务数。
您可以按状态筛选任务列表。如果您使用控制台检索列表，还可以按描述或 ID 搜索作业并按 AWS 区域对作业进行筛选。
## 获取 `Active` 和 `Complete` 任务的列表
以下 AWS CLI 示例获取 `Active` 和 `Complete` 任务的列表。要使用此示例，请将 *`user input placeholders`* 替换为您自己的信息。
```
aws s3control list-jobs \
--region us-west-2 \
--account-id account-id \
--job-statuses '["Active","Complete"]' \
--max-results 20
```
有关更多信息和示例，请参阅 *AWS CLI 命令参考*中的 [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3control/list-jobs.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3control/list-jobs.html)。
# 查看任务详细信息
如果您需要有关 Amazon S3 批量操作作业的信息比通过列出作业所检索到的信息更多，则可查看单个作业的所有详细信息。您可以查看尚未完成的作业或者过去 90 天内完成的作业的详细信息。除了作业列表中返回的信息之外，单个作业的详细信息还包含其他信息，例如：
+ 操作参数。
+ 有关清单的详细信息。
+ 有关完成报告的信息（如果您在创建作业时配置了完成报告）。
+ 您分配用于运行作业务的 AWS Identity and Access Management（IAM）角色的 Amazon 资源名称（ARN）。
通过查看单个任务的详细信息，可以访问任务的整个配置。要查看任务的详细信息，您可以使用 Amazon S3 控制台或 AWS Command Line Interface（AWS CLI）。
## 在 Amazon S3 控制台中获取 S3 批量操作任务的描述
**使用控制台查看批量操作任务的描述**
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**批量操作**。
1. 选择特定任务的任务 ID，以查看其详细信息。
## 在 AWS CLI 中获取 S3 批量操作任务的描述
以下示例使用 AWS CLI 获取 S3 批量操作任务的描述。要使用以下示例命令，请将 *`user input placeholders`* 替换为您自己的信息。
```
aws s3control describe-job \
--region us-west-2 \
--account-id account-id \
--job-id 00e123a4-c0d8-41f4-a0eb-b46f9ba5b07c
```
有关更多信息和示例，请参阅 *AWS CLI 命令参考*中的 [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3control/describe-job.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3control/describe-job.html)。
# 分配任务优先级
可以为每个 Amazon S3 批量操作任务分配一个数字优先级，该优先级可以是任意正整数。S3 批量操作根据分配的优先级确定任务的优先次序。系统将首先评估具有较高优先级（或者优先级参数的数值较高）的任务。优先级按降序确定。例如，优先级值为 10 的任务队列将会比优先级值为 1 的任务队列优先计划。
可以在任务正在运行时更改其优先级。如果您在任务运行时提交优先级更高的新任务，则优先级较低的任务可以暂停，以允许优先级高的任务运行。
更改任务的优先级不会影响任务的处理速度。
**注意**
S3 批量操作尽最大努力遵循任务优先级。尽管优先级高的任务通常优先于优先级低的任务，但 Amazon S3 无法保证任务的严格顺序。
## 使用 S3 控制台
**如何在 Amazon S3 控制台中更新任务优先级**
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，请选择**分批操作**。
1. 请选择您想要管理的特定任务。
1. 请选择 **Action**（操作）。请在下拉列表中，选择 **Update priority**（更新优先级）。
## 使用 AWS CLI
以下示例使用 AWS CLI 更新任务优先级。数字越大，执行优先级越高。要使用以下示例命令，请将 *`user input placeholders`* 替换为您自己的信息。
```
aws s3control update-job-priority \
--region us-west-2 \
--account-id account-id \
--priority 98 \
--job-id 00e123a4-c0d8-41f4-a0eb-b46f9ba5b07c
```
## 使用 适用于 Java 的 AWS SDK
要使用适用于 Java 的 AWS SDK 更新 S3 批量操作任务的优先级，可以使用 S3Control 客户端来修改该任务的执行优先级，该优先级决定了任务相对于队列中其它任务的处理顺序。
有关任务优先级的更多信息，请参阅 [分配任务优先级](#batch-ops-job-priority)。
有关如何使用适用于 Java 的 AWS SDK 更新任务优先级的示例，请参阅《Amazon S3 API Reference》**中的 [Update the priority of a batch job](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_UpdateJobPriority_section.html)。
# 跟踪任务状态和完成报告
借助 S3 分批操作，您可以查看和更新任务状态、添加通知和日志记录、跟踪任务失败以及生成完成报告。
**Topics**
+ [任务状态](#batch-ops-job-status-table)
+ [更新任务状态](#updating-job-statuses)
+ [通知和日志记录](#batch-ops-notifications)
+ [跟踪任务失败](#batch-ops-job-status-failure)
+ [完成报告](#batch-ops-completion-report)
+ [示例：通过 AWS CloudTrail 在 Amazon EventBridge 中跟踪 S3 分批操作任务。](batch-ops-examples-event-bridge-cloud-trail.md)
+ [示例：S3 分批操作完成报告](batch-ops-examples-reports.md)
## 任务状态
在您创建和运行任务之后，该任务会逐步经过一系列状态。下表描述了状态以及状态之间可能的转换。
| Status | 说明 | 转换 |
| --- | --- | --- |
| `New` | 在您创建任务时，任务首先处于 `New` 状态。 | Amazon S3 开始处理清单对象时，任务自动转入 `Preparing` 状态。 |
| `Preparing` | Amazon S3 正在处理清单对象及其他任务参数，以设置和运行任务。 | Amazon S3 完成清单和其他参数的处理之后，任务自动转入 `Ready` 状态。然后，任务随时可以在清单中列出的对象上开始运行指定的操作。如果任务要求在运行之前确认，就像您在使用 Amazon S3 控制台创建任务时那样，则任务从 `Preparing` 转换为 `Suspended`。在您确认希望运行之前，任务将保持在 `Suspended` 状态。 |
| `Suspended` | 任务需要确认，但您尚未确认您想要运行该任务。只有使用 Amazon S3 控制台创建的任务需要确认。使用控制台创建的任务在 `Preparing` 之后立即进入 `Suspended` 状态。在您确认希望运行任务并且任务成为 `Ready` 状态之后，它不会再返回 `Suspended` 状态。 | 在您确认希望运行任务之后，其状态将更改为 `Ready`。 |
| `Ready` | Amazon S3 已准备好开始运行请求的对象操作。 | Amazon S3 开始运行任务时，任务自动转入 `Active` 状态。任务保持在 `Ready` 状态的时间长度取决于您是否已经在运行具有较高优先级的任务，以及完成这些任务需要多长时间。 |
| `Active` | Amazon S3 正在对清单中列出的对象执行请求的操作。当任务处于 `Active` 状态时，您可使用 Amazon S3 控制台，或者通过 REST API、AWS CLI 或 AWS 开发工具包使用 `DescribeJob` 操作监控其进度。 | 当任务不再在对象上运行操作时，该任务就移出 `Active` 状态。此行为自动发生，例如在任务成功完成或失败时。或者，此行为也可作为用户操作的结果发生，例如取消某个任务。任务转入的状态取决于发生转换的原因。 |
| `Pausing` | 任务从其他状态转换为 `Paused`。 | `Paused` 阶段完成时，任务自动转入 `Pausing` 状态。 |
| `Paused` | 在当前任务正在运行时，如果您提交了具有更高优先级的其他任务，任务可以进入 `Paused` 状态。 | 对于处于 `Paused` 状态的任务，如果阻止了该任务的任何较高优先级的任务执行完成、失败或暂停，则该任务自动返回 `Active` 状态。 |
| `Completing` | 任务从其他状态转换为 `Complete`。 | `Complete` 阶段完成时，任务自动转入 `Completing` 状态。 |
| `Complete` | 任务已完成对清单中所有对象执行请求的操作。对于每个对象，操作可能成功或失败。如果您配置任务生成完成报告，则在任务处于 `Complete` 状态之后报告立即可用。 | `Complete` 是最终状态。任务一旦进入 `Complete` 状态，就不会转换为任何其它状态。 |
| `Cancelling` | 任务转换为 `Cancelled` 状态。 | `Cancelled` 阶段完成时，任务自动转入 `Cancelling` 状态。 |
| `Cancelled` | 您请求取消任务，而 S3 批量操作已成功取消了任务。任务将不会向 Amazon S3 提交任何新请求。 | `Cancelled` 是最终状态。任务进入 `Cancelled` 状态之后，就不会转换为任何其它状态。 |
| `Failing` | 任务转换为 `Failed` 状态。 | `Failed` 阶段完成后，任务自动转入 `Failing` 状态。 |
| `Failed` | 任务已失败，不再运行。有关任务失败的更多信息，请参阅 [跟踪任务失败](#batch-ops-job-status-failure)。 | `Failed` 是最终状态。任务进入 `Failed` 状态之后，就不会转换为任何其它状态。 |
## 更新任务状态
以下 AWS CLI 和适用于 Java 的 AWS SDK 示例更新批量操作任务的状态。有关使用 Amazon S3 控制台管理批量操作任务的更多信息，请参阅[使用 Amazon S3 控制台管理 S3 分批操作任务](batch-ops-managing-jobs.md#batch-ops-manage-console)。
### 使用 AWS CLI
要使用以下示例命令，请将 *`user input placeholders`* 替换为您自己的信息。
+ 如果未在 `create-job` 命令中指定 `--no-confirmation-required` 参数，则任务将保持为暂停状态，直至通过将其状态设置为 `Ready` 来确认任务。然后，Amazon S3 会使任务符合执行的条件。
```
aws s3control update-job-status \
--region us-west-2 \
--account-id 123456789012 \
--job-id 00e123a4-c0d8-41f4-a0eb-b46f9ba5b07c \
--requested-job-status 'Ready'
```
+ 通过将任务状态设置为 `Cancelled` 来取消任务。
```
aws s3control update-job-status \
--region us-west-2 \
--account-id 123456789012 \
--job-id 00e123a4-c0d8-41f4-a0eb-b46f9ba5b07c \
--status-update-reason "No longer needed" \
--requested-job-status Cancelled
```
### 使用适用于 Java 的 AWS 开发工具包
有关如何使用适用于 Java 的 AWS SDK 更新任务状态的示例，请参阅《Amazon S3 API Reference》**中的 [Update the status of a batch job](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_UpdateJobStatus_section.html)。
## 通知和日志记录
除了请求完成报告外，还可以使用 AWS CloudTrail 捕获、查看和审计批量操作活动。由于批量操作使用现有的 Amazon S3 API 操作来执行任务，因此，这些任务还会发出与您直接调用这些操作时相同的事件。因此，可以使用相同的通知、日志记录和审计工具以及已用于 Amazon S3 的过程，来跟踪和记录任务及其所有工作的进度。有关更多信息，请参阅以下部分中的示例。
**注意**
批量操作会在任务执行期间在 CloudTrail 中同时生成管理事件和数据事件。这些事件的数量随每个任务的清单中的键数量而扩展。有关更多信息，请参阅 [CloudTrail 定价](https://aws.amazon.com/cloudtrail/pricing/)页面，其中包括定价如何根据您在账户中配置的跟踪数量而变化的示例。要了解如何配置和记录事件以满足您的需求，请参阅《*AWS CloudTrail 用户指南*》中的[创建您的第一个跟踪](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-tutorial.html#tutorial-step2)。
有关 Amazon S3 事件的更多信息，请参阅 [Amazon S3 事件通知](EventNotifications.md)。
## 跟踪任务失败
如果 S3 分批操作任务遇到的问题使其无法成功运行（如无法读取指定清单），则该任务失败。任务失败时，系统会生成一个或多个故障代码或失败原因。S3 批量操作将故障代码和原因与任务一起存储，便于您通过请求任务的详细信息来查看它们。如果您请求任务的完成报告，同时还会显示故障代码和原因。
为防止任务运行大量不成功的操作，Amazon S3 会对每个分批操作任务施加任务失败阈值。当任务已运行至少 1000 项工作时，Amazon S3 将监控工作失败率。在任何时刻，如果失败率（失败的任务数占已运行任务总数的比例）超过 50%，则任务失败。如果任务由于超过了任务失败阈值而失败，您可以确定造成失败的原因。例如，您可能在清单中意外地包括了一些指定存储桶中不存在的对象。修复错误之后，您可以重新提交任务。
**注意**
S3 批量操作异步进行操作，而工作并不一定按照清单中列出对象的顺序来运行。因此您不能使用清单顺序来确定哪些对象的任务成功，哪些对象的任务失败。而是可以通过查看任务的完成报告（如果已请求）或查看 AWS CloudTrail 事件日志来帮助确定失败原因。
## 完成报告
在创建任务时，您可以请求完成报告。只要 S3 批量操作成功调用至少一项工作，Amazon S3 便会在任务完成运行工作、失败或被取消后生成完成报告。可对完成报告进行配置，以包含所有任务或只包含失败的任务。
完成报告包含任务配置、状态以及每项工作的信息，包括对象键和版本、状态、错误代码以及有关任何错误的描述。完成报告提供了以合并格式查看任务结果的简单途径，且无需进行任何附加设置。完成报告使用具有 Amazon S3 托管式密钥的服务器端加密（SSE-S3）来进行加密。有关完成报告的示例，请参阅 [示例：S3 分批操作完成报告](batch-ops-examples-reports.md)。
如果您未配置完成报告，则仍可使用 CloudTrail 和 Amazon CloudWatch 监控并审计您的任务及其各项工作。有关更多信息，请参阅以下主题：
**Topics**
+ [任务状态](#batch-ops-job-status-table)
+ [更新任务状态](#updating-job-statuses)
+ [通知和日志记录](#batch-ops-notifications)
+ [跟踪任务失败](#batch-ops-job-status-failure)
+ [完成报告](#batch-ops-completion-report)
+ [示例：通过 AWS CloudTrail 在 Amazon EventBridge 中跟踪 S3 分批操作任务。](batch-ops-examples-event-bridge-cloud-trail.md)
+ [示例：S3 分批操作完成报告](batch-ops-examples-reports.md)
# 示例：通过 AWS CloudTrail 在 Amazon EventBridge 中跟踪 S3 分批操作任务。
Amazon S3 分批操作任务活动在 AWS CloudTrail 中记录为事件。您可以在 Amazon EventBridge 中创建自定义规则，然后将这些事件发送到您选择的目标通知资源，例如 Amazon Simple Notification Service (Amazon SNS)。
**注意**
Amazon EventBridge 是管理事件的首选方式。Amazon CloudWatch Events 和 EventBridge 是相同的底层服务和 API，但 EventBridge 提供了更多功能。您在 CloudWatch 或 EventBridge 中所作的更改将显示在每个控制台中。有关更多信息，请参阅 *[Amazon EventBridge 用户指南](https://docs.aws.amazon.com/eventbridge/latest/userguide/)*。
**Topics**
+ [在 CloudTrail 中记录的 S3 分批操作事件](#batch-ops-examples-cloud-trail-events)
+ [用于跟踪 S3 分批操作任务事件的 EventBridge 规则](#batch-ops-examples-event-bridge)
## 在 CloudTrail 中记录的 S3 分批操作事件
创建分批操作任务后，它将作为 `JobCreated` 事件记录在 CloudTrail 中。在任务运行时，它会在处理过程中更改状态，并且其他 `JobStatusChanged` 事件将记录到 CloudTrail 中。您可以在 [CloudTrail 控制台](https://console.aws.amazon.com/cloudtrail)中查看这些事件。有关 CloudTrail 的更多信息，请参阅《[https://docs.aws.amazon.com/awscloudtrail/latest/userguide/how-cloudtrail-works.html](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/how-cloudtrail-works.html)》。
**注意**
CloudTrail 中只记录 S3 分批操作任务 `status-change` 事件。
**Example — CloudTrail 记录的 S3 批处理操作作业完成事件**
```
{
"eventVersion": "1.05",
"userIdentity": {
"accountId": "123456789012",
"invokedBy": "s3.amazonaws.com"
},
"eventTime": "2020-02-05T18:25:30Z",
"eventSource": "s3.amazonaws.com",
"eventName": "JobStatusChanged",
"awsRegion": "us-west-2",
"sourceIPAddress": "s3.amazonaws.com",
"userAgent": "s3.amazonaws.com",
"requestParameters": null,
"responseElements": null,
"eventID": "f907577b-bf3d-4c53-b9ed-8a83a118a554",
"readOnly": false,
"eventType": "AwsServiceEvent",
"recipientAccountId": "123412341234",
"serviceEventDetails": {
"jobId": "d6e58ec4-897a-4b6d-975f-10d7f0fb63ce",
"jobArn": "arn:aws:s3:us-west-2:181572960644:job/d6e58ec4-897a-4b6d-975f-10d7f0fb63ce",
"status": "Complete",
"jobEventId": "b268784cf0a66749f1a05bce259804f5",
"failureCodes": [],
"statusChangeReason": []
}
}
```
## 用于跟踪 S3 分批操作任务事件的 EventBridge 规则
以下示例说明如何在 Amazon EventBridge 中创建规则，以便将 AWS CloudTrail 记录的 S3 分批操作事件捕获到您选择的目标。
为此，您可以按照[创建用于响应事件的 EventBridge 规则](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule.html)中的所有步骤来创建规则。粘贴以下 S3 分批操作自定义事件模式策略（如果适用），然后选择所需的目标服务。
**S3 分批操作自定义事件模式策略**
```
{
"source": [
"aws.s3"
],
"detail-type": [
"AWS Service Event via CloudTrail"
],
"detail": {
"eventSource": [
"s3.amazonaws.com"
],
"eventName": [
"JobCreated",
"JobStatusChanged"
]
}
}
```
以下示例是从 EventBridge 事件规则发送到 Amazon Simple Queue Service (Amazon SQS) 的两个分批操作事件。由于分批操作任务在处理期间会经历多种不同的状态（`New`、`Preparing`、`Active` 等），因此对于每个任务，您都将收到多条消息。
**Example — JobCreated 示例事件**
```
{
"version": "0",
"id": "51dc8145-541c-5518-2349-56d7dffdf2d8",
"detail-type": "AWS Service Event via CloudTrail",
"source": "aws.s3",
"account": "123456789012",
"time": "2020-02-27T15:25:49Z",
"region": "us-east-1",
"resources": [],
"detail": {
"eventVersion": "1.05",
"userIdentity": {
"accountId": "11112223334444",
"invokedBy": "s3.amazonaws.com"
},
"eventTime": "2020-02-27T15:25:49Z",
"eventSource": "s3.amazonaws.com",
"eventName": "JobCreated",
"awsRegion": "us-east-1",
"sourceIPAddress": "s3.amazonaws.com",
"userAgent": "s3.amazonaws.com",
"eventID": "7c38220f-f80b-4239-8b78-2ed867b7d3fa",
"readOnly": false,
"eventType": "AwsServiceEvent",
"serviceEventDetails": {
"jobId": "e849b567-5232-44be-9a0c-40988f14e80c",
"jobArn": "arn:aws:s3:us-east-1:181572960644:job/e849b567-5232-44be-9a0c-40988f14e80c",
"status": "New",
"jobEventId": "f177ff24f1f097b69768e327038f30ac",
"failureCodes": [],
"statusChangeReason": []
}
}
}
```
**Example — JobStatusChanged 任务完成事件**
```
{
"version": "0",
"id": "c8791abf-2af8-c754-0435-fd869ce25233",
"detail-type": "AWS Service Event via CloudTrail",
"source": "aws.s3",
"account": "123456789012",
"time": "2020-02-27T15:26:42Z",
"region": "us-east-1",
"resources": [],
"detail": {
"eventVersion": "1.05",
"userIdentity": {
"accountId": "1111222233334444",
"invokedBy": "s3.amazonaws.com"
},
"eventTime": "2020-02-27T15:26:42Z",
"eventSource": "s3.amazonaws.com",
"eventName": "JobStatusChanged",
"awsRegion": "us-east-1",
"sourceIPAddress": "s3.amazonaws.com",
"userAgent": "s3.amazonaws.com",
"eventID": "0238c1f7-c2b0-440b-8dbd-1ed5e5833afb",
"readOnly": false,
"eventType": "AwsServiceEvent",
"serviceEventDetails": {
"jobId": "e849b567-5232-44be-9a0c-40988f14e80c",
"jobArn": "arn:aws:s3:us-east-1:181572960644:job/e849b567-5232-44be-9a0c-40988f14e80c",
"status": "Complete",
"jobEventId": "51f5ac17dba408301d56cd1b2c8d1e9e",
"failureCodes": [],
"statusChangeReason": []
}
}
}
```
# 示例：S3 分批操作完成报告
当您创建 S3 分批操作任务时，可以为全部任务或仅失败任务请求完成报告。只要成功调用了至少一个任务，S3 分批操作即会为已完成、已失败或已取消的任务生成报告。
完成报告包含每个任务的其他信息，包括对象键名称和版本、版本、错误代码以及任何错误的描述。每个失败任务的错误的描述可用于诊断在任务创建期间发生的问题，如权限。对于**计算校验和**任务，完成报告包含每个对象的校验和值。
**注意**
完成报告始终使用 Amazon S3 托管式密钥（SSE-S3）进行加密。
**Example — 顶级清单结果文件**
顶级 `manifest.json` 文件包含每个成功报告的位置以及（如果任务有任何失败）失败报告的位置，如以下示例所示。
```
{
"Format": "Report_CSV_20180820",
"ReportCreationDate": "2019-04-05T17:48:39.725Z",
"Results": [
{
"TaskExecutionStatus": "succeeded",
"Bucket": "my-job-reports",
"MD5Checksum": "83b1c4cbe93fc893f54053697e10fd6e",
"Key": "job-f8fb9d89-a3aa-461d-bddc-ea6a1b131955/results/6217b0fab0de85c408b4be96aeaca9b195a7daa5.csv"
},
{
"TaskExecutionStatus": "failed",
"Bucket": "my-job-reports",
"MD5Checksum": "22ee037f3515975f7719699e5c416eaa",
"Key": "job-f8fb9d89-a3aa-461d-bddc-ea6a1b131955/results/b2ddad417e94331e9f37b44f1faf8c7ed5873f2e.csv"
}
],
"ReportSchema": "Bucket, Key, VersionId, TaskStatus, ErrorCode, HTTPStatusCode, ResultMessage"
}
```
**成功的任务报告**
成功任务报告包含*成功* 任务的以下各项内容：
+ `Bucket`
+ `Key`
+ `VersionId`
+ `TaskStatus`
+ `ErrorCode`
+ `HTTPStatusCode`
+ `ResultMessage`
**失败的任务报告**
失败的任务报告包含所有*失败*任务的以下信息：
+ `Bucket`
+ `Key`
+ `VersionId`
+ `TaskStatus`
+ `ErrorCode`
+ `HTTPStatusCode`
+ `ResultMessage`
**Example — Lambda 函数任务报告**
在以下示例中，Lambda 函数将 Amazon S3 对象成功复制到其他存储桶。返回的 Amazon S3 响应会传回到 S3 分批操作，然后写入最终完成报告。
```
amzn-s3-demo-bucket1,image_17775,,succeeded,200,,"{u'CopySourceVersionId': 'xVR78haVKlRnurYofbTfYr3ufYbktF8h', u'CopyObjectResult': {u'LastModified': datetime.datetime(2019, 4, 5, 17, 35, 39, tzinfo=tzlocal()), u'ETag': '""fe66f4390c50f29798f040d7aae72784""'}, 'ResponseMetadata': {'HTTPStatusCode': 200, 'RetryAttempts': 0, 'HostId': 'nXNaClIMxEJzWNmeMNQV2KpjbaCJLn0OGoXWZpuVOFS/iQYWxb3QtTvzX9SVfx2lA3oTKLwImKw=', 'RequestId': '3ED5852152014362', 'HTTPHeaders': {'content-length': '234', 'x-amz-id-2': 'nXNaClIMxEJzWNmeMNQV2KpjbaCJLn0OGoXWZpuVOFS/iQYWxb3QtTvzX9SVfx2lA3oTKLwImKw=', 'x-amz-copy-source-version-id': 'xVR78haVKlRnurYofbTfYr3ufYbktF8h', 'server': 'AmazonS3', 'x-amz-request-id': '3ED5852152014362', 'date': 'Fri, 05 Apr 2019 17:35:39 GMT', 'content-type': 'application/xml'}}}"
amzn-s3-demo-bucket1,image_17763,,succeeded,200,,"{u'CopySourceVersionId': '6HjOUSim4Wj6BTcbxToXW44pSZ.40pwq', u'CopyObjectResult': {u'LastModified': datetime.datetime(2019, 4, 5, 17, 35, 39, tzinfo=tzlocal()), u'ETag': '""fe66f4390c50f29798f040d7aae72784""'}, 'ResponseMetadata': {'HTTPStatusCode': 200, 'RetryAttempts': 0, 'HostId': 'GiCZNYr8LHd/Thyk6beTRP96IGZk2sYxujLe13TuuLpq6U2RD3we0YoluuIdm1PRvkMwnEW1aFc=', 'RequestId': '1BC9F5B1B95D7000', 'HTTPHeaders': {'content-length': '234', 'x-amz-id-2': 'GiCZNYr8LHd/Thyk6beTRP96IGZk2sYxujLe13TuuLpq6U2RD3we0YoluuIdm1PRvkMwnEW1aFc=', 'x-amz-copy-source-version-id': '6HjOUSim4Wj6BTcbxToXW44pSZ.40pwq', 'server': 'AmazonS3', 'x-amz-request-id': '1BC9F5B1B95D7000', 'date': 'Fri, 05 Apr 2019 17:35:39 GMT', 'content-type': 'application/xml'}}}"
amzn-s3-demo-bucket1,image_17860,,succeeded,200,,"{u'CopySourceVersionId': 'm.MDD0g_QsUnYZ8TBzVFrp.TmjN8PJyX', u'CopyObjectResult': {u'LastModified': datetime.datetime(2019, 4, 5, 17, 35, 40, tzinfo=tzlocal()), u'ETag': '""fe66f4390c50f29798f040d7aae72784""'}, 'ResponseMetadata': {'HTTPStatusCode': 200, 'RetryAttempts': 0, 'HostId': 'F9ooZOgpE5g9sNgBZxjdiPHqB4+0DNWgj3qbsir+sKai4fv7rQEcF2fBN1VeeFc2WH45a9ygb2g=', 'RequestId': '8D9CA56A56813DF3', 'HTTPHeaders': {'content-length': '234', 'x-amz-id-2': 'F9ooZOgpE5g9sNgBZxjdiPHqB4+0DNWgj3qbsir+sKai4fv7rQEcF2fBN1VeeFc2WH45a9ygb2g=', 'x-amz-copy-source-version-id': 'm.MDD0g_QsUnYZ8TBzVFrp.TmjN8PJyX', 'server': 'AmazonS3', 'x-amz-request-id': '8D9CA56A56813DF3', 'date': 'Fri, 05 Apr 2019 17:35:40 GMT', 'content-type': 'application/xml'}}}"
```
以下示例报告显示 AWS Lambda 函数超时，从而导致失败以超出失败阈值的情况。然后，它会标记为 `PermanentFailure`。
```
amzn-s3-demo-bucket1,image_14975,,failed,200,PermanentFailure,"Lambda returned function error: {""errorMessage"":""2019-04-05T17:35:21.155Z 2845ca0d-38d9-4c4b-abcf-379dc749c452 Task timed out after 3.00 seconds""}"
amzn-s3-demo-bucket1,image_15897,,failed,200,PermanentFailure,"Lambda returned function error: {""errorMessage"":""2019-04-05T17:35:29.610Z 2d0a330b-de9b-425f-b511-29232fde5fe4 Task timed out after 3.00 seconds""}"
amzn-s3-demo-bucket1,image_14819,,failed,200,PermanentFailure,"Lambda returned function error: {""errorMessage"":""2019-04-05T17:35:22.362Z fcf5efde-74d4-4e6d-b37a-c7f18827f551 Task timed out after 3.00 seconds""}"
amzn-s3-demo-bucket1,image_15930,,failed,200,PermanentFailure,"Lambda returned function error: {""errorMessage"":""2019-04-05T17:35:29.809Z 3dd5b57c-4a4a-48aa-8a35-cbf027b7957e Task timed out after 3.00 seconds""}"
amzn-s3-demo-bucket1,image_17644,,failed,200,PermanentFailure,"Lambda returned function error: {""errorMessage"":""2019-04-05T17:35:46.025Z 10a764e4-2b26-4d8c-9056-1e1072b4723f Task timed out after 3.00 seconds""}"
amzn-s3-demo-bucket1,image_17398,,failed,200,PermanentFailure,"Lambda returned function error: {""errorMessage"":""2019-04-05T17:35:44.661Z 1e306352-4c54-4eba-aee8-4d02f8c0235c Task timed out after 3.00 seconds""}"
```
**Example — 计算校验和任务报告**
在以下示例中，**计算校验和**操作成功计算了上传的静态对象的校验和。返回的 Amazon S3 响应会传回到 S3 批量操作，然后写入最终完成报告：
```
amzn-s3-demo-bucket1,s3-standard-1mb-test-object,,succeeded,200,,"{""checksum_base64"":""bS9TOQ\u003d\u003d"",""etag"":""3c3c1813042989094598e4b57ecbdc82"",""checksumAlgorithm"":""CRC32"",""checksumType"":""FULL_OBJECT"",""checksum_hex"":""6D2F5339""}"
```
以下示例报告显示了当**计算校验和**操作失败并导致任务报告失败时会发生什么：
```
amzn-s3-demo-bucket1,image_14975,,failed,200,PermanentFailure,"error details: {""failureMessage"":"Task 2845ca0d-38d9-4c4b-abcf-379dc749c452 SSE-C encryption type is not supported for this operation", ""errorCode"": "400"}"
amzn-s3-demo-bucket1,image_14975,,failed,200,PermanentFailure,"error details: {""failureMessage"":"Task 2845ca0d-38d9-4c4b-abcf-379dc749c452 Key not found", ""errorCode"": "404"}"
amzn-s3-demo-bucket1,image_14975,,failed,200,PermanentFailure,"error details: {""failureMessage"":"Task 2845ca0d-38d9-4c4b-abcf-379dc749c452 Internal server error, please retry", ""errorCode"": "500"}"
```
# 使用标签控制访问和标记任务
您可以通过添加*标签*来标记和控制对 S3 分批操作任务的访问。标签可用于确定谁负责分批操作任务。任务标签的存在可授予或限制用户取消任务、激活处于确认状态的任务或更改任务优先级的能力。可以创建附加了标签的任务，并且可以在创建任务后向任务添加标签。每个标签都是一个键值对，可以在创建任务或稍后更新时包含该键值对。
**警告**
确保任务标签中不包含任何机密信息或个人数据。
考虑以下标记示例：假设您希望您的财务部门创建一个分批操作任务。您可以编写允许用户调用 `CreateJob` 的 AWS Identity and Access Management (IAM) 策略，前提是创建任务时使用分配了 `Finance` 值的 `Department` 标签。此外，您可以将该策略附加到作为财务部门成员的所有用户。
继续使用此示例，您可以编写一个策略，允许用户更新具有所需标签的任何任务的优先级，或者取消具有这些标签的任何任务。有关更多信息，请参阅 [使用任务标签控制批量操作的权限](batch-ops-job-tags-examples.md)。
您可以在创建新的 S3 分批操作任务时向其添加标签，也可以将向现有任务添加标签。
注意以下标签限制：
+ 只要任务具有唯一的标签键，就可以将最多 50 个标签与该任务关联。
+ 标签键的长度最大可以为 128 个 Unicode 字符，标签值的长度最大可以为 256 个 Unicode 字符。
+ 键和值区分大小写。
有关标签限制的更多信息，请参阅《*AWS 账单与成本管理 用户指南*》中的[用户定义的标签限制](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/allocation-tag-restrictions.html)。
## 与 S3 分批操作任务标记相关的 API 操作
Amazon S3 支持以下特定于 S3 分批操作任务标记的 API 操作：
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_GetJobTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_GetJobTagging.html) – 返回与批量操作任务关联的标签集。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_PutJobTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_PutJobTagging.html) – 替换与任务关联的标签集。使用此 API 操作进行 S3 分批操作任务标签管理有两种不同的方案：
+ 任务没有标签 – 可以向任务添加一组标签（任务之前没有标签）。
+ 任务具有一组现有标签 – 要修改现有标签集，您可以完全替换现有标签集，或者通过使用 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_GetJobTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_GetJobTagging.html) 检索现有标签集来在现有标签集中进行更改，修改该标签集，然后使用此 API 操作来将此标签集替换为您已修改的标签集。
**注意**
如果您发送带有空标签集的此请求，S3 分批操作将删除对象上的现有标签集。如果您使用此方法，则需为套餐 1 请求 (`PUT`) 付费。有关更多信息，请参阅 [Amazon S3 定价](https://aws.amazon.com/s3/pricing)。
要删除分批操作任务的现有标签，首选执行 `DeleteJobTagging` 操作，因为该操作在不产生费用的情况下实现相同的结果。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DeleteJobTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DeleteJobTagging.html) – 删除与批量操作任务关联的标签集。
# 使用用于标记的任务标签创建分批操作任务
可以通过添加*标签* 来标注 Amazon S3 批量操作任务和控制对任务的访问。标签可用于确定谁负责分批操作任务。您可以创建附加了标签的任务，并且可以在创建任务后向任务添加标签。有关更多信息，请参阅 [使用标签控制访问和标记任务](batch-ops-job-tags.md)。
## 使用 AWS CLI
以下 AWS CLI 示例创建了 S3 分批操作 `S3PutObjectCopy` 任务，其中使用任务标签作为该任务的标签。
1. 请选择您希望分批操作任务执行的操作或 `OPERATION`，然后选择您的 `TargetResource`。
```
read -d '' OPERATION <
要使用适用于 Java 的 AWS SDK 创建带有标签的 S3 批量操作任务，可以使用 S3Control 客户端来配置任务参数，包括清单位置、任务操作、报告设置以及用于组织和跟踪目的的标签。
有关如何使用适用于 Java 的 AWS SDK 创建带有标签的 S3 批量操作任务的示例，请参阅《Amazon S3 API Reference》**中的 [Create a batch job to copy objects](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_CreateJob_section.html)。
# 从 S3 分批操作任务中删除标签
可以使用这些示例从 Amazon S3 批量操作任务中删除标签。
## 使用 AWS CLI
以下示例使用 AWS CLI 从分批操作任务中删除标签。
```
aws \
s3control delete-job-tagging \
--account-id 123456789012 \
--job-id Example-e25a-4ed2-8bee-7f8ed7fc2f1c \
--region us-east-1
```
## 删除分批操作任务的任务标签
要使用适用于 Java 的 AWS SDK 删除 S3 批量操作任务的标签，可以使用 S3Control 客户端以及任务 ID 来移除与批量操作任务关联的所有标签。
有关如何使用适用于 Java 的 AWS SDK 删除任务标签的示例，请参阅《Amazon S3 API Reference》**中的 [Delete tags from a batch job](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_DeleteJobTagging_section.html)。
# 向现有批量操作任务添加任务标签
可以使用 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_PutJobTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_PutJobTagging.html) API 操作向现有 Amazon S3 批量操作任务添加任务标签。有关更多信息，请参阅以下示例。
## 使用 AWS CLI
以下是使用 AWS CLI 通过 `s3control put-job-tagging` 向 S3 批量操作任务添加任务标签的示例。要使用这些示例，请将 *`user input placeholders`* 替换为您自己的信息。
**注意**
如果您发送带有空标签集的此请求，批量操作将删除对象上的现有标签集。但是，如果您使用此方法，则需为套餐 1 请求 (`PUT`) 付费。有关更多信息，请参阅 [Amazon S3 定价](https://aws.amazon.com/s3/pricing)。
相反，要删除批量操作任务的现有标签，建议使用 `DeleteJobTagging` 操作，因为该操作可在不产生费用的情况下实现相同的结果。
1. 确定您需要用于此任务的任务 `TAGS`。在这种情况下，您应用两个标签 `department` 和 `FiscalYear`，值分别为 `Marketing` 和 `2020`。
```
read -d '' TAGS <
要使用适用于 Java 的 AWS SDK 在 S3 批量操作任务上放置标签，可以使用 S3Control 客户端来添加或更新带有键值对的标签，以用于整理和跟踪目的。
有关如何使用适用于 Java 的 AWS SDK 放置任务标签的示例，请参阅《Amazon S3 API Reference》**中的 [Add tags to a batch job](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_PutJobTagging_section.html)。
# 获取 S3 分批操作任务的标签
要检索 Amazon S3 批量操作任务的标签，可以使用 `GetJobTagging` API 操作。有关更多信息，请参阅以下示例。
## 使用 AWS CLI
以下示例使用 AWS CLI 获取分批操作任务的标签。要使用此示例，请将 *`user input placeholders`* 替换为您自己的信息。
```
aws \
s3control get-job-tagging \
--account-id 123456789012 \
--job-id Example-e25a-4ed2-8bee-7f8ed7fc2f1c \
--region us-east-1
```
## 使用适用于 Java 的 AWS SDK
要使用适用于 Java 的 AWS SDK 获取 S3 批量操作任务的标签，可以使用 S3Control 客户端以及任务 ID 来检索与批量操作任务关联的所有标签，并将其作为列表返回。
有关如何使用适用于 Java 的 AWS SDK 获取任务标签的示例，请参阅《Amazon S3 API Reference》**中的 [Get tags from a batch job](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_GetJobTagging_section.html)。
# 使用任务标签控制批量操作的权限
为了协助您管理 Amazon S3 批量操作任务，可以添加*任务标签*。借助任务标签，您可以控制对 S3 分批操作任务的访问，并强制在创建任何任务时应用标签。
您最多可以为每个分批操作任务应用 50 个任务标签。通过使用标签，可以设置精细的策略，来限制可以编辑任务的用户集。任务标签可授予或限制用户取消任务、激活处于确认状态的任务或更改任务优先级的能力。此外，您可以强制将标签应用于所有新任务，并为标签指定允许的键值对。可以使用 [AWS Identity and Access Management（IAM）策略语言](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_iam-tags.html)来表达所有这些条件。有关更多信息，请参阅《Service Authorization Reference》**中的 [Actions, resources, and condition keys for Amazon S3](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazons3.html)。
有关按 S3 资源类型对 S3 API 操作的权限的更多信息，请参阅 [Amazon S3 API 操作所需的权限](using-with-s3-policy-actions.md)。
以下示例显示如何使用 S3 分批操作任务标签仅向用户授予创建和编辑在特定部门（例如，财务或合规性部门）内运行的任务的权限。您还可以根据与任务相关的开发阶段分配任务，例如 QA 或生产。
在此示例中，您在 IAM 策略中使用 S3 批量操作任务标签，来向用户授予创建和编辑只能在其部门内运行的任务的权限。您可以根据与任务相关的开发阶段分配任务，例如 QA 或生产。
下面的示例使用以下部门，每个部门使用批量操作的方式均不同：
+ 财务
+ 合规性
+ 商业智能
+ 工程
**Topics**
+ [通过向用户和资源分配标签来控制访问](#job-tags-examples-attaching-tags)
+ [按阶段标记分批操作任务并对任务优先级实施限制](#tagging-jobs-by-stage-and-enforcing-limits-on-job-priority)
## 通过向用户和资源分配标签来控制访问
在这种情况下，管理员正在使用[基于属性的访问控制 (ABAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html)。ABAC 是一种 IAM 授权策略，它通过向用户和 AWS 资源附加标签来定义权限。
为用户和任务分配以下部门标签之一：
**键 : 值**
+ `department : Finance`
+ `department : Compliance`
+ `department : BusinessIntelligence`
+ `department : Engineering`
**注意**
任务标签键和值区分大小写。
使用 ABAC 访问控制策略，您可以授予“财务”部门中的用户在其部门内创建和管理 S3 批量操作任务的权限，方法是将标签 `department=Finance` 与其用户关联。
此外，您可以将托管策略附加到 IAM 用户，此策略允许公司中的任何用户在其各自部门内创建或修改 S3 分批操作任务。
此示例中的策略包括三个策略语句：
+ 策略中的第一个语句允许用户创建分批操作任务，前提是任务创建请求包含与其各自部门匹配的任务标签。这使用 `"${aws:PrincipalTag/department}"` 语法表示，该语法在策略评估时被用户的部门标签所取代。当在请求 `("aws:RequestTag/department")` 中为部门标签提供的值与用户的部门匹配时，该条件将得到满足。
+ 策略中的第二个语句允许用户更改任务的优先级或更新任务的状态，前提是用户正在更新的任务与用户的部门匹配。
+ 第三个语句允许用户随时通过 `PutJobTagging` 请求更新分批操作任务的标签，只要 (1) 其部门标签被保留，并且 (2) 他们正在更新的任务位于其部门内。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:CreateJob",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:RequestTag/department": "${aws:PrincipalTag/department}"
}
}
},
{
"Effect": "Allow",
"Action": [
"s3:UpdateJobPriority",
"s3:UpdateJobStatus"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/department": "${aws:PrincipalTag/department}"
}
}
},
{
"Effect": "Allow",
"Action": "s3:PutJobTagging",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:RequestTag/department": "${aws:PrincipalTag/department}",
"aws:ResourceTag/department": "${aws:PrincipalTag/department}"
}
}
}
]
}
```
------
## 按阶段标记分批操作任务并对任务优先级实施限制
所有 S3 分批操作任务都具有数字优先级，Amazon S3 使用此优先级来决定以何种顺序运行任务。对于此示例，您可以限制大多数用户可以分配给任务的最大优先级，并为有限的特权用户集保留更高的优先级范围，如下所示：
+ QA 阶段优先级范围（低）：1-100
+ 生产阶段优先级范围（高）：1-300
为此，请引入一个代表任务阶段 的新标签集：
**键 : 值**
+ `stage : QA`
+ `stage : Production`
### 在部门内创建和更新低优先级任务
除了基于部门的限制外，此策略还对 S3 分批操作任务创建和更新引入了两个新的限制：
+ 它允许用户在其部门中创建或更新任务，而一个新条件要求任务包含标签 `stage=QA`。
+ 它允许用户创建或更新任务的优先级，新的最大优先级为 100。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:CreateJob",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:RequestTag/department": "${aws:PrincipalTag/department}",
"aws:RequestTag/stage": "QA"
},
"NumericLessThanEquals": {
"s3:RequestJobPriority": 100
}
}
},
{
"Effect": "Allow",
"Action": [
"s3:UpdateJobStatus"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/department": "${aws:PrincipalTag/department}"
}
}
},
{
"Effect": "Allow",
"Action": "s3:UpdateJobPriority",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/department": "${aws:PrincipalTag/department}",
"aws:ResourceTag/stage": "QA"
},
"NumericLessThanEquals": {
"s3:RequestJobPriority": 100
}
}
},
{
"Effect": "Allow",
"Action": "s3:PutJobTagging",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:RequestTag/department" : "${aws:PrincipalTag/department}",
"aws:ResourceTag/department": "${aws:PrincipalTag/department}",
"aws:RequestTag/stage": "QA",
"aws:ResourceTag/stage": "QA"
}
}
},
{
"Effect": "Allow",
"Action": "s3:GetJobTagging",
"Resource": "*"
}
]
}
```
### 在部门内创建和更新高优先级任务
少数用户可能需要在 QA 或 生产 中创建高优先级任务的能力。为了满足这一需求，您可以创建一个根据上一节中的低优先级策略改写的托管策略。
该策略执行以下操作：
+ 允许用户使用标签 `stage=QA` 或 `stage=Production` 在其部门中创建或更新任务。
+ 允许用户创建或更新任务的优先级，最高为 300。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:CreateJob",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:RequestTag/stage": [
"QA",
"Production"
]
},
"StringEquals": {
"aws:RequestTag/department": "${aws:PrincipalTag/department}"
},
"NumericLessThanEquals": {
"s3:RequestJobPriority": 300
}
}
},
{
"Effect": "Allow",
"Action": [
"s3:UpdateJobStatus"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/department": "${aws:PrincipalTag/department}"
}
}
},
{
"Effect": "Allow",
"Action": "s3:UpdateJobPriority",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:ResourceTag/stage": [
"QA",
"Production"
]
},
"StringEquals": {
"aws:ResourceTag/department": "${aws:PrincipalTag/department}"
},
"NumericLessThanEquals": {
"s3:RequestJobPriority": 300
}
}
},
{
"Effect": "Allow",
"Action": "s3:PutJobTagging",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:RequestTag/department": "${aws:PrincipalTag/department}",
"aws:ResourceTag/department": "${aws:PrincipalTag/department}"
},
"ForAnyValue:StringEquals": {
"aws:RequestTag/stage": [
"QA",
"Production"
],
"aws:ResourceTag/stage": [
"QA",
"Production"
]
}
}
}
]
}
```
------
# 使用 S3 分批操作管理 S3 对象锁定
您可以使用 S3 批量操作对 Amazon S3 对象执行大规模批量操作。S3 批量操作可以对您指定的 Amazon S3 对象列表执行单个操作。单个任务可对数十亿个包含 EB 级数据的对象执行指定操作。Amazon S3 跟踪进度、发送通知并存储所有操作的详细完成报告，从而提供完全托管、可审核的无服务器体验。可以通过 Amazon S3 控制台、AWS CLI、AWS SDK 或 Amazon S3 REST API 使用 S3 批量操作。
S3 对象锁定还可以对对象版本进依法保留。与设置保留期限相似，依法保留可防止对象版本被覆盖或删除。但是，法定保留没有关联的保留期，在移除法定保留之前将保持有效。有关更多信息，请参阅 [S3 对象锁定依法保留](batch-ops-legal-hold.md)。
要将 S3 批量操作与对象锁定结合使用，以便同时对许多 Amazon S3 对象添加法定保留，请参阅以下主题。
**Topics**
+ [使用 S3 分批操作启用 S3 对象锁定](batch-ops-object-lock.md)
+ [使用分批操作设置对象锁定保留](batch-ops-object-lock-retention.md)
+ [将 S3 分批操作与 S3 对象锁定保留合规模式结合使用](batch-ops-compliance-mode.md)
+ [将 S3 分批操作与 S3 对象锁定保留监管模式结合使用](batch-ops-governance-mode.md)
+ [使用 S3 批量操作关闭 S3 对象锁定法定保留](batch-ops-legal-hold-off.md)
# 使用 S3 分批操作启用 S3 对象锁定
可以将 Amazon S3 批量操作与 S3 对象锁定结合使用，以便同时为许多 Amazon S3 对象管理保留或启用法定保留。您可以在清单中指定目标对象的列表并将该列表提交到分批操作以完成操作。有关更多信息，请参阅[S3 对象锁定保留](batch-ops-retention-date.md)和[S3 对象锁定依法保留](batch-ops-legal-hold.md)。
以下示例说明如何创建具有 S3 批量操作权限的 AWS Identity and Access Management（IAM）角色并更新角色权限，来创建启用对象锁定的任务。还必须有一个 `CSV` 清单来标识 S3 批量操作任务的对象。有关更多信息，请参阅 [指定清单](batch-ops-create-job.md#specify-batchjob-manifest)。
要使用以下示例，请将 *`user input placeholders`* 替换为您自己的信息。
## 使用 AWS CLI
1. 创建 IAM 角色并为 S3 分批操作分配运行权限。
所有 S3 分批操作任务都必须执行此步骤。
```
export AWS_PROFILE='aws-user'
read -d '' batch_operations_trust_policy <
可以使用适用于 Java 的 AWS SDK 创建具有 S3 批量操作权限的 IAM 角色，并更新角色权限来创建启用对象锁定的任务。您还必须有一个 `CSV` 清单来标识 S3 分批操作任务的对象。有关更多信息，请参阅 [指定清单](batch-ops-create-job.md#specify-batchjob-manifest)。
执行以下步骤：
1. 创建 IAM 角色并为 S3 分批操作分配运行权限。所有 S3 分批操作任务都必须执行此步骤。
1. 设置要运行的 S3 分批操作和 S3 对象锁定。
允许角色执行以下操作：
1. 在包含您希望在其上运行分批操作的目标对象的 S3 存储桶上运行对象锁定。
1. 读取清单 CSV 文件和对象所在的 S3 存储桶。
1. 将 S3 分批操作任务的结果写入报告存储桶。
有关演示如何通过将 S3 批量操作与适用于 Java 的 AWS SDK 结合使用来创建 IAM 角色以启用 S3 对象锁定的代码示例，请参阅《AWS SDK for Java 2.x Code Examples》**中的 [CreateObjectLockRole.java](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/s3/src/main/java/com/example/s3/batch/CreateObjectLockRole.java)。
# 使用分批操作设置对象锁定保留
可以将 Amazon S3 批量操作与 S3 对象锁定结合使用，以便同时管理许多 Amazon S3 对象的保留。您可以在清单中指定目标对象的列表并将该列表提交到分批操作以完成操作。有关更多信息，请参阅[S3 对象锁定保留](batch-ops-retention-date.md)和[S3 对象锁定依法保留](batch-ops-legal-hold.md)。
以下示例说明如何创建具有 S3 批量操作权限的 AWS Identity and Access Management（IAM）角色，并更新角色权限来包含 `s3:PutObjectRetention` 权限，以便您可以对清单存储桶中的对象运行 S3 对象锁定保留。还必须有一个 `CSV` 清单来标识 S3 批量操作任务的对象。有关更多信息，请参阅 [指定清单](batch-ops-create-job.md#specify-batchjob-manifest)。
要使用以下示例，请将 *`user input placeholders`* 替换为您自己的信息。
## 使用 AWS CLI
以下 AWS CLI 示例说明如何使用批量操作跨多个对象应用 S3 对象锁定保留。
```
export AWS_PROFILE='aws-user'
read -d '' retention_permissions <
有关如何使用批量操作通过适用于 Java 的 AWS SDK 对多个对象应用 S3 对象锁定保留的示例，请参阅《Amazon S3 API Reference》**中的 [Use CreateJob with an AWS SDK or CLI](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_CreateJob_section.html)。
# 将 S3 分批操作与 S3 对象锁定保留合规模式结合使用
以下示例基于上述创建信任策略以及在对象上设置 S3 分批操作和 S3 对象锁定配置权限的示例而构建。此示例将保留模式设置为 `COMPLIANCE`，并将 `retain until date` 设置为 2025 年 1 月 1 日。此示例将创建一个任务，该任务以清单存储桶中的对象为目标，并在您标识的报告存储桶中报告结果。
要使用以下示例，请将 *`user input placeholders`* 替换为您自己的信息。
## 使用 AWS CLI
以下 AWS CLI 示例说明如何使用批量操作跨多个对象应用 S3 对象锁定保留合规模式。
**Example — 跨多个对象设置 S3 对象锁定保留合规模式**
```
export AWS_PROFILE='aws-user'
export AWS_DEFAULT_REGION='us-west-2'
export ACCOUNT_ID=123456789012
export ROLE_ARN='arn:aws:iam::123456789012:role/batch_operations-objectlock'
read -d '' OPERATION <
以下适用于 Java 的 AWS SDK 示例说明如何使用批量操作跨多个对象应用 S3 对象锁定保留合规模式，包括将保留模式设置为具有保留截止日期的 COMPLIANCE 和延长 COMPLIANCE 模式保留截止日期。
有关如何使用批量操作通过适用于 Java 的 AWS SDK 对多个对象应用 S3 对象锁定保留合规模式的示例，请参阅《Amazon S3 API Reference》**中的 [Use CreateJob with an AWS SDK or CLI](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_CreateJob_section.html)。
# 将 S3 分批操作与 S3 对象锁定保留监管模式结合使用
以下示例基于上述创建信任策略以及设置 S3 分批操作和 S3 对象锁定配置权限的示例而构建。本示例说明如何跨多个对象应用 S3 对象锁定保留监管，`retain until date` 为 2025 年 1 月 30 日。它会创建一个分批操作任务，该任务使用清单存储桶，并在报告存储桶中报告结果。
要使用以下示例，请将 *`user input placeholders`* 替换为您自己的信息。
## 使用 AWS CLI
以下 AWS CLI 示例说明如何使用批量操作跨多个对象应用 S3 对象锁定保留监管模式。
**Example — 跨多个对象应用 S3 对象锁定保留监管，“保留到期日”为 2025 年 1 月 30 日**
```
export AWS_PROFILE='aws-user'
export AWS_DEFAULT_REGION='us-west-2'
export ACCOUNT_ID=123456789012
export ROLE_ARN='arn:aws:iam::123456789012:role/batch_operations-objectlock'
read -d '' OPERATION <
以下适用于 Java 的 AWS SDK 示例说明如何跨多个对象应用 S3 对象锁定保留治理（`retain until date` 设置为 2025 年 1 月 30 日），包括跨多个对象应用具有保留截止日期的对象锁定保留治理，以及绕过跨多个对象的保留治理。
有关如何通过适用于 Java 的 AWS SDK 将批量操作与 S3 对象锁定保留治理模式结合使用的示例，请参阅《Amazon S3 API Reference》**中的 [Use CreateJob with an AWS SDK or CLI](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_CreateJob_section.html)。
# 使用 S3 批量操作关闭 S3 对象锁定法定保留
以下示例基于上述创建信任策略以及设置 S3 分批操作和 S3 对象锁定配置权限的示例而构建。本示例说明如何使用批量操作在对象上禁用对象锁定法定保留。
在该示例中，首先更新角色以授予 `s3:PutObjectLegalHold` 权限，再创建一个分批操作任务（该任务从清单中标识的对象中禁用（删除）依法保留，然后报告此情况）。
要使用以下示例，请将 *`user input placeholders`* 替换为您自己的信息。
## 使用 AWS CLI
以下 AWS CLI 示例说明如何使用批量操作跨多个对象关闭 S3 对象锁定法定保留。
**Example — 更新角色以授予 `s3:PutObjectLegalHold` 权限**
```
export AWS_PROFILE='aws-user'
read -d '' legal_hold_permissions <
有关如何通过适用于 Java 的 AWS SDK 使用 S3 批量操作来关闭 S3 对象锁定依法保留的示例，请参阅《Amazon S3 API Reference》**中的 [Use CreateJob with an AWS SDK or CLI](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_CreateJob_section.html)。
# 教程：使用 S3 批量操作对视频进行批量转码
视频消费者使用各种形状、尺寸和年份的设备来享受媒体内容。这种广泛的设备类型给内容创作者和转发者带来了挑战。视频不是一刀切的格式，而是必须进行转换，以便涵盖各种尺寸、格式和比特率。如果大量必须转换的视频，这一转换任务就更具挑战性。
AWS 为您提供了构建可扩展的分布式架构的方法，该架构可执行以下操作：
+ 摄取输入视频
+ 处理视频以便在各种设备上播放
+ 存储转码的媒体文件
+ 交付输出媒体文件以满足需求
如果在 Amazon S3 中存储了大量的视频存储库，您可以将这些视频从源格式转换为多种文件类型，按照特定视频播放器或设备所需的大小、分辨率和格式转换为多种文件类型。具体来说，[S3 批量操作](https://aws.amazon.com/s3/features/batch-operations)为您提供了一个可以为 S3 源存储桶中的现有输入视频调用 AWS Lambda 函数的解决方案。然后，Lambda 函数调用 [AWS Elemental MediaConvert](https://aws.amazon.com/mediaconvert/) 来执行大规模视频转码任务。转换后的输出媒体文件存储在 S3 目标存储桶中。
![\[批处理转码工作流程图。\]](http://docs.aws.amazon.com/zh_cn/AmazonS3/latest/userguide/images/batchops-example-image-global.png)
**目标**
在本教程中，您将了解如何将 S3 批量操作设置为调用 Lambda 函数对存储在 S3 源存储桶中的视频进行批量转码。Lambda 函数调用 MediaConvert 转码视频。S3 源存储桶中每个视频的输出如下所示：
+ [HTTP 实时流 (HLS)](http://wikipedia.org/wiki/HTTP_Live_Streaming) 自适应比特率流，用于在多个大小的设备和不同的带宽上播放。
+ MP4 视频文件
+ 按间隔收集的缩略图图像
**Topics**
+ [先决条件](#batchops-s3-prerequisites)
+ [步骤 1：为输出媒体文件创建 S3 存储桶](#batchops-s3-step1)
+ [步骤 2：为 MediaConvert 创建 IAM 角色](#batchops-s3-step2)
+ [步骤 3：为您的 Lambda 函数创建 IAM 角色](#batchops-s3-step3)
+ [步骤 4：创建 Lambda 函数以进行视频转码](#batchops-s3-step4)
+ [步骤 5：为 S3 源存储桶配置 Amazon S3 清单](#batchops-s3-step5)
+ [步骤 6：为 S3 批量操作创建 IAM 角色](#batchops-s3-step6)
+ [步骤 7：设置并运行 S3 批量操作任务](#batchops-s3-step7)
+ [步骤 8：检查 S3 目标存储桶中的输出媒体文件](#batchops-s3-step8)
+ [步骤 9：清除](#batchops-s3-step9)
+ [后续步骤](#batchops-s3-next-steps)
## 先决条件
在开始本教程之前，您必须有储存要转码视频的 Amazon S3 源存储桶（例如，`amzn-s3-demo-source-bucket`）。
如果愿意，您可以重新命名存储桶。有关 Amazon S3 存储桶名称的更多信息，请参阅 [通用存储桶命名规则](bucketnamingrules.md)。
对于 S3 源存储桶，请保留**阻止此存储桶的公有访问**设置为默认值（已启用**阻止*全部*公共访问**）。有关更多信息，请参阅 [创建通用存储桶](create-bucket-overview.md)。
有关将视频上传到 S3 源存储桶的详细信息，请参阅 [上传对象](upload-objects.md)。如果将许多大型视频文件上传到 S3 时，您还可以使用 [Amazon S3 Transfer Acceleration](https://aws.amazon.com/s3/transfer-acceleration) 配置快速安全的文件传输。Transfer Acceleration 可以加快视频上传到 S3 存储桶的速度，以便远距离传输较大的视频。有关更多信息，请参阅 [使用 Amazon S3 Transfer Acceleration 配置快速、安全的文件传输](transfer-acceleration.md)。
## 步骤 1：为输出媒体文件创建 S3 存储桶
在此步骤中，您将创建一个 S3 目标存储桶来存储转换后的输出媒体文件。您还可以创建跨源资源共享（CORS）配置，允许跨源访问存储在 S3 目标存储桶中的转码媒体文件。
**Topics**
+ [为输出媒体文件创建存储桶。](#batchops-s3-step1-create-bucket)
+ [将 CORS 配置添加到 S3 输出存储桶](#batchops-s3-step1-cors)
### 为输出媒体文件创建存储桶。
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**存储桶**。
1. 选择**创建存储桶**。
1. 对于 **Bucket Name（存储桶名称）**，输入您的存储桶的名称（例如 `amzn-s3-demo-destination-bucket1`）。
1. 对于 ** Region（区域）**，选择要放置桶的位置 AWS 区域。
1. 要确保公众访问输出媒体文件，请在**阻止此存储桶的公有访问设置**，清除**阻止*全部*公有访问权限**。
**警告**
在完成此步骤之前，请查看 [阻止对您的 Amazon S3 存储的公有访问](access-control-block-public-access.md)，以确保您了解并接受允许进行公有访问所涉及的风险。当您关闭屏蔽公共访问权限设置以使您的存储桶变为公有时，Internet 上的任何人都可以访问您的存储桶。我们建议您阻止对存储桶的所有公有访问。
如果您不想清除“屏蔽公共访问权限”设置，可以使用 Amazon CloudFront 将转码的媒体文件传送给查看者（最终用户）。有关更多信息，请参阅 [教程：使用 Amazon S3、Amazon CloudFront 和 Amazon Route 53 托管点播流视频](tutorial-s3-cloudfront-route53-video-streaming.md)。
1. 选择**旁边的复选框，我确认当前设置可能会导致此存储桶及其中的对象变为公有**。
1. 对于其余设置，保留默认值。
1. 选择 **Create bucket**（创建存储桶）。
### 将 CORS 配置添加到 S3 输出存储桶
JSON CORS 配置定义了在一个域中加载的客户端 Web 应用程序（此处上下文的视频播放器）在另一个域中播放转码后的输出媒体文件的方式。
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择 **Buckets（存储桶）**。
1. 在 **Buckets（存储桶）**列表中，选择之前创建的存储桶名称（例如，`amzn-s3-demo-destination-bucket1`）。
1. 选择 **Permissions (权限)** 选项卡。
1. 在 **Cross-origin resource sharing（CORS）（跨源资源共享（CORS））**部分中，请选择 **Edit（编辑）**。
1. 在 CORS 配置文本框中，复制并粘贴如下的 CORS 配置。
CORS 配置必须采用 JSON 格式。在此示例中，`AllowedOrigins` 属性使用通配符 (`*`) 来指定所有来源。如果您知道您的特定来源，则可以限制 `AllowedOrigins` 属性添加到您的特定播放器 URL。有关配置此属性和其他属性的更多信息，请参阅 [CORS 配置的元素](ManageCorsUsing.md)。
```
[
{
"AllowedOrigins": [
"*"
],
"AllowedMethods": [
"GET"
],
"AllowedHeaders": [
"*"
],
"ExposeHeaders": []
}
]
```
1. 选择 **Save changes (保存更改)**。
## 步骤 2：为 MediaConvert 创建 IAM 角色
为了使用 AWS Elemental MediaConvert 转码存储在 S3 存储桶中的输入视频，您必须有一个 AWS Identity and Access Management（IAM）服务角色以授予 MediaConvert 权限，以便从 S3 源存储桶读取视频文件以及向 S3 目标存储桶写入视频文件。当您运行转码任务时，MediaConvert 控制台会使用此角色。
**为 MediaConvert 创建 IAM 角色**
1. 使用您选择的角色名称创建 IAM 角色（例如，**tutorial-mediaconvert-role**)。要创建此角色，请按照《AWS Elemental MediaConvert 用户指南》**的[在 IAM（控制台）中创建您的 MediaConvert 角色](https://docs.aws.amazon.com/mediaconvert/latest/ug/creating-the-iam-role-in-iam.html)中的步骤操作。
1. 为 MediaConvert 创建 IAM 角色之后，请在 **Role (角色)**列表中选择您为 MediaConvert 创建的角色的名称（例如，**tutorial-mediaconvert-role**)。
1. 在 **Summary (摘要)** 页面上，复制 **Role ARN (角色 ARN)** (从 `arn:aws:iam::` 开始) 并保存 ARN 以供稍后使用。
有关 ARN 的更多信息，请参阅 *AWS 一般参考*中的 [Amazon Resource Name (ARN)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。
## 步骤 3：为您的 Lambda 函数创建 IAM 角色
要使用 MediaConvert 和 S3 Batch 操作批量转码视频，您可使用 Lambda 函数来连接这两个服务来转换视频。此 Lambda 函数必须具有一个 IAM 角色，该角色可授予 Lambda 函数访问 MediaConvert 和 S3 Batch Operations 的权限。
**Topics**
+ [为 Lambda 函数创建 IAM 角色](#batchops-s3-step3-role)
+ [为 Lambda 函数的 IAM 角色嵌入内联策略](#batchops-s3-step3-inline-policy)
### 为 Lambda 函数创建 IAM 角色
1. 登录 AWS 管理控制台，然后通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。
1. 在左侧导航窗格中，选择**角色**，然后选择**创建角色**。
1. 选择 **AWS 服务**角色类型，然后在 **Common use cases (常见用例)**中，选择 **Lambda**。
1. 选择 **Next: Permissions (下一步: 权限)**。
1. 在 **Attach permissions policies (附加权限策略)** 页的 **Filter policies (筛选策略)** 框中输入 **AWSLambdaBasicExecutionRole**。若要附加托管策略 **AWSLambdaBasicExecutionRole** 至此角色，以向 Amazon CloudWatch Logs 授予写入权限，则应选中 **AWSLambdaBasicExecutionRole** 旁边的复选框。
1. 选择**下一步**。
1. 对于**角色名称**，输入 **tutorial-lambda-transcode-role**。
1. （可选）将标签添加到托管策略。
1. 选择 **Create role (创建角色)**。
### 为 Lambda 函数的 IAM 角色嵌入内联策略
您必须使用内联策略，方可向 Lambda 函数执行所需的 MediaConvert 资源授予权限。
1. 登录 AWS 管理控制台，然后通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。
1. 在左侧导航窗格中，选择 **Roles（角色）**。
1. 在 **Roles (角色)** 列表中，选择您在前面为 Lambda 函数创建的 IAM 角色的名称（例如，**tutorial-lambda-transcode-role**）。
1. 选择 **Permissions (权限)** 选项卡。
1. 选择 **Add inline policy (添加内联策略)**。
1. 选择 **JSON** 选项卡，然后复制并粘贴以下 JSON 策略。
将在 JSON 策略中的示例 ARN 值 `Resource` 替换为您在[步骤 2](#batchops-s3-step2)中为 MediaConvert 创建的 IAM 角色的角色 ARN（例如，**tutorial-mediaconvert-role**）。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "*",
"Effect": "Allow",
"Sid": "Logging"
},
{
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/tutorial-mediaconvert-role"
],
"Effect": "Allow",
"Sid": "PassRole"
},
{
"Action": [
"mediaconvert:*"
],
"Resource": [
"*"
],
"Effect": "Allow",
"Sid": "MediaConvertService"
},
{
"Action": [
"s3:*"
],
"Resource": [
"*"
],
"Effect": "Allow",
"Sid": "S3Service"
}
]
}
```
------
1. 选择 **Review Policy (查看策略)**。
1. 对于 **Name (名称)**，请输入 **tutorial-lambda-policy**。
1. 选择 **Create Policy (创建策略)**。
创建内联策略后，会自动嵌入您的 Lambda 函数 IAM 角色。
## 步骤 4：创建 Lambda 函数以进行视频转码
在本教程的此部分中，您使用适用于 Python 的 SDK 构建 Lambda 函数，以便与 S3 批量操作和 MediaConvert 集成。要开始对存储在 S3 源存储桶中的视频进行转码，您可运行 S3 Batch Operation，该任务直接为 S3 源存储桶中的每个视频调用 Lambda 函数。然后，Lambda 函数将每个视频的转码任务提交给 MediaConvert。
**Topics**
+ [编写 Lambda 函数代码并创建部署程序包](#batchops-s3-step4-write-function)
+ [使用执行角色创建 Lambda 函数（控制台）](#batchops-s3-step4-create-function)
+ [使用 .zip 文件归档部署 Lambda 函数并配置 Lambda 函数（控制台）](#batchops-s3-step4-deploy-function)
### 编写 Lambda 函数代码并创建部署程序包
1. 在您的本地计算机上，创建名为 `batch-transcode` 的文件夹。
1. 在 `batch-transcode` 文件夹中，创建具有 JSON 任务设置的文件。例如，您可以使用本部分中提供的设置并为文件指定名称 `job.json`。
`job.json` 文件指定以下内容：
+ 要转码的文件
+ 您希望如何对输入的视频进行转码
+ 您希望创建何种输出媒体文件
+ 要为转码文件指定的名称
+ 在何处保存转码文件
+ 要应用的高级特征等。
在本教程中，我们使用如下 `job.json` 文件为 S3 源存储桶中的每个视频创建以下输出：
+ HTTP 实时流 (HLS) 自适应比特率流，用于在多个大小的设备和不同的带宽上播放。
+ MP4 视频文件
+ 按间隔收集的缩略图图像
此示例 `job.json` 文件使用质量定义的可变比特率 (QVBR) 来优化视频质量。HTTP 实时流 (HLS) 输出符合苹果标准（从视频解除音频，6 秒的段持续时间，并通过自动 QVBR 优化视频质量）。
如果您不想使用此处提供的示例设置，可以基于您的使用案例生成 `job.json` 规范。要确保输出的一致性，请确保输入文件具有类似的视频和音频配置。对于具有不同视频和音频配置的任何输入文件，可创建单独的自动化（唯一的 `job.json` 设置）。有关更多信息，请参阅《AWS Elemental MediaConvert 用户指南》**中的 [JSON 格式的 AWS Elemental MediaConvert 任务设置示例](https://docs.aws.amazon.com/mediaconvert/latest/ug/example-job-settings.html)。
```
{
"OutputGroups": [
{
"CustomName": "HLS",
"Name": "Apple HLS",
"Outputs": [
{
"ContainerSettings": {
"Container": "M3U8",
"M3u8Settings": {
"AudioFramesPerPes": 4,
"PcrControl": "PCR_EVERY_PES_PACKET",
"PmtPid": 480,
"PrivateMetadataPid": 503,
"ProgramNumber": 1,
"PatInterval": 0,
"PmtInterval": 0,
"TimedMetadata": "NONE",
"VideoPid": 481,
"AudioPids": [
482,
483,
484,
485,
486,
487,
488,
489,
490,
491,
492
]
}
},
"VideoDescription": {
"Width": 640,
"ScalingBehavior": "DEFAULT",
"Height": 360,
"TimecodeInsertion": "DISABLED",
"AntiAlias": "ENABLED",
"Sharpness": 50,
"CodecSettings": {
"Codec": "H_264",
"H264Settings": {
"InterlaceMode": "PROGRESSIVE",
"NumberReferenceFrames": 3,
"Syntax": "DEFAULT",
"Softness": 0,
"GopClosedCadence": 1,
"GopSize": 2,
"Slices": 1,
"GopBReference": "DISABLED",
"MaxBitrate": 1200000,
"SlowPal": "DISABLED",
"SpatialAdaptiveQuantization": "ENABLED",
"TemporalAdaptiveQuantization": "ENABLED",
"FlickerAdaptiveQuantization": "DISABLED",
"EntropyEncoding": "CABAC",
"FramerateControl": "INITIALIZE_FROM_SOURCE",
"RateControlMode": "QVBR",
"CodecProfile": "MAIN",
"Telecine": "NONE",
"MinIInterval": 0,
"AdaptiveQuantization": "HIGH",
"CodecLevel": "AUTO",
"FieldEncoding": "PAFF",
"SceneChangeDetect": "TRANSITION_DETECTION",
"QualityTuningLevel": "SINGLE_PASS_HQ",
"FramerateConversionAlgorithm": "DUPLICATE_DROP",
"UnregisteredSeiTimecode": "DISABLED",
"GopSizeUnits": "SECONDS",
"ParControl": "INITIALIZE_FROM_SOURCE",
"NumberBFramesBetweenReferenceFrames": 2,
"RepeatPps": "DISABLED"
}
},
"AfdSignaling": "NONE",
"DropFrameTimecode": "ENABLED",
"RespondToAfd": "NONE",
"ColorMetadata": "INSERT"
},
"OutputSettings": {
"HlsSettings": {
"AudioGroupId": "program_audio",
"AudioRenditionSets": "program_audio",
"SegmentModifier": "$dt$",
"IFrameOnlyManifest": "EXCLUDE"
}
},
"NameModifier": "_360"
},
{
"ContainerSettings": {
"Container": "M3U8",
"M3u8Settings": {
"AudioFramesPerPes": 4,
"PcrControl": "PCR_EVERY_PES_PACKET",
"PmtPid": 480,
"PrivateMetadataPid": 503,
"ProgramNumber": 1,
"PatInterval": 0,
"PmtInterval": 0,
"TimedMetadata": "NONE",
"TimedMetadataPid": 502,
"VideoPid": 481,
"AudioPids": [
482,
483,
484,
485,
486,
487,
488,
489,
490,
491,
492
]
}
},
"VideoDescription": {
"Width": 960,
"ScalingBehavior": "DEFAULT",
"Height": 540,
"TimecodeInsertion": "DISABLED",
"AntiAlias": "ENABLED",
"Sharpness": 50,
"CodecSettings": {
"Codec": "H_264",
"H264Settings": {
"InterlaceMode": "PROGRESSIVE",
"NumberReferenceFrames": 3,
"Syntax": "DEFAULT",
"Softness": 0,
"GopClosedCadence": 1,
"GopSize": 2,
"Slices": 1,
"GopBReference": "DISABLED",
"MaxBitrate": 3500000,
"SlowPal": "DISABLED",
"SpatialAdaptiveQuantization": "ENABLED",
"TemporalAdaptiveQuantization": "ENABLED",
"FlickerAdaptiveQuantization": "DISABLED",
"EntropyEncoding": "CABAC",
"FramerateControl": "INITIALIZE_FROM_SOURCE",
"RateControlMode": "QVBR",
"CodecProfile": "MAIN",
"Telecine": "NONE",
"MinIInterval": 0,
"AdaptiveQuantization": "HIGH",
"CodecLevel": "AUTO",
"FieldEncoding": "PAFF",
"SceneChangeDetect": "TRANSITION_DETECTION",
"QualityTuningLevel": "SINGLE_PASS_HQ",
"FramerateConversionAlgorithm": "DUPLICATE_DROP",
"UnregisteredSeiTimecode": "DISABLED",
"GopSizeUnits": "SECONDS",
"ParControl": "INITIALIZE_FROM_SOURCE",
"NumberBFramesBetweenReferenceFrames": 2,
"RepeatPps": "DISABLED"
}
},
"AfdSignaling": "NONE",
"DropFrameTimecode": "ENABLED",
"RespondToAfd": "NONE",
"ColorMetadata": "INSERT"
},
"OutputSettings": {
"HlsSettings": {
"AudioGroupId": "program_audio",
"AudioRenditionSets": "program_audio",
"SegmentModifier": "$dt$",
"IFrameOnlyManifest": "EXCLUDE"
}
},
"NameModifier": "_540"
},
{
"ContainerSettings": {
"Container": "M3U8",
"M3u8Settings": {
"AudioFramesPerPes": 4,
"PcrControl": "PCR_EVERY_PES_PACKET",
"PmtPid": 480,
"PrivateMetadataPid": 503,
"ProgramNumber": 1,
"PatInterval": 0,
"PmtInterval": 0,
"TimedMetadata": "NONE",
"VideoPid": 481,
"AudioPids": [
482,
483,
484,
485,
486,
487,
488,
489,
490,
491,
492
]
}
},
"VideoDescription": {
"Width": 1280,
"ScalingBehavior": "DEFAULT",
"Height": 720,
"TimecodeInsertion": "DISABLED",
"AntiAlias": "ENABLED",
"Sharpness": 50,
"CodecSettings": {
"Codec": "H_264",
"H264Settings": {
"InterlaceMode": "PROGRESSIVE",
"NumberReferenceFrames": 3,
"Syntax": "DEFAULT",
"Softness": 0,
"GopClosedCadence": 1,
"GopSize": 2,
"Slices": 1,
"GopBReference": "DISABLED",
"MaxBitrate": 5000000,
"SlowPal": "DISABLED",
"SpatialAdaptiveQuantization": "ENABLED",
"TemporalAdaptiveQuantization": "ENABLED",
"FlickerAdaptiveQuantization": "DISABLED",
"EntropyEncoding": "CABAC",
"FramerateControl": "INITIALIZE_FROM_SOURCE",
"RateControlMode": "QVBR",
"CodecProfile": "MAIN",
"Telecine": "NONE",
"MinIInterval": 0,
"AdaptiveQuantization": "HIGH",
"CodecLevel": "AUTO",
"FieldEncoding": "PAFF",
"SceneChangeDetect": "TRANSITION_DETECTION",
"QualityTuningLevel": "SINGLE_PASS_HQ",
"FramerateConversionAlgorithm": "DUPLICATE_DROP",
"UnregisteredSeiTimecode": "DISABLED",
"GopSizeUnits": "SECONDS",
"ParControl": "INITIALIZE_FROM_SOURCE",
"NumberBFramesBetweenReferenceFrames": 2,
"RepeatPps": "DISABLED"
}
},
"AfdSignaling": "NONE",
"DropFrameTimecode": "ENABLED",
"RespondToAfd": "NONE",
"ColorMetadata": "INSERT"
},
"OutputSettings": {
"HlsSettings": {
"AudioGroupId": "program_audio",
"AudioRenditionSets": "program_audio",
"SegmentModifier": "$dt$",
"IFrameOnlyManifest": "EXCLUDE"
}
},
"NameModifier": "_720"
},
{
"ContainerSettings": {
"Container": "M3U8",
"M3u8Settings": {}
},
"AudioDescriptions": [
{
"AudioSourceName": "Audio Selector 1",
"CodecSettings": {
"Codec": "AAC",
"AacSettings": {
"Bitrate": 96000,
"CodingMode": "CODING_MODE_2_0",
"SampleRate": 48000
}
}
}
],
"OutputSettings": {
"HlsSettings": {
"AudioGroupId": "program_audio",
"AudioTrackType": "ALTERNATE_AUDIO_AUTO_SELECT_DEFAULT"
}
},
"NameModifier": "_audio"
}
],
"OutputGroupSettings": {
"Type": "HLS_GROUP_SETTINGS",
"HlsGroupSettings": {
"ManifestDurationFormat": "INTEGER",
"SegmentLength": 6,
"TimedMetadataId3Period": 10,
"CaptionLanguageSetting": "OMIT",
"Destination": "s3://EXAMPLE-BUCKET/HLS/",
"DestinationSettings": {
"S3Settings": {
"AccessControl": {
"CannedAcl": "PUBLIC_READ"
}
}
},
"TimedMetadataId3Frame": "PRIV",
"CodecSpecification": "RFC_4281",
"OutputSelection": "MANIFESTS_AND_SEGMENTS",
"ProgramDateTimePeriod": 600,
"MinSegmentLength": 0,
"DirectoryStructure": "SINGLE_DIRECTORY",
"ProgramDateTime": "EXCLUDE",
"SegmentControl": "SEGMENTED_FILES",
"ManifestCompression": "NONE",
"ClientCache": "ENABLED",
"StreamInfResolution": "INCLUDE"
}
}
},
{
"CustomName": "MP4",
"Name": "File Group",
"Outputs": [
{
"ContainerSettings": {
"Container": "MP4",
"Mp4Settings": {
"CslgAtom": "INCLUDE",
"FreeSpaceBox": "EXCLUDE",
"MoovPlacement": "PROGRESSIVE_DOWNLOAD"
}
},
"VideoDescription": {
"Width": 1280,
"ScalingBehavior": "DEFAULT",
"Height": 720,
"TimecodeInsertion": "DISABLED",
"AntiAlias": "ENABLED",
"Sharpness": 100,
"CodecSettings": {
"Codec": "H_264",
"H264Settings": {
"InterlaceMode": "PROGRESSIVE",
"ParNumerator": 1,
"NumberReferenceFrames": 3,
"Syntax": "DEFAULT",
"Softness": 0,
"GopClosedCadence": 1,
"HrdBufferInitialFillPercentage": 90,
"GopSize": 2,
"Slices": 2,
"GopBReference": "ENABLED",
"HrdBufferSize": 10000000,
"MaxBitrate": 5000000,
"ParDenominator": 1,
"EntropyEncoding": "CABAC",
"RateControlMode": "QVBR",
"CodecProfile": "HIGH",
"MinIInterval": 0,
"AdaptiveQuantization": "AUTO",
"CodecLevel": "AUTO",
"FieldEncoding": "PAFF",
"SceneChangeDetect": "ENABLED",
"QualityTuningLevel": "SINGLE_PASS_HQ",
"UnregisteredSeiTimecode": "DISABLED",
"GopSizeUnits": "SECONDS",
"ParControl": "SPECIFIED",
"NumberBFramesBetweenReferenceFrames": 3,
"RepeatPps": "DISABLED",
"DynamicSubGop": "ADAPTIVE"
}
},
"AfdSignaling": "NONE",
"DropFrameTimecode": "ENABLED",
"RespondToAfd": "NONE",
"ColorMetadata": "INSERT"
},
"AudioDescriptions": [
{
"AudioTypeControl": "FOLLOW_INPUT",
"AudioSourceName": "Audio Selector 1",
"CodecSettings": {
"Codec": "AAC",
"AacSettings": {
"AudioDescriptionBroadcasterMix": "NORMAL",
"Bitrate": 160000,
"RateControlMode": "CBR",
"CodecProfile": "LC",
"CodingMode": "CODING_MODE_2_0",
"RawFormat": "NONE",
"SampleRate": 48000,
"Specification": "MPEG4"
}
},
"LanguageCodeControl": "FOLLOW_INPUT",
"AudioType": 0
}
]
}
],
"OutputGroupSettings": {
"Type": "FILE_GROUP_SETTINGS",
"FileGroupSettings": {
"Destination": "s3://EXAMPLE-BUCKET/MP4/",
"DestinationSettings": {
"S3Settings": {
"AccessControl": {
"CannedAcl": "PUBLIC_READ"
}
}
}
}
}
},
{
"CustomName": "Thumbnails",
"Name": "File Group",
"Outputs": [
{
"ContainerSettings": {
"Container": "RAW"
},
"VideoDescription": {
"Width": 1280,
"ScalingBehavior": "DEFAULT",
"Height": 720,
"TimecodeInsertion": "DISABLED",
"AntiAlias": "ENABLED",
"Sharpness": 50,
"CodecSettings": {
"Codec": "FRAME_CAPTURE",
"FrameCaptureSettings": {
"FramerateNumerator": 1,
"FramerateDenominator": 5,
"MaxCaptures": 500,
"Quality": 80
}
},
"AfdSignaling": "NONE",
"DropFrameTimecode": "ENABLED",
"RespondToAfd": "NONE",
"ColorMetadata": "INSERT"
}
}
],
"OutputGroupSettings": {
"Type": "FILE_GROUP_SETTINGS",
"FileGroupSettings": {
"Destination": "s3://EXAMPLE-BUCKET/Thumbnails/",
"DestinationSettings": {
"S3Settings": {
"AccessControl": {
"CannedAcl": "PUBLIC_READ"
}
}
}
}
}
}
],
"AdAvailOffset": 0,
"Inputs": [
{
"AudioSelectors": {
"Audio Selector 1": {
"Offset": 0,
"DefaultSelection": "DEFAULT",
"ProgramSelection": 1
}
},
"VideoSelector": {
"ColorSpace": "FOLLOW"
},
"FilterEnable": "AUTO",
"PsiControl": "USE_PSI",
"FilterStrength": 0,
"DeblockFilter": "DISABLED",
"DenoiseFilter": "DISABLED",
"TimecodeSource": "EMBEDDED",
"FileInput": "s3://EXAMPLE-INPUT-BUCKET/input.mp4"
}
]
}
```
1. 在 `batch-transcode` 文件夹中，创建 Lambda 函数的文件。您可以使用以下 Python 示例并将文件命名为 `convert.py`。
S3 Batch Operation 将特定任务数据发送到 Lambda 函数，并要求返回结果数据。对于 Lambda 函数的请求和响应示例、响应和结果代码的信息以及 S3 Batch Operations 的示例 Lambda 函数的信息，请参阅 [调用 AWS Lambda 函数](batch-ops-invoke-lambda.md)。
```
import json
import os
from urllib.parse import urlparse
import uuid
import boto3
"""
When you run an S3 Batch Operations job, your job
invokes this Lambda function. Specifically, the Lambda function is
invoked on each video object listed in the manifest that you specify
for the S3 Batch Operations job in Step 5.
Input parameter "event": The S3 Batch Operations event as a request
for the Lambda function.
Input parameter "context": Context about the event.
Output: A result structure that Amazon S3 uses to interpret the result
of the operation. It is a job response returned back to S3 Batch Operations.
"""
def handler(event, context):
invocation_schema_version = event['invocationSchemaVersion']
invocation_id = event['invocationId']
task_id = event['tasks'][0]['taskId']
source_s3_key = event['tasks'][0]['s3Key']
source_s3_bucket = event['tasks'][0]['s3BucketArn'].split(':::')[-1]
source_s3 = 's3://' + source_s3_bucket + '/' + source_s3_key
result_list = []
result_code = 'Succeeded'
result_string = 'The input video object was converted successfully.'
# The type of output group determines which media players can play
# the files transcoded by MediaConvert.
# For more information, see [Creating outputs with AWS Elemental MediaConvert](https://docs.aws.amazon.com/mediaconvert/latest/ug/creating-streaming-and-file-outputs.html).
output_group_type_dict = {
'HLS_GROUP_SETTINGS': 'HlsGroupSettings',
'FILE_GROUP_SETTINGS': 'FileGroupSettings',
'CMAF_GROUP_SETTINGS': 'CmafGroupSettings',
'DASH_ISO_GROUP_SETTINGS': 'DashIsoGroupSettings',
'MS_SMOOTH_GROUP_SETTINGS': 'MsSmoothGroupSettings'
}
try:
job_name = 'Default'
with open('job.json') as file:
job_settings = json.load(file)
job_settings['Inputs'][0]['FileInput'] = source_s3
# The path of each output video is constructed based on the values of
# the attributes in each object of OutputGroups in the job.json file.
destination_s3 = 's3://{0}/{1}/{2}' \
.format(os.environ['amzn-s3-demo-destination-bucket'],
os.path.splitext(os.path.basename(source_s3_key))[0],
os.path.splitext(os.path.basename(job_name))[0])
for output_group in job_settings['OutputGroups']:
output_group_type = output_group['OutputGroupSettings']['Type']
if output_group_type in output_group_type_dict.keys():
output_group_type = output_group_type_dict[output_group_type]
output_group['OutputGroupSettings'][output_group_type]['Destination'] = \
"{0}{1}".format(destination_s3,
urlparse(output_group['OutputGroupSettings'][output_group_type]['Destination']).path)
else:
raise ValueError("Exception: Unknown Output Group Type {}."
.format(output_group_type))
job_metadata_dict = {
'assetID': str(uuid.uuid4()),
'application': os.environ['Application'],
'input': source_s3,
'settings': job_name
}
region = os.environ['AWS_DEFAULT_REGION']
endpoints = boto3.client('mediaconvert', region_name=region) \
.describe_endpoints()
client = boto3.client('mediaconvert', region_name=region,
endpoint_url=endpoints['Endpoints'][0]['Url'],
verify=False)
try:
client.create_job(Role=os.environ['MediaConvertRole'],
UserMetadata=job_metadata_dict,
Settings=job_settings)
# You can customize error handling based on different error codes that
# MediaConvert can return.
# For more information, see [MediaConvert error codes](https://docs.aws.amazon.com/mediaconvert/latest/ug/mediaconvert_error_codes.html).
# When the result_code is TemporaryFailure, S3 Batch Operations retries
# the task before the job is completed. If this is the final retry,
# the error message is included in the final report.
except Exception as error:
result_code = 'TemporaryFailure'
raise
except Exception as error:
if result_code != 'TemporaryFailure':
result_code = 'PermanentFailure'
result_string = str(error)
finally:
result_list.append({
'taskId': task_id,
'resultCode': result_code,
'resultString': result_string,
})
return {
'invocationSchemaVersion': invocation_schema_version,
'treatMissingKeyAs': 'PermanentFailure',
'invocationId': invocation_id,
'results': result_list
}
```
1. 若要在本地终端中使用 `convert.py` 和 `job.json` 创建部署程序包 (作为名为 `lambda.zip` 的 `.zip` 文件)，打开之前创建的 `batch-transcode` 文件夹，并运行以下命令。
对于 **macOS 用户**，运行以下命令：
```
zip -r lambda.zip convert.py job.json
```
对于 **Windows 用户**，运行以下命令：
```
powershell Compress-Archive convert.py lambda.zip
```
```
powershell Compress-Archive -update job.json lambda.zip
```
### 使用执行角色创建 Lambda 函数（控制台）
1.
通过 [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) 打开 AWS Lambda 控制台。
1. 在左侧导航窗格中，选择 **Functions (函数)**。
1. 选择 **Create function (创建函数)**。
1. 选择**从头开始创作**。
1. 在**基本信息**中，执行以下操作：
1. 对于 **Function name（函数名称）**，请输入 **tutorial-lambda-convert**。
1. 对于**运行时**，选择 **Python 3.13**。
1. 选择 **Change default execution role (更改默认执行角色)**，在 **Execution role (执行角色)**中，选择 **Use an existing role (使用现有角色)**。
1. 在 **Existing role (退出角色)** 中，选择[步骤 3](#batchops-s3-step3)中您为 Lambda 函数创建的 IAM 角色的名称（例如，**tutorial-lambda-transcode-role**)。
1. 对于其余设置，保留默认值。
1. 选择 **Create function（创建函数）**。
### 使用 .zip 文件归档部署 Lambda 函数并配置 Lambda 函数（控制台）
1. 在您创建的 Lambda 函数**代码源**部分中（例如，**tutorial-lambda-convert**），请选择**上传自**，然后选择 **.zip 文件**。
1. 选择**上传**以选择本地 `.zip` 文件。
1. 选择您之前创建的 `lambda.zip` 文件，然后选择**打开**。
1. 选择**保存**。
1. 在**运行时间设置**部分，选择**编辑**。
1. 要告诉 Lambda 运行时要调用 Lambda 函数代码中的哪个处理程序方法，请输入 **convert.handler** 的**处理程序**字段。
当您在 Python 中配置函数时，处理程序设置的值是文件名，也是处理程序模块的名称（由点 (`.`) 分隔）。例如，`convert.handler` 调用在 `convert.py` 文件中定义的 `handler` 方法。
1. 选择**保存**。
1. 在 Lambda 函数页面上，选择**配置**选项卡。在左侧导航窗格中的**配置**选项卡上，选择**环境变量**，然后选择**编辑**。
1. 选择**添加环境变量**。然后，输入以下每个环境变量的指定**密钥**和**值**。
+ **密钥**：**DestinationBucket** **值**：**amzn-s3-demo-destination-bucket1**
此值是您在[步骤 1](#batchops-s3-step1) 中创建的输出媒体文件的 S3 存储桶。
+ **密钥**：**MediaConvertRole** **值**：**arn:aws:iam::*111122223333*:role/tutorial-mediaconvert-role**
此值是您在[步骤 2](#batchops-s3-step2) 中创建的 MediaConvert IAM 角色 ARN。） 确保用 IAM 角色的实际 ARN 替换此 ARN。
+ **密钥**：**Application** **值**：**Batch-Transcoding**
此值是您的应用程序的名称。
1. 选择**保存**。
1. （可选）在**配置**选项卡上，在左侧导航窗格的**常规配置**部分中，选择**编辑**。在**超时**字段中，输入 **2** 分钟 **0** 秒。然后，选择**保存**。
**超时** –是Lambda允许函数在停止调用之前为调用运行的时长。默认值为 3 秒。定价基于配置的内存量和代码运行的时间量。有关更多信息，请参阅 [AWS Lambda 定价](https://aws.amazon.com/lambda/pricing/?icmpid=docs_console_unmapped)。
## 步骤 5：为 S3 源存储桶配置 Amazon S3 清单
设置 Lambda 函数转码后，创建 S3 Batch Operation 以转码一组视频。首先，您需要您希望 S3 批量操作对其运行指定转码操作的输入视频对象列表。要获取输入视频对象列表，您可以为 S3 源存储桶生成 S3 清单报告（例如 `amzn-s3-demo-source-bucket`)。
**Topics**
+ [为输入视频的 S3 清单报告创建和配置存储桶](#batchops-s3-step5-bucket)
+ [为 S3 视频源存储桶配置 Amazon S3 清单](#batchops-s3-step5-inventory)
+ [检查 S3 视频源存储桶清单报告](#batchops-s3-step5-manifest)
### 为输入视频的 S3 清单报告创建和配置存储桶
要存储列出 S3 源存储桶对象的 S3 清单报告，请创建 S3 清单目标存储桶，然后为存储桶配置存储桶策略，将清单文件写入 S3 源存储桶。
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**存储桶**。
1. 选择**创建存储桶**。
1. 对于 **Bucket Name（存储桶名称）**，输入您的存储桶的名称（例如 `amzn-s3-demo-destination-bucket2`）。
1. 对于 **AWS 区域**，选择要中放置存储桶的 AWS 区域。
目标存储桶必须位于与您为其设置 S3 清单存储桶相同的 AWS 区域 中。清单目标存储桶可处于不同的 AWS 账户中。
1. 在**阻止此存储桶的公有访问设置**中，保留默认设置（已启用**阻止*全部*公有访问**）。
1. 对于其余设置，保留默认值。
1. 选择 **Create bucket**（创建存储桶）。
1. 在**存储桶**列表中，选择刚刚创建的存储桶名称（例如，`amzn-s3-demo-destination-bucket2`）。
1. 要授予 Amazon S3 将清单报告的数据写入 S3 清单目标存储桶的权限，您可选择**权限**选项卡。
1. 向下滚动到**存储桶策略**部分，然后选择**编辑**。**存储桶策略**页面随即打开。
1. 要授予 S3 清单的权限，请在**策略**字段中，粘贴以下存储桶策略。
将三个示例值替换为以下值：
+ 您为存储库存报告创建的存储桶名称（例如，`amzn-s3-demo-destination-bucket2`)。
+ 存储输入视频的源存储桶名称（例如，`amzn-s3-demo-source-bucket`)。
+ 您用于创建 S3 视频源存储桶的 AWS 账户 ID（例如，`111122223333`）。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"InventoryAndAnalyticsExamplePolicy",
"Effect":"Allow",
"Principal": {"Service": "s3.amazonaws.com"},
"Action":"s3:PutObject",
"Resource":["arn:aws:s3:::amzn-s3-demo-destination-bucket2/*"],
"Condition": {
"ArnLike": {
"aws:SourceArn": "arn:aws:s3:::amzn-s3-demo-source-bucket"
},
"StringEquals": {
"aws:SourceAccount": "111122223333",
"s3:x-amz-acl": "bucket-owner-full-control"
}
}
}
]
}
```
------
1. 选择 **Save changes（保存更改）**。
### 为 S3 视频源存储桶配置 Amazon S3 清单
若要生成视频对象和元数据的平面文件列表，您必须为 S3 视频源存储桶配置 S3 清单。这些计划清单可以包括存储桶中的所有对象，或者按共享前缀分组的对象。在本教程中，S3 清单报告包含 S3 源存储桶中的所有视频对象。
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**存储桶**。
1. 要配置 S3 源存储桶中输入视频的 S3 清单报告，请在**存储桶**列表中，选择 S3 源存储桶的名称（例如，`amzn-s3-demo-source-bucket`)。
1. 选择**管理**选项卡。
1. 向下滚动到**清单配置**部分，然后选择**创建清单配置**。
1. 对于**清单配置名称**，输入名称（例如，**tutorial-inventory-config**)。
1. 对于本教程，在**清单范围**下，为**对象版本**选择**仅限当前版本**，并将其它**清单范围**设置保留为默认值。
1. 在**报告详细信息**下，对于**目标存储桶**，选择**此账户**。
1. 对于**目的地**，选择**浏览 S3**，然后选择您在上面创建的目标存储桶，以将库存报告保存到其中（例如，`amzn-s3-demo-destination-bucket2`)。然后，选择**选择路径**。
目标存储桶必须位于与您为其设置 S3 清单存储桶相同的 AWS 区域 中。清单目标存储桶可处于不同的 AWS 账户中。
在**目标**存储桶字段下**目标存储桶权限)**添加到目标存储桶策略中允许 Amazon S3 在该存储桶中放置数据。有关更多信息，请参阅 [创建目标存储桶策略](configure-inventory.md#configure-inventory-destination-bucket-policy)。
1. 在 **频率**下，选择**每天**。
1. 为**输出格式**选择 **CSV**。
1. 对于**状态**，选择**已启用**。
1. 在**服务器端加密**部分下，对于本教程选择**禁用**。
有关更多信息，请参阅 [使用 S3 控制台配置清单](configure-inventory.md#configure-inventory-console) 和 [向 Amazon S3 授予权限以使用客户自主管理型密钥进行加密](configure-inventory.md#configure-inventory-kms-key-policy)。
1. 在**其他字段 - *可选***部分中，选择**大小**、**上次修改**和**存储类**。
1. 选择**创建**。
有关更多信息，请参阅 [使用 S3 控制台配置清单](configure-inventory.md#configure-inventory-console)。
### 检查 S3 视频源存储桶清单报告
在清单列表发布后，清单文件将发送到 S3 清单目标存储桶。
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**存储桶**。
1. 在**存储桶**列表中，选择视频源存储桶的名称（例如，`amzn-s3-demo-source-bucket`)。
1. 选择**管理**。
1. 要查看 S3 清单报告是否准备好，以便您在[步骤 7](#batchops-s3-step7) 中创建 S3 Batch Operation 任务，则在**清单配置**下，检查是否启用**从清单创建任务**按钮。
**注意**
交付第一份清单报告可能需要最多 48 小时。如果**从清单创建任务**按钮处于禁用状态，则第一个清单报告尚未送达。等到第一个清单报告交付，并且**从清单创建任务**按钮在创建[步骤 7](#batchops-s3-step7)中的 S3 Batch Operation 任务之前已启用。
1. 要检查 S3 清单报告（`manifest.json`），在**目标**列中，选择您在前面创建的用于存储库存报告的库存目标存储桶名称（例如，`amzn-s3-demo-destination-bucket2`)。
1. 在**对象**选项卡上，选择具有 S3 源存储桶名称的现有文件夹（例如，`amzn-s3-demo-source-bucket`)。然后选择之前创建库存配置时在**清单配置名称**中输入的名称（例如，**tutorial-inventory-config**)。
您可以查看以报告生成日期作为其名称的文件夹列表。
1. 要检查某一日期的每日 S3 清单报告，请选择带相应生成日期名称的文件夹，然后选择 `manifest.json`。
1. 要查看特定日期库存报告的详细信息，请在 **manifest.json** 页面上，选择**下载**或**打开**。
## 步骤 6：为 S3 批量操作创建 IAM 角色
要使用 S3 Batch Operation 执行批处理转码，您必须首先创建 IAM 角色，让 Amazon S3 拥有执行 S3 批处理操作的权限。
**Topics**
+ [为 S3 批量操作创建 IAM 策略](#batchops-s3-step6-policy)
+ [创建 S3 Batch Operations IAM 角色并附加权限策略。](#batchops-s3-step6-role)
### 为 S3 批量操作创建 IAM 策略
您必须创建 IAM 策略，为 S3 Batch Operation 授予读取输入清单、调用 Lambda 函数以及编写 S3 Batch Operation 任务完成报告的权限。
1. 登录 AWS 管理控制台，然后通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。
1. 在左侧导航窗格中，选择 **Policies（策略）**。
1. 选择**创建策略**。
1. 选择 **JSON** 选项卡。
1. 在 **JSON** 文本字段中，粘贴以下 JSON 策略。
在 JSON 策略中，将四个示例值替换为以下值：
+ 存储输入视频的源存储桶名称（例如，`amzn-s3-demo-source-bucket`)。
+ 您在[步骤 5](#batchops-s3-step5) 中创建以存储 `manifest.json` 文件的清单目标存储桶名称（例如，`amzn-s3-demo-destination-bucket2`)。
+ 您在[步骤 1](#batchops-s3-step1) 中创建以存储输出媒体文件的存储桶名称（例如，`amzn-s3-demo-destination-bucket1`)。在本教程中，我们将任务完成报告存储在输出媒体文件的目标存储桶中。
+ 您在[步骤 4](#batchops-s3-step4) 中创建的 Lambda 函数的角色 ARN。要查找并复制 Lambda 函数的角色 ARN，请执行以下操作：
+ 在新浏览器选项卡中，打开 [https://console.aws.amazon.com/lambda/home#/functions](https://console.aws.amazon.com/lambda/home#/functions) 中的 Lambda 控制台上的**函数**页面。
+ 在**函数**列表中，选择在[步骤 4](#batchops-s3-step4) 中创建的 Lambda 函数（例如，**tutorial-lambda-convert**)。
+ 选择**复制 ARN**。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "S3Get",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-source-bucket/*",
"arn:aws:s3:::amzn-s3-demo-destination-bucket2/*"
]
},
{
"Sid": "S3PutJobCompletionReport",
"Effect": "Allow",
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket1/*"
},
{
"Sid": "S3BatchOperationsInvokeLambda",
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:us-west-2:111122223333:function:tutorial-lambda-convert"
]
}
]
}
```
------
1. 选择**下一步：标签**。
1. 选择**下一步：审核**。
1. 在**名称**字段中，输入 **tutorial-s3batch-policy**。
1. 选择**创建策略**。
### 创建 S3 Batch Operations IAM 角色并附加权限策略。
1. 登录 AWS 管理控制台，然后通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。
1. 在左侧导航窗格中，选择**角色**，然后选择**创建角色**。
1. 选择 **AWS 服务** 角色类型，然后选择 **S3** 服务。
1. 在**选择您的用例**中，选择 **S3 批量操作**。
1. 选择**下一步**。
1. 在**附加权限**下，在搜索框中输入您以前创建的 IAM 策略的名称（例如 **tutorial-s3batch-policy**），以筛选策略列表。选中策略名称旁边的复选框（例如，**tutorial-s3batch-policy**)。
1. 选择**下一步**。
1. 对于 **Role name（角色名称）**，输入 **tutorial-s3batch-role**。
1. 选择 **Create role（创建角色）**。
创建 S3 批量操作的 IAM 角色后，以下信任策略将自动附加到该角色。此信任策略允许 S3 批量操作服务主体担任 IAM 角色。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Principal":{
"Service":"batchoperations.s3.amazonaws.com"
},
"Action":"sts:AssumeRole"
}
]
}
```
------
## 步骤 7：设置并运行 S3 批量操作任务
要创建 S3 批量操作任务以处理 S3 源存储桶中的输入视频，您必须为此特定任务指定参数。
**注意**
在开始创建 S3 批量操作任务之前，请确保启用**从清单创建任务**按钮。有关更多信息，请参阅 [检查 S3 视频源存储桶清单报告](#batchops-s3-step5-manifest)。如果**从清单创建任务**按钮处于禁用状态，则第一个清单报告尚未送达，您必须等到启用该按钮。在[步骤 5](#batchops-s3-step5) 中为 S3 源存储桶配置 Amazon S3 清单后，交付第一个清单报告可能需要最长 48 小时。
**Topics**
+ [创建 S3 批量操作任务](#batchops-s3-step7-create-job)
+ [运行 S3 批量操作任务以调用 Lambda 函数](#batchops-s3-step7-run-job)
+ [（可选）检查您的完成报告](#batchops-s3-step7-check-report)
+ [（可选）在 Lambda 控制台中监控每个 Lambda 调用](#batchops-s3-step7-monitor-lambda)
+ [（可选）监控 MediaConvert 控制台中的每个 MediaConvert 视频转码任务](#batchops-s3-step7-monitor-mediaconvert)
### 创建 S3 批量操作任务
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**批量操作**。
1. 选择**创建任务**。
1. 对于 **AWS 区域**，选择要在其中创建任务的区域。
在本教程中，要使用 S3 批量操作任务调用 Lambda 函数，您必须在清单中引用的对象所在的 S3 视频源存储桶所在的同一区域中创建任务。
1. 在**清单** 部分中执行以下操作：
1. 对于 **Manifest format**（清单格式），选择 **S3 清单报告 (manifest.json)**。
1. 针对**清单对象**，选择**浏览 S3**查找您在[步骤 5](#batchops-s3-step5) 中创建用于存储清单报告的存储桶（例如，`amzn-s3-demo-destination-bucket2`)。在**清单对象**页面中，浏览对象名称直到找到特定日期的 `manifest.json` 文件。此文件列出了有关要批量转码的所有视频的信息。当您找到要使用的 `manifest.json` 文件之后，选择旁边的选项按钮。然后，选择**选择路径**。
1. （可选）对于**清单对象版本 ID - *可选***，如果您希望使用其他版本而不是最新版本，则输入清单对象的版本 ID。
1. 选择**下一步**。
1. 要使用 Lambda 函数来转码选定 `manifest.json` 文件中列出的所有对象，在**操作类型**中，选择**调用 AWS Lambda 函数**。
1. 在**调用 Lambda 函数**部分中，执行以下操作：
1. 选择**从账户中的函数选择**。
1. 对于 **Lambda 函数**，选择您在[步骤 4](#batchops-s3-step4) 中创建的 Lambda 函数（例如，**tutorial-lambda-convert**)。
1. 对于 **Lambda 函数版本**，请保留默认值 **\$1LATEST**。
1. 选择**下一步**。**配置其它选项**页面随即打开。
1. 在**其他选项**部分下，请保留默认设置。
有关这些选项的详细信息，请参阅[批量操作任务请求元素](batch-ops-create-job.md#batch-ops-create-job-request-elements)。
1. 在**完成报告**部分，对于**完成报告目的地的路径**，选择**浏览 S3**。查找您在[步骤 1](#batchops-s3-step1) 中创建以存储输出媒体文件的存储桶名称（例如，`amzn-s3-demo-destination-bucket1`)。选择该存储桶名称旁边的选项按钮。然后，选择**选择路径**。
对于其余的**完成报告**设置，请保留默认值。有关完成报告设置的更多信息，请参阅 [批量操作任务请求元素](batch-ops-create-job.md#batch-ops-create-job-request-elements)。完成报告维护任务详细信息和执行的操作的记录。
1. 在**权限**部分下，选择**从现有 IAM 角色中进行选择**。对于 **IAM 角色**，选择您在[步骤 6](#batchops-s3-step6) 中创建的 S3 批量操作任务的 IAM 角色（例如，**tutorial-s3batch-role**)。
1. 选择**下一步**。
1. 在**审阅**页面上，检查您的设置。然后选择**创建任务**。
S3 读取 S3 批量操作任务清单后，它会将任务的**状态**设为**等待确认运行**。要查看任务状态的更新，请刷新页面。直到任务状态为**等待确认运行**，您才可运行任务。
### 运行 S3 批量操作任务以调用 Lambda 函数
运行批量操作任务以调用 Lambda 函数进行视频转码。如果任务失败，您可以检查完成报告以确定原因。
**运行 S3 批量操作任务**
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**批量操作**。
1. 从**任务**列表中，在第一行上选择任务的**任务 ID**，这是之前创建的 S3 批量操作任务。
1. 选择**运行任务**。
1. 再次复核您的任务参数，并确认**清单中列出的对象总数**与清单中对象的数量相同。然后选择**运行任务**。
您的 S3 批量操作任务页面打开。
1. 任务开始运行后，在任务页面上的**状态**下，检查 S3 批量操作任务的进度，例如**状态**、**已完成百分比**、**成功总数（费率）**、**失败总数（速率）**、**终止日期**和**终止原因**。
S3 批量操作任务完成后，查看任务页面上的数据，确认已按预期完成任务。
如果在尝试超过 1,000 个操作后，超过 50% 的 S3 批量操作任务的对象操作失败，该任务将自动失败。要检查完成报告确定失败的原因，请使用下面的可选步骤。
### （可选）检查您的完成报告
您可以使用完成报告来确定哪些对象失败以及失败的原因。
**要检查完成报告以了解有关失败对象的详细信息**
1. 在 S3 批量操作任务的页面上，向下滚动至**完成报告**部分，然后选择**完成报告目标**下的链接。
S3 输出目标存储桶页面打开。
1. 在**对象**选项卡上，选择之前创建的 S3 批量操作务以任务 ID 名称结尾的文件夹。
1. 选择**结果/**。
1. 选中 `.csv` 文件旁边的复选框。
1. 要查看任务报告，请选择**打开**或者**下载**。
### （可选）在 Lambda 控制台中监控每个 Lambda 调用
S3 批量操作任务开始运行后，任务将为每个输入视频对象调用 Lambda 函数。S3 将每次 Lambda 调用的日志写入到 CloudWatch Logs。您可以使用 Lambda 控制台的监控控制面板来监控 Lambda 函数。
1. 通过 [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) 打开 AWS Lambda 控制台。
1. 在左侧导航窗格中，选择 **Functions（函数）**。
1. 在**函数**列表中，选择在[步骤 4](#batchops-s3-step4) 中创建的 Lambda 函数（例如，**tutorial-lambda-convert**)。
1. 选择**监控**选项卡。
1. 在**指标**下，请参阅 Lambda 函数的运行时间指标。
1. 在**日志**下，通过 CloudWatch Logs Insights 查看每个 Lambda 调用的日志数据。
**注意**
将 S3 批量操作与 Lambda 函数结合使用时，会在每个对象上调用 Lambda 函数。如果您的 S3 批量操作任务很大，可以同时调用多个 Lambda 函数，从而导致 Lambda 并发峰值。
对于每个区域，每个 AWS 账户 都有 Lambda 并发配额。有关更多信息，请参阅 *AWS Lambda 开发人员指南*中的 [AWS Lambda 函数扩展](https://docs.aws.amazon.com/lambda/latest/dg/invocation-scaling.html)。将 Lambda 函数与 S3 批量操作结合使用的最佳做法是对 Lambda 函数本身设置并发限制。设置并发限制会使您的任务不会占用大部分 Lambda 并发，并可能会限制您账户中的其他函数。有关更多信息，请参阅 *AWS Lambda 开发人员指南*中的[管理 Lambda 预留并发](https://docs.aws.amazon.com/lambda/latest/dg/configuration-concurrency.html)。
### （可选）监控 MediaConvert 控制台中的每个 MediaConvert 视频转码任务
MediaConvert 任务执行转换媒体文件的工作。当您的 S3 批量操作任务为每个视频调用 Lambda 函数时，每个 Lambda 函数调用都会为每个输入视频创建一个 MediaConvert 转码任务。
1. 登录到 AWS 管理控制台，然后在 [https://console.aws.amazon.com/mediaconvert/](https://console.aws.amazon.com/mediaconvert/) 打开 MediaConvert 控制台。
1. 如果显示 MediaConvert 介绍页面，请选择**开始**。
1. 从**任务**列表中，查看每行以监控每个输入视频的转码任务。
1. 确定要检查的任务行，然后选择**任务 ID** 链接打开任务详细信息页面。
1. 在**任务摘要**页面，在**输出**中，根据浏览器支持的内容，选择 HLS、MP4 或缩略图输出的链接，转到输出媒体文件的 S3 目标存储桶。
1. 在 S3 输出目标存储桶的相应文件夹（HLS、MP4 或缩略图）中，选择输出媒体文件对象的名称。
将打开对象的详细信息页面。
1. 在对象的详细信息页面上，在**对象概述**中，选择**对象 URL** 下的链接观看转码输出媒体文件。
## 步骤 8：检查 S3 目标存储桶中的输出媒体文件
**若要从 S3 目标存储桶检查输出媒体文件**
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**存储桶**。
1. 从**存储桶**列表中，选择您在[步骤 1](#batchops-s3-step1) 中创建的输出媒体文件的 S3 目标存储桶名称（例如，`amzn-s3-demo-destination-bucket1`)。
1. 在**对象**选项卡上，每个输入视频都有一个带输入视频名称的文件夹。每个文件夹都包含输入视频的转码输出媒体文件。
要检查输出媒体文件中的输入视频，请执行以下操作：
1. 选择要检查的输入视频名称文件夹。
1. 选择**Default/**文件夹。
1. 选择转码格式的文件夹（本教程中的 HLS、MP4 或缩略图）。
1. 选择输出媒体文件的名称。
1. 要观看转码后的文件，在对象的详细信息页面上，选择**对象 URL** 下的链接。
HLS 格式的输出媒体文件被拆分为短段。要播放这些视频，您需要嵌入 `.m3u8` 文件的对象 URL 在兼容的播放器中。
## 步骤 9：清除
如果您只使用 S3 批量操作、Lambda 和 MediaConvert 转码视频作为学习练习，请删除 AWS 您分配的资源，以免继续产生费用。
**Topics**
+ [删除 S3 源存储桶的 S3 清单配置](#batchops-s3-step9-delete-inventory)
+ [删除 Lambda 函数](#batchops-s3-step9-delete-lambda)
+ [删除 CloudWatch 日志组](#batchops-s3-step9-delete-cw)
+ [删除 IAM 角色以及 IAM 角色的内联策略](#batchops-s3-step9-delete-role)
+ [删除客户管理型 IAM 策略](#batchops-s3-step9-delete-policy)
+ [清空 S3 存储桶](#batchops-s3-step9-empty-bucket)
+ [删除 S3 存储桶](#batchops-s3-step9-delete-bucket)
### 删除 S3 源存储桶的 S3 清单配置
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**存储桶**。
1. 在**存储桶**列表中，选择您的源存储桶名称（例如，`amzn-s3-demo-source-bucket`)。
1. 选择**管理**选项卡。
1. 在**清单配置**部分中，选择您在[步骤 5](#batchops-s3-step5) 中创建的清单配置旁边的选项按钮（例如，**tutorial-inventory-config**)。
1. 选择**删除**，然后选择**确认**。
### 删除 Lambda 函数
1.
通过 [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) 打开 AWS Lambda 控制台。
1. 在左侧导航窗格中，选择 **Functions（函数）**。
1. 选择在[步骤 4](#batchops-s3-step4) 中创建的函数旁边的复选框（例如，**tutorial-lambda-convert**)。
1. 选择**操作**，然后选择**删除**。
1. 在**删除函数**对话框中，选择**删除**。
### 删除 CloudWatch 日志组
1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 CloudWatch 控制台。
1. 在左侧导航窗格中，选择**日志**，然后选择**日志组**。
1. 选中日志组旁边的复选框，该复选框的名称以在[步骤 4](#batchops-s3-step4) 中创建的 Lambda 函数结尾（例如，**tutorial-lambda-convert**)。
1. 选择**操作**，然后选择**删除日志组**。
1. 在**删除日志组**对话框中，选择**删除**。
### 删除 IAM 角色以及 IAM 角色的内联策略
删除您在[步骤 2](#batchops-s3-step2)、[步骤 3](#batchops-s3-step3) 和[步骤 6](#batchops-s3-step6) 中创建的 IAM 角色，执行以下操作：
1. 登录 AWS 管理控制台，然后通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。
1. 在左侧导航窗格中，选择**角色**，然后选中要删除的角色名称旁的复选框。
1. 在页面的顶部，选择**删除**。
1. 在确认对话框中，根据提示在文本输入字段中输入所需的响应，然后选择**删除**。
### 删除客户管理型 IAM 策略
若要删除您在[步骤 6](#batchops-s3-step6) 中创建的客户托管 IAM 策略，执行以下操作：
1. 登录 AWS 管理控制台，然后通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。
1. 在左侧导航窗格中，选择 **Policies（策略）**。
1. 选择您在[步骤 6](#batchops-s3-step6) 中创建的策略旁边的选项按钮（例如，**tutorial-s3batch-policy**)。您可以使用搜索框筛选策略列表。
1. 选择 **Actions**，然后选择 **Delete**。
1. 在文本字段中输入名称，确认您要删除的策略，然后选择**删除**。
### 清空 S3 存储桶
若要清空您在[先决条件](#batchops-s3-prerequisites)、[步骤 1](#batchops-s3-step1) 和[步骤 5](#batchops-s3-step5) 中创建的 S3 存储桶，执行以下操作：
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**存储桶**。
1. 在**存储桶**列表中，选择要清空的存储桶名称旁边的选项图标，然后选择**清空**。
1. 在**清空存储桶**页面上，通过在文本字段中输入 **permanently delete** 来确认要清空存储桶，然后选择**清空**。
### 删除 S3 存储桶
若要删除您在[先决条件](#batchops-s3-prerequisites)、[步骤 1](#batchops-s3-step1) 和[步骤 5](#batchops-s3-step5) 中创建的 S3 存储桶，执行以下操作：
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**存储桶**。
1. 在**存储桶**列表中，选择要删除的存储桶名称旁边的选项按钮。
1. 选择**删除**。
1. 在**删除存储桶**页面上，通过在文本字段中输入存储桶名称来确认要删除存储桶，然后选择**删除存储桶**。
## 后续步骤
完成本教程后，您可以进一步探索其他相关使用案例：
+ 您可以使用 Amazon CloudFront 将转码后的媒体文件流式传输到全球各地的查看者。有关更多信息，请参阅 [教程：使用 Amazon S3、Amazon CloudFront 和 Amazon Route 53 托管点播流视频](tutorial-s3-cloudfront-route53-video-streaming.md)。
+ 将视频上传到 S3 源存储桶时，您可以对视频进行转码。为此，您可以配置 Amazon S3 事件触发器，该触发器自动调用 Lambda 函数以使用 MediaConvert 转码 S3 中的新对象。有关更多信息，请参阅 *AWS Lambda 开发人员指南*中的[教程：使用 Amazon S3 触发器调用 Lambda函数](https://docs.aws.amazon.com/lambda/latest/dg/with-s3-example.html)。
# 排查 S3 批量操作问题
Amazon S3 批量操作可让您对 Amazon S3 对象执行大规模操作。本指南有助于排查您可能遇到的常见问题。
要排查 S3 批量复制的问题，请参阅[对复制进行问题排查](replication-troubleshoot.md)。
导致批量操作错误的失败主要有两种类型：
1. **API 失败**：所请求的 API（例如 `CreateJob`）执行失败。
1. **作业失败**：初始 API 请求获得成功但作业失败，例如，由于清单或在清单中指定的对象的权限存在问题。
## NoSuchJobException
**类型：**API 失败
当 S3 批量操作找不到指定的作业时，就会发生 `NoSuchJobException`。除了简单的作业到期之外，还可能在多种情况下发生此错误。常见原因包括以下各项：
1. **作业到期**：作业在达到终止状态（`Complete`、`Cancelled` 或 `Failed`）的 90 天后自动被删除。
1. **作业 ID 不正确**：`DescribeJob` 或 `UpdateJobStatus` 中使用的作业 ID 与 `CreateJob` 返回的 ID 不匹配。
1. **错误的区域**：尝试访问的作业所在的区域与创建该作业的区域不同。
1. **账户错误**：使用其它 AWS 账户中的作业 ID。
1. **作业 ID 格式错误**：作业 ID 中存在拼写错误、多余字符或格式不正确。
1. **计时问题**：在完全注册作业之前，在创建后立即检查作业状态。
相关错误消息包括以下各项。
1. `No such job`
1. `The specified job does not exist`
### 防止 `NoSuchJobException` API 失败的最佳实践
1. **立即存储作业 ID**：在进行后续的 API 调用之前，先保存 `CreateJob` 响应中的作业 ID。
1. **实现重试逻辑**：在创建作业后立即检查作业状态时添加指数回退。
1. **设置监控**：创建 CloudWatch 警报以跟踪作业在 90 天到期之前的完成情况。有关详细信息，请参阅《Amazon CloudWatch 用户指南》中的[使用 Amazon CloudWatch 警报](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html)。
1. **使用一致的区域**：确保所有作业操作使用与创造作业相同的区域。
1. **验证输入**：在进行 API 调用之前检查作业 ID 格式。
### 作业何时到期
处于终止状态的作业将在 90 天后被自动删除。为避免丢失作业信息，请考虑以下事项。
1. **在到期前下载完成报告**：有关检索和存储作业结果的说明，请参阅[ 完成报告 在创建任务时，您可以请求完成报告。只要 S3 批量操作成功调用至少一项工作，Amazon S3 便会在任务完成运行工作、失败或被取消后生成完成报告。可对完成报告进行配置，以包含所有任务或只包含失败的任务。 完成报告包含任务配置、状态以及每项工作的信息，包括对象键和版本、状态、错误代码以及有关任何错误的描述。完成报告提供了以合并格式查看任务结果的简单途径，且无需进行任何附加设置。完成报告使用具有 Amazon S3 托管式密钥的服务器端加密（SSE-S3）来进行加密。有关完成报告的示例，请参阅 [示例：S3 分批操作完成报告](batch-ops-examples-reports.md)。 如果您未配置完成报告，则仍可使用 CloudTrail 和 Amazon CloudWatch 监控并审计您的任务及其各项工作。有关更多信息，请参阅以下主题： ](batch-ops-job-status.md#batch-ops-completion-report.title)。
1. **在您自己的系统中归档作业元数据**：将关键的作业信息存储在数据库或监控系统中。
1. **设置 90 天截止日期之前的自动通知**：使用 Amazon EventBridge 创建在作业完成时触发通知的规则。有关更多信息，请参阅 [Amazon S3 事件通知](EventNotifications.md)。
### `NoSuchJobException` 故障排除
1. 使用以下命令验证作业是否存在于您的账户和区域中。
```
aws s3control list-jobs --account-id 111122223333 --region us-east-1
```
1. 使用以下命令在所有作业状态间进行搜索。可能的作业状态包括 `Active`、`Cancelled`、`Cancelling`、`Complete`、`Completing`、`Failed`、`Failing`、`New`、`Paused`、`Pausing`、`Preparing`、`Ready`、和 `Suspended`。
```
aws s3control list-jobs --account-id 111122223333 --job-statuses your-job-status
```
1. 使用以下命令检查作业是否存在于您通常创建作业的其它区域中。
```
aws s3control list-jobs --account-id 111122223333 --region job-region-1 aws s3control list-jobs --account-id 111122223333 --region job-region-2
```
1. 验证作业 ID 格式。作业 ID 通常包含 36 个字符，例如 `12345678-1234-1234-1234-123456789012`。检查是否有多余的空格、缺少字符或是否存在区分大小写问题，并验证您使用的是 `CreateJob` 命令返回的完整作业 ID。
1. 使用以下命令检查 CloudTrail 日志中是否存在作业创建事件。
```
aws logs filter-log-events --log-group-name CloudTrail/S3BatchOperations \ --filter-pattern "{ $.eventName = CreateJob }" \ --start-time timestamp
```
### AccessDeniedException
**类型：**API 失败
由于权限不足、操作不受支持或策略限制而阻止 S3 批量操作请求时，就会发生 `AccessDeniedException`。这是批量操作中最常见的错误之一。它具有以下常见原因：
1. **缺少 IAM 权限**：IAM 身份缺少批量操作 API 所需的权限。
1. **S3 权限不足**：缺少访问源或目标存储桶和对象的权限。
1. **作业执行角色问题**：作业执行角色缺少执行指定操作的权限。
1. **操作不受支持**：尝试使用当前区域或存储桶类型不支持的操作。
1. **跨账户访问问题**：缺少跨账户访问存储桶或对象的权限。
1. **基于资源的策略限制**：存储桶策略或对象 ACL 阻止操作。
1. **服务控制策略（SCP）限制**：组织级策略阻止操作。
相关错误消息：
1. `Access Denied`
1. `User: arn:aws:iam::account:user/username is not authorized to perform: s3:operation`
1. `Cross-account pass role is not allowed`
1. `The bucket policy does not allow the specified operation`
#### 防止 AccessDeniedException API 失败的最佳实践
1. **使用最低权限原则**：仅授予特定操作所需的最小权限。
1. **在大型作业之前测试权限**：在处理成千上万个对象之前，运行小型测试作业来验证权限。
1. **使用 IAM 策略模拟器**：在部署之前使用 IAM 策略模拟器测试策略。有关更多信息，请参阅《IAM 用户指南》中的[使用 IAM 策略模拟器测试 IAM 策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_testing-policies.html)。
1. **实施正确的跨账户设置**：检查您的跨账户访问配置以了解跨账户作业配置。有关更多信息，请参阅《IAM 用户指南》中的 [IAM 教程：使用 IAM 角色委托跨 AWS 账户的访问权限](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html)。
1. **监控权限变更**：针对可能影响批量操作的 IAM 策略修改设置 CloudTrail 提醒。
1. **记录角色要求**：清晰地记录每种作业类型的所需权限。
1. **使用常用权限模板**：使用权限示例和策略模板：
1. [授予批处理操作的权限](batch-ops-iam-role-policies.md)
1. 《IAM 用户指南》中的 [IAM 中的跨账户资源](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html)。
1. 《AWS PrivateLink Guide》中的 [Control access to VPC endpoints using endpoint policies](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html)。
#### AccessDeniedException 故障排除
按照以下步骤系统化地识别和解决权限问题。
1. 查看 [S3 分批操作支持的操作](batch-ops-operations.md)以了解按区域支持的操作。确认目录存储桶操作仅适用于区域端点和可用区端点。验证存储桶的存储类别支持该操作。
1. 使用以下命令确定您是否可以列出作业。
```
aws s3control list-jobs --account-id 111122223333
```
1. 使用以下命令检查请求身份的 IAM 权限。运行作业的账户需要以下权限：`s3:CreateJob`、`s3:DescribeJob`、`s3:ListJobs`、`s3:UpdateJobPriority`、`s3:UpdateJobStatus` 和 `iam:PassRole`。
```
aws sts get-caller-identity 111122223333
```
1. 使用以下命令检查角色是否存在以及是否可代入。
```
aws iam get-role --role-name role-name
```
1. 使用以下命令查看角色的信任策略。运行作业的角色必须具有以下各项：
1. 可让 `batchoperations.s3.amazonaws.com` 代入此角色的信任关系。
1. 批量操作正在执行的操作（例如，对于标记操作为 `s3:PutObjectTagging`）。
1. 对源存储桶和目标存储桶的访问权限。
1. 读取清单文件的权限。
1. 写入完成报告的权限。
```
aws iam get-role --role-name role-name --query 'Role.AssumeRolePolicyDocument'
```
1. 使用以下命令可测试对清单和源存储桶的访问权限。
```
aws s3 ls s3://amzn-s3-demo-bucket
```
1. 测试批量操作正在执行的操作。例如，如果批量操作执行标记操作，则在源存储桶中为示例对象添加标签。
1. 查看存储桶策略，以了解是否存在可能拒绝该操作的策略。
1. 如果使用旧版访问控制，请检查对象 ACL。
1. 验证没有服务控制策略（SCP）阻止该操作。
1. 如果使用 VPC 端点，请确认 VPC 端点策略支持批量操作。
1. 通过以下命令使用 CloudTrail 来识别权限故障。
```
aws logs filter-log-events --log-group-name CloudTrail/S3BatchOperations \
--filter-pattern "{ $.errorCode = AccessDenied }" \
--start-time timestamp
```
#### SlowDownError
**类型：**API 失败
当您的账户超过 S3 批量操作 API 的请求速率限制时，就会出现 `SlowDownError` 异常。这是一种节流机制，旨在防止服务因请求过多而不堪重负。它具有以下常见原因：
1. **API 请求频率高**：在短时间内进行过多的 API 调用。
1. **并行作业操作**：多个应用程序或用户同时创建/管理作业。
1. **没有速率限制的自动化脚本**：未实施正确的回退策略的脚本。
1. **过于频繁地轮询作业状态**：检查作业状态的频率超出所需程度。
1. **突增流量模式**：在高峰处理时段，API 使用量突然激增。
1. **区域容量限制**：超过您的区域的已分配请求容量。
相关错误消息：
1. `SlowDown`
1. `Please reduce your request rate`
1. `Request rate exceeded`
#### 防止 SlowDownError API 失败的最佳实践
1. **实施客户端速率限制**：在应用程序中的 API 调用之间添加延迟。
1. **使用指数回退以及抖动**：随机化重试延迟，以避免出现惊群效应问题。
1. **设置正确的重试逻辑**：实施自动重试，并增加瞬态错误的延迟。
1. **使用事件驱动的架构**：将轮询替换为有关作业状态更改的 EventBridge 通知。
1. **跨时间分配负载**：将作业创建和状态检查错开在不同的时间段内进行。
1. **监控速率限制并发出提醒**：设置 CloudWatch 警报以便在接近限制时进行检测。
大多数 AWS SDK 都包含针对速率限制错误的内置重试逻辑。按如下所示对它们进行配置：
1. **AWS CLI**：使用 `cli-read-timeout` 和 `cli-connect-timeout` 参数。
1. **适用于 Python 的 AWS SDK（Boto3）**：在客户端配置中配置重试模式和最大尝试次数。
1. **适用于 Java 的 AWS SDK**：使用 `RetryPolicy` 和 `ClientConfiguration` 设置。
1. **适用于 JavaScript 的 AWS SDK**：配置 `maxRetries` 和 `retryDelayOptions`。
有关重试模式和最佳实践的更多信息，请参阅《AWS Prescriptive Guidance》指南中的 [Retry with backoff pattern](https://docs.aws.amazon.com/prescriptive-guidance/latest/cloud-design-patterns/retry-backoff.html)。
#### SlowDownError 故障排除
1. 在代码中立即实现指数回退。
**Example ：bash 中的指数回退**
```
for attempt in {1..5}; do
if aws s3control describe-job --account-id 111122223333 --job-id job-id; then
break
else
wait_time=$((2**attempt)) echo "Rate limited, waiting ${wait_time} seconds..." sleep $wait_time
fi
done
```
1. 使用 CloudTrail 来识别高请求量的源。
```
aws logs filter-log-events \
--log-group-name CloudTrail/S3BatchOperations \
--filter-pattern "{ $.eventName = CreateJob || $.eventName = DescribeJob }" \
--start-time timestamp \
--query 'events[*].[eventTime,sourceIPAddress,userIdentity.type,eventName]'
```
1. 查看轮询频率。
1. 对于处于活动状态的作业，请避免检查作业状态的频率超过每 30 秒一次。
1. 尽可能使用作业完成通知而非轮询。
1. 在轮询间隔中实施抖动，以避免同步的请求。
1. 优化 API 使用模式。
1. 如果可能，请批量执行多个操作。
1. 使用 `ListJobs` 在一次调用中获取多个作业的状态。
1. 缓存作业信息以减少冗余的 API 调用。
1. 将作业创建操作分散到不同的时间，而不是同时创建许多作业。
1. 针对 API 调用使用 CloudWatch 指标来监控请求模式。
```
aws logs put-metric-filter \
--log-group-name CloudTrail/S3BatchOperations \
--filter-name S3BatchOpsAPICallCount \
--filter-pattern "{ $.eventSource = s3.amazonaws.com && $.eventName = CreateJob }" \
--metric-transformations \
metricName=S3BatchOpsAPICalls,metricNamespace=Custom/S3BatchOps,metricValue=1
```
## InvalidManifestContent
**类型：**作业失败
当清单文件格式、内容或结构出现问题而导致 S3 批量操作无法处理作业时，就会出现 `InvalidManifestContent` 异常。它具有以下常见原因：
1. **格式违规**：缺少必需列、分隔符不正确或 CSV 结构的格式错误。
1. **内容编码问题**：字符编码、BOM 标记或非 UTF-8 字符不正确。
1. **对象键问题**：字符无效、URL 编码不正确或键超过长度限制。
1. **大小限制**：清单包含的对象数量超过了操作支持的数量。
1. **版本 ID 格式错误**：受版本控制的对象的版本 ID 无效或格式错误。
1. **ETag 格式问题**：ETag 格式不正确，或需要 ETag 的操作缺少引号。
1. **数据不一致**：同一个清单中具有混合格式或列计数不一致。
相关错误消息：
1. `Required fields are missing in the schema: + missingFields`
1. `Invalid Manifest Content`
1. `The S3 Batch Operations job failed because it contains more keys than the maximum allowed in a single job`
1. `Invalid object key format`
1. `Manifest file is not properly formatted`
1. `Invalid version ID format`
1. `ETag format is invalid`
### 防止 InvalidManifestContent 作业失败的最佳实践
1. **上传前验证**：在处理大型数据集之前，使用小型作业测试清单格式。
1. **使用一致的编码**：对于清单文件，始终使用无 BOM 的 UTF-8 编码。
1. **实施清单生成标准**：为创建清单操作创建模板和验证过程。
1. **正确地处理特殊字符**：对包含特殊字符的对象键进行 URL 编码。
1. **监控对象计数**：跟踪清单大小并主动拆分大型作业。
1. **验证对象存在**：在将对象包括在清单中之前，先验证对象是否存在。
1. **使用 AWS 工具生成清单**：利用 AWS CLI `s3api list-objects-v2` 生成格式正确的对象列表。
常见清单问题和解决方案：
1. **缺少必需列**：确保清单包含适用于操作类型的所有必需列。最常见的缺失列是 Bucket 和 Key。
1. **CSV 格式不正确**：使用逗号分隔符，确保所有行的列计数一致，并避免在字段中嵌入换行符。
1. **对象键中的特殊字符**：对包含空格、Unicode 字符或 XML 特殊字符（<、>、&、"、'）的对象键进行 URL 编码。
1. **大型清单文件**：将超过操作限制的清单拆分为多个较小的清单并创建单独的作业。
1. **版本 ID 无效**：确保版本 ID 是格式正确的字母数字字符串。如果不需要版本 ID 列，请将其移除。
1. **编码问题**：将清单文件另存为无 BOM 的 UTF-8。避免通过可能更改编码的系统来复制清单。
有关详细的清单格式规范和示例，请参阅以下内容：
1. [指定清单](batch-ops-create-job.md#specify-batchjob-manifest)
1. [S3 分批操作支持的操作](batch-ops-operations.md)
1. [为 Amazon S3 对象命名](object-keys.md)
### InvalidManifestContent 故障排除
1. 下载并检查清单文件。手动验证清单是否符合格式要求：
1. 使用逗号分隔符的 CSV 格式。
1. 无 BOM 的 UTF-8 编码。
1. 所有行的列数一致。
1. 没有空行或尾随空格。
1. 如果对象键包含特殊字符，已对对象键进行正确的 URL 编码。
使用以下命令下载作业清单文件。
```
aws s3 cp s3://amzn-s3-demo-bucket1/manifest-key ./manifest.csv
```
1. 检查您的操作所需的列：
1. 所有操作：`Bucket`、`Key`
1. 复制操作：`VersionId`（可选）
1. 还原操作：`VersionId`（可选）
1. 替换标签操作：无需其它列。
1. 替换 ACL 操作：无需其它列。
1. 启动还原：`VersionId`（可选）
1. 检查对象计数限制：
1. 复制：最多 10 亿个对象。
1. 删除：最多 10 亿个对象。
1. 还原：最多 10 亿个对象。
1. 添加标签：最多 10 亿个对象。
1. ACL：最多 10 亿个对象。
1. 使用原始清单中的几个对象创建测试清单。
1. 使用以下命令检查清单中的对象示例是否存在。
```
aws s3 ls s3://amzn-s3-demo-bucket1/object-key
```
1. 检查作业失败详细信息，并在作业描述中查看失败原因和任何特定错误详情。
```
aws s3control describe-job --account-id 111122223333 --job-id job-id
```