# バッチオペレーションでオブジェクトオペレーションを一括で実行する
S3 バッチ操作を使用すると、Amazon S3 のオブジェクトに対して大規模なバッチ操作を実行することができます。S3 バッチ操作では、指定した Amazon S3 のオブジェクトのリストに対して、1 つのオペレーションを実行できます。1 つのジョブで、エクサバイトのデータを含む数十億ものオブジェクトに対して、指定されたオペレーションを実行できます。Amazon S3 は、進捗状況の追跡、通知の送信、すべてのアクションの詳細な完了レポートの保存を行い、フルマネージド型の監査可能なサーバーレスエクスペリエンスを提供します。S3 バッチオペレーションは、Amazon S3 コンソール、AWS Command Line Interface (AWS CLI)、AWS SDK、または Amazon S3 REST API を通じて使用できます。
S3 バッチオペレーションを使用して、オブジェクトのコピー、オブジェクトのサーバー側の暗号化の更新、オブジェクトのタグやアクセスコントロールリスト (ACL) の設定を行います。また、S3 Glacier Flexible Retrieval からオブジェクトの復元を行ったり、AWS Lambda 関数を呼び出してオブジェクトを使用してカスタムアクションを実行したりすることもできます。これらのオペレーションは、指定したオブジェクトのカスタムリストに対して実行できます。また、Amazon S3 インベントリレポートを使用して、オブジェクトのリストを簡単に作成することもできます。Amazon S3 バッチオペレーションは、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)」を参照してください。S3 Express One Zone とディレクトリバケットでのバッチオペレーションの使用の詳細については、「[ディレクトリバケットでのバッチオペレーションの使用](directory-buckets-objects-Batch-Ops.md)」を参照してください。
## S3 バッチ操作の基本
S3 バッチオペレーションを使用して Amazon S3 のオブジェクトに対する大規模なバッチオペレーションを実行できます。S3 バッチ操作では、指定した Amazon S3 のオブジェクトのリストに対して、1 つのオペレーションまたはアクションを実行できます。
### 用語
このセクションでは、次のように定義される*マニフェスト*、*ジョブ*、*オペレーション*、および*タスク*の用語を使用します。
**マニフェスト**
マニフェストは、Amazon S3 が動作するオブジェクトキーを含む Amazon S3 オブジェクトです。バッチオペレーションジョブを作成する場合は、マニフェストを指定する必要があります。ユーザーが生成したマニフェストには、各オブジェクトのバケット名、オブジェクトキー、およびオプションでオブジェクトバージョンを含める必要があります。ユーザーが作成したマニフェストを提供する場合は、Amazon S3 インベントリレポートまたは CSV ファイルの形式である必要があります。
ジョブの作成時に指定したオブジェクトフィルター条件に基づいてマニフェストを自動的に生成するように Amazon S3 に指示できます。このオプションは、Amazon S3 コンソールを使用して作成したバッチオペレーションジョブ、または AWS Command Line Interface (AWS CLI)、AWS SDK、または Amazon S3 REST API を使用して作成した任意のジョブタイプで使用できます。
**ジョブ**
ジョブは、S3 バッチ操作の基本単位です。ジョブには、マニフェストにリストされているオブジェクトに対して指定されたオペレーションを実行するために必要なすべての情報が含まれています。この情報を入力してからジョブの開始をリクエストすると、ジョブはマニフェスト内の各オブジェクトにおいてオペレーションを実行します。
**オペレーション**
オペレーションは、バッチ操作のジョブで実行する API の[アクション](https://docs.aws.amazon.com/AmazonS3/latest/API/API_Operations.html)の種類 (オブジェクトのコピーなど) です。各ジョブは、マニフェストで指定されているすべてのオブジェクトに対して 1 種類のオペレーションを実行します。
**タスク**
タスクは、ジョブ実行の単位です。タスクは、1 つのオブジェクトに対してジョブのオペレーションを実行するための Amazon S3 または AWS Lambda API のオペレーションの 1 回の呼び出しを表します。S3 バッチ操作は、ジョブの実行中に、マニフェストで指定されている各オブジェクトに対して 1 つのタスクを作成します。
### S3 バッチ操作のジョブの仕組み
ジョブは、S3 バッチ操作の基本単位です。ジョブには、オブジェクトのリストに対して指定されたオペレーションを実行するために必要なすべての情報が含まれています。ジョブを作成するには、S3 バッチ操作にオブジェクトのリストを渡し、それらのオブジェクトに対して実行するアクションを指定します。S3 バッチ操作がサポートするオペレーションの詳細については、[S3 バッチ操作でサポートされるオペレーション](batch-ops-operations.md) を参照してください。
バッチジョブは、そのマニフェストに含まれるすべてのオブジェクトで指定されたオペレーションを実行します。**マニフェストには、バッチジョブで処理するオブジェクトが一覧表示され、オブジェクトとしてバケットに保存されます。カンマ区切り値 (CSV) 形式の [S3 インベントリを使用したデータのカタログ化と分析](storage-inventory.md) レポートをマニフェストとして使用できます。これにより、バケット内に配置されたオブジェクトの大きなリストを簡単に作成できます。1 つのバケット内に含まれるカスタマイズされたオブジェクトのリストに対してバッチ操作を実行できるように、シンプルな CSV 形式でマニフェストを指定することもできます。
ジョブを作成すると、Amazon S3 はマニフェストにリストされているオブジェクトを処理し、指定されたオペレーションをそれぞれのオブジェクトに対して実行します。ジョブの実行中は、プログラムまたは Amazon S3 コンソールで進捗状況をモニタリングできます。終了時に完了レポートを生成するようにジョブを設定することもできます。完了レポートには、ジョブによって実行された各タスクの結果が示されます。ジョブのモニタリングの詳細については、「[S3 バッチ操作ジョブの管理](batch-ops-managing-jobs.md)」を参照してください。
S3 バッチオペレーションにはコストがかかります。バッチオペレーションジョブの作成 (完了前にキャンセルしたジョブを含む) に対して課金されます。詳細については、「[Amazon S3 の料金](https://aws.amazon.com/s3/pricing/)」を参照してください。
S3 バッチオペレーションジョブはデフォルトで、すべてのオペレーションで最大 40 億個のオブジェクトを処理できます。具体的には、コピー、オブジェクトのタグ付け、Object Lock、AWS Lambda 関数の呼び出し、バッチレプリケーションジョブは、最大 200 億個のオブジェクトをサポートできます。AWS アカウントごとにアクティブなバッチレプリケーションジョブは 6 つに制限されています。バッチオペレーションジョブの作成を開始するには、「[S3 バッチオペレーションジョブの作成](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-create-job.html)」を参照してください。
## S3 バッチ操作のチュートリアル
次のチュートリアルでは、いくつかのバッチ操作タスクにおけるエンドツーエンドの一連の手順について説明します。
+ [チュートリアル: S3 バッチオペレーションを使用した動画のバッチトランスコーディング](tutorial-s3-batchops-lambda-mediaconvert-video.md)
# バッチオペレーションに対するアクセス許可の付与
S3 バッチ操作ジョブを作成して実行する前に、必要な許可を付与する必要があります。Amazon S3 バッチ操作ジョブを作成するには、`s3:CreateJob` ユーザー許可が必要です。ジョブを作成する同じエンティティには、ジョブに対して指定された AWS Identity and Access Management (IAM) ロールをバッチオペレーションに渡すための `iam:PassRole` 許可も必要です。
以下のセクションでは、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 バッチ操作のサービスプリンシパル (`batchoperations.s3.amazonaws.com`) がロールを引き受けることを許可します。アクセス許可ポリシーは、ジョブに指定した設定に基づいて、ジョブを実行するために必要なすべてのアクションを許可します。例えば、AWS アカウント内の 1 つのバケットから別のバケットにオブジェクトをコピーするようにジョブを設定する場合、アクセス許可ポリシーは `s3:GetObject` や `s3:PutObject` などのアクションを許可します。ジョブを送信する前に、ロールの信頼ポリシーとアクセス許可ポリシーを確認できます。このオプションは、Amazon S3 コンソールを使用してジョブを作成し、フィルターを使用するか、レプリケーション設定に基づく S3 生成オブジェクトリストを使用するようにジョブを設定する場合にのみ使用できます。ジョブを送信すると、IAM ロールはアカウントに保持されます。その後、同じオペレーションを実行する後続のジョブに再度使用したり、ジョブの実行が終了したときに削除したりできます。
IAM ロールを手動で作成する場合は、このセクションのポリシー例がロールの作成に役立ちます。ロールの作成と設定の詳細については、「*IAM ユーザーガイド*」の「[IAM ロール](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)」を参照してください。S3 リソースタイプ別の S3 API オペレーションのアクセス許可の詳細については、「[Amazon S3 API オペレーションに必要なアクセス許可](using-with-s3-policy-actions.md)」を参照してください。その他の例については、「[ジョブタグを使用したバッチオペレーションのアクセス許可の制御](batch-ops-job-tags-examples.md)」および「[S3 バッチ操作を使用したオブジェクトのコピー](batch-ops-examples-copy.md)」を参照してください。
IAM ポリシーでは、条件キーを使用して、S3 バッチ操作ジョブのアクセス許可をフィルタリングすることもできます。Amazon S3 固有の条件キーの詳細な情報と完全なリストについては、「サービス認可リファレンス」の「[Actions, resources, and condition keys for Amazon S3](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazons3.html)」を参照してください。**
S3 リソースタイプ別の S3 API オペレーションへのアクセス許可の詳細については、「[Amazon S3 API オペレーションに必要なアクセス許可](using-with-s3-policy-actions.md)」を参照してください。
次の動画には、Amazon S3 コンソールを使用してバッチオペレーションジョブの IAM アクセス許可を設定する方法が含まれています。
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/qpwHUrwAiUI/)
### 信頼ポリシー
S3 バッチ操作のサービスプリンシパルが IAM ロールを引き受けることを許可するには、ロールに次の信頼ポリシーをアタッチします。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Principal":{
"Service":"batchoperations.s3.amazonaws.com"
},
"Action":"sts:AssumeRole"
}
]
}
```
------
## 許可ポリシーのアタッチ
オペレーションのタイプに応じて、以下のいずれかのポリシーをアタッチできます。
アクセス権限を設定する前に、以下の点にご留意ください。
+ オペレーションに関係なく、Amazon S3 には S3 バケットからマニフェストオブジェクトを読み込み、またオプションでバケットにレポートを書き込むアクセス許可が必要です。そのため、次のポリシーにはすべて、これらのアクセス許可が含まれます。
+ Amazon S3 インベントリレポートマニフェストの場合、S3 バッチ操作では manifest.json オブジェクトおよび関連するすべての CSV データファイルを読み込むためのアクセス許可が必要です。
+ オブジェクトのバージョン ID を指定している場合にのみ、`s3:GetObjectVersion` などのバージョン固有のアクセス許可が必要です。
+ 暗号化されたオブジェクトに対して S3 バッチ操作を実行している場合、IAM ロールには、暗号化に使用される AWS KMS キーへのアクセス許可も必要です。
+ インベントリレポートマニフェストを AWS KMS で暗号化して送信する場合、IAM ポリシーでは manifest.json オブジェクトおよび関連するすべての CSV データファイルに対するアクセス許可の `"kms:Decrypt"` と `"kms:GenerateDataKey"` が必要です。
+ バッチオペレーションジョブにより、アクセスコントロールリスト (ACL) が有効で、別の AWS アカウントのバケットにマニフェストを生成する場合は、そのバッチジョブ用に設定された IAM ロールの IAM ポリシーで `s3:PutObjectAcl` 権限を付与する必要があります。この権限を含めない場合、バッチジョブは `Error occurred when preparing manifest: Failed to write manifest` エラーで失敗します。
### オブジェクトのコピー: PutObject
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:PutObject",
"s3:PutObjectAcl",
"s3:PutObjectTagging"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
},
{
"Action": [
"s3:GetObject",
"s3:GetObjectAcl",
"s3:GetObjectTagging",
"s3:ListBucket"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-source-bucket",
"arn:aws:s3:::amzn-s3-demo-source-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
]
}
]
}
```
------
### オブジェクトのタグ付けの置き換え: PutObjectTagging
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"s3:PutObjectTagging",
"s3:PutObjectVersionTagging"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect":"Allow",
"Action":[
"s3:PutObject"
],
"Resource":[
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
]
}
]
}
```
------
### オブジェクトタグの削除: DeleteObjectTagging
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:DeleteObjectTagging",
"s3:DeleteObjectVersionTagging"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
]
}
]
}
```
------
### アクセスコントロールリストの置き換え: PutObjectAcl
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObjectAcl",
"s3:PutObjectVersionAcl"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
]
}
]
}
```
------
### オブジェクトの復元: RestoreObject
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"s3:RestoreObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect":"Allow",
"Action":[
"s3:PutObject"
],
"Resource":[
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
]
}
]
}
```
------
### Object Lock 保持の適用: 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/*"
]
}
]
}
```
------
### Object Lock のリーガルホールド: 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 で生成されたマニフェストを使用して保存する場合にはこのポリシーを使用します。バッチオペレーションを使用して既存のオブジェクトをレプリケートする方法の詳細は、「[バッチレプリケーションを使用した既存のオブジェクトのレプリケーション](s3-batch-replication-batch.md)」を参照してください。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Action":[
"s3:InitiateReplication"
],
"Effect":"Allow",
"Resource":[
"arn:aws:s3:::amzn-s3-demo-source-bucket/*"
]
},
{
"Action":[
"s3:GetReplicationConfiguration",
"s3:PutInventoryConfiguration"
],
"Effect":"Allow",
"Resource":[
"arn:aws:s3:::amzn-s3-demo-source-bucket"
]
},
{
"Action":[
"s3:GetObject",
"s3:GetObjectVersion"
],
"Effect":"Allow",
"Resource":[
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect":"Allow",
"Action":[
"s3:PutObject"
],
"Resource":[
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*",
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
}
]
}
```
------
### 既存のオブジェクトのレプリケート: ユーザーマニフェストによる InitiateReplication
ユーザー指定のマニフェストを使用する場合にはこののポリシーを使用します。バッチオペレーションを使用して既存のオブジェクトをレプリケートする方法の詳細は、「[バッチレプリケーションを使用した既存のオブジェクトのレプリケーション](s3-batch-replication-batch.md)」を参照してください。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Action":[
"s3:InitiateReplication"
],
"Effect":"Allow",
"Resource":[
"arn:aws:s3:::amzn-s3-demo-source-bucket/*"
]
},
{
"Action":[
"s3:GetObject",
"s3:GetObjectVersion"
],
"Effect":"Allow",
"Resource":[
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect":"Allow",
"Action":[
"s3:PutObject"
],
"Resource":[
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
]
}
]
}
```
------
### チェックサムの計算: `GetObject`、`GetObjectVersion`、`RestoreObject`、および `PutObject` を許可します
S3 バッチオペレーションで **[チェックサムを計算]** オペレーションを使用しようとする場合は、このポリシーを使用します。`GetObject`、`GetObjectVersion`、および `RestoreObject` のアクセス許可は、保存されたデータのバイトを取得して読み取るために必要です。ユーザー入力プレースホルダーを独自の情報に置き換えます。**[チェックサムを計算]** の詳細については、「[Amazon S3 で保管中のデータのオブジェクトの整合性を確認する](checking-object-integrity-at-rest.md)」を参照してください。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:RestoreObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket2/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket3/*"
]
}
]
}
```
### オブジェクトの暗号化を更新する
バッチオペレーションにマニフェストの読み取り、オブジェクトの暗号化タイプの更新、完了レポートの書き込みを許可するには、次のアクセス許可ポリシーをアタッチする必要があります。このアクセス許可ポリシーを使用するには、*`user input placeholders`* をユーザー自身の情報に置き換えます。このオペレーションの使用と、IAM プリンシパルが使用するロールにアタッチする必要があるアクセス許可の詳細については、「[オブジェクトの暗号化を更新する](batch-ops-update-encryption.md)」を参照してください。
```
{
"Version": "2012-10-17",
"Statement": [{
"Sid": "S3BatchOperationsUpdateEncryption",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:PutObject",
"s3:UpdateObjectEncryption"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket-target"
"arn:aws:s3:::amzn-s3-demo-bucket-target/*"
]
},
{
"Sid": "S3BatchOperationsPolicyForManifestFile",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket-manifest/*"
]
},
{
"Sid": "S3BatchOperationsPolicyForCompletionReport",
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket-completion-report/*"
]
},
{
"Sid": "S3BatchOperationsPolicyManifestGeneration",
"Effect": "Allow",
"Action": [
"s3:PutInventoryConfiguration"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket-target"
]
}
{
"Sid": "AllowKMSOperationsForS3BatchOperations",
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey",
"kms:Encrypt",
"kms:ReEncrypt*"
],
"Resource": [
"arn:aws:kms:us-east-1:111122223333:key/01234567-89ab-cdef-0123-456789abcdef"
]
}
]
}
```
# S3 バッチオペレーションジョブの作成
Amazon S3 バッチオペレーションを使用すると、特定の Amazon S3 オブジェクトのリストに対して大規模なバッチオペレーションを実行できます。このセクションでは、S3 バッチ操作ジョブの作成に必要な情報と `CreateJob` リクエストの結果について説明します。また、AWS Command Line Interface (AWS CLI)、AWS SDK for Java を使用したバッチオペレーションジョブの作成手順についても説明します。
S3 バッチオペレーションジョブを作成するときに、すべてのタスクまたは失敗したタスクについてのみ完了レポートをリクエストできます。少なくとも 1 つのタスクが正常に呼び出される限り、S3 バッチオペレーションは、完了、失敗、またはキャンセルされたジョブに関するレポートを生成します。詳細については、「[例: S3 バッチ操作完了レポート](batch-ops-examples-reports.md)」を参照してください。
次の動画では、Amazon S3 コンソールを使用してバッチオペレーションジョブを作成する方法の簡単なデモンストレーションを提供しています
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/qpwHUrwAiUI/)
**Topics**
+ [バッチ操作ジョブのリクエストの要素](#batch-ops-create-job-request-elements)
+ [マニフェストの指定](#specify-batchjob-manifest)
+ [オブジェクトリストを自動的に生成し、マニフェストファイルとして保存する](#automatically-generate-manifest-file)
+ [マニフェストファイルの作成](#create-manifest-file)
+ [既存のマニフェストを使用する](#specify-existing-manifest-file)
+ [ジョブの作成](#to-create-batch-ops-job)
+ [ジョブのレスポンス](#batch-ops-create-job-response-elements)
## バッチ操作ジョブのリクエストの要素
S3 バッチ操作ジョブを作成するには、次の情報を指定する必要があります。
**オペレーション**
S3 バッチ操作でマニフェストのオブジェクトに対して実行するオペレーションを指定します。オペレーションのタイプごとに、そのオペレーションに固有のパラメータを受け入れます。バッチオペレーションを使用すると、オペレーションを一括で実行でき、各オブジェクトに対してそのオペレーションを 1 つずつ実行した場合と同じ結果が得られます。
**マニフェスト**
*マニフェスト*は、Amazon S3 が動作するオブジェクトキーを含む Amazon S3 オブジェクトリストです。バッチオペレーションジョブのマニフェストは、次の方法で指定できます。
+ 指定したメタデータに基づいてオブジェクトリストを生成するようにバッチオペレーションに指示します。このリストをマニフェストファイルとして保存し、ジョブの作成時に使用できます。このオプションは、Amazon S3 コンソール、AWS CLI、AWS SDK、または Amazon S3 REST API を使用して作成した任意のジョブタイプで使用できます。
+ 既存のレプリケーション設定に基づいてオブジェクトリストを自動的に生成します。このリストをマニフェストファイルとして保存し、今後のジョブで再度使用できます。
+ 新しいマニフェストファイルを手動で作成する。
+ 既存のマニフェストを使用する。
+ 作業するオブジェクトをどのように指定するかにかかわらず、マニフェスト自体は汎用バケットに保存する必要があります。バッチオペレーションでは、既存のマニフェストをディレクトリバケットからインポートしたり、生成されたオブジェクトリストをマニフェストとしてディレクトリバケットに保存したりすることはできません。ただし、マニフェスト内に記述されたオブジェクトはディレクトリバケットに保存できます。詳細については、「[ディレクトリバケット](https://docs.aws.amazon.com//AmazonS3/latest/userguide/directory-buckets-overview.html)」を参照してください。
+ マニフェスト内のオブジェクトがバージョニング対象のバケット内にある場合は、そのオブジェクトのバージョン ID を指定すると特定のバージョンに対してオペレーションが実行されます。バージョン ID が指定されていない場合、バッチオペレーションはオブジェクトの最新バージョンに対してオペレーションを実行します。マニフェストにバージョン ID フィールドが含まれている場合は、マニフェスト内にあるすべてのオブジェクトのバージョン ID を指定する必要があります。
詳細については、「[マニフェストの指定](#specify-batchjob-manifest)」を参照してください。
**優先度**
ジョブの優先順位を使用して、自分のアカウントで実行中の他のユーザーに対するこのジョブの相対的な優先順位を示します。番号が大きいほど、優先度が高いことを表します。
ジョブの優先度は、同じアカウントとリージョンの他のジョブに設定された優先度に相対して解釈されます。お客様に合った番号付け体系を選択できます。例えば、すべての **[復元]** (`RestoreObject`) ジョブに優先度 1、すべての **[コピー]** (`CopyObject`) ジョブに優先度 2、すべての **[アクセスコントロールリスト (ACL) に置き換える]** (`PutObjectAcl`) ジョブに優先度 3 を割り当てることができます。
S3 バッチオペレーションでは、優先度の数字に従ってジョブに優先順位が付けられます。ただし、厳密に順序付けされるとは限りません。そのため、いずれかのジョブをその他のジョブよりも前に開始または終了させるためにジョブの優先度は使用すべきではありません。厳密な順序付けする必要がある場合は、1 つのジョブが終了するまで待ってから次のジョブを開始します。
**RoleArn**
ジョブを実行する AWS Identity and Access Management (IAM) ロールを指定します。使用する IAM ロールには、そのジョブで指定されているオペレーションを実行するための十分なアクセス許可が必要です。例えば、`CopyObject` ジョブを実行するには、IAM ロールに、ソースバケットに対する `s3:GetObject` アクセス許可と、送信先バケットに対する `s3:PutObject` アクセス許可が必要です。このロールには、マニフェストを読み取り、完了レポートを書き込むためのアクセス許可も必要です。
IAM ロールは既存のロールにすることができます。または、Amazon S3 コンソールを使用してジョブを作成する場合、Amazon S3 が自動的に作成する IAM ロールにすることができます。詳細については、「[バッチオペレーションに対するアクセス許可の付与](batch-ops-iam-role-policies.md)」を参照してください。
IAM ロールの詳細については、*IAM ユーザーガイド*の [IAM ロール](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)を参照してください。Amazon S3 のアクセス許可の詳細については、「[Amazon S3 のポリシーアクション](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-actions)」を参照してください。
ディレクトリバケットに対してアクションを実行するバッチオペレーションジョブには、特定のアクセス許可が必要です。詳細については、[S3 Express One Zone 向け AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-security-iam.html)」を参照してください。
**レポート**
S3 バッチ操作で完了レポートを生成するかどうかを指定します。完了レポートをリクエストする場合は、この要素にレポートのパラメータも指定する必要があります。次の情報が返されます。
+ レポートを保存するバケット。
**注記**
レポートは汎用バケットに保存する必要があります。バッチオペレーションではレポートをディレクトリバケットに保存できません。詳細については、「[ディレクトリバケット](https://docs.aws.amazon.com//AmazonS3/latest/userguide/directory-buckets-overview.html)」を参照してください。
+ レポートの形式。
+ レポートに、すべてのタスクの詳細を含めるか、失敗したタスクのみを含めるかを指定します。
+ オプションのプレフィックス文字列
`CreateJob.Report.ExpectedBucketOwner` フィールドを指定する場合は、完了レポートのバケット所有者が一致している必要があります。一致しない場合、ジョブは失敗します。
完了レポートは、常に Amazon S3 マネージドキー (SSE-S3) によるサーバー側の暗号化で暗号化されます。
**[タグ (省略可能)]**
*タグ*を追加することで、S3 バッチ操作ジョブへのラベル付けとアクセスの制御を実行できます。タグを使用して、バッチオペレーションジョブの担当者を識別したり、ユーザーがバッチオペレーションジョブを操作する方法を制御したりできます。ジョブタグがあることで、ユーザーによるジョブのキャンセル、確認状態にあるジョブの有効化、ジョブの優先度レベルの変更を許可したり制限したりできます。例えば、ジョブが `"Department=Finance"` タグ付きで作成されている場合、`CreateJob` オペレーションを呼び出すアクセス許可をユーザーに付与できます。
タグをアタッチしてジョブを作成し、後でジョブにタグを追加できます。
詳細については、「[タグを使用したアクセスのコントロールとジョブのラベル付け](batch-ops-job-tags.md)」を参照してください。
**Description (オプション) **
ジョブを追跡および監視するために、最大 256 文字の説明を指定することもできます。Amazon S3 では、ジョブに関する情報を返すか、Amazon S3 コンソールにジョブの詳細を表示するたびに、この説明が含まれます。これによって、入力した説明に応じて簡単にジョブを並べ替えたりフィルタリングしたりできます。説明は一意である必要はないので、類似したジョブのグループを追跡するのに役立つように、説明をカテゴリとして使用することができます (「Weekly Log Copy Jobs」など)。
## マニフェストの指定
*マニフェスト*は、Amazon S3 が動作するオブジェクトキーを含む Amazon S3 オブジェクトリストです。バッチオペレーションジョブのマニフェストは、次の方法で指定できます。
+ 指定したメタデータに基づいてオブジェクトリストを生成するようにバッチオペレーションに指示します。このリストをマニフェストとして保存し、ジョブの作成時に使用できます。このオプションは、Amazon S3 コンソール、AWS CLI、AWS SDK、または Amazon S3 REST API を使用して作成した任意のジョブタイプで使用できます。
+ 既存のレプリケーション設定に基づいてオブジェクトリストを自動的に生成します。このリストをマニフェストとして保存し、今後のジョブで再度使用できます。
+ 新しいマニフェストファイルを手動で作成する。
+ 既存のマニフェストを使用する。
**注記**
Amazon S3 バッチオペレーションは、クロスリージョンのオブジェクトリスト生成をサポートしていません。
作業するオブジェクトをどのように指定するかにかかわらず、マニフェスト自体は汎用バケットに保存する必要があります。バッチオペレーションでは、既存のマニフェストをディレクトリバケットからインポートしたり、生成されたオブジェクトリストをマニフェストとしてディレクトリバケットに保存したりすることはできません。ただし、マニフェスト内に記述されたオブジェクトはディレクトリバケットに保存できます。詳細については、「[ディレクトリバケット](https://docs.aws.amazon.com//AmazonS3/latest/userguide/directory-buckets-overview.html)」を参照してください。
## オブジェクトリストを自動的に生成し、マニフェストファイルとして保存する
指定したメタデータに基づいてオブジェクトリストを自動的に生成するように Amazon S3 に指示できます。このリストをマニフェストとして保存し、ジョブの作成時に使用できます。このオプションは、Amazon S3 コンソール、AWS CLI、AWS SDK、または Amazon S3 REST API を使用して作成した任意のジョブタイプで使用できます。
オブジェクトリストを自動的に生成してマニフェストファイルとして保存するには、ジョブ作成リクエストの一環として次の要素を指定します。
+ バケット所有者や Amazon リソースネーム (ARN) など、ソースオブジェクトが含まれるバケットに関する情報。
+ マニフェストファイルを作成するためのフラグ、出力バケット所有者、ARN、プレフィックス、ファイル形式、暗号化タイプなど、マニフェスト出力に関する情報。
+ 作成日、キー名、サイズ、暗号化タイプ、KMS キー ARN、バケットキー、ストレージクラスでオブジェクトをフィルタリングするオプションの条件。レプリケーションジョブの場合は、タグを使用してオブジェクトをフィルタリングすることもできます。
### オブジェクトフィルターの条件
自動生成されたオブジェクトリストに含まれるオブジェクトのリストをフィルタリングするには、次の条件を指定できます。詳細については、「**Amazon S3 API リファレンス」の「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_JobManifestGeneratorFilter.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_JobManifestGeneratorFilter.html)」を参照してください。
**CreatedAfter**
指定した場合、生成されたマニフェストには、この時間以降に作成されたソースバケットオブジェクトのみが含まれます。
**CreatedBefore**
指定した場合、生成されたマニフェストには、この時間以降に作成されたソースバケットオブジェクトのみが含まれます。
**EligibleForReplication**
指定した場合、生成されたマニフェストには、ソースバケットのレプリケーション設定に従ってレプリケーションの対象となるオブジェクトのみが含まれます。
**KeyNameConstraint**
指定された場合、生成されたマニフェストには、オブジェクトキーが **MatchAnySubstring**、**MatchAnyPrefix**、**MatchAnySuffix** に指定された文字列制約と一致するソースバケットオブジェクトのみが含まれます。
**MatchAnySubstring** – 指定した場合、指定された文字列がオブジェクトキー文字列内のいずれかの部分に出現する場合、生成されたマニフェストにそのオブジェクトが含まれます。
**MatchAnyPrefix** – 指定すると、指定された文字列がオブジェクトキー文字列の先頭に現れる場合、生成されたマニフェストにオブジェクトが含まれます。
**MatchAnySuffix** – 指定した場合、指定された文字列がオブジェクトキー文字列の末尾に出現する場合、生成されたマニフェストにオブジェクトが含まれます。
**MatchAnyObjectEncryption**
指定した場合、マニフェストファイルとして保存された生成されたオブジェクトリストには、指定されたサーバー側の暗号化タイプ (SSE-S3、SSE-KMS、DSSE-KMS、SSE-C、または NOT-SSE) を持つソースバケットオブジェクトのみが含まれます。SSE-KMS または DSSE-KMS を選択した場合、オプションで特定の KMS キー ARN を指定して結果をさらにフィルタリングできます。SSE-KMS を選択した場合は、オプションでバケットキーの有効ステータスで結果をさらにフィルタリングすることもできます。
**MatchAnyStorageClass**
指定した場合、生成されたマニフェストには、指定されたストレージクラスで保存されているソースバケットオブジェクトのみが含まれます。
**ObjectReplicationStatuses**
指定した場合、生成されたマニフェストには、指定されたレプリケーションステータスのいずれかを持つソースバケットオブジェクトのみが含まれます。
**ObjectSizeGreaterThanBytes**
指定した場合、生成されたマニフェストには、ファイルサイズが指定されたバイト数以上のソースバケットオブジェクトのみが含まれます。
**ObjectSizeLessThanBytes**
指定した場合、生成されたマニフェストには、ファイルサイズが指定されたバイト数未満のソースバケット オブジェクトのみが含まれます。
**注記**
自動的に生成されたオブジェクトリストがマニフェストとして保存されているほとんどのジョブのクローン作成はできません。バッチ レプリケーション ジョブは`KeyNameConstraint`、`MatchAnyStorageClass`、`ObjectSizeGreaterThanBytes`、または `ObjectSizeLessThanBytes` マニフェストフィルター条件を使用する場合を除き、クローンを作成できます。
マニフェスト条件を指定する構文は、ジョブの作成に使用する方法に応じて異なります。例については「[ジョブの作成](#to-create-batch-ops-job)」を参照してください。
## マニフェストファイルの作成
ジョブのマニフェストを手動で作成するには、マニフェストオブジェクトキー、ETag (エンティティタグ)、オプションでバージョン ID を CSV 形式のリストで指定します。マニフェストの内容は URL エンコードされている必要があります。
デフォルトでは、Amazon S3 は、Amazon S3 マネージドキー (SSE-S3) を使用したサーバー側暗号化を自動的に使用して、Amazon S3 バケットにアップロードされるマニフェストを暗号化します。顧客指定のキーを使用したサーバー側の暗号化 (SSE-C) を使用するマニフェストはサポートされていません。AWS Key Management Service (AWS KMS) キー (SSE-KMS) でサーバー側の暗号化を使用するマニフェストは、CSV 形式のインベントリレポートを使用する場合にのみサポートされます。AWS KMS を使用したマニフェストの手動作成はサポートされていません。
マニフェストには、各オブジェクトのバケット名、オブジェクトキー、およびオプションでオブジェクトバージョンを含める必要があります。マニフェストのその他のフィールドは、S3 バッチ操作では使用されません。
**注記**
マニフェスト内のオブジェクトがバージョニング対象のバケット内にある場合は、そのオブジェクトのバージョン ID を指定すると特定のバージョンに対してオペレーションが実行されます。バージョン ID が指定されていない場合、バッチオペレーションはオブジェクトの最新バージョンに対してオペレーションを実行します。マニフェストにバージョン ID フィールドが含まれている場合は、マニフェスト内にあるすべてのオブジェクトのバージョン ID を指定する必要があります。
CSV 形式のマニフェスト（バージョン ID なし）の例を以下に示します。
```
amzn-s3-demo-bucket1,objectkey1
amzn-s3-demo-bucket1,objectkey2
amzn-s3-demo-bucket1,objectkey3
amzn-s3-demo-bucket1,photos/jpgs/objectkey4
amzn-s3-demo-bucket1,photos/jpgs/newjersey/objectkey5
amzn-s3-demo-bucket1,object%20key%20with%20spaces
```
バージョン 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
```
## 既存のマニフェストを使用する
次の 2 つの形式のいずれかを使用して、既存のマニフェストを指定してバッチオペレーションジョブを作成できます。
+ **Amazon S3 インベントリレポート** - CSV 形式の Amazon S3 インベントリレポートである必要があります。インベントリレポートに関連付けられた `manifest.json` ファイルを指定する必要があります。インベントリレポートの詳細については、「[S3 インベントリを使用したデータのカタログ化と分析](storage-inventory.md)」を参照してください。インベントリレポートにバージョン ID が含まれている場合、S3 バッチ操作は特定のオブジェクトのバージョンに対して実行されます。
**注記**
S3 バッチオペレーションは、SSE-KMS で暗号化された CSV **インベントリレポートをサポートしています。
SSE-KMS で暗号化されたインベントリレポートマニフェストを送信する場合、IAM ポリシーには、`"kms:Decrypt"`、`manifest.json` オブジェクトのための `"kms:GenerateDataKey"`、関連するすべての CSV データ ファイルに対するアクセス許可が含まれている必要があります。
+ **CSV ファイル** – ファイルの各行には、バケット名とオブジェクトのキーを含める必要があります。また、任意でオブジェクトのバージョンを含めることができます。オブジェクトキーは、次の例に示されているように、URL エンコードする必要があります。マニフェストには、すべてのオブジェクトのバージョン ID を含めるか、すべてのオブジェクトのバージョン ID を省略する必要があります。CSV マニフェスト形式の詳細については、「**Amazon Simple Storage Service API リファレンス」の「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_JobManifestSpec.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_JobManifestSpec.html)」を参照してください。.
**注記**
S3 バッチオペレーションは、SSE-KMS で暗号化された CSV **マニフェストファイルをサポートしていません。
**重要**
手動で作成したマニフェストとバージョニング対応のバケットを使用する場合は、そのオブジェクトのバージョン ID を指定することをお勧めします。ジョブを作成すると、S3 バッチ操作はジョブを実行する前にマニフェスト全体を解析します。ただし、これによってバケットの状態は「スナップショット」されません。
マニフェストには数十億のオブジェクトが含まれる可能性があるため、ジョブの実行に時間がかかる可能性があり、その結果ジョブが動作するオブジェクトのバージョンに影響を与える場合があります。ジョブの実行中にオブジェクトを新しいバージョンで上書きして、そのオブジェクトのバージョン ID を指定しなかったとします。この場合、Amazon S3 は、ジョブの作成時に存在していたバージョンではなく、オブジェクトの最新バージョンに対してオペレーションを実行します。この動作を回避する唯一の方法は、マニフェスト内でリストされたオブジェクトにバージョン ID を指定することです。
## ジョブの作成
Amazon S3 コンソール、AWS CLI、AWS SDK、または Amazon S3 REST API を使用して S3 バッチオペレーションジョブを作成できます。
ジョブリクエストの作成の詳細については、[バッチ操作ジョブのリクエストの要素](#batch-ops-create-job-request-elements) を参照してください。
**前提条件**
バッチオペレーションジョブを作成する前に、関連するアクセス許可が設定されていることを確認します。詳細については、「[バッチオペレーションに対するアクセス許可の付与](batch-ops-iam-role-policies.md)」を参照してください。
### S3 コンソールの使用
**S3 コンソールを使用してバッチオペレーションジョブを作成するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. Amazon S3 コンソールのナビゲーションペインで **[バッチオペレーション]** を選択します。
1. **[ジョブの作成]** を選択します。
1. **[リージョンとスコープを選択]** で、ジョブを作成する AWS リージョンを選択して表示します。
**注記**
コピーオペレーションの場合は、コピー先バケットと同じリージョンにジョブを作成する必要があります。その他すべてのオペレーションの場合は、マニフェスト内のオブジェクトと同じリージョンにジョブを作成する必要があります。
1. **[スコープ]** には、バッチオペレーションジョブが実行するオブジェクトのリストを指定します。
**[オブジェクトリスト]** では、オブジェクトリストを使用してマニフェストを生成するか、レプリケーション設定を使用してマニフェストを生成するか、既存のマニフェストを使用するかを選択できます。
+ **[オブジェクトリストの生成]** を選択すると、指定したソースの場所とメタデータに基づいてオブジェクトリストが自動的に生成されます。このリストをマニフェストとして保存し、今後のジョブで再度使用できます。
**注記**
オブジェクトリストを生成するには、`s3:PutInventoryConfiguration` アクセス許可が必要です。ソースバケットは汎用バケットである必要があります。
+ **[既存のマニフェストを使用]** を選択した場合は、既存のマニフェストからオブジェクトリストをインポートできます。マニフェストは、バッチオペレーションで実行する特定のオブジェクトを一覧表示する S3 インベントリレポートまたは CV ファイルです。
+ **[レプリケーション設定の使用]** を選択する場合、既存のレプリケーション設定に基づいてオブジェクトリストを自動的に生成できます。このリストをマニフェストとして保存し、今後のジョブで再度使用できます。
この例では、**[オブジェクトリストの生成]** を選択します。
1. **[ソースアカウント]** で、ソースオブジェクトを所有するアカウントを選択します。
1. **[ソース]** に、ソースへのパスを入力します。例: `s3://`*amzn-s3-demo-bucket*。
1. **[オブジェクトフィルター]** では、フィルターを使用してオブジェクトキーの任意の部分でフィルタリングしたり、オブジェクトキーの末尾でフィルタリングしたりできます。**[オブジェクトキーフィルター]** は、マニフェストで使用するオブジェクトのリストの絞り込みに役立ちます。**[オブジェクトメタデータフィルター]** では、フィルターを選択して、マニフェストに含めるオブジェクトの範囲をさらに定義します。
1. **[オペレーションを選択]** で、マニフェストにリストされたすべてのオブジェクトを実行するオペレーションタイプを選択します。マニフェストがディレクトリバケットに保存されているオブジェクトを参照する場合は、コピーのみを使用するか、AWS Lambda 関数オペレーションを呼び出します。その他のすべてのオペレーションはサポートされていません。
1. オペレーションタイプを選択した後、**[次へ]** を選択します。
1. **[追加のオプションを設定]** に関する情報を入力します。
**[アクセス許可]** には、ジョブで使用する AWS Identity and Access Management (IAM) ロールを指定します。これは、既存のロールでも、Amazon S3 が自動的に作成するロールでもかまいません。詳細については、「[バッチオペレーションに対するアクセス許可の付与](batch-ops-iam-role-policies.md)」を参照してください。フィルター付きの S3 生成オブジェクトリストまたはレプリケーション設定に基づくオブジェクトリストを使用するようにジョブを設定した場合、Amazon S3 によってロールが作成されます。
1. 追加オプションの設定が完了したら、**[次へ]** を選択します。
1. [**Review (確認)**] で、設定を確認します。変更が必要な場合は、[**戻る**] を選択します。それ以外の場合は、**[ジョブの送信]** を選択できます。
### の使用AWS CLI
AWS CLI を使用してバッチオペレーションジョブを作成するには、既存のマニフェストを指定するか、マニフェストを自動的に生成するかに応じて、次のいずれかの例を選択します。
------
#### [ Specify manifest ]
AWS CLI を使用して、既存のマニフェストファイルにリストされているオブジェクトに対して動作する S3 バッチオペレーション `S3PutObjectTagging` ジョブを作成する方法は、次の例のとおりです。
**マニフェストを指定してバッチオペレーション `S3PutObjectTagging` ジョブを作成するには**
1. 次のコマンドを使用して AWS Identity and Access Management (IAM) ロールを作成してから、IAM ポリシーを作成して関連するアクセス許可を割り当てます。次のロールとポリシーは、オブジェクト タグを追加するための Amazon S3 アクセス許可を付与します。このアクセス許可は、以降のステップでジョブを作成する際に必要になります。
1. 次のコマンド例を使用して、バッチオペレーションで使用する IAM ロールを作成します。このコマンド例を使用するには、`S3BatchJobRole` をロールにつける名前に置き換えます。
```
aws iam create-role \
--role-name S3BatchJobRole \
--assume-role-policy-document '{
"Version": "2012-10-17" ,
"Statement":[
{
"Effect":"Allow",
"Principal":{
"Service":"batchoperations.s3.amazonaws.com"
},
"Action":"sts:AssumeRole"
}
]
}'
```
ロールの Amazon リソースネーム (ARN) を記録します。ジョブの作成時にこの ARN が必要となります。
1. 次のコマンド例を使用して、必要なアクセス許可を持つ IAM ポリシーを作成して、前の手順で作成した IAM ロールにアタッチします。必要なアクセス権限の詳細については、「[バッチオペレーションに対するアクセス許可の付与](batch-ops-iam-role-policies.md)」を参照してください。
**注記**
ディレクトリバケットに対してアクションを実行するバッチオペレーションジョブには、特定のアクセス許可が必要です。詳細については、[S3 Express One Zone 向け AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-security-iam.html)」を参照してください。
このサンプルコマンドを使用するには、`user input placeholders` を次のとおり置き換えます。
+ `S3BatchJobRole` は、IAM ロール名に置き換えます。この名前が以前に使用した名前と一致することを確認します。
+ `PutObjectTaggingBatchJobPolicy` は、IAM ポリシーにつける名前に置き換えます。
+ `amzn-s3-demo-destination-bucket` は、タグを付けるオブジェクトがあるバケット名と置き換えます。
+ *`amzn-s3-demo-manifest-bucket`* は、マニフェストがあるバケットの名前と置き換えます。
+ *`amzn-s3-demo-completion-report-bucket`* は、完了レポートの配信先のバケット名と置き換えます。
```
aws iam put-role-policy \
--role-name S3BatchJobRole \
--policy-name PutObjectTaggingBatchJobPolicy \
--policy-document '{
"Version": "2012-10-17" , TCX5-2025-waiver;,
"Statement":[
{
"Effect":"Allow",
"Action":[
"s3:PutObjectTagging",
"s3:PutObjectVersionTagging"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-manifest-bucket",
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect":"Allow",
"Action":[
"s3:PutObject",
"s3:GetBucketLocation"
],
"Resource":[
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket",
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
]
}
]
}'
```
1. 次のコマンド例を使用して、`S3PutObjectTagging` ジョブを作成します。
`manifest.csv` ファイルは、バケットのリストとオブジェクトキー値を提供します。このジョブは、マニフェストで識別されたオブジェクトに指定されたタグを適用します。`ETag` は `manifest.csv` オブジェクトの ETag であり、Amazon S3 コンソールから取得できます。このリクエストは `no-confirmation-required` パラメータを指定するため、`update-job-status` コマンドで確認しなくてもジョブを実行できます。詳細については、**AWS CLI コマンドリファレンスの「[https://docs.aws.amazon.com/cli/latest/reference/s3control/create-job.html](https://docs.aws.amazon.com/cli/latest/reference/s3control/create-job.html)」を参照してください。
このコマンド例を実行するには、`user input placeholders` をユーザー自身の情報に置き換えます。*`IAM-role`* を先ほど作成した IAM ロールの ARN に置き換えます。
```
aws s3control create-job \
--region us-west-2 \
--account-id acct-id \
--operation '{"S3PutObjectTagging": { "TagSet": [{"Key":"keyOne", "Value":"ValueOne"}] }}' \
--manifest '{"Spec":{"Format":"S3BatchOperations_CSV_20180820","Fields":["Bucket","Key"]},"Location":{"ObjectArn":"arn:aws:s3:::amzn-s3-demo-manifest-bucket/manifest.csv","ETag":"60e460c9d1046e73f7dde5043ac3ae85"}}' \
--report '{"Bucket":"arn:aws:s3:::amzn-s3-demo-completion-report-bucket","Prefix":"final-reports", "Format":"Report_CSV_20180820","Enabled":true,"ReportScope":"AllTasks"}' \
--priority 42 \
--role-arn IAM-role \
--client-request-token $(uuidgen) \
--description "job description" \
--no-confirmation-required
```
応答として、Amazon S3 はジョブ ID (など `00e123a4-c0d8-41f4-a0eb-b46f9ba5b07c`) を返します。ジョブの識別、モニタリング、変更にはこのジョブ ID が必要です。
------
#### [ Generate manifest ]
オブジェクトフィルター条件に基づいてマニフェストを自動的に生成する S3 バッチオペレーション `S3DeleteObjectTagging` ジョブを作成する方法は、次の例のとおりです。この条件には、作成日、キー名、サイズ、ストレージクラス、タグが含まれます。
**マニフェストを生成してバッチオペレーション `S3DeleteObjectTagging` ジョブを作成するには**
1. 次のコマンドを使用して AWS Identity and Access Management (IAM) ロールを作成してから、IAM ポリシーを作成してアクセス許可を割り当てます。次のロールとポリシーは、オブジェクト タグを削除するための Amazon S3 アクセス許可を付与します。このアクセス許可は、以降のステップでジョブを作成する際に必要になります。
1.
次のコマンド例を使用して、バッチオペレーションで使用する IAM ロールを作成します。このコマンド例を使用するには、`S3BatchJobRole` をロールにつける名前に置き換えます。
```
aws iam create-role \
--role-name S3BatchJobRole \
--assume-role-policy-document '{
"Version": "2012-10-17" , TCX5-2025-waiver;,
"Statement":[
{
"Effect":"Allow",
"Principal":{
"Service":"batchoperations.s3.amazonaws.com"
},
"Action":"sts:AssumeRole"
}
]
}'
```
ロールの Amazon リソースネーム (ARN) を記録します。ジョブの作成時にこの ARN が必要となります。
1. 次のコマンド例を使用して、必要なアクセス許可を持つ IAM ポリシーを作成して、前の手順で作成した IAM ロールにアタッチします。必要なアクセス権限の詳細については、「[バッチオペレーションに対するアクセス許可の付与](batch-ops-iam-role-policies.md)」を参照してください。
**注記**
ディレクトリバケットに対してアクションを実行するバッチオペレーションジョブには、特定のアクセス許可が必要です。詳細については、[S3 Express One Zone 向け AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-security-iam.html)」を参照してください。
このサンプルコマンドを使用するには、`user input placeholders` を次のとおり置き換えます。
+ `S3BatchJobRole` は、IAM ロール名に置き換えます。この名前が以前に使用した名前と一致することを確認します。
+ `DeleteObjectTaggingBatchJobPolicy` は、IAM ポリシーにつける名前に置き換えます。
+ `amzn-s3-demo-destination-bucket` は、タグを付けるオブジェクトがあるバケット名と置き換えます。
+ `amzn-s3-demo-manifest-bucket` は、マニフェストの保存先バケット名と置き換えます。
+ `amzn-s3-demo-completion-report-bucket` は、完了レポートの配信先のバケット名と置き換えます。
```
aws iam put-role-policy \
--role-name S3BatchJobRole \
--policy-name DeleteObjectTaggingBatchJobPolicy \
--policy-document '{
"Version": "2012-10-17" , TCX5-2025-waiver;,
"Statement":[
{
"Effect":"Allow",
"Action":[
"s3:DeleteObjectTagging",
"s3:DeleteObjectVersionTagging"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
},
{
"Effect":"Allow",
"Action":[
"s3:PutInventoryConfiguration"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-manifest-bucket",
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
},
{
"Effect":"Allow",
"Action":[
"s3:PutObject",
"s3:ListBucket"
],
"Resource":[
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket",
"arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*",
"arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
]
}
]
}'
```
1. 次のコマンド例を使用して、`S3DeleteObjectTagging` ジョブを作成します。
この例では、`--report` セクション内の値によって、生成されるジョブレポートのバケット、プレフィックス、形式、範囲が指定されます。`--manifest-generator` セクションでは、ジョブの対象となるオブジェクトを含むソースバケットに関する情報、ジョブに対して生成されるマニフェスト出力リストに関する情報、マニフェストに含めるオブジェクトの範囲を作成日、名前の制約、サイズ、ストレージクラスによって絞り込むためのフィルター条件を指定します。このコマンドでは、ジョブの優先度、IAM ロール、AWS リージョン も指定します。
詳細については、**AWS CLI コマンドリファレンスの「[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 が必要です。
------
### の使用AWS SDK for Java
AWS SDK for Java を使用してバッチオペレーションジョブを作成するには、既存のマニフェストを指定するか、マニフェストを自動的に生成するかに応じて、次の 2 つのアプローチのいずれかを選択します。
+ *既存のマニフェストを指定する:* 既存のマニフェストファイルにリストされているオブジェクトを操作する S3 バッチオペレーションジョブ (`S3PutObjectTagging` など) を作成します。このアプローチでは、マニフェストのロケーション、ETag、および形式の仕様を指定する必要があります。
+ *マニフェストを自動的に生成する:* 作成日、キー名、サイズ制約など、オブジェクトフィルター条件に基づいてマニフェストを自動的に生成する S3 バッチオペレーションジョブ (`s3PutObjectCopy` など) を作成します。
どちらのアプローチも S3Control クライアントを使用して、ジョブオペレーション、マニフェスト仕様、ジョブレポート、IAM ロール、および優先度や確認要件などのその他のジョブパラメータを設定します。
AWS SDK for Java を使用して S3 バッチオペレーションジョブを作成する方法の例については、「*Amazon S3 API リファレンス*」の「[Create a batch job to copy objects](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_CreateJob_section.html)」を参照してください。
### REST API の使用
REST API を使用して、バッチ操作ジョブを作成できます。詳細については、「**Amazon Simple Storage Service API リファレンス」の「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateJob.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateJob.html)」を参照してください。
## ジョブのレスポンス
`CreateJob` リクエストが成功すると、Amazon S3 はジョブ ID を返します。ジョブ ID は Amazon S3 が自動的に生成する一意の識別子であるため、バッチ操作ジョブを識別してそのステータスを監視できます。
AWS CLI、AWS SDK または REST API を介してジョブを作成する場合、S3 バッチオペレーションを設定してジョブを自動処理を開始できます。ジョブはより高い優先度のジョブを待機せずに、準備が整うと直ちに実行されます。
Amazon S3 コンソールを使用してジョブを作成する際は、バッチオペレーションでジョブの処理を開始する前に、ジョブの詳細を確認し、ジョブを実行できるかを確認する必要があります。ジョブが 30 日以上停止状態のままになると、失敗します。
# S3 バッチ操作でサポートされるオペレーション
S3 バッチ操作を使用すると、Amazon S3 のオブジェクトに対して大規模なバッチ操作を実行することができます。S3 バッチ操作では、指定した Amazon S3 のオブジェクトのリストに対して、1 つのオペレーションを実行できます。1 つのジョブで、エクサバイトのデータを含む数十億ものオブジェクトに対して、指定されたオペレーションを実行できます。Amazon S3 は、進捗状況の追跡、通知の送信、すべてのアクションの詳細な完了レポートの保存を行い、フルマネージド型の監査可能なサーバーレスエクスペリエンスを提供します。S3 バッチオペレーションは、Amazon S3 コンソール、AWS CLI、AWS SDK、または Amazon S3 REST API を通じて使用できます。
S3 バッチオペレーションでは、以下のオペレーションがサポートされています。
# オブジェクトのコピー
Amazon S3 バッチオペレーションを使用すると、Amazon S3 のオブジェクトに対して大規模なバッチオペレーションを実行できます。バッチオペレーション **Copy** オペレーションは、マニフェストで指定した各オブジェクトをコピーします。オブジェクトを同じ AWS リージョンのバケットにコピーしたり、別のリージョンのバケットにコピーしたりできます。S3 バッチ操作では、Amazon S3 のオブジェクトのコピーで使用できるほとんどのオプションがサポートされています。このオプションには、オブジェクトのメタデータの設定、アクセス許可の設定およびオブジェクトのストレージクラスの変更が含まれます。
**Copy** オペレーションを使用して、既存の暗号化されていないオブジェクトをコピーし、同じバケットに暗号化されたオブジェクトとして書き込むこともできます。詳細については、「[Encrypting objects with Amazon S3 Batch Operations](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)」を参照してください。**
## 制約と制限
バッチオペレーション **Copy** オペレーションを使用している場合は、以下の制約と制限が適用されます。
+ すべてのソースオブジェクトは 1 つのバケットにある必要があります。
+ すべての送信先オブジェクトは 1 つのバケットにある必要があります。
+ 送信元バケットへの読み込み許可および送信先バケットへの書き込み許可を保持していることが必要です。
+ コピーできるオブジェクトのサイズは 5 GB までです。
+ S3 Glacier Flexible Retrieval または S3 Glacier Deep Archive クラスから S3 Standard ストレージクラスにオブジェクトをコピーする場合は、まずこれらのオブジェクトを復元する必要があります。詳細については、「[アーカイブされたオブジェクトの復元](restoring-objects.md)」を参照してください。
+ バッチオペレーション **Copy** コピージョブは、コピー先リージョン (オブジェクトをコピーする先のリージョン) で作成する必要があります。
+ 条件式によるエンティティタグ (ETag) の確認とお客様が用意した暗号化キーを使用したサーバー側の暗号化 (SSE-C) を除く、すべての `CopyObject` オプションがサポートされています。
+ 送信先バケットがバージョン化されていない場合、同じキー名を持つオブジェクトを上書きできます。
+ オブジェクトは、マニフェストに表示されている順序と同じ順序でコピーされるとは限りません。バージョン管理されたバケットで、現在のバージョンまたは以前のバージョンの順序を維持することが必要な場合は、最初に以前のバージョンをすべてコピーします。次に、最初のジョブが完了したら、後続のジョブで現在のバージョンをコピーします。
+ 低冗長化ストレージ (RRS) クラスへのオブジェクトのコピーはサポートされていません。
+ 1 つのバッチオペレーションコピージョブで、最大 200 億個のオブジェクトを持つマニフェストをサポートできます。
# S3 バッチ操作を使用したオブジェクトのコピー
Amazon S3 バッチオペレーションを使用すると、Amazon S3 のオブジェクトに対して大規模なバッチオペレーションを実行できます。S3 バッチオペレーションを使用して **Copy** (`CopyObject`) ジョブを作成し、同じアカウント内または別の送信先アカウントにオブジェクトをコピーできます。
次のセクションでは、別のアカウントにあるマニフェストを保存して使用する方法の例を示します。最初の例は、Amazon S3 インベントリからインベントリレポートをコピー先アカウントに配信して、ジョブの作成時に使用する方法を示しています。2 番目の例は、送信元または送信先アカウントでカンマ区切り値 (CSV) マニフェストを使用する方法を示しています。3 番目の例は、**Copy** オペレーションを使用して、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)
+ [バッチオペレーションを使用して SSE-KMS の S3 バケットキーを有効にする](batch-ops-copy-example-bucket-key.md)
# インベントリレポートを使用して AWS アカウント 間でオブジェクトをコピーする
Amazon S3 バッチオペレーションを使用すると、Amazon S3 のオブジェクトに対して大規模なバッチオペレーションを実行できます。S3 バッチオペレーションを使用して **Copy** (`CopyObject`) コピージョブを作成し、同じアカウント内または別の送信先アカウントにオブジェクトをコピーできます。
Amazon S3 インベントリを使用してインベントリレポートを作成し、そのレポートを使用して、S3 バッチオペレーションでコピーするオブジェクトのリスト (マニフェスト) を作成できます。ソースアカウントまたは送信先アカウントでの CSV マニフェストの使用について詳しくは、[CSV マニフェストを使用して AWS アカウント 間でオブジェクトをコピーする](specify-batchjob-manifest-xaccount-csv.md) を参照してください。
Amazon S3 インベントリは、バケット内のオブジェクトのインベントリを生成します。結果のリストは出力ファイルに公開されます。インベントリ対象となるバケットはソースバケットと呼ばれ、インベントリレポートファイルが保存されているバケットは送信先バケットと呼ばれます。
Amazon S3 インベントリレポートは、別の AWS アカウント に配信されるように設定できます。これにより、送信先アカウントでジョブが作成されたときに S3 バッチオペレーションがインベントリレポートを読み取ることができます。
Amazon S3 インベントリのコピー元およびコピー先バケットの詳細については、「[ソースバケットと保存先バケット](storage-inventory.md#storage-inventory-buckets)」を参照してください。
インベントリを設定する最も簡単な方法は、Amazon S3 を使用することですが、REST API、AWS Command Line Interface (AWS CLI)、または AWS SDK を使用することもできます。
以下のコンソールの手順には、S3 バッチ操作ジョブに対するアクセス許可を設定するための大まかなステップが含まれています。この手順では、オブジェクトを送信元アカウントから送信先アカウントにコピーし、インベントリレポートを送信先アカウントに保存します。
**さまざまなアカウントが所有する送信元および送信先バケットの Amazon S3 インベントリを設定する方法**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、**[バケット]** を選択します。
1. インベントリレポートを保存するための送信先マニフェストバケットを決定 (または作成) します。この手順では、*送信先アカウント*は、送信先マニフェストバケットとオブジェクトのコピー先バケットの両方を所有するアカウントです。
1. ソースバケットのインベントリレポートを設定します。コンソールを使用してインベントリリストを設定する方法またはインベントリリストファイルを暗号化する方法については、「[Amazon S3 インベントリの設定](configure-inventory.md)」を参照してください。
インベントリレポートを設定する場合は、リストを保存する送信先バケットを指定します。ソースバケットのインベントリレポートが送信先バケットに発行されます。この手順では、*ソースアカウント*は、ソースバケットを所有するアカウントです。
出力形式として [**CSV**] を選択してください。
送信先バケットの情報を入力したら、[**Buckets in another account (別のアカウントのバケット)**] を選択します。次に、送信先マニフェストバケットの名前を入力します。必要に応じて、送信先アカウントのアカウント ID を入力できます。
インベントリ設定が保存されると、コンソールに次のようなメッセージが表示されます。
Amazon S3 は送信先バケットにバケットポリシーを作成できませんでした。Amazon S3 が送信先バケットに対してデータの保存ができるよう、送信先バケット所有者に次のバケットポリシーの追加を依頼してください。
コンソールには、送信先バケットに使用できるバケットポリシーが表示されます。
1. コンソールに表示される送信先バケットポリシーをコピーします。
1. 送信先アカウントで、インベントリレポートが格納されている送信先マニフェストバケットにコピーしたバケットポリシーを追加します。
1. S3 バッチ操作信頼ポリシーに基づいて、送信先アカウントにロールを作成します。この信頼ポリシーの詳細については、「[信頼ポリシー](batch-ops-iam-role-policies.md#batch-ops-iam-role-policies-trust)」を参照してください。
ロールの作成について詳しくは、「IAM ユーザーガイド」の「[AWS のサービスにアクセス許可を委任するロールを作成する](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html)」を参照してください。**
ロールの名前を入力します (以下の例では *`BatchOperationsDestinationRoleCOPY`* という名前を使用しています)。**[S3]** サービスを選択してから、信頼ポリシーをロールに適用する **[S3 バッチオペレーション]** ユースケースを選択します。
次に [**ポリシーの作成**]を選択して、ロールに次のポリシーをアタッチします。このポリシーを使用するには、*`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. ソースアカウントで、前の手順で作成したロールにソースバケット内のオブジェクト、ACL、タグ、およびバージョンの `GET` を付与する、ソースバケットのバケットポリシーを作成します。このステップにより、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 バッチオペレーション **Copy** (`CopyObject`) ジョブを作成し、送信先マニフェストバケットから在庫レポートを選択します。送信先アカウントで作成した IAM ロールの ARN が必要です。
ジョブの作成に関する全般情報については、「[S3 バッチオペレーションジョブの作成](batch-ops-create-job.md)」を参照してください。
コンソールを使用してジョブを作成する方法については、「[S3 バッチオペレーションジョブの作成](batch-ops-create-job.md)」を参照してください。
# CSV マニフェストを使用して AWS アカウント 間でオブジェクトをコピーする
Amazon S3 バッチオペレーションを使用すると、Amazon S3 のオブジェクトに対して大規模なバッチオペレーションを実行できます。S3 バッチオペレーションを使用して **Copy** (`CopyObject`) ジョブを作成し、同じアカウント内または別の送信先アカウントにオブジェクトをコピーできます。
ソースアカウントに保存された CSV マニフェストを使用して、S3 バッチオペレーションによって AWS アカウント間でオブジェクトをコピーできます。S3 インベントリレポートをマニフェストとして使用するには、「[インベントリレポートを使用して AWS アカウント 間でオブジェクトをコピーする](specify-batchjob-manifest-xaccount-inventory.md)」を参照してください。
CSV 形式のマニフェストファイルの例については、「[マニフェストファイルの作成](batch-ops-create-job.md#create-manifest-file)」を参照してください。
次の手順は、S3 バッチオペレーションジョブを使用して、ソースアカウントに保存されている CSV マニフェストファイルによってソースアカウントから送信先アカウントにオブジェクトをコピーするときに、アクセス許可を設定する方法を示しています。
**CSV マニフェストを使用して AWS アカウント間でオブジェクトをコピーするには**
1. S3 バッチオペレーション信頼ポリシーに基づいて、送信先アカウントに AWS Identity and Access Management (IAM) ロールを作成します。この手順では、*送信先アカウント*は、オブジェクトのコピー先のアカウントです。
信頼ポリシーの詳細については、「[信頼ポリシー](batch-ops-iam-role-policies.md#batch-ops-iam-role-policies-trust)」を参照してください。
ロールの作成について詳しくは、「IAM ユーザーガイド」の「[AWS のサービスにアクセス許可を委任するロールを作成する](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html)」を参照してください。**
コンソールを使用してロールを作成する場合は、ロールの名前を入力します (以下のサンプルロールでは `BatchOperationsDestinationRoleCOPY` という名前が使用されています)。**[S3]** サービスを選択してから、信頼ポリシーをロールに適用する **[S3 バッチオペレーション]** ユースケースを選択します。
次に [**ポリシーの作成**]を選択して、ロールに次のポリシーをアタッチします。このポリシーを使用するには、*`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` アクセス許可を付与します。ソースオブジェクトバケット内のオブジェクト、アクセスコントロールリスト (ACL)、タグ、およびバージョンを `GET` するアクセス許可を付与し、また、送信先のオブジェクトバケットへオブジェクト、ACL、タグ、およびバージョンを `PUT` するアクセス許可も付与します。
1. 前のステップで作成したロールにソースマニフェストバケット内のオブジェクトとバージョンを `GET` するアクセス許可を付与するために、ソースアカウントで、マニフェストが含まれるバケットに適用するバケットポリシーを作成します。
このステップにより、信頼できるロールを使用して、S3 バッチオペレーションでマニフェストを読み取ることができます。マニフェストを含むバケットにバケットポリシーを適用します。
以下は、ソースマニフェストバケットに適用するバケットポリシーの例です。このポリシーを使用するには、*`user input placeholders`* をユーザー自身の情報に置き換えます。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowBatchOperationsSourceManifestRead",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:user/ConsoleUserCreatingJob",
"arn:aws:iam::111122223333:role/BatchOperationsDestinationRoleCOPY"
]
},
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-manifest-bucket/*"
}
]
}
```
------
このポリシーでは、送信先アカウントでジョブを作成しているコンソールユーザーに、同じバケットポリシーを介してソースマニフェストバケットでも同じアクセス許可を許可する権限も付与されます。
1. 前の手順で作成したロールにソースオブジェクトバケット内のオブジェクト、ACL、タグ、およびバージョンを `GET` するアクセス許可を付与するために、ソースアカウントで、ソースバケットに適用するバケットポリシーを作成します。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 リソースネーム (ARN) が必要です。ジョブの作成の詳細については、「[S3 バッチオペレーションジョブの作成](batch-ops-create-job.md)」を参照してください。
# バッチオペレーションを使用して SSE-KMS の S3 バケットキーを有効にする
S3 バケットキーは、Amazon S3 から AWS KMS へのリクエストトラフィックを減らすことにより、AWS Key Management Service (AWS KMS) (SSE−KMS) を使用したサーバー側の暗号化のコストを削減します。詳細については、「[Amazon S3 バケットキーを使用した SSE−KMS のコストの削減](bucket-key.md)」および「[新しいオブジェクトで SSE−KMS の S3 バケットキーを使用するようにバケットを設定する](configuring-bucket-key.md)」を参照してください。REST API、AWS SDK、または AWS CLI を使用して `CopyObject` オペレーションを実行する際、`true` または `false` の値の付いた `x-amz-server-side-encryption-bucket-key-enabled` リスエストヘッダーを追加して、オブジェクトレベルで S3 バケットキーを有効または無効にできます。
`CopyObject` オペレーションを使用してオブジェクトの S3 バケットキーを設定すると、Amazon S3 では、そのオブジェクトの設定のみが更新されます。送信先バケットの S3 バケットキーの設定は変更されません。AWS KMS で暗号化されたオブジェクトの `CopyObject` リクエストを S3 バケットキーが有効になっているバケットに送信すると、リクエストヘッダーのキーを無効にしない限り、オブジェクトレベルのオペレーションでは自動的に S3 バケットキーが使用されます。オブジェクトに S3 バケットキーを指定しない場合、Amazon S3 ではレプリケート先バケットの S3 バケットキーの設定がオブジェクトに適用されます。
既存の Amazon S3 オブジェクトを暗号化するには、S3 バッチオペレーションを使用します。**バッチオペレーションのコピーオペレーション**を使用して、既存の暗号化されていないオブジェクトをコピーし、同じバケットに新しい暗号化されたオブジェクトを書き込めます。詳細については、「AWS ストレージブログ」の「[Encrypting objects with Amazon S3 Batch Operations](https://aws.amazon.com/blogs/storage/encrypting-objects-with-amazon-s3-batch-operations/)」を参照してください。
次の例では、バッチオペレーションの **Copy** オペレーションを使用して、既存のオブジェクトで S3 バケットキーを有効にします。詳細については、「[オブジェクトレベルで S3 バケットキーを設定する](configuring-bucket-key-object.md)」を参照してください。
**Topics**
+ [S3 バッチオペレーションを使用し、有効になっている S3 バケットキーでオブジェクトを暗号化する際の考慮事項](#bucket-key-ex-things-to-note)
+ [前提条件](#bucket-key-ex-prerequisites)
+ [ステップ 1: Amazon S3 インベントリを使用してオブジェクトのリストを取得する](#bucket-key-ex-get-list-of-objects)
+ [ステップ 2: S3 Select を使用してオブジェクトリストをフィルタリングする](#bucket-key-ex-filter-object-list-with-s3-select)
+ [ステップ 3: S3 バッチオペレーションジョブをセットアップして実行する](#bucket-key-ex-setup-and-run-job)
## S3 バッチオペレーションを使用し、有効になっている S3 バケットキーでオブジェクトを暗号化する際の考慮事項
S3 バッチオペレーションを使用し、有効になっている S3 バケットキーを使ってオブジェクトを暗号化するときは、次の問題を考慮してください。
+ S3 バッチオペレーションがお客様に代わって実行するデータ転送、リクエスト、その他の料金などのオペレーションに関連する料金に加えて、S3 バッチオペレーションジョブ、オブジェクト、およびリクエストに対して課金されます。詳細については、「[Amazon S3 の料金](https://aws.amazon.com/s3/pricing)」を参照してください。
+ バージョニングされたバケットを使用する場合、実行される各 S3 バッチオペレーションジョブは、オブジェクトの新しい暗号化されたバージョンを作成します。また、S3 バケットキーが設定されていない、前のバージョンも維持されます。古いバージョンを削除するには、[ライフサイクル設定の要素](intro-lifecycle-rules.md) で説明されているように、最新でないバージョンに対して S3 ライフサイクルの有効期限ポリシーをセットアップします。
+ コピーオペレーションでは、新しい作成日を持つ新しいオブジェクトが作成されます。これは、アーカイブなどのライフサイクルアクションに影響を与える可能性があります。バケット内のすべてのオブジェクトをコピーすると、新しいすべてのコピーの作成日が同一になるか類似する日付になります。これらのオブジェクトをさらに識別し、さまざまなデータサブセットに対して異なるライフサイクルルールを作成するには、オブジェクトタグの使用を検討してください。
## 前提条件
S3 バケットキーを使用するようオブジェクトを設定する前に、「[S3 バケットキーを有効にする前に注意するべき変更点](bucket-key.md#bucket-key-changes)」を確認してください。
この例を使用するには、AWS アカウントと、作業ファイルと暗号化された結果を保持するために少なくとも 1 つの 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 SDK も使用できます。これらのステップを実行する前に、必ずコンソールにサインインして Amazon S3 コンソール ([https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)) を開いてください。アクセス許可拒否エラーが発生した場合は、バケットポリシーを送信先バケットに追加します。詳細については、「[S3 インベントリおよび S3 分析に対するアクセス許可の付与](example-bucket-policies.md#example-bucket-policies-s3-inventory-1)」を参照してください。
**S3 インベントリを使用してオブジェクトのリストを取得するには、次のようにします。**
1. Amazon S3 コンソール ([https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)) を開きます。
1. ナビゲーションペインで、**[バケット]** を選択し、暗号化するオブジェクトを含むバケットを選択します。
1. [**Management**] (管理) タブの [**Inventory configurations**] (インベントリ設定) セクションに移動し、[**Create inventory configuration**] (インベントリ設定の作成) を選択します。
1. 新しいインベントリに名前を付け、送信先 S3 バケットの名前を入力し、オプションで Amazon S3 の送信先プレフィックスを作成して、そのバケット内のオブジェクトを割り当てます。
1. [**Output format**] (出力形式) として [**CSV**] を選択します。
1. **[追加フィールド** - *オプション]* セクションで、**[暗号化]** と、関心のあるその他の任意のレポートフィールドを選択します。レポート配信の頻度を [**Daily**] (毎日) に設定して、最初のレポートが早くバケットに配信されるようにします。
1. [**Create**] (作成) を選択して設定を保存します。
Amazon S3 では最初のレポートが配信されるまでに最大で 48 時間かかることがあります。最初のレポートが到着したら確認してください。最初のレポートを受け取ったら、次のステップに進み、S3 インベントリレポートの内容をフィルタリングします。このバケットのインベントリレポートを受信する必要がなくなった場合は、S3 インベントリ設定を削除します。削除しない場合、Amazon S3 は毎日または毎週のスケジュールでレポートの配信を継続します。
インベントリ・リストは、すべてのオブジェクトの単一のポイント・イン・タイム・ビューではありません。インベントリリストはバケットアイテムのローリングスナップショットであり、最終的には整合します (たとえば、最近追加されたオブジェクトや削除されたオブジェクトはリストに含まれない可能性があります)。静的オブジェクトや、2 日以上前に作成したオブジェクトセットを操作するときには、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 を使用してください。Amazon Athena は複数の S3 オブジェクトに対して実行されますが、S3 Select は一度に 1 つのオブジェクトに対して動作するためです。Amazon S3 と Athena を一緒に使用する方法について詳しくは、「[Amazon Athena で Amazon S3 インベントリをクエリする](storage-inventory-athena-query.md)」と、AWS ブログ投稿「[Encrypting objects with Amazon S3 Batch Operations](https://aws.amazon.com/blogs/storage/encrypting-objects-with-amazon-s3-batch-operations)」の「Using Athena」を参照してください。
**S3 Select を使用して S3 インベントリレポートをフィルタリングするには**
1. インベントリレポートの `manifest.json` ファイルを開き、JSON の `fileSchema` セクションを探します。このセクションは、データに対して実行するクエリに情報を提供します。
次の JSON は、バージョニングが有効なバケットの CSV 形式のインベントリに対する `manifest.json` ファイルの例です。インベントリレポートの設定方法に応じて、マニフェストの内容は異なる場合があります。
```
{
"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 に注意してください。
S3 バッチオペレーションは、ジョブを実行するための入力として、検索条件のフィールド (`BucketKeyStatus`) に加えて、バケット、キー、およびバージョン 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 expression] (SQL 式) フィールドに入力し、[**Run SQL**] (SQL の実行) を選択します。次の式は、S3 バケットキー が設定されていないすべてのオブジェクトの列 1 ～ 3 を返します。
`select s._1, s._2, s._3 from s3object s where s._6 = 'DISABLED'`
結果の例は次のとおりです。
```
batchoperationsdemo,0100059%7Ethumb.jpg,lsrtIxksLu0R0ZkYPL.LhgD5caTYn6vu
batchoperationsdemo,0100074%7Ethumb.jpg,sd2M60g6Fdazoi6D5kNARIE7KzUibmHR
batchoperationsdemo,0100075%7Ethumb.jpg,TLYESLnl1mXD5c4BwiOIinqFrktddkoL
batchoperationsdemo,0200147%7Ethumb.jpg,amufzfMi_fEw0Rs99rxR_HrDFlE.l3Y0
batchoperationsdemo,0301420%7Ethumb.jpg,9qGU2SEscL.C.c_sK89trmXYIwooABSh
batchoperationsdemo,0401524%7Ethumb.jpg,ORnEWNuB1QhHrrYAGFsZhbyvEYJ3DUor
batchoperationsdemo,200907200065HQ%7Ethumb.jpg,d8LgvIVjbDR5mUVwW6pu9ahTfReyn5V4
batchoperationsdemo,200907200076HQ%7Ethumb.jpg,XUT25d7.gK40u_GmnupdaZg3BVx2jN40
batchoperationsdemo,201103190002HQ%7Ethumb.jpg,z.2sVRh0myqVi0BuIrngWlsRPQdb7qOS
```
1. 結果をダウンロードし、CSV 形式で保存し、S3 バッチオペレーションジョブのオブジェクトのリストとして Amazon S3 にアップロードします。
1. マニフェストファイルが複数ある場合は、それらに対して **S3 Select を使用したクエリ**も実行します。結果のサイズに応じて、リストを組み合わせて単一の S3 バッチオペレーションジョブを実行することも、各リストを個別のジョブとして実行することもできます。実行するジョブ数を決定するときは、各 S3 バッチオペレーションジョブを実行する[料金](https://aws.amazon.com/s3/pricing/)を考慮してください。
## ステップ 3: S3 バッチオペレーションジョブをセットアップして実行する
これで、S3 オブジェクトの CSV リストがフィルタリングされたため、S3 バッチオペレーションジョブを開始して、有効になっている S3 バケットキーでオブジェクトを暗号化できます。
*ジョブ*は、指定されるオブジェクトのリスト (マニフェスト)、実行されるオペレーション、および指定されたパラメータの総称です。有効になっている S3 バケットキーでこのオブジェクトのセットを暗号化する最も簡単な方法は、**Copy** オペレーションを使用し、マニフェストにリストされているオブジェクトと同じ送信先プレフィックスを指定することです。バージョン設定されていないバケットでは、このオペレーションによって既存のオブジェクトが上書きされます。バージョニングが有効になっているバケットでは、このオペレーションにより、オブジェクトの暗号化された新しいバージョンが作成されます。
オブジェクトのコピーの一環として、Amazon S3 が SSE-KMS 暗号化を使用してオブジェクトを暗号化するように指定します。このジョブはオブジェクトをコピーするため、Amazon S3 に最初に追加した日時に関係なく、完了時にすべてのオブジェクトについて更新された作成日が表示されます。また、S3 バッチオペレーションジョブの一環として、オブジェクトタグやストレージクラスなどのオブジェクトのセットの他のプロパティを指定します。
**Topics**
+ [IAM ポリシーをセットアップする](#bucket-key-ex-set-up-iam-policy)
+ [バッチオペレーションの IAM ロールのセットアップ](#bucket-key-ex-set-up-iam-role)
+ [既存のバケットに対して S3 バケットキーを有効にする](#bucket-key-ex-enable-s3-bucket-key-on-a-bucket)
+ [バッチオペレーションジョブを作成する](#bucket-key-ex-create-job)
+ [バッチオペレーションジョブを実行する](#bucket-key-ex-run-job)
### IAM ポリシーをセットアップする
1. IAM コンソール ([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)) を開きます。
1. 左のナビゲーションペインで、**[ポリシー]** を選択し、**[ポリシーの作成]** を選択します。
1. [**JSON**] タブを選択します。[**Edit policy**] (ポリシーの編集) を選択し、次のコードブロックに表示される IAM ポリシーの例を追加します。
ポリシーの例を [IAM コンソール](https://console.aws.amazon.com/iam/)にコピーしたら、次の項目を置き換えます。
1. `amzn-s3-demo-source-bucket` をオブジェクトのコピー元であるソースバケットの名前に置き換えます。
1. `amzn-s3-demo-destination-bucket` を、オブジェクトをコピーする宛先のバケットの名前に置き換えます。
1. `amzn-s3-demo-manifest-bucket/manifest-key` を、マニフェストオブジェクトの名前に置き換えます。
1. `amzn-s3-demo-completion-report-bucket` を、完了レポートを保存するバケットの名前に置き換えます。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CopyObjectsToEncrypt",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:PutObjectTagging",
"s3:PutObjectAcl",
"s3:PutObjectVersionTagging",
"s3:PutObjectVersionAcl",
"s3:GetObject",
"s3:GetObjectAcl",
"s3:GetObjectTagging",
"s3:GetObjectVersion",
"s3:GetObjectVersionAcl",
"s3:GetObjectVersionTagging"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-source-bucket/*",
"arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
]
},
{
"Sid": "ReadManifest",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-manifest-bucket/manifest-key"
},
{
"Sid": "WriteReport",
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-completion-report-bucket/*"
}
]
}
```
------
1. **[Next: Tags]** (次へ: タグ) を選択します。
1. 必要なタグを追加し (オプション)、[**Next: Review**] (次へ: 確認) を選択します。
1. ポリシー名と、オプションで説明を追加追加し、[**Create Policy**] (ポリシーの作成) を選択します。
1. [**Review policy**] (ポリシーの確認) を選択し、[**Save changes**] (変更の保存) を選択します。
1. S3 バッチオペレーションポリシーが完了したため、コンソールが IAM の ［**Policies**] (ポリシー) ページに戻ります。ポリシー名をフィルタリングし、ポリシー名の左にあるボタンを選択します。次に、[**Policy actions**] (ポリシーアクション) を選択し、[**Attach**] (アタッチ) を選択します。
新しく作成したポリシーを IAM ロールにアタッチするには、アカウントで該当するユーザー、グループ、またはロールを選択し、[**Attach policy**] (ポリシーのアタッチ) を選択します。これにより、IAM コンソールに戻ります。
### バッチオペレーションの IAM ロールのセットアップ
1. [IAM コンソール](https://console.aws.amazon.com/iam/)のナビゲーションペインで、**[ロール]**、**[ロールの作成]** の順に選択します。
1. **[AWS のサービス]**、**[S3]**、および **[S3 バッチオペレーション]** を選択します。続いて、[**Next: Permissions**] を選択します。
1. 先ほど作成した IAM **ポリシー**の名前の入力を開始します。表示されるポリシー名のチェックボックスをオンにし、[**Next: Tags**] (次: タグ) を選択します。
1. (オプション) この演習では、タグを追加するか、キーと値のフィールドを空白のままにします。[**Next: Review**] を選択します。
1. ロール名を入力し、デフォルトの説明をそのまま使用するか、独自の説明を追加します。[**ロールの作成**] を選択します。
1. ジョブを作成するユーザーに、次の例の権限があることを確認します。
`account-id` を AWS アカウント ID に、`IAM-role-name` を後でバッチオペレーションジョブの作成ステップで作成する IAM ロールに適用する予定の名前に置き換えます。詳細については、「[バッチオペレーションに対するアクセス許可の付与](batch-ops-iam-role-policies.md)」を参照してください。
```
{
"Sid": "AddIamPermissions",
"Effect": "Allow",
"Action": [
"iam:GetRole",
"iam:PassRole"
],
"Resource": "arn:aws:iam::account-id:role/IAM-role-name"
}
```
### 既存のバケットに対して S3 バケットキーを有効にする
1. Amazon S3 コンソール ([https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)) を開きます。
1. **[バケット]** リストで、S3 バケットキーを有効にするバケットを選択します。
1. [**プロパティ**] を選択します。
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 は、最強のブロック暗号の 1 つである 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. **[バケットキー]** で **[有効化]** を選択します。コピーオペレーションでは、送信先バケットに、S3 バケットキーが適用されます。
1. ジョブに説明を付け (またはデフォルトのままにし)、その優先順位レベルを設定し、レポートタイプを選択して、[**Path to completion report destination**] (完了レポートの送信先へのパス) を指定します。
1. [**Permissions**] (アクセス権限) セクションで、前に定義したバッチオペレーションの IAM ロールを選択するようにしてください。[**Next (次へ)**] を選択します。
1. [**Review**] (確認) で、設定を確認します。変更が必要な場合は、[**Previous**] (前へ) を選択します。バッチオペレーションの設定を確認したら、[**Create job**] (ジョブの作成) を選択します。
詳細については、「[S3 バッチオペレーションジョブの作成](batch-ops-create-job.md)」を参照してください。
### バッチオペレーションジョブを実行する
セットアップウィザードによって、Amazon S3 コンソールの S3 バッチオペレーションセクションに自動的に戻ります。S3 がプロセスを開始すると、新しいジョブが [**New**] (新規) 状態から [**Preparing**] (準備中) 状態に遷移します。[Preparing] (準備中) 状態の間、S3 はジョブのマニフェストを読み取り、エラーをチェックし、オブジェクトの数を計算します。
1. 進行状況を確認するには、Amazon S3 コンソールの [Refresh] (更新) ボタンを選択します。マニフェストのサイズによっては、読み取りに数分または数時間かかることがあります。
1. S3 がジョブのマニフェストの読み取りを終了すると、ジョブは [**Awaiting your confirmation**] (確認待ち) 状態に移行します。ジョブ ID の左にあるオプションボタンを選択し、[**Run job**] (ジョブの実行) を選択します。
1. ジョブの設定を確認し、右下隅の [**Run job**] (ジョブの実行) を選択します。
ジョブの実行が開始したら、[refresh] (更新) ボタンを選択してコンソールのダッシュボードビューで、または特定のジョブを選択して、進行状況を確認できます。
1. ジョブが完了したら、[**Successful**] (成功) と [**Failed**] (失敗) のオブジェクト数を表示して、すべてが予期したとおりに実行されたことを確認できます。ジョブレポートを有効にした場合は、ジョブレポートで、失敗したオペレーションの正確な原因を確認します。
これらのステップは、AWS CLI、AWS SDK、または Amazon S3 REST API を使用して実行することもできます。ジョブのステータスと完了レポートの追跡については、[ジョブステータスと完了レポートの追跡](batch-ops-job-status.md) を参照してください。
AWS CLI および AWS SDK for Java を使用したタグによるコピーオペレーションの例については、[ラベル付けに使用されるジョブタグを使用したバッチ操作ジョブの作成](batch-ops-tags-create.md) を参照してください。
# チェックサムの計算
**[チェックサムを計算]** オペレーションで S3 バッチオペレーションを使用して、Amazon S3 に保存されている保管中のオブジェクトのチェックサム計算を実行できます。**[チェックサムを計算]** オペレーションは、オブジェクトのチェックサムを計算します。このチェックサムを使用して、保存されたデータのオブジェクトをダウンロードまたは復元することなく、データの整合性を検証できます。**[チェックサムを計算]** オペレーションを使用して、サポートされているすべてのチェックサムアルゴリズムについて、複合チェックサムタイプとフルオブジェクトチェックサムタイプの両方のチェックサムを計算できます。
**[チェックサムを計算]** オペレーションを使用すると、1 回のジョブリクエストで数十億のオブジェクトを処理できます。このバッチオペレーションは、オブジェクトサイズに関係なく、すべての S3 ストレージクラスと互換性があります。**[チェックサムを計算]** ジョブを作成するには、Amazon S3 コンソール、AWS Command Line Interface (AWS CLI)、AWS SDK、または Amazon S3 REST API を使用します。
[サーバーアクセスログ記録を有効](https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerLogs.html)にすると、**[チェックサムを計算]** ジョブに関するログエントリを受信することもできます。**[チェックサムを計算]** ジョブオペレーションは、チェックサム計算の完了後に個別のサーバーアクセスログイベントを出力します。これらのログエントリは、標準の [S3 サーバーアクセスログの形式](https://docs.aws.amazon.com/AmazonS3/latest/userguide/LogFormat.html)に従い、オペレーションタイプ、タイムスタンプ、[エラーコード](https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#ErrorCodeList)、関連する **[チェックサムを計算]** ジョブ ID などのフィールドが含まれます。このログ記録は、オブジェクトで実行されたチェックサム検証アクティビティの監査証跡を提供し、データ整合性オペレーションの追跡と検証に役立ちます。
**注記**
**[チェックサムを計算]** オペレーションは、お客様が用意した暗号化キー (SSE-C) 暗号化オブジェクトによるサーバー側の暗号化をサポートしていません。ただし、[S3 マネージドキーによるサーバー側の暗号化 (SSE-S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html)、AWS Key Management Service によるサーバー側の暗号化 (DSSE-KMS) を使用して暗号化されたオブジェクトでは、**[チェックサムを計算]** オペレーションを使用できます。**[チェックサムを計算]** オペレーションを実行するための[適切な AWS KMS アクセス許可が付与](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html#require-sse-kms)されていることを確認します。
バッチオペレーションを使用して **[チェックサムを計算]** オペレーションを開始するには、次のいずれかを実行します。
+ 新しいマニフェストファイルを手動で作成する。
+ 既存のマニフェストを使用する。
+ 直接バッチオペレーションでは、[ジョブの作成時に指定した](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-create-job.html#specify-batchjob-manifest)オブジェクトフィルター条件に基づいてマニフェストを自動的に生成します。
次に、**[チェックサムを計算]** ジョブリクエストを送信し、そのステータスをモニタリングします。**[チェックサムを計算]** ジョブが完了すると、指定した送信先バケットに完了レポートが自動的に送信されます。この完了レポートには、バケット内のすべてのオブジェクトのチェックサム情報が含まれており、データ整合性を検証できます。このレポートを使用してジョブを確認する方法については、「[ジョブステータスと完了レポートの追跡](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-job-status.html)」を参照してください。
**[チェックサムを計算]** 機能について、およびコンソールで **[チェックサムを計算]** を使用する方法の詳細については、「[Amazon S3 で保管中のデータのオブジェクトの整合性を確認する](checking-object-integrity-at-rest.md)」を参照してください。**[チェックサムを計算]** に REST リクエストを送信する方法については、「*Amazon S3 API リファレンス*」の「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DescribeJob.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DescribeJob.html)」と「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateJob.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateJob.html)」を参照してください。
以下のセクションでは、S3 バッチオペレーションで **[チェックサムを計算]** オペレーションの使用を開始する方法について説明します。
**Topics**
+ [S3 バッチオペレーションの **[チェックサムを計算]** に関する考慮事項](#batch-ops-compute-checksum-considerations)
+ [S3 バッチオペレーション完了レポート](#batch-ops-compute-checksum-completion-report)
## S3 バッチオペレーションの **[チェックサムを計算]** に関する考慮事項
**[チェックサムを計算]** オペレーションを使用する前に、次の考慮事項のリストを確認してください。
+ マニフェストにバージョン ID フィールドが含まれている場合は、マニフェスト内にあるすべてのオブジェクトのバージョン ID を指定する必要があります。バージョン ID が指定されていない場合、**[チェックサムを計算]** リクエストはオブジェクトの最新バージョンに対してオペレーションを実行します。
+ [サーバーアクセスログ](https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerLogs.html)で **[チェックサムを計算]** オペレーションの詳細を受信するには、まずソースバケットで[サーバーアクセスログを有効](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-server-access-logging.html)にし、ログを保存する送信先バケットを指定する必要があります。また、ソースと送信先バケットの両方が同じ AWS リージョンにあり、同じ AWS アカウントが所有している必要があります。サーバーアクセスのログ記録を設定すると、**[チェックサムを計算]** オペレーションは、オペレーションタイプ、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)を生成します。**[チェックサムを計算]** オペレーションは非同期的に実行されます。その結果、[ログエントリ](https://docs.aws.amazon.com/AmazonS3/latest/userguide/LogFormat.html#log-record-fields)では、リクエスト ID ではなく **[チェックサムを計算]** ジョブ ID がログエントリに使用されます。
+ 保存されたオブジェクトのレポートの生成には、最大で数時間かかる場合があります。
+ 次の S3 Glacier ストレージクラスの場合、**[チェックサムを計算]** ジョブが完了するまでに最大 1 週間かかることがあります。
+ S3 Glacier Flexible Retrieval
+ S3 Glacier Deep Archive
+ 完了レポートが書き込まれるバケットの場合、**[チェックサムを計算]** オペレーションを実行するときに[バケット所有者条件](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-owner-condition.html#bucket-owner-condition-when-to-use)を使用する必要があります。実際のバケット所有者が送信したジョブリクエストの正しいバケット所有者と一致しない場合、ジョブは失敗します。バケット所有者条件がサポートされていない S3 オペレーションのリストについては、「[制約と制限](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-owner-condition.html#bucket-owner-condition-restrictions-limitations)」を参照してください。
## S3 バッチオペレーション完了レポート
**[チェックサムを計算]** ジョブを作成するときに、S3 バッチオペレーションの完了レポートをリクエストできます。この CSV ファイルには、オブジェクト、成功コードまたは失敗コード、出力、および説明が表示されます。ジョブの追跡と完了レポートの追跡については、「[完了レポート](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-job-status.html#batch-ops-completion-report)」を参照してください。
# すべてのオブジェクトタグを削除する
Amazon S3 バッチオペレーションを使用すると、Amazon S3 のオブジェクトに対して大規模なバッチオペレーションを実行できます。**すべてのオブジェクトタグの削除**のオペレーションは、マニフェストにリストされているオブジェクトに現在関連付けられているすべての Amazon S3 オブジェクトタグセットを削除します。S3 バッチオペレーションでは、他のタグを維持したままオブジェクトからタグを削除することはできません。
マニフェスト内のオブジェクトがバージョニングされたバケットにある場合は、オブジェクトの特定のバージョンからタグセットを削除できます。これを実行するには、マニフェストですべてのオブジェクトにバージョン ID を指定する必要があります。オブジェクトのバージョン ID を含めない場合、S3 バッチ操作はすべてのオブジェクトの最新バージョンからタグセットを削除します。バッチ操作マニフェストの詳細については、「[マニフェストの指定](batch-ops-create-job.md#specify-batchjob-manifest)」をご参照ください。
オブジェクトのタグ付けの詳細については、このガイドの「[タグを使用したオブジェクトの分類](object-tagging.md)」および「Amazon Simple Storage Service API リファレンス」の「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html)」、「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObjectTagging.html)」、「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjectTagging.html)」を参照してください。**
**警告**
このジョブを実行すると、マニフェストにリストされているすべてのオブジェクトのすべてのオブジェクトタグセットが削除されます。
コンソールを使用して **[すべてのオブジェクトタグを削除する]** ジョブを作成するには、「[S3 バッチオペレーションジョブの作成](batch-ops-create-job.md)」を参照してください。
## 制約と制限
バッチオペレーションを使用してオブジェクトタグを削除する場合、以下の制約と制限が適用されます。
+ ジョブを実行するために指定する AWS Identity and Access Management (IAM) ロールには、基になる Amazon S3 の `DeleteObjectTagging` オペレーションを実行するためのアクセス権限が必要です。詳細については、「**Amazon Simple Storage Service API リファレンス」の「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjectTagging.html)」を参照してください。
+ S3 バッチオペレーションは、Amazon S3 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjectTagging.html) オペレーションを使用して、マニフェスト内のすべてのオブジェクトからタグセットを削除します。基になるオペレーションに適用されるすべての制約と制限は、S3 バッチ操作ジョブにも適用されます。
+ 1 つのオブジェクト削除タグ付けジョブで、最大 200 億個のオブジェクトを持つマニフェストをサポートできます。
# AWS Lambda 関数の呼び出し
Amazon S3 バッチオペレーションを使用すると、Amazon S3 のオブジェクトに対して大規模なバッチオペレーションを実行できます。**AWS Lambda の呼び出し関数**バッチオペレーションは、AWS Lambda 関数を開始し、マニフェストにリストされているオブジェクトに対してカスタムアクションを実行します。このセクションでは、S3 バッチ操作で使用する Lambda 関数とその関数を呼び出すジョブを作成する方法について説明します。S3 バッチ操作ジョブでは、`LambdaInvoke` オペレーションを使用して、マニフェストにリストされているすべてのオブジェクトに対して Lambda 関数を実行します。
Amazon S3 コンソール、AWS Command Line Interface (AWS CLI)、AWS SDK、または Amazon S3 REST API を使用して S3 バッチオペレーションを扱うことができます。Lambda の使用について詳しくは、*AWS Lambda 開発者ガイド*の[AWS Lambda の使用を開始する](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html)を参照してください。
以下のセクションでは、S3 バッチ操作で Lambda を使用する方法について説明します。
**Topics**
+ [バッチオペレーションで Lambda を使用する](#batch-ops-invoke-lambda-using)
+ [S3 バッチ操作で使用する Lambda 関数の作成](#batch-ops-invoke-lambda-custom-functions)
+ [Lambda 関数を呼び出す S3 バッチ操作のジョブの作成](#batch-ops-invoke-lambda-create-job)
+ [Lambda のマニフェストでのタスクレベルの情報の指定](#storing-task-level-information-in-lambda)
+ [S3 バッチ操作のチュートリアル](#batch-ops-tutorials-lambda)
## バッチオペレーションで Lambda を使用する
S3 バッチ操作で AWS Lambda を使用するときは、S3 バッチ操作で使用するための Lambda 関数を新しく作成する必要があります。既存の Amazon S3 のイベントベースの関数を S3 バッチ操作で再利用することはできません。イベント関数はメッセージの受信のみ可能です。メッセージを返すことはできません。S3 バッチ操作で使用する Lambda 関数では、メッセージを受け取って返す必要があります。Amazon S3 のイベントで Lambda を使用する方法について詳しくは、*AWS Lambda 開発者ガイド*の[AWS Lambda を Amazon S3 に使用する](https://docs.aws.amazon.com/lambda/latest/dg/with-s3.html)を参照してください。
Lambda 関数を呼び出す S3 バッチ操作のジョブを作成します。このジョブは、マニフェストにリストされているすべてのオブジェクトに対して同じ Lambda 関数を実行します。マニフェストのオブジェクトの処理時に使用する Lambda 関数のバージョンは指定できます。S3 バッチ操作では、非修飾 Amazon リソースネーム (ARN)、エイリアス、特定のバージョンがサポートされています。詳しくは、*AWS Lambda 開発者ガイド*の[AWS Lambda 関数のバージョン](https://docs.aws.amazon.com/lambda/latest/dg/versioning-intro.html)を参照してください。
S3 バッチ操作のジョブにエイリアスまたは `$LATEST` 修飾子を使用する関数の ARN を指定し、それらのいずれかが指すバージョンを更新すると、S3 バッチ操作は新しいバージョンの Lambda 関数を呼び出します。これは、大規模なジョブで機能の一部を更新する場合に役立ちます。S3 バッチオペレーションで使用するバージョンを変更したくない場合は、ジョブの作成時に `FunctionARN` パラメータで特定のバージョンを指定します。
1 つの S3 バッチオペレーションを使用する AWS Lambda ジョブで、最大 200 億個のオブジェクトを持つマニフェストをサポートできます。
### ディレクトリバケットで Lambda とバッチオペレーションを使用する
ディレクトリバケットは Amazon S3 バケットタイプの1 つであり、一貫して 1 桁ミリ秒のレイテンシーに維持する必要があるワークロードまたはパフォーマンス重視のアプリケーション向けに設計されています。詳細については、「[ディレクトリバケット](https://docs.aws.amazon.com//AmazonS3/latest/userguide/directory-buckets-overview.html)」を参照してください。
バッチオペレーションを使用してディレクトリバケットで動作する Lambda 関数を呼び出すには、独自の要件があります。例えば、更新された JSON スキーマを使用して Lambda リクエストを構築し、ジョブを作成する際に [https://docs.aws.amazon.com//AmazonS3/latest/API/API_control_LambdaInvokeOperation.html#AmazonS3-Type-control_LambdaInvokeOperation-InvocationSchemaVersion](https://docs.aws.amazon.com//AmazonS3/latest/API/API_control_LambdaInvokeOperation.html#AmazonS3-Type-control_LambdaInvokeOperation-InvocationSchemaVersion) 2.0 (1.0 ではない) を指定する必要があります。この更新されたスキーマでは、[https://docs.aws.amazon.com//AmazonS3/latest/API/API_control_LambdaInvokeOperation.html#AmazonS3-Type-control_LambdaInvokeOperation-UserArguments](https://docs.aws.amazon.com//AmazonS3/latest/API/API_control_LambdaInvokeOperation.html#AmazonS3-Type-control_LambdaInvokeOperation-UserArguments) にオプションのキーバリューペアを指定できます。これを使用して、既存の Lambda 関数の特定のパラメータを変更できます。詳細については、「AWS ストレージブログ」の「[Automate object processing in Amazon S3 directory buckets with S3 Batch Operations and AWS Lambda](https://aws.amazon.com/blogs/storage/automate-object-processing-in-amazon-s3-directory-buckets-with-s3-batch-operations-and-aws-lambda/)」を参照してください。
### レスポンスと結果のコード
S3 バッチオペレーションは、それぞれに `TaskID` が関連付けられている 1 つ以上のキーを使用して Lambda 関数を呼び出します。S3 バッチオペレーションには、Lambda 関数からのキーごとの結果コードが必要です。キーごとの結果コードで返されないタスク ID は、リクエストコードで返され、`treatMissingKeysAs` フィールドの結果コードが付与されます。`treatMissingKeysAs` はオプションのリクエストフィールドで、デフォルトは `TemporaryFailure` です。次の表に、 `treatMissingKeysAs` フィールドの他の有効な結果コードと値を示します。
| Response Code (レスポンスコード) | 説明 |
| --- | --- |
| Succeeded | タスクは正常に完了しました。ジョブ完了レポートをリクエストした場合は、タスクの結果の文字列がレポートに含まれます。 |
| TemporaryFailure | タスクは一時的に失敗し、ジョブが完了する前に再始動されます。結果の文字列は無視されます。最終的な再処理である場合は、エラーメッセージが最終レポートに含まれます。 |
| PermanentFailure | タスクに固定障害が発生しました。ジョブ完了レポートをリクエストした場合、タスクは Failed としてマークされ、エラーメッセージの文字列が含まれます。失敗したタスクの結果の文字列は無視されます。 |
## S3 バッチ操作で使用する Lambda 関数の作成
このセクションでは、Lambda 関数で使用する必要のある AWS Identity and Access Management (IAM) アクセス許可の例について説明します。また、S3 バッチ操作で使用する Lambda 関数の例も示します。Lambda 関数を作成したことがない場合は、*AWS Lambda 開発者ガイド*の[チュートリアル: Amazon S3 トリガーを使用して AWS Lambda 関数を呼び出す](https://docs.aws.amazon.com/lambda/latest/dg/with-s3-example.html)を参照してください。
S3 バッチ操作で使用するための Lambda 関数を作成する必要があります。既存の Amazon S3 イベントベースの Lambda 関数を再利用することはできません。これは、S3 バッチオペレーションで使用する Lambda 関数では、特別なデータフィールドを受け取って返す必要があるためです。
**重要**
Java で記述された AWS Lambda 関数は、[https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/RequestHandler.java](https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/RequestHandler.java) または [https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/RequestStreamHandler.java](https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/RequestStreamHandler.java) ハンドラーインターフェイスのいずれかを受け入れます。ただし、S3 バッチ操作のリクエストとレスポンスの形式をサポートするため、リクエストとレスポンスのカスタムのシリアル化と逆シリアル化のために AWS Lambda は `RequestStreamHandler` インターフェイスを必要とします。このインターフェイスにより、Lambda は Java の `handleRequest` メソッドに InputStream と OutputStream ストリームを渡すことができます。
S3 バッチ操作で Lambda 関数を使用する場合は、必ず `RequestStreamHandler` インターフェイスを使用してください。`RequestHandler` インターフェイスを使用すると、バッチジョブが失敗し、完了レポートに「Invalid JSON returned in Lambda payload」と表示されます。
詳しくは、*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 ポリシー**
以下は、S3 バッチ操作に Lambda 関数を呼び出して入力のマニフェストを読み取るアクセス許可を与える IAM ポリシーの例です。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "BatchOperationsLambdaPolicy",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:PutObject",
"lambda:InvokeFunction"
],
"Resource": "*"
}
]
}
```
### リクエストとレスポンスの例
このセクションでは、Lambda 関数のリクエストとレスポンスの例を示します。
**Example リクエスト**
以下は、Lambda 関数のリクエストの JSON の例です。
```
{
"invocationSchemaVersion": "1.0",
"invocationId": "YXNkbGZqYWRmaiBhc2RmdW9hZHNmZGpmaGFzbGtkaGZza2RmaAo",
"job": {
"id": "f3cc4f60-61f6-4a2b-8a21-d07600c373ce"
},
"tasks": [
{
"taskId": "dGFza2lkZ29lc2hlcmUK",
"s3Key": "customerImage1.jpg",
"s3VersionId": "1",
"s3BucketArn": "arn:aws:s3:us-east-1:0123456788:amzn-s3-demo-bucket1"
}
]
}
```
**Example 応答**
以下は、Lambda 関数のレスポンスの JSON の例です。
```
{
"invocationSchemaVersion": "1.0",
"treatMissingKeysAs" : "PermanentFailure",
"invocationId" : "YXNkbGZqYWRmaiBhc2RmdW9hZHNmZGpmaGFzbGtkaGZza2RmaAo",
"results": [
{
"taskId": "dGFza2lkZ29lc2hlcmUK",
"resultCode": "Succeeded",
"resultString": "[\"Mary Major", \"John Stiles\"]"
}
]
}
```
### S3 バッチ操作の Lambda 関数の例
次の Python Lambda の例では、バージョン管理されたオブジェクトから削除マーカーを削除します。
例に示すように、S3 バッチ操作のキーは URL エンコードされます。Amazon S3 を他の AWS のサービスとともに使用するには、S3 バッチ操作から渡されたキーを URL デコードすることが重要です。
```
import logging
from urllib import parse
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logger.setLevel("INFO")
s3 = boto3.client("s3")
def lambda_handler(event, context):
"""
Removes a delete marker from the specified versioned object.
:param event: The S3 batch event that contains the ID of the delete marker
to remove.
:param context: Context about the event.
:return: A result structure that Amazon S3 uses to interpret the result of the
operation. When the result code is TemporaryFailure, S3 retries the
operation.
"""
# Parse job parameters from Amazon S3 batch operations
invocation_id = event["invocationId"]
invocation_schema_version = event["invocationSchemaVersion"]
results = []
result_code = None
result_string = None
task = event["tasks"][0]
task_id = task["taskId"]
try:
obj_key = parse.unquote_plus(task["s3Key"], encoding="utf-8")
obj_version_id = task["s3VersionId"]
bucket_name = task["s3BucketArn"].split(":")[-1]
logger.info(
"Got task: remove delete marker %s from object %s.", obj_version_id, obj_key
)
try:
# If this call does not raise an error, the object version is not a delete
# marker and should not be deleted.
response = s3.head_object(
Bucket=bucket_name, Key=obj_key, VersionId=obj_version_id
)
result_code = "PermanentFailure"
result_string = (
f"Object {obj_key}, ID {obj_version_id} is not " f"a delete marker."
)
logger.debug(response)
logger.warning(result_string)
except ClientError as error:
delete_marker = error.response["ResponseMetadata"]["HTTPHeaders"].get(
"x-amz-delete-marker", "false"
)
if delete_marker == "true":
logger.info(
"Object %s, version %s is a delete marker.", obj_key, obj_version_id
)
try:
s3.delete_object(
Bucket=bucket_name, Key=obj_key, VersionId=obj_version_id
)
result_code = "Succeeded"
result_string = (
f"Successfully removed delete marker "
f"{obj_version_id} from object {obj_key}."
)
logger.info(result_string)
except ClientError as error:
# Mark request timeout as a temporary failure so it will be retried.
if error.response["Error"]["Code"] == "RequestTimeout":
result_code = "TemporaryFailure"
result_string = (
f"Attempt to remove delete marker from "
f"object {obj_key} timed out."
)
logger.info(result_string)
else:
raise
else:
raise ValueError(
f"The x-amz-delete-marker header is either not "
f"present or is not 'true'."
)
except Exception as error:
# Mark all other exceptions as permanent failures.
result_code = "PermanentFailure"
result_string = str(error)
logger.exception(error)
finally:
results.append(
{
"taskId": task_id,
"resultCode": result_code,
"resultString": result_string,
}
)
return {
"invocationSchemaVersion": invocation_schema_version,
"treatMissingKeysAs": "PermanentFailure",
"invocationId": invocation_id,
"results": results,
}
```
## Lambda 関数を呼び出す S3 バッチ操作のジョブの作成
Lambda 関数を呼び出す S3 バッチ操作のジョブを作成する場合は、以下を指定する必要があります。
+ Lambda 関数の ARN (関数のエイリアスまたは特定のバージョン番号を含む)
+ 関数を呼び出すアクセス許可を持つ IAM ロール
+ アクションパラメータ `LambdaInvokeFunction`
S3 バッチ操作のジョブの作成の詳細については、「[S3 バッチオペレーションジョブの作成](batch-ops-create-job.md)」および「[S3 バッチ操作でサポートされるオペレーション](batch-ops-operations.md)」を参照してください。
次の例では、AWS CLI を使用して Lambda 関数を呼び出す S3 バッチオペレーションのジョブを作成します。この例を実行するには、*`user input placeholders`* をユーザー自身の情報に置き換えます。
```
aws s3control create-job
--account-id account-id
--operation '{"LambdaInvoke": { "FunctionArn": "arn:aws:lambda:region:account-id:function:LambdaFunctionName" } }'
--manifest '{"Spec":{"Format":"S3BatchOperations_CSV_20180820","Fields":["Bucket","Key"]},"Location":{"ObjectArn":"arn:aws:s3:::amzn-s3-demo-manifest-bucket","ETag":"ManifestETag"}}'
--report '{"Bucket":"arn:aws:s3:::amzn-s3-demo-bucket","Format":"Report_CSV_20180820","Enabled":true,"Prefix":"ReportPrefix","ReportScope":"AllTasks"}'
--priority 2
--role-arn arn:aws:iam::account-id:role/BatchOperationsRole
--region region
--description "Lambda Function"
```
## Lambda のマニフェストでのタスクレベルの情報の指定
S3 バッチオペレーションで AWS Lambda 関数を使用する際、操作対象の各タスク/キーに付随する追加データが必要になる場合があります。例えば、ソースオブジェクトキーと新しいオブジェクトキーの両方を提供したい場合があります。Lambda 関数は、元のキーを新しい名前で新しい S3 バケットにコピーできます。デフォルトでは、バッチオペレーションでは、ジョブへの入力マニフェストで移行先バケットとソースキーのリストのみを指定できます。以下の例では、マニフェストにデータを追加して、より複雑な Lambda 関数を実行する方法について説明します。
S3 バッチ操作のマニフェストでキーごとのパラメータを指定して Lambda 関数のコードで使用するには、以下に示すように URL エンコードされた形式の JSON を使用します。`key` フィールドは、Amazon S3 のオブジェクトのキーのように Lambda 関数に渡されます。ただし、以下の例に示すように、Lambda 関数で他の値や複数のキーを含めるように解釈することができます。
**注記**
マニフェストの `key` フィールドの最大文字数は 1,024 文字です。
**Example - 「Amazon S3 のキー」を JSON の文字列に置き換える前のマニフェスト**
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 バッチオペレーションのマニフェストに解析する方法を示しています。タスクは、指定されたオブジェクトに適用されているリビジョンオペレーションを示します。
```
import logging
from urllib import parse
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logger.setLevel("INFO")
s3 = boto3.resource("s3")
def lambda_handler(event, context):
"""
Applies the specified revision to the specified object.
:param event: The Amazon S3 batch event that contains the ID of the object to
revise and the revision type to apply.
:param context: Context about the event.
:return: A result structure that Amazon S3 uses to interpret the result of the
operation.
"""
# Parse job parameters from Amazon S3 batch operations
invocation_id = event["invocationId"]
invocation_schema_version = event["invocationSchemaVersion"]
results = []
result_code = None
result_string = None
task = event["tasks"][0]
task_id = task["taskId"]
# The revision type is packed with the object key as a pipe-delimited string.
obj_key, revision = parse.unquote_plus(task["s3Key"], encoding="utf-8").split("|")
bucket_name = task["s3BucketArn"].split(":")[-1]
logger.info("Got task: apply revision %s to %s.", revision, obj_key)
try:
stanza_obj = s3.Bucket(bucket_name).Object(obj_key)
stanza = stanza_obj.get()["Body"].read().decode("utf-8")
if revision == "lower":
stanza = stanza.lower()
elif revision == "upper":
stanza = stanza.upper()
elif revision == "reverse":
stanza = stanza[::-1]
elif revision == "delete":
pass
else:
raise TypeError(f"Can't handle revision type '{revision}'.")
if revision == "delete":
stanza_obj.delete()
result_string = f"Deleted stanza {stanza_obj.key}."
else:
stanza_obj.put(Body=bytes(stanza, "utf-8"))
result_string = (
f"Applied revision type '{revision}' to " f"stanza {stanza_obj.key}."
)
logger.info(result_string)
result_code = "Succeeded"
except ClientError as error:
if error.response["Error"]["Code"] == "NoSuchKey":
result_code = "Succeeded"
result_string = (
f"Stanza {obj_key} not found, assuming it was deleted "
f"in an earlier revision."
)
logger.info(result_string)
else:
result_code = "PermanentFailure"
result_string = (
f"Got exception when applying revision type '{revision}' "
f"to {obj_key}: {error}."
)
logger.exception(result_string)
finally:
results.append(
{
"taskId": task_id,
"resultCode": result_code,
"resultString": result_string,
}
)
return {
"invocationSchemaVersion": invocation_schema_version,
"treatMissingKeysAs": "PermanentFailure",
"invocationId": invocation_id,
"results": results,
}
```
## S3 バッチ操作のチュートリアル
次のチュートリアルでは、Lambda を使用したいくつかのバッチ操作タスクにおけるエンドツーエンドの一連の手順について説明します。このチュートリアルでは、S3 ソースバケットに保存された動画のバッチトランスコーディング用に Lambda 関数を呼び出すようにバッチオペレーションを設定する方法を学習します。Lambda 関数は AWS Elemental MediaConvert を呼び出して、動画をトランスコードします。
+ [チュートリアル: S3 バッチオペレーションを使用した動画のバッチトランスコーディング](tutorial-s3-batchops-lambda-mediaconvert-video.md)
# すべてのオブジェクトタグを置換する
Amazon S3 バッチオペレーションを使用すると、Amazon S3 のオブジェクトに対して大規模なバッチオペレーションを実行できます。**[すべてのオブジェクトタグを置換する]** オペレーションは、マニフェストにリストされているすべてのオブジェクトのオブジェクトタグを置き換えます。 オブジェクトタグは、オブジェクトのメタデータを保存するために使用できる文字列のキー値ペアです。
**[すべてのオブジェクトタグを置換する]** ジョブを作成するには、適用するタグのセットを指定します。S3 バッチ操作では、すべてのオブジェクトに同じタグセットが適用されます。指定したタグのセットは、マニフェストのオブジェクトに既に関連付けられているすべてのタグのセットを置き換えます。S3 バッチオペレーションでは、既存のタグを保持したままのオブジェクトへのタグの追加はサポートされていません。
マニフェスト内のオブジェクトがバージョニング対応のバケット内にある場合は、タグセットを適用してすべてのオブジェクトのバージョンを指定することができます。そのためには、マニフェストですべてのオブジェクトにバージョン ID を指定します。オブジェクトのバージョン ID を含めない場合、S3 バッチオペレーションはすべてのオブジェクトの最新バージョンにタグセットを適用します。バッチ操作マニフェストの詳細については、「[マニフェストの指定](batch-ops-create-job.md#specify-batchjob-manifest)」をご参照ください。
オブジェクトのタグ付けの詳細については、このガイドの「[タグを使用したオブジェクトの分類](object-tagging.md)」および「Amazon Simple Storage Service API リファレンス」の「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html)」、「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObjectTagging.html)」、「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjectTagging.html)」を参照してください。**
コンソールを使用して **[すべてのオブジェクトタグを置換する]** ジョブを作成するには、「[S3 バッチオペレーションジョブの作成](batch-ops-create-job.md)」を参照してください。
## 制約と制限
バッチオペレーションを使用してオブジェクトタグを置き換える場合、以下の制約と制限が適用されます。
+ バッチオペレーションジョブを実行するために指定する AWS Identity and Access Management IAM ロールには、基になる `PutObjectTagging` オペレーションを実行するための許可が必要です。必要なアクセス許可の詳細については、「Amazon Simple Storage Service API リファレンス」の「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html)」を参照してください。**
+ S3 バッチオペレーションは、Amazon S3 の [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html) オペレーションを使用して、タグをマニフェストの各オブジェクトに適用します。基になるオペレーションに適用されるすべての制約と制限は、S3 バッチ操作ジョブにも適用されます。
+ 1 つのすべてのオブジェクトタグの置換ジョブで、最大 200 億個のオブジェクトを持つマニフェストをサポートできます。
# アクセスコントロールリスト (ACL) を置き換える
Amazon S3 バッチオペレーションを使用すると、Amazon S3 のオブジェクトに対して大規模なバッチオペレーションを実行できます。**[アクセスコントロールリスト (ACL) を置き換える]** オペレーションは、マニフェストにリストされているすべてのオブジェクトのアクセスコントロールリスト (ACL) を置き換えます。ACL を使用すると、オブジェクトにアクセスできる人物およびその人物が実行できるアクションを定義できます。
**注記**
Amazon S3 の最新のユースケースの大部分では ACL を使用する必要がなくなっています。オブジェクトごとに個別にアクセスを制御する必要がある状況を除き、ACL は無効にしておくことをお勧めします。ACL を無効にすると、誰がオブジェクトをバケットにアップロードしたかに関係なく、ポリシーを使用してバケット内のすべてのオブジェクトへのアクセスを制御できます。詳細については、「[オブジェクトの所有権の制御とバケットの ACL の無効化。](about-object-ownership.md)」を参照してください。
S3 バッチオペレーションでは、ユーザー定義のカスタム ACL と、Amazon S3 で提供されている一連のアクセス許可が事前定義された既定の ACL がサポートされています。
マニフェスト内のオブジェクトがバージョニング対応のバケット内にある場合は、ACL を適用してすべてのオブジェクトのバージョンを指定することができます。そのためには、マニフェストですべてのオブジェクトにバージョン ID を指定します。オブジェクトのバージョン ID を含めない場合、S3 バッチオペレーションはオブジェクトの最新バージョンに ACL を適用します。
Amazon S3 の ACL の詳細については、「[アクセスコントロールリスト (ACL) の概要](acl-overview.md)」を参照してください。
**S3 ブロックパブリックアクセス**
バケット内のすべてのオブジェクトに対するパブリックアクセスを制限する場合は、S3 バッチオペレーションではなく、Amazon S3 パブリックアクセスブロックを使用して ACL を適用することをお勧めします。パブリックアクセスブロックは、素早く効果を発揮する単一の簡単なオペレーションを使用して、バケットごとあるいは全アカウントベースでパブリックアクセスを制限することができます。Amazon S3 パブリックアクセスブロックは、バケットあるいはアカウント内のすべてのオブジェクトに対するパブリックアクセスを制限することが目的の場合には、最適な選択肢となります。S3 バッチオペレーションは、マニフェストのすべてのオブジェクトにカスタム ACL を適用する必要がある場合にのみ使用します。S3 ブロックパブリックアクセスについての詳細は、[Amazon S3 ストレージへのパブリックアクセスのブロック](access-control-block-public-access.md) を参照してください。
**S3 オブジェクトの所有権**
マニフェスト内のオブジェクトがバケット内にあり、オブジェクト所有者に **[バケット所有者の強制]** 設定を使用している場合、**[アクセスコントロールリスト (ACL) を置き換える]** オペレーションでは、バケット所有者に完全な制御を許可するオブジェクト ACL のみを指定できます。この場合、**[アクセスコントロールリスト (ACL) を置き換える]** オペレーションは、他の AWS アカウントまたは グループにオブジェクト ACL アクセス許可を付与できません。詳細については、「[オブジェクトの所有権の制御とバケットの ACL の無効化。](about-object-ownership.md)」を参照してください。
## 制約と制限
バッチオペレーションを使用して ACL を置き換える場合、以下の制約と制限が適用されます。
+ **[アクセスコントロールリスト (ACL) を置き換える]** ジョブを実行するために指定する AWS Identity and Access Management (IAM) ロールには、基になる Amazon S3 `PutObjectAcl` オペレーションを実行するための許可が必要です。必要なアクセス許可の詳細については、Amazon Simple Storage Service API リファレンスの「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectAcl.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectAcl.html)」を参照してください。**
+ S3 バッチ操作は、Amazon S3 の `PutObjectAcl` オペレーションを使用して、指定した ACL をマニフェストのすべてのオブジェクトに適用します。したがって、基になる `PutObjectAcl` オペレーションに適用されるすべての制約と制限は、S3 バッチオペレーションの **[アクセスコントロールリスト (ACL) を置き換える]** ジョブにも適用されます。
+ 1 つのアクセスコントロールリスト置き換えるジョブで、最大 200 億個のオブジェクトを持つマニフェストをサポートできます。
# バッチオペレーションを使ってオブジェクトを復元する
Amazon S3 バッチオペレーションを使用すると、Amazon S3 のオブジェクトに対して大規模なバッチオペレーションを実行できます。**Restore** オペレーションは、マニフェストにリストされた、アーカイブされた Amazon S3 オブジェクトの復元リクエストを開始します。次のアーカイブされたオブジェクトは、リアルタイムでアクセスする前に、復元される必要があります。
+ S3 Glacier Flexible Retrieval または S3 Glacier Deep Archive ストレージクラスにアーカイブされたオブジェクト
+ Archive アクセス階層または Deep Archive アクセス階層の S3 Intelligent-Tiering ストレージクラスを介してアーカイブされたオブジェクト
S3 バッチオペレーションジョブで **[復元]** ([https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_S3InitiateRestoreObjectOperation.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_S3InitiateRestoreObjectOperation.html)) オペレーションを使用すると、マニフェストで指定されたすべてのオブジェクトの `RestoreObject` リクエストが生成されます。
**重要**
**[復元]** ジョブでは、オブジェクトの復元リクエストのみを開始します。**S3 バッチ操作では、各オブジェクトに対するリクエストが開始されると、そのオブジェクトのジョブは完了としてレポートされます。Amazon S3 では、ジョブを更新したり、オブジェクトが復元されたときに通知したりすることはありません。ただし、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 アクセス階層オブジェクトをターゲットとする **[復元]** オペレーションの作成時には `ExpirationInDays` を設定しないでください。S3 Intelligent-Tiering Archive Access 階層のオブジェクトは復元の有効期限の対象にならないため、`ExpirationInDays` を指定すると `RestoreObject` リクエストが失敗します。
**GlacierJobTier**
Amazon S3 では、`EXPEDITED`、`STANDARD`、および `BULK` の 3 つの異なる取得階層のいずれかを使用してオブジェクトを復元できます。ただし、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 アクセス階層または Deep Archive アクセス階層の S3 Intelligent-Tiering ストレージクラスからのファイルの復元とは異なります。
+ S3 Glacier Flexible Retrieval または S3 Glacier Deep Archive から復元すると、オブジェクトの一時*コピー*が作成されます。Amazon S3 は、`ExpirationInDays` 引数で指定した値が経過した後、このコピーを削除します。この一時コピーが削除された後にそのオブジェクトにアクセスするには、追加の復元リクエストを送信する必要があります。
+ アーカイブされた S3 Intelligent-Tiering オブジェクトを復元するときは、`ExpirationInDays` 引数を指定*しないでください*。S3 Intelligent-Tiering Archive アクセス階層または Deep Archive アクセス階層からオブジェクトを復元すると、オブジェクトは S3 Intelligent-Tiering Frequent アクセス階層に戻ります。オブジェクトは、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 バッチオペレーションは次のように処理します。
次のいずれかの条件が true の場合には、オブジェクトに対するこの復元オペレーションは成功します。
+ 進行中の復元リクエストと比較して、このジョブの `ExpirationInDays` 値が同じであり、また、`GlacierJobTier` 値が高速であること。
+ 以前の復元リクエストが完了済みであり、オブジェクトが現在利用可能であること。この場合、バッチ操作は、復元されたオブジェクトの有効期限を、進行中の復元リクエストで指定された `ExpirationInDays` 値と一致するように更新します。
次のいずれかの条件が true の場合には、オブジェクトに対するこの復元オペレーションは失敗します。
+ 進行中の復元リクエストが未完了であり、かつ、このジョブの復元期間 (`ExpirationInDays` 値によって指定) が進行中の復元リクエストで指定される復元期間とは異なること。
+ このジョブの復元階層 (`GlacierJobTier` 値によって指定) が進行中の復元リクエストで指定される復元階層と同じであるか、またはより低速であること。
## 制限事項
`S3InitiateRestoreObjectOperation` ジョブには次の制限があります。
+ アーカイブされたオブジェクトと同じリージョンにジョブを作成する必要があります。
+ S3 バッチオペレーションでは、`EXPEDITED` 取得階層はサポートされていません。
+ 1 つのバッチオペレーション復元ジョブで、最大 40 億個のオブジェクトを持つマニフェストをサポートできます。
オブジェクトの復元の詳細については、「[アーカイブされたオブジェクトの復元](restoring-objects.md)」をご参照ください。
# オブジェクトの暗号化を更新する
Amazon S3 バッチオペレーションを使用すると、Amazon S3 のオブジェクトに対して大規模なバッチオペレーションを実行できます。バッチオペレーション [https://docs.aws.amazon.com//AmazonS3/latest/API/API_control_UpdateObjectEncryptionOperation.html](https://docs.aws.amazon.com//AmazonS3/latest/API/API_control_UpdateObjectEncryptionOperation.html) オペレーションは、1 回のリクエストで複数の Amazon S3 オブジェクトのサーバー側の暗号化タイプを更新します。1 つの `UpdateObjectEncryption` オペレーションジョブで、最大 200 億個のオブジェクトを持つマニフェストをサポートできます。
`UpdateObjectEncryption` オペレーションは、汎用バケットでサポートされているすべての Amazon S3 ストレージクラスでサポートされています。`UpdateObjectEncryption` オペレーションを使用して、暗号化されたオブジェクトを [Amazon S3 マネージドキー (SSE-S3) によるサーバー側の暗号化](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingServerSideEncryption.html)から [AWS Key Management Service (AWS KMS) キー (SSE-KMS)](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingKMSEncryption.html) に変更したり、S3 バケットキーを適用したりできます。`UpdateObjectEncryption` オペレーションを使用して、データの暗号化に使用されるカスタマーマネージド KMS キーを変更し、カスタムキーローテーション標準に準拠することもできます。
バッチオペレーションジョブを作成すると、指定したソースの場所とフィルター条件に基づいてオブジェクトリストを生成できます。`MatchAnyObjectEncryption` フィルターを使用して、更新するバケット内のオブジェクトのリストを生成し、マニフェストに含めることができます。生成されたオブジェクトリストには、指定されたサーバー側の暗号化タイプを持つソースバケットオブジェクトのみが含まれます。SSE-KMS を選択した場合は、オプションで特定の KMS キー ARN とバケットキーの有効化ステータスを指定して、結果をさらにフィルタリングできます。詳細については、「*Amazon S3 API Reference*」の「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_JobManifestGeneratorFilter.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_JobManifestGeneratorFilter.html)」と「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_SSEKMSFilter.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_SSEKMSFilter.html)」を参照してください。
## 制限と考慮事項
バッチオペレーション `UpdateObjectEncryption` オペレーションを使用している場合は、以下の制限と考慮事項が適用されます。
+ `UpdateObjectEncryption` オペレーションでは、暗号化されていないオブジェクトや、AWS KMS keys による二層式サーバー側の暗号化 (DSSE-KMS) またはお客様が用意した暗号化キー (SSE-C) のいずれかで暗号化されたオブジェクトはサポートされません。また、SSE-S3 暗号化タイプ `UpdateObjectEncryption` リクエストを指定することはできません。
+ `UpdateObjectEncryption` オペレーションを使用して、S3 バージョニングが有効になっているバケット内のオブジェクトを更新できます。特定のバージョンの暗号化タイプを更新するには、`UpdateObjectEncryption` リクエストでバージョン ID を指定する必要があります。バージョン ID を指定しない場合、`UpdateObjectEncryption` リクエストはオブジェクトの現在のバージョンに対して実行されます。S3 バージョニングの詳細については、[S3 バージョニングによる複数のバージョンのオブジェクトの保持](Versioning.md) を参照してください。
+ `UpdateObjectEncryption` オペレーションは、S3 Object Lock の保持モードまたはリーガルホールドが適用されているオブジェクトで失敗します。オブジェクトにガバナンスモードの保持期間またはリーガルホールドがある場合は、`UpdateObjectEncryption` リクエストを発行する前に、まずオブジェクトの Object Lock ステータスを削除する必要があります。Object Lock コンプライアンスモードの保持期間が適用されているオブジェクトでは、`UpdateObjectEncryption` オペレーションを使用できません。S3 オブジェクトロックの詳細については、「[S3 Object Lock を使用したオブジェクトのロック](object-lock.md)」を参照してください。
+ ライブレプリケーションが有効になっているソースバケットに対する `UpdateObjectEncryption` リクエストでは、レプリケート先バケットでレプリカイベントが開始されません。ソースバケットとレプリケート先バケットの両方のオブジェクトの暗号化タイプを変更する場合は、ソースバケットとレプリケート先バケットのオブジェクトに対して個別の `UpdateObjectEncryption` リクエストを開始する必要があります。
+ デフォルトでは、カスタマー管理の KMS キーを指定するすべての `UpdateObjectEncryption` リクエストは、バケット所有者の AWS アカウントが所有する KMS キーに制限されます。AWS Organizations を使用している場合は、AWS サポート に連絡して、組織内の他のメンバーアカウントが所有する AWS KMS keys を使用する機能をリクエストできます。
+ S3 バッチレプリケーションを使用してデータセットをリージョン間でレプリケートし、オブジェクトのサーバー側の暗号化タイプを SSE-S3 から SSE-KMS に更新したことがある場合は、追加のアクセス許可が必要になる場合があります。ソースリージョンバケットでは、`kms:decrypt` アクセス許可が必要です。次に、レプリケート先リージョンのバケットの `kms:decrypt` および `kms:encrypt` アクセス許可が必要です。
+ `UpdateObjectEncryption` リクエストに完全な KMS キー ARN を指定します。エイリアス名またはエイリアス ARN を使用することはできません。完全な KMS キー ARN は、AWS KMS コンソールまたは AWS KMS `DescribeKey` API を使用して判断できます。
`UpdateObjectEncryption` の詳細については、「[既存データのサーバー側の暗号化の更新](update-sse-encryption.md)」を参照してください。
## 必要なアクセス許可
`UpdateObjectEncryption` オペレーションを実行するには、IAM プリンシパル (ユーザー、ロール、またはグループ) に次の AWS Identity and Access Management (IAM) ポリシーを追加します。このポリシーを使用するには、*`amzn-s3-demo-bucket`* を暗号化を更新するオブジェクトを含むバケットの名前に置き換えます。`amzn-s3-demo-manifest-bucket` をマニフェストを含むバケットの名前に置き換え、`amzn-s3-demo-completion-report-bucket` を完了レポートを保存するバケットの名前に置き換えます。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "S3BatchOperationsUpdateEncryption",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:PutObject",
"s3:UpdateObjectEncryption"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket-target"
"arn:aws:s3:::amzn-s3-demo-bucket-target-target/*"
]
},
{
"Sid": "S3BatchOperationsPolicyForManifestFile",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket-manifest/*"
]
},
{
"Sid": "S3BatchOperationsPolicyForCompletionReport",
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket-completion-report/*"
]
},
{
"Sid": "S3BatchOperationsPolicyManifestGeneration",
"Effect": "Allow",
"Action": [
"s3:PutInventoryConfiguration"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket-target"
]
},
{
"Sid": "AllowKMSOperationsForS3BatchOperations",
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey",
"kms:Encrypt",
"kms:ReEncrypt*"
],
"Resource": [ "arn:aws:kms:us-east-1:111122223333:key/01234567-89ab-cdef-0123-456789abcdef"
]
}
]
}
```
S3 バッチオペレーションサービスプリンシパルがユーザーに代わってバッチオペレーションジョブを実行するために引き受ける IAM ロールにアタッチする必要がある信頼ポリシーとアクセス許可ポリシーについては、「[バッチオペレーションに対するアクセス許可の付与](batch-ops-iam-role-policies.md)」および「[オブジェクトの暗号化を更新する](batch-ops-iam-role-policies.md#batch-ops-update-encryption-policies)」を参照してください。
# バッチオペレーションジョブを作成してオブジェクトの暗号化を更新する
1 回のリクエストで複数の Amazon S3 オブジェクトのサーバー側の暗号化タイプを更新するには、S3 バッチオペレーションを使用できます。S3 バッチオペレーションは、Amazon S3 コンソール、AWS Command Line Interface (AWS CLI)、AWS SDK、または Amazon S3 REST API を通じて使用できます。
## の使用AWS CLI
次のコマンドを実行するには、AWS CLI をインストールして設定する必要があります。AWS CLI をまだインストールしていない場合は、「*AWS Command Line Interface ユーザーガイド*」の「[AWS CLI の最新バージョンのインストールまたは更新](https://docs.aws.amazon.com//cli/latest/userguide/getting-started-install.html)」を参照してください。
別の方法として、AWS CloudShell を使用してコンソールから AWS CLI コマンドを実行することもできます。AWS CloudShell は、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 バッチオペレーションジョブを作成する方法を示しています。このコマンドは、1 つの AWS Key Management Service (AWS KMS) キーで暗号化されたオブジェクトを別の KMS キーを使用するように変更するジョブを作成します。このジョブは、影響を受けるオブジェクトのマニフェストも生成して保存し、結果のレポートも作成します。このコマンドを使用するには、`user input placeholders` をユーザー自身の情報に置き換えます。
```
aws s3control create-job --account-id account-id \
--no-confirmation-required \
--operation '{"S3UpdateObjectEncryption": { "ObjectEncryption": { "SSEKMS": { "KMSKeyArn": "KMS-key-ARN-to-apply", "BucketKeyEnabled": false } } } }' \
--report '{ "Enabled": true, "Bucket": "report-bucket-ARN", "Format": "Report_CSV_20180820", "Prefix": "report", "ReportScope": "AllTasks" }' \
--manifest-generator '{ "S3JobManifestGenerator": { "ExpectedBucketOwner": "account-id", "SourceBucket": "source-bucket-ARN", "EnableManifestOutput": true, "ManifestOutputLocation": { "Bucket": "manifest-bucket-ARN", "ManifestFormat": "S3InventoryReport_CSV_20211130", "ManifestPrefix": "manifest-prefix" }, "Filter": { "MatchAnyObjectEncryption": [{ "SSEKMS": { "KmsKeyArn": "kms-key-ARN-to-match" } }] } } }' \
--priority 1 \
--role-arn batch-operations-role-ARN
```
最高のパフォーマンスを得るには、`KmsKeyArn` フィルターを、`MatchAnyPrefix`、`CreatedAfter`、`MatchAnyStorageClass` などの他のオブジェクトメタデータフィルターと組み合わせて使用することをお勧めします。
**Example 2 – SSE-S3 で暗号化されたオブジェクトを SSE-KMS に更新するバッチオペレーションジョブを作成する**
次の例は、汎用バケット内の複数のオブジェクトの暗号化設定を更新する S3 バッチオペレーションジョブを作成する方法を示しています。このコマンドは、Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) を使用して暗号化されたオブジェクトを変更し、代わりに AWS Key Management Service (AWS KMS) キーによるサーバー側の暗号化 (SSE-KMS) を使用するジョブを作成します。このジョブは、影響を受けるオブジェクトのマニフェストも生成して保存し、結果のレポートも作成します。このコマンドを使用するには、`user input placeholders` をユーザー自身の情報に置き換えます。
```
aws s3control create-job --account-id account-id \
--no-confirmation-required \
--operation '{"S3UpdateObjectEncryption": { "ObjectEncryption": { "SSEKMS": { "KMSKeyArn": "KMS-key-ARN-to-apply", "BucketKeyEnabled": false } } } }' \
--report '{ "Enabled": true, "Bucket": "report-bucket-ARN", "Format": "Report_CSV_20180820", "Prefix": "report", "ReportScope": "AllTasks" }' \
--manifest-generator '{ "S3JobManifestGenerator": { "ExpectedBucketOwner": "account-id", "SourceBucket": "source-bucket-ARN", "EnableManifestOutput": true, "ManifestOutputLocation": { "Bucket": "manifest-bucket-ARN", "ManifestFormat": "S3InventoryReport_CSV_20211130", "ManifestPrefix": "manifest-prefix" }, "Filter": { "MatchAnyObjectEncryption": [{ "SSES3": {} }] } } }' \
--priority 1 \
--role-arn batch-operations-role-ARN
```
最高のパフォーマンスを得るには、`KmsKeyArn` フィルターを、`MatchAnyPrefix`、`CreatedAfter`、`MatchAnyStorageClass` などの他のオブジェクトメタデータフィルターと組み合わせて使用することをお勧めします。
# S3 オブジェクトロックの保持
Amazon S3 バッチオペレーションを使用すると、Amazon S3 のオブジェクトに対して大規模なバッチオペレーションを実行できます。**[Object Lock の保持]** オペレーションでは、[ガバナンス] モードまたは [コンプライアンス] モードのいずれかを使用して、オブジェクトの保持日を適用できます。****これらのリテンションモードは、さまざまなレベルの保護を適用します。いずれかのリテンションモードを任意のオブジェクトバージョンに適用できます。リーガルホールドなどの保持期間に基づいて、オブジェクトの上書きや削除を防ぎます。Amazon S3 は、オブジェクトのメタデータで指定されている [保持期日] を保存し、その保持期間が経過するまで指定されたバージョンのオブジェクトを保護します。**
S3 バッチオペレーションと Object Lock を使用すると、多くの Amazon S3 のオブジェクトの保持期間を一括で管理できます。マニフェストでターゲットオブジェクトのリストを指定し、そのマニフェストをジョブの完了のためにバッチオペレーションに送信します。詳細については、S3 オブジェクトロックの「[保持期間](object-lock.md#object-lock-retention-periods)」を参照してください。
S3 バッチ操作の保持期間の適用ジョブは、完了するか、キャンセルするか、エラー状態になるまで実行されます。S3 バッチオペレーションと S3 Object Lock による保持は、1 回のリクエストで多くのオブジェクトの保持期限を追加、変更、削除する場合に使用することをお勧めします。
バッチ操作は、マニフェストのキーを処理する前に、バケットでオブジェクトロックが有効になっているかどうかを確認します。オペレーションと検証を実行するには、バッチオペレーションがユーザーの代わりに Object Lock を呼び出せるように、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)」を参照してください。AWS SDK for Java の例については、「[AWS SDK for Java の使用](batch-ops-object-lock-retention.md#batch-ops-examples-java-object-lock-retention)」を参照してください。
## 制約と制限
バッチオペレーションを使用して Object Lock の保持期間を適用する場合、以下の制約と制限が適用されます。
+ S3 バッチオペレーションでは、バケットレベルでの変更は行われません。
+ ジョブを実行するバケットでバージョニングと S3 オブジェクトロックを設定する必要があります。
+ マニフェストに登録されているすべてのオブジェクトは同じバケットにあることが必要です。
+ マニフェストでオブジェクトのバージョンが明示的に指定されていない限り、オペレーションにはオブジェクトの最新バージョンが使用されます。
+ **[Object Lock の保持]** ジョブを使用するには、IAM ロールに `s3:PutObjectRetention` アクセス許可が必要です。
+ ジョブを実行している S3 バケットで Object Lock が有効になっていることを確認するには、`s3:GetBucketObjectLockConfiguration` IAM アクセス許可が必要です。
+ オブジェクトの保持期間を延長できるのは、`COMPLIANCE` モードの保持期限が適用されている場合のみであり、短縮することはできません。
+ 1 つの S3 Object Lock 保持ジョブで、最大 200 億個のオブジェクトを持つマニフェストをサポートできます。
# S3 オブジェクトロックのリーガルホールド
Amazon S3 バッチオペレーションを使用すると、Amazon S3 のオブジェクトに対して大規模なバッチオペレーションを実行できます。**[Object Lock のリーガルホールド]** オペレーションを使用すると、オブジェクトバージョンにリーガルホールドを適用できます。保持期間の設定と同様に、リーガルホールドは、オブジェクトバージョンが上書きまたは削除されるのを防ぎます。ただし、リーガルホールドには関連する保持期間はなく、削除するまで有効です。
S3 バッチ操作とオブジェクトロックを使用すると、一度に多くの Amazon S3 のオブジェクトをリーガルホールドにすることができます。これを行うには、マニフェストに対象のオブジェクトのリストを指定し、そのリストをバッチオペレーションに渡します。S3 バッチオペレーションの **[Object Lock のリーガルホールド]** ジョブは、完了するか、キャンセルするか、エラー状態になるまで実行されます。
S3 バッチオペレーションは、マニフェストのオブジェクトを処理する前に、S3 バケットで Object Lock が有効になっているかどうかを確認します。オブジェクトオペレーションとバケットレベルの検証を実行するには、S3 バッチオペレーションに AWS Identity and Access Management (IAM) ロールの `s3:PutObjectLegalHold` と `s3:GetBucketObjectLockConfiguration` が必要です。これらのアクセス許可により、S3 バッチオペレーションはユーザーに代わって S3 Object Lock を呼び出すことができます。
リーガルホールドを削除する S3 バッチオペレーションのジョブを作成するには、リーガルホールドのステータスに `Off` を指定するだけで構いません。詳細については、「[オブジェクトロックの考慮事項](object-lock-managing.md)」を参照してください。
Amazon S3 REST API でこのオペレーションを使用する方法については、「Amazon Simple Storage Service API リファレンス」の「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateJob.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateJob.html)」のオペレーションの「`S3PutObjectLegalHold`」を参照してください。**
このオペレーションの使用例については、「[AWS SDK for Java の使用](batch-ops-legal-hold-off.md#batch-ops-examples-java-object-lock-legalhold)」を参照してください。
## 制約と制限
バッチオペレーションを使用して Object Lock のリーガルホールドを適用または削除する場合、以下の制約と制限が適用されます。
+ S3 バッチオペレーションでは、バケットレベルでの変更は行われません。
+ マニフェストに登録されているすべてのオブジェクトは同じバケットにあることが必要です。
+ ジョブを実行するバケットでバージョニングと S3 オブジェクトロックを設定する必要があります。
+ マニフェストでバージョンが明示的に指定されていない限り、**[Object Lock のリーガルホールド]** オペレーションにはオブジェクトの最新バージョンが使用されます。
+ オブジェクトのリーガルホールドを追加または解除するには、IAM ロールに `s3:PutObjectLegalHold` アクセス許可が必要です。
+ ジョブが実行されている S3 バケットで S3 Object Lock が有効になっていることを確認するには、`s3:GetBucketObjectLockConfiguration` IAM アクセス許可が必要です。
+ 1 つの S3 Object Lock リーガルホールドジョブで、最大 200 億個のオブジェクトを持つマニフェストをサポートできます。
+ [オブジェクトのコピー](batch-ops-copy-object.md)
+ [チェックサムの計算](batch-ops-compute-checksums.md)
+ [すべてのオブジェクトタグを削除する](batch-ops-delete-object-tagging.md)
+ [AWS Lambda 関数の呼び出し](batch-ops-invoke-lambda.md)
+ [すべてのオブジェクトタグを置換する](batch-ops-put-object-tagging.md)
+ [アクセスコントロールリスト (ACL) を置き換える](batch-ops-put-object-acl.md)
+ [バッチオペレーションを使ってオブジェクトを復元する](batch-ops-initiate-restore-object.md)
+ [オブジェクトの暗号化を更新する](batch-ops-update-encryption.md)
+ [バッチレプリケーションを使用した既存のオブジェクトのレプリケーション](s3-batch-replication-batch.md)
+ [S3 オブジェクトロックの保持](batch-ops-retention-date.md)
+ [S3 オブジェクトロックのリーガルホールド](batch-ops-legal-hold.md)
# S3 バッチ操作ジョブの管理
Amazon S3 は、作成した S3 バッチ操作ジョブを管理するための一連の堅牢なツールを用意しています。このセクションでは、Amazon S3 コンソール、AWS Command Line Interface (AWS CLI)、AWS SDK、または Amazon S3 REST API を使用してジョブを管理および追跡するために使用できるオペレーションについて説明します。
**Topics**
+ [S3 バッチオペレーションジョブの管理に Simple Storage Service (Amazon S3) コンソールを使用する](#batch-ops-manage-console)
+ [ジョブのリスト取得](batch-ops-list-jobs.md)
+ [ジョブの詳細の表示](batch-ops-job-details.md)
+ [ジョブの優先度の割り当て](batch-ops-job-priority.md)
## S3 バッチオペレーションジョブの管理に Simple Storage Service (Amazon S3) コンソールを使用する
コンソールを使用して、S3 バッチオペレーションジョブを管理できます。例えば、以下のことが可能です:
+ アクティブなジョブとキュージョブを表示する
+ ジョブのステータスを確認する
+ ジョブの優先順位を変更する
+ ジョブを確認して実行する
+ ジョブのクローンを作成する
+ ジョブのキャンセル
**S3 コンソールを使用して S3 バッチオペレーションジョブを管理するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左のナビゲーションペインで、[**バッチ操作**] を選択します。
1. 管理するジョブを選択します。
# ジョブのリスト取得
S3 バッチ操作ジョブのリストを取得できます。このリストには、まだ終了していないジョブと 90 日以内に終了したジョブに関する情報が表示されます。各ジョブのリストには、ジョブ ID、説明、優先度、現在のステータス、および成功したタスクと失敗したタスクの数などの詳細が含まれます。
ジョブのリストをステータスでフィルタリングできます。コンソールを使用してリストを取得するときに、説明または ID でジョブを検索して AWS リージョン別にフィルタリングすることもできます。
## `Active` および `Complete` ジョブのリストを取得する
以下の AWS CLI の例では、`Active` および `Complete` ジョブのリストを取得します。この例を実行するには、*`user input placeholders`* をユーザー自身の情報に置き換えます。
```
aws s3control list-jobs \
--region us-west-2 \
--account-id account-id \
--job-statuses '["Active","Complete"]' \
--max-results 20
```
詳細と例については、「AWS CLI コマンドリファレンス」で「[https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3control/list-jobs.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3control/list-jobs.html)」を参照してください。**
# ジョブの詳細の表示
ジョブを一覧表示することで取得できるよりも多くの Amazon S3 バッチオペレーションジョブの情報が必要な場合、単一のジョブのすべての詳細を表示できます。まだ終了していないジョブや、過去 90 日以内に終了したジョブの詳細を確認できます。ジョブリストで返される情報に加えて、単一のジョブの詳細には次のような情報が含まれています。
+ オペレーションパラメータ。
+ マニフェストに関する詳細。
+ 完了レポートに関する情報 (ジョブの作成時にレポートを設定した場合)。
+ ジョブの実行に割り当てた AWS Identity and Access Management (IAM) ロールの Amazon リソースネーム (ARN)。
個々のジョブの詳細を表示することで、そのジョブの設定全体にアクセスできます。ジョブの詳細を表示するには、Amazon S3 コンソールまたは AWS Command Line Interface (AWS CLI) を使用します。
## Amazon S3 コンソールで S3 バッチオペレーションジョブの説明を取得する
**コンソールを使用してバッチオペレーションジョブの説明を表示するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左のナビゲーションペインで、[**バッチ操作**] を選択します。
1. 詳細を表示する特定のジョブの ID を選択します。
## AWS CLI で S3 バッチオペレーションジョブの説明を取得する
次の例では、AWS CLI を使用して S3 バッチオペレーションジョブの説明を取得します。次のコマンド例を使用するには、*`user input placeholders`* をユーザー自身の情報に置き換えます。
```
aws s3control describe-job \
--region us-west-2 \
--account-id account-id \
--job-id 00e123a4-c0d8-41f4-a0eb-b46f9ba5b07c
```
詳細と例については、「AWS CLI コマンドリファレンス」で「[https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3control/describe-job.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3control/describe-job.html)」を参照してください。**
# ジョブの優先度の割り当て
各 Amazon S3 バッチオペレーションジョブには、数値の優先度 (任意の正の整数) を割り当てることができます。S3 バッチオペレーションは、割り当てられた優先度に従ってジョブの優先順位を決定します。優先度が高いジョブ (または、優先パラメータの数値が高いジョブ) ほど先に処理されます。優先度は降順に決定されます。例えば、優先度の値が 10 のジョブキューは、優先度の値が 1 のジョブキューより先にスケジュールされます。
ジョブの実行中にジョブの優先順位を変更できます。また、ジョブの実行中に優先順位が高い新しいジョブを送信すると、優先順位の低いジョブが一時停止して優先順位の高いジョブが実行される可能性があります。
ジョブの優先順位を変更しても、ジョブの処理速度には影響しません。
**注記**
S3 バッチオペレーションはベストエフォートベースでジョブの優先度を重視します。優先順位の高いジョブは優先順位の低いジョブより優先されるのが一般的ですが、Amazon S3 はジョブの厳密な順序付けを保証しません。
## S3 コンソールの使用
**Amazon S3 コンソールでジョブの優先度を更新する方法**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左のナビゲーションペインで、[**バッチ操作**] を選択します。
1. 管理する特定のジョブを選択します。
1. **[Actions]** (アクション) を選択します。ドロップダウンリストから **[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
```
## の使用AWS SDK for Java
AWS SDK for Java を使用して S3 バッチオペレーションジョブの優先度を更新するには、S3Control クライアントを使用してジョブの実行優先度を変更します。これにより、キュー内の他のジョブと比較してジョブが処理される順序が決まります。
ジョブの優先度の詳細については、「[ジョブの優先度の割り当て](#batch-ops-job-priority)」を参照してください。
AWS SDK for Java を使用してジョブの優先度を更新する方法の例については、「*Amazon S3 API リファレンス*」の「[Update the priority of a batch job](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_UpdateJobPriority_section.html)」を参照してください。
# ジョブステータスと完了レポートの追跡
S3 バッチ操作を使用すると、ジョブステータスの表示と更新、通知とログの追加、ジョブの失敗の追跡、完了レポートの生成を行うことができます。
**Topics**
+ [ジョブステータス](#batch-ops-job-status-table)
+ [ジョブステータスの更新](#updating-job-statuses)
+ [通知とログ記録](#batch-ops-notifications)
+ [ジョブの失敗の追跡](#batch-ops-job-status-failure)
+ [完了レポート](#batch-ops-completion-report)
+ [例: を使用して Amazon EventBridge の S3 バッチ操作ジョブを追跡するAWS CloudTrail](batch-ops-examples-event-bridge-cloud-trail.md)
+ [例: S3 バッチ操作完了レポート](batch-ops-examples-reports.md)
## ジョブステータス
ジョブの作成および実行後、ジョブは一連のステータスを進行します。ステータスとその間のあり得る移行を次の表に示します。
| ステータス | 説明 | Transitions |
| --- | --- | --- |
| `New` | ジョブを作成すると、ジョブは `New` ステータスから始まります。 | Amazon S3 がマニフェストオブジェクトの処理を開始すると、ジョブは自動的に `Preparing` ステータスになります。 |
| `Preparing` | Amazon S3 はマニフェストオブジェクトと他のジョブパラメータを処理してセットアップし、ジョブを実行します。 | Amazon S3 がマニフェストと他のパラメータの処理を終了すると、ジョブは自動的に `Ready` ステータスになります。その後、ジョブではマニフェストに一覧表示されているオブジェクトにおいて指定されたオペレーションの実行を開始する準備が整います。ジョブで実行前に確認が必要な場合は (Amazon S3 コンソールを使用してジョブを作成した場合など)、ジョブは `Preparing` から `Suspended` に移行します。ジョブを実行することが確認されるまで、`Suspended` 状態のままになります。 |
| `Suspended` | ジョブには確認が必要ですが、ジョブを実行することをまだ確認していません。Amazon S3 コンソールを使用して作成したジョブのみ確認が必要になります。コンソールを使用して作成したジョブは、`Suspended` 後にすぐ `Preparing` 状態になります。ジョブを実行したいことを確認すると、このジョブは `Ready` になり、`Suspended` 状態に戻ることはありません。 | ジョブを実行したいことを確認すると、そのステータスは `Ready` に変更します。 |
| `Ready` | Amazon S3 はリクエストしたオブジェクトオペレーションの実行を開始する準備ができました。 | Amazon S3 がジョブを開始すると、ジョブは自動的に `Active` ステータスになります。ジョブが `Ready` 状態のままになる期間は、優先度の高いジョブをすでに実行中であるかどうか、またそのジョブが完了するまでの時間に応じます。 |
| `Active` | Amazon S3 はマニフェストで一覧表示されているオブジェクトでリクエストされたオペレーションを実行しています。ジョブが `Active` の間、Amazon S3 コンソール、あるいは REST API、AWS CLI、または AWS SDK の `DescribeJob` オペレーションを使用してその進捗状況を監視できます。 | ジョブがオブジェクトでオペレーションを実行しなくなると、ジョブは `Active` 状態ではなくなります。この動作は、ジョブが正常に完了したか失敗した場合などに自動的に起こります。あるいは、ジョブのキャンセルなどのユーザーアクションの結果としても生じます。ジョブが移行する状態は、移行の理由によって異なります。 |
| `Pausing` | ジョブは別の状態から `Paused` に移行しています。 | `Paused` ステージが完了すると、ジョブは自動的に `Pausing` になります。 |
| `Paused` | ジョブを現在実行中に優先度の高い別のジョブを送信すると、ジョブは `Paused` になります。 | ジョブの実行が完了、失敗、あるいは停止になることを阻止している優先度の高いジョブの後、`Paused` ジョブは自動的に `Active` に戻ります。 |
| `Completing` | ジョブは別の状態から `Complete` に移行しています。 | `Complete` ステージが完了すると、ジョブは自動的に `Completing` になります。 |
| `Complete` | ジョブは、マニフェストのすべてのオブジェクトでリクエストされたオペレーションの実行を終了しました。このオペレーションは、すべてのオブジェクトで成功または失敗することがあります。完了レポートを生成するようにジョブを設定した場合、このレポートはジョブが `Complete` になるとすぐに利用可能になります。 | `Complete` は終了状態です。ジョブが `Complete` に達すると、他の状態に移行することはありません。 |
| `Cancelling` | このジョブは `Cancelled` に移行しています。 | `Cancelled` ステージが完了すると、ジョブは自動的に `Cancelling` になります。 |
| `Cancelled` | ユーザーはジョブのキャンセルをリクエストし、S3 バッチオペレーションはジョブのキャンセルに成功しました。このジョブは、Amazon S3 に新しいリクエストを送信しません。 | `Cancelled` は終了状態です。ジョブが `Cancelled` に達した後、他の状態には移行しません。 |
| `Failing` | このジョブは `Failed` に移行しています。 | `Failed` ステージが完了すると、ジョブは自動的に `Failing` になります。 |
| `Failed` | このジョブは失敗し、もう実行されていません。ジョブの失敗に関する詳細については、「[ジョブの失敗の追跡](#batch-ops-job-status-failure)」を参照してください。 | `Failed` は終了状態です。ジョブが `Failed` に達した後、他の状態には移行しません。 |
## ジョブステータスの更新
次の AWS CLI および AWS SDK for Java の例は、バッチオペレーションジョブのステータスを更新します。Amazon S3 コンソールを使用してバッチオペレーションジョブを管理する方法の詳細については、「[S3 バッチオペレーションジョブの管理に Simple Storage Service (Amazon S3) コンソールを使用する](batch-ops-managing-jobs.md#batch-ops-manage-console)」を参照してください。
### の使用AWS CLI
次のコマンド例を使用する際は、*`user input placeholders`* をユーザー自身の情報に置き換えます。
+ 例えば、`--no-confirmation-required` のコマンドで `create-job` パラメータを指定しなかった場合、ジョブのステータスを `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
```
### AWS SDK for Java の使用
AWS SDK for Java を使用してジョブステータスを更新する方法の例については、「*Amazon S3 API リファレンス*」の「[Update the status of a batch job](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_UpdateJobStatus_section.html)」を参照してください。
## 通知とログ記録
完了レポートをリクエストすることに加えて、AWS CloudTrail を使用してバッチオペレーションのアクティビティをキャプチャ、確認、および監査することもできます。バッチオペレーションは既存の Amazon S3 API オペレーションを使用してタスクを実行するため、それらのタスクも直接呼び出した場合と同じイベントを出力します。したがって、Amazon S3 で既に使用しているのと同じ通知、ログ記録、および監査ツールとプロセスを使用することで、ジョブの進捗状況とジョブのすべてのタスクを追跡および記録することができます。詳細については、次のセクションの例を参照してください。
**注記**
バッチオペレーションは、ジョブの実行中に CloudTrail で管理イベントとデータイベントの両方を生成します。これらのイベントの量は、各ジョブのマニフェスト内のキーの数に応じてスケールします。詳細については、「[CloudTrail の料金](https://aws.amazon.com/cloudtrail/pricing/)」ページを参照してください。このページには、アカウントで設定した証跡の数に応じて料金がどのように変わるのかを示す例が記載されています。ニーズに合わせてイベントを設定してログに記録する方法については、*AWS CloudTrail ユーザーガイド*の[最初の証跡の作成](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-tutorial.html#tutorial-step2)を参照してください。
Amazon S3 イベントの詳細については、「[Amazon S3 イベント通知](EventNotifications.md)」を参照してください。
## ジョブの失敗の追跡
指定されたマニフェストを読み取れないなど、S3 バッチ操作が正常に実行できない問題が発生した場合、そのジョブは失敗します。ジョブが失敗すると、1 つ以上の障害コードまたは失敗の理由が生成されます。S3 バッチオペレーションは、ジョブの詳細をリクエストしてそれらを表示できるように、障害コードと理由をジョブとともに保存します。ジョブの完了レポートをリクエストした場合は、そこに障害コードと理由も表示されます。
ジョブが大量の失敗したオペレーションを実行するのを防ぐために、Amazon S3 はすべてのバッチ操作ジョブにタスク失敗のしきい値を設定します。ジョブが 1,000 個以上のタスクを実行すると、Amazon S3 はタスクの失敗率を監視します。いずれかの時点で、失敗率 (実行されたタスクの総数に対する失敗したタスクの数の割合) が 50 パーセントを超えると、そのジョブは失敗します。タスク失敗しきい値を超えたためにジョブが失敗した場合、この失敗の原因を識別できます。たとえば、特定のバケットに存在しないいくつかのオブジェクトを誤ってマニフェストに含めてしまうことがあります。誤りを訂正したら、ジョブを再送信できます。
**注記**
S3 バッチオペレーションは非同期で動作するため、タスクはマニフェストにリストされているオブジェクトの順序で実行する必要はありません。つまり、どのオブジェクトのタスクが成功して、どれが失敗したかを判断するためにマニフェストの順序を使用することはできません。代わりに、ジョブの完了レポート (リクエストした場合) を調べるか、AWS CloudTrail イベントログを表示して失敗の原因を特定することができます。
## 完了レポート
ジョブを作成するときに、完了レポートをリクエストできます。S3 バッチオペレーションが少なくとも 1 つのタスクを正常に呼び出す限り、ジョブでタスクの実行が完了した後、失敗したとき、またはキャンセルされたときに、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` イベントとして記録されます。ジョブは実行されると、処理中に状態が変わり、他の `JobStatusChanged` イベントが CloudTrail に記録されます。[CloudTrail コンソール](https://console.aws.amazon.com/cloudtrail)でこれらのイベントを表示できます。CloudTrail の詳細については、[https://docs.aws.amazon.com/awscloudtrail/latest/userguide/how-cloudtrail-works.html](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/how-cloudtrail-works.html)を参照してください。
**注記**
CloudTrail には、S3 バッチ操作ジョブ `status-change` イベントのみが記録されます。
**Example — CloudTrail によって記録された S3 バッチオペレーションジョブ完了イベント**
```
{
"eventVersion": "1.05",
"userIdentity": {
"accountId": "123456789012",
"invokedBy": "s3.amazonaws.com"
},
"eventTime": "2020-02-05T18:25:30Z",
"eventSource": "s3.amazonaws.com",
"eventName": "JobStatusChanged",
"awsRegion": "us-west-2",
"sourceIPAddress": "s3.amazonaws.com",
"userAgent": "s3.amazonaws.com",
"requestParameters": null,
"responseElements": null,
"eventID": "f907577b-bf3d-4c53-b9ed-8a83a118a554",
"readOnly": false,
"eventType": "AwsServiceEvent",
"recipientAccountId": "123412341234",
"serviceEventDetails": {
"jobId": "d6e58ec4-897a-4b6d-975f-10d7f0fb63ce",
"jobArn": "arn:aws:s3:us-west-2:181572960644:job/d6e58ec4-897a-4b6d-975f-10d7f0fb63ce",
"status": "Complete",
"jobEventId": "b268784cf0a66749f1a05bce259804f5",
"failureCodes": [],
"statusChangeReason": []
}
}
```
## S3 バッチ操作ジョブイベントを追跡するための EventBridge ルール
次の例は、Amazon EventBridge でルールを作成して、AWS CloudTrail によって記録された S3 バッチ操作イベントを任意のターゲットにキャプチャする方法を示しています。
そのためには、「[イベントに反応する EventBridge ルールの作成](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule.html)」のすべての手順に従ってルールを作成します。必要に応じて、以下の S3 バッチ操作カスタムイベントパターンポリシーを貼り付け、ターゲットサービスを選択します。
**S3 バッチ操作カスタムイベントパターンポリシー**
```
{
"source": [
"aws.s3"
],
"detail-type": [
"AWS Service Event via CloudTrail"
],
"detail": {
"eventSource": [
"s3.amazonaws.com"
],
"eventName": [
"JobCreated",
"JobStatusChanged"
]
}
}
```
以下の例は、EventBridge イベントルールから Amazon Simple Queue Service (Amazon SQS) に送信された 2 つのバッチ操作イベントです。バッチ操作ジョブは処理中にさまざまな状態 (`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 バッチ操作ジョブを作成するときに、すべてのタスクまたは失敗したタスクについてのみ完了レポートをリクエストできます。少なくとも 1 つのタスクが正常に呼び出されている限り、S3 バッチ操作は、完了、失敗、またはキャンセルされたジョブに関するレポートを生成します。
完了レポートには、オブジェクトキーの名前とバージョン、ステータス、エラーコード、およびエラーの説明など、各タスクに関する追加情報が含まれています。失敗した各タスクのエラーの説明を使用して、アクセス許可の問題など、ジョブの作成中に発生した問題を診断できます。**[チェックサムを計算]** ジョブの場合、完了レポートにはすべてのオブジェクトのチェックサム値が含まれます。
**注記**
完了レポートは常に、Amazon S3 マネージドキー (SSE-S3) で暗号化されます。
**Example — 最上位マニフェストの結果ファイル**
次の例に示すように、最上位の `manifest.json` ファイルには、成功した各レポートの場所と (ジョブに失敗があった場合は) 失敗したレポートの場所が含まれています。
```
{
"Format": "Report_CSV_20180820",
"ReportCreationDate": "2019-04-05T17:48:39.725Z",
"Results": [
{
"TaskExecutionStatus": "succeeded",
"Bucket": "my-job-reports",
"MD5Checksum": "83b1c4cbe93fc893f54053697e10fd6e",
"Key": "job-f8fb9d89-a3aa-461d-bddc-ea6a1b131955/results/6217b0fab0de85c408b4be96aeaca9b195a7daa5.csv"
},
{
"TaskExecutionStatus": "failed",
"Bucket": "my-job-reports",
"MD5Checksum": "22ee037f3515975f7719699e5c416eaa",
"Key": "job-f8fb9d89-a3aa-461d-bddc-ea6a1b131955/results/b2ddad417e94331e9f37b44f1faf8c7ed5873f2e.csv"
}
],
"ReportSchema": "Bucket, Key, VersionId, TaskStatus, ErrorCode, HTTPStatusCode, ResultMessage"
}
```
**成功したタスクのレポート**
成功したタスクのレポートには、**完了したタスクに関する以下の情報が含まれています。
+ `Bucket`
+ `Key`
+ `VersionId`
+ `TaskStatus`
+ `ErrorCode`
+ `HTTPStatusCode`
+ `ResultMessage`
**失敗したタスクのレポート**
失敗したタスクのレポートには、すべての*失敗した*タスクに関する以下の情報が含まれています。
+ `Bucket`
+ `Key`
+ `VersionId`
+ `TaskStatus`
+ `ErrorCode`
+ `HTTPStatusCode`
+ `ResultMessage`
**Example – Lambda 関数タスクレポート**
次の例では、Lambda 関数は Amazon S3 オブジェクトを別のバケットに正常にコピーしています。返された Amazon S3 レスポンスは S3 バッチ操作に戻され、最終的な完了レポートに書き込まれます。
```
amzn-s3-demo-bucket1,image_17775,,succeeded,200,,"{u'CopySourceVersionId': 'xVR78haVKlRnurYofbTfYr3ufYbktF8h', u'CopyObjectResult': {u'LastModified': datetime.datetime(2019, 4, 5, 17, 35, 39, tzinfo=tzlocal()), u'ETag': '""fe66f4390c50f29798f040d7aae72784""'}, 'ResponseMetadata': {'HTTPStatusCode': 200, 'RetryAttempts': 0, 'HostId': 'nXNaClIMxEJzWNmeMNQV2KpjbaCJLn0OGoXWZpuVOFS/iQYWxb3QtTvzX9SVfx2lA3oTKLwImKw=', 'RequestId': '3ED5852152014362', 'HTTPHeaders': {'content-length': '234', 'x-amz-id-2': 'nXNaClIMxEJzWNmeMNQV2KpjbaCJLn0OGoXWZpuVOFS/iQYWxb3QtTvzX9SVfx2lA3oTKLwImKw=', 'x-amz-copy-source-version-id': 'xVR78haVKlRnurYofbTfYr3ufYbktF8h', 'server': 'AmazonS3', 'x-amz-request-id': '3ED5852152014362', 'date': 'Fri, 05 Apr 2019 17:35:39 GMT', 'content-type': 'application/xml'}}}"
amzn-s3-demo-bucket1,image_17763,,succeeded,200,,"{u'CopySourceVersionId': '6HjOUSim4Wj6BTcbxToXW44pSZ.40pwq', u'CopyObjectResult': {u'LastModified': datetime.datetime(2019, 4, 5, 17, 35, 39, tzinfo=tzlocal()), u'ETag': '""fe66f4390c50f29798f040d7aae72784""'}, 'ResponseMetadata': {'HTTPStatusCode': 200, 'RetryAttempts': 0, 'HostId': 'GiCZNYr8LHd/Thyk6beTRP96IGZk2sYxujLe13TuuLpq6U2RD3we0YoluuIdm1PRvkMwnEW1aFc=', 'RequestId': '1BC9F5B1B95D7000', 'HTTPHeaders': {'content-length': '234', 'x-amz-id-2': 'GiCZNYr8LHd/Thyk6beTRP96IGZk2sYxujLe13TuuLpq6U2RD3we0YoluuIdm1PRvkMwnEW1aFc=', 'x-amz-copy-source-version-id': '6HjOUSim4Wj6BTcbxToXW44pSZ.40pwq', 'server': 'AmazonS3', 'x-amz-request-id': '1BC9F5B1B95D7000', 'date': 'Fri, 05 Apr 2019 17:35:39 GMT', 'content-type': 'application/xml'}}}"
amzn-s3-demo-bucket1,image_17860,,succeeded,200,,"{u'CopySourceVersionId': 'm.MDD0g_QsUnYZ8TBzVFrp.TmjN8PJyX', u'CopyObjectResult': {u'LastModified': datetime.datetime(2019, 4, 5, 17, 35, 40, tzinfo=tzlocal()), u'ETag': '""fe66f4390c50f29798f040d7aae72784""'}, 'ResponseMetadata': {'HTTPStatusCode': 200, 'RetryAttempts': 0, 'HostId': 'F9ooZOgpE5g9sNgBZxjdiPHqB4+0DNWgj3qbsir+sKai4fv7rQEcF2fBN1VeeFc2WH45a9ygb2g=', 'RequestId': '8D9CA56A56813DF3', 'HTTPHeaders': {'content-length': '234', 'x-amz-id-2': 'F9ooZOgpE5g9sNgBZxjdiPHqB4+0DNWgj3qbsir+sKai4fv7rQEcF2fBN1VeeFc2WH45a9ygb2g=', 'x-amz-copy-source-version-id': 'm.MDD0g_QsUnYZ8TBzVFrp.TmjN8PJyX', 'server': 'AmazonS3', 'x-amz-request-id': '8D9CA56A56813DF3', 'date': 'Fri, 05 Apr 2019 17:35:40 GMT', 'content-type': 'application/xml'}}}"
```
次のレポート例は、AWS Lambda 関数がタイムアウトし、失敗が失敗しきい値を超えた場合を示しています。これはその後 `PermanentFailure` としてマークされます。
```
amzn-s3-demo-bucket1,image_14975,,failed,200,PermanentFailure,"Lambda returned function error: {""errorMessage"":""2019-04-05T17:35:21.155Z 2845ca0d-38d9-4c4b-abcf-379dc749c452 Task timed out after 3.00 seconds""}"
amzn-s3-demo-bucket1,image_15897,,failed,200,PermanentFailure,"Lambda returned function error: {""errorMessage"":""2019-04-05T17:35:29.610Z 2d0a330b-de9b-425f-b511-29232fde5fe4 Task timed out after 3.00 seconds""}"
amzn-s3-demo-bucket1,image_14819,,failed,200,PermanentFailure,"Lambda returned function error: {""errorMessage"":""2019-04-05T17:35:22.362Z fcf5efde-74d4-4e6d-b37a-c7f18827f551 Task timed out after 3.00 seconds""}"
amzn-s3-demo-bucket1,image_15930,,failed,200,PermanentFailure,"Lambda returned function error: {""errorMessage"":""2019-04-05T17:35:29.809Z 3dd5b57c-4a4a-48aa-8a35-cbf027b7957e Task timed out after 3.00 seconds""}"
amzn-s3-demo-bucket1,image_17644,,failed,200,PermanentFailure,"Lambda returned function error: {""errorMessage"":""2019-04-05T17:35:46.025Z 10a764e4-2b26-4d8c-9056-1e1072b4723f Task timed out after 3.00 seconds""}"
amzn-s3-demo-bucket1,image_17398,,failed,200,PermanentFailure,"Lambda returned function error: {""errorMessage"":""2019-04-05T17:35:44.661Z 1e306352-4c54-4eba-aee8-4d02f8c0235c Task timed out after 3.00 seconds""}"
```
**Example – [チェックサムを計算] タスクレポート**
次の例では、**[チェックサムを計算]** オペレーションが、保管中にアップロードされたオブジェクトのチェックサムを正常に計算しました。返された Amazon S3 レスポンスは S3 バッチオペレーションに戻され、最終的な完了レポートに書き込まれます。
```
amzn-s3-demo-bucket1,s3-standard-1mb-test-object,,succeeded,200,,"{""checksum_base64"":""bS9TOQ\u003d\u003d"",""etag"":""3c3c1813042989094598e4b57ecbdc82"",""checksumAlgorithm"":""CRC32"",""checksumType"":""FULL_OBJECT"",""checksum_hex"":""6D2F5339""}"
```
次のレポート例は、**[チェックサムを計算]** オペレーションが失敗し、タスクレポートが失敗した場合の結果を示しています。
```
amzn-s3-demo-bucket1,image_14975,,failed,200,PermanentFailure,"error details: {""failureMessage"":"Task 2845ca0d-38d9-4c4b-abcf-379dc749c452 SSE-C encryption type is not supported for this operation", ""errorCode"": "400"}"
amzn-s3-demo-bucket1,image_14975,,failed,200,PermanentFailure,"error details: {""failureMessage"":"Task 2845ca0d-38d9-4c4b-abcf-379dc749c452 Key not found", ""errorCode"": "404"}"
amzn-s3-demo-bucket1,image_14975,,failed,200,PermanentFailure,"error details: {""failureMessage"":"Task 2845ca0d-38d9-4c4b-abcf-379dc749c452 Internal server error, please retry", ""errorCode"": "500"}"
```
# タグを使用したアクセスのコントロールとジョブのラベル付け
*タグ*を追加することで、S3 バッチ操作ジョブへのラベル付けとアクセスの制御を実行できます。タグを使用して、バッチ操作ジョブの担当者を識別できます。ジョブタグがあることで、ユーザーによるジョブのキャンセル、確認状態にあるジョブの有効化、ジョブの優先度レベルの変更を許可したり制限したりできます。タグをアタッチしてジョブを作成します。作成後にジョブにタグを追加できます。各タグはキーと値のペアであり、ジョブの作成時に追加することも、後で更新することもできます。
**警告**
ジョブタグに機密情報や個人データが含まれていないことを確認してください。
以下のタグ付けの例を考えてみます。経理部門にバッチ操作ジョブを作成するとします。`Department` タグに値 `Finance` を割り当ててジョブが作成される場合に、ユーザーに AWS Identity and Access Management の呼び出しを許可する `CreateJob` (IAM) ポリシーを作成できます。さらに、財務部門のメンバーであるすべてのユーザーにそのポリシーをアタッチできます。
この例を進めて、ユーザーに、必要なタグの付いたジョブの優先度を更新することを許可するポリシーや、それらのタグの付いたジョブをキャンセルすることを許可するポリシーを作成できます。詳細については、「[ジョブタグを使用したバッチオペレーションのアクセス許可の制御](batch-ops-job-tags-examples.md)」を参照してください。
タグは、新しい S3 バッチ操作ジョブの作成時に追加することも、既存のジョブに追加することもできます。
タグには以下の制限があります。
+ タグキーが一意である限り、最大 50 個のタグをジョブに関連付けることができます。
+ タグキーには最大 128 個の Unicode 文字、タグ値には最大 256 個の Unicode 文字を使用できます。
+ キーと値は大文字と小文字が区別されます。
タグの制限の詳細については、*AWS Billing and Cost Management ユーザーガイド*の[ユーザー定義タグの制限](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/allocation-tag-restrictions.html)を参照してください。
## S3 バッチ操作ジョブのタグ付けに関連する API オペレーション
Amazon S3 では、S3 バッチ操作ジョブのタグ付けについて次の API オペレーションがサポートされています。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_GetJobTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_GetJobTagging.html) – バッチオペレーションジョブに関連付けられたタグセットを返します。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_PutJobTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_PutJobTagging.html) – ジョブに関連付けられたタグのセットを置き換えます。この API アクションを使用した S3 バッチ操作ジョブタグの管理には、2 つの異なるシナリオがあります。
+ ジョブにタグがない - ジョブに一連のタグを追加できます (ジョブに以前のタグがない)。
+ ジョブに既存のタグのセットがある - 既存のタグのセットを変更するには、既存のタグのセット全体を置き換えます。または、[https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_GetJobTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_GetJobTagging.html) により既存のタグのセットを取得し、そのタグのセットに変更を加えて、この API アクションにより既存のタグのセットを、変更したタグのセットに置き換えます。
**注記**
タグセットを空にしてこのリクエストを送信すると、S3 バッチ操作 によってオブジェクトの既存のタグセットが削除されます。この方法を使用する場合は、階層 1 リクエスト (`PUT`) に対して料金が発生します。詳細については、「[Amazon S3 の料金](https://aws.amazon.com/s3/pricing)」を参照してください。
バッチ操作ジョブの既存のタグを削除するには、`DeleteJobTagging` アクションをお勧めします。このアクションでは、料金が発生せずに同じ結果が得られるためです。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DeleteJobTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DeleteJobTagging.html) - バッチオペレーションジョブに関連付けられたタグセットを削除します。
# ラベル付けに使用されるジョブタグを使用したバッチ操作ジョブの作成
タグを追加することで、Amazon S3 バッチオペレーションジョブへのラベル付けとアクセスの制御を実行できます。**タグを使用して、バッチ操作ジョブの担当者を識別できます。タグをアタッチしてジョブを作成し、後でジョブにタグを追加できます。詳細については、「[タグを使用したアクセスのコントロールとジョブのラベル付け](batch-ops-job-tags.md)」を参照してください。
## AWS CLI の使用
次の AWS CLI の例では、ジョブタグをジョブのラベルとして使用して S3 バッチ操作 `S3PutObjectCopy` ジョブを作成します。
1. バッチ操作ジョブで実行するアクションまたは `OPERATION` を選択してから、`TargetResource` を選択します。
```
read -d '' OPERATION <
AWS SDK for Java を使用してタグ付きの S3 バッチオペレーションジョブを作成する場合は、S3Control クライアントを使用して、組織化と追跡の目的で、マニフェストのロケーション、ジョブオペレーション、レポート設定、タグなどのジョブパラメータを設定できます。
AWS SDK for Java を使用してタグ付きの S3 バッチオペレーションジョブを作成する方法の例については、「*Amazon S3 API リファレンス*」の「[Create a batch job to copy objects](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_CreateJob_section.html)」を参照してください。
# S3 バッチ操作ジョブからタグを削除
これらの例を使用して、Amazon S3 バッチオペレーションジョブからタグを削除できます。
## の使用AWS CLI
次の例では、AWS CLI を使用してバッチ操作ジョブからタグを削除します。
```
aws \
s3control delete-job-tagging \
--account-id 123456789012 \
--job-id Example-e25a-4ed2-8bee-7f8ed7fc2f1c \
--region us-east-1
```
## バッチ操作ジョブのジョブタグを削除する
AWS SDK for Java を使用して S3 バッチオペレーションジョブのタグを削除する場合は、ジョブ ID を持つ S3Control クライアントを使用して、バッチオペレーションジョブに関連付けられたすべてのタグを削除します。
AWS SDK for Java を使用してジョブのタグを削除する方法の例については、「*Amazon S3 API リファレンス*」の「[Delete tags from a batch job](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_DeleteJobTagging_section.html)」を参照してください。
# 既存のバッチオペレーションジョブへのジョブタグの追加
[https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_PutJobTagging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_PutJobTagging.html) API オペレーションを使用して、既存の Amazon S3 バッチオペレーションジョブにジョブタグを追加できます。詳細については、以下の例を参照してください。
## の使用AWS CLI
AWS CLI を使用し、`s3control put-job-tagging` を使用して S3 バッチオペレーションジョブにジョブタグを追加する例を次に示します。例を使用するには、*`user input placeholders`* をユーザー自身の情報に置き換えます。
**注記**
タグセットを空にしてこのリクエストを送信すると、バッチオペレーション によってオブジェクトの既存のタグセットが削除されます。ただし、この方法を使用する場合は、階層 1 リクエスト (`PUT`) に対して料金が発生します。詳細については、「[Amazon S3 の料金](https://aws.amazon.com/s3/pricing)」を参照してください。
代わりに、バッチオペレーションジョブの既存のタグを削除するには、`DeleteJobTagging` オペレーションをお勧めします。このオペレーションでは、料金が発生せずに同じ結果が得られるためです。
1. ジョブに必要なジョブ `TAGS` を特定します。この場合、2 つのタグ `department` および `FiscalYear` を適用し、値 `Marketing` および `2020` をそれぞれ使用します。
```
read -d '' TAGS <
AWS SDK for Java を使用して S3 バッチオペレーションジョブにタグを配置するには、S3Control クライアントを使用して、組織化と追跡の目的で、キーと値のペアを使ってタグを追加または更新できます。
AWS SDK for Java を使用してジョブのタグを配置する方法の例については、「*Amazon S3 API リファレンス*」の「[Add tags to a batch job](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_PutJobTagging_section.html)」を参照してください。
# S3 バッチ操作ジョブのタグの取得
Amazon S3 バッチオペレーションジョブのタグを取得するには、`GetJobTagging` API オペレーションを使用できます。詳細については、以下の例を参照してください。
## AWS CLI の使用
次の例では、AWS CLI を使用してバッチ操作ジョブのタグを取得します。この例を実行するには、*`user input placeholders`* をユーザー自身の情報に置き換えます。
```
aws \
s3control get-job-tagging \
--account-id 123456789012 \
--job-id Example-e25a-4ed2-8bee-7f8ed7fc2f1c \
--region us-east-1
```
## AWS SDK for Java の使用
AWS SDK for Java を使用して S3 バッチオペレーションジョブのタグを取得するには、ジョブ ID を持つ S3Control クライアントを使用して、バッチオペレーションジョブに関連付けられたすべてのタグを取得し、リストとして返します。
AWS SDK for Java を使用してジョブのタグを取得する方法の例については、「*Amazon S3 API リファレンス*」の「[Get tags from a batch job](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_GetJobTagging_section.html)」を参照してください。
# ジョブタグを使用したバッチオペレーションのアクセス許可の制御
Amazon S3 バッチオペレーションジョブの管理に役立つように、ジョブタグを追加できます。**ジョブタグを使用すると、バッチ操作ジョブへのアクセスをコントロールし、ジョブの作成時にタグが適用されるようにできます。
バッチ操作ジョブごとに最大 50 個のジョブタグを適用できます。タグを使用することで、ジョブを編集できるユーザーのセットを制限する詳細なポリシーを設定できます。ジョブタグを使用して、ユーザーによるジョブのキャンセル、確認状態にあるジョブの有効化、ジョブの優先度レベルの変更を許可したり制限したりできます。さらに、すべての新しいジョブにタグが適用されるようにし、タグに許可されるキーと値のペアを指定できます。これらのすべての条件を [AWS Identity and Access Management IAM ポリシー言語](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_iam-tags.html)を使用して表現できます。詳細については、「サービス認証リファレンス」の「[Actions, resources, and condition keys for Amazon S3](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazons3.html)」を参照してください。**
S3 リソースタイプ別の S3 API オペレーションへのアクセス許可の詳細については、「[Amazon S3 API オペレーションに必要なアクセス許可](using-with-s3-policy-actions.md)」を参照してください。
以下の例では、S3 バッチ操作ジョブタグを使用して、特定の部門(たとえば、財務またはコンプライアンス部門) 内で実行されるジョブのみを作成および編集するアクセス許可をユーザーに付与する方法を示しています。QA や本番稼働など、関連する開発のステージに基づいてジョブを割り当てることもできます。
この例では、IAM ポリシーで S3 バッチオペレーションのジョブタグを使用して、部門内で実行されているジョブのみを作成および編集するアクセス権限をユーザーに付与します。QA や本番稼働など、関連する開発のステージに基づいてジョブを割り当てます。
以下の例では、次の部門を使用しています。各部門では、バッチオペレーションをさまざまな方法で使用しています。
+ 財務
+ コンプライアンス
+ ビジネスインテリジェンス
+ エンジニアリング
**Topics**
+ [ユーザーとリソースへのタグの割り当てによるアクセスのコントロール](#job-tags-examples-attaching-tags)
+ [バッチ操作ジョブをステージ別にタグ付けし、ジョブの優先度の制限を強制する](#tagging-jobs-by-stage-and-enforcing-limits-on-job-priority)
## ユーザーとリソースへのタグの割り当てによるアクセスのコントロール
このシナリオでは、管理者は[属性ベースのアクセスコントロール (ABAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html) を使用しています。ABAC は、ユーザーと AWS リソースの両方にタグを付けることでアクセス許可を定義する IAM 認可戦略です。
ユーザーとジョブには、以下の部門タグのいずれかが割り当てられます。
**キー : 値**
+ `department : Finance`
+ `department : Compliance`
+ `department : BusinessIntelligence`
+ `department : Engineering`
**注記**
ジョブタグのキーと値は大文字と小文字が区別されます。
ABAC アクセスコントロール戦略を使用して、タグ `department=Finance` をユーザーと関連付けることで、財務部門のユーザーに対して、部門内で S3 バッチ操作ジョブを作成および管理するアクセス許可を付与します。
さらにマネージドポリシーを IAM ユーザーにアタッチして、社内のすべてのユーザーに、それぞれの部門内での S3 バッチ操作ジョブの作成または変更を許可できます。
この例のポリシーには、3 つのポリシーステートメントが含まれています。
+ ポリシーの最初のステートメントでは、ユーザーに対して、ジョブ作成リクエストにそれぞれの部門に一致するジョブタグが含まれている場合に、バッチ操作ジョブの作成を許可しています。これは、`"${aws:PrincipalTag/department}"` 構文を使用して表現され、ポリシー評価時にユーザーの部門タグに置き換えられます。リクエスト `("aws:RequestTag/department")` の部門タグに指定した値がユーザーの部門と一致すると、条件が満たされます。
+ ポリシーの 2 番目のステートメントでは、ユーザーに対して、更新対象のジョブがそのユーザーの部門と一致する場合に、ジョブの優先度の変更、ジョブのステータスの更新を許可しています。
+ 3 番目のステートメントでは、ユーザーに対して、(1) 部門タグが保持され、(2) 更新対象のジョブが部門内にある限り、`PutJobTagging` リクエストによりいつでもバッチ操作ジョブのタグを更新することを許可しています。
------
#### [ 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 バッチ操作ジョブの作成と更新に対して、部門ベースの制限に加えて 2 つの新しい制限を導入します。
+ ジョブにタグ `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 のオブジェクトのリストに対して、1 つのオペレーションを実行できます。1 つのジョブで、エクサバイトのデータを含む数十億ものオブジェクトに対して、指定されたオペレーションを実行できます。Amazon S3 は、進捗状況の追跡、通知の送信、すべてのアクションの詳細な完了レポートの保存を行い、フルマネージド型の監査可能なサーバーレスエクスペリエンスを提供します。S3 バッチオペレーションは、Amazon S3 コンソール、AWS CLI、AWS SDK、または Amazon S3 REST API を通じて使用できます。
S3 オブジェクトロックを使用すると、オブジェクトバージョンにリーガルホールドを設定することができます。保持期間の設定と同様に、リーガルホールドは、オブジェクトバージョンが上書きまたは削除されるのを防ぎます。ただし、リーガルホールドには関連する保持期間はなく、リーガルホールドが削除されるまで有効です。詳細については、「[S3 オブジェクトロックのリーガルホールド](batch-ops-legal-hold.md)」を参照してください。
S3 バッチオペレーションと Object Lock を使用すると、一度に多くの Amazon S3 のオブジェクトをリーガルホールドにすることができます。以下のトピックを参照してください。
**Topics**
+ [S3 バッチ操作を使用した S3 オブジェクトロックの有効化](batch-ops-object-lock.md)
+ [バッチ操作を使用したオブジェクトロック保持の設定](batch-ops-object-lock-retention.md)
+ [S3 オブジェクトロック保持コンプライアンスモードでの S3 バッチ操作の使用](batch-ops-compliance-mode.md)
+ [S3 オブジェクトロック保持ガバナンスモードで S3 バッチ操作を使用する](batch-ops-governance-mode.md)
+ [S3 バッチオペレーションを使用した S3 Object Lock のリーガルホールドの無効化](batch-ops-legal-hold-off.md)
# S3 バッチ操作を使用した S3 オブジェクトロックの有効化
Amazon S3 バッチオペレーションを S3 Object Lock とともに使用すると、一度に多くの Amazon S3 オブジェクトの保持を管理したり、リーガルホールドを有効にしたりできます。マニフェストでターゲットオブジェクトのリストを指定し、そのマニフェストをジョブの完了のためにバッチ操作に送信します。詳細については、「[S3 オブジェクトロックの保持](batch-ops-retention-date.md)」および「[S3 オブジェクトロックのリーガルホールド](batch-ops-legal-hold.md)」を参照してください。
以下の例では、S3 バッチオペレーションアクセス許可を持つ AWS Identity and Access Management (IAM) ロールを作成し、そのロールのアクセス許可を更新して Object Lock を有効化するジョブを作成する方法を示します。S3 バッチオペレーションジョブのオブジェクトを識別する `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 <
S3 バッチオペレーション許可を持つ IAM ロールを作成し、AWS SDK for Java を使用して Object Lock を有効にするジョブを作成するためにロールの許可を更新できます。S3 バッチ操作ジョブのオブジェクトを識別する `CSV` マニフェストも必要です。詳細については、「[マニフェストの指定](batch-ops-create-job.md#specify-batchjob-manifest)」を参照してください。
以下のステップを実行します。
1. IAM ロールを作成し、実行する S3 バッチ操作のアクセス許可を割り当てます。このステップは、すべての S3 バッチ操作ジョブで必要です。
1. S3 オブジェクトロックを使用して S3 バッチ操作を実行するように設定します。
ロールに以下のことを許可します。
1. バッチ操作を実行するターゲットオブジェクトを含む S3 バケットでオブジェクトロックを実行します。
1. マニフェスト CSV ファイルとオブジェクトがある S3 バケットを読み取る。
1. S3 バッチ操作ジョブの結果をレポートバケットに書き込みます。
AWS SDK for Java で S3 バッチオペレーションを使用して S3 Object Lock を有効にするために IAM ロールを作成する方法を示すコード例については、「*AWS SDK for Java 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)」を参照してください。
# バッチ操作を使用したオブジェクトロック保持の設定
Amazon S3 バッチオペレーションと S3 Object Lock を使用すると、多くの Amazon S3 のオブジェクトの保持期間を一括で管理できます。マニフェストでターゲットオブジェクトのリストを指定し、そのマニフェストをジョブの完了のためにバッチ操作に送信します。詳細については、「[S3 オブジェクトロックの保持](batch-ops-retention-date.md)」および「[S3 オブジェクトロックのリーガルホールド](batch-ops-legal-hold.md)」を参照してください。
次の例は、S3 バッチオペレーションのアクセス許可を持つ AWS Identity and Access Management (IAM) ロールを作成し、マニフェストバケット内のオブジェクトで S3 Object Lock 保持を実行できるように、`s3:PutObjectRetention` アクセス許可を含めるようロールアクセス許可を更新する方法を示しています。S3 バッチオペレーションジョブのオブジェクトを識別する `CSV` マニフェストも必要です。詳細については、「[マニフェストの指定](batch-ops-create-job.md#specify-batchjob-manifest)」を参照してください。
次の例を実行するには、*`user input placeholders`* をユーザー自身の情報に置き換えます。
## の使用AWS CLI
次の AWS CLI の例は、バッチオペレーションを使用して、複数のオブジェクトに S3 Object Lock 保持を適用する方法を示しています。
```
export AWS_PROFILE='aws-user'
read -d '' retention_permissions <
AWS SDK for Java でバッチオペレーションを使用して複数のオブジェクトに S3 Object Lock 保持を適用する方法の例については、「*Amazon S3 API リファレンス*」の「[Use CreateJob with an AWS SDK or CLI](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_CreateJob_section.html)」を参照してください。
# S3 オブジェクトロック保持コンプライアンスモードでの S3 バッチ操作の使用
以下の例は、信頼ポリシーを作成し、オブジェクトに S3 バッチ操作と S3 オブジェクトロックの設定アクセス許可を設定する前の例に基づいています。この例では、保持モードを `COMPLIANCE` に、`retain until date` を 2025 年 1 月 1 日に設定しています。この例では、マニフェストバケット内のオブジェクトをターゲットとし、指定したレポートバケットに結果を書き込むジョブを作成します。
次の例を実行するには、*`user input placeholders`* をユーザー自身の情報に置き換えます。
## の使用AWS CLI
次の AWS CLI の例は、バッチオペレーションを使用して、複数のオブジェクトに S3 Object Lock 保持コンプライアンスモードを適用する方法を示しています。
**Example – 複数のオブジェクトに S3 Object Lock 保持コンプライアンスモードを設定する**
```
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 <
次の AWS SDK for Java の例は、バッチオペレーションを使用して複数のオブジェクトに S3 Object Lock 保持コンプライアンスモードを適用する方法を示しています。これには、保持モードを保持期日がある COMPLIANCE に設定し、COMPLIANCE モードの保持期日を延長する方法が含まれます。
AWS SDK for Java でバッチオペレーションを使用して複数のオブジェクトに S3 Object Lock 保持コンプライアンスモードを適用する方法の例については、「*Amazon S3 API リファレンス*」の「[Use CreateJob with an AWS SDK or CLI](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_CreateJob_section.html)」を参照してください。
# S3 オブジェクトロック保持ガバナンスモードで S3 バッチ操作を使用する
次の例は、信頼ポリシーを作成し、S3 バッチ操作と S3 オブジェクトロックの設定アクセス許可を設定する前の例に基づいています。この例は、2025 年 1 月 30 日の `retain until date` で S3 Object Lock 保持ガバナンスを複数のオブジェクトに適用する方法を示しています。また、マニフェストバケットを使用しレポートバケットに結果を書き込むバッチ操作ジョブを作成します。
次の例を実行するには、*`user input placeholders`* をユーザー自身の情報に置き換えます。
## の使用AWS CLI
次の AWS CLI の例は、バッチオペレーションを使用して、複数のオブジェクトに S3 Object Lock 保持ガバナンスモードを適用する方法を示しています。
**Example – 2025 年 1 月 30 日まで保持する複数のオブジェクトに S3 Object Lock 保持ガバナンスを適用する**
```
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 <
次の AWS SDK for Java の例は、`retain until date` を 2025 年 1 月 30 日に設定した S3 Object Lock 保持ガバナンスを複数のオブジェクトに適用する方法を示しています。これには、保持期間がある複数のオブジェクトに Object Lock 保持ガバナンスを適用し、複数のオブジェクトに保持ガバナンスをバイパスする方法が含まれます。
AWS SDK for Java で S3 Object Lock 保持ガバナンスモードでバッチオペレーションを使用する方法の例については、「*Amazon S3 API リファレンス*」の「[Use CreateJob with an AWS SDK or CLI](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_CreateJob_section.html)」を参照してください。
# S3 バッチオペレーションを使用した S3 Object Lock のリーガルホールドの無効化
以下の例は、信頼ポリシーを作成し、S3 バッチ操作と S3 オブジェクトロックの設定アクセス許可を設定する前の例に基づいています。この例では、バッチオペレーションを使用して、オブジェクトの Object Lock のリーガルホールドを無効にする方法を示します。
この例ではまず、`s3:PutObjectLegalHold` アクセス許可を付与するようにロールを更新したうえで、マニフェストで指定されたオブジェクトから法的保留をオフにし (削除)、その結果をレポートするバッチ操作ジョブを作成します。
次の例を実行するには、*`user input placeholders`* をユーザー自身の情報に置き換えます。
## の使用AWS CLI
次の AWS CLI の例は、バッチオペレーションを使用して、複数のオブジェクト間で S3 Object Lock のリーガルホールドを無効にする方法を示しています。
**Example – ロールを更新して `s3:PutObjectLegalHold` にアクセス許可を付与する**
```
export AWS_PROFILE='aws-user'
read -d '' legal_hold_permissions <
AWS SDK for Java で S3 バッチオペレーションを使用して S3 Object Lock のリーガルホールドを無効にする方法の例については、「*Amazon S3 API リファレンス*」の「[Use CreateJob with an AWS SDK or CLI](https://docs.aws.amazon.com/AmazonS3/latest/API/s3-control_example_s3-control_CreateJob_section.html)」を参照してください。
# チュートリアル: S3 バッチオペレーションを使用した動画のバッチトランスコーディング
動画消費者は、あらゆる形状、サイズ、ビンテージのデバイスを使用してメディアコンテンツを楽しんでいます。この幅広い一連のデバイスは、コンテンツ作成者やディストリビューターにとって課題となります。動画は、ワンサイズですべてにフィットするフォーマットではなく、幅広いサイズ、フォーマット、ビットレートに変換する必要があります。変換が必要な動画が多数ある場合、この変換タスクはさらに困難になります。
AWS では、以下を実行するスケーラブルな分散アーキテクチャを構築する方法を提供します。
+ 入力動画を取り込みます。
+ さまざまなデバイスで再生するために動画を処理します。
+ トランスコードされたメディアファイルを格納します。
+ 需要に合わせて出力メディアファイルを配信します。
Amazon S3 に広範な動画リポジトリを保存している場合は、これらの動画をソース形式から、特定の動画プレーヤーやデバイスに必要なサイズ、解像度、形式の複数のファイルタイプに変換できます。具体的には、[S3 バッチ操作](https://aws.amazon.com/s3/features/batch-operations) は、S3 ソースバケット内の既存の入力動画の AWS Lambda 関数を呼び出すためのソリューションを提供します。次に、Lambda 関数は [AWS Elemental MediaConvert](https://aws.amazon.com/mediaconvert/) を呼び出して、広範な動画トランスコーディングタスクを実行します。変換後の出力メディアファイルは S3 保存先バケットに保存されます。
![\[バッチトランスコーディングのワークフロー図\]](http://docs.aws.amazon.com/ja_jp/AmazonS3/latest/userguide/images/batchops-example-image-global.png)
**目的**
このチュートリアルでは、S3 送信先バケットに保存された動画のバッチトランスコーディング用に Lambda 関数を呼び出すように S3 バッチ操作を設定する方法を学習します。Lambda 関数は MediaConvert を呼び出して、動画をトランスコードします。S3 ソースバケット内の各動画の出力は、次のとおりです。
+ 複数のサイズのデバイスおよびさまざまな帯域幅で再生するための [HTTP Live Streaming (HLS)](http://wikipedia.org/wiki/HTTP_Live_Streaming) アダプティブビットレートストリーム。
+ MP4 動画ファイル
+ サムネイル画像は、間隔をおいて収集されます。
**Topics**
+ [前提条件](#batchops-s3-prerequisites)
+ [ステップ 1: 出力メディアファイルの S3 バケットを作成する。](#batchops-s3-step1)
+ [ステップ 2: MediaConvert 用に IAM ロールを作成する](#batchops-s3-step2)
+ [ステップ 3: Lambda 関数の IAM ロールを作成する](#batchops-s3-step3)
+ [ステップ 4: 動画トランスコーディング用の Lambda 関数の作成](#batchops-s3-step4)
+ [ステップ 5: S3 ソースバケットの Amazon S3 インベントリを設定する。](#batchops-s3-step5)
+ [ステップ 6: S3 バッチ操作の IAM ロールを作成する。](#batchops-s3-step6)
+ [ステップ 7: S3 バッチ操作ジョブを作成して実行する。](#batchops-s3-step7)
+ [ステップ 8: S3 宛先バケットから出力メディアファイルを確認する。](#batchops-s3-step8)
+ [ステップ 9: クリーンアップする。](#batchops-s3-step9)
+ [次のステップ](#batchops-s3-next-steps)
## 前提条件
このチュートリアルを開始する前に、トランスコードされる動画がすでにその中に保存されている Amazon S3 ソースバケットが必要です (例、`amzn-s3-demo-source-bucket` )。
必要に応じて、バケットに別の名前を付けることができます。Amazon S3 のバケット命名規則の詳細については、「[汎用バケットの命名規則](bucketnamingrules.md)」を参照してください。
S3 ソースバケットの場合、**このバケットのブロックパブリックアクセス設定** に関連する設定をデフォルトに設定したままにします (***すべて* のパブリックアクセスをブロックする** が有効)。詳細については、「[汎用バケットの作成](create-bucket-overview.md)」を参照してください。
S3 ソースバケットへの動画のアップロードの詳細については、[オブジェクトのアップロード](upload-objects.md) を参照してください。S3 に動画ファイルをアップロードするときは、[Amazon S3 Transfer Acceleration](https://aws.amazon.com/s3/transfer-acceleration) を使用して、高速かつ安全なファイル転送を設定します。転送アクセラレーションを使用すると、S3 バケットへの動画のアップロードを高速化して、大きな動画の長距離転送を行うことができます。詳細については、「[Amazon S3 Transfer Acceleration を使用した高速かつ安全なファイル転送の設定](transfer-acceleration.md)」を参照してください。
## ステップ 1: 出力メディアファイルの S3 バケットを作成する。
このステップでは、変換後の出力メディアファイルを保存するための S3 ソースバケットを作成します。また、Cross Origin Resource Sharing (CORS) 設定を作成して、S3 の送信先バケットに保存されているトランスコードされたメディアファイルへのクロスオリジンアクセスを許可します。
**Topics**
+ [出力メディアファイル用のバケットを作成する。](#batchops-s3-step1-create-bucket)
+ [CORS 設定を S3 出力バケットに追加する](#batchops-s3-step1-cors)
### 出力メディアファイル用のバケットを作成する。
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、[**バケット**] を選択します。
1. [**Create bucket (バケットの作成)**] を選択します。
1. **Bucket Name** に、バケットの名前 (例: `amzn-s3-demo-destination-bucket1`) を入力します。
1. **[リージョン]** で、バケットを保存する AWS リージョンを選択します。
1. 出力メディアファイルへのパブリックアクセスを確保するには、**Block Public Access settings** (パブリックアクセスのブロック設定) で、**Block *all* public access** (すべてのパブリックアクセスをブロック) をオフにします。
**警告**
このステップを完了する前に「[Amazon S3 ストレージへのパブリックアクセスのブロック](access-control-block-public-access.md)」を読んで、パブリックアクセスを許可することに伴うリスクを理解し、了承します。ブロックパブリックアクセス設定をオフにしてバケットをパブリックにすると、インターネット上の誰でもバケットにアクセスできるようになります。バケットへのすべてのパブリックアクセスをブロックすることをお勧めします。
ブロックパブリックアクセス設定をクリアしたくない場合は、Amazon CloudFront を使用して、トランスコードされたメディアファイルをビューワー (エンドユーザー) に配信できます。詳細については、「[チュートリアル: Amazon S3、Amazon CloudFront、Amazon Route 53 を使用したオンデマンドストリーミング動画のホスティング。](tutorial-s3-cloudfront-route53-video-streaming.md)」を参照してください。
1. [**現在の設定により、このバケットと保存されたオブジェクトがパブリックになる可能性があることを了承します**] の横にあるチェックボックスを選択します。
1. 残りの設定はデフォルト値のままにしておきます。
1. **[バケットを作成する]** を選択します。
### CORS 設定を S3 出力バケットに追加する
JSON CORS 設定は、特定のドメインにロードされたクライアントウェブアプリケーション (このコンテキストでは動画プレーヤー) が、異なるドメインでトランスコードされた出力メディアファイルを再生する方法を定義します。
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、**[バケット]** を選択します。
1. **バケット** リストで、先に作成したバケットの名前を選択します(例: `amzn-s3-demo-destination-bucket1`) 。
1. **[アクセス許可]** タブを選択します。
1. **[CORS (クロスオリジンリソース共有)]** セクションで、**[編集]** を選択します。
1. [CORS 設定] テキストボックスで、次に示す CORS 設定をコピーして貼り付けます。
CORS 設定は、JSON 形式である必要があります。この例では、`AllowedOrigins` 属性はワイルドカード文字 (`*`) を使用して、すべてのオリジンを指定します。特定のオリジンがわかっている場合は、`AllowedOrigins` 属性を特定のプレーヤーの URL に限定します。この属性およびその他の属性の設定の詳細については、「[CORS 設定のエレメント](ManageCorsUsing.md)」を参照してください。
```
[
{
"AllowedOrigins": [
"*"
],
"AllowedMethods": [
"GET"
],
"AllowedHeaders": [
"*"
],
"ExposeHeaders": []
}
]
```
1. **[Save changes]** (変更の保存) をクリックします。
## ステップ 2: MediaConvert 用に IAM ロールを作成する
AWS Elemental MediaConvert を使用して S3 バケットに保存されている入力動画をトランスコーディングするには、AWS Identity and Access Management (IAM) サービスロールを使用して、S3 ソースバケットおよび宛先バケットから動画ファイルを読み書きするための MediaConvert アクセス許可を付与します。トランスコーディングジョブを実行すると、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 ロールを作成した後、**ロール** のリストで、作成した MediaConvert のロールの名前を選択します (例: **tutorial-mediaconvert-role**)。
1. **概要** ページで、`arn:aws:iam::` で始まる **ロール ARN** をコピーし、後で使用できるように ARN を保存します。
ARN の詳細については、*AWS 全般のリファレンス*の[ Amazon リ送信先ネーム (ARN)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) を参照してください。
## ステップ 3: Lambda 関数の IAM ロールを作成する
MediaConvert および S3 バッチ操作で動画をバッチトランスコードするには、これらの 2 つのサービスを接続して動画を変換する Lambda 関数を使用します。この Lambda 関数には、MediaConvert および S3 バッチ操作にアクセスするための許可を Lambda 関数に付与する IAM ロールが必要です。
**Topics**
+ [Lambda 関数の IAM ロールを作成する](#batchops-s3-step3-role)
+ [Lambda 関数の IAM ロールにインラインポリシーを埋め込む](#batchops-s3-step3-inline-policy)
### Lambda 関数の IAM ロールを作成する
1. AWS マネジメントコンソール にサインインして、IAM コンソール [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) を開きます。
1. 左側のナビゲーションペインから、[**Roles (ロール)**] を選択し、[**Create role (ロールの作成)**] を選択します。
1. **AWS サービス** ロールの種類を選択し、**一般的ユースケース** で、**Lambda** を選択します。
1. **[Next: Permissions]** (次のステップ: 許可) を選択します。
1. [**Attach Permissions policies (許可ポリシーのアタッチ) ** ]ページにある**ポリシーのフィルタリング** に **AWSLambdaBasicExecutionRole** を入力します。管理ポリシー **AWSLambdaBasicExecutionRole** をこのロールにアタッチして、Amazon CloudWatch Logs への書き込み許可を付与するには、**AWSLambdaBasicExecutionRole** の横にあるチェックボックスを選択します。
1. [**次へ**] を選択します。
1. **[ロール名]** には、「**tutorial-lambda-transcode-role**」と入力します。
1. (オプション) 管理ポリシーにタグを追加します。
1. [**ロールの作成**] を選択してください。
### Lambda 関数の IAM ロールにインラインポリシーを埋め込む
Lambda 関数の実行に必要な MediaConvert リソースに許可を付与するためには、インラインポリシーを使用する必要があります。
1. AWS マネジメントコンソール にサインインして、IAM コンソール [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) を開きます。
1. 左のナビゲーションペインで、**[Roles (ロール)]** を選択してください。
1. **ロール** のリストで、Lambda 関数用に先に作成した IAM ロールの名前を選択します (例、**tutorial-lambda-transcode-role**)。
1. [**Permissions**] タブを選択します。
1. [**Add inline policy**] を選択します。
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 関数の作成
チュートリアルの子のセクションでは、S3 バッチ操作および MediaConvert と統合するには、SDK for Python を使用して Lambda 関数を構築します。S3 ソースバケットにすでに保存されている動画のトランスコーディングを開始するには、S3 ソースバケット内の各動画に対して Lambda 関数を直接呼び出す S3 バッチ操作ジョブを実行します。次に、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 Live Streaming (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` および `lambda.zip` という名前の `.zip` ファイルとして `job.json` を使用してデプロイパッケージを作成するには、上記で作成した `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.
AWS Lambda コンソールの [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) を開いてください。
1. 左側のナビゲーションペインで、**関数** を選択します。
1. **関数の作成** を選択します。
1. **Author from scratch** を選択します。
1. **基本的な情報** で、以下の作業を行います。
1. **[関数名]** に「**tutorial-lambda-convert**」と入力します。
1. **[ランタイム]** で **[Python 3.13]** を選択します。
1. **デフォルト実行ロールを変更する** を選択し、**実行ロール** で、**既存のロールを使用する** を選択します。
1. **既存のロール** で、[ステップ 3](#batchops-s3-step3) で Lambda 関数用に作成した IAM ロールの名前を選択します (例、**tutorial-lambda-transcode-role**)。
1. 残りの設定はデフォルトのままにしておきます。
1. **関数の作成** を選択します。
### .zip ファイルアーカイブを使用して Lambda 関数コードをデプロイし、Lambda 関数を設定します (コンソール)。
1. 上で作成した Lambda 関数のページの **[コードソース]** セクション (**tutorial-lambda-convert** など) で、**[アップロード元]**、**[.zip ファイル]**の順に選択します。
1. **アップロード** を選択して、ローカルの `.zip` ファイルを選択します。
1. 前に作成した `lambda.zip` ファイルを選択し、**開く** を選択します。
1. **Save** を選択します。
1. **ランタイム設定** セクションで、**編集** を選択します。
1. Lambda ランタイムに Lambda 関数コード内のどのハンドラメソッドの呼び出しを指示するには、**ハンドラー** フィールドに **convert.handler** を入力します。
Python で関数を設定するとき、ハンドラー設定の値は、ファイル名と、ハンドラーモジュールの名前を、ドット (`.`) で区切ったものになります。例えば、`convert.handler` は、`convert.py` ファイルで定義された `handler` メソッドを呼び出します。
1. **Save** を選択します。
1. [Lambda 関数] ページで、**設定** タブを選択します。**設定** タブの左側のナビゲーションペインで、**環境変数** を選択し、**編集** を選択します。
1. **環境変数の追加** を選択します。次に、次の環境変数ごとに**キー** および**値** を入力します。
+ **キー** : **DestinationBucket** **値**: **amzn-s3-demo-destination-bucket1**
この値は、[ステップ 1](#batchops-s3-step1) で作成した出力メディアファイルの S3 バケットです。
+ **キー** : **MediaConvertRole** **値**: **arn:aws:iam::*111122223333*:role/tutorial-mediaconvert-role**
この値は、[ステップ 2](#batchops-s3-step2) で作成した MediaConvert の IAM ロールの ARN です。この ARN を IAM ロールの実際の ARN に置き換えてください。
+ **キー** : **Application** **値**: **Batch-Transcoding**
この値は、アプリケーションの名前です。
1. **Save** を選択します。
1. (オプション) **Configuration** (設定) タブの左側のナビゲーションペインの **General configuration** (一般設定) セクションで、**Edit** (編集) を選択します。[**タイムアウト**] フィールドに、**2** 分 **0** 秒と入力します。次に、**[保存]** を選択します。
**タイムアウト**は、Lambda で関数が停止するまでに許可される実行時間の長さです。デフォルト値は 3 秒です。料金は、設定されたメモリの量とコードの実行時間に基づいて請求されます。詳細については、「[AWS Lambda 料金表](https://aws.amazon.com/lambda/pricing/?icmpid=docs_console_unmapped)」を参照してください。
## ステップ 5: S3 ソースバケットの Amazon S3 インベントリを設定する。
トランスコーディング Lambda 関数をセットアップしたら、S3 バッチ操作ジョブを作成して、一連の動画をトランスコードします。まず、S3 バッチ操作で指定したトランスコーディングアクションを実行する入力動画オブジェクトのリストが必要です。入力動画オブジェクトのリストを取得するには、S3 ソースバケットの S3 インベントリレポートを生成できます (例、`amzn-s3-demo-source-bucket`)。
**Topics**
+ [入力動画の S3 インベントリレポート用のバケットを作成して設定する](#batchops-s3-step5-bucket)
+ [S3 動画ソースバケットの Amazon S3 インベントリを設定します。](#batchops-s3-step5-inventory)
+ [S3 動画ソースバケットのインベントリレポートを確認します。](#batchops-s3-step5-manifest)
### 入力動画の S3 インベントリレポート用のバケットを作成して設定する
S3 ソースバケットのオブジェクトをリストする S3 インベントリレポートを保存するには、S3 インベントリ宛先バケットを作成し、そのバケットに対してインベントリファイルを S3 ソースバケットに書き込むようにバケットポリシーを設定します。
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、[**バケット**] を選択します。
1. [**Create bucket (バケットの作成)**] を選択します。
1. **Bucket Name** に、バケットの名前 (例: `amzn-s3-demo-destination-bucket2`) を入力します。
1. **AWS リージョン** で、バケットを保存するAWS リージョン を選択します。
インベントリ宛先バケットは、S3 インベントリを設定するソースバケットと同じ AWS リージョン である必要があります。インベントリ宛先バケットは、別の AWS アカウント にある場合があります。
1. **このバケットのパブリックアクセス設定をブロック** で、デフォルト設定 (**ブロック*すべて*パブリックアクセス**が有効) のままであることを確認します。
1. 残りの設定はデフォルトのままにしておきます。
1. **[バケットを作成する]** を選択します。
1. [**バケット**] リストで、作成したばかりのバケットの名前を選択します(例、`amzn-s3-demo-destination-bucket2`) 。
1. S3 インベントリレポートのデータを S3 インベントリ送信先バケットに書き込む許可を Amazon S3 に付与するには、**許可** タブを選択します。
1. **バケットポリシー** セクションまで下にスクロールし、**編集** を選択します。**バケットポリシー** ページが開きます。
1. S3 インベントリの許可を付与するには、**ポリシー** フィールドに、次のバケットポリシーを貼り付けます。
3 つの例の値を、それぞれ次の値に置き換えます。
+ インベントリレポート (例、`amzn-s3-demo-destination-bucket2`) を保存するために作成したバケットの名前。
+ 入力動画を保存するソースバケットの名前 (例、`amzn-s3-demo-source-bucket` )。
+ S3 動画ソースバケットの作成に使用した AWS アカウント ID (例、`111122223333`)。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"InventoryAndAnalyticsExamplePolicy",
"Effect":"Allow",
"Principal": {"Service": "s3.amazonaws.com"},
"Action":"s3:PutObject",
"Resource":["arn:aws:s3:::amzn-s3-demo-destination-bucket2/*"],
"Condition": {
"ArnLike": {
"aws:SourceArn": "arn:aws:s3:::amzn-s3-demo-source-bucket"
},
"StringEquals": {
"aws:SourceAccount": "111122223333",
"s3:x-amz-acl": "bucket-owner-full-control"
}
}
}
]
}
```
------
1. **[Save changes]** (変更の保存) をクリックします。
### S3 動画ソースバケットの Amazon S3 インベントリを設定します。
動画オブジェクトとメタデータのフラットファイルリストを生成するには、S3 動画ソースバケットの S3 インベントリを設定する必要があります。これらのスケジュールされたレポートには、バケット内のすべてのオブジェクト、または共有プレフィックスでグループ化されたオブジェクトを含めることができます。このチュートリアルでは、S3 インベントリレポートに S3 ソースバケット内のすべての動画オブジェクトが含まれます。
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、**[バケット]** を選択します。
1. S3 ソースバケットの入力動画の S3 インベントリレポートを設定するには、**バケット** リストで、S3 ソースバケットの名前を選択します (例、`amzn-s3-demo-source-bucket`)。
1. **[管理]** タブを選択します。
1. **インベントリの設定** セクションを下にスクロールし、**インベントリ設定を作成する** を選択します。
1. **Inventory configuration name** (インベントリ設定名) に、名前を入力します (例、**tutorial-inventory-config**)。
1. **[インベントリスコープ]** で、**[オブジェクトバージョン]** に対して **[現在のバージョンのみ]** を選択し、他の **[インベントリスコープ]** 設定をこのチュートリアルのデフォルトに設定したままにします。
1. **レポートの詳細** の **宛先バケット** で、**このアカウント** を選択します。
1. **宛先** で **S3 を参照** を選択し、インベントリレポートを保存するために先に作成した宛先バケットを選択します (例、`amzn-s3-demo-destination-bucket2`)。次に、**パスの選択** を選択します。
インベントリ宛先バケットは、S3 インベントリを設定するソースバケットと同じ AWS リージョン である必要があります。宛先バケットは、別の AWS アカウント アカウントにある場合があります。
[**送信先**] バケットフィールドの下に、Amazon S3 がそのバケットにデータを入れることを許可するために送信先バケットポリシーに追加される [**送信先バケットの許可**] が追加されます。詳細については、「[ターゲットバケットポリシーの作成](configure-inventory.md#configure-inventory-destination-bucket-policy)」を参照してください。
1. **頻度** で、**1 日 1 回** を選択します。
1. [**Output format**] (出力形式) として [**CSV**] を選択します。
1. **Status** (ステータス) で、**有効** を選択します。
1. **サーバー側の暗号化** で、このチュートトリアルの **無効** を選択します。
詳細については、「[S3 コンソールを使用したインベントリの設定](configure-inventory.md#configure-inventory-console)」および「[カスタマーマネージドキーを暗号化に使用するためのアクセス許可を Amazon S3 に付与する](configure-inventory.md#configure-inventory-kms-key-policy)」を参照してください。
1. **追加フィールド - *オプション*** セクションで、**サイズ**、**最終更新日時** および **ストレージクラス** を選択します。
1. **[作成]** を選択します。
詳細については、「[S3 コンソールを使用したインベントリの設定](configure-inventory.md#configure-inventory-console)」を参照してください。
### S3 動画ソースバケットのインベントリレポートを確認します。
インベントリレポートが発行されると、マニフェストファイルは S3 インベントリ宛先バケットに送信されます。
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、**[バケット]** を選択します。
1. **Buckets** (バケット) リストで、動画送信先バケットの名前を選択します (例、`amzn-s3-demo-source-bucket`)。
1. [**Management (管理)**] を選択します。
1. S3 インベントリレポートで S3 バッチ操作ジョブを作成する準備ができているかどうかを確認するには、[ステップ 7](#batchops-s3-step7) の **インベントリ設定** で、**マニフェストからジョブを作成** ボタンが有効になっているかを確認します。
**注記**
最初のレポートが配信されるまでに最大で 48 時間かかることがあります。**Create job from manifest** (マニフェストからジョブを作成) ボタンが無効になっている場合、最初のインベントリレポートは配信されていません。[ステップ 7](#batchops-s3-step7) で S3 バッチ操作ジョブを作成するには、最初のインベントリレポートが配信され、**マニフェストからジョブを作成** ボタンが有効になるまで待つ必要があります。
1. S3 インベントリレポート (`manifest.json`) を確認するには、**宛先** 列で、インベントリレポートを保存するために先に作成したインベントリ宛先バケットの名前を選択します (例、`amzn-s3-demo-destination-bucket2`)。
1. **オブジェクト** タブで、S3 ソースバケットの名前を持つ既存のフォルダ (例、`amzn-s3-demo-source-bucket`) を選択します。次に、先にインベントリ設定を作成した際に **インベントリの設定名** で入力した名前を選択します (例、**tutorial-inventory-config**)。
レポートの生成日を名前として含むフォルダのリストを表示できます。
1. 特定の日付の日次 S3 インベントリレポートを確認するには、生成日の名前が付いたフォルダを選択して、`manifest.json` を選択します。
1. 特定の日付のインベントリレポートの詳細を確認するには、**manifest.json** ページで、**Download** (ダウンロード) または **Open** (開く) を選択します。
## ステップ 6: S3 バッチ操作の IAM ロールを作成する。
S3 バッチ操作を使用してバッチトランスコーディングを行うには、最初に IAM ロールを作成して、S3 バッチ操作を実行する許可を Amazon S3 に付与する必要があります。
**Topics**
+ [S3 バッチ操作用の IAM ポリシーを作成する。](#batchops-s3-step6-policy)
+ [S3 バッチ操作 IAM ロールを作成し、許可ポリシーを割り当てる](#batchops-s3-step6-role)
### S3 バッチ操作用の IAM ポリシーを作成する。
S3 バッチ操作に、入力マニフェストを読み取り、Lambda 関数を呼び出し、S3 バッチ操作ジョブ完了レポートに書き込みを行う許可を与える IAM ポリシーを作成する必要があります。
1. AWS マネジメントコンソール にサインインして、IAM コンソール [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) を開きます。
1. 左のナビゲーションペインの **[ポリシー]** を選択します。
1. [**Create policy (ポリシーの作成)**] を選択します。
1. **JSON** タブを選択します。
1. **JSON** テキストフィールドに、次の JSON ポリシーをコピーして貼り付けます。
JSON ポリシーで、4 つのサンプル値を次の値に置き換えます。
+ 入力動画を保存するソースバケットの名前 (例、`amzn-s3-demo-source-bucket`)。
+ `manifest.json` ファイル (例、`amzn-s3-demo-destination-bucket2`) を保存するために[ステップ 5](#batchops-s3-step5) で作成したインベントリ送信先バケットの名前。
+ 出力メディアファイルを保存するために [ステップ 1](#batchops-s3-step1) で作成したバケットの名前 (例、`amzn-s3-demo-destination-bucket1`)。このチュートリアルでは、出力メディアファイルの送信先バケットにジョブ完了レポートを配置します。
+ [ステップ 4](#batchops-s3-step4) で作成した Lambda 関数のロール ARN。Lambda 関数のロール ARN を検索してコピーするには、次の操作を行います。
+ 新しいブラウザタブで、[https://console.aws.amazon.com/lambda/home#/functions](https://console.aws.amazon.com/lambda/home#/functions) にある Lambda コンソールの **関数** ページを開きます。
+ **関数** のリストから、[ステップ 4](#batchops-s3-step4) で作成した Lambda 関数を選択します (例、**tutorial-lambda-convert**)。
+ [**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. [**Next: Tags (次へ: タグ)**] を選択します。
1. [**Next: Review (次へ: レビュー)**] を選択します。
1. [**名前**] フィールドに **tutorial-s3batch-policy** を入力してください。
1. [**Create policy (ポリシーの作成)**] を選択します。
### S3 バッチ操作 IAM ロールを作成し、許可ポリシーを割り当てる
1. AWS マネジメントコンソール にサインインして、IAM コンソール [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) を開きます。
1. 左側のナビゲーションペインから、[**Roles (ロール)**] を選択し、[**Create role (ロールの作成)**] を選択します。
1. **AWS のサービス** ロールタイプを選択し、**S3** サービスを選択します。
1. [**ユースケースを選択**] で、**S3 バッチ操作** を選択します。
1. [**次へ**] を選択します。
1. **[アクセス許可をアタッチ]** で、事前に作成した IAM ポリシーの名前 (**tutorial-s3batch-policy** など) を検索ボックスに入力し、ポリシーのリストをフィルタリングします。ポリシー名の横にあるチェックボックスを選択します (例、**tutorial-s3batch-policy**)。
1. [**次へ**] を選択します。
1. **[Role name]** (ロール名) に**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 バッチ操作ジョブの作成を開始するには、[**マニフェストからジョブを作成**] ボタンが有効になっていることを確認する必要があります。詳細については、「[S3 動画ソースバケットのインベントリレポートを確認します。](#batchops-s3-step5-manifest)」を参照してください。**マニフェストからジョブを作成** ボタンが無効になっている場合、最初のインベントリレポートは配信されておらず、ボタンが有効になるまで待つ必要があります。[ステップ 5](#batchops-s3-step5) で S3 ソースバケットの Amazon S3 インベントリを設定した後は、最初のインベントリレポートが配信されるまでに最大で 48 時間かかることがあります。
**Topics**
+ [S3 バッチオペレーションジョブを作成します。](#batchops-s3-step7-create-job)
+ [S3 バッチ操作ジョブを実行して Lambda 関数を呼び出します。](#batchops-s3-step7-run-job)
+ [(オプション) 完了レポートを確認する。](#batchops-s3-step7-check-report)
+ [(オプション) Lambda コンソールで各 Lambda 呼び出しをモニタリングする。](#batchops-s3-step7-monitor-lambda)
+ [(オプション)MediaConvert コンソールで各 MediaConvert 動画トランスコーディングジョブを監視する](#batchops-s3-step7-monitor-mediaconvert)
### S3 バッチオペレーションジョブを作成します。
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左のナビゲーションペインで、[**バッチ操作**] を選択します。
1. **[ジョブの作成]** を選択します。
1. **AWS リージョン** については、ジョブを作成する [Region (リージョン)] を選択します。
このチュートリアルで、S3 バッチ操作ジョブを使用して Lambda 関数を呼び出すには、マニフェストで参照されるオブジェクトがある S3 動画ソースバケットと同じリージョンにジョブを作成する必要があります。
1. **マニフェスト** セクションで、以下を実行します。
1. **Manifest format** (マニフェスト形式) で、**S3 inventory report (manifest.json)** を選択します。
1. **オブジェクトのマニフェスト** については、**Browse S3** を選択して、インベントリレポートを保存するために [ステップ 5](#batchops-s3-step5) で作成したバケットを見つけます (例、`amzn-s3-demo-destination-bucket2`)。**マニフェストオブジェクト** ページで、特定の日付の `manifest.json` ファイルが見つかるまで、オブジェクト名を検索します。このファイルには、バッチトランスコードするすべての動画に関する情報がリストされます。使用する `manifest.json` ファイルを見つけたら、横にあるオプションボタンを選択します。次に、[**パスの選択**] を選択します。
1. （オプション）[**マニフェストオブジェクトのバージョン ID-*オプション***] で、最新版以外のバージョンを使用する場合は、マニフェストオブジェクトのバージョン ID を入力します。
1. [**次へ**] を選択します。
1. Lambda 関数を使用して、選択した `manifest.json` ファイルリストされているすべてのオブジェクトをトランスコードするには、**オペレーションタイプ** で **AWS Lambda 関数を呼び出す** を選択します。
1. **Lambda 関数の呼び出し** ウィンドウで、次を実行します。
1. **Choose from functions in your account** (アカウントの関数を選択する) を選択します。
1. **Lambda 関数** で、[ステップ 4](#batchops-s3-step4) で作成した Lambda 関数を選択します (例、**tutorial-lambda-convert**)。
1. **Lambda 関数のバージョン** で、デフォルト値の **\$1LATEST** を維持します。
1. **Next** を選択します。**追加のオプションの設定** ページが開きます。
1. **追加のオプション** で、デフォルトの設定を維持します。
これらのパラメータの詳細については「[バッチ操作ジョブのリクエストの要素](batch-ops-create-job.md#batch-ops-create-job-request-elements)」を参照してください。
1. **完了レポート** セクションの **完了レポートの送信先へのパス** で、**S3 をブラウズ** を選択します。[ステップ 1](#batchops-s3-step1) で出力メディアファイル用に作成したバケットを見つけます (例、`amzn-s3-demo-destination-bucket1`)。バケット名の横にあるオプションボタンを選択します。次に、**パスの選択** を選択します。
残りの **完了レポート** 設定は、デフォルト値のままにしておきます。レポートの設定の完了に関する詳細については、「[バッチ操作ジョブのリクエストの要素](batch-ops-create-job.md#batch-ops-create-job-request-elements)」を参照してください。完了レポートには、ジョブの詳細と実行された操作のレコードが保持されます。
1. **許可** で、**既存の IAM ロールから選択する** を選択します。**IAM role** (IAM ロール) で、[ステップ 6](#batchops-s3-step6) (例、**tutorial-s3batch-role**) で作成した S3 バッチ操作ジョブの IAM ロールを選択します。
1. [**次へ**] を選択します。
1. **Review** ページで、設定を確認します。次に、**ジョブの作成** を選択します。
S3 が S3 バッチ操作のジョブのマニフェストの読み取りを終了すると、**実行のための確認待ち** の **ステータス** に移行します。ジョブのステータスの更新を表示するには、ページをリフレッシュします。ステータスが **実行のための確認待ち** になるまで、ジョブを実行することはできません。
### S3 バッチ操作ジョブを実行して Lambda 関数を呼び出します。
バッチ操作ジョブを実行して、動画トランスコーディング用の Lambda 関数を呼び出します。ジョブが失敗した場合は、完了レポートを確認して原因を特定できます。
**S3 バッチ操作ジョブを実行するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左のナビゲーションペインで、**バッチ操作** を選択します。
1. **ジョブ** のリストから、最初の行のジョブの **ジョブ ID** を選択します。これは、上記で作成した S3 バッチ操作ジョブです。
1. **[ジョブの実行]** を選択します。
1. ジョブパラメータをもう一度確認し、**Total objects listed in manifest** (マニフェストにリストされているオブジェクトの総数) の値がマニフェスト内のオブジェクトの数と同じであることを確認します。次に、**ジョブの実行** を選択します。
S3 バッチ操作ジョブページが開きます。
1. ジョブの実行が開始されたら、ジョブページの **Status** (ステータス) で、**Status** (ステータス)、**% Complete** (% 完了)、**Total succeeded (rate)** (成功合計) (レート)、**Total failed (rate)** (失敗合計) (レート)、**Date terminated** (終了日)、**Reason for termination** (終了理由) など、S3 バッチ操作ジョブの進行状況を確認します。
S3 バッチ操作ジョブが完了したら、ジョブページのデータを表示して、ジョブが期待どおりに完了したことを確認します。
1,000 を超える操作が試行された後、失敗が S3 バッチ操作ジョブのオブジェクト操作の 50% を超えると、ジョブは自動的に失敗します。完了レポートを確認して失敗の原因を特定するには、以下のオプション手順を参照してください。
### (オプション) 完了レポートを確認する。
完了レポートを使用して、失敗したオブジェクトと失敗の原因を特定できます。
**失敗したオブジェクトの詳細について完了レポートを確認するには**
1. S3 バッチ操作ジョブのページで、**完了レポート** までスクロールし、**完了レポートの宛先** のリンクを選択します。
S3 出力宛先バケットページが開きます。
1. **オブジェクト** タブで、上記で作成した S3 バッチ操作ジョブのジョブ ID で終わる名前のフォルダを選択します。
1. **results/** (結果/) を選択します。
1. `.csv` ファイルの横にあるチェックボックスを選択します。
1. ジョブレポートを表示するには、[**オープン**] または [**ダウンロード** ] を選択します。
### (オプション) Lambda コンソールで各 Lambda 呼び出しをモニタリングする。
S3 バッチ操作ジョブの実行が開始されると、ジョブは入力動画オブジェクトごとに Lambda 関数の呼び出しを開始します。S3 では、各 Lambda 呼び出しのログを CloudWatch Logs に書き込みます。Lambda コンソールのモニタリングダッシュボードを使用して、Lambda 関数とアプリケーションをモニタリングできます。
1. AWS Lambda コンソールの [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) を開いてください。
1. 左側のナビゲーションペインで、**[関数]** を選択します。
1. **関数** のリストから、[ステップ 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 マネジメントコンソール にサインインし、MediaConvert コンソール ([https://console.aws.amazon.com/mediaconvert/](https://console.aws.amazon.com/mediaconvert/)) を開きます。
1. MediaConvert 入門者向けページが表示される場合は、[**Get Started**] を選択します。
1. **ジョブ**のリストから、各行を表示して、各入力動画のトランスコーディングタスクを監視します。
1. チェックするジョブの行を特定し、**ジョブ ID** リンクを選択してジョブ詳細ページを開きます。
1. [**Job 概要**] ページの [**出力**] で、ブラウザでサポートされている内容に応じて、HLS、MP4、またはサムネイル出力のリンクを選択し、出力メディアファイルの S3 送信先バケットに移動します。
1. S3 出力先バケットの対応するフォルダ(HLS、MP4、またはサムネイル)で、出力メディアファイルオブジェクトの名前を選択します。
オブジェクトの詳細ページが開きます。
1. [**オブジェクトの概要**] のオブジェクトの詳細ページで、**オブジェクト URL** のリンクを選択して、トランスコードされた出力メディアファイルを監視します。
## ステップ 8: S3 宛先バケットから出力メディアファイルを確認する。
**S3 宛先バケットから出力メディアファイルを確認するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、**[バケット]** を選択します。
1. **バケット** のリストから、[ステップ 1](#batchops-s3-step1) で作成した出力メディアファイルの S3 宛先バケットの名前を選択します (例、`amzn-s3-demo-destination-bucket1`)。
1. [**オブジェクト**] タブで、各入力動画には、入力動画の名前を持つフォルダがあります。各フォルダには、入力動画のトランスコードされた出力メディアファイルが含まれています。
入力動画の出力メディアファイルを確認するには、次の操作を行います。
1. 確認したい入力動画の名前が入ったフォルダを選択します。
1. [**Default/** ] フォルダを選択します。
1. トランスコード形式 (HLS、MP4、またはこのチュートリアルではサムネイル) のフォルダを選択します。
1. 出力メディアファイルの名前を選択します。
1. トランスコードされたファイルを見るには、オブジェクト詳細ページで、**オブジェクト URL** の下のリンクを選択します。
HLS 形式の出力メディアファイルは、短いセグメントに分割されます。これらの動画を再生するには、互換性のあるプレーヤーに `.m3u8` ファイルのオブジェクト URL を埋め込む必要があります。
## ステップ 9: クリーンアップする。
S3 バッチ操作、Lambda、MediaConvert を学習演習としてのみ使用して動画をトランスコードした場合は、割り当てた AWS リ送信先を削除して、料金が発生しないようにします。
**Topics**
+ [S3 ソースバケットの S3 インベントリ設定を削除する。](#batchops-s3-step9-delete-inventory)
+ [Lambda 関数を削除する](#batchops-s3-step9-delete-lambda)
+ [CloudWatch Logs グループを削除する](#batchops-s3-step9-delete-cw)
+ [IAM ロールのインラインポリシーとともに IAM ロールを削除する](#batchops-s3-step9-delete-role)
+ [カスタマー管理の IAM ポリシーを削除する。](#batchops-s3-step9-delete-policy)
+ [S3 バケットを空にする](#batchops-s3-step9-empty-bucket)
+ [S3 バケットの削除](#batchops-s3-step9-delete-bucket)
### S3 ソースバケットの S3 インベントリ設定を削除する。
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、**[バケット]** を選択します。
1. **バケット**] リストで、送信先バケットの名前を選択します (例、`amzn-s3-demo-source-bucket`)。
1. **[管理]** タブを選択します。
1. [**インベントリ設定**] セクションで、[ステップ 5](#batchops-s3-step5) で作成したインベントリ設定の横のオプションボタンを選択します (例、**tutorial-inventory-config**)。
1. [**削除**]、[**確認**] の順に選択します。
### Lambda 関数を削除する
1.
AWS Lambda コンソールの [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) を開いてください。
1. 左側のナビゲーションペインで、**[関数]** を選択します。
1. [ステップ 4](#batchops-s3-step4) で作成した関数の横にあるチェックボックスを選択します (例、**tutorial-lambda-convert**)。
1. **[アクション]**、**[削除]** の順に選択します。
1. **[関数の削除]** ダイアログボックスで、**[削除]** を選択します。
### CloudWatch Logs グループを削除する
1. CloudWatch コンソールの [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) を開いてください。
1. 左のナビゲーションペインで、[**ログ**] 、[**ロググループ**] の順に選択します。
1. [ステップ 4](#batchops-s3-step4) で作成した Lambda 関数で終わる名前を持つロググループの横にあるチェックボックスを選択します (例、**tutorial-lambda-convert**)。
1. [**アクション**] を選択してから、[**ロググループの削除**] を選択します。
1. **[ロググループの削除]** ダイアログボックスで、**[削除]** をクリックします。
### IAM ロールのインラインポリシーとともに IAM ロールを削除する
[ステップ 2](#batchops-s3-step2)、[ステップ 3](#batchops-s3-step3)、および[ステップ 6](#batchops-s3-step6)] で作成した IAM ロールを削除するには、次の作業を行います。
1. AWS マネジメントコンソール にサインインして、IAM コンソール [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) を開きます。
1. ナビゲーションペインで、[**ロール**] を選択し、削除するロール名の隣にあるチェックボックスを選択します。
1. ページの上部で、[**削除**] を選択します。
1. 確認ダイアログボックスで、プロンプトに基づいてテキスト入力フィールドに必要な応答を入力し、[**削除**] を選択します。
### カスタマー管理の IAM ポリシーを削除する。
[ステップ 6](#batchops-s3-step6) で作成したカスタマー管理の IAM ポリシーを削除するには、次の作業を行います。
1. AWS マネジメントコンソール にサインインして、IAM コンソール [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) を開きます。
1. 左のナビゲーションペインの **[ポリシー]** を選択します。
1. [ステップ 6](#batchops-s3-step6) で作成したポリシーの横にあるオプションボタンを選択します (例、**tutorial-s3batch-policy**)。検索ボックスを使用して、グループのリストをフィルタリングできます。
1. **[アクション]**、**[削除]** の順に選択します。
1. テキストフィールドにポリシーの名前を入力して、このポリシーを削除することを確認し、[**削除**] を選択します。
### S3 バケットを空にする
[前提条件](#batchops-s3-prerequisites) 、[ステップ 1](#batchops-s3-step1)、および [ステップ 5](#batchops-s3-step5) で作成した S3 バケットを空にするには、次の作業を行います。
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、**[バケット]** を選択します。
1. [**バケット名**] リストで、空にするバケットの名前の横にあるバケットアイコンを選択し、[**バケットを空にする**] を選択します。
1. [**バケットを空にする**] ページで、テキストフィールドに **permanently delete** を入力することでバケットを空にすることを確定し、[**空にする**] を選択します。
### S3 バケットの削除
[前提条件](#batchops-s3-prerequisites) 、[ステップ 1](#batchops-s3-step1) および[ステップ 5](#batchops-s3-step5) で作成した S3 バケットを削除するには、次の作業を行います。
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、**[バケット]** を選択します。
1. [**バケット**] リストで、削除するバケット名の横にあるオプションボタンを選択します。
1. **[削除]** を選択します。
1. **[バケットの削除]** ページで、テキストフィールドにバケット名を入力することでバケットを削除することを確認し、**[バケットを削除]** を選択します。
## 次のステップ
このチュートリアルを完了すると、他の関連するユースケースをさらに詳しく調べることができます。
+ Amazon CloudFront を使用して、トランスコードされたメディアファイルを世界中のビューワーにストリーミングできます。詳細については、「[チュートリアル: Amazon S3、Amazon CloudFront、Amazon Route 53 を使用したオンデマンドストリーミング動画のホスティング。](tutorial-s3-cloudfront-route53-video-streaming.md)」を参照してください。
+ S3 ソースバケットにアップロードした時点で、動画をトランスコードできます。これを行うには、MediaConvert を使用して S3 の新しいオブジェクトをトランスコードするために、Lambda 関数を自動的に呼び出す Amazon S3 イベントトリガーを設定できます。詳細については、*AWS Lambdaデベロッパーガイド* の[チュートリアル: Amazon S3 トリガーを使用して Lambda 関数を呼び出す](https://docs.aws.amazon.com/lambda/latest/dg/with-s3-example.html) を参照してください。
# S3 バッチオペレーションのトラブルシューティング
Amazon S3 バッチオペレーションを使用すると、Amazon S3 のオブジェクトに対して大規模なオペレーションを実行できます。このガイドは、発生する可能性のある一般的な問題のトラブルシューティングに役立ちます。
S3 バッチレプリケーションに関する問題のトラブルシューティングについては、「[レプリケーションのトラブルシューティング](replication-troubleshoot.md)」を参照してください。
バッチオペレーションエラーが発生する障害には、主に 2 つのタイプがあります。
1. **API の失敗** – リクエストされた API (`CreateJob` など) の実行に失敗しました。
1. **ジョブの失敗** – 最初の API リクエストは成功しましたが、例えば、マニフェストの問題やマニフェストで指定されたオブジェクトへのアクセス許可が原因でジョブが失敗しました。
## NoSuchJobException
**タイプ:** API の失敗
`NoSuchJobException` は、S3 バッチオペレーションが指定されたジョブを見つけられない場合に発生します。このエラーは、単純なジョブの有効期限切れ以外にも、いくつかのシナリオで発生する可能性があります。一般的な原因には以下が含まれます。
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. **モニタリングの設定** – 90 日の有効期限が切れる前にジョブの完了を追跡する CloudWatch アラームを作成します。手順については、「Amazon CloudWatch ユーザーガイド」の「[Amazon CloudWatch でのアラームの使用](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html)」を参照してください。
1. **一貫したリージョンを使用する** – すべてのジョブオペレーションでジョブ作成と同じリージョンが使用されていることを確認します。
1. **入力の検証** – API コールを実行する前にジョブ ID 形式を確認します。
### ジョブの有効期限が切れたとき
終了状態のジョブは、90 日後に自動的に削除されます。ジョブ情報が失われないように、次の点を考慮してください。
1. **有効期限前に完了レポートをダウンロードする** – ジョブ結果の取得と保存の手順については、「[ 完了レポート ジョブを作成するときに、完了レポートをリクエストできます。S3 バッチオペレーションが少なくとも 1 つのタスクを正常に呼び出す限り、ジョブでタスクの実行が完了した後、失敗したとき、またはキャンセルされたときに、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 は通常、`12345678-1234-1234-1234-123456789012` のように 36 文字で構成されます。余分なスペース、欠落している文字、大文字と小文字の区別の問題をチェックし、`CreateJob` コマンドによって返される完全なジョブ ID を使用していることを確認します。
1. 次のコマンドを使用して、ジョブ作成イベントの CloudTrail ログを確認します。
```
aws logs filter-log-events --log-group-name CloudTrail/S3BatchOperations \ --filter-pattern "{ $.eventName = CreateJob }" \ --start-time timestamp
```
### AccessDeniedException
**タイプ:** API の失敗
`AccessDeniedException` は、アクセス許可の不足、サポートされていないオペレーション、またはポリシーの制限により S3 バッチオペレーションリクエストがブロックされた場合に発生します。これは、バッチオペレーションで最も一般的なエラーの 1 つです。これには次の一般的な原因があります。
1. **IAM アクセス許可がない** – IAM ID にバッチオペレーション 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 ユーザーガイドの「[AWS アカウント間の IAM ロールを使用したアクセスの委任](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html)」を参照してください。
1. **アクセス許可の変更を監視する** – バッチオペレーションに影響を与える可能性のある IAM ポリシーの変更に関する CloudTrail アラートを設定します。
1. **ドキュメントロールの要件** – 各ジョブタイプに必要なアクセス許可の明確なドキュメントを維持します。
1. **一般的なアクセス許可テンプレートを使用する** - アクセス許可の例とポリシーテンプレートを使用します。
1. [バッチオペレーションに対するアクセス許可の付与](batch-ops-iam-role-policies.md)
1. IAM ユーザーガイドの[IAM のクロスアカウントリソース](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html)。
1. AWS PrivateLink ガイドの[エンドポイントポリシーを使用して 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. 次のコマンドを使用して、リクエスト元の ID の IAM アクセス許可を確認します。ジョブを実行しているアカウントには、`s3:CreateJob`、`s3:DescribeJob`、`s3:ListJobs`、`s3:UpdateJobPriority`、`s3:UpdateJobStatus`、`iam:PassRole` のアクセス許可が必要です。
```
aws sts get-caller-identity 111122223333
```
1. 次のコマンドを使用して、ロールが存在し、引き受け可能であるかどうかを確認します。
```
aws iam get-role --role-name role-name
```
1. ロール用の信頼ポリシーを確認するには、次のコマンドを使用します。ジョブを実行するロールには、次のものが必要です。
1. 信頼関係により、`batchoperations.s3.amazonaws.com` はロールを引き受けることができます。
1. バッチオペレーションが実行しているオペレーション (タグ付けオペレーション `s3:PutObjectTagging` など)。
1. 送信元および送信先バケットへのアクセス。
1. マニフェストファイルを読み取るアクセス許可。
1. 完了レポートを書き込むアクセス許可。
```
aws iam get-role --role-name role-name --query 'Role.AssumeRolePolicyDocument'
```
1. 次のコマンドを使用して、マニフェストとソースバケットへのアクセスをテストします。
```
aws s3 ls s3://amzn-s3-demo-bucket
```
1. バッチオペレーションによって実行されるオペレーションをテストします。例えば、バッチオペレーションでタグ付けを実行する場合は、ソースバケットのサンプルオブジェクトにタグ付けします。
1. バケットポリシーで、オペレーションを拒否する可能性のあるポリシーを確認します。
1. レガシーアクセスコントロールを使用する場合はオブジェクトの ACL を確認します。
1. サービスコントロールポリシー (SCP) がオペレーションをブロックしていないことを確認します。
1. VPC エンドポイントを使用する場合は、VPC エンドポイントポリシーでバッチオペレーションが許可されていることを確認します。
1. CloudTrail を使用してアクセス許可の失敗を特定するには、次のコマンドを使用します。
```
aws logs filter-log-events --log-group-name CloudTrail/S3BatchOperations \
--filter-pattern "{ $.errorCode = AccessDenied }" \
--start-time timestamp
```
#### SlowDownError
**タイプ:** API の失敗
この `SlowDownError` 例外は、アカウントが S3 バッチオペレーション API のリクエストレート制限を超えた場合に発生します。これは、リクエストが多すぎてサービスが過負荷にならないようにするためのスロットリングメカニズムです。これには次の一般的な原因があります。
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. **ジッターでエクスポネンシャルバックオフを使用する** – 再試行の遅延をランダム化して、Thundering Herd 問題を回避します。
1. **適切な再試行ロジックを設定する** – 一時的なエラーに対して、遅延を徐々に増やしながら自動的に再試行する機能を実装します。
1. **イベント駆動型アーキテクチャを使用する** – ジョブステータスの変更に関して、ポーリングを EventBridge 通知に置き換えます。
1. **時間の経過とともに負荷を分散する** – ジョブの作成とステータスチェックを異なる時間帯で分散させます。
1. **レート制限のモニタリングとアラート** – CloudWatch アラームを設定して、制限に近づいていることを検出します。
ほとんどの AWS SDK には、レート制限エラーの再試行ロジックが組み込まれています。次のように設定します。
1. **AWS CLI** – `cli-read-timeout` および `cli-connect-timeout` パラメータを使用します。
1. **AWS SDK for Python (Boto3)** – クライアント設定で再試行モードと最大試行回数を設定します。
1. **AWS SDK for Java** – `RetryPolicy` と `ClientConfiguration` 設定を使用します。
1. **AWS SDK for JavaScript** – `maxRetries` と `retryDelayOptions` を設定します。
再試行パターンとベストプラクティスの詳細については、「AWS 規範ガイダンスガイド」の「[Retry with backoff pattern](https://docs.aws.amazon.com/prescriptive-guidance/latest/cloud-design-patterns/retry-backoff.html)」を参照してください。
#### SlowDownError のトラブルシューティング
1. コードで、エクスポネンシャルバックオフをすぐに実装します。
**Example bash でのエクスポネンシャルバックオフ**
```
for attempt in {1..5}; do
if aws s3control describe-job --account-id 111122223333 --job-id job-id; then
break
else
wait_time=$((2**attempt)) echo "Rate limited, waiting ${wait_time} seconds..." sleep $wait_time
fi
done
```
1. CloudTrail を使用して、リクエスト量が多いソースを特定します。
```
aws logs filter-log-events \
--log-group-name CloudTrail/S3BatchOperations \
--filter-pattern "{ $.eventName = CreateJob || $.eventName = DescribeJob }" \
--start-time timestamp \
--query 'events[*].[eventTime,sourceIPAddress,userIdentity.type,eventName]'
```
1. ポーリングの頻度を確認します。
1. アクティブなジョブについては、30 秒に 1 回以上ジョブのステータスをチェックしないようにします。
1. 可能な場合はポーリングの代わりにジョブ完了通知を使用します。
1. 同期したリクエストを避けるために、ポーリング間隔にジッターを実装します。
1. API の使用パターンを最適化します。
1. 可能な場合は、複数のオペレーションをバッチ処理します。
1. `ListJobs` を使用して、1 回の呼び出しで複数のジョブのステータスを取得します。
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
**タイプ:** ジョブの失敗
この `InvalidManifestContent` 例外は、マニフェストファイルの形式、内容、または構造に問題があり、S3 バッチオペレーションがジョブを処理できない場合に発生します。これには次の一般的な原因があります。
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. **オブジェクトキーの特殊文字** – スペース、Unicode 文字、または XML 特殊文字 (<、>、&、"、') を含む URL エンコードオブジェクトキー。
1. **大きなマニフェストファイル** – オペレーション制限を超えるマニフェストを複数の小さなマニフェストに分割し、個別のジョブを作成します。
1. **無効なバージョン ID** – バージョン ID が正しくフォーマットされた英数字の文字列であることを確認します。不要な場合はバージョン ID 列を削除します。
1. **エンコードの問題** – マニフェストファイルを BOM なし UTF-8 として保存します。エンコードを変更する可能性のあるシステムを介してマニフェストをコピーすることは避けてください。
マニフェスト形式の仕様と例の詳細については、以下を参照してください。
1. [マニフェストの指定](batch-ops-create-job.md#specify-batchjob-manifest)
1. [S3 バッチ操作でサポートされるオペレーション](batch-ops-operations.md)
1. [Amazon S3 オブジェクトに命名する](object-keys.md)
### InvalidManifestContent のトラブルシューティング
1. マニフェストファイルをダウンロードして内容を確認します。マニフェストが形式要件を満たしていることを手動で確認します。
1. カンマ区切り文字を含む CSV 形式。
1. BOM なし UTF-8 エンコーディング。
1. すべての行で一貫した列数。
1. 空の行や末尾のスペースは含めません。
1. オブジェクトキーに特殊文字が含まれている場合、適切に URL エンコードされます。
次のコマンドを使用して、マニフェストファイルをダウンロードします。
```
aws s3 cp s3://amzn-s3-demo-bucket1/manifest-key ./manifest.csv
```
1. オペレーションに必要な列を確認します。
1. すべてのオペレーション: `Bucket`、`Key`
1. コピーオペレーション: `VersionId` (オプション)
1. 復元オペレーション: `VersionId` (オプション)
1. タグの置換オペレーション: 追加の列は必要ありません。
1. ACL の置換オペレーション: 追加の列は必要ありません。
1. 復元の開始: `VersionId` (オプション)
1. オブジェクト数の制限を確認します。
1. コピー: 最大 10 億個のオブジェクト。
1. 削除: 最大 10 億個のオブジェクト。
1. 復元: 最大 10 億個のオブジェクト。
1. タグ付け: 最大 10 億個のオブジェクト。
1. ACL: 最大 10 億個のオブジェクト。
1. 元のマニフェストからいくつかのオブジェクトを含むテストマニフェストを作成します。
1. マニフェストからのオブジェクトのサンプルが存在するかどうかを確認する場合は、次のコマンドを使用します。
```
aws s3 ls s3://amzn-s3-demo-bucket1/object-key
```
1. ジョブの失敗の詳細を確認し、ジョブの説明で失敗の理由と特定のエラーの詳細を確認します。
```
aws s3control describe-job --account-id 111122223333 --job-id job-id
```