本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 使用 Batch Operations 大量執行物件操作
您可以使用 S3 批次作業對 Amazon S3 物件執行大規模的批次作業。S3 批次作業可以對您指定的 Amazon S3 物件清單執行單一作業。單一任務可在包含數 EB 資料的數以億計物件上執行指定的操作。Amazon S3 會追蹤進度、傳送通知，並存放所有動作的詳細完成報告，提供完整受管、可稽核、無伺服器的體驗。您可以透過 Amazon S3 主控台、 AWS Command Line Interface (AWS CLI)、 AWS SDKs 或 Amazon S3 REST API 使用 S3 批次操作。 Amazon S3
使用 S3 Batch Operations 複製物件、更新物件的伺服器端加密，以及設定物件標籤或存取控制清單 ACLs)。您也可以從 S3 Glacier Flexible Retrieval 啟動物件還原，或叫用 AWS Lambda 函數，以使用您的物件執行自訂動作。您可以對自訂物件清單執行這些操作，也可以使用 Amazon S3 庫存報告輕鬆產生物件清單。Amazon S3 Batch Operations 使用已與 Amazon S3 搭配使用的相同 Amazon S3 API 操作。
**注意**
如需將 Amazon S3 Express One Zone 儲存類別與目錄儲存貯體搭配使用的詳細資訊，請參閱 [S3 Express One Zone](directory-bucket-high-performance.md#s3-express-one-zone) 和 [使用目錄儲存貯體](directory-buckets-overview.md)。如需使用 Batch Operations 搭配 S3 Express One Zone 和目錄儲存貯體的詳細資訊，請參閱 [使用 Batch Operations 搭配目錄儲存貯體](directory-buckets-objects-Batch-Ops.md)。
## S3 批次作業基礎知識
您可以使用 S3 批次作業對 Amazon S3 物件執行大規模的批次作業。S3 批次作業可以對您指定的 Amazon S3 物件清單執行單一作業或動作。
### 術語
本節使用「資訊清單」**、「作業」**、「操作」**和「任務」**等術語，其定義如下：
**清單檔案**
清單檔案是 Amazon S3 物件，其中包含您希望 Amazon S3 採取行動的物件索引鍵。如果您想要建立 Batch Operations 作業，則必須提供資訊清單。使用者產生的資訊清單必須包含儲存貯體名稱、物件金鑰，也可選擇包含每個物件的物件版本。如果您提供使用者產生的資訊清單，則必須採用 Amazon S3 庫存清單報告或 CSV 檔案的形式。
您也可以讓 Amazon S3 根據您在建立作業時指定的物件篩選條件自動產生資訊清單。此選項適用於您使用 Amazon S3 主控台建立的批次操作任務，或您使用 AWS Command Line Interface (AWS CLI)、 AWS SDKs或 Amazon S3 REST API 建立的任何任務類型。
**任務 (Job)**
任務是 S3 批次作業的基本工作單位。任務包含所有針對資訊清單中所列出物件執行指定操作時的必要資訊。當您提供此資訊並請求開始任務後，任務會針對資訊清單中的每個物件執行操作。
**操作**
作業是您希望批次作業任務執行的 API [動作](https://docs.aws.amazon.com/AmazonS3/latest/API/API_Operations.html)類型，例如複製物件。每個任務會在資訊清單中指定的所有物件上執行單一類型的操作。
**任務**
任務 (task) 是任務 (job) 的執行單位。任務代表對 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 主控台來監控進度。您也可以設定任務，在其完成時產生完成報告。完成報告會描述任務 (job) 所執行的每個任務 (task) 結果。如需監控任務的詳細資訊，請參閱 [管理 S3 批次作業任務](batch-ops-managing-jobs.md)。
與 S3 Batch Operations 有相關聯的成本。您需要支付建立 Batch Operations 作業的費用，包括在完成之前取消的作業。如需詳細資訊，請參閱 [Simple Storage Service (Amazon S3) 定價](https://aws.amazon.com/s3/pricing/)。
根據預設，S3 Batch Operations 任務最多可以為所有操作處理 40 億個物件。具體而言，複製、物件標記、物件鎖定、叫用 AWS Lambda 函數和批次複寫任務最多可支援 200 億個物件。每個 AWS 帳戶僅限 6 個作用中的批次複寫任務。若要開始建立 Batch Operations 作業，請參閱[建立 S3 Batch Operations 作業](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-create-job.html)。
## S3 Batch Operations 教學課程
下列教學課程會針對部分批次操作工作，提供完整的端對端程序。
+ [教學課程：使用 S3 Batch Operations 進行影片的批次轉碼](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 政策元素：資源](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 Batch Operations 服務主體 (`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 Operations 的許可](batch-ops-job-tags-examples.md)和 [使用 S3 批次操作複製物件](batch-ops-examples-copy.md)。
在您的 IAM 政策中，您也可以使用條件金鑰來篩選 S3 批次操作任務的存取許可。如需詳細資訊以及 Amazon S3 特定條件索引鍵的完整清單，請參閱服務授權參考**中的 [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 物件`"kms:Decrypt"`和所有相關聯 CSV 資料檔案`"kms:GenerateDataKey"`的許可和 。
+ 如果批次操作任務在已啟用存取控制清單 (ACLs) 且位於不同 的儲存貯體中產生資訊清單 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/*"
]
}
]
}
```
------
### 使用 S3 產生的資訊清單複寫現有物件：InitiateReplication
如果您使用並儲存 S3 產生的資訊清單，請使用此政策。如需使用 Batch Operations 來複寫現有物件的詳細資訊，請參閱[使用批次複寫來複寫現有物件](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
如果您使用使用者提供的資訊清單，請使用此政策。如需使用 Batch Operations 來複寫現有物件的詳細資訊，請參閱[使用批次複寫來複寫現有物件](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`、`RestoreObject`、 `GetObjectVersion`和 `PutObject`
如果您嘗試搭配 S3 Batch Operations 使用**運算檢查總和**操作，請使用此政策。需要 `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/*"
]
}
]
}
```
### 更新物件加密
您必須連接下列許可政策，以允許 Batch Operations 讀取資訊清單、更新物件的加密類型，以及撰寫完成報告。若要使用此許可政策，請將 取代*`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 Batch Operations，在特定 Amazon S3 物件清單上執行大規模的批次操作。本節說明建立 S3 批次操作任務所需的資訊，以及 `CreateJob` 要求的結果，它還提供使用 Amazon S3 主控台、 AWS Command Line Interface (AWS CLI) 和 建立批次操作任務的說明 適用於 Java 的 AWS SDK。
當您建立 S3 批次操作任務時，您可以為所有任務請求完成報告，或僅請求失敗的任務。只要順利叫用至少一個任務，S3 Batch Operations 就會產生已完成、失敗或已取消任務的報告。如需詳細資訊，請參閱[範例：S3 批次操作完成報告](batch-ops-examples-reports.md)。
下列影片提供如何使用 Amazon S3 主控台建立 Batch Operations 任務的簡短示範。
[](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 批次操作針對資訊清單中物件執行的操作。每個操作類型都接受該操作特有的參數。您可以透過 Batch Operations 大量執行操作，結果與您在每一個物件上逐一執行操作相同。
**清單檔案**
*資訊清單*是 Amazon S3 物件清單，其中包含您希望 Amazon S3 採取行動的物件索引鍵。您可以使用下列方法指定 Batch Operations 任務的清單檔案：
+ 指示 Batch Operations 根據您指定的中繼資料產生物件清單。您可以將此清單儲存為資訊清單，並在建立您的作業時使用該檔案。此選項適用於您使用 Amazon S3 主控台、、 AWS CLI AWS SDKs 或 Amazon S3 REST API 建立的任何任務類型。
+ 根據現有的複寫組態自動產生物件清單。您可以將此清單儲存為資訊清單，並再次用於未來的作業。
+ 手動建立新的清單檔案。
+ 使用現有的清單檔案。
+ 無論您如何指定要處理的物件，資訊清單本身都必須儲存在一般用途儲存貯體中。Batch Operations 無法從目錄儲存貯體匯入現有的資訊清單，也無法將產生的物件清單儲存到目錄儲存貯體。不過，清單檔案內描述的物件可以儲存在目錄儲存貯體中。如需詳細資訊，請參閱[目錄儲存貯體](https://docs.aws.amazon.com//AmazonS3/latest/userguide/directory-buckets-overview.html)。
+ 如果您清單檔案中的物件位於已進行版本控制的儲存貯體中，指定物件的版本 ID 將會指示 Batch Operations 對特定版本執行操作。如果未指定版本 ID，則 Batch Operations 會對物件的最新版本執行操作。如果您的清單檔案包含版本 ID 欄位，您必須為資訊清單中的所有物件提供一個版本 ID。
如需詳細資訊，請參閱[指定資訊清單](#specify-batchjob-manifest)。
**優先順序**
請使用任務優先順序，指出此任務與您帳戶中執行之其他任務的相對優先順序。數字越大表示優先順序越高。
任務優先順序僅在相對於為同一帳戶和區域中的其他任務所設定的優先順序有意義。您可以選擇任何適合您的編號系統。例如，您可能想要為所有**還原** (`RestoreObject`) 作業派優先順序 1，為所有**複製** (`CopyObject`) 作業指派優先順序 2，以及為所有**取代存取控制清單 (ACL)** (`PutObjectAcl`) 作業指派優先順序 3。
S3 Batch Operations 會根據優先順序編號來排序任務的優先順序，但不保證嚴格排序。因此，請不要使用任務優先順序來確保其中任何一個任務會在其他任務之前啟動或完成。若您必須確保嚴格排序，請等待一個任務完成之後，再啟動下一個任務。
**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)。
對目錄儲存貯體執行動作的 Batch Operations 任務須具備特定許可。如需詳細資訊，請參閱[適用於 S3 Express One Zone 的AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-security-iam.html)。
**報告**
指定是否希望 S3 批次操作產生完整報告。若您請求一份完成報告，您也必須在此元素中提供報告的參數。下列為必要資訊：
+ 您希望在其中存放報告的儲存貯體
**注意**
報告必須儲存在一般用途儲存貯體中。Batch Operations 無法將報告儲存至目錄儲存貯體。如需詳細資訊，請參閱[目錄儲存貯體](https://docs.aws.amazon.com//AmazonS3/latest/userguide/directory-buckets-overview.html)。
+ 報告的格式
+ 您希望報告包含所有任務的詳細資訊，還是僅限失敗的任務
+ 選擇性的字首字串
如果提供 `CreateJob.Report.ExpectedBucketOwner` 欄位，則需要與完成報告儲存貯體擁有者相符。如果不相符，則該作業就會失敗。
完成報告一律會使用 Amazon S3 受管金鑰的伺服器端加密 (SSE-S3) 進行加密。
**標籤 （選用）**
您可以透過新增*標籤*，標示和控制對 S3 批次操作任務的存取權。您可以使用標籤來識別負責 Batch Operations 任務的人員，或控制使用者與 Batch Operations 任務互動的方式。任務標籤的存在可以授與或限制使用者的以下能力：取消任務、啟動處於確認狀態的任務或變更任務的優先順序層級。例如，假設建立的任務具有標籤 `"Department=Finance"`，您就可以授予使用者調用 `CreateJob` 操作的許可。
您可以建立已連接標籤的任務，也可以在建立任務後將標籤新增至任務。
如需詳細資訊，請參閱[使用標籤控制存取和標記任務](batch-ops-job-tags.md)。
**描述 (選用)**
若要追蹤和監控任務，您也可以提供最多 256 個字元的說明。每當 Amazon S3 在 Amazon S3 主控台上傳回任務的相關資訊或顯示任務的詳細資訊時，都會包含此說明。您可以輕鬆地根據指派的描述來排序和篩選任務。描述不需要是唯一的，因此您可以使用描述作為類別 (例如「每週複製日誌任務」) 來協助您追蹤相似任務的群組。
## 指定資訊清單
*資訊清單*是 Amazon S3 物件清單，其中包含您希望 Amazon S3 採取行動的物件索引鍵。您可以使用下列方法指定 Batch Operations 任務的清單檔案：
+ 指示 Batch Operations 根據您指定的中繼資料產生物件清單。您可以將此清單儲存為資訊清單，並在建立作業時使用該清單。此選項適用於您使用 Amazon S3 主控台、、 AWS CLI AWS SDKs 或 Amazon S3 REST API 建立的任何任務類型。
+ 根據現有的複寫組態自動產生物件清單。您可以將此清單另存為資訊清單，等未來作業時再派上用場。
+ 手動建立新的清單檔案。
+ 使用現有的清單檔案。
**注意**
Amazon S3 Batch Operations 不支援跨區域產生物件清單。
無論您如何指定要處理的物件，資訊清單本身都必須儲存在一般用途儲存貯體中。Batch Operations 無法從目錄儲存貯體匯入現有的資訊清單，也無法將產生的物件清單儲存到目錄儲存貯體。不過，清單檔案內描述的物件可以儲存在目錄儲存貯體中。如需詳細資訊，請參閱[目錄儲存貯體](https://docs.aws.amazon.com//AmazonS3/latest/userguide/directory-buckets-overview.html)。
## 自動產生物件清單，並將其儲存為資訊清單檔案
您可以指示 Amazon S3 根據您指定的中繼資料來自動產生物件清單。您可以將此清單儲存為資訊清單，並在建立作業時使用該清單。此選項適用於您使用 Amazon S3 主控台、、 AWS CLI AWS SDKs 或 Amazon S3 REST API 建立的任何任務類型。
若要自動產生物件清單，並另存為資訊清單檔案，您可以在建立作業請求中指定下列元素：
+ 包含來源物件的儲存貯體相關資訊，包括儲存貯體擁有者和 Amazon Resource Name (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，您也可以選擇依儲存貯體金鑰啟用狀態來進一步篩選結果。
若要在使用`KmsKeyArn`篩選條件時改善資訊清單產生效能，請使用篩選條件搭配其他物件中繼資料篩選條件，例如 `MatchAnyPrefix`、 `CreatedAfter`或 `MatchAnyStorageClass`。
**MatchAnyStorageClass**
如有提供，則產生的清單檔案只會包含以指定的儲存類別儲存的來源儲存貯體物件。
**ObjectReplicationStatuses**
如有提供，則產生的清單檔案只會包含具有其中一種指定複寫狀態的來源儲存貯體物件。
**ObjectSizeGreaterThanBytes**
如有提供，則產生的清單檔案只會包含檔案大小大於所指定位元組數目的來源儲存貯體物件。
**ObjectSizeLessThanBytes**
如有提供，則產生的清單檔案只會包含檔案大小小於所指定位元組數目的來源儲存貯體物件。
**注意**
您無法複製大部分已自動產生另存為資訊清單之物件清單的作業。除非批次複寫任務使用 `KeyNameConstraint`、`MatchAnyStorageClass`、`ObjectSizeGreaterThanBytes` 或 `ObjectSizeLessThanBytes` 清單檔案篩選條件，否則可以複製這些任務。
指定清單檔案條件的語法會根據您用來建立任務的方法而有所不同。如需範例，請參閱 [建立任務](#to-create-batch-ops-job)。
## 建立清單檔案
若要手動建立清單檔案，您可指定清單檔案物件索引鍵、ETag (實體標籤) 和選用的版本 ID (使用 CSV 格式清單)。資訊清單的內容必須為 URL 編碼。
根據預設，Amazon S3 會自動使用採用 Amazon S3 受管金鑰 (SSE-S3) 的伺服器端加密，來加密上傳至 S3 儲存貯體的清單檔案。不支援使用以客戶提供之金鑰 (SSE-C) 進行伺服器端加密的資訊清單。只有在您使用 CSV 格式的庫存報告時，才支援使用伺服器端加密搭配 AWS Key Management Service (AWS KMS) 金鑰 (SSE-KMS) 的資訊清單。 AWS KMS 不支援搭配 使用手動建立的資訊清單。
您的資訊清單必須包含儲存貯體名稱、物件金鑰，也可選擇納入各物件的物件版本。S3 批次作業不會使用資訊清單中的任何其他欄位。
**注意**
如果您清單檔案中的物件位於已進行版本控制的儲存貯體中，指定物件的版本 ID 將會指示 Batch Operations 對特定版本執行操作。如果未指定版本 ID，則 Batch Operations 會對物件的最新版本執行操作。如果您的清單檔案包含版本 ID 欄位，您必須為資訊清單中的所有物件提供一個版本 ID。
以下為不帶版本 ID 的 CSV 格式資訊清單範例。
```
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
```
以下是包含版本 ID 的 CSV 格式清單檔案範例。
```
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
```
## 使用現有的資訊清單
您可以藉由使用下列兩種格式之一，指定現有的資訊清單來建立 Batch Operations 作業：
+ **Amazon S3 庫存清單報告**：必須是 CSV 格式的 Amazon S3 庫存清單報告。您必須指定與庫存報告關聯的 `manifest.json` 檔案。如需庫存報告的詳細資訊，請參閱 [使用 S3 庫存清單編目和分析資料](storage-inventory.md)。如果庫存報告包含版本 ID，則 S3 批次作業會對特定物件版本執行操作。
**注意**
S3 Batch Operations 支援使用 SSE-KMS 加密的 CSV *庫存報告*。
如果您提交使用 SSE-KMS 加密的庫存報告清單檔案，您的 IAM 政策必須包含 `manifest.json` 物件及所有相關聯 CSV 資料檔案的許可 `"kms:GenerateDataKey"` 和 `"kms:Decrypt"`。
+ **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 Batch Operations 不支援使用 SSE-KMS 加密的 CSV *清單檔案*。
**重要**
如果您使用手動建立的清單檔案和版本控制的儲存貯體時，我們建議您指定物件的版本 ID。建立任務時，S3 批次作業會在執行任務之前剖析整個資訊清單。但是，它不會為儲存貯體的狀態拍攝「快照」。
由於清單檔案可能包含數十億個物件，因此任務可能需要很長的時間來執行，這樣可能會影響任務採取行動的物件版本。假設您在任務執行時，以新版本覆寫物件，而您未指定該物件的版本 ID。在此情況下，Amazon S3 會對物件的最新版本執行操作，而非您建立任務時已存在的版本。避免此行為最簡單的方式，便是為資訊清單中列出的物件指定版本 ID。
## 建立任務
您可以使用 Amazon S3 主控台、 AWS CLI、 AWS SDKs 或 Amazon S3 REST API 來建立 Amazon S3 批次操作任務。 Amazon S3
如需建立任務請求的詳細資訊，請參閱 [批次操作任務請求元素](#batch-ops-create-job-request-elements)。
**先決條件**
建立 Batch Operations 任務之前，請先確認您已設定相關許可。如需詳細資訊，請參閱[授予批次操作的許可](batch-ops-iam-role-policies.md)。
### 使用 S3 主控台
**使用 S3 主控台建立 Batch Operations 作業**
1. 登入 AWS 管理主控台 ，並在 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)：// 開啟 Amazon S3 主控台。
1. 在 Amazon S3 主控台的左側導覽窗格上，選擇 **Batch Operations**。
1. 選擇**建立任務**。
1. 在**選擇區域和範圍**下，選擇並檢視您要建立任務 AWS 的區域。
**注意**
對於複製操作，您必須在與目的地儲存貯體相同的區域中建立作業。對於所有其他操作，您必須在與資訊清單中的物件相同的區域中建立作業。
1. 針對**範圍**，指定 Batch Operations 作業將據以採取行動的物件清單。
在**物件清單**下，您可以選擇使用物件清單產生資訊清單、使用複寫組態產生資訊清單，或使用現有的資訊清單。
+ 如果您選擇**產生物件清單**，就會根據您指定的來源位置和中繼資料自動產生物件清單。您可以將此清單另存為資訊清單，等未來作業時再派上用場。
**注意**
若要產生物件清單，您必須擁有 `s3:PutInventoryConfiguration`許可。來源儲存貯體必須是一般用途儲存貯體。
+ 如果選擇**使用現有的資訊清單**，您可以從現有的資訊清單匯入物件清單。資訊清單是 S3 庫存清單報告或 CV 檔案，其中列出您希望 Batch Operations 處理的特定物件。
+ 如果選擇**使用複寫組態**，您可以根據現有的複寫組態自動產生物件清單。您可以將此清單另存為資訊清單，等未來作業時再派上用場。
在此範例中，選擇**產生物件清單**。
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. 在 **Review (檢閱)** 中，確認您的設定。如需變更，請選擇 **Previous** (上一步)。否則，您可以選擇**提交任務**。
### 使用 AWS CLI
若要使用 建立批次操作任務 AWS CLI，請根據您要指定現有資訊清單或自動產生資訊清單，選擇下列其中一個範例。
------
#### [ Specify manifest ]
下列範例示範如何使用 AWS CLI 來建立 S3 批次操作`S3PutObjectTagging`任務，以對現有資訊清單檔案中列出的物件採取行動。
**透過指定資訊清單來建立 Batch Operations `S3PutObjectTagging` 作業**
1. 使用下列命令來建立 AWS Identity and Access Management (IAM) 角色，然後建立 IAM 政策來指派相關許可。下列角色和政策會授予 Amazon S3 許可來新增物件標籤，您在後續步驟中建立任務時將會需要這些標籤。
1. 使用下列範例命令來建立要供 Batch Operations 使用的 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 Resource Name (ARN)。在建立任務時，您將需要 ARN。
1. 使用下列範例命令來建立具有必要許可的 IAM 政策，並將其連接到上一個步驟中建立的 IAM 角色。如需有關必要許可的詳細資訊，請參閱 [授予批次操作的許可](batch-ops-iam-role-policies.md)。
**注意**
對目錄儲存貯體執行動作的 Batch Operations 任務須具備特定許可。如需詳細資訊，請參閱[適用於 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 命令參考》**中的 [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 Batch Operations `S3DeleteObjectTagging` 任務，讓它根據您的物件篩選條件自動產生清單檔案。此條件包括建立日期、索引鍵名稱、大小、儲存類別和標籤。
**透過產生資訊清單來建立 Batch Operations `S3DeleteObjectTagging` 作業**
1. 使用下列命令來建立 AWS Identity and Access Management (IAM) 角色，然後建立 IAM 政策來指派許可。下列角色和政策會授予 Amazon S3 許可來刪除物件標籤，您在後續步驟中建立任務時將會需要這些標籤。
1.
使用下列範例命令來建立要供 Batch Operations 使用的 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 Resource Name (ARN)。在建立任務時，您將需要 ARN。
1. 使用下列範例命令來建立具有必要許可的 IAM 政策，並將其連接到上一個步驟中建立的 IAM 角色。如需有關必要許可的詳細資訊，請參閱 [授予批次操作的許可](batch-ops-iam-role-policies.md)。
**注意**
對目錄儲存貯體執行動作的 Batch Operations 任務須具備特定許可。如需詳細資訊，請參閱[適用於 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 命令參考》**中的 [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 開發套件建立批次操作任務，您可以根據指定現有資訊清單或自動產生資訊清單，在兩種方法之間進行選擇：
+ *指定現有資訊清單：*建立可對現有資訊清單檔案中列出的物件採取行動的 S3 Batch Operations 作業 (例如 `S3PutObjectTagging`)。此方法要求您提供資訊清單位置、ETag 和格式規格。
+ *自動產生資訊清單：*建立可根據物件篩選條件 (包括建立日期、索引鍵名稱和大小限制)，自動產生資訊清單的 S3 Batch Operations 作業 (例如 `s3PutObjectCopy`)。
這兩種方法都使用 S3Control 用戶端來設定任務操作、資訊清單規格、任務報告、IAM 角色和其他任務參數，包括優先順序和確認要求。
如需如何使用適用於 Java 的 AWS SDK 建立 S3 批次操作任務的範例，請參閱《*Amazon S3 API 參考*》中的[建立批次任務以複製物件](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 SDKs或 REST API 建立任務時，您可以設定 S3 批次操作以開始自動處理任務。任務會在準備好後立即開始執行，而不會等待優先順序更高的任務。
當您透過 Amazon S3 主控台建立任務時，您必須檢閱任務詳細資訊，並確認您希望在 Batch Operations 開始處理任務之前執行該任務。如果任務維持暫停狀態超過 30 天，將會失敗。
# S3 批次操作支援的操作
您可以使用 S3 批次作業對 Amazon S3 物件執行大規模的批次作業。S3 批次作業可以對您指定的 Amazon S3 物件清單執行單一作業。單一任務可在包含數 EB 資料的數以億計物件上執行指定的操作。Amazon S3 會追蹤進度、傳送通知，並存放所有動作的詳細完成報告，提供完整受管、可稽核、無伺服器的體驗。您可以透過 Amazon S3 主控台、 AWS CLI、 AWS SDKs 或 Amazon S3 REST API 使用 Amazon S3 批次操作。 Amazon S3
S3 批次作業支援下列作業：
# 複製物件
您可以使用 Amazon S3 Batch Operations 對 Amazon S3 物件執行大規模的批次操作。Batch Operations **複製**操作會複製資訊清單中指定的每個物件。您可以將物件複製到相同 中的儲存貯體， 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)。
## 法規與限制
當您使用 Batch Operations **複製**操作時，適用下列限制：
+ 所有來源物件必須位於一個儲存貯體中。
+ 所有目的地物件必須位於一個儲存貯體中。
+ 您必須具有來源儲存貯體的讀取許可，和目的地儲存貯體的寫入許可。
+ 複製的物件大小上限可達 5 GB。
+ 如果嘗試將物件從 S3 Glacier Flexible Retrieval 或 S3 Glacier Deep Archive 類別複製到 S3 Standard 儲存類別，必須先還原這些物件。如需詳細資訊，請參閱[還原已封存的物件](restoring-objects.md)。
+ 您必須在目的地區域中建立 Batch Operations **複製**作業，也就是您要將物件複製到其中的區域。
+ 支援所有 `CopyObject` 選項，但不包括對實體標籤 (ETag) 執行條件式檢查，以及使用客戶提供加密金鑰的伺服器端加密 (SSE-C)。
+ 如果目的地儲存貯體無版本控制，您將覆寫任何具有相同金鑰名稱的物件。
+ 物件不一定按照它們在資訊清單中出現的相同順序進行複製。對於使用版本控制的儲存貯體，如果保留目前或非目前版本順序很重要，請先複製所有非目前版本。然後，在第一個任務完成後，在接下來的任務中複製目前版本。
+ 不支援將物件複製到低冗餘儲存 (RRS) 類別。
+ 單一 Batch Operations 複製作業最多可支援 200 億個物件的資訊清單。
# 使用 S3 批次操作複製物件
您可以使用 Amazon S3 Batch Operations 對 Amazon S3 物件執行大規模的批次操作。您可以使用 S3 Batch Operations 建立**複製** (`CopyObject`) 作業，將相同帳戶中的物件複製到不同的目的地帳戶。
下列範例示範如何儲存和使用不同帳戶中的資訊清單。第一個範例示範如何使用 Amazon S3 庫存清單將庫存報告傳送至目的地帳戶，以在建立作業期間使用。第二個範例示範如何在來源或目的地帳戶中使用逗號分隔值 (CSV) 資訊清單。第三個範例示範如何使用**複製**操作，為已使用 AWS Key Management Service (AWS KMS) 金鑰的伺服器端加密 (SSE-KMS) 加密的現有物件啟用 S3 儲存貯體金鑰。
**Topics**
+ [
# 使用庫存報告跨 複製物件 AWS 帳戶
](specify-batchjob-manifest-xaccount-inventory.md)
+ [
# 使用 CSV 資訊清單跨 複製物件 AWS 帳戶
](specify-batchjob-manifest-xaccount-csv.md)
+ [
# 使用 Batch Operations 為 SSE-KMS 啟用 S3 儲存貯體金鑰
](batch-ops-copy-example-bucket-key.md)
# 使用庫存報告跨 複製物件 AWS 帳戶
您可以使用 Amazon S3 Batch Operations 對 Amazon S3 物件執行大規模的批次操作。您可以使用 S3 Batch Operations 建立**複製** (`CopyObject`) 作業，將相同帳戶中的物件複製到不同的目的地帳戶。
您可以使用 Amazon S3 庫存清單建立庫存報告，並使用該報告建立要透過 S3 Batch Operations 複製的物件清單 (資訊清單)。如需更多有關在來源帳戶或目標帳戶中使用 CSV 資訊清單的資訊，請參閱「[使用 CSV 資訊清單跨 複製物件 AWS 帳戶](specify-batchjob-manifest-xaccount-csv.md)」。
Amazon S3 庫存會在儲存貯體中產生物件的庫存。結果清單將推送至一個輸出檔案。已進行庫存儲存貯體稱作來源儲存貯體，存放庫存報告檔案的儲存貯體則稱作目的地儲存貯體。
Amazon S3 清查報告可設定為交付至另一個 AWS 帳戶。這樣做可讓 S3 Batch Operations 在目的地帳戶建立作業時讀取庫存報告。
如需 Amazon S3 清查來源和目的地儲存貯體的詳細資訊，請參閱「[來源與目的地儲存貯體](storage-inventory.md#storage-inventory-buckets)」。
設定清查最簡單的方式是使用 Amazon S3 主控台，但您也可以使用 Amazon S3 REST API、 AWS Command Line Interface (AWS CLI) 或 AWS SDKs。
下列主控台程序包含設定 S3 批次操作任務許可的高階步驟。在此程序中，您從來源帳戶複製物件至目的地帳戶，並將清查報告存放於目的地帳戶中。
**設定來源與目標儲存貯體分屬於不同帳戶時的 Amazon S3 庫存**
1. 登入 AWS 管理主控台 ，並在 https：//[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 開啟 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Buckets** (儲存貯體)。
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 Batch Operations** 使用案例，以將信任政策套用至該角色。
然後選擇 **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` 物件、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 Batch Operations **複製** (`CopyObject`) 作業，並從目的地資訊清單儲存貯體選擇庫存報告。您需要在目的地帳戶中建立之 IAM 角色的 ARN。
如需建立任務的一般資訊，請參閱「[建立 S3 批次操作任務](batch-ops-create-job.md)」。
如需使用主控台建立作業的資訊，請參閱[建立 S3 批次操作任務](batch-ops-create-job.md)。
# 使用 CSV 資訊清單跨 複製物件 AWS 帳戶
您可以使用 Amazon S3 Batch Operations 對 Amazon S3 物件執行大規模的批次操作。您可以使用 S3 Batch Operations 建立**複製** (`CopyObject`) 作業，將相同帳戶中的物件複製到不同的目的地帳戶。
您可以使用儲存在來源帳戶中的 CSV 資訊清單，透過 S3 Batch Operations 在 AWS 帳戶 之間複製物件。若要使用 S3 庫存報告作為資訊清單，請參閱[使用庫存報告跨 複製物件 AWS 帳戶](specify-batchjob-manifest-xaccount-inventory.md)。
如需 CSV 格式資訊清單檔案的範例，請參閱[建立清單檔案](batch-ops-create-job.md#create-manifest-file)。
下列程序示範當使用 S3 Batch Operations 作業將物件從來源帳戶複製到目的地帳戶時，如何使用來源帳戶中儲存的 CSV 資訊清單檔案設定許可。
**使用 CSV 資訊清單跨 複製物件 AWS 帳戶**
1. 在以 S3 Batch Operations 信任政策為基礎的目的地帳戶中建立 AWS Identity and Access Management (IAM) 角色。在此程序中，*destination account (目的地帳戶)* 為物件複製到的目的地帳戶。
如需信任政策的詳細資訊，請參閱「[信任政策](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 Batch Operations** 使用案例，以將信任政策套用至該角色。
然後選擇 **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 Batch Operations 使用信任的角色讀取資訊清單。套用儲存貯體政策至包含資訊清單的儲存貯體。
以下為套用至來源資訊清單儲存貯體的儲存貯體政策範例。若要使用此政策，請以您自己的資訊取代 *`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)。
# 使用 Batch Operations 為 SSE-KMS 啟用 S3 儲存貯體金鑰
S3 儲存貯體金鑰透過減少從 Amazon S3 到 的請求流量，降低使用 AWS Key Management Service (AWS KMS) (SSE-KMS) 進行伺服器端加密的成本 AWS KMS。如需詳細資訊，請參閱[使用 Amazon S3 儲存貯體金鑰降低 SSE-KMS 的成本](bucket-key.md)及[設定您的儲存貯體以使用具有 SSE-KMS 的 S3 儲存貯體來獲取新物件](configuring-bucket-key.md)。當您使用 REST API、 AWS SDKs 或 執行`CopyObject`操作時 AWS CLI，您可以透過新增具有 或 `true``false`值的`x-amz-server-side-encryption-bucket-key-enabled`請求標頭，在物件層級啟用或停用 S3 儲存貯體金鑰。
當您使用 `CopyObject` 操作為物件設定 S3 儲存貯體金鑰時，Amazon S3 只會更新該物件的設定。目的地儲存貯體的 S3 儲存貯體金鑰設定不會變更。如果您將 AWS KMS 加密物件的 `CopyObject` 請求提交至啟用 S3 儲存貯體金鑰的儲存貯體，除非您停用請求標頭中的金鑰，否則物件層級操作將自動使用 S3 儲存貯體金鑰。如果您沒有為物件指定 S3 儲存貯體金鑰，Amazon S3 會將目的地儲存貯體的 S3 儲存貯體金鑰設定套用至物件。
若要加密現有的 Amazon S3 物件，您可以使用 S3 Batch Operations。您可以使用**批次操作複製操作**來複製現有的未加密物件，並將其作為加密物件寫入相同的儲存貯體中。如需詳細資訊，請參閱 AWS 儲存部落格上的[使用 Amazon S3 Batch Operations 加密物件](https://aws.amazon.com/blogs/storage/encrypting-objects-with-amazon-s3-batch-operations/)。
在下列範例中，您將使用 Batch Operations **複製**操作，在現有物件上啟用 S3 儲存貯體金鑰。如需詳細資訊，請參閱[在物件層級設定 S3 儲存貯體金鑰](configuring-bucket-key-object.md)。
**Topics**
+ [
## 使用 S3 Batch Operations 透過啟用 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 Batch Operations 透過啟用 S3 儲存貯體金鑰來加密物件的考量
在您使用 S3 Batch Operations 透過 S3 儲存貯體金鑰來加密物件時，請考慮下列議題：
+ 除了與 S3 批次操作代表您執行之作業相關聯的任何費用之外，還需支付 S3 批次操作任務、物件及請求之費用，包括資料傳輸、請求及其他費用。如需詳細資訊，請參閱 [Amazon S3 定價](https://aws.amazon.com/s3/pricing)。
+ 如果您使用無版本控制的儲存貯體，則執行的每個 S3 批次操作任務都會建立物件的新加密版本。同時也會保留先前沒有配置 S3 儲存貯體金鑰的版本。若要刪除舊版本，請如 [生命週期組態元素](intro-lifecycle-rules.md) 之描述，設定非最新版本 S3 生命週期過期政策。
+ 複製操作會建立具有新建立日期的新物件，這會影響封存等生命週期動作。若您複製儲存貯體中的所有物件，則所有新副本皆會有相同或類似的建立日期。若要進一步識別這些物件，並為多個資料子集建立不同的生命週期規則，請考慮使用物件標籤。
## 先決條件
將物件設定為使用 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 儲存貯體，並取得其內容清單。Amazon S3 清查報告是執行此操作最方便且經濟實惠的方式。報告會提供儲存貯體中的物件清單，以及相關聯的中繼資料。在此步驟中，來源儲存貯體是已進行清查的儲存貯體，而目的地儲存貯體是您用於儲存庫存報告檔案的儲存貯體。如需 Amazon S3 清查來源和目的地儲存貯體的詳細資訊，請參閱「[使用 S3 庫存清單編目和分析資料](storage-inventory.md)」。
設定庫存最簡單的方式就是使用 AWS 管理主控台。但您也可以使用 REST API、 AWS Command Line Interface (AWS CLI) 或 AWS SDKs。在執行這些步驟前，請務必先登入主控台，然後開啟位於 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 的 Amazon S3 主控台。如果您遇到權限遭拒絕的錯誤情況，請將儲存貯體政策新增至目的地儲存貯體。如需詳細資訊，請參閱[授予 S3 清查與 S3 分析的許可](example-bucket-policies.md#example-bucket-policies-s3-inventory-1)。
**使用 S3 庫存取得您的物件清單**
1. 開啟位於 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 的 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇**儲存貯體**，然後選擇包含要加密之物件的儲存貯體。
1. 在 **Management** (管理) 索引標籤上，導覽至 **Inventory configurations** (庫存組態) 區段，然後選擇 **Create inventory configuration** (建立庫存組態)。
1. 為您的新清查命名、輸入目的地 S3 儲存貯體的名稱，然後選擇是否要建立 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 的詳細資訊，請參閱 AWS 儲存部落格文章中的 [使用 Amazon Athena 查詢 Amazon S3 庫存](storage-inventory-athena-query.md)和「使用 Athena」[使用 Amazon S3 Batch Operations 加密物件](https://aws.amazon.com/blogs/storage/encrypting-objects-with-amazon-s3-batch-operations)。
**使用 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` 物件會列出 **files** (檔案) 下的資料檔案。
1. 在 S3 主控台中找出並選取資料檔案後，請選擇 **Actions** (動作)，然後選擇 **Query with S3 Select** (使用 S3 Select 查詢)。
1. 保留選取預設 **CSV**、**Comma** (逗號) 以及 **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 格式，然後將結果上傳到 Amazon S3 作為 S3 批次操作任務的物件清單。
1. 如果您有多個清單檔案，也請在其上執行 **Query with S3 Select** (使用 S3 Select 查詢)。根據結果大小，您可以合併清單並執行單一 S3 批次操作任務，或將每個清單當成個別任務來執行。若要決定執行的作業數目，請考慮執行每個 S3 Batch Operations 作業的[價格](https://aws.amazon.com/s3/pricing/)。
## 步驟 3：設定並執行 S3 批次操作任務
現在，您已擁有經過篩選的 S3 物件 CSV 清單，可以開始 S3 Batch Operations 作業，以透過啟用 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. 在 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 中開啟 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. 請確定建立任務的使用者具有以下範例中的權限。
以您的 AWS 帳戶 ID 取代 `account-id`，並以您要套用至 IAM 角色的名稱 (稍後將在 Batch 批次操作建立步驟中建立該名稱) 來取代 `IAM-role-name`。如需詳細資訊，請參閱[授予批次操作的許可](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. 開啟位於 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 的 Amazon 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. 開啟位於 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 的 Amazon 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 Batch Operations (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 SDKs或 Amazon S3 REST API 來執行這些步驟。如需追蹤任務狀態和完成報告的詳細資訊，請參閱「[追蹤任務狀態和完成報告](batch-ops-job-status.md)」。
如需使用 AWS CLI 和 顯示具有標籤的複製操作範例 適用於 Java 的 AWS SDK，請參閱 [建立具有任務標籤 (用於標示) 的批次作業任務](batch-ops-tags-create.md)。
# 運算檢查總和
您可以搭配**運算檢查總和**操作使用 S3 Batch Operations，對儲存在 Amazon S3 中的靜態物件執行檢查總和計算。**運算檢查總和**操作可計算物件檢查總和，其可用來驗證資料完整性，無需下載或還原存放資料的物件。您可以使用**運算檢查總和**操作，針對所有支援的檢查總和演算法，計算複合及完整物件兩種檢查總和類型的檢查總和。
您可以使用**運算檢查總和**操作，透過單一作業請求處理數十億個物件。此批次操作與所有 S3 儲存類別相容，無論物件大小為何。若要建立**運算檢查總**和任務，請使用 Amazon S3 主控台、 AWS Command Line Interface (AWS CLI)、 AWS SDKs或 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)，並包含操作類型、時間戳記、[錯誤代碼](https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#ErrorCodeList)和相關聯的**運算檢查總和**任務 ID 欄位。此日誌記錄提供對物件執行檢查總和驗證活動的稽核軌跡，協助您追蹤和驗證資料完整性操作。
**注意**
**運算檢查總和**操作不使用客戶提供加密金鑰 (SSE-C) 加密物件支援伺服器端加密。不過，您可以使用**運算檢查總**和操作搭配 S[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)。 ****
若要使用 Batch Operations 開始使用**運算檢查總和**操作，您可以：
+ 手動建立新的資訊清單檔案。
+ 使用現有的清單檔案。
+ 指示 Batch Operations 根據您[在建立任務時指定](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 參考》**中的 [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 Batch Operations 使用**運算檢查總和**操作。
**Topics**
+ [
## S3 Batch Operations **運算檢查總和**考量事項
](#batch-ops-compute-checksum-considerations)
+ [
## S3 Batch Operations 完成報告
](#batch-ops-compute-checksum-completion-report)
## S3 Batch Operations **運算檢查總和**考量事項
使用**運算檢查總和**操作之前，請檢閱下列考量清單：
+ 如果您的清單檔案包含版本 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 Batch Operations 完成報告
當您建立**運算檢查總和**作業時，可以請求 S3 Batch Operations 完成報告。此 CSV 檔案會顯示物件、成功或失敗代碼、輸出及描述。如需作業追蹤和完成報告的詳細資訊，請參閱[完成報告](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-job-status.html#batch-ops-completion-report)。
# 刪除所有物件標籤
您可以使用 Amazon S3 Batch Operations 對 Amazon S3 物件執行大規模的批次操作。**刪除所有物件標籤**操作會移除目前與資訊清單中列出的物件關聯的所有 Amazon S3 物件標籤組。S3 Batch Operations 不支援從物件中刪除標籤，同時保留其他標籤。
如果資訊清單中的物件位於已建立版本的儲存貯體中，您可以從特定版本的物件中移除標籤組。若要執行這項操作，您必須為資訊清單中的每個物件指定版本 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)。
## 法規與限制
當您使用 Batch Operations 刪除物件標籤時，適用下列限制：
+ 您指定執行任務的 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 Batch Operations 使用 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 Batch Operations 任務。
+ 單一刪除物件標記作業最多可支援 200 億個物件的資訊清單。
# 叫用 AWS Lambda 函數
您可以使用 Amazon S3 Batch Operations 對 Amazon S3 物件執行大規模的批次操作。**叫用 AWS Lambda 函數**批次操作操作會 AWS Lambda 啟動函數，以對資訊清單中列出的物件執行自訂動作。本節說明如何建立 Lambda 函數以搭配 S3 批次作業使用，以及如何建立任務來叫用函數。S3 批次操作任務會使用 `LambdaInvoke` 操作，對資訊清單中列出的每個物件執行 Lambda 函數。
您可以使用 Amazon S3 主控台、 AWS Command Line Interface (AWS CLI)、 AWS SDKs 或 Amazon S3 REST API Amazon S3 批次操作。 Amazon S3 如需有關使用 Lambda 的詳細資訊，請參閱*《AWS Lambda 開發人員指南》*中的 [AWS Lambda入門](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html)。
下列各節說明如何開始搭配 Lambda 使用 S3 批次作業。
**Topics**
+ [
## 搭配 Batch Operations 使用 Lambda
](#batch-ops-invoke-lambda-using)
+ [
## 建立 Lambda 函數以搭配 S3 批次作業使用
](#batch-ops-invoke-lambda-custom-functions)
+ [
## 建立 S3 批次作業任務以叫用 Lambda 函數
](#batch-ops-invoke-lambda-create-job)
+ [
## 在 Lambda 資訊清單中提供工作層級的資訊
](#storing-task-level-information-in-lambda)
+ [
## S3 Batch Operations 教學課程
](#batch-ops-tutorials-lambda)
## 搭配 Batch Operations 使用 Lambda
搭配 S3 Batch Operations 使用 時 AWS Lambda，您必須建立專門用於 S3 Batch Operations 的新 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) 搭配使用。
您建立 S3 批次作業任務來叫用 Lambda 函數。此任務對資訊清單中列出的所有物件執行相同的 Lambda 函數。您可以控制在處理清單中的物件時，使用 Lambda 函數的哪些版本。S3 批次作業支援不合格的 Amazon Resource Name (ARN)、別名和特定版本。如需詳細資訊，請參閱《 *AWS Lambda 開發人員指南*》中的[AWS Lambda 版本控制簡介](https://docs.aws.amazon.com/lambda/latest/dg/versioning-intro.html)。
如果您為 S3 批次作業任務提供的函數 ARN 使用別名或 `$LATEST` 限定詞，而且您更新其中任一項所指向的版本，則 S3 批次作業會開始呼叫 Lambda 函數的新版本。當您想要隨著大型工作更新部分功能，此功能會很有用。如果您不希望 S3 Batch Operations 變更使用的版本，請在建立作業時在 `FunctionARN` 參數中提供特定版本。
具有 S3 Batch Operations 的單一 AWS Lambda 任務可支援具有高達 200 億個物件的資訊清單。
### 搭配目錄儲存貯體使用 Lambda 和 Batch Operations
目錄儲存貯體是一種 Amazon S3 儲存貯體，這是專為需要一致的個位數毫秒延遲的工作負載或效能關鍵應用程式所設計的類型。如需詳細資訊，請參閱[目錄儲存貯體](https://docs.aws.amazon.com//AmazonS3/latest/userguide/directory-buckets-overview.html)。
使用 Batch Operations 調用對目錄儲存貯體執行動作的 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 儲存部落格[中的使用 Amazon S3 S3 目錄儲存貯體中的物件處理 AWS Lambda](https://aws.amazon.com/blogs/storage/automate-object-processing-in-amazon-s3-directory-buckets-with-s3-batch-operations-and-aws-lambda/)。
### 回應代碼和結果代碼
S3 Batch Operations 會使用一或多個金鑰調用 Lambda 函數，每個金鑰都有相關聯的 `TaskID`。S3 Batch Operations 預期會從 Lambda 函數收到每個金鑰的結果碼。在請求中傳送的任何任務 ID 若未傳回每個金鑰的結果碼，則會從 `treatMissingKeysAs` 欄位得到結果碼。`treatMissingKeysAs` 是選用的請求欄位，預設為 `TemporaryFailure`。下表包含 `treatMissingKeysAs` 欄位的其他可能結果碼和值。
| 回應代碼 | 描述 |
| --- | --- |
| Succeeded | 任務正常完成。如果您請求工作完成報告，即會在報告中包含任務的結果字串。 |
| TemporaryFailure | 任務遇到暫時性的失敗，並且將在工作完成之前重新推動。會忽略結果字串。如果這是最後一次的重新推動，即會在最終報告中包含錯誤訊息。 |
| PermanentFailure | 任務遇到永久的失敗。如果您請求工作完成報告，即會將任務標示為 Failed，並包含錯誤訊息字串。會忽略來自失敗任務的結果字串。 |
## 建立 Lambda 函數以搭配 S3 批次作業使用
本節提供必須搭配 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 Batch Operations 的 Lambda 函數必須接受並傳回特殊資料欄位。
**重要**
AWS Lambda 以 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/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 Batch Operations 請求和回應格式， AWS Lambda 需要 `RequestStreamHandler`界面，以進行請求和回應的自訂序列化和還原序列化。此介面允許 Lambda 將 InputStream 和 OutputStream 傳遞給 Java `handleRequest` 方法。
搭配 S3 批次作業使用 Lambda 函數時，請務必使用 `RequestStreamHandler` 介面。如果您使用 `RequestHandler` 介面，批次任務會失敗，完成報告中出現「Lambda 承載中傳回無效的 JSON」。
如需詳細資訊，請參閱*《AWS Lambda 使用者指南》*中的[處理常式介面](https://docs.aws.amazon.com//lambda/latest/dg/java-handler.html#java-handler-interfaces)。
### IAM 權限範例
以下是搭配 S3 批次作業使用 Lambda 函數所需的 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 政策**
以下 IAM 政策範例准許 S3 批次作業叫用 Lambda 函數和讀取輸入資訊清單。
****
```
{
"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 Batch Operations 傳遞的金鑰進行 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,
}
```
## 建立 S3 批次作業任務以叫用 Lambda 函數
建立 S3 批次作業任務來叫用 Lambda 函數時，您必須提供下列項目：
+ Lambda 函數的 ARN (可能包含函數別名或特定版本號碼)
+ 獲准叫用函數的 IAM 角色
+ 動作參數 `LambdaInvokeFunction`
如需有關建立 S3 批次作業任務的詳細資訊，請參閱[建立 S3 批次操作任務](batch-ops-create-job.md)和[S3 批次操作支援的操作](batch-ops-operations.md)。
下列範例會建立一個 S3 Batch Operations 作業，使用 AWS CLI來調用 Lambda 函數。若要使用此範例，請以您自己的資訊取代 *`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 資訊清單中提供工作層級的資訊
當您搭配 S3 Batch Operations 使用 AWS Lambda 函數時，您可能會希望每個操作的任務或金鑰隨附額外的資料。例如，您可能希望同時提供來源物件金鑰與全新的物件金鑰。這樣 Lambda 函數就能以新名稱，將來源金鑰複製到新的 S3 儲存貯體。根據預設，Batch Operations 可讓您在作業的輸入資訊清單中僅指定目的地儲存貯體和來源金鑰清單。下列範例說明如何在資訊清單中包含其他資料，以便執行更複雜的 Lambda 函數。
若要在 S3 批次作業資訊清單中指定每個金鑰的參數，以用於 Lambda 函數程式碼中，請使用以下 URL 編碼的 JSON 格式。`key` 欄位視同 Amazon S3 物件金鑰傳遞給 Lambda 函數。但 Lambda 函數可以轉譯此欄位，以包含其他值或多個金鑰，如下列範例所示。
**注意**
資訊清單中 `key` 欄位的字元數上限是 1,024。
**Example — 以 JSON 字串取代「Amazon S3 金鑰」的資訊清單**
必須提供以 URL 編碼的版本給 S3 批次作業。
```
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 編碼的資訊清單**
必須提供這個以 URL 編碼的版本給 S3 批次作業。非 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 Batch Operations 資訊清單的縱線分隔任務。任務會指出要套用至指定物件的修訂版作業。
```
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 Batch Operations 教學課程
下列教學課程會針對部分搭配 Lambda 的批次操作工作，提供完整的端對端程序。在本教學課程中，您將了解如何設定 Batch Operations 來調用 Lambda 函數，以對儲存在 S3 來源儲存貯體中的影片進行批次轉碼。Lambda 函數會呼叫 AWS Elemental MediaConvert 來轉碼影片。
+ [教學課程：使用 S3 Batch Operations 進行影片的批次轉碼](tutorial-s3-batchops-lambda-mediaconvert-video.md)
# 取代所有物件標籤
您可以使用 Amazon S3 Batch Operations 對 Amazon S3 物件執行大規模的批次操作。**取代所有物件標籤**操作會取代資訊清單中所列出每個物件上的物件標籤。 物件標籤是字串的鍵/值組，可用於存放物件的中繼資料。
若要建立**取代所有物件標籤**作業，請提供要套用的標籤組。S3 批次操作會將相同的標籤集套用至每個物件。您提供的標籤集會取代已與資訊清單中的物件相關聯的任何標籤組。S3 Batch Operations 不支援將標籤新增至物件，同時保留現有標籤。
若您資訊清單中的物件位於啟用版本控制的儲存貯體，您可以將標籤組套用至每個物件的特定版本。若要執行這項操作，請為資訊清單中的每個物件指定版本 ID。如果您未包含任何物件的版本 ID，則 S3 Batch Operations 會將標籤組套用至每個物件的最新版本。如需批次操作資訊清單的詳細資訊，請參閱[指定資訊清單](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)。
## 法規與限制
當您使用 Batch Operations 取代物件標籤時，適用下列限制：
+ 您指定執行批次操作任務的 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 Batch Operations 使用 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 Batch Operations 任務。
+ 單一取代所有物件標籤作業，最多可支援 200 億個物件的資訊清單。
# 取代存取控制清單 (ACL)
您可以使用 Amazon S3 Batch Operations 對 Amazon S3 物件執行大規模的批次操作。**取代存取控制清單 (ACL)** 操作會取代資訊清單中所列每個物件的存取控制清單 (ACL)。透過使用 ACL，您將能夠來定義可存取物件的人員，以及這些人員可執行的動作。
**注意**
Amazon S3 中的大多數新式使用案例不再需要使用 ACL。建議您將 ACL 保持停用狀態，除非是在必須個別控制每個物件存取的情況。停用 ACL 後，您可以使用政策來控制對儲存貯體中所有物件的存取，無論是誰將物件上傳到您的儲存貯體。如需詳細資訊，請參閱[控制物件的擁有權並停用儲存貯體的 ACL](about-object-ownership.md)。
S3 Batch Operations 支援您定義的自訂 ACL，以及 Amazon S3 提供的標準 ACL (隨附一組預先定義的存取許可)。
若您資訊清單中的物件位於啟用版本控制的儲存貯體，您可以將 ACL 套用至每個物件的特定版本。若要執行這項操作，請為資訊清單中的每個物件指定版本 ID。如果您未包含任何物件的版本 ID，則 S3 Batch Operations 會將 ACL 套用至物件的最新版本。
如需 Amazon S3 中 ACL 的詳細資訊，請參閱[存取控制清單 (ACL) 概觀](acl-overview.md)。
**S3 封鎖公有存取權**
若要限制對儲存貯體中所有物件的公開存取，建議使用 Amazon S3 封鎖公開存取，而不是使用 S3 Batch Operations 套用 ACL。封鎖公用存取是一項快速生效的單一簡單操作，能夠限制每個儲存貯體或帳戶範圍內的公用存取。此行為使得 Amazon S3 封鎖公開存取成為更好的選擇，特別是在您的目標是控制儲存貯體或帳戶中所有物件公開存取的情況下。只有在您需要將自訂 ACL 套用至資訊清單中的每個物件時，才使用 S3 Batch Operations。如需 S3 封鎖公有存取的詳細資訊，請參閱[封鎖對 Amazon S3 儲存體的公開存取權](access-control-block-public-access.md)。
**S3 物件擁有權**
如果資訊清單中的物件位於使用**儲存貯體擁有者強制執行**之物件擁有權設定的儲存貯體中，則**取代存取控制清單 (ACL)** 操作只能指定向儲存貯體擁有者授予完全控制權的物件 ACL。在此情況下，**取代存取控制清單 (ACL)** 操作無法將物件 ACL 許可授予其他 AWS 帳戶 或 群組。如需詳細資訊，請參閱[控制物件的擁有權並停用儲存貯體的 ACL](about-object-ownership.md)。
## 法規與限制
當您使用 Batch Operations 取代 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 Batch Operations **取代存取控制清單 (ACL)** 作業。
+ 單一取代存取控制清單作業，最多可支援 200 億個物件的資訊清單。
# 使用批次操作還原物件
您可以使用 Amazon S3 Batch Operations 對 Amazon S3 物件執行大規模的批次操作。**還原**操作會針對您的清單檔案中列出的已封存 Amazon S3 物件，啟動還原請求。下列封存的物件必須先還原，才能供即時存取：
+ 在 S3 Glacier Flexible Retrieval 或 S3 Glacier Deep Archive 儲存類別中封存的物件
+ 透過 Archive Access 或 Deep Archive Access 方案中的 S3 Intelligent-Tiering 儲存類別封存的物件
在您的 S3 Batch Operations 作業中使用**還原** ([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 不會更新任務或另外通知您。不過，使用 S3 事件通知即可在 Amazon 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 Archive Access 和 Deep Archive Access 層物件為目標的**還原**操作時，請勿設定 `ExpirationInDays`。S3 Intelligent-Tiering Archive Access 層中的物件沒有還原到期日，因此指定 `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 儲存類別還原封存檔案，與從 Archive Access 或 Deep Archive Access 中的 S3 Intelligent-Tiering 儲存類別中還原檔案不同。
+ 當您從 S3 Glacier Flexible Retrieval 或 S3 Glacier Deep Archive 還原時，會建立物件的暫時*複本*。Amazon S3 會在您於 `ExpirationInDays` 引數中指定的值經過之後刪除此複本。刪除此暫時複本之後，您必須提交額外的還原請求才能存取物件。
+ 還原封存的 S3 Intelligent-Tiering 物件時，*請勿*指定 `ExpirationInDays` 引數。當您從 S3 Intelligent-Tiering Archive Access 或 Deep Archive Access 層還原物件時，物件會移回 S3 Intelligent-Tiering Frequent Access 層。在至少連續 90 天無存取的情況下，物件會自動移至 Archive Access 層。在至少連續 180 天無存取的情況下，物件會自動移至 Deep Archive Access 層。
+ 批次操作任務可以在 S3 Glacier Flexible Retrieval 和 S3 Glacier Deep Archive 儲存類別物件，*或者* S3 Intelligent-Tiering Archive Access 和 Deep Archive Access 儲存層物件上進行。批次操作無法在同一任務中同時對兩種類型的封存物件進行操作。若要還原這兩種類型的物件，您*必須*建立單獨批次操作任務。
## 重疊還原
如果您的 [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 Batch Operations 會依下列方式繼續進行。
如果滿足以下任一條件，則物件的還原操作將會成功：
+ 與已在進行中的還原請求相比，此任務的 `ExpirationInDays` 值相同，且其 `GlacierJobTier` 值較快。
+ 之前的還原請求已完成，且該物件目前可用。在此情況下，批次操作會更新還原物件的到期日期，以符合正在進行的還原請求中指定的 `ExpirationInDays` 值。
如果滿足以下任一條件，則物件的還原操作將會失敗：
+ 已在進行的還原請求尚未完成，而且此作業的還原持續時間 (由 `ExpirationInDays` 值指定) 與正在進行的還原請求中指定的還原持續時間不同。
+ 此作業的還原層 (由 `GlacierJobTier` 值指定) 等於或慢於正在進行的還原請求中指定的還原層。
## 限制
`S3InitiateRestoreObjectOperation` 作業具有下列限制：
+ 您必須在與封存物件相同的區域中建立任務。
+ S3 Batch Operations 不支援 `EXPEDITED` 擷取層。
+ 單一 Batch Operations 還原作業，最多可支援 40 億個物件的資訊清單。
如需還原物件的詳細資訊，請參閱[還原已封存的物件](restoring-objects.md)。
# 更新物件加密
您可以使用 Amazon S3 Batch Operations 對 Amazon S3 物件執行大規模的批次操作。Batch Operations [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 金鑰管理服務 (AWS KMS) 金鑰 (SSE-KMS)](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingKMSEncryption.html)，或套用 S3 儲存貯體金鑰。您也可以使用 `UpdateObjectEncryption`操作來變更用於加密資料的客戶受管 KMS 金鑰，以便符合自訂金鑰輪換標準。
當您建立批次操作任務時，您可以根據您指定的來源位置和篩選條件產生物件清單。您可以使用 `MatchAnyObjectEncryption`篩選條件，從要更新並包含在資訊清單中的儲存貯體中產生物件清單。產生的物件清單僅包含具有指定伺服器端加密類型的來源儲存貯體物件。如果您選取 SSE-KMS，您可以選擇指定特定 KMS 金鑰 ARN 和儲存貯體金鑰啟用狀態，以進一步篩選結果。如需詳細資訊，請參閱《[`SSEKMSFilter`*Amazon S3API 參考*》中的](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_SSEKMSFilter.html) [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_JobManifestGeneratorFilter.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_JobManifestGeneratorFilter.html)和 。
## 限制與考量事項
當您使用批次操作`UpdateObjectEncryption`操作時，適用下列限制和考量事項：
+ `UpdateObjectEncryption` 此操作不支援未加密的物件，或使用 (DSSE-KMS) 或客戶提供的加密金鑰 (SSE-C) 進行 AWS KMS keys 雙層伺服器端加密的物件。此外，您無法指定 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`請求僅限於儲存貯體擁有者 擁有的 KMS 金鑰 AWS 帳戶。如果您使用的是 AWS Organizations，您可以透過聯絡 來請求使用組織內其他成員帳戶 AWS KMS keys 擁有的功能 AWS 支援。
+ 如果您使用 S3 批次複寫來跨區域複寫資料集，且物件先前已將其伺服器端加密類型從 SSE-S3 更新為 SSE-KMS，則您可能需要額外的許可。在來源區域儲存貯體上，您必須擁有 `kms:decrypt` 許可。然後，您將需要目的地區域中儲存貯體的 `kms:decrypt`和 `kms:encrypt`許可。
+ 在`UpdateObjectEncryption`請求中提供完整的 KMS 金鑰 ARN。您無法使用別名名稱或別名 ARN。您可以在 AWS KMS 主控台或使用 AWS KMS `DescribeKey` API 來判斷完整的 KMS 金鑰 ARN。
+ 若要在使用`KmsKeyArn`篩選條件時改善資訊清單產生效能，請將此篩選條件與其他物件中繼資料篩選條件搭配使用。例如，當您在 S3 批次操作中自動產生資訊清單`MatchAnyStorageClass`時`MatchAnyPrefix`，您可以`KmsKeyArn`結合 `CreatedAfter`、 或 。
如需 `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 Batch Operations 服務主體擔任的 IAM 角色，以代表您執行 Batch Operations 任務，請參閱 [授予批次操作的許可](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 SDKs 或 Amazon S3 REST API 使用 S3 批次操作。 Amazon 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 CLI 命令 AWS CloudShell。 AWS CloudShell 是一種以瀏覽器為基礎的預先驗證 Shell，您可以直接從 啟動 AWS 管理主控台。如需詳細資訊，請參閱《AWS CloudShell 使用者指南》**中的[什麼是 CloudShell](https://docs.aws.amazon.com//cloudshell/latest/userguide/welcome.html) 和[開始使用 AWS CloudShell](https://docs.aws.amazon.com//cloudshell/latest/userguide/getting-started.html)。
**Example 1 – 建立批次操作任務，將加密的物件從一個更新 AWS KMS key 到另一個 KMS 金鑰**
下列範例示範如何建立 S3 批次操作任務，以更新一般用途儲存貯體中多個物件的加密設定。此命令會建立任務，將以 one 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 Batch Operations 對 Amazon S3 物件執行大規模的批次操作。您可以使用**物件鎖定保留**操作，透過「控管」**模式或「合規」**模式來為物件套用保留日期。這些保留模式可套用不同層級的保護。您可以將任一保留模式套用至任何物件版本。保留日期 (如法務保存) 可防止覆寫或刪除物件。Amazon S3 會將指定的「保留截止日期」**儲存在物件的中繼資料中，並保護物件版本的指定版本，直到保留期間到期為止。
您可以搭配物件鎖定使用 S3 Batch Operations，一次管理許多 Amazon S3 物件的保留日期。您可以在資訊清單中指定目標物件清單，並將此資訊清單提交給 Batch Operations 以便完成。如需詳細資訊，請參閱 S3 物件鎖定[保留期](object-lock.md#object-lock-retention-periods)。
搭配保留日期的 S3 批次作業任務會執行直到完成、取消或失敗狀態為止。當您想要透過單一請求新增、變更或移除多個物件的保留日期時，建議使用 S3 Batch Operations 和 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 開發套件](batch-ops-object-lock-retention.md#batch-ops-examples-java-object-lock-retention)。
## 法規與限制
當您使用 Batch Operations 來套用物件鎖定保留期間時，適用於下列限制：
+ S3 Batch Operations 不會進行任何儲存貯體層級變更。
+ 執行任務的儲存貯體上必須設定版本控制和 S3 物件鎖定。
+ 資訊清單中列出的所有物件都必須位於同一個儲存貯體中。
+ 除非在資訊清單中明確指定版本，否則作業會適用於物件的最新版本。
+ 您需要 IAM 角色具有 `s3:PutObjectRetention` 許可，才能使用**物件鎖定保留**作業。
+ 需要 `s3:GetBucketObjectLockConfiguration` IAM 許可，才能確認您執行作業所在的 S3 儲存貯體已啟用物件鎖定。
+ 您只能延長套用 `COMPLIANCE` 模式保留日期之物件的保留期間，無法縮短此保留期間。
+ 單一 S3 物件鎖定保留作業，最多可支援 200 億個物件的資訊清單。
# S3 物件鎖定法務保存
您可以使用 Amazon S3 Batch Operations 對 Amazon S3 物件執行大規模的批次操作。您可以使用**物件鎖定法務保存**操作，對物件版本進行法務保存。就像設定保留期一樣，法務保存可避免物件版本遭到覆寫或刪除。不過，法務保存沒有相關聯的保留期間，除非將其移除，否則會持續有效。
您可以搭配物件鎖定使用 S3 批次作業，一次為許多 Amazon S3 物件新增法務保存。若要執行這項操作，請在資訊清單中指定目標物件清單，並將該清單提交給 Batch Operations。您的 S3 Batch Operations **物件鎖定法務保存**作業會一直執行到完成、取消或出現失敗狀態為止。
S3 Batch Operations 會驗證您的 S3 儲存貯體上已啟用物件鎖定，再處理資訊清單中的任何物件。若要執行物件操作和儲存貯體層級驗證，S3 Batch Operations 需要 `s3:PutObjectLegalHold`和 AWS Identity and Access Management (IAM) 角色`s3:GetBucketObjectLockConfiguration`中的 。這些許可允許 S3 Batch Operations 代表您呼叫 S3 物件鎖定。
當您建立 S3 Batch Operations 作業以移除法務保存時，只需將法務保存狀態指定為 `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)。
## 法規與限制
當您使用 Batch Operations 來移除物件鎖定法務保存時，適用於下列限制：
+ S3 Batch Operations 不會進行任何儲存貯體層級變更。
+ 資訊清單中列出的所有物件都必須位於同一個儲存貯體中。
+ 執行任務的儲存貯體上必須設定版本控制和 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 SDKs 或 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 管理主控台 並開啟位於 https：//[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 的 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Batch Operations** (批次操作)。
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 Batch Operations 任務的詳細資訊，而不是透過列出任務來擷取的詳細資訊，您可以檢視單一任務的所有詳細資訊。您可以檢視尚未完成的任務，或過去 90 天內完成的任務的詳細資訊。除了任務清單中傳回的資訊之外，單一任務的詳細資訊還包含下列資訊：
+ 操作參數。
+ 資訊清單的詳細資訊。
+ 如果您在建立任務時設定了完成報告的相關資訊。
+ 您指派執行任務之 (IAM) 角色的 Amazon Resource Name AWS Identity and Access Management (ARN)。
透過檢視個別任務的詳細資訊，您可以存取任務的整個組態。若要檢視任務的詳細資訊，您可以使用 Amazon S3 主控台或 AWS Command Line Interface (AWS CLI)。
## 在 Amazon S3 主控台取得 S3 批次操作的任務說明
**使用主控台檢視批次操作任務說明**
1. 登入 AWS 管理主控台 ，並在 https：//[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 開啟 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Batch Operations** (批次操作)。
1. 選擇特定任務的 ID 以檢視其詳細資訊。
## 在 中取得 S3 批次操作任務描述 AWS CLI
下列範例使用 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 Batch Operations 作業指派數值優先順序，這可以是任何正整數。S3 Batch Operations 會根據指派的優先順序，排列作業的優先順序。優先順序較高的任務 (或優先順序參數較高的數值) 會先進行評估。優先順序會依遞減順序決定。例如，優先順序值為 10 的任務佇列的排程優先順序會高於優先順序值為 1 的任務佇列。
您可以在作業執行時變更作業的優先順序。如果您在任務執行時提交較高優先順序的新任務，則系統會暫停較低優先順序的任務，以允許優先順序較高之任務的執行。
變更作業的優先順序不會影響作業的處理速度。
**注意**
S3 Batch Operations 會盡力遵守作業優先順序。雖然優先順序較高的作業一般會優先於優先順序較低的作業，但 Amazon S3 不保證一定遵守作業順序。
## 使用 S3 主控台
**如何在 Amazon S3 主控台中更新作業優先順序**
1. 登入 AWS 管理主控台 ，並在 https：//[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 開啟 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Batch Operations** (批次操作)。
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 參考*》中的[更新批次任務的優先順序](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)
+ [
# 範例：透過 追蹤 Amazon EventBridge 中的 S3 批次操作任務 AWS CloudTrail
](batch-ops-examples-event-bridge-cloud-trail.md)
+ [
# 範例：S3 批次操作完成報告
](batch-ops-examples-reports.md)
## 任務狀態
建立和執行任務後，該任務會根據進度顯示一系列狀態。下表說明狀態和可能的轉換。
| 狀態 | 描述 | 轉換 |
| --- | --- | --- |
| `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 SDKs `DescribeJob`監控其進度。 | 當作業不再對物件執行操作時，作業將移出 `Active` 狀態。此行為可能會自動發生，例如當作業成功完成或失敗時。此行為也可能是使用者動作 (例如取消作業) 的結果。任務移至的狀態依轉換原因而定。 |
| `Pausing` | 任務正在從其他狀態轉換為 `Paused`。 | 當 `Paused` 階段結束時，任務將自動移到 `Pausing` 狀態。 |
| `Paused` | 如果在目前任務執行時提交優先順序更高的其他任務，該任務會變更為 `Paused` 狀態。 | 當有任何優先順序較高的任務，使 `Paused` 任務執行無法完成、失敗，或遭到暫停時，該任務將自動返回 `Active` 狀態。 |
| `Completing` | 任務正在從其他狀態轉換為 `Complete`。 | 當 `Complete` 階段結束時，任務將自動移到 `Completing` 狀態。 |
| `Complete` | 任務已完成對資訊清單中所有物件執行的請求操作。每個物件的操作可能成功或失敗。如果您已設定任務以產生完成報告，則當任務為 `Complete` 時，系統就會立即提供報告。 | `Complete` 是最終狀態。一旦作業達到 `Complete`，便不會轉換到任何其他狀態。 |
| `Cancelling` | 任務正在轉換為 `Cancelled` 狀態。 | 當 `Cancelled` 階段結束時，任務將自動移到 `Cancelling` 狀態。 |
| `Cancelled` | 您已請求取消作業，且 S3 Batch Operations 已成功取消作業。作業不會向 Amazon S3 提交任何新請求。 | `Cancelled` 是最終狀態。任務達到 `Cancelled` 之後，便不會轉換到任何其他狀態。 |
| `Failing` | 任務正在轉換為 `Failed` 狀態。 | 當 `Failed` 階段結束時，任務將自動移到 `Failing` 狀態。 |
| `Failed` | 任務已失敗，不再繼續執行。如需任務失敗的詳細資訊，請參閱[追蹤作業失敗](#batch-ops-job-status-failure)。 | `Failed` 是最終狀態。任務達到 `Failed` 之後，便不會轉換到任何其他狀態。 |
## 更新任務狀態
下列 AWS CLI 和 適用於 Java 的 AWS SDK 範例會更新批次操作任務的狀態。如需使用 Amazon S3 主控台管理 Batch Operations 作業的詳細資訊，請參閱[使用 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 參考*》中的[更新批次任務的狀態](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_UpdateJobStatus_section.html)。
## 通知和記錄日誌
除了請求完成報告之外，您還可以使用 AWS CloudTrail來擷取、檢閱和稽核 Batch Operations 活動。由於 Batch Operations 會使用現有的 Amazon S3 API 操作來執行任務，因此這些任務也會發出與您直接呼叫時的相同事件。因此，您可以使用您已運用在 Amazon S3 的相同通知、記錄及稽核工具和程序，追蹤和記錄作業及其所有任務的進度。如需詳細資訊，請參閱下列段落中的範例。
**注意**
Batch Operations 會在作業執行期間，於 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 Batch Operations 會將失敗代碼和原因連同作業一起儲存，以便您可以請求作業的詳細資訊來檢視。若您請求任務的完成報告，即會在該處顯示故障代碼和原因。
為了防止任務執行大量的失敗操作，Amazon S3 會對每個批次作業任務施加任務失敗閾值。當一個作業執行至少 1,000 個任務時，Amazon S3 會監控任務失敗率。若在任何一個時間點，失敗率 (失敗的任務數，以相對於已執行任務總數的比例呈現) 超過 50%，任務便會失敗。如果您的任務因超出任務失敗閾值而失敗，您可以判定失敗的原因。例如，您可能不小心在資訊清單中包含了一些在指定儲存貯體中不存在的物件。修復錯誤後，您可以重新提交任務。
**注意**
S3 Batch Operations 以非同步方式運作，任務不一定按照資訊清單列出物件的順序執行。因此，您無法使用資訊清單排序來確定哪些物件的任務成功，以及哪些物件的任務失敗。反之，您可以檢查任務的完成報告 （如果您請求） 或檢視 AWS CloudTrail 事件日誌，以協助判斷失敗的來源。
## 完成報告
當您建立任務時，您可以請求完成報告。只要 S3 Batch Operations 成功調用至少一個任務，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)
+ [
# 範例：透過 追蹤 Amazon EventBridge 中的 S3 批次操作任務 AWS CloudTrail
](batch-ops-examples-event-bridge-cloud-trail.md)
+ [
# 範例：S3 批次操作完成報告
](batch-ops-examples-reports.md)
# 範例：透過 追蹤 Amazon EventBridge 中的 S3 批次操作任務 AWS CloudTrail
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 批次操作事件
建立批次操作任務時，該任務會記錄為 CloudTrail 中的 `JobCreated` 事件。當任務執行時，它會在處理期間變更狀態，並在 CloudTrail 中記錄其他 `JobStatusChanged` 事件。您可以在 [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 Batch Operations，然後寫入最終完成報告。
```
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 Batch Operations 任務的存取權。標籤可用來識別負責批次操作任務的人員。任務標籤的存在可以授與或限制使用者的以下能力：取消任務、啟動處於確認狀態的任務或變更任務的優先順序層級。您可以建立已連接標籤的作業，也可以在建立作業之後為其新增標籤。每個標籤都是一個鍵值對，可以在建立任務時包含或稍後更新。
**警告**
請確定您的作業標籤不包含任何機密資訊或個人資料。
請考慮下列標記範例：假設您希望財務部門建立批次作業任務。您可以撰寫 AWS Identity and Access Management (IAM) 政策，允許使用者叫用 `CreateJob`，前提是任務是使用指派值 的`Department`標籤建立的`Finance`。此外，您可以將該政策連接到屬於財務部門成員的所有使用者。
您可以繼續使用此範例撰寫政策，允許使用者更新具有所需標籤之任何任務的優先順序，或取消任何具有該些標籤的任務。如需詳細資訊，請參閱[使用作業標籤控制 Batch Operations 的許可](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) – 傳回與 Batch Operations 作業相關聯的標籤組。
+ [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 批次作業會刪除物件上的現有標籤組。如果您使用此方法，則須支付 Tier 1 Request (`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) – 刪除與 Batch Operations 作業相關聯的標籤組。
# 建立具有任務標籤 (用於標示) 的批次作業任務
您可以透過新增「標籤」**來標記 Amazon S3 Batch Operations 作業並控制其存取。標籤可用來識別負責批次操作任務的人員。您可以建立已連接標籤的任務，也可以在建立任務後將標籤新增至任務。如需詳細資訊，請參閱[使用標籤控制存取和標記任務](batch-ops-job-tags.md)。
## 使用 AWS CLI
下列 AWS CLI 範例會使用任務標籤做為`S3PutObjectCopy`任務的標籤來建立 S3 批次操作任務。
1. 選取您要批次操作任務執行的動作或 `OPERATION`，然後選擇您的 `TargetResource`。
```
read -d '' OPERATION <
若要使用適用於 Java 的 AWS SDK 建立具有標籤的 S3 批次操作任務，您可以使用 S3Control 用戶端來設定任務參數，包括資訊清單位置、任務操作、報告設定，以及用於組織和追蹤目的的標籤。
如需如何使用適用於 Java 的 AWS SDK 建立具有標籤的 S3 批次操作任務的範例，請參閱《*Amazon S3 API 參考*》中的[建立批次任務以複製物件](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_CreateJob_section.html)。
# 從 S3 批次作業任務中刪除標籤
您可以使用下列範例來刪除 Amazon S3 Batch Operations 作業的標籤。
## 使用 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 參考*》中的[從批次任務刪除標籤](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_DeleteJobTagging_section.html)。
# 為現有的 Batch Operations 作業新增作業標籤
您可以使用 [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 Batch Operations 作業新增作業標籤。如需詳細資訊，請參閱下列範例。
## 使用 AWS CLI
以下示範如何使用 `s3control put-job-tagging`，透過 AWS CLI為 S3 Batch Operations 作業新增作業標籤。若要使用這些範例，請以您自己的資訊取代 *`user input placeholders`*。
**注意**
若傳送此請求時附上空的標籤組，則 Batch Operations 會刪除物件上的現有標籤組。不過，如果您使用此方法，則須支付 Tier 1 Request (`PUT`) 的費用。如需詳細資訊，請參閱 [Simple Storage Service (Amazon S3) 定價](https://aws.amazon.com/s3/pricing)。
反之，若要刪除 Batch Operations 作業的現有標籤，建議使用 `DeleteJobTagging` 操作，因為這可以達到相同的結果，而不會產生費用。
1. 識別您要用於任務的 `TAGS`。在本例中，您套用兩個標籤，`department` 和`FiscalYear`，分別具有數值 `Marketing` 和 `2020`。
```
read -d '' TAGS <
若要使用適用於 Java 的 AWS SDK 在 S3 批次操作任務上放置標籤，您可以使用 S3Control 用戶端新增或更新具有索引鍵值對的標籤，以用於組織和追蹤目的。
如需如何使用適用於 Java 的 AWS SDK 放置任務標籤的範例，請參閱《*Amazon S3 API 參考*》中的[將標籤新增至批次任務](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_PutJobTagging_section.html)。
# 取得 S3 批次作業任務的標籤
若要擷取 Amazon S3 Batch Operations 作業的標籤，您可以使用 `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 開發套件
若要使用適用於 Java 的 AWS SDK 取得 S3 批次操作任務的標籤，您可以使用具有任務 ID 的 S3Control 用戶端來擷取與批次操作任務相關聯的所有標籤，並將其傳回為清單。
如需如何使用適用於 Java 的 AWS SDK 取得任務標籤的範例，請參閱《*Amazon S3 API 參考*》中的[從批次任務取得標籤](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_GetJobTagging_section.html)。
# 使用作業標籤控制 Batch Operations 的許可
為了協助您管理 Amazon S3 Batch Operations 作業，您可以新增「作業標籤」**。您可以使用任務標籤控制對批次操作任務的存取，並強制在建立任何任務時套用標籤。
您最多可以將 50 個任務標籤套用至每個批次操作任務。透過使用標籤，您可以設定精細的政策來限制一組能夠編輯作業的使用者。任務標籤可以授與或限制使用者的以下能力：取消任務、啟動處於確認狀態的任務或變更任務的優先順序層級。此外，您可以強制將標籤套用至所有新任務，並為標籤指定允許的鍵值對。您可以使用 [AWS Identity and Access Management (IAM) 政策語言](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_iam-tags.html)來表達所有這些條件。如需詳細資訊，請參閱服務授權參考**中的 [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 Batch Operations 作業標籤，准許使用者僅能建立和編輯在其部門內執行的作業。您可以根據任務相關的開發階段指派任務，例如 QA 或生產。
下列範例使用以下部門，其中每個部門會以不同的方式使用 Batch Operations：
+ 財務
+ 合規
+ 商業智慧
+ 工程設計
**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 存取控制策略，您可以藉由將標籤 `department=Finance` 與其使用者關聯，以授予財務部門的使用者建立和管理其部門內 S3 批次操作任務的許可。
此外，您可以將受管政策連接至 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 SDKs 或 Amazon S3 REST API 使用 Amazon S3 批次操作。 Amazon S3
使用 S3 物件鎖定，您可以對物件版本進行法務保存。就像設定保留期一樣，法務保存可避免物件版本遭到覆寫或刪除。不過，法務保存沒有相關聯的保留期間，除非移除法務保存，否則會持續有效。如需詳細資訊，請參閱[S3 物件鎖定法務保存](batch-ops-legal-hold.md)。
若要搭配物件鎖定使用 S3 Batch Operations 一次為多個 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 Batch Operations 關閉 S3 物件鎖定法務保存
](batch-ops-legal-hold-off.md)
# 使用 S3 批次作業啟用 S3 物件鎖定
您可以搭配 S3 物件鎖定使用 Amazon S3 Batch Operations 來管理保留，或一次為多個 Amazon S3 物件啟用法務保存。您可以在資訊清單中指定目標物件的清單，並提交至批次操作以便完成。如需詳細資訊，請參閱[S3 物件鎖定保留](batch-ops-retention-date.md)及[S3 物件鎖定法務保存](batch-ops-legal-hold.md)。
下列範例示範如何建立具有 S3 批次操作許可的 AWS Identity and Access Management (IAM) 角色，並更新角色許可以建立啟用物件鎖定的任務。您也必須具有識別 S3 Batch Operations 作業物件的 `CSV` 資訊清單。如需詳細資訊，請參閱[指定資訊清單](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 Batch Operations 許可權的 IAM 角色，並更新角色權限以建立啟用物件鎖定的作業。您也必須擁有能識別用於 S3 批次操作任務之物件的 `CSV` 資訊清單。如需詳細資訊，請參閱[指定資訊清單](batch-ops-create-job.md#specify-batchjob-manifest)。
執行以下步驟：
1. 建立 IAM 角色並指派要執行的 S3 批次操作許可。所有 S3 批次操作任務都需要此步驟。
1. 設定具有 S3 物件鎖定的 S3 批次操作以便執行。
您允許角色執行下列動作：
1. 對包含要執行批次操作的目標物件的 S3 儲存貯體執行物件鎖定。
1. 讀取資訊清單 CSV 檔案和物件所在的 S3 儲存貯體。
1. 將 S3 Batch Operations 任務的結果寫入報告儲存貯體。
如需示範如何使用適用於 Java 的 AWS SDK 使用 S3 批次操作來建立 IAM 角色以啟用 S3 物件鎖定的程式碼範例，請參閱*AWS 適用於 Java 的 SDK 2.x 程式碼範例*中的 [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)。
# 使用批次作業設定物件鎖定保留
您可以搭配 S3 物件鎖定使用 Amazon S3 Batch Operations，一次管理多個 Amazon S3 物件的保留。您可以在資訊清單中指定目標物件的清單，並提交至批次操作以便完成。如需詳細資訊，請參閱[S3 物件鎖定保留](batch-ops-retention-date.md)及[S3 物件鎖定法務保存](batch-ops-legal-hold.md)。
下列範例示範如何建立具有 S3 批次操作許可的 AWS Identity and Access Management (IAM) 角色，並更新角色許可以包含`s3:PutObjectRetention`許可，讓您可以在資訊清單儲存貯體中的物件上執行 S3 物件鎖定保留。您也必須具有識別 S3 Batch Operations 作業物件的 `CSV` 資訊清單。如需詳細資訊，請參閱[指定資訊清單](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 S*Amazon S3 API 參考*》中的[搭配使用 CreateJob 與 AWS SDK 或 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 物件鎖定保留合規模式套用至多個物件，包括將保留模式設定為具有保留至日期的合規，以及將合規模式延長為保留至日期。
如需如何使用批次操作搭配適用於 Java 的 AWS SDK 將 S3 物件鎖定保留合規模式套用至多個物件的範例，請參閱《*Amazon S3 API 參考*》中的[搭配使用 CreateJob 與 AWS SDK 或 CLI](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_CreateJob_section.html)。
# 使用具有 S3 物件鎖定保留控管模式的 S3 批次操作
下列範例以先前建立信任政策的範例，以及設定 S3 Batch Operations 和 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 參考*》中的[搭配 AWS SDK 或 CLI 使用 CreateJob](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_CreateJob_section.html)。
# 使用 S3 Batch Operations 關閉 S3 物件鎖定法務保存
下列範例以先前建立信任原則的範例，以及設定 S3 批次操作和 S3 物件鎖定組態許可的範例為基礎。此範例示範如何使用 Batch Operations 停用物件的物件鎖定法務保存。
此範例會先更新角色以授予 `s3:PutObjectLegalHold` 許可、建立會關閉 (移除) 從資訊清單中識別之物件的法務保存的批次操作任務，然後報告該任務。
若要使用下列範例，請以您自己的資訊取代 *`user input placeholders`*。
## 使用 AWS CLI
下列 AWS CLI 範例示範如何使用批次操作來關閉多個物件的 S3 物件鎖定法務保存。
**Example — 更新角色以授予 `s3:PutObjectLegalHold` 許可**
```
export AWS_PROFILE='aws-user'
read -d '' legal_hold_permissions <
如需如何使用 S3 批次操作搭配適用於 Java 的 AWS SDK 關閉 S3 物件鎖定法務保存的範例，請參閱《*Amazon S3 API 參考*》中的[搭配 AWS SDK 或 CLI 使用 CreateJob](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_CreateJob_section.html)。
# 教學課程：使用 S3 Batch Operations 進行影片的批次轉碼
影片消費者使用各種類型、尺寸和年份的裝置來觀賞媒體內容。各式各樣的裝置對內容創作者和發行者來說是一項挑戰。影片必須經過轉換才能跨越各種大小、格式和位元率，而不是採用通用格式。當您有大量必須轉換的影片時，這項轉換任務更具挑戰性。
AWS 提供您建置可擴展、分散式架構的方法，以執行下列動作：
+ 擷取輸入影片
+ 處理影片，以在各種裝置上播放
+ 存放轉碼後的媒體檔案
+ 交付輸出媒體檔案，以滿足需求
當您在 Amazon S3 中存放了大量的影片儲存庫時，您可以將這些影片從其來源格式轉碼為特定影片播放器或裝置所需的大小、解析度和格式各異的多種檔案類型。具體而言，[S3 Batch Operations](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_tw/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 來源儲存貯體，請將與 **Block Public Access settings for this bucket** (此儲存貯體的封鎖公開存取設定) 相關的設定保留為預設值 (已啟用 **Block *all* public access** (封鎖所有公開存取))。如需詳細資訊，請參閱[建立一般用途儲存貯體](create-bucket-overview.md)。
如需有關將影片上傳至 S3 來源儲存貯體的詳細資訊，請參閱 [上傳物件](upload-objects.md)。如果您正在上傳許多大型影片到 S3，您會想要使用 [Amazon S3 Transfer Acceleration](https://aws.amazon.com/s3/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 管理主控台 ，並在 https：//[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 開啟 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Buckets** (儲存貯體)。
1. 選擇**建立儲存貯體**。
1. 針對 **Bucket name** (儲存貯體名稱)，輸入儲存貯體的名稱 (例如 `amzn-s3-demo-destination-bucket1`)。
1. 針對**區域**，選擇您希望儲存貯體所在的 AWS 區域 。
1. 若要確保公開存取您的輸出媒體檔案，請在 **Block Public Access settings for this bucket** (此儲存貯體的封鎖公開存取設定) 中，清除 **Block *all* public access** (封鎖所有公開存取)。
**警告**
在完成此步驟之前，請檢閱 [封鎖對 Amazon S3 儲存體的公開存取權](access-control-block-public-access.md) 以確保您了解並接受允許公開存取所涉及的風險。當您關閉 Block Public Access (封鎖公開存取) 設定以公開儲存貯體時，網際網路上的任何人都可以存取您的儲存貯體。我們建議您封鎖對儲存貯體的所有公用存取權。
如果不想清除 Block Public Access (封鎖公開存取) 設定，您可以使用 Amazon CloudFront 將轉碼的媒體檔案交付給瀏覽者 (最終使用者)。如需詳細資訊，請參閱[教學課程：使用 Amazon S3、Amazon CloudFront 和 Amazon Route 53 託管隨需串流影片](tutorial-s3-cloudfront-route53-video-streaming.md)。
1. 選取 **I acknowledge that the current settings might result in this bucket and the objects within becoming public** (我確認目前的設定可能會導致此儲存貯體及其中的物件變為公開) 旁的核取方塊。
1. 將其餘設定保持為預設值。
1. 選擇**建立儲存貯體**。
### 將 CORS 組態新增至 S3 輸出儲存貯體
JSON CORS 組態會定義一種方式，讓單一網域載入的用戶端 Web 應用程式 (即影片播放器)，能播放不同網域中的轉碼後的輸出媒體檔案。
1. 登入 AWS 管理主控台 ，並在 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)：// 開啟 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Buckets** (儲存貯體)。
1. 在 **Buckets** (儲存貯體) 清單中，選擇您先前建立的儲存貯體名稱 (例如，`amzn-s3-demo-destination-bucket1`)。
1. 選擇**許可**索引標籤。
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. 選擇**儲存變更**。
## 步驟 2：為 MediaConvert 建立 IAM 角色
若要使用 AWS Elemental MediaConvert 來轉碼存放在 S3 儲存貯體中的輸入影片，您必須具有 AWS Identity and Access Management (IAM) 服務角色，才能授予 MediaConvert 許可，以從 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 角色之後，在 **Roles** (角色) 清單中，選擇您已為 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 批次操作來批次轉碼影片，您需要使用 Lambda 函數來連接這兩個服務，進而轉換影片。此 Lambda 函數必須設有 IAM 角色，該角色可授予 Lambda 函數許可，以存取 MediaConvert 和 S3 批次操作。
**Topics**
+ [
### 為您的 Lambda 函數建立 IAM 角色
](#batchops-s3-step3-role)
+ [
### 嵌入 Lambda 函式的 IAM 角色內嵌政策
](#batchops-s3-step3-inline-policy)
### 為您的 Lambda 函數建立 IAM 角色
1. 登入 AWS 管理主控台 ，並在 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 開啟 IAM 主控台。
1. 在左側導覽窗格中，選擇 **Roles** (角色)，然後選擇 **Create role** (建立角色)。
1. 選擇 **AWS 服務**角色類型，然後在**常見使用案例**下，選擇 **Lambda**。
1. 選擇**下一步：許可**。
1. 在 **Attach Permissions policies** (連接許可政策) 頁面上，於 **Filter policies** (篩選政策) 方塊中輸入 **AWSLambdaBasicExecutionRole**。若要將受管政策 **AWSLambdaBasicExecutionRole** 連接至此角色，以授予寫入 Amazon CloudWatch Logs 的許可，選取 **AWSLambdaBasicExecutionRole** 旁的核取方塊。
1. 選擇**下一步**。
1. 在**角色名稱**中，輸入 **tutorial-lambda-transcode-role**。
1. (選用) 新增標籤至受管政策。
1. 選擇建**立角色**。
### 嵌入 Lambda 函式的 IAM 角色內嵌政策
若要將許可授予執行 Lambda 函式所需的 MediaConvert 資源，您必須使用內嵌政策。
1. 登入 AWS 管理主控台 並開啟位於 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 的 IAM 主控台。
1. 在左側導覽窗格中，選擇 **Roles** (角色)。
1. 在 **Roles** (角色) 清單中，選擇您在先前為您的 Lambda 函數建立的 IAM 角色的名稱 (例如，**tutorial-lambda-transcode-role**)。
1. 選擇 **Permissions (許可)** 標籤。
1. 選擇**新增內嵌政策**。
1. 選擇 **JSON** 標籤，然後將下列 JSON 政策複製後貼上。
在 JSON 政策中，將 `Resource` 的範例 ARN 值取代為您在[步驟 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. 選擇**檢閱政策**。
1. 對於 **Name** (名稱)，輸入 **tutorial-lambda-policy**。
1. 選擇**建立政策**。
在您建立內嵌政策後，該政策會自動嵌入您的 Lambda 函式的 IAM 角色中。
## 步驟 4：為影片轉碼建立 Lambda 函數
在此教學課程區段中，您會使用適用於 Python 的開發套件來建置一個 Lambda 函數，以與 S3 批次操作和 MediaConvert 整合。若要開始轉碼已存放在 S3 來源儲存貯體中的影片，您需要執行 S3 批次操作任務，該任務會直接為 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) 來最佳化影片品質。HLS 輸出符合 Apple 標準 (影片未混合音訊、區段持續時間為 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 批次操作會將特定的任務資料傳送至 Lambda 函數，並需要傳回結果資料。如需 Lambda 函數的請求和回應範例、回應和結果程式碼的資訊，以及 S3 批次操作的範例 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：//[https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) 開啟 AWS Lambda 主控台。
1. 在左側導覽窗格中，選擇 **Functions** (函數)。
1. 選擇 **Create function (建立函數)**。
1. 選擇 **Author from scratch** (從頭開始撰寫)。
1. 在**基本資訊**下，請執行下列動作：
1. 針對**函數名稱**，請輸入 **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. 選擇**建立函數**。
### 使用 .zip 檔案封存部署您的 Lambda 函數，並設定 Lambda 函數 (主控台)
1. 在頁面的 **Code Source** (程式碼來源) 區段中，為您先前建立的 Lambda 函數 (例如，**tutorial-lambda-convert**)，依次選擇 **Upload from** (上傳來源) 和 **.zip 檔案**。
1. 選擇 **Upload** (上傳) 以選取您的本機 `.zip` 檔案。
1. 選擇您之前建立的 `lambda.zip` 檔案，然後選擇 **Open** (開啟)。
1. 選擇**儲存**。
1. 在 **Runtime settings** (執行時間設定) 區段中，選擇 **Edit** (編輯)。
1. 若要告知 Lambda 執行時間要叫用 Lambda 函數程式碼中的處理常式方法，請在 **Handler** (處理常式) 欄位中輸入 **convert.handler**。
當您設定 Python 函式時，處理常式的設定值就是檔案名稱加上處理常式模組名稱，並且以點 (`.`) 分隔。例如，`convert.handler` 會呼叫 `convert.py` 檔案中定義的 `handler` 方法。
1. 選擇**儲存**。
1. 在 Lambda 函數頁面上，選擇 **Configuration** (組態) 標籤。在 **Configuration** (組態) 索引標籤的左側導覽窗格中，選擇 **Environment variables** (環境變數)，然後選擇 **Edit** (編輯)。
1. 選擇 **Add environment variable** (新增環境變數)。然後，為以下每個環境變數輸入指定的 **Key** (索引鍵) 和 **Value** (數值)：
+ **Key** (索引鍵)：**DestinationBucket** **Value** (數值)：**amzn-s3-demo-destination-bucket1**
該數值是您在[步驟 1](#batchops-s3-step1) 中建立的輸出媒體檔案的 S3 儲存貯體。
+ **Key** (索引鍵)：**MediaConvertRole** **Value** (數值)：**arn:aws:iam::*111122223333*:role/tutorial-mediaconvert-role**
該數值是您在[步驟 2](#batchops-s3-step2) 中為 MediaConvert 建立的 IAM 角色的 ARN。請務必將此 ARN 取代為 IAM 角色的實際 ARN。
+ **Key** (索引鍵)：**Application** **Value** (數值)：**Batch-Transcoding**
這是應用程式名稱的值。
1. 選擇**儲存**。
1. (選用) 在 **Configuration** (組態) 標籤上，在左側導覽窗格的 **General configuration** (一般組態) 區段中，選擇 **Edit** (編輯)。在 **Timeout** (逾時) 欄位中，輸入 **2** 分 **0** 秒。然後選擇 **Save (儲存)**。
**Timeout** (逾時) 是 Lambda 在停用函數前允許函數執行叫用的時間。預設為 3 秒。定價是根據設定的記憶體數量和程式碼執行的時間量而定。如需詳細資訊，請參閱 [AWS Lambda 定價](https://aws.amazon.com/lambda/pricing/?icmpid=docs_console_unmapped)。
## 步驟 5：為您的 S3 來源儲存貯體設定 Amazon S3 清查
設定 Lambda 函數轉碼後，您會建立 S3 批次操作任務以轉碼一組影片。首先，您需要一份您希望 S3 批次操作對其執行指定轉碼動作的輸入影片物件清單。若要取得輸入影片物件的清單，您可以為 S3 來源儲存貯體 (例如，`amzn-s3-demo-source-bucket`) 產生 S3 清查報告。
**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 管理主控台 ，並在 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)：// 開啟 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Buckets** (儲存貯體)。
1. 選擇**建立儲存貯體**。
1. 針對 **Bucket name** (儲存貯體名稱)，輸入儲存貯體的名稱 (例如 `amzn-s3-demo-destination-bucket2`)。
1. 針對 **AWS 區域**，選擇您希望儲存貯體所在的 AWS 區域 。
清查目的地儲存貯體必須 AWS 區域 與您設定 S3 清查的來源儲存貯體位於相同的 。清查目的地儲存貯體可位於不同的 AWS 帳戶之中。
1. 在 **Block Public Access settings for this bucket** (此儲存貯體的封鎖公開存取設定) 中，保留預設設定 (已啟用 **Block *all *public access** (封鎖所有公開存取))。
1. 對於其他設定，請保留預設值。
1. 選擇**建立儲存貯體**。
1. 在 **Buckets** (儲存貯體) 清單中，選擇您剛剛建立的儲存貯體名稱 (例如，`amzn-s3-demo-destination-bucket2`)。
1. 若要授予 Amazon S3 將清查報告的資料寫入 S3 清查目的地儲存貯體的許可，請選擇 **Permissions** (許可) 標籤。
1. 向下捲動到 **Bucket policy** (儲存貯體政策) 區段，然後選擇 **Edit** (編輯)。**Bucket policy** (儲存貯體政策) 頁面隨即開啟。
1. 若要授予 S3 清查的許可，請在 **Policy** (政策) 欄位中，貼上以下儲存貯體政策。
將三個範例值取代為下列值：
+ 您為存放清查報告而建立的儲存貯體名稱 (例如，`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. 選擇**儲存變更**。
### 為 S3 影片來源儲存貯體設定 Amazon S3 清查
若要產生影片物件和中繼資料的一般檔案清單，您需要為 S3 影片來源儲存貯體設定 S3 清查。這些排程清查報告可以包含儲存貯體中的所有物件，或是依共用字首分組的物件。在本教學課程中，S3 清查報告包含 S3 來源儲存貯體中的所有影片物件。
1. 登入 AWS 管理主控台 ，並在 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)：// 開啟 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Buckets** (儲存貯體)。
1. 若要在 S3 來源儲存貯體中設定輸入影片的 S3 清查報告，請在 **Buckets** (儲存貯體) 清單中，選擇 S3 來源儲存貯體的名稱 (例如，`amzn-s3-demo-source-bucket`)。
1. 選擇 **Management** (管理) 標籤，
1. 向下捲動至 **Inventory configurations** (清查組態) 區段，然後選擇 **Create inventory configuration** (建立清查組態)。
1. 在 **Inventory configuration name** (清查組態名稱) 中，輸入一個名稱 (例如，**tutorial-inventory-config**)。
1. 在**庫存範圍**下，針對**物件版本**選擇**僅限目前版本**，並將其他**庫存範圍**設定為本教學課程保留預設值。
1. 在 **Report details** (報告詳細資訊) 區段中，針對 **Destination bucket** (目的地儲存貯體)，選擇 **This account** (此帳戶)。
1. 針對 **Destination** (目的地)，選擇 **Browse S3** (瀏覽 S3)，然後選擇您先前建立的目的地儲存貯體，以儲存清查報告 (例如，`amzn-s3-demo-destination-bucket2`)。然後，選擇 **Choose path** (選擇路徑)。
清查目的地儲存貯體必須 AWS 區域 與您設定 S3 清查的來源儲存貯體位於相同的 。清查目的地儲存貯體可位於不同的 AWS 帳戶之中。
在 **Destination bucket** (目的地儲存貯體) 欄位下，您會看到 **Destination bucket permission** (目的地儲存貯體許可)，這會新增至清查目的地儲存貯體政策，以允許 Amazon S3 將資料放入清查目的地儲存貯體中。如需詳細資訊，請參閱[建立目的地儲存貯體政策](configure-inventory.md#configure-inventory-destination-bucket-policy)。
1. 針對 **Frequency** (頻率)，請選擇 **Daily** (每日)。
1. 在 **Output format** (輸出格式) 中，選擇 **CSV**。
1. 針對 **Status** (狀態)，請選擇 **Enable** (啟用)。
1. 在 **Server-side encryption** (伺服器端加密) 區段中，為此教學課程選擇 **Disable** (停用)。
如需詳細資訊，請參閱 [使用 S3 主控台設定清查](configure-inventory.md#configure-inventory-console) 和 [對 Amazon S3 授予許可使用您的客戶受管金鑰進行加密](configure-inventory.md#configure-inventory-kms-key-policy)。
1. 在 **Additional fields - *optional*** (其他欄位 - 選用) 區段中，選取 **Size** (大小)、**Last modified** (上次修改) 及 **Storage class** (儲存方案)。
1. 選擇**建立**。
如需詳細資訊，請參閱[使用 S3 主控台設定清查](configure-inventory.md#configure-inventory-console)。
### 檢查您的 S3 影片來源儲存貯體的清查報告
發佈清查報告時，資訊清單檔案會傳送到 S3 清查目的地儲存貯體。
1. 登入 AWS 管理主控台 並開啟位於 https：//[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 的 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Buckets** (儲存貯體)。
1. 在 **Buckets** (儲存貯體) 清單中，選擇影片來源儲存貯體的名稱 (例如，`amzn-s3-demo-source-bucket`)。
1. 選擇 **Management (管理)**。
1. 若要查看 S3 清查報告是否準備好讓您在[步驟 7](#batchops-s3-step7) 中建立 S3 批次操作任務，則在 **Inventory configurations** (清查組態) 下，檢查是否已啟用 **Create job from manifest** (從資訊清單建立任務) 按鈕。
**注意**
最多可能需要 48 小時的時間來提供首次清查報告。如果停用 **Create job from manifest** (從資訊清單建立任務) 按鈕，則尚未交付第一份清查報告。等到第一份清查報告交付，並且已啟用 **Create job from manifest** (從資訊清單建立任務) 按鈕，才能在[步驟 7](#batchops-s3-step7) 中建立 S3 批次操作任務。
1. 若要檢查 S3 清查報告 (`manifest.json`)，在 **Destination** (目的地) 欄位中，選擇您先前為存放清查報告而建立的清查目的地儲存貯體名稱 (例如，`amzn-s3-demo-destination-bucket2`)。
1. 在 **Objects** (物件) 索引標籤上，選擇具有 S3 來源儲存貯體名稱的現有資料夾 (例如，`amzn-s3-demo-source-bucket`)。然後在 **Inventory configuration name** (清查組態名稱) 中，選擇您先前建立清查組態時所輸入的名稱 (例如，**tutorial-inventory-config**)。
您可以看到以報告產生日期為名稱的資料夾清單。
1. 若要檢查某個特定日期的每日 S3 清查報告，請選擇具有對應產生日期名稱的資料夾，然後選擇 `manifest.json`。
1. 若要在特定日期檢查清查報告的詳細資訊，請在 **manifest.json** 頁面中，選擇 **Download** (下載) 或 **Open** (開啟)。
## 步驟 6：為 S3 批次操作建立 IAM 角色
若要使用 S3 批次操作進行批次轉碼，您必須先建立 IAM 角色，授予 Amazon S3 執行 S3 批次操作的許可。
**Topics**
+ [
### 為 S3 批次操作建立 IAM 政策
](#batchops-s3-step6-policy)
+ [
### 建立 S3 批次操作 IAM 角色並連接許可政策
](#batchops-s3-step6-role)
### 為 S3 批次操作建立 IAM 政策
您必須建立 IAM 政策，授予 S3 批次操作讀取輸入資訊清單、叫用 Lambda 函數及寫入 S3 批次操作任務完成報告的許可。
1. 登入 AWS 管理主控台 並開啟位於 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 的 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 主控台中的 **Functions** (函數) 頁面。
+ 在 **Functions** (函數) 清單中，選擇您在[步驟 4](#batchops-s3-step4) 中建立的 Lambda 函數名稱 (例如，**tutorial-lambda-convert**)。
+ 選擇 **Copy ARN** (複製 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. 在 **Name (名稱)** 欄位中，輸入 **tutorial-s3batch-policy**。
1. 選擇**建立政策**。
### 建立 S3 批次操作 IAM 角色並連接許可政策
1. 登入 AWS 管理主控台 並開啟位於 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 的 IAM 主控台。
1. 在左側導覽窗格中，選擇 **Roles** (角色)，然後選擇 **Create role** (建立角色)。
1. 選擇 **AWS 服務** 角色類型，然後選擇 **S3** 服務。
1. 在 **Select your use case** (選取使用案例) 下，選擇 **S3 Batch Operations** (S3 批次操作)。
1. 選擇**下一步**。
1. 在**連接許可**下，在搜尋方塊中輸入您先前建立的 IAM 政策名稱 (例如，**tutorial-s3batch-policy**) 以用來篩選政策清單。選取政策名稱 (例如，**tutorial-s3batch-policy**) 旁的核取方塊。
1. 選擇**下一步**。
1. 在**角色名稱**中，輸入 **tutorial-s3batch-role**。
1. 選擇建**立角色**。
建立 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 批次操作任務之前，請確定 **Create job from manifest** (從資訊清單建立任務) 按鈕已啟用。如需詳細資訊，請參閱[檢查您的 S3 影片來源儲存貯體的清查報告](#batchops-s3-step5-manifest)。如果 **Create job from 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 管理主控台 ，並在 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)：// 開啟 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Batch Operations** (批次操作)。
1. 選擇**建立任務**。
1. 針對 **AWS 區域**，選擇要在其中建立任務的區域。
在本教學課程中，若要使用 S3 批次操作任務來叫用 Lambda 函數，您必須在與資訊清單中參照的物件所在的 S3 影片來源儲存貯體相同的區域中建立任務。
1. 在 **Manifest** (資訊清單) 區段中，執行下列動作：
1. 針對 **Manifest format** (資訊清單格式)，選擇 **S3 Inventory report (manifest.json)** (S3 庫存報告 (manifest.json))。
1. 針對 **Manifest object** (資訊清單物件)，選擇 **Browse S3** (瀏覽 S3)，以查找您在[步驟 5](#batchops-s3-step5) 中為存放清查報告而建立的儲存貯體 (例如，`amzn-s3-demo-destination-bucket2`)。在 **Manifest object** (資訊清單物件) 頁面上，瀏覽物件名稱，直到找到特定日期的 `manifest.json` 檔案。此檔案會列出您想要批次轉碼的所有影片的相關資訊。當您找到 `manifest.json` 檔案時，請選擇檔案旁邊的選項按鈕。然後，選擇 **Choose path** (選擇路徑)。
1. (選用) 對於 **Manifest object version ID - *optional*** (資訊清單物件版本 ID - 選用)，如果您想要使用最新版本以外的版本，請輸入資訊清單物件的版本 ID。
1. 選擇**下一步**。
1. 若要使用 Lambda 函式轉碼選定的 `manifest.json` 檔案中列出的所有物件，請在**操作類型**下，選擇**調用 AWS Lambda 函式**。
1. 在 **Invoke Lambda function** (叫用 Lambda 函數) 區段中，執行下列動作：
1. 選擇 **Choose from functions in your account** (從帳戶中的函數選擇)。
1. 針對 **Lambda function** (Lambda 函數)，選擇您在[步驟 4](#batchops-s3-step4) 中建立的 Lambda 函數 (例如，**tutorial-lambda-convert**)。
1. 針對 **Lambda function version** (Lambda 函數版本)，請保留為預設值 **\$1LATEST**。
1. 選擇**下一步**。**Configure additional options** (設定其他選項) 頁面隨即開啟。
1. 在 **Additional options** (其他選項) 區段中，保留預設設定。
如需關於這些選項的詳細資訊，請參閱 [批次操作任務請求元素](batch-ops-create-job.md#batch-ops-create-job-request-elements)。
1. 在 **Completion report** (完成報告) 區段中, 針對 **Path to completion report destination** (完成報告目的地的路徑)，選擇 **Browse S3** (瀏覽 S3)。找出在[步驟 1](#batchops-s3-step1) 中您為輸出媒體檔案建立的儲存貯體 (例如，`amzn-s3-demo-destination-bucket1`)。選擇儲存貯體名稱旁的選項按鈕。然後，選擇 **Choose path** (選擇路徑)。
對於剩餘的 **Completion report** (完成報告) 設定，請保留預設值。如需完成報告設定的詳細資訊，請參閱 [批次操作任務請求元素](batch-ops-create-job.md#batch-ops-create-job-request-elements)。完成報告會維護任務的詳細資訊和執行的操作的記錄。
1. 在 **Permissions** (許可) 區段中，選擇 **Choose from existing IAM roles** (從現有 IAM 角色中選擇)。對於 **IAM role** (IAM 角色)，為您在[步驟 6](#batchops-s3-step6) 中建立的 S3 批次操作任務選擇 IAM 角色 (例如，**tutorial-s3batch-role**)。
1. 選擇**下一步**。
1. 請詳閱 **Review** (檢閱) 頁面上的設定。然後，選擇 **Create Job** (建立任務)。
在 S3 完成讀取 S3 批次操作任務的資訊清單後，會將任務的 **Status** (狀態) 設定為 **Awaiting your confirmation to run** (等待確認執行)。若要查看任務狀態的更新，請重新整理頁面。您無法執行任務，直到其狀態為 **Awaiting your confirmation to run** (等待確認執行)。
### 執行 S3 批次操作任務來叫用 Lambda 函數
執行批次操作任務以叫用 Lambda 函數進行影片轉碼。如果您的任務失敗，您可以檢查完成報告，以找出原因。
**執行 S3 批次操作任務**
1. 登入 AWS 管理主控台 並開啟位於 https：//[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 的 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Batch Operations** (批次操作)。
1. 從 **Jobs** (任務) 清單中，選擇第一列的任務的 **Job ID** (任務 ID)，也就是您先前建立的 S3 批次操作任務。
1. 選擇**執行工作**。
1. 再次檢閱您的任務參數，並確認 **Total objects listed in manifest** (資訊清單中列出的物件總數) 的數值與資訊清單中的物件數目相同。接著選擇 **Run job** (執行任務)。
隨即開啟 S3 批次操作任務頁面。
1. 開始執行任務後，在任務頁面上的 **Status** (狀態) 下，檢查 S3 批次操作任務的進度，例如 **Status** (狀態)、**% Complete** (完成百分比)、**Total succeeded (rate)** (總成功 (率))、**Total failed (rate)** (總失敗 (率))、**Date terminated** (終止日期) 以及 **Reason for termination** (終止的原因)。
S3 批次操作任務完成時，請檢視任務頁面上的資料，以確認任務是否如預期完成。
如果超過 50% 的 S3 批次操作任務的物件操作在嘗試超過 1,000 次操作後失敗，則任務會自動失敗。若要檢查完成報告以識別失敗的原因，請使用下列選用程序。
### (選用) 檢查完成報告
您可以使用完成報告來判斷哪些物件失敗以及失敗的原因。
**若要檢查完成報告，以取得失敗物件的詳細資訊**
1. 在 S3 批次操作任務的頁面上，向下捲動至 **Completion report** (完成報告) 區段，然後選擇 **Completion report destination** (完成報告目的地) 下的連結。
S3 輸出目的地儲存貯體頁面隨即開啟。
1. 在 **Objects** (物件) 索引標籤上，選擇名稱以您先前建立之 S3 批次操作任務的任務 ID 為結尾的資料夾。
1. 選擇 **results/**。
1. 選取 `.csv` 檔案旁的核取方塊。
1. 若要檢視任務報告，請選擇 **Open** (開啟) 或 **Download** (下載)。
### (選用) 監控 Lambda 主控台中的每個 Lambda 叫用
開始執行 S3 批次操作任務之後，任務會叫用每個輸入影片物件的 Lambda 函數。S3 會將每次 Lambda 叫用的日誌寫入 CloudWatch Logs。您可以使用 Lambda 主控台的監控儀表板來監控您的 Lambda 函數。
1. 在 https：//[https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) 開啟 AWS Lambda 主控台。
1. 在左側導覽窗格中，選擇 **Functions** (函數)。
1. 在 **Functions** (函數) 清單中，選擇您在[步驟 4](#batchops-s3-step4) 中建立的 Lambda 函數名稱 (例如，**tutorial-lambda-convert**)。
1. 選擇 **Monitor** (監控) 索引標籤。
1. 在 **Metrics** (指標) 下，請參閱 Lambda 函數的執行時間指標。
1. 在 **Logs** (日誌) 下，透過 CloudWatch Logs 洞察檢視每個 Lambda 叫用的日誌資料。
**注意**
當您搭配 Lambda 函數使用 S3 批次操作時，Lambda 函數會叫用每個物件。如果您的 S3 批次操作任務較大，則可以同時叫用多個 Lambda 函數，會造成 Lambda 並行峰值。
每個 AWS 帳戶 都有每個區域的 Lambda 並行配額。如需詳細資訊，請參閱《AWS Lambda 開發人員指南》**中的 [AWS Lambda 函數擴展](https://docs.aws.amazon.com/lambda/latest/dg/invocation-scaling.html)。搭配 S3 批次操作使用 Lambda 函數的最佳實務是設定 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：//[https://console.aws.amazon.com/mediaconvert/](https://console.aws.amazon.com/mediaconvert/) 開啟 MediaConvert 主控台。
1. 出現 MediaConvert 簡介頁面時，請選擇 **Get Started** (開始使用)。
1. 從 **Jobs** (任務) 清單中，檢視每一列，以監控每個輸入影片的轉碼任務。
1. 識別您要檢查的任務列，然後選擇 **Job ID** (任務 ID) 連結，以開啟任務詳細資訊頁面。
1. 在 **Job summary** (任務摘要) 頁面，在 **Outputs** (輸出) 下，根據瀏覽器支援的內容，選擇 HLS、MP4 或縮圖輸出的連結，以前往輸出媒體檔案的 S3 目的地儲存貯體。
1. 在 S3 輸出目的地儲存貯體的對應資料夾 (HLS、MP4 或縮圖) 中，選擇輸出媒體檔案物件的名稱。
物件詳細資訊頁面隨即開啟。
1. 在物件詳細資訊頁面的 **Object overview** (物件概觀) 下，選擇 **Object URL** (物件 URL)，以觀看轉碼後的輸出媒體檔案。
## 步驟 8：從 S3 目的地儲存貯體檢查輸出媒體檔案
**若要從 S3 目的地儲存貯體檢查輸出媒體檔案**
1. 登入 AWS 管理主控台 ，並在 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)：// 開啟 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Buckets** (儲存貯體)。
1. 在 **Buckets** (儲存貯體) 清單中，選擇您在[步驟 1](#batchops-s3-step1) 中建立的輸出媒體檔案的 S3 目的地儲存貯體名稱 (例如，`amzn-s3-demo-destination-bucket1`)。
1. 在 **Objects** (物件) 標籤上，每個輸入影片都有一個具有輸入影片名稱的資料夾。每個資料夾皆包含輸入影片的轉碼後的輸出媒體檔案。
若要檢查輸入影片的輸出媒體檔案，請執行下列動作：
1. 選擇以您要檢查的輸入影片名稱命名的資料夾。
1. 選擇 **Default/** 資料夾。
1. 選擇轉碼後的格式的資料夾 (本教學課程中為 HLS、MP4 或縮圖)。
1. 選擇輸出媒體檔案的名稱。
1. 如要觀看轉碼後的檔案，在物件詳細資訊頁面上，選擇 **Object URL** (物件 URL) 下的連結。
HLS 格式的輸出媒體檔案會分割成數個短區段。若要播放這些影片，請在相容的播放器中嵌入 `.m3u8` 檔案。
## 步驟 9：清除
如果您只將 S3 Batch Operations、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 管理主控台 ，並在 https：//[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 開啟 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Buckets** (儲存貯體)。
1. 在 **Buckets** (儲存貯體) 清單中，選擇來源儲存貯體的名稱 (例如，`amzn-s3-demo-source-bucket`)。
1. 選擇 **Management** (管理) 標籤，
1. 在 **Inventory configurations** (清查組態) 中，選擇您在[步驟 5](#batchops-s3-step5) 中建立的清查組態 (例如，**tutorial-inventory-config**) 旁的選項按鈕。
1. 選擇 **Delete** (刪除)，然後選擇 **Confirm** (確認)。
### 刪除 Lambda 函數
1.
在 https：//[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. 在 **Delete function** (刪除函數) 對話方塊中，選擇 **Delete** (刪除)。
### 刪除 CloudWatch 日誌群組
1. 透過 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 開啟 CloudWatch 主控台。
1. 在左側導覽窗格中，選擇 **Logs** (日誌)，然後選擇 **Log groups** (日誌群組)。
1. 選取日誌群組旁的核取方塊，該日誌群組的名稱以您在[步驟 4](#batchops-s3-step4) 中建立的 Lambda 函數結尾 (例如，**tutorial-lambda-convert**)。
1. 選擇 **Actions** (動作)，然後選擇 **Delete log group** (刪除日誌群組)。
1. 在 **刪除日誌群組** 對話方塊中，選擇 **刪除** 。
### 刪除 IAM 角色以及 IAM 角色的內嵌政策
若要刪除您在[步驟 2](#batchops-s3-step2)、[步驟 3](#batchops-s3-step3) 及[步驟 6](#batchops-s3-step6) 中建立的 IAM 角色，請執行下列動作：
1. 登入 AWS 管理主控台 並開啟位於 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 的 IAM 主控台。
1. 在左側導覽窗格中，選擇 **Roles** (角色)，然後選取您要刪除之角色名稱旁的核取方塊。
1. 在頁面頂端，選擇 **Delete** (刪除)。
1. 在確認對話方塊中，根據提示在文字輸入欄位中輸入所需的回應，然後選擇 **Delete** (刪除)。
### 刪除客戶受管的 IAM 政策
若要刪除您在[步驟 6](#batchops-s3-step6) 中建立的客戶受管的 IAM 政策，請執行下列動作：
1. 登入 AWS 管理主控台 ，並在 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 開啟 IAM 主控台。
1. 在左側導覽窗格中選擇 **Policies** (政策)。
1. 選擇您在[步驟 6](#batchops-s3-step6) 中建立之政策 (例如，**tutorial-s3batch-policy**) 旁的選項按鈕。您可以使用搜尋方塊來篩選政策清單。
1. 選擇 **動作**，然後選擇 **刪除**。
1. 在文字欄位中，輸入本政策的名稱，以確認您要刪除此政策，然後選擇 **Delete** (刪除)。
### 清空 S3 儲存貯體
若要清空您在[先決條件](#batchops-s3-prerequisites)、[步驟 1](#batchops-s3-step1) 及[步驟 5](#batchops-s3-step5) 中建立的 S3 儲存貯體，請執行下列動作：
1. 登入 AWS 管理主控台 ，並在 https：//[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 開啟 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Buckets** (儲存貯體)。
1. 在 **Bucket** (儲存貯體) 清單中，選擇您要清空之儲存貯體名稱旁的選項按鈕，然後選擇 **Empty** (清空)。
1. 在 **Empty bucket** (清空儲存貯體) 頁面上，在文字欄位中輸入 **permanently delete** 以確認您要清空儲存貯體，然後選擇 **Empty** (清空)。
### 刪除 S3 儲存貯體
若要刪除您在[先決條件](#batchops-s3-prerequisites)、[步驟 1](#batchops-s3-step1) 及[步驟 5](#batchops-s3-step5) 中建立的 S3 儲存貯體，請執行下列動作：
1. 登入 AWS 管理主控台 ，並在 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)：// 開啟 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Buckets** (儲存貯體)。
1. 在 **Buckets** (儲存貯體) 清單中，選擇您要刪除之儲存貯體名稱旁的選項按鈕。
1. 選擇 **刪除**。
1. 在 **Delete bucket** (刪除儲存貯體) 頁面上，在文字欄位中輸入儲存貯體名稱以確認您要刪除該儲存貯體，然後選擇 **Delete bucket** (刪除儲存貯體)。
## 後續步驟
完成本教學課程後，您可以進一步探索其他相關使用案例：
+ 您可以使用 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 Batch Operations 進行故障診斷
Amazon S3 Batch Operations 可讓您對 Amazon S3 物件執行大規模的操作。本指南可協助您針對可能遇到的常見問題進行故障診斷。
若要對 S3 批次複寫問題進行故障診斷，請參閱[故障排除複寫](replication-troubleshoot.md)。
有兩種主要類型的失敗會導致 Batch Operations 錯誤：
1. **API 失敗** – 請求的 API (例如 `CreateJob`) 無法執行。
1. **作業失敗** – 初始 API 請求成功，但作業失敗，例如由於資訊清單或資訊清單中指定物件的權限問題。
## NoSuchJobException
**類型**：API 失敗
當 S3 Batch Operations 找不到指定的任務時，就會發生 `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 Batch Operations 成功調用至少一個任務，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 Batch Operations 請求因權限不足、不受支援的操作或政策限制而遭到封鎖時，就會發生 `AccessDeniedException`。這是 Batch Operations 中最常見的錯誤之一。它有下列常見原因：
1. **缺少 IAM 許可** – IAM 身分缺少 Batch Operations 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. **監控許可權變更** – 設定可能影響 Batch Operations 的 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 指南》中的[使用端點政策控制對 VPC 端點的存取](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:UpdateJobStatus`、 `s3:UpdateJobPriority`和 `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 端點政策允許 Batch Operations。
1. 使用下列命令，以使用 CloudTrail 識別許可權失敗。
```
aws logs filter-log-events --log-group-name CloudTrail/S3BatchOperations \
--filter-pattern "{ $.errorCode = AccessDenied }" \
--start-time timestamp
```
#### SlowDownError
**類型**：API 失敗
當您的帳戶超出 S3 Batch Operations 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 SDKs 包含速率限制錯誤的內建重試邏輯。設定如下：
1. **AWS CLI** – 使用 `cli-read-timeout` 和 `cli-connect-timeout` 參數。
1. **AWS 適用於 Python 的 SDK (Boto3)** – 在用戶端組態中設定重試模式和最大嘗試次數。
1. **AWS 適用於 Java 的 SDK** – 使用 `RetryPolicy` 和 `ClientConfiguration`設定。
1. **AWS 適用於 JavaScript 的 SDK** – 設定 `maxRetries`和 `retryDelayOptions`。
如需重試模式和最佳實務的詳細資訊，請參閱 AWS 規範性指引指南中的[使用退避模式重試](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 Batch Operations 無法處理任務時，就會發生 `InvalidManifestContent` 例外狀況。它有下列常見原因：
1. **格式不符** – 缺少必要欄、不正確的分隔符號或格式不正確的 CSV 結構。
1. **內容編碼問題** – 字元編碼不正確、BOM 標記或非 UTF-8 字元。
1. **物件索引鍵問題** – 無效的字元、不正確的 URL 編碼，或索引鍵超出長度限制。
1. **大小限制** – 資訊清單包含的物件數量超出作業支援的數量。
1. **版本 ID 格式錯誤** – 版本控制物件的版本 ID 格式不正確或無效。
1. **ETag 格式問題** – 需要 ETag 之操作的 ETags 格式不正確或缺少引號。
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. **缺少必要欄** – 確保您的資訊清單包含操作類型的所有必要欄。最常見的遺失欄是儲存貯體和索引鍵。
1. **CSV 格式不正確** – 使用逗號分隔符號，確保所有列的欄數一致，並避免欄位中有嵌入換行符號。
1. **物件索引鍵中的特殊字元** – URL 編碼物件索引鍵，其中包含空格、Unicode 字元或 XML 特殊字元 (＜、＞、&、"、')。
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
```