# S3 Object Lambda を使用したオブジェクトの変換
**注記**
2025 年 11 月 7 日現在、S3 Object Lambda は、現在サービスを使用している既存のお客様、および一部の AWS パートナーネットワーク (APN) パートナーのみが利用できます。S3 Object Lambda と同様の機能の詳細については、「[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)」を参照してください。
Amazon S3 Object Lambda を使用すると、Amazon S3 `GET`、`LIST`、`HEAD` リクエストに独自のコードを追加して、データがアプリケーションに返されるときにそのデータを変更および処理できます。カスタムコードを使用すると、S3 `GET` リクエストによって返されるデータを変更し、行のフィルタリング、画像の動的なサイズ変更と透かし、機密データの編集などを行うことができます。また、S3 Object Lambda を使用して、バケット内のすべてのオブジェクトのカスタムビューを作成する S3 `LIST` リクエストの出力や、オブジェクト名やサイズなどのオブジェクトメタデータを変更する S3 `HEAD` リクエストの出力を変更することもできます。S3 Object Lambda を Amazon CloudFront ディストリビューションのオリジンとして使用して、画像の自動サイズ変更、古い形式 (JPEG から WebP など) のトランスコーディング、メタデータの削除など、エンドユーザー向けにデータを調整できます。詳細については、AWS ブログの「[Use Amazon S3 Object Lambda with Amazon CloudFront](https://aws.amazon.com/blogs/aws/new-use-amazon-s3-object-lambda-with-amazon-cloudfront-to-tailor-content-for-end-users/)」(Amazon S3 Object Lambda を Amazon CloudFront で使用する) を参照してください。AWS Lambda 関数を利用しているため、コードは AWS によって完全に管理されたインフラストラクチャ上で実行されます。S3 Object Lambda を使用すると、データの派生コピーを作成して保存したり、プロキシを実行したりする必要が少なくなり、アプリケーションに変更を加える必要もなくなります。
**S3 オブジェクト Lambda の仕組み**
S3 Object Lambda は AWS Lambda 関数を使用して、標準の S3 `GET`、`LIST`、`HEAD` リクエストの出力を自動的に処理します。AWS Lambda は、基盤となるコンピューティングリソースの管理を必要とせずに、顧客定義のコードを実行するサーバーレスコンピューティングサービスです。データ変換を特定のユースケースに合わせて調整し、独自のカスタム Lambda 関数を作成して実行することができます。
Lambda 関数を設定したら、*Object Lambda アクセスポイント*と呼ばれる S3 Object Lambda サービスエンドポイントにアタッチします。Object Lambda アクセスポイントは、*サポートアクセスポイント*と呼ばれる、標準の S3 アクセスポイントを使用してデータにアクセスします。
Object Lambda アクセスポイントにリクエストを送信すると、Amazon S3 は自動的に Lambda 関数を呼び出します。その後、S3 Object Lambda アクセスポイントを介して S3 `GET`、`LIST`、または `HEAD` リクエストを使用して取得されたデータは、変換された結果をアプリケーションに返します。次の図に示すように、他のすべてのリクエストは通常どおりに処理されます。
![\[S3 Object Lambda の仕組みを説明する図\]](http://docs.aws.amazon.com/ja_jp/AmazonS3/latest/userguide/images/ObjectLamdaDiagram.png)
このセクションのトピックでは、S3 Object Lambda の使用方法について説明します。
**Topics**
+ [Object Lambda アクセスポイントの作成](olap-create.md)
+ [Amazon S3 Object Lambda アクセスポイントの使用](olap-use.md)
+ [S3 Object Lambda アクセスポイントのセキュリティに関する考慮事項](olap-security.md)
+ [S3 Object Lambda アクセスポイントの Lambda 関数の記述](olap-writing-lambda.md)
+ [AWS で構築された Lambda 関数の使用](olap-examples.md)
+ [S3 Object Lambda のベストプラクティスとガイドライン](olap-best-practices.md)
+ [S3 Object Lambda のチュートリアル](olap-tutorials.md)
+ [S3 Object Lambda のデバッグとトラブルシューティング](olap-debugging-lambda.md)
# Object Lambda アクセスポイントの作成
**注記**
2025 年 11 月 7 日現在、S3 Object Lambda は、現在サービスを使用している既存のお客様、および一部の AWS パートナーネットワーク (APN) パートナーのみが利用できます。S3 Object Lambda と同様の機能の詳細については、「[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)」を参照してください。
Object Lambda アクセスポイントは、作成時に指定した 1 つの標準アクセスポイントにのみ関連付けられます。Object Lambda アクセスポイントを作成するには、次のリソースが必要です。
+ **標準 S3 アクセスポイント。**Object Lambda アクセスポイントを使用する場合、この標準アクセスポイントは*サポートアクセスポイント*と呼ばれ、S3 バケットまたは Amazon FSx for OpenZFS ボリュームにアタッチされます。標準アクセスポイントの作成については、「[アクセスポイントの作成](creating-access-points.md)」を参照してください。
+ **AWS Lambda 関数。**独自の Lambda 関数を作成することも、事前に構築された関数を使用することもできます。Lambda 関数の詳細については、「[S3 Object Lambda アクセスポイントの Lambda 関数の記述](olap-writing-lambda.md)」を参照してください。事前構築された関数の詳細については、「[AWS で構築された Lambda 関数の使用](olap-examples.md)」を参照してください。
+ **(オプション) AWS Identity and Access Management (IAM) ポリシー。**Amazon S3 アクセスポイントは IAM リソースポリシーをサポートしています。これにより、リソース、ユーザー、またはその他の条件別にアクセスポイントの使用を制御できます。これらのポリシーの作成の詳細については、「[Object Lambda アクセスポイントの IAM ポリシーの設定](olap-policies.md)」を参照してください。
以下のセクションでは、下記を使用して Object Lambda アクセスポイントを作成する方法について説明します。
+ AWS マネジメントコンソール
+ AWS Command Line Interface (AWS CLI)
+ AWS CloudFormation テンプレート
+ AWS Cloud Development Kit (AWS CDK)
REST API を使用して Object Lambda アクセスポイントを作成する方法については、*Amazon Simple Storage Service API リファレンス*の「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateAccessPointForObjectLambda.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateAccessPointForObjectLambda.html)」を参照してください。
## Object Lambda アクセスポイントの作成
次のいずれかの手順に従って Object Lambda アクセスポイントを作成します。
### S3 コンソールの使用
**コンソールを使用して Object Lambda のアクセスポイントを作成するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. ナビゲーションバーで、現在表示されている AWS リージョン の名前をクリックします。次に、切り替え先のリージョンを選択します。
1. 左のナビゲーションペインで、[**Object Lambda アクセスポイント**] を選択します。
1. [**Object Lambda アクセスポイント**] ページで、[**Object Lambda アクセスポイントの作成**] を選択します。
1. **[Object Lambda Access Point name]** (Object Lambda アクセスポイント名) に、アクセスポイントに使用する名前を入力します。
標準のアクセスポイントと同様に、Object Lambda には命名規則があります。詳細については、「[アクセスポイントの命名規則](access-points-restrictions-limitations-naming-rules.md#access-points-names)」を参照してください。
1. **[Supporting Access Point]** (サポートアクセスポイント) で、使用する標準アクセスポイントを入力または参照します。アクセスポイントは、変換するオブジェクトと同じ AWS リージョン に存在する必要があります。標準アクセスポイントの作成については、「[アクセスポイントの作成](creating-access-points.md)」を参照してください。
1. **[変換の設定]** で、Object Lambda アクセスポイントのデータを変換する関数を追加できます。次のいずれかを行います。
+ アカウントに既に AWS Lambda 関数がある場合は、**[Invoke Lambda function]** (Lambda 関数の呼び出し) で選択できます。ここで、AWS アカウント で Lambda 関数の Amazon リソースネーム (ARN) を入力するか、ドロップダウンメニューから Lambda 関数を選択できます。
+ AWS で構築された関数を使用する場合は、**[AWS で構築された関数]** で関数名を選択し、**[Lambda 関数を作成]** を選択します。これにより Lambda コンソールが表示され、そこで構築した関数を AWS アカウント にデプロイできます。構築した関数の詳細については、「[AWS で構築された Lambda 関数の使用](olap-examples.md)」を参照してください。
**[S3 APIs]** で、呼び出す API オペレーションを 1 つ以上選択します。選択した各 API に対して、呼び出す Lambda 関数を指定する必要があります。
1. (オプション) **[Payload]** (ペイロード) に、入力として Lambda 関数に提供する JSON テキストを追加します。同じ Lambda 関数を呼び出す異なる Object Lambda アクセスポイントに対して、異なるパラメータを使用してペイロードを設定できます。これにより、Lambda 関数の柔軟性が向上します。
**重要**
Object Lambda アクセスポイントを使用する場合、ペイロードには機密情報を一切含めないでください。
1. (オプション) **[Range and part number]** (範囲とパート番号) では、範囲とパート番号ヘッダーで `GET` および `HEAD` リクエストを処理するには、このオプションを有効にする必要があります。このオプションを有効にすると、Lambda 関数がこれらのリクエストを認識して処理できることが確認されます。範囲ヘッダーとパート番号の詳細については、[Range および partNumber ヘッダーの操作](range-get-olap.md) を参照してください。
1. (オプション) **[リクエストのメトリクス]** で、**[有効化]** または **[無効化]** を選択して、Amazon S3 モニタリングを Object Lambda アクセスポイントに追加します。リクエストメトリクスには、Amazon CloudWatch の標準料金が課金されます。
1. (オプション) **[Object Lambda Access Point policy]** (Object Lambda アクセスポイントポリシー) で、リソースポリシーを設定します。リソースポリシーは、指定された Object Lambda アクセスポイントにアクセス許可を付与し、リソース、ユーザー、その他の条件別にアクセスポイントの使用を制御します。Object Lambda アクセスポイントのリソースポリシーの詳細については、「[Object Lambda アクセスポイントの IAM ポリシーの設定](olap-policies.md)」を参照してください。
1. **[Block Public Access settings for this Object Lambda Access Point]** (この Object Lambda アクセスポイントのパブリックアクセス設定をブロック) で、適用するパブリックアクセスブロック設定を選択します。新しい Object Lambda アクセスポイントでは、すべてのパブリックアクセスブロック設定がデフォルトで有効になります。デフォルトの設定のままにしておくことをお勧めします。Amazon S3 は、現在、Object Lambda アクセスポイントの作成後における Object Lambda アクセスポイントのパブリックアクセスブロック設定の変更をサポートしていません。
Amazon S3 パブリックアクセスブロックの詳細については、「[汎用バケットのアクセスポイントへのパブリックアクセスの管理](access-points-bpa-settings.md)」を参照してください。
1. **[Create Object Lambda Access Point]** (Object Lambda アクセスポイントの作成) を選択します。
### の使用AWS CLI
**AWS CloudFormation テンプレートを使用して Object Lambda アクセスポイントを作成するには**
**注記**
次のコマンドを使用するには、`user input placeholders` をユーザー自身の情報に置き換えます。
1. [S3 Object Lambda のデフォルト設定](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration)で、AWS Lambda 関数デプロイパッケージ `s3objectlambda_deployment_package.zip` をダウンロードします。
1. 次の `put-object` コマンドを実行して、Amazon S3 バケットにパッケージをアップロードします。
```
aws s3api put-object --bucket Amazon S3 bucket name --key s3objectlambda_deployment_package.zip --body release/s3objectlambda_deployment_package.zip
```
1. [S3 Object Lambda のデフォルト設定](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration)で AWS CloudFormation テンプレート `s3objectlambda_defaultconfig.yaml` をダウンロードします。
1. 次の `deploy` コマンドを実行して、テンプレートを AWS アカウント にデプロイします。
```
aws cloudformation deploy --template-file s3objectlambda_defaultconfig.yaml \
--stack-name CloudFormation stack name \
--parameter-overrides ObjectLambdaAccessPointName=Object Lambda Access Point name \
SupportingAccessPointName=Amazon S3 access point S3BucketName=Amazon S3 bucket \
LambdaFunctionS3BucketName=Amazon S3 bucket containing your Lambda package \
LambdaFunctionS3Key=Lambda object key LambdaFunctionS3ObjectVersion=Lambda object version \
LambdaFunctionRuntime=Lambda function runtime --capabilities capability_IAM
```
`GET`、`HEAD`、および `LIST` API オペレーションで Lambda を呼び出すようにこの AWS CloudFormation テンプレートを設定できます。テンプレートのデフォルト設定の変更の詳細については、「[CloudFormation テンプレートを使用して S3 Object Lambda のセットアップを自動化する](olap-using-cfn-template.md)」を参照してください。
**AWS CLI を使用して Object Lambda アクセスポイントを作成するには**
**注記**
次のコマンドを使用するには、`user input placeholders` をユーザー自身の情報に置き換えます。
以下の例では、アカウント *`111122223333`* のバケット *`amzn-s3-demo-bucket1`* に「*`my-object-lambda-ap`*」という名前の Object Lambda アクセスポイントを作成します。この例では、「*`example-ap`*」という名前の標準アクセスポイントが既に作成されていることを前提としています。標準アクセスポイントの作成については、[アクセスポイントの作成](creating-access-points.md) を参照してください。
この例では、AWS の事前構築された関数 `decompress` を使用しています。事前構築された関数の詳細については、「[AWS で構築された Lambda 関数の使用](olap-examples.md)」を参照してください。
1. バケットを作成します。この例では、*`amzn-s3-demo-bucket1`* を使用します。バケットの作成については、「[汎用バケットの作成](create-bucket-overview.md)」を参照してください。
1. 標準アクセスポイントを作成し、バケットにアタッチします。この例では、*`example-ap`* を使用します。標準アクセスポイントの作成については、「[アクセスポイントの作成](creating-access-points.md)」を参照してください。
1. 次のいずれかを行います。
+ Amazon S3 オブジェクトの変換に使用する Lambda 関数をアカウント内に作成します。Lambda 関数の詳細については、「[S3 Object Lambda アクセスポイントの Lambda 関数の記述](olap-writing-lambda.md)」を参照してください。AWS CLI でカスタム関数を使用するには、「*AWS Lambda 開発者ガイド*」の「[AWS CLI での Lambda の使用](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-awscli.html)」を参照してください。
+ AWS の事前構築された Lambda 関数を使用します。事前構築された関数の詳細については、「[AWS で構築された Lambda 関数の使用](olap-examples.md)」を参照してください。
1. `my-olap-configuration.json` という名前の JSON 設定ファイルを作成します。この設定では、前のステップで作成した Lambda 関数のサポートアクセスポイントと Amazon リソースネーム (ARN)、または使用している事前構築された関数の ARN を指定します。
**Example**
```
{
"SupportingAccessPoint" : "arn:aws:s3:us-east-1:111122223333:accesspoint/example-ap",
"TransformationConfigurations": [{
"Actions" : ["GetObject", "HeadObject", "ListObjects", "ListObjectsV2"],
"ContentTransformation" : {
"AwsLambda": {
"FunctionPayload" : "{\"compressionType\":\"gzip\"}",
"FunctionArn" : "arn:aws:lambda:us-east-1:111122223333:function/compress"
}
}
}]
}
```
1. `create-access-point-for-object-lambda` コマンドを実行して Object Lambda アクセスポイントを作成します。
```
aws s3control create-access-point-for-object-lambda --account-id 111122223333 --name my-object-lambda-ap --configuration file://my-olap-configuration.json
```
1. (オプション) `my-olap-policy.json` という名前の JSON ポリシーファイルを作成します。
Object Lambda アクセスポイントのリソースポリシーを追加することで、リソース、ユーザー、その他の条件別にアクセスポイントの使用を制御することができます。このリソースポリシーは、アカウント *`444455556666`* に指定された Object Lambda アクセスポイントへの `GetObject` 許可を付与します。
**Example**
```
{
"Version": "2008-10-17",
"Statement": [
{
"Sid": "Grant account 444455556666 GetObject access",
"Effect": "Allow",
"Action": "s3-object-lambda:GetObject",
"Principal": {
"AWS": "arn:aws:iam::444455556666:root"
},
"Resource": "your-object-lambda-access-point-arn"
}
]
}
```
1. (オプション) `put-access-point-policy-for-object-lambda` コマンドを実行して、リソースポリシーを設定します。
```
aws s3control put-access-point-policy-for-object-lambda --account-id 111122223333 --name my-object-lambda-ap --policy file://my-olap-policy.json
```
1. (オプション) ペイロードを規定します。
ペイロードは、AWS Lambda 関数に入力として提供できるオプションの JSON です。同じ Lambda 関数を呼び出す異なる Object Lambda アクセスポイントに対して、異なるパラメータを使用してペイロードを設定できます。これにより、Lambda 関数の柔軟性が向上します。
次の Object Lambda アクセスポイントの設定は、2 つのパラメータを持つペイロードを示しています。
```
{
"SupportingAccessPoint": "AccessPointArn",
"CloudWatchMetricsEnabled": false,
"TransformationConfigurations": [{
"Actions": ["GetObject", "HeadObject", "ListObjects", "ListObjectsV2"],
"ContentTransformation": {
"AwsLambda": {
"FunctionArn": "FunctionArn",
"FunctionPayload": "{\"res-x\": \"100\",\"res-y\": \"100\"}"
}
}
}]
}
```
次の Object Lambda アクセスポイント設定は、パラメータが 1 つあり、`GetObject-Range`、`GetObject-PartNumber`、`HeadObject-Range`、および `HeadObject-PartNumber` が有効になっているペイロードを示しています。
```
{
"SupportingAccessPoint":"AccessPointArn",
"CloudWatchMetricsEnabled": false,
"AllowedFeatures": ["GetObject-Range", "GetObject-PartNumber", "HeadObject-Range", "HeadObject-PartNumber"],
"TransformationConfigurations": [{
"Action": ["GetObject", "HeadObject", "ListObjects", "ListObjectsV2"],
"ContentTransformation": {
"AwsLambda": {
"FunctionArn":"FunctionArn",
"FunctionPayload": "{\"compression-amount\": \"5\"}"
}
}
}]
}
```
**重要**
Object Lambda アクセスポイントを使用する場合、ペイロードには機密情報を一切含めないでください。
### AWS CloudFormation コンソールとテンプレートの使用。
Amazon S3 が提供するデフォルト設定を使用して、Object Lambda アクセスポイントを作成できます。[GitHub リポジトリ](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration) から AWS CloudFormation テンプレートと Lambda 関数のソースコードのリソースをダウンロードして、これらのリソースをデプロイして、Object Lambda アクセスポイントを設定します。
AWS CloudFormation テンプレートのデフォルト設定の変更の詳細については、「[CloudFormation テンプレートを使用して S3 Object Lambda のセットアップを自動化する](olap-using-cfn-template.md)」を参照してください。
テンプレートなしで CloudFormation を使用する Object Lambda アクセスポイントの設定の詳細については、*AWS CloudFormation ユーザーガイド*の「[https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-s3objectlambda-accesspoint.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-s3objectlambda-accesspoint.html)」を参照してください。
**Lambda 関数のデプロイパッケージをアップロードします**
1. [S3 Object Lambda のデフォルト設定](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration)で、AWS Lambda 関数デプロイパッケージ `s3objectlambda_deployment_package.zip` をダウンロードします。
1. Amazon S3 バケットにパッケージをアップロードします。
**AWS CloudFormation コンソールを使用して Object Lambda のアクセスポイントを作成するには**
1. [S3 Object Lambda のデフォルト設定](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration)で AWS CloudFormation テンプレート `s3objectlambda_defaultconfig.yaml` をダウンロードします。
1. AWS マネジメントコンソール にサインインした後、[https://console.aws.amazon.com/cloudformation/](https://console.aws.amazon.com/cloudformation/) で AWS CloudFormation コンソールを開きます。
1. 次のいずれかを行います。
+ AWS CloudFormation を初めて使用する場合は、AWS CloudFormation ホームページで **[Create stack]** (スタックの作成) を選択します。
+ 以前に AWS CloudFormation を使用したことがある場合は、左側のナビゲーションペインで **[Stacks]** (スタック) を選択します。**[Create stack]** (スタックの作成) を選択し、**[With new resources (standard)]** (新しいリソースを使用 (標準)) を選択します。
1. **前提条件 − テンプレートの準備**で、**テンプレートの準備完了**を選択します。
1. **[Specify template]** (テンプレートの指定) で、**[Upload a template file]** (テンプレートファイルのアップロード) を選択して `s3objectlambda_defaultconfig.yaml` をアップロードします。
1. [**次へ**] を選択します。
1. **スタックの詳細の指定**ページで、スタックの名前を入力します。
1. **[Parameters]** (パラメータ) セクションで、スタックテンプレートで定義されている次のパラメータを指定します。
1. **[CreateNewSupportingAccessPoint]** では、次のいずれかを実行します。
+ テンプレートをアップロードした S3 バケット用のサポートアクセスポイントが既にある場合は、**[false]** を選択します。
+ このバケット用に新しいアクセスポイントを作成する場合は、**[true]** を選択します。
1. **[EnableCloudWatchMonitoring]** では、Amazon CloudWatch リクエストメトリクスとアラームを有効にするかどうかに応じて、**[true]** または **[false]** を選択します。
1. (オプション) **[LambdaFunctionPayload]** に、入力として Lambda 関数に提供する JSON テキストを追加します。同じ Lambda 関数を呼び出す異なる Object Lambda アクセスポイントに対して、異なるパラメータを使用してペイロードを設定できます。これにより、Lambda 関数の柔軟性が向上します。
**重要**
Object Lambda アクセスポイントを使用する場合、ペイロードには機密情報を一切含めないでください。
1. **[LambdaFunctionRuntime]** で、Lambda 関数に希望するランタイムを入力します。使用可能な選択は次のとおりです。`nodejs14.x`、`python3.9`、`java11`。
1. **[LambdaFunctionS3BucketName]** で、デプロイパッケージをアップロードした Amazon S3 バケット名を入力します。
1. **[LambdaFunctionS3Key]** で、デプロイパッケージをアップロードした Amazon S3 オブジェクトキーを入力します。
1. **[LambdaFunctionS3ObjectVersion]** で、デプロイパッケージをアップロードした Amazon S3 オブジェクトバージョンを入力します。
1. **[ObjectLambdaAccessPointName]** で、Object Lambda アクセスポイント名を入力します。
1. **[S3BucketName]** で、Object Lambda アクセスポイントと関連付けられる Amazon S3 のバケット名を入力します。
1. **[SupportingAccessPointName]** で、サポートアクセスポイント名を入力します。
**注記**
これは前のステップで選択した Amazon S3 バケットに関連付けられたアクセスポイントです。Amazon S3 バケットに関連付けられているアクセスポイントがない場合は、**[CreateNewSupportingAccessPoint]** で **[true]** を選択すると、テンプレートを作成するようにテンプレートを構成できます。
1. [**次へ**] を選択します。
1. **[スタックオプションの設定]** ページで、**[次へ]** を選択します。
このページのオプション設定の詳細については、「*AWS CloudFormation ユーザーガイド*」の「[AWS CloudFormation スタックオプションの設定](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-add-tags.html)」を参照してください。
1. **[確認]** ページで **[スタックの作成]** を選択します。
### の使用AWS Cloud Development Kit (AWS CDK)
AWS CDK を使用した Object Lambda アクセスポイントの設定の詳細については、*AWS Cloud Development Kit (AWS CDK) API リファレンス*の「[`AWS::S3ObjectLambda` Construct Library](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-s3objectlambda-readme.html)」を参照してください。
# CloudFormation テンプレートを使用して S3 Object Lambda のセットアップを自動化する
**注記**
2025 年 11 月 7 日現在、S3 Object Lambda は、現在サービスを使用している既存のお客様、および一部の AWS パートナーネットワーク (APN) パートナーのみが利用できます。S3 Object Lambda と同様の機能の詳細については、「[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)」を参照してください。
AWS CloudFormation テンプレートを使用すると、Amazon S3 Object Lambda アクセスポイントをすばやく作成できます。CloudFormation テンプレートは、関連するリソースを自動的に作成し、AWS Identity and Access Management (IAM) ロールを設定し、Object Lambda アクセスポイントを介してリクエストを自動的に処理する AWS Lambda 関数を設定します。CloudFormation テンプレートでベストプラクティスを実装し、セキュリティ体制を改善し、マニュアルプロセスによって引き起こされるエラーを減らすことができます。
この [GitHub リポジトリ](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration)には、CloudFormation テンプレートと Lambda 関数のソースコードが含まれています。テンプレートの使用方法については、「[Object Lambda アクセスポイントの作成](olap-create.md)」を参照してください。
テンプレートで提供される Lambda 関数が変換を実行することはありません。代わりに、基盤となるデータソースからオブジェクトをそのまま返します。関数をクローン化し、独自の変換コードを追加して、データがアプリケーションに返されるときに変更および処理できます。関数の変更の詳細については、「[Lambda 関数の変更](#modifying-lambda-function)」と「[S3 Object Lambda アクセスポイントの Lambda 関数の記述](olap-writing-lambda.md)」を参照してください。
## テンプレートの変更
**新しいサポートアクセスポイントの作成**
S3 Object Lambda は、Object Lambda アクセスポイントと、*サポートアクセスポイント*と呼ばれる、標準の S3 アクセスポイントの 2 つのアクセスポイントを使用します。Object Lambda アクセスポイントにリクエストを行うと、S3 は S3 Object Lambda の設定に応じて、ユーザーに代わって Lambda を呼び出すか、サポートアクセスポイントにリクエストを委任します。テンプレートのデプロイ時に、`aws cloudformation deploy` コマンドの一部として次のパラメータを渡すことにより、新しいサポートアクセスポイントを作成できます。
```
CreateNewSupportingAccessPoint=true
```
**関数ペイロードの設定。**
テンプレートをデプロイするときに `aws cloudformation deploy` コマンドの一部として、次のパラメータを渡すことにより、Lambda 関数に補足データを提供するようにペイロードを設定できます。
```
LambdaFunctionPayload="format=json"
```
**Amazon CloudWatch モニタリングを有効にします。**
テンプレートをデプロイするときに `aws cloudformation deploy` コマンドの一部として<次のパラメータを渡すことで、CloudWatch モニタリングを有効にできます。
```
EnableCloudWatchMonitoring=true
```
このパラメータにより、Amazon S3 リクエストメトリクスの Object Lambda アクセスポイントが有効になり、クライアント側とサーバー側のエラーをモニタリングする 2 つの CloudWatch アラームが作成されます。
**注記**
Amazon CloudWatch の使用には追加コストが発生します。Amazon S3 リクエストメトリクスの詳細については、「[アクセスポイントのモニタリングとログ記録](access-points-monitoring-logging.md)」を参照してください。
料金表については、「[CloudWatch 料金表](https://aws.amazon.com/cloudwatch/pricing/)」を参照してください。
**プロビジョニング済み同時実行の設定**
レイテンシーを低減するために、Object Lambda アクセスポイントをサポートする Lambda 関数にプロビジョニングされた同時実行を設定するには、テンプレートを編集して、`Resources` の以下の行を含めます。
```
LambdaFunctionVersion:
Type: AWS::Lambda::Version
Properties:
FunctionName: !Ref LambdaFunction
ProvisionedConcurrencyConfig:
ProvisionedConcurrentExecutions: Integer
```
**注記**
同時実行のプロビジョニングには追加料金が発生します。プロビジョニングされた同時実行の詳細については、「*AWS Lambda デベロッパーガイド*」の「[Lambda プロビジョニング済み同時実行数の管理](https://docs.aws.amazon.com/lambda/latest/dg/provisioned-concurrency.html)」を参照してください。
料金の詳細については、「[AWS Lambda の料金](https://aws.amazon.com/lambda/pricing/)」を参照してください。
## Lambda 関数の変更
**`GetObject` リクエストのヘッダー値の変更**
デフォルトでは、Lambda 関数は `Content-Length` と `ETag` を除くすべてのヘッダーを、署名付き URL リクエストから `GetObject` クライアントに転送します。Lambda 関数の変換コードに基づいて、新しいヘッダー値を `GetObject` クライアントに送信を選択できます。
Lambda 関数を更新して、新しいヘッダー値を `WriteGetObjectResponse` API オペレーションで渡すことで送信できます。
例えば、Lambda 関数が Amazon S3 オブジェクトのテキストを別の言語に変換する場合、`Content-Language` ヘッダーに新しい値を渡すことができます。これを行うには、以下のように `writeResponse` 関数を変更します。
```
async function writeResponse (s3Client: S3, requestContext: GetObjectContext, transformedObject: Buffer,
headers: Headers): Promise> {
const { algorithm, digest } = getChecksum(transformedObject);
return s3Client.writeGetObjectResponse({
RequestRoute: requestContext.outputRoute,
RequestToken: requestContext.outputToken,
Body: transformedObject,
Metadata: {
'body-checksum-algorithm': algorithm,
'body-checksum-digest': digest
},
...headers,
ContentLanguage: 'my-new-language'
}).promise();
}
```
サポートされているヘッダーの完全なリストについては、*Amazon Simple Storage Service API リファレンス*の [https://docs.aws.amazon.com/AmazonS3/latest/API/API_WriteGetObjectResponse.html#API_WriteGetObjectResponse_RequestSyntax](https://docs.aws.amazon.com/AmazonS3/latest/API/API_WriteGetObjectResponse.html#API_WriteGetObjectResponse_RequestSyntax) を参照してください。
**メタデータヘッダーを返します。**
Lambda 関数を更新して、新しいヘッダー値を [https://docs.aws.amazon.com/AmazonS3/latest/API/API_WriteGetObjectResponse.html#API_WriteGetObjectResponse_RequestSyntax](https://docs.aws.amazon.com/AmazonS3/latest/API/API_WriteGetObjectResponse.html#API_WriteGetObjectResponse_RequestSyntax) API オペレーションリクエストで渡すことで送信できます。
```
async function writeResponse (s3Client: S3, requestContext: GetObjectContext, transformedObject: Buffer,
headers: Headers): Promise> {
const { algorithm, digest } = getChecksum(transformedObject);
return s3Client.writeGetObjectResponse({
RequestRoute: requestContext.outputRoute,
RequestToken: requestContext.outputToken,
Body: transformedObject,
Metadata: {
'body-checksum-algorithm': algorithm,
'body-checksum-digest': digest,
'my-new-header': 'my-new-value'
},
...headers
}).promise();
}
```
**新しいステータスコードを返します。**
カスタムステータスコードを [https://docs.aws.amazon.com/AmazonS3/latest/API/API_WriteGetObjectResponse.html#API_WriteGetObjectResponse_RequestSyntax](https://docs.aws.amazon.com/AmazonS3/latest/API/API_WriteGetObjectResponse.html#API_WriteGetObjectResponse_RequestSyntax) API オペレーションリクエストで渡すことにより、`GetObject` クライアントに返すことができます。
```
async function writeResponse (s3Client: S3, requestContext: GetObjectContext, transformedObject: Buffer,
headers: Headers): Promise> {
const { algorithm, digest } = getChecksum(transformedObject);
return s3Client.writeGetObjectResponse({
RequestRoute: requestContext.outputRoute,
RequestToken: requestContext.outputToken,
Body: transformedObject,
Metadata: {
'body-checksum-algorithm': algorithm,
'body-checksum-digest': digest
},
...headers,
StatusCode: Integer
}).promise();
}
```
サポートされているステータスコードの完全なリストについては、*Amazon Simple Storage Service API リファレンス*の [https://docs.aws.amazon.com/AmazonS3/latest/API/API_WriteGetObjectResponse.html#API_WriteGetObjectResponse_RequestSyntax](https://docs.aws.amazon.com/AmazonS3/latest/API/API_WriteGetObjectResponse.html#API_WriteGetObjectResponse_RequestSyntax) を参照してください。
**ソースオブジェクトに `Range` と `partNumber` パラメータを適用します。**
デフォルトでは、CloudFormation テンプレートによって作成された Object Lambda アクセスポイントは、`Range` と `partNumber` のパラメータを処理できます。Lambda 関数は、要求された範囲または部品番号を変換されたオブジェクトに適用します。これを行うには、関数がオブジェクト全体をダウンロードして変換を実行する必要があります。場合によっては、変換されたオブジェクト範囲がソースオブジェクトの範囲に正確にマップされることがあります。つまり、ソースオブジェクトでバイト範囲 A−B を要求して変換を実行すると、オブジェクト全体を要求して変換を実行し、変換されたオブジェクトでバイト範囲 A−B を返すのと同じ結果が得られる可能性があります。
このような場合、Lambda 関数の実装を変更して、範囲または部品番号をソースオブジェクトに直接適用できます。このアプローチにより、関数全体のレイテンシーと必要なメモリが軽減されます。詳細については、「[Range および partNumber ヘッダーの操作](range-get-olap.md)」を参照してください。
**`Range` と `partNumber` 処理の無効化**
デフォルトでは、CloudFormation テンプレートによって作成された Object Lambda アクセスポイントは、`Range` と `partNumber` のパラメータを処理できます。この動作が不要な場合は、テンプレートから次の行を削除して無効化することができます。
```
AllowedFeatures:
- GetObject-Range
- GetObject-PartNumber
- HeadObject-Range
- HeadObject-PartNumber
```
**大きなオブジェクトの変換**
デフォルトでは、Lambda 関数は、S3 Object Lambda への応答のストリーミングをスタートする前に、メモリ内のオブジェクト全体を処理します。関数を変更して、変換の実行時に応答をストリーミングできます。これにより、変換のレイテンシーと Lambda 関数のメモリサイズを軽減できます。実装例については、[ストリーミング圧縮コンテンツの例](olap-writing-lambda.md#olap-getobject-response)を参照してください。
# Amazon S3 Object Lambda アクセスポイントの使用
**注記**
2025 年 11 月 7 日現在、S3 Object Lambda は、現在サービスを使用している既存のお客様、および一部の AWS パートナーネットワーク (APN) パートナーのみが利用できます。S3 Object Lambda と同様の機能の詳細については、「[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)」を参照してください。
Amazon S3 Object Lambda アクセスポイントを介してリクエストを行うことは、他のアクセスポイントを介してリクエストを行う場合と同様に機能します。アクセスポイントを介してリクエストを行う方法の詳細については、「[汎用バケットでの Amazon S3 アクセスポイントの使用](using-access-points.md)」を参照してください。Amazon S3 コンソール、AWS Command Line Interface、(AWS CLI)、AWS SDK、または Amazon S3 REST API を使用して Object Lambda アクセスポイントを介し、リクエストを行うことができます。
**重要**
Object Lambda アクセスポイントの Amazon リソースネーム (ARN) では、`s3-object-lambda` のサービス名が使用されます。したがって、Object Lambda アクセスポイントの ARN は、`arn:aws::s3` の代わりに `arn:aws::s3-object-lambda` で始まり、他のアクセスポイントと共に使用されます。
## Object Lambda アクセスポイントの ARN を見つける方法
AWS CLI または AWS SDK で Object Lambda アクセスポイントを使用するには、Object Lambda アクセスポイントの Amazon リソースネーム (ARN) を知る必要があります。以下の例では、Amazon S3 コンソールまたは AWS CLI を使用して Object Lambda アクセスポイントの ARN を検索する方法を示します。
### S3 コンソールの使用
**コンソールを使用して Object Lambda アクセスポイントの ARN を見つける方法**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左のナビゲーションペインで、**[Object Lambda Access Points]** (Object Lambda アクセスポイント)を選択します。
1. ARN をコピーする Object Lambda アクセスポイントの横にあるオプションボタンを選択します。
1. [**ARN のコピー**] を選択します。
### の使用AWS CLI
**AWS CLI を使用して Object Lambda アクセスポイントの ARN を見つける方法**
1. AWS アカウント に関連付けられている Object Lambda アクセスポイントのリストを取得するにはで、以下のコマンドを実行します。コマンドを実行する前に、アカウント ID *`111122223333`* と AWS アカウント ID を交換してください。
```
aws s3control list-access-points-for-object-lambda --account-id 111122223333
```
1. コマンド出力を確認して、使用するオブジェクト Lambda アクセスポイント ARN を見つけます。先ほどのコマンドの出力は、次の例のようになります。
```
{
"ObjectLambdaAccessPointList": [
{
"Name": "my-object-lambda-ap",
"ObjectLambdaAccessPointArn": "arn:aws:s3-object-lambda:us-east-1:111122223333:accesspoint/my-object-lambda-ap"
},
...
]
}
```
## S3 バケット Object Lambda アクセスポイントでのバケット形式のエイリアスの使用方法
Object Lambda アクセスポイントを作成すると、Amazon S3 は Object Lambda アクセスポイントの固有のエイリアスを自動的に生成します。アクセスポイントのデータプレーンオペレーションのリクエストで、Amazon S3 バケット名や Object Lambda アクセスポイント Amazon Resource Name (ARN) の代わりに、このエイリアスを使用することができます。これらのオペレーションのリストについては、「[アクセスポイントの互換性](access-points-service-api-support.md)」を参照してください。
Object Lambda アクセスポイントのエイリアス名は、Amazon S3 バケットと同じ名前空間内に作成されます。このエイリアス名は自動的に生成され、変更できません。既存の Object Lambda アクセスポイントには、エイリアスが自動的に割り当てられて使用されます。Object Lambda アクセスポイントのエイリアス名は、有効な Amazon S3 バケット名のすべての要件を満たしており、次の部分で構成されています。
`Object Lambda Access Point name prefix-metadata--ol-s3`
**注記**
`--ol-s3` サフィックスは、Object Lambda アクセスポイントのエイリアス名用に予約されており、バケット名や Object Lambda アクセスポイント名には使用できません。Amazon S3 バケット命名規則の詳細については、「[汎用バケットの命名規則](bucketnamingrules.md)」を参照してください。
以下は、`my-object-lambda-access-point` という名前の Object Lambda アクセスポイントの ARN と Object Lambda アクセスポイントのエイリアスの例です。
+ **ARN** — `arn:aws:s3-object-lambda:region:account-id:accesspoint/my-object-lambda-access-point`
+ **Object Lambda アクセスポイントのエイリアス** — `my-object-lambda-acc-1a4n8yjrb3kda96f67zwrwiiuse1a--ol-s3`
Object Lambda アクセスポイントを使用する場合、コードを大幅に変更しなくても Object Lambda アクセスポイントのエイリアス名を使用できます。
Object Lambda アクセスポイントを削除すると、Object Lambda アクセスポイントのエイリアス名は非アクティブになり、プロビジョニングも解除されます。
### Object Lambda アクセスポイントのエイリアスを見つける方法
#### S3 コンソールの使用
**コンソールを使用して Object Lambda アクセスポイントのエイリアスを見つけるには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左のナビゲーションペインで、**[Object Lambda Access Points]** (Object Lambda アクセスポイント)を選択します。
1. 使用する Object Lambda アクセスポイントについて、**Object Lambda アクセスポイントのエイリアス**値をコピーします。
#### の使用AWS CLI
Object Lambda アクセスポイントを作成すると、次のコマンド例に示すように、Amazon S3 によって Object Lambda アクセスポイントのエイリアス名が自動的に生成されます。このコマンドを実行するには、`user input placeholders` をユーザー自身の情報に置き換えます。AWS CLI を使用して Object Lambda アクセスポイントを作成する方法については、「[AWS CLI を使用して Object Lambda アクセスポイントを作成するには](olap-create.md#olap-create-cli-specific)」を参照してください。
```
aws s3control create-access-point-for-object-lambda --account-id 111122223333 --name my-object-lambda-access-point --configuration file://my-olap-configuration.json
{
"ObjectLambdaAccessPointArn": "arn:aws:s3:region:111122223333:accesspoint/my-access-point",
"Alias": {
"Value": "my-object-lambda-acc-1a4n8yjrb3kda96f67zwrwiiuse1a--ol-s3",
"Status": "READY"
}
}
```
生成された Object Lambda アクセスポイントのエイリアス名には 2 つのフィールドがあります。
+ `Value` フィールドは、Obda Lambda アクセスポイントのエイリアス値です。
+ `Status` フィールドは、Object Lambda アクセスポイントのエイリアスのステータスです。ステータスが `PROVISIONING` の場合、Amazon S3 は Object Lambda Access Point エイリアスをプロビジョニング中ですが、エイリアスはまだ使用できる状態ではありません。ステータスが `READY` の場合、Object Lambda Access Point エイリアスは正常にプロビジョニングされ、使用できる状態になっています。
REST API `ObjectLambdaAccessPointAlias` データ型の詳細については、*Amazon Simple Storage Service API リファレンス* の「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateAccessPointForObjectLambda.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateAccessPointForObjectLambda.html)」および「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_ObjectLambdaAccessPointAlias.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_ObjectLambdaAccessPointAlias.html)」を参照してください。
### Object Lambda アクセスポイントのエイリアスの使用方法
[アクセスポイントの互換性](access-points-service-api-support.md) に示されているオペレーションには、Amazon S3 バケット名の代わりに Object Lambda Access Point エイリアスを使用できます。
`get-bucket-location` コマンドの次の AWS CLI 例は、バケットのアクセスポイントエイリアスを使用して、バケットが置かれている AWS リージョン を返します。このコマンドを実行するには、`user input placeholders` をユーザー自身の情報に置き換えます。
```
aws s3api get-bucket-location --bucket my-object-lambda-acc-w7i37nq6xuzgax3jw3oqtifiusw2a--ol-s3
{
"LocationConstraint": "us-west-2"
}
```
リクエスト内の Object Lambda アクセスポイントのエイリアスが有効でない場合、エラーコード `InvalidAccessPointAliasError` が返されます。`InvalidAccessPointAliasError` の詳細については、*Amazon Simple Storage Service API リファレンス*の「[List of Error Codes](https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#ErrorCodeList)」(エラーコードのリスト) を参照してください。
Object Lambda アクセスポイントエイリアスの制限は、アクセスポイントエイリアスの制限と同じです。アクセスポイントエイリアスの制限の詳細については、「[アクセスポイントエイリアスの制限](access-points-naming.md#use-ap-alias-limitations)」を参照してください。
# S3 Object Lambda アクセスポイントのセキュリティに関する考慮事項
**注記**
2025 年 11 月 7 日現在、S3 Object Lambda は、現在サービスを使用している既存のお客様、および一部の AWS パートナーネットワーク (APN) パートナーのみが利用できます。S3 Object Lambda と同様の機能の詳細については、「[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)」を参照してください。
Amazon S3 Object Lambda では、コンピューティングプラットフォームとして AWS Lambda のスケールと柔軟性を利用して、Amazon S3 を離れたデータに対してカスタム変換を実行できます。S3 と Lambda はデフォルトで安全なままですが、この安全性を維持するためには、Lambda 関数の作成者による特別な考慮が必要です。S3 Object Lambda では、すべてのアクセスが、認証されたプリンシパル (匿名アクセスなし) により、HTTPS 経由で行われる必要があります。
セキュリティリスクを軽減するために、以下を推奨します。
+ Lambda 実行ロールの範囲を、可能な限り最小の権限セットに設定します。
+ 可能な限り、提供された署名付き URL を通じて Lambda 関数が Amazon S3 にアクセスするようにしてください。
## IAM ポリシーの設定
S3 アクセスポイントは AWS Identity and Access Management (IAM) リソースポリシーをサポートしています。これにより、リソース、ユーザー、その他の条件別にアクセスポイントの使用を制御できます。詳細については、[Object Lambda アクセスポイントの IAM ポリシーの設定](olap-policies.md) を参照してください。
## 暗号化動作
Object Lambda アクセスポイントは Amazon S3 と AWS Lambda の両方を使用するため、暗号化の動作には違いがあります。デフォルトの S3 暗号化の動作の詳細については、[Amazon S3 バケット向けのサーバー側のデフォルトの暗号化動作の設定](bucket-encryption.md) を参照してください。
+ Object Lambda アクセスポイントで S3 サーバー側の暗号化を使用している場合、オブジェクトは Lambda に送信される前に復号化されます。オブジェクトが Lambda に送信されると、暗号化されずに処理されます (`GET` または `HEAD` リクエストの場合)。
+ 暗号化キーがログに記録されないようにするため、S3 は、お客様が指定したキーを使用したサーバー側の暗号化 (SSE-C) で暗号化されたオブジェクトに対する `GET` および `HEAD` リクエストを拒否します。ただし、Lambda 関数は、クライアントが指定したキーにアクセスできる場合、これらのオブジェクトを取得する可能性があります。
+ Object Lambda アクセスポイントで S3 クライアント側の暗号化を使用する際は、Lambda がオブジェクトを復号および再暗号化するための暗号化キーにアクセスできることを確認してください。
## アクセスポイントセキュリティ
S3 Object Lambda は、Object Lambda アクセスポイントと、*サポートアクセスポイント*と呼ばれる、標準の S3 アクセスポイントの 2 つのアクセスポイントを使用します。Object Lambda アクセスポイントにリクエストを行うと、S3 は S3 Object Lambda の設定に応じて、ユーザーに代わって Lambda を呼び出すか、サポートアクセスポイントにリクエストを委任します。Lambda がリクエストに対して呼び出されると、S3 は、サポートアクセスポイントを通じて、ユーザーに代わってオブジェクトへの署名付き URL を生成します。Lambda 関数は、関数が呼び出されたときにこの URL を入力として受け取ります。
S3 を直接呼び出すのではなく、この署名付き URL を使用して元のオブジェクトを取得するように Lambda 関数を設定できます。このモデルを使用することで、より優れたセキュリティ境界をオブジェクトに適用できます。S3 バケットまたは S3 アクセスポイント経由のオブジェクト直接アクセスを、限定された IAM ロールまたはユーザーのセットに制限できます。このアプローチにより、Lambda 関数が「[混乱した代理問題](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html)」のターゲットになることを防げます。これは、呼び出し元とは異なるアクセス許可を持つ誤って設定された関数が、本来は許可または拒否すべきでないオブジェクトへのアクセスを許可または拒否する可能性があるというものです。
## Object Lambda アクセスポイントのパブリックアクセス
S3 Object Lambda は匿名またはパブリックアクセスを許可しません。これは、Amazon S3 が S3 Object Lambda リクエストを完了するために ID を承認する必要があるためです。Object Lambda アクセスポイントを介してリクエストを呼び出す際には、設定された Lambda 関数の `lambda:InvokeFunction` 許可が必要となります。同様に、Object Lambda アクセスポイントを介して他の API オペレーションを呼び出す際には、必須の `s3:*` 許可が必要となります。
これらのアクセス許可がないと、Lambda の呼び出しまたは S3 への委任のリクエストは HTTP 403 (Forbidden) エラーとして失敗します。すべてのアクセスは、認証されたプリンシパルによって行われる必要があります。パブリックアクセスが必要な場合は、Lambda@Edge を代替として使用できます。詳細については、*Amazon CloudFront 開発者ガイド*の [Lambda@Edge を使用したエッジでのカスタマイズ](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-at-the-edge.html)を参照してください。
## Object Lambda アクセスポイント IP アドレス
`describe-managed-prefix-lists` サブネットはゲートウェイ仮想プライベートクラウド (VPC) エンドポイントをサポートしており、VPC エンドポイントのルーティングテーブルに関連しています。Object Lambda アクセスポイントはゲートウェイ VPC をサポートしていないため、その IP 範囲は欠落しています。欠落している範囲は Amazon S3 に属しますが、ゲートウェイ VPC エンドポイントではサポートされていません。`describe-managed-prefix-lists` の詳細については、「*Amazon EC2 API リファレンス*」の「[DescribeManagedPrefixLists](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeManagedPrefixLists.html)」と「*AWS 全般のリファレンス*」の「[AWS IP アドレスの範囲](https://docs.aws.amazon.com/general/latest/gr/aws-ip-ranges.html)」を参照してください。
# Object Lambda アクセスポイントの IAM ポリシーの設定
**注記**
2025 年 11 月 7 日現在、S3 Object Lambda は、現在サービスを使用している既存のお客様、および一部の AWS パートナーネットワーク (APN) パートナーのみが利用できます。S3 Object Lambda と同様の機能の詳細については、「[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)」を参照してください。
Amazon S3 アクセスポイントは AWS Identity and Access Management (IAM) リソースポリシーをサポートしています。これにより、リソース、ユーザー、またはその他の条件別にアクセスポイントの使用を制御できます。Object Lambda アクセスポイントのオプションリソースポリシー、またはサポートアクセスポイントのリソースポリシーを使用してアクセスを制御できます。詳細な例については、[チュートリアル: S3 Object Lambda を使用したアプリケーションのデータの変換](tutorial-s3-object-lambda-uppercase.md) および [チュートリアル: S3 Object Lambda と Amazon Comprehend を使用した PII データの検出と編集](tutorial-s3-object-lambda-redact-pii.md) を参照してください。
次の 4 つのリソースに Object Lambda アクセスポイントを使用するための許可が付与されている必要があります。
+ ユーザーやロールなどの IAM ID。IAM ID およびベストプラクティスの詳細については、「*IAM ユーザーガイド*」の「[IAM ID (ユーザー、ユーザーグループ、ロール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html)」を参照してください。
+ S3 バケットや Amazon FSx for OpenZFS ボリュームなどの基盤となるデータソースに接続されている標準アクセスポイント。Object Lambda アクセスポイントを使用する場合、この標準アクセスポイントは*サポートアクセスポイント*と呼ばれます。
+ Object Lambda アクセスポイント。
+ AWS Lambda 関数。
**重要**
ポリシーを保存する前に、AWS Identity and Access Management Access Analyzer からの セキュリティ警告、エラー、一般的な警告、および提案を解決してください。IAM Access Analyzer は、IAM [ポリシーの文法](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_grammar.html)と[ベストプラクティス](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html)に照らしてポリシーチェックを行います。これらのチェックにより、機能的でセキュリティのベストプラクティスに準拠したポリシーを作成するのに、役立つ結果と実行可能なレコメンデーションが示されます。
IAM Access Analyzer を使用したポリシーの検証の詳細については、「*IAM ユーザーガイド*」の「[IAM Access Analyzer のポリシーの検証](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html)」を参照してください。IAM Access Analyzer によって返される警告、エラー、および提案のリストを表示するには、「[IAM Access Analyzer ポリシーチェックリファレンス](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-reference-policy-checks.html)」を参照してください。
以下のポリシーは、次のリソースがあることを前提としています。
+ 次の Amazon リソースネーム (ARN) を持つ Amazon S3 バケット:
`arn:aws:s3:::amzn-s3-demo-bucket1`
+ このバケット上の Amazon S3 Standard アクセスポイントに次の ARN があること。
`arn:aws:s3:us-east-1:111122223333:accesspoint/my-access-point`
+ Object Lambda アクセスポイントに次の ARN があること。
`arn:aws:s3-object-lambda:us-east-1:111122223333:accesspoint/my-object-lambda-ap`
+ AWS Lambda 関数に次の ARN があること。
`arn:aws:lambda:us-east-1:111122223333:function:MyObjectLambdaFunction`
**注記**
アカウントから Lambda 関数を使用する場合は、ポリシーステートメントに特定の関数のバージョンを含める必要があります。次の ARN の例では、バージョンは *1* で示されています。
`arn:aws:lambda:us-east-1:111122223333:function:MyObjectLambdaFunction:1`
Lambda は、バージョン `$LATEST` への IAM ポリシーの追加をサポートしていません。Lambda 関数のバージョンの詳細については、「*AWS Lambda 開発者ガイド*」の「[Lambda 関数のバージョン](https://docs.aws.amazon.com/lambda/latest/dg/configuration-versions.html)」を参照してください。
**Example - アクセスコントロールを標準アクセスポイントに委任するバケットポリシー**
次の S3 バケットポリシーの例は、バケットのアクセスコントロールをバケットの標準アクセスポイントに委任します。このポリシーでは、バケット所有者のアカウントが所有するすべてのアクセスポイントへのフルアクセスを許可しています。したがって、このバケットへのすべてのアクセスは、そのアクセスポイントにアタッチされているポリシーによってコントロールされます。ユーザーはアクセスポイントを介してのみバケットから読み取ることができます。つまり、オペレーションは、アクセスポイントを介してのみ呼び出すことができます。詳細については、「[アクセスポイントへのアクセスコントロールの委任](access-points-policies.md#access-points-delegating-control)」を参照してください。
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect": "Allow",
"Principal" : { "AWS":"account-ARN"},
"Action" : "*",
"Resource" : [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
],
"Condition": {
"StringEquals" : { "s3:DataAccessPointAccount" : "Bucket owner's account ID" }
}
}]
}
```
**Example — Object Lambda アクセスポイントを使用するために必要なアクセス許可をユーザーに付与する IAM ポリシー**
次の IAM ポリシーは、Lambda 関数、標準アクセスポイント、および Object Lambda アクセスポイントに対するアクセス許可をユーザーに付与します。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowLambdaInvocation",
"Action": [
"lambda:InvokeFunction"
],
"Effect": "Allow",
"Resource": "arn:aws:lambda:us-east-1:111122223333:function:MyObjectLambdaFunction:1",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:CalledVia": [
"s3-object-lambda.amazonaws.com"
]
}
}
},
{
"Sid": "AllowStandardAccessPointAccess",
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:us-east-1:111122223333:accesspoint/my-access-point/*",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:CalledVia": [
"s3-object-lambda.amazonaws.com"
]
}
}
},
{
"Sid": "AllowObjectLambdaAccess",
"Action": [
"s3-object-lambda:Get*",
"s3-object-lambda:List*"
],
"Effect": "Allow",
"Resource": "arn:aws:s3-object-lambda:us-east-1:111122223333:accesspoint/my-object-lambda-ap"
}
]
}
```
## Lambda 実行ロールの許可を有効化する
Object Lambda アクセスポイントに `GET` リクエストが行われた場合、Lambda 関数には、S3 Object Lambda アクセスポイントにデータを送信する許可が必要です。このアクセス許可は、Lambda 関数の実行ロールで `s3-object-lambda:WriteGetObjectResponse` 許可を有効にすることで提供されます。新しい実行ロールを使作成することも、既存のロールを更新することもできます。
**注記**
関数に `s3-object-lambda:WriteGetObjectResponse` 許可が必要なのは、`GET` リクエストを行う場合のみです。
**IAM コンソールで実行ロールを作成するには**
1. IAM コンソール ([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)) を開きます。
1. 左のナビゲーションペインで、**[Roles (ロール)]** を選択してください。
1. [**ロールの作成**] を選択してください。
1. [**一般的なユースケース**] で、[**Lambda**] を選択します。
1. [**次へ**] を選択します。
1. **[Add permissions]** (許可の追加) ページで、AWS マネージドポリシー [https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AmazonS3ObjectLambdaExecutionRolePolicy$serviceLevelSummary](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AmazonS3ObjectLambdaExecutionRolePolicy$serviceLevelSummary) を検索し、ポリシー名の横にあるチェックボックスをオンにします。
このポリシーには `s3-object-lambda:WriteGetObjectResponse` アクションを含める必要があります。
1. [**次へ**] を選択します。
1. **[Name, review, and create]** (名前、確認、作成) ページで、**[Role name]** (ロール名) に **s3-object-lambda-role** と入力します。
1. (オプション) このロールの説明とタグを追加します。
1. [**ロールの作成**] を選択してください。
1. 新しく作成した **s3-object-lambda-role** を Lambda 関数の実行ロールとして適用します。これは、Lambda コンソールで Lambda 関数の作成中または作成後に実行できます。
実行ロールの詳細については、「*AWS Lambda デベロッパーガイド*」の「[Lambda 実行ロール](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html)」を参照してください。
## Object Lambda アクセスポイントでのコンテキストキーの使用
S3 Object Lambda は、リクエストの接続や署名に関連する `s3-object-lambda:TlsVersion` や `s3-object-lambda:AuthType` などのコンテキストキーを評価します。`s3:prefix` など、他のすべてのコンテキストキーは、Amazon S3 によって評価されます。
## Object Lambda アクセスポイントの CORS サポート
S3 Object Lambda がブラウザからリクエストを受信するか、リクエストに `Origin` ヘッダーが含まれている場合、S3 Object Lambda は常に `"AllowedOrigins":"*"` ヘッダーフィールドを追加します。
詳細については、「[Cross−Origin Resource Sharing (CORS) の使用](cors.md)」を参照してください。
# S3 Object Lambda アクセスポイントの Lambda 関数の記述
**注記**
2025 年 11 月 7 日現在、S3 Object Lambda は、現在サービスを使用している既存のお客様、および一部の AWS パートナーネットワーク (APN) パートナーのみが利用できます。S3 Object Lambda と同様の機能の詳細については、「[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)」を参照してください。
このセクションでは、Amazon S3 Object Lambda アクセスポイントで使用するための AWS Lambda 関数を記述する方法について詳述します。
S3 Object Lambda の一部のタスクにおける完全なエンドツーエンド手順については、以下を参照してください。
+ [チュートリアル: S3 Object Lambda を使用したアプリケーションのデータの変換](tutorial-s3-object-lambda-uppercase.md)
+ [チュートリアル: S3 Object Lambda と Amazon Comprehend を使用した PII データの検出と編集](tutorial-s3-object-lambda-redact-pii.md)
+ [チュートリアル: S3 Object Lambda を使用して、取得時に画像に動的に透かしを入れる](https://aws.amazon.com/getting-started/hands-on/amazon-s3-object-lambda-to-dynamically-watermark-images/?ref=docs_gateway/amazons3/olap-writing-lambda.html)
**Topics**
+ [Lambdaでの `GetObject` リクエストの処理](#olap-getobject-response)
+ [Lambdaでの `HeadObject` リクエストの処理](#olap-headobject)
+ [Lambda での `ListObjects` リクエストの使用](#olap-listobjects)
+ [Lambda での `ListObjectsV2` リクエストの使用](#olap-listobjectsv2)
+ [イベントコンテキストの形式と使用法](olap-event-context.md)
+ [Range および partNumber ヘッダーの操作](range-get-olap.md)
## Lambdaでの `GetObject` リクエストの処理
このセクションでは、Object Lambda アクセスポイントが `GetObject` 用に Lambda 関数を呼び出すように設定されていることを前提としています。S3 Object Lambda には、Amazon S3 API オペレーション、`WriteGetObjectResponse` が含まれています。これにより、Lambda 関数は、カスタマイズされたデータとレスポンスヘッダーを `GetObject` 発信者に提供できるようになります。
`WriteGetObjectResponse` は、処理のニーズに基づいて、ステータスコード、レスポンスヘッダー、レスポンス本文を広範囲に制御できます。`WriteGetObjectResponse` を使用すると、変換されたオブジェクト全体、変換されたオブジェクトの一部、またはアプリケーションのコンテキストに基づくその他のレスポンスに対して応答することができます。次のセクションでは、`WriteGetObjectResponse` API オペレーションを使用した一意の例を示します。
+ **例 1:** HTTP ステータスコード 403 (Forbidden) で応答します。
+ **例 2:** 変換された画像で応答する
+ **例 3:** 圧縮されたコンテンツをストリーミングする
**例 1: HTTP ステータスコード 403 (Forbidden) で応答します。**
`WriteGetObjectResponse` を使用して、オブジェクトの内容に基づいて HTTP ステータスコード 403 (Forbidden) で応答できます。
------
#### [ Java ]
```
package com.amazon.s3.objectlambda;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.events.S3ObjectLambdaEvent;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.WriteGetObjectResponseRequest;
import java.io.ByteArrayInputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
public class Example1 {
public void handleRequest(S3ObjectLambdaEvent event, Context context) throws Exception {
S3Client s3Client = S3Client.builder().build();
// Check to see if the request contains all of the necessary information.
// If it does not, send a 4XX response and a custom error code and message.
// Otherwise, retrieve the object from S3 and stream it
// to the client unchanged.
var tokenIsNotPresent = !event.getUserRequest().getHeaders().containsKey("requiredToken");
if (tokenIsNotPresent) {
s3Client.writeGetObjectResponse(WriteGetObjectResponseRequest.builder()
.requestRoute(event.outputRoute())
.requestToken(event.outputToken())
.statusCode(403)
.contentLength(0L)
.errorCode("MissingRequiredToken")
.errorMessage("The required token was not present in the request.")
.build(),
RequestBody.fromInputStream(new ByteArrayInputStream(new byte[0]), 0L));
return;
}
// Prepare the presigned URL for use and make the request to S3.
HttpClient httpClient = HttpClient.newBuilder().build();
var presignedResponse = httpClient.send(
HttpRequest.newBuilder(new URI(event.inputS3Url())).GET().build(),
HttpResponse.BodyHandlers.ofInputStream());
// Stream the original bytes back to the caller.
s3Client.writeGetObjectResponse(WriteGetObjectResponseRequest.builder()
.requestRoute(event.outputRoute())
.requestToken(event.outputToken())
.build(),
RequestBody.fromInputStream(presignedResponse.body(),
presignedResponse.headers().firstValueAsLong("content-length").orElse(-1L)));
}
}
```
------
#### [ Python ]
```
import boto3
import requests
def handler(event, context):
s3 = boto3.client('s3')
"""
Retrieve the operation context object from the event. This object indicates where the WriteGetObjectResponse request
should be delivered and contains a presigned URL in 'inputS3Url' where we can download the requested object from.
The 'userRequest' object has information related to the user who made this 'GetObject' request to
S3 Object Lambda.
"""
get_context = event["getObjectContext"]
user_request_headers = event["userRequest"]["headers"]
route = get_context["outputRoute"]
token = get_context["outputToken"]
s3_url = get_context["inputS3Url"]
# Check for the presence of a 'CustomHeader' header and deny or allow based on that header.
is_token_present = "SuperSecretToken" in user_request_headers
if is_token_present:
# If the user presented our custom 'SuperSecretToken' header, we send the requested object back to the user.
response = requests.get(s3_url)
s3.write_get_object_response(RequestRoute=route, RequestToken=token, Body=response.content)
else:
# If the token is not present, we send an error back to the user.
s3.write_get_object_response(RequestRoute=route, RequestToken=token, StatusCode=403,
ErrorCode="NoSuperSecretTokenFound", ErrorMessage="The request was not secret enough.")
# Gracefully exit the Lambda function.
return { 'status_code': 200 }
```
------
#### [ Node.js ]
```
const { S3 } = require('aws-sdk');
const axios = require('axios').default;
exports.handler = async (event) => {
const s3 = new S3();
// Retrieve the operation context object from the event. This object indicates where the WriteGetObjectResponse request
// should be delivered and contains a presigned URL in 'inputS3Url' where we can download the requested object from.
// The 'userRequest' object has information related to the user who made this 'GetObject' request to S3 Object Lambda.
const { userRequest, getObjectContext } = event;
const { outputRoute, outputToken, inputS3Url } = getObjectContext;
// Check for the presence of a 'CustomHeader' header and deny or allow based on that header.
const isTokenPresent = Object
.keys(userRequest.headers)
.includes("SuperSecretToken");
if (!isTokenPresent) {
// If the token is not present, we send an error back to the user. The 'await' in front of the request
// indicates that we want to wait for this request to finish sending before moving on.
await s3.writeGetObjectResponse({
RequestRoute: outputRoute,
RequestToken: outputToken,
StatusCode: 403,
ErrorCode: "NoSuperSecretTokenFound",
ErrorMessage: "The request was not secret enough.",
}).promise();
} else {
// If the user presented our custom 'SuperSecretToken' header, we send the requested object back to the user.
// Again, note the presence of 'await'.
const presignedResponse = await axios.get(inputS3Url);
await s3.writeGetObjectResponse({
RequestRoute: outputRoute,
RequestToken: outputToken,
Body: presignedResponse.data,
}).promise();
}
// Gracefully exit the Lambda function.
return { statusCode: 200 };
}
```
------
**例 2: 変換された画像で応答する**
画像変換を実行する場合、ソースオブジェクトの処理を開始する前に、ソースオブジェクトのすべてのバイトが必要になる可能性があります。この場合、`WriteGetObjectResponse` リクエストは、オブジェクト全体を 1 回の呼び出しでリクエスト元のアプリケーションに返します。
------
#### [ Java ]
```
package com.amazon.s3.objectlambda;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.events.S3ObjectLambdaEvent;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.WriteGetObjectResponseRequest;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.awt.Image;
import java.io.ByteArrayOutputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
public class Example2V2 {
private static final int HEIGHT = 250;
private static final int WIDTH = 250;
public void handleRequest(S3ObjectLambdaEvent event, Context context) throws Exception {
S3Client s3Client = S3Client.builder().build();
HttpClient httpClient = HttpClient.newBuilder().build();
// Prepare the presigned URL for use and make the request to S3.
var presignedResponse = httpClient.send(
HttpRequest.newBuilder(new URI(event.inputS3Url())).GET().build(),
HttpResponse.BodyHandlers.ofInputStream());
// The entire image is loaded into memory here so that we can resize it.
// Once the resizing is completed, we write the bytes into the body
// of the WriteGetObjectResponse request.
var originalImage = ImageIO.read(presignedResponse.body());
var resizingImage = originalImage.getScaledInstance(WIDTH, HEIGHT, Image.SCALE_DEFAULT);
var resizedImage = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
resizedImage.createGraphics().drawImage(resizingImage, 0, 0, WIDTH, HEIGHT, null);
var baos = new ByteArrayOutputStream();
ImageIO.write(resizedImage, "png", baos);
// Stream the bytes back to the caller.
s3Client.writeGetObjectResponse(WriteGetObjectResponseRequest.builder()
.requestRoute(event.outputRoute())
.requestToken(event.outputToken())
.build(), RequestBody.fromBytes(baos.toByteArray()));
}
}
```
------
#### [ Python ]
```
import boto3
import requests
import io
from PIL import Image
def handler(event, context):
"""
Retrieve the operation context object from the event. This object indicates where the WriteGetObjectResponse request
should be delivered and has a presigned URL in 'inputS3Url' where we can download the requested object from.
The 'userRequest' object has information related to the user who made this 'GetObject' request to
S3 Object Lambda.
"""
get_context = event["getObjectContext"]
route = get_context["outputRoute"]
token = get_context["outputToken"]
s3_url = get_context["inputS3Url"]
"""
In this case, we're resizing .png images that are stored in S3 and are accessible through the presigned URL
'inputS3Url'.
"""
image_request = requests.get(s3_url)
image = Image.open(io.BytesIO(image_request.content))
image.thumbnail((256,256), Image.ANTIALIAS)
transformed = io.BytesIO()
image.save(transformed, "png")
# Send the resized image back to the client.
s3 = boto3.client('s3')
s3.write_get_object_response(Body=transformed.getvalue(), RequestRoute=route, RequestToken=token)
# Gracefully exit the Lambda function.
return { 'status_code': 200 }
```
------
#### [ Node.js ]
```
const { S3 } = require('aws-sdk');
const axios = require('axios').default;
const sharp = require('sharp');
exports.handler = async (event) => {
const s3 = new S3();
// Retrieve the operation context object from the event. This object indicates where the WriteGetObjectResponse request
// should be delivered and has a presigned URL in 'inputS3Url' where we can download the requested object from.
const { getObjectContext } = event;
const { outputRoute, outputToken, inputS3Url } = getObjectContext;
// In this case, we're resizing .png images that are stored in S3 and are accessible through the presigned URL
// 'inputS3Url'.
const { data } = await axios.get(inputS3Url, { responseType: 'arraybuffer' });
// Resize the image.
const resized = await sharp(data)
.resize({ width: 256, height: 256 })
.toBuffer();
// Send the resized image back to the client.
await s3.writeGetObjectResponse({
RequestRoute: outputRoute,
RequestToken: outputToken,
Body: resized,
}).promise();
// Gracefully exit the Lambda function.
return { statusCode: 200 };
}
```
------
**例 3: 圧縮されたコンテンツをストリーミングする**
オブジェクトを圧縮すると、圧縮データは増分的に生成されます。したがって、準備ができたらすぐに圧縮されたデータを返すために、`WriteGetObjectResponse` リクエストを使用できます。この例で示すように、完了した変換の長さを知る必要はありません。
------
#### [ Java ]
```
package com.amazon.s3.objectlambda;
import com.amazonaws.services.lambda.runtime.events.S3ObjectLambdaEvent;
import com.amazonaws.services.lambda.runtime.Context;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.WriteGetObjectResponseRequest;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
public class Example3 {
public void handleRequest(S3ObjectLambdaEvent event, Context context) throws Exception {
S3Client s3Client = S3Client.builder().build();
HttpClient httpClient = HttpClient.newBuilder().build();
// Request the original object from S3.
var presignedResponse = httpClient.send(
HttpRequest.newBuilder(new URI(event.inputS3Url())).GET().build(),
HttpResponse.BodyHandlers.ofInputStream());
// Consume the incoming response body from the presigned request,
// apply our transformation on that data, and emit the transformed bytes
// into the body of the WriteGetObjectResponse request as soon as they're ready.
// This example compresses the data from S3, but any processing pertinent
// to your application can be performed here.
var bodyStream = new GZIPCompressingInputStream(presignedResponse.body());
// Stream the bytes back to the caller.
s3Client.writeGetObjectResponse(WriteGetObjectResponseRequest.builder()
.requestRoute(event.outputRoute())
.requestToken(event.outputToken())
.build(),
RequestBody.fromInputStream(bodyStream,
presignedResponse.headers().firstValueAsLong("content-length").orElse(-1L)));
}
}
```
------
#### [ Python ]
```
import boto3
import requests
import zlib
from botocore.config import Config
"""
A helper class to work with content iterators. Takes an interator and compresses the bytes that come from it. It
implements 'read' and '__iter__' so that the SDK can stream the response.
"""
class Compress:
def __init__(self, content_iter):
self.content = content_iter
self.compressed_obj = zlib.compressobj()
def read(self, _size):
for data in self.__iter__()
return data
def __iter__(self):
while True:
data = next(self.content)
chunk = self.compressed_obj.compress(data)
if not chunk:
break
yield chunk
yield self.compressed_obj.flush()
def handler(event, context):
"""
Setting the 'payload_signing_enabled' property to False allows us to send a streamed response back to the client.
in this scenario, a streamed response means that the bytes are not buffered into memory as we're compressing them,
but instead are sent straight to the user.
"""
my_config = Config(
region_name='eu-west-1',
signature_version='s3v4',
s3={
"payload_signing_enabled": False
}
)
s3 = boto3.client('s3', config=my_config)
"""
Retrieve the operation context object from the event. This object indicates where the WriteGetObjectResponse request
should be delivered and has a presigned URL in 'inputS3Url' where we can download the requested object from.
The 'userRequest' object has information related to the user who made this 'GetObject' request to S3 Object Lambda.
"""
get_context = event["getObjectContext"]
route = get_context["outputRoute"]
token = get_context["outputToken"]
s3_url = get_context["inputS3Url"]
# Compress the 'get' request stream.
with requests.get(s3_url, stream=True) as r:
compressed = Compress(r.iter_content())
# Send the stream back to the client.
s3.write_get_object_response(Body=compressed, RequestRoute=route, RequestToken=token, ContentType="text/plain",
ContentEncoding="gzip")
# Gracefully exit the Lambda function.
return {'status_code': 200}
```
------
#### [ Node.js ]
```
const { S3 } = require('aws-sdk');
const axios = require('axios').default;
const zlib = require('zlib');
exports.handler = async (event) => {
const s3 = new S3();
// Retrieve the operation context object from the event. This object indicates where the WriteGetObjectResponse request
// should be delivered and has a presigned URL in 'inputS3Url' where we can download the requested object from.
const { getObjectContext } = event;
const { outputRoute, outputToken, inputS3Url } = getObjectContext;
// Download the object from S3 and process it as a stream, because it might be a huge object and we don't want to
// buffer it in memory. Note the use of 'await' because we want to wait for 'writeGetObjectResponse' to finish
// before we can exit the Lambda function.
await axios({
method: 'GET',
url: inputS3Url,
responseType: 'stream',
}).then(
// Gzip the stream.
response => response.data.pipe(zlib.createGzip())
).then(
// Finally send the gzip-ed stream back to the client.
stream => s3.writeGetObjectResponse({
RequestRoute: outputRoute,
RequestToken: outputToken,
Body: stream,
ContentType: "text/plain",
ContentEncoding: "gzip",
}).promise()
);
// Gracefully exit the Lambda function.
return { statusCode: 200 };
}
```
------
**注記**
S3 Object Lambda では、発信者に完全なレスポンスを送信するのに最大 60 秒かかります。`WriteGetObjectResponse` リクエストの場合、実際の利用可能な時間は短くなる可能性があります。例えば、Lambda 関数のタイムアウトが 60 秒未満である可能性があります。それ以外にも、発信者のタイムアウトがより厳しい場合があります。
元の発信者が HTTP ステータスコード 500 以外のレスポンス (内部サーバエラー) を受信するには、`WriteGetObjectResponse` コールが完了する必要があります。`WriteGetObjectResponse` API オペレーションが呼び出される前に、Lambda 関数が例外的に、またはその他の方法で返された場合、元の発信者は 500 (内部サーバーエラー) レスポンスを受け取ります。レスポンスが完了するまでの間にスローされた例外は、発信者へのレスポンスが切り捨てられます。Lambda 関数が `WriteGetObjectResponse` API コールから HTTP ステータスコード 200 (OK) レスポンスを受信した場合、元の発信者は完全なリクエストを送信しています。例外がスローされたかどうかにかかわらず、Lambda 関数のレスポンスは S3 Object Lambda では無視されます。
この `WriteGetObjectResponse` API オペレーションを呼び出すとき、Amazon S3 はイベントコンテキストからのルートトークンとリクエストトークンを必要とします。詳細については、「[イベントコンテキストの形式と使用法](olap-event-context.md)」を参照してください。
ルートトークンとリクエストトークンのパラメータは、`WriteGetObjectResult` レスポンスを元の発信者に接続するために必要です。通常、500 (内部サーバーエラー) レスポンスを再試行するのが適切ですが、リクエストトークンはワンタイムトークンであることに注意してください。それ以降に使用を試みると、HTTP ステータスコード 400 (Bad Request) レスポンスが返されることになる可能性があります。ルートトークンとリクエストトークンを使用した `WriteGetObjectResponse` への呼び出しは、呼び出された Lambda 関数から作成する必要はありませんが、同じアカウント内のアイデンティティによって作成する必要があります。この呼び出しは、Lambda 関数の実行を完了する前に完了する必要があります。
## Lambdaでの `HeadObject` リクエストの処理
このセクションでは、Object Lambda アクセスポイントが `HeadObject` 用に Lambda 関数を呼び出すように設定されていることを前提としています。Lambda は `headObjectContext` というキーを含む JSON ペイロードを受け取ります。コンテキスト内には、`inputS3Url` というプロパティが 1 つあります。これは、`HeadObject` をサポートしているアクセスポイントの署名付き URL です。
署名付き URL に次のプロパティが指定されている場合、署名付き URL にはそれらが含まれます。
+ `versionId` (クエリパラメータ内)
+ `requestPayer` (`x-amz-request-payer` ヘッダー内)
+ `expectedBucketOwner` (`x-amz-expected-bucket-owner` ヘッダー内)
他のプロパティは署名付きではないため、含まれません。ヘッダーとして送信される署名されていないオプションは、`userRequest` ヘッダーにある署名付き URL を呼び出すときに、手動でリクエストに追加できます。サーバー側の暗号化オプションは、`HeadObject` ではサポートされていません。
リクエスト構文 URI パラメータについては、「*Amazon Simple Storage Service API リファレンス*」の「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html)」を参照してください。
次の例は、`HeadObject` の Lambda JSON 入力ペイロードを示しています。
```
{
"xAmzRequestId": "requestId",
"**headObjectContext**": {
"**inputS3Url**": "https://my-s3-ap-111122223333.s3-accesspoint.us-east-1.amazonaws.com/example?X-Amz-Security-Token="
},
"configuration": {
"accessPointArn": "arn:aws:s3-object-lambda:us-east-1:111122223333:accesspoint/example-object-lambda-ap",
"supportingAccessPointArn": "arn:aws:s3:us-east-1:111122223333:accesspoint/example-ap",
"payload": "{}"
},
"userRequest": {
"url": "https://object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com/example",
"headers": {
"Host": "object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com",
"Accept-Encoding": "identity",
"X-Amz-Content-SHA256": "e3b0c44298fc1example"
}
},
"userIdentity": {
"type": "AssumedRole",
"principalId": "principalId",
"arn": "arn:aws:sts::111122223333:assumed-role/Admin/example",
"accountId": "111122223333",
"accessKeyId": "accessKeyId",
"sessionContext": {
"attributes": {
"mfaAuthenticated": "false",
"creationDate": "Wed Mar 10 23:41:52 UTC 2021"
},
"sessionIssuer": {
"type": "Role",
"principalId": "principalId",
"arn": "arn:aws:iam::111122223333:role/Admin",
"accountId": "111122223333",
"userName": "Admin"
}
}
},
"protocolVersion": "1.00"
}
```
Lambda 関数は、`HeadObject` 呼び出しで返されるヘッダーと値を含む JSON オブジェクトを返します。
次の例は、`HeadObject` の Lambda レスポンス JSON の構造を示しています。
```
{
"statusCode": ; // Required
"errorCode": ;
"errorMessage": ;
"headers": {
"Accept-Ranges": ,
"x-amz-archive-status": ,
"x-amz-server-side-encryption-bucket-key-enabled": ,
"Cache-Control": ,
"Content-Disposition": ,
"Content-Encoding": ,
"Content-Language": ,
"Content-Length": , // Required
"Content-Type": ,
"x-amz-delete-marker": ,
"ETag": ,
"Expires": ,
"x-amz-expiration": ,
"Last-Modified": ,
"x-amz-missing-meta": ,
"x-amz-object-lock-mode": ,
"x-amz-object-lock-legal-hold": ,
"x-amz-object-lock-retain-until-date": ,
"x-amz-mp-parts-count": ,
"x-amz-replication-status": ,
"x-amz-request-charged": ,
"x-amz-restore": ,
"x-amz-server-side-encryption": ,
"x-amz-server-side-encryption-customer-algorithm": ,
"x-amz-server-side-encryption-aws-kms-key-id": ,
"x-amz-server-side-encryption-customer-key-MD5": ,
"x-amz-storage-class": ,
"x-amz-tagging-count": ,
"x-amz-version-id": ,
: , // user-defined metadata
"x-amz-meta-meta1": , // example of the user-defined metadata header, it will need the x-amz-meta prefix
"x-amz-meta-meta2":
...
};
}
```
次の例は、JSON を返す前に必要に応じてヘッダー値を変更することにより、署名付き URL を使用してレスポンスを入力する方法を示しています。
------
#### [ Python ]
```
import requests
def lambda_handler(event, context):
print(event)
# Extract the presigned URL from the input.
s3_url = event["headObjectContext"]["inputS3Url"]
# Get the head of the object from S3.
response = requests.head(s3_url)
# Return the error to S3 Object Lambda (if applicable).
if (response.status_code >= 400):
return {
"statusCode": response.status_code,
"errorCode": "RequestFailure",
"errorMessage": "Request to S3 failed"
}
# Store the headers in a dictionary.
response_headers = dict(response.headers)
# This obscures Content-Type in a transformation, it is optional to add
response_headers["Content-Type"] = ""
# Return the headers to S3 Object Lambda.
return {
"statusCode": response.status_code,
"headers": response_headers
}
```
------
## Lambda での `ListObjects` リクエストの使用
このセクションでは、Object Lambda アクセスポイントが `ListObjects` 用に Lambda 関数を呼び出すように設定されていることを前提としています。Lambda は、`listObjectsContext` という新しいオブジェクトを持つ JSON ペイロードを受け取ります。`listObjectsContext` には、`inputS3Url` という単一のプロパティが含まれており、これは `ListObjects` をサポートしているアクセスポイント用の署名付き URL です。
`GetObject` や `HeadObject` とは異なり、署名付き URL には、次のプロパティが指定されている場合はそれらが含まれます。
+ すべてのクエリパラメータ
+ `requestPayer` (`x-amz-request-payer` ヘッダー内)
+ `expectedBucketOwner` (`x-amz-expected-bucket-owner` ヘッダー内)
リクエスト構文 URI パラメータについては、「*Amazon Simple Storage Service API リファレンス*」の「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html)」を参照してください。
**重要**
アプリケーションを開発する場合は、新しいバージョンの [ListObjectSv2](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html) を使用することをお勧めします。Amazon S3 は、下位互換性のために、引き続き `ListObjects` をサポートしています。
次の例は、`ListObjects` の Lambda JSON 入力ペイロードを示しています。
```
{
"xAmzRequestId": "requestId",
"**listObjectsContext**": {
"**inputS3Url**": "https://my-s3-ap-111122223333.s3-accesspoint.us-east-1.amazonaws.com/?X-Amz-Security-Token=",
},
"configuration": {
"accessPointArn": "arn:aws:s3-object-lambda:us-east-1:111122223333:accesspoint/example-object-lambda-ap",
"supportingAccessPointArn": "arn:aws:s3:us-east-1:111122223333:accesspoint/example-ap",
"payload": "{}"
},
"userRequest": {
"url": "https://object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com/example",
"headers": {
"Host": "object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com",
"Accept-Encoding": "identity",
"X-Amz-Content-SHA256": "e3b0c44298fc1example"
}
},
"userIdentity": {
"type": "AssumedRole",
"principalId": "principalId",
"arn": "arn:aws:sts::111122223333:assumed-role/Admin/example",
"accountId": "111122223333",
"accessKeyId": "accessKeyId",
"sessionContext": {
"attributes": {
"mfaAuthenticated": "false",
"creationDate": "Wed Mar 10 23:41:52 UTC 2021"
},
"sessionIssuer": {
"type": "Role",
"principalId": "principalId",
"arn": "arn:aws:iam::111122223333:role/Admin",
"accountId": "111122223333",
"userName": "Admin"
}
}
},
"protocolVersion": "1.00"
}
```
Lambda 関数は、S3 Object Lambda から返されるステータスコード、XML 結果のリスト、またはエラー情報を含む JSON オブジェクトを返します。
S3 Object Lambda は `listResultXml` の処理も検証もせず、代わりに `ListObjects` 呼び出し元に転送します。`listBucketResult` については、S3 Object Lambda は特定のプロパティが特定のタイプであることを想定し、解析できない場合は例外をスローします。 `listResultXml` および `listBucketResult` を同時に提供することはできません。
次の例は、署名付き URL を使用して Amazon S3 を呼び出し、その結果を使用してエラーチェックを含むレスポンスを入力する方法を示しています。
------
#### [ Python ]
```
import requests
import xmltodict
def lambda_handler(event, context):
# Extract the presigned URL from the input.
s3_url = event["listObjectsContext"]["inputS3Url"]
# Get the head of the object from Amazon S3.
response = requests.get(s3_url)
# Return the error to S3 Object Lambda (if applicable).
if (response.status_code >= 400):
error = xmltodict.parse(response.content)
return {
"statusCode": response.status_code,
"errorCode": error["Error"]["Code"],
"errorMessage": error["Error"]["Message"]
}
# Store the XML result in a dict.
response_dict = xmltodict.parse(response.content)
# This obscures StorageClass in a transformation, it is optional to add
for item in response_dict['ListBucketResult']['Contents']:
item['StorageClass'] = ""
# Convert back to XML.
listResultXml = xmltodict.unparse(response_dict)
# Create response with listResultXml.
response_with_list_result_xml = {
'statusCode': 200,
'listResultXml': listResultXml
}
# Create response with listBucketResult.
response_dict['ListBucketResult'] = sanitize_response_dict(response_dict['ListBucketResult'])
response_with_list_bucket_result = {
'statusCode': 200,
'listBucketResult': response_dict['ListBucketResult']
}
# Return the list to S3 Object Lambda.
# Can return response_with_list_result_xml or response_with_list_bucket_result
return response_with_list_result_xml
# Converting the response_dict's key to correct casing
def sanitize_response_dict(response_dict: dict):
new_response_dict = dict()
for key, value in response_dict.items():
new_key = key[0].lower() + key[1:] if key != "ID" else 'id'
if type(value) == list:
newlist = []
for element in value:
if type(element) == type(dict()):
element = sanitize_response_dict(element)
newlist.append(element)
value = newlist
elif type(value) == dict:
value = sanitize_response_dict(value)
new_response_dict[new_key] = value
return new_response_dict
```
------
次の例は、`ListObjects` の Lambda レスポンス JSON の構造を示しています。
```
{
"statusCode": ; // Required
"errorCode": ;
"errorMessage": ;
"listResultXml": ; // This can also be Error XML string in case S3 returned error response when calling the pre-signed URL
"listBucketResult": { // listBucketResult can be provided instead of listResultXml, however they can not both be provided in the JSON response
"name": , // Required for 'listBucketResult'
"prefix": ,
"marker": ,
"nextMarker": ,
"maxKeys": , // Required for 'listBucketResult'
"delimiter": ,
"encodingType":
"isTruncated": , // Required for 'listBucketResult'
"contents": [ {
"key": , // Required for 'content'
"lastModified": ,
"eTag": ,
"checksumAlgorithm": , // CRC32, CRC32C, SHA1, SHA256
"size": , // Required for 'content'
"owner": {
"displayName": , // Required for 'owner'
"id": , // Required for 'owner'
},
"storageClass":
},
...
],
"commonPrefixes": [ {
"prefix": // Required for 'commonPrefix'
},
...
],
}
}
```
## Lambda での `ListObjectsV2` リクエストの使用
このセクションでは、Object Lambda アクセスポイントが `ListObjectsV2` 用に Lambda 関数を呼び出すように設定されていることを前提としています。Lambda は、`listObjectsV2Context` という新しいオブジェクトを持つ JSON ペイロードを受け取ります。`listObjectsV2Context` には、`inputS3Url` という単一のプロパティが含まれており、これは `ListObjectsV2` をサポートしているアクセスポイント用の署名付き URL です。
`GetObject` や `HeadObject` とは異なり、署名付き URL には、次のプロパティが指定されている場合はそれらが含まれます。
+ すべてのクエリパラメータ
+ `requestPayer` (`x-amz-request-payer` ヘッダー内)
+ `expectedBucketOwner` (`x-amz-expected-bucket-owner` ヘッダー内)
リクエスト構文 URI パラメータについては、「*Amazon Simple Storage Service API リファレンス*」の「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html)」を参照してください。
次の例は、`ListObjectsV2` の Lambda JSON 入力ペイロードを示しています。
```
{
"xAmzRequestId": "requestId",
"**listObjectsV2Context**": {
"**inputS3Url**": "https://my-s3-ap-111122223333.s3-accesspoint.us-east-1.amazonaws.com/?list-type=2&X-Amz-Security-Token=",
},
"configuration": {
"accessPointArn": "arn:aws:s3-object-lambda:us-east-1:111122223333:accesspoint/example-object-lambda-ap",
"supportingAccessPointArn": "arn:aws:s3:us-east-1:111122223333:accesspoint/example-ap",
"payload": "{}"
},
"userRequest": {
"url": "https://object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com/example",
"headers": {
"Host": "object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com",
"Accept-Encoding": "identity",
"X-Amz-Content-SHA256": "e3b0c44298fc1example"
}
},
"userIdentity": {
"type": "AssumedRole",
"principalId": "principalId",
"arn": "arn:aws:sts::111122223333:assumed-role/Admin/example",
"accountId": "111122223333",
"accessKeyId": "accessKeyId",
"sessionContext": {
"attributes": {
"mfaAuthenticated": "false",
"creationDate": "Wed Mar 10 23:41:52 UTC 2021"
},
"sessionIssuer": {
"type": "Role",
"principalId": "principalId",
"arn": "arn:aws:iam::111122223333:role/Admin",
"accountId": "111122223333",
"userName": "Admin"
}
}
},
"protocolVersion": "1.00"
}
```
Lambda 関数は、S3 Object Lambda から返されるステータスコード、XML 結果のリスト、またはエラー情報を含む JSON オブジェクトを返します。
S3 Object Lambda は `listResultXml` の処理も検証もせず、代わりに `ListObjectsV2` 呼び出し元に転送します。`listBucketResult` については、S3 Object Lambda は特定のプロパティが特定のタイプであることを想定し、解析できない場合は例外をスローします。 `listResultXml` および `listBucketResult` を同時に提供することはできません。
次の例は、署名付き URL を使用して Amazon S3 を呼び出し、その結果を使用してエラーチェックを含むレスポンスを入力する方法を示しています。
------
#### [ Python ]
```
import requests
import xmltodict
def lambda_handler(event, context):
# Extract the presigned URL from the input.
s3_url = event["listObjectsV2Context"]["inputS3Url"]
# Get the head of the object from Amazon S3.
response = requests.get(s3_url)
# Return the error to S3 Object Lambda (if applicable).
if (response.status_code >= 400):
error = xmltodict.parse(response.content)
return {
"statusCode": response.status_code,
"errorCode": error["Error"]["Code"],
"errorMessage": error["Error"]["Message"]
}
# Store the XML result in a dict.
response_dict = xmltodict.parse(response.content)
# This obscures StorageClass in a transformation, it is optional to add
for item in response_dict['ListBucketResult']['Contents']:
item['StorageClass'] = ""
# Convert back to XML.
listResultXml = xmltodict.unparse(response_dict)
# Create response with listResultXml.
response_with_list_result_xml = {
'statusCode': 200,
'listResultXml': listResultXml
}
# Create response with listBucketResult.
response_dict['ListBucketResult'] = sanitize_response_dict(response_dict['ListBucketResult'])
response_with_list_bucket_result = {
'statusCode': 200,
'listBucketResult': response_dict['ListBucketResult']
}
# Return the list to S3 Object Lambda.
# Can return response_with_list_result_xml or response_with_list_bucket_result
return response_with_list_result_xml
# Converting the response_dict's key to correct casing
def sanitize_response_dict(response_dict: dict):
new_response_dict = dict()
for key, value in response_dict.items():
new_key = key[0].lower() + key[1:] if key != "ID" else 'id'
if type(value) == list:
newlist = []
for element in value:
if type(element) == type(dict()):
element = sanitize_response_dict(element)
newlist.append(element)
value = newlist
elif type(value) == dict:
value = sanitize_response_dict(value)
new_response_dict[new_key] = value
return new_response_dict
```
------
次の例は、`ListObjectsV2` の Lambda レスポンス JSON の構造を示しています。
```
{
"statusCode": ; // Required
"errorCode": ;
"errorMessage": ;
"listResultXml": ; // This can also be Error XML string in case S3 returned error response when calling the pre-signed URL
"listBucketResult": { // listBucketResult can be provided instead of listResultXml, however they can not both be provided in the JSON response
"name": , // Required for 'listBucketResult'
"prefix": ,
"startAfter": ,
"continuationToken": ,
"nextContinuationToken": ,
"keyCount": , // Required for 'listBucketResult'
"maxKeys": , // Required for 'listBucketResult'
"delimiter": ,
"encodingType":
"isTruncated": , // Required for 'listBucketResult'
"contents": [ {
"key": , // Required for 'content'
"lastModified": ,
"eTag": ,
"checksumAlgorithm": , // CRC32, CRC32C, SHA1, SHA256
"size": , // Required for 'content'
"owner": {
"displayName": , // Required for 'owner'
"id": , // Required for 'owner'
},
"storageClass":
},
...
],
"commonPrefixes": [ {
"prefix": // Required for 'commonPrefix'
},
...
],
}
}
```
# イベントコンテキストの形式と使用法
**注記**
2025 年 11 月 7 日現在、S3 Object Lambda は、現在サービスを使用している既存のお客様、および一部の AWS パートナーネットワーク (APN) パートナーのみが利用できます。S3 Object Lambda と同様の機能の詳細については、「[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)」を参照してください。
Amazon S3 Object Lambda は、AWS Lambda 関数に渡されたイベントで行われたリクエストに関するコンテキストを提供します。リクエストの例を次に示します。フィールドの説明は例の後に含まれています。
```
{
"xAmzRequestId": "requestId",
"getObjectContext": {
"inputS3Url": "https://my-s3-ap-111122223333.s3-accesspoint.us-east-1.amazonaws.com/example?X-Amz-Security-Token=",
"outputRoute": "io-use1-001",
"outputToken": "OutputToken"
},
"configuration": {
"accessPointArn": "arn:aws:s3-object-lambda:us-east-1:111122223333:accesspoint/example-object-lambda-ap",
"supportingAccessPointArn": "arn:aws:s3:us-east-1:111122223333:accesspoint/example-ap",
"payload": "{}"
},
"userRequest": {
"url": "https://object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com/example",
"headers": {
"Host": "object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com",
"Accept-Encoding": "identity",
"X-Amz-Content-SHA256": "e3b0c44298fc1example"
}
},
"userIdentity": {
"type": "AssumedRole",
"principalId": "principalId",
"arn": "arn:aws:sts::111122223333:assumed-role/Admin/example",
"accountId": "111122223333",
"accessKeyId": "accessKeyId",
"sessionContext": {
"attributes": {
"mfaAuthenticated": "false",
"creationDate": "Wed Mar 10 23:41:52 UTC 2021"
},
"sessionIssuer": {
"type": "Role",
"principalId": "principalId",
"arn": "arn:aws:iam::111122223333:role/Admin",
"accountId": "111122223333",
"userName": "Admin"
}
}
},
"protocolVersion": "1.00"
}
```
リクエストには次のフィールドが含まれます。
+ `xAmzRequestId` － このリクエストの Amazon S3 リクエスト ID。デバッグに役立つように、この値をログに記録することをお勧めします。
+ `getObjectContext` － Amazon S3 および S3 Object Lambda への接続に関する入力および出力の詳細。
+ `inputS3Url` － Amazon S3 から元のオブジェクトを取得するために使用できる署名付き URL。URL は元の発信者のアイデンティティを使用して署名され、URL が使用されるときにそのユーザーのアクセス許可が適用されます。URL に署名されたヘッダーがある場合、Lambda 関数では、`Host` ヘッダーを除き、Amazon S3 への呼び出しにこれらのヘッダーを含める必要があります。
+ `outputRoute` – Lambda 関数が を呼び出すときに S3 Object Lambda URL に追加されるルーティングトークン。`WriteGetObjectResponse`
+ `outputToken` - `WriteGetObjectResponse` 呼び出しを元の発信者と一致させるために、S3 Object Lambda によって使用される不透明なトークン。
+ `configuration` - Object Lambda アクセスポイントに関する設定情報。
+ `accessPointArn` - このリクエストを受信した Object Lambda アクセスポイントの Amazon リソースネーム (ARN)。
+ `supportingAccessPointArn` - Object Lambda アクセスポイント設定で指定されているサポートアクセスポイントの ARN。
+ `payload` - Object Lambda アクセスポイント設定に適用されるカスタムデータ。S3 Object Lambda はこのデータを不透明な文字列として扱うため、使用前にデコードする必要がある場合があります。
+ `userRequest` - S3 Object Lambda への元の呼び出しに関する情報。
+ `url` - S3 Object Lambda で受信したリクエストのデコードされた URL。認可関連のクエリパラメータは除きます。
+ `headers` - HTTP ヘッダーと元の呼び出しからの値を含む文字列への文字列マップ。認可関連のヘッダーは含まれません。同じヘッダーが複数回表示される場合、同じヘッダーの各インスタンスからの値は、コンマ区切りのリストに結合されます。元のヘッダーの大文字と小文字は、このマップに保持されます。
+ `userIdentity` – S3 Object Lambda への呼び出しを行ったアイデンティティの詳細。詳細については、**「AWS CloudTrail ユーザーガイド」の「[証跡のデータイベントの記録](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html)」を参照してください。
+ `type` – アイデンティティのタイプ。
+ `accountId` - アイデンティティが属するAWS アカウント。
+ `userName` - 呼び出しを行ったアイデンティティのわかりやすい名前。
+ `principalId` - 呼び出しを行ったアイデンティティの一意の識別子。
+ `arn` – 呼び出しを行ったプリンシパルの ARN。ARN の最後のセクションには、呼び出しを行ったユーザーまたはロールが含まれています。
+ `sessionContext` - リクエストが、一時的セキュリティ認証情報を使用して行われた場合、このエレメントはこれらの認証情報のために作成されたセッションに関する情報を提供します。
+ `invokedBy` – Amazon EC2 Auto Scaling や AWS Elastic Beanstalk など、リクエストを行った AWS のサービス の名前。
+ `sessionIssuer` - リクエストが一時的セキュリティ認証情報を使用して行われた場合、このエレメントは認証情報がどのように取得されたかに関する情報を提供します。
+ `protocolVersion` – 提供されるコンテキストのバージョン ID。このフィールドの形式は `{Major Version}.{Minor Version}` です。マイナーバージョン番号は、常に 2 桁の数字です。フィールドのセマンティクスを削除または変更する場合は、メジャーバージョンバンプが必要となり、アクティブなオプトインが必要になります。Amazon S3 ではいつでも新しいフィールドを追加できます。この時点で、マイナーバージョンのバンプが発生する可能性があります。ソフトウェアのロールアウトの性質上、一度に複数のマイナーバージョンが使用されている場合があります。
# Range および partNumber ヘッダーの操作
**注記**
2025 年 11 月 7 日現在、S3 Object Lambda は、現在サービスを使用している既存のお客様、および一部の AWS パートナーネットワーク (APN) パートナーのみが利用できます。S3 Object Lambda と同様の機能の詳細については、「[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)」を参照してください。
Amazon S3 Object Lambda で大規模なオブジェクトを操作する場合は、`Range` HTTP ヘッダーを使用して、オブジェクトから指定されたバイト範囲をダウンロードできます。同じオブジェクトのさまざまなバイト範囲をフェッチするには、Amazon S3 への同時接続を使用できます。また、オブジェクトの指定されたパートに対して範囲リクエストを実行する `partNumber` パラメータ(1～10,000 の整数) を指定することもできます。
`Range` または `partNumber` のパラメータを含んだリクエストを処理するには、複数の方法があるため、S3 オブジェクト Lambda ではこれらのパラメータを変換されたオブジェクトに適用しません。代わりに、AWS Lambda 関数は、アプリケーションで必要に応じてこの機能を実装する必要があります。
S3 Object Lambda で `Range` および `partNumber` パラメータを使用するには、次の操作を行います。
+ Object Lambda アクセスポイントの設定でこれらのパラメータを有効にします。
+ これらのパラメータを含むリクエストを処理できる Lambda 関数を作成します。
次のステップでそのやり方を説明します。
## ステップ 1: Object Lambda アクセスポイントの設定
デフォルトでは、オブジェクト Lambda アクセスポイントは、ヘッダーまたはクエリパラメータに `Range` または `partNumber` パラメータを含む `GetObject` または `HeadObject` リクエストに対して、HTTP ステータスコード 501 (未実装) エラーで応答します。
Object Lambda アクセスポイントがこのようなリクエストを有効にするには、Object Lambda アクセスポイント設定の `AllowedFeatures` セクションに `GetObject-Range`、`GetObject-PartNumber`、`HeadObject-Range`、または `HeadObject-PartNumber` を含める必要があります。Object Lambda アクセスポイントの設定の更新の詳細については、「[Object Lambda アクセスポイントの作成](olap-create.md)」を参照してください。
## ステップ 2: Lambda 関数で `Range` または `partNumber` 処理を実装する
Object Lambda アクセスポイントが範囲 `GetObject` または `HeadObject` のリクエストで Lambda 関数を呼び出すとき、`Range` または `partNumber` パラメータはイベントコンテキストに含まれます。イベントコンテキストでのパラメータの場所は、次の表で説明するように、使用されたパラメータと Object Lambda アクセスポイントへの元のリクエストにどのように Lambda 含まれていたかによって異なります。
| パラメータ | イベントコンテキストの場所 |
| --- | --- |
| `Range` (ヘッダー) | `userRequest.headers.Range` |
| `Range` (クエリパラメータ) | `userRequest.url` (クエリパラメータ `Range`) |
| `partNumber` | `userRequest.url` (クエリパラメータ `partNumber`) |
**重要**
指定された Object Lambda アクセスポイントの署名付き URL には、元のリクエストの `Range` または `partNumber` パラメータが含まれていません。AWS Lambda 関数でこれらのパラメータを処理する方法については、以下のオプションを参照してください。
`Range` または `partNumber` の値を抽出した後に、アプリケーションのニーズに基づいて、次のいずれかの方法を使用できます。
1. **リクエストされた `Range` または `partNumber` を変換されたオブジェクトにマッピングします (推奨)。**
`Range` または `partNumber` リクエストを処理する最も確実な方法は、以下を実行することです。
+ Amazon S3 から完全なオブジェクトを取得します。
+ オブジェクトを変換します。
+ リクエストされた `Range` または `partNumber` パラメータを変換後のオブジェクトに適用します。
これを行うには、指定された署名付き URL を使用して Amazon S3 からオブジェクト全体をフェッチし、必要に応じてオブジェクトを処理します。例の Lambda 関数では、この方法で `Range` パラメータを設定し、AWS サンプル GitHub リポジトリの[「このサンプル」](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration/blob/main/function/nodejs_20_x/src/response/range_mapper.ts)を参照してください。
1. **リクエストされた `Range` を署名付き URL にマッピングします。**
場合によっては、Lambda 関数でリクエストされた `Range` を署名済み URL に直接マッピングして、Amazon S3 からオブジェクトの一部のみを取得できます。このアプローチは、変換が次の両方の条件を満たしている場合にのみ適切です。
1. 変換関数は、部分的なオブジェクト範囲に適用できます。
1. 変換関数の前または後に `Range` パラメータを指定すると、同じ変換後のオブジェクトになります。
たとえば、ASCII エンコードオブジェクト内のすべての文字を大文字に変換する変換関数は、上記の両方の条件を満たします。変換はオブジェクトの一部に適用でき、変換前に `Range` パラメータを適用すると、変換後にパラメータを適用するのと同じ結果が得られます。
対照的に、ASCII エンコードされたオブジェクトの文字を反転する関数は、これらの条件を満たしていません。このような関数は、部分的なオブジェクト範囲に適用できるため、基準 1 を満たしています。ただし、基準 2 を満たしていません。なぜなら、`Range` パラメータを変換前に適用した場合と、変換後にパラメータを適用する場合とは結果が異なるためです。
コンテンツ `abcdefg` を含むオブジェクトの最初の 3 文字に関数を適用するリクエストを考えてみましょう。変換前にの `Range` パラメータを適用すると `abc` のみが取得され、その後、データを逆にして戻すと `cba` が取得されます。しかし、変換後にパラメータが適用された場合、関数はオブジェクト全体を取得し、それを反転し、`Range` パラメータを適用して、`gfe` を返します。これらの結果は異なるため、この関数は Amazon S3 からオブジェクトを取得する際に、`Range` パラメータを適用すべきではありません。代わりに、オブジェクト全体を取得し、変換を実行してから、`Range` パラメータを適用する必要があります。
**警告**
多くの場合、`Range` パラメータを署名済み URL に適用すると、Lambda 関数またはリクエスト元のクライアントによる予期しない動作が発生します。Amazon S3 から部分的なオブジェクトのみを取得するときにアプリケーションが正常に動作することが確実でない限り、アプローチ A で前述したように、完全なオブジェクトを取得して変換することをお勧めします。
アプリケーションがアプローチ B の基準を満たしていれば、要求されたオブジェクト範囲のみをフェッチし、その範囲で変換を実行することで、AWS Lambda 関数を単純化することができます。
次の Java コードの例では、次の処理を実行する方法を示します。
+ `GetObject` リクエストから `Range` ヘッダーを取得します。
+ Lambda が Amazon S3 からリクエストされた範囲を取得するために使用できる署名付き URL に `Range` ヘッダーを追加します。
```
private HttpRequest.Builder applyRangeHeader(ObjectLambdaEvent event, HttpRequest.Builder presignedRequest) {
var header = event.getUserRequest().getHeaders().entrySet().stream()
.filter(e -> e.getKey().toLowerCase(Locale.ROOT).equals("range"))
.findFirst();
// Add check in the query string itself.
header.ifPresent(entry -> presignedRequest.header(entry.getKey(), entry.getValue()));
return presignedRequest;
}
```
# AWS で構築された Lambda 関数の使用
**注記**
2025 年 11 月 7 日現在、S3 Object Lambda は、現在サービスを使用している既存のお客様、および一部の AWS パートナーネットワーク (APN) パートナーのみが利用できます。S3 Object Lambda と同様の機能の詳細については、「[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)」を参照してください。
AWS には、あらかじめ構築された AWS Lambda 関数が用意されています。これを Amazon S3 Object Lambda と共に使用して、個人を特定できる情報 (PII) を検出して編集したり、S3 オブジェクトを解凍したりできます。これらの Lambda 関数は AWS Serverless Application Repository にあります。これらの関数は、Object Lambda アクセスポイントの作成時に AWS マネジメントコンソール から選択できます。
AWS Serverless Application Repository からサーバーレスアプリケーションをデプロイする方法の詳細については、「*AWS Serverless Application Repository デベロッパーガイド*」の「[Deploying Applications](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-consuming-applications.html)」を参照してください。
**注記**
次の例は `GetObject` リクエストでのみ使用できます。
## 例 1: PII アクセスコントロール
Lambda 関数は Amazon Comprehend を使用します。これは、機械学習を使用してテキスト内でインサイトや関係性を検出する自然言語処理 (NLP) サービスです。この関数は、Amazon S3 バケット内のドキュメントから、名前、住所、日付、クレジットカード番号、社会保障番号などの個人を特定できる情報 (PII) を自動的に検出します。バケットに PII を含むドキュメントがある場合、PII アクセスコントロール関数を設定して、PII エンティティタイプを検出し、許可されていないユーザーへのアクセスを制限できます。
使用開始するには、アカウントに次の Lambda 関数をデプロイし、関数の Amazon リソースネーム (ARN) を Object Lambda アクセスポイント設定に追加します。
この関数の ARN の例を以下に示します。
```
arn:aws:serverlessrepo:us-east-1:111122223333:applications/ComprehendPiiAccessControlS3ObjectLambda
```
AWS マネジメントコンソール でこの関数をビューに追加するには、次の AWS Serverless Application Repository リンクを使用します。[ComprehendPiiAccessControlS3ObjectLambda](https://console.aws.amazon.com/lambda/home#/create/app?applicationId=arn:aws:serverlessrepo:us-east-1:839782855223:applications/ComprehendPiiAccessControlS3ObjectLambda)
GitHub でこの関数を表示するには、「[Amazon Comprehend S3 Object Lambda](https://github.com/aws-samples/amazon-comprehend-s3-object-lambdas)」 を参照してください。
## 例 2: PII Redaction
Lambda 関数は Amazon Comprehend を使用します。これは、機械学習を使用してテキスト内でインサイトや関係性を検出する自然言語処理 (NLP) サービスです。この関数は、Amazon S3 バケット内のドキュメントから、名前、住所、日付、クレジットカード番号、社会保障番号などの個人を特定できる情報 (PII) を自動的にマスキングします。
クレジットカード番号や銀行口座情報などの情報を含むドキュメントがバケットにある場合は、PII Redaction S3 Object Lambda 関数を設定して、PII を検出し、PII エンティティタイプがマスキングされたドキュメントのコピーを返すように設定できます。
使用開始するには、アカウントに次の Lambda 関数をデプロイし、関数の ARN を Object Lambda アクセスポイント設定に追加します。
この関数の ARN の例を以下に示します。
```
arn:aws:serverlessrepo:us-east-1:111122223333::applications/ComprehendPiiRedactionS3ObjectLambda
```
AWS マネジメントコンソール にこの関数を表示または追加するには、次の AWS Serverless Application Repository リンクを使用します。[ComprehendPiiRedactionS3ObjectLambda](https://console.aws.amazon.com/lambda/home#/create/app?applicationId=arn:aws:serverlessrepo:us-east-1:839782855223:applications/ComprehendPiiRedactionS3ObjectLambda)
GitHub でこの関数を表示するには、「[Amazon Comprehend S3 Object Lambda](https://github.com/aws-samples/amazon-comprehend-s3-object-lambdas)」を参照してください。
PII リダクションにおけるいくつかの S3 Object Lambda タスクにおけるエンドツーエンドの一連の手順については、「[チュートリアル: S3 Object Lambda と Amazon Comprehend を使用した PII データの検出と編集](tutorial-s3-object-lambda-redact-pii.md)」を参照してください。
## 例 3: 解凍
Lambda 関数 `S3ObjectLambdaDecompression` は、Amazon S3 に格納されているオブジェクトを、次の 6 つの圧縮ファイル形式のうちの 1 つで解凍できます。`bzip2`、`gzip`、`snappy`、`zlib`、`zstandard`、および `ZIP`。
使用開始するには、アカウントに次の Lambda 関数をデプロイし、関数の ARN を Object Lambda アクセスポイント設定に追加します。
この関数の ARN の例を以下に示します。
```
arn:aws:serverlessrepo:us-east-1:111122223333::applications/S3ObjectLambdaDecompression
```
AWS マネジメントコンソール でこの関数をビューに追加するには、次の AWS Serverless Application Repository リンクを使用します。[S3ObjectLambdaDecompression](https://eu-west-1.console.aws.amazon.com/lambda/home?region=eu-west-1#/create/app?applicationId=arn:aws:serverlessrepo:eu-west-1:123065155563:applications/S3ObjectLambdaDecompression)
GitHub でこの関数を表示するには、「[S3 Object Lambda Decompression](https://github.com/aws-samples/amazon-s3-object-lambda-decompression)」(S3 Object Lambda の解凍) を参照してください。
# S3 Object Lambda のベストプラクティスとガイドライン
**注記**
2025 年 11 月 7 日現在、S3 Object Lambda は、現在サービスを使用している既存のお客様、および一部の AWS パートナーネットワーク (APN) パートナーのみが利用できます。S3 Object Lambda と同様の機能の詳細については、「[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)」を参照してください。
S3 Object Lambda を使用する場合は、操作とパフォーマンスを最適化するには、以下のベストプラクティスとガイドラインに従ってください。
**Topics**
+ [S3 Object Lambda の使用](#olap-working-with)
+ [S3 Object Lambda に関連して使用される AWS のサービス](#olap-services)
+ [`Range` および `partNumber` ヘッダー](#olap-managing-range-part)
+ [`expiry-date` の変換](#olap-console-download)
+ [AWS CLI と AWS SDK の使用](#olap-cli-sdk)
## S3 Object Lambda の使用
S3 Object Lambda は、`GET`、`LIST`、および `HEAD` リクエストの処理のみをサポートします。他のリクエストは AWS Lambda を呼び出さず、標準の変換されていない API レスポンスを返します。リージョンごとに AWS アカウント あたり最大 1,000 個の Object Lambda アクセスポイントを作成できます。使用する AWS Lambda 関数は、Object Lambda アクセスポイントと同じ AWS アカウントおよびリージョンに存在する必要があります。
S3 Object Lambda では、発信者に完全なレスポンスをストリームするのに最大 60 秒かかります。関数には、AWS Lambda のデフォルトクォータも適用されます。詳細については、*AWS Lambda デベロッパーガイド*の「[Lambda のクォータ](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html)」を参照してください。
S3 Object Lambda が指定された Lambda 関数を呼び出す場合、データが指定された Lambda 関数またはアプリケーションによって意図的に上書きまたは Amazon S3 から削除され、それが正しいことを確認する責任は、ユーザーにあります。
S3 Object Lambda は、オブジェクトに対する操作の実行にのみ使用できます。S3 Object Lambda を使用して、バケットの変更や削除など、他の Amazon S3 オペレーションを実行することはできません。アクセスポイントをサポートする S3 オペレーションの詳細なリストについては、「[S3 オペレーションとアクセスポイントの互換性](access-points-service-api-support.md#access-points-operations-support)」を参照してください。
このリストに加えて、Object Lambda アクセスポイントは [https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)、[https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html) (ソースとして)、および [https://docs.aws.amazon.com/AmazonS3/latest/API/API_SelectObjectContent.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_SelectObjectContent.html) API オペレーションをサポートしていません。
## S3 Object Lambda に関連して使用される AWS のサービス
S3 Object Lambda は、Amazon S3、AWS Lambda、およびオプションで、リクエストしているアプリケーションに関連するオブジェクトを配信するために選択した他の AWS のサービス を接続します。S3 Object Lambda で使用されるすべての AWS のサービス は、それぞれのサービスレベルアグリーメント (SLA) に準拠します。例えば、AWS のサービス がサービスコミットメントを満たさない場合は、そのサービスの SLA に記されたとおり、ユーザーにはサービスクレジットを受け取る資格が発生します。
## `Range` および `partNumber` ヘッダー
大規模なオブジェクトを操作する場合は、`Range` HTTP ヘッダーを使用して、オブジェクトから指定されたバイト範囲をダウンロードできます。`Range` ヘッダーを使用すると、リクエストはオブジェクトの指定された部分のみをフェッチします。`partNumber` ヘッダーは、オブジェクトから指定されたパートに対して範囲リクエストを実行するためにも使用できます。
詳細については、「[Range および partNumber ヘッダーの操作](range-get-olap.md)」を参照してください。
## `expiry-date` の変換
AWS マネジメントコンソール の Object Lambda アクセスポイントから、変換されたオブジェクトを開いたり、ダウンロードしたりできます。これらのオブジェクトは、期限が切れていないものである必要があります。Lambda 関数でオブジェクトの `expiry-date` を変換すると、開いたりダウンロードしたりできない期限切れのオブジェクトが表示されることがあります。この動作は、S3 Glacier Flexible Retrieval、および S3 Glacier Deep Archive の復元されたオブジェクトにのみ適用されます。
## AWS CLI と AWS SDK の使用
AWS Command Line Interface (AWS CLI) S3 サブコマンド (`cp`、`mv`、および `sync`)、および AWS SDK for Java `TransferManager` クラスについては、S3 Object Lambda での使用はサポートされていません。
# S3 Object Lambda のチュートリアル
**注記**
2025 年 11 月 7 日現在、S3 Object Lambda は、現在サービスを使用している既存のお客様、および一部の AWS パートナーネットワーク (APN) パートナーのみが利用できます。S3 Object Lambda と同様の機能の詳細については、「[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)」を参照してください。
次のチュートリアルでは、いくつかの S3 Object Lambda タスクにおけるエンドツーエンドの一連の手順について説明します。
S3 Object Lambda を使用すると、独自のコードを追加して、データがアプリケーションに返される前に S3 からのデータを処理できます。以下のチュートリアルでは、既存のオブジェクトを変更したり、データの複数のコピーを維持したりすることなく、Amazon S3 から取得されるデータを変更します。最初のチュートリアルでは、S3 GET リクエストに AWS Lambda 関数を追加して、S3 から取得したオブジェクトを変更する方法について説明します。2 番目のチュートリアルでは、Amazon Comprehend を搭載した構築済みの Lambda 関数を使用して、S3 から取得した個人を特定できる情報 (PII) をアプリケーションに返す前に保護する方法を示します。3 番目のチュートリアルでは、S3 Object Lambda を使用してAmazon S3から取得されるイメージに透かしを追加します。
+ [チュートリアル: S3 Object Lambda を使用したアプリケーションのデータの変換](tutorial-s3-object-lambda-uppercase.md)
+ [チュートリアル: S3 Object Lambda と Amazon Comprehend を使用した PII データの検出と編集](tutorial-s3-object-lambda-redact-pii.md)
+ [チュートリアル: S3 Object Lambda を使用して、取得時に画像に動的に透かしを入れる](https://aws.amazon.com/getting-started/hands-on/amazon-s3-object-lambda-to-dynamically-watermark-images/?ref=docs_gateway/amazons3/olap-tutorials.html)
# チュートリアル: S3 Object Lambda を使用したアプリケーションのデータの変換
**注記**
2025 年 11 月 7 日現在、S3 Object Lambda は、現在サービスを使用している既存のお客様、および一部の AWS パートナーネットワーク (APN) パートナーのみが利用できます。S3 Object Lambda と同様の機能の詳細については、「[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)」を参照してください。
Amazon S3 にデータを保管すると、複数のアプリケーションで使用するために簡単にデータを共有できます。ただし、各アプリケーションには固有のデータ形式の要件があり、特定のユースケースでデータの変更や処理が必要になる場合があります。例えば、e コマースアプリケーションによって作成されたデータセットには、個人を特定できる情報 (PII) が含まれている場合があります。分析のために同じデータが処理される場合、この PII は必要ないため、編集する必要があります。ただし、同じデータセットをマーケティングキャンペーンに使用する場合は、顧客ロイヤルティデータベースからの情報など、追加の詳細でデータを充実させる必要がある場合があります。
[S3 Object Lambda](https://aws.amazon.com/s3/features/object-lambda) を使用すると、独自のコードを追加して、データがアプリケーションに返される前に S3 からのデータを処理できます。具体的には、AWS Lambda 関数を設定して、S3 Object Lambda アクセスポイントにアタッチします。アプリケーションが S3 Object Lambda アクセスポイントを介して[標準 S3 GET リクエスト](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)を送信すると、指定された Lambda 関数が呼び出され、サポートする S3 アクセスポイントを介して基盤となるデータソースから取得されたデータが処理されます。その後、S3 Object Lambda アクセスポイントは、変換された結果をアプリケーションに返します。独自のカスタム Lambda 関数を作成して実行し、S3 Object Lambda データ変換を特定のユースケースに合わせて調整できます。すべて、アプリケーションの変更は不要です。
![\[これは S3 Object Lambda ワークフロー図です。\]](http://docs.aws.amazon.com/ja_jp/AmazonS3/latest/userguide/images/ol-example-image-global.png)
**目的**
このチュートリアルでは、標準の S3 GET リクエストにカスタムコードを追加して、リクエストしたクライアントまたはアプリケーションのニーズに合うように、S3 から取得したリクエストされたオブジェクトを変更する方法を学習します。具体的には、S3 バケットに保存されている元のオブジェクトのすべてのテキストを S3 Object Lambda を使用して大文字に変換する方法を学習します。
**注記**
このチュートリアルでは、Python コードを使用してデータを変換します。他の AWS SDK の使用例については、AWS SDK コードサンプルライブラリの「[S3 Object Lambda でアプリケーションのデータを変換する](https://docs.aws.amazon.com/code-library/latest/ug/lambda_example_cross_ServerlessS3DataTransformation_section.html)」を参照してください。
**Topics**
+ [前提条件](#ol-upper-prerequisites)
+ [ステップ 1: S3 バケットを作成する](#ol-upper-step1)
+ [ステップ 2: S3 バケットにファイルをアップロード](#ol-upper-step2)
+ [ステップ 3: S3 アクセスポイントの作成](#ol-upper-step3)
+ [ステップ 4: Lambda 関数を作成する](#ol-upper-step4)
+ [ステップ 5: Lambda 関数の実行ロールの IAM ポリシーを設定する](#ol-upper-step5)
+ [ステップ 6: Object Lambda アクセスポイントの作成](#ol-upper-step6)
+ [ステップ 7: 変換されたデータを表示する](#ol-upper-step7)
+ [ステップ 8: クリーンアップする](#ol-upper-step8)
+ [次のステップ](#ol-upper-next-steps)
## 前提条件
このチュートリアルを開始する前に、適切な許可が付与された AWS Identity and Access Management (IAM) ユーザーとしてサインインできる AWS アカウントが必要です。また、バージョン 3.8 以降の Python をインストールする必要があります。
**Topics**
+ [AWS アカウントでアクセス許可を持つ IAM ユーザーを作成します (コンソール)。](#ol-upper-prerequisites-account)
+ [ローカルマシンに Python 3.8 以降をインストールする](#ol-upper-prerequisites-python)
### AWS アカウントでアクセス許可を持つ IAM ユーザーを作成します (コンソール)。
チュートリアル用の IAM ユーザーを作成できます。このチュートリアルを完了するには、IAM ユーザーが次の IAM ポリシーをアタッチして、関連する AWS リソースにアクセスし、特定のアクションを実行する必要があります。IAM ユーザーを作成する方法の詳細については、**「IAM ユーザーガイド」の「[IAM ユーザーの作成 (コンソール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html#id_users_create_console)」を参照してください。
IAM ユーザーには次のポリシーが必要です。
+ [AmazonS3FullAccess](https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AmazonS3FullAccess$jsonEditor) – Object Lambda アクセスポイントを作成および使用するための許可を含む、すべての Amazon S3 アクションに対する許可を付与します。
+ [AWSLambda\$1FullAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSLambda_FullAccess$jsonEditor) – すべての Lambda アクションに許可を付与します。
+ [IAMFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/IAMFullAccess$jsonEditor) – すべての IAM アクションに許可を付与します。
+ [IAMAccessAnalyzerReadOnlyAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/IAMAccessAnalyzerReadOnlyAccess$jsonEditor) – IAM Access Analyzer によって提供されるすべてのアクセス情報を読み取る許可を付与します。
+ [CloudWatchLogsFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/CloudWatchLogsFullAccess$jsonEditor) – CloudWatch Logs へのフルアクセスを付与します。
**注記**
このチュートリアルでは、わかりやすいように IAM ユーザーを作成して使用します。このチュートリアルを完了したら、忘れずに「[IAM ユーザーを削除する](#ol-upper-step8-delete-user)」を行います。本番環境で使用する場合は、「*IAM ユーザーガイド*」の「[IAM でのセキュリティのベストプラクティス](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html)」に従うことをお勧めします。ベストプラクティスでは、人間のユーザーと ID プロバイダーとのフェデレーションにより、一時的な認証情報を使用して AWS にアクセスする必要があります。追加のベストプラクティスとして、ワークロードでは一時的な認証情報で IAM ロールを使用し、AWS にアクセス必要があります。AWS IAM アイデンティティセンター を使用して一時的な認証情報を持つユーザーを作成する方法については、「*AWS IAM アイデンティティセンター ユーザーガイド*」の「[Getting started](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html)」を参照してください。
このチュートリアルでは、フルアクセス権を持つ AWS マネージドポリシーも使用します。実稼働環境では、代わりに、[セキュリティのベストプラクティス](security-best-practices.md#security-best-practices-prevent)に従って、ユースケースに必要な最小限の許可のみを付与することをお勧めします。
### ローカルマシンに Python 3.8 以降をインストールする
次の手順に従って、Python 3.8 以降をローカルマシンにインストールします。インストール手順については、Python の *Beginner Guide* で「[Python のダウンロード](https://wiki.python.org/moin/BeginnersGuide/Download)」ページを参照してください。
1. ローカルターミナルまたはシェルを開き、次のコマンドを実行して、Python がすでにインストールされているかどうか、インストールされている場合は、どのバージョンがインストールされているかを確認します。
```
python --version
```
1. Python 3.8 以降をお持ちでない場合は、ローカルマシンに適した Python 3.8 以降の[公式インストーラ](https://www.python.org/downloads/)をダウンロードします。
1. ダウンロードしたファイルをダブルクリックしてインストーラを実行し、手順に従ってインストールを完了します。
**Windows ユーザー**の場合、インストールウィザードで [**Python 3.X を PATH に追加**] を選択してから、[**今すぐ、インストール**] を選択します。
1. ターミナルを閉じて再度開いて、再起動します。
1. 次のコマンドを実行して、Python 3.8 以降が正しくインストールされていることを確認します。
**macOS ユーザー**の場合は、このコマンドを実行します。
```
python3 --version
```
**Windows ユーザー**の場合は、このコマンドを実行します。
```
python --version
```
1. 次のコマンドを実行して、pip3 パッケージマネージャーがインストールされていることを確認します。コマンド応答に pip のバージョン番号と python 3.8 以降が表示された場合、pip3 パッケージマネージャが正常にインストールされていることを意味します。
```
pip --version
```
## ステップ 1: S3 バケットを作成する
変換する元のデータを保存するバケットを作成します。
**注記**
Amazon FSx for OpenZFS ボリュームなどの別のデータソースにアクセスポイントをアタッチできますが、このチュートリアルでは S3 バケットにアタッチされたサポートアクセスポイントを使用します。
**バケットを作成するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、[**バケット**] を選択します。
1. [**Create bucket (バケットの作成)**] を選択します。
**[バケットの作成]** ページが開きます。
1. [**バケット名**] に、バケットの名前 (例、**tutorial-bucket**) を入力します。
Amazon S3 のバケット命名規則の詳細については、「[汎用バケットの命名規則](bucketnamingrules.md)」を参照してください。
1. [**リージョン**] で、バケットを保存する AWS リージョン を選択します。
バケットのリージョンの詳細については、「[汎用バケットの概要](UsingBucket.md)」を参照してください。
1. [**このバケットのパブリックアクセス設定をブロック**] で、デフォルト設定 (**ブロック*すべて*パブリックアクセス**が有効) のままであることを確認します。
ユースケースでオフにする必要のある設定が 1 つ以上あることがわかっている場合を除き、すべてのブロックパブリックアクセス設定を有効にしておくことをお勧めします。パブリックアクセスのブロックの詳細については、[Amazon S3 ストレージへのパブリックアクセスのブロック](access-control-block-public-access.md) を参照してください。
1. 残りの設定はデフォルトのままにしておきます。
(オプション) 特定のユースケースに追加のバケット設定を設定する場合は、「[汎用バケットの作成](create-bucket-overview.md)」を参照してください。
1. **[バケットを作成]** を選択します。
## ステップ 2: S3 バケットにファイルをアップロード
S3 バケットにテキストファイルをアップロードします。このテキストファイルには、このチュートリアルの後半で大文字に変換する元のデータが含まれています。
例えば、次のテキストが含まれている `tutorial.txt` ファイルをアップロードできます。
```
Amazon S3 Object Lambda Tutorial:
You can add your own code to process data retrieved from S3 before
returning it to an application.
```
**バケットにファイルをアップロードするには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、[**バケット**] を選択します。
1. **[バケット]** リストで、[ステップ 1](#ol-upper-step1) で作成したバケットの名前を選択し (**tutorial-bucket** など)、ファイルをアップロードします。
1. バケットの **[オブジェクト]** タブで、**[アップロード]** を選択します。
1. [**アップロード**] ページの [**ファイルとフォルダ**] の下で、[**ファイルを追加**] を選択します。
1. アップロードするファイルを選択し、続いて **[オープン]** を選択します。例えば、前述した `tutorial.txt` ファイルの例をアップロードできます。
1. **アップロード** を選択します。
## ステップ 3: S3 アクセスポイントの作成
S3 Object Lambda アクセスポイントを使用して元のデータにアクセスし、変換するには、S3 アクセスポイントを作成し、[ステップ 1](#ol-upper-step1) で作成した S3 バケットに関連付けます。アクセスポイントは、変換するオブジェクトと同じ AWS リージョン に存在する必要があります。
このチュートリアルの後半では、このアクセスポイントを Object Lambda アクセスポイントのサポートアクセスポイントとして使用します。
**アクセスポイントを作成するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール ([https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)) を開きます。
1. 左のナビゲーションペインで、[**アクセスポイント**] を選択します。
1. [**アクセスポイント**] ページで、[**アクセスポイントの作成**] を選択します。
1. **[アクセスポイント名]** フィールドに、アクセスポイントの名前を入力します (**tutorial-access-point** など)。
アクセスポイントの名前付けの詳細については、「[アクセスポイントの命名規則](access-points-restrictions-limitations-naming-rules.md#access-points-names)」を参照してください。
1. **[データソース]** フィールドに、[ステップ 1](#ol-upper-step1) で作成したバケットの名前を入力します (**tutorial-bucket** など)。S3 は、アクセスポイントをこのバケットにアタッチします。
(オプション) **[S3 を参照]** を選択して、アカウント内のバケットを参照および検索できます。**[S3 を参照]** を選択した場合は、目的のバケットを選択し、**[パスの選択]** を選択して、**[バケット名]** フィールドにバケットの名前を入力します。
1. [**ネットワークオリジン**] で、[**インターネット**] を選択します。
アクセスポイントのネットワークオリジンの詳細については、「[Virtual Private Cloud に制限されたアクセスポイントの作成](access-points-vpc.md)」を参照してください。
1. デフォルトでは、アクセスポイントに対してすべてのブロックパブリックアクセス設定が有効になります。**パブリックアクセスブロック設定**は、*すべて*を有効にしておくことを推奨します。
詳細については、「[汎用バケットのアクセスポイントへのパブリックアクセスの管理](access-points-bpa-settings.md)」を参照してください。
1. その他のすべてのアクセスポイント設定で、デフォルトの設定を保持します。
(オプション) アクセスポイントの設定は、ユースケースをサポートするように変更できます。このチュートリアルでは、デフォルトの設定を保持することをお勧めします。
(オプション) アクセスポイントへのアクセスを管理する必要がある場合は、アクセスポイントポリシーを指定できます。詳細については、「[アクセスポイントのポリシーの例](access-points-policies.md#access-points-policy-examples)」を参照してください。
1. **[アクセスポイントを作成]** を選択します。
## ステップ 4: Lambda 関数を作成する
元のデータを変換するには、S3 Object Lambda アクセスポイントで使用する Lambda 関数を作成します。
**Topics**
+ [Lambda 関数コードを記述し、仮想環境でデプロイパッケージを作成する](#ol-upper-step4-write-lambda)
+ [実行ロールを使用した Lambda 関数の作成 (コンソール)](#ol-upper-step4-create-function)
+ [.zip ファイルアーカイブを使用して Lambda 関数コードをデプロイし、Lambda 関数を設定 (コンソール)](#ol-upper-step4-deploy-function)
### Lambda 関数コードを記述し、仮想環境でデプロイパッケージを作成する
1. ローカルマシンで、このチュートリアルの後半で使用する仮想環境に対して、フォルダ名が `object-lambda` であるフォルダを作成します。
1. `object-lambda` フォルダで、元のオブジェクトのすべてのテキストを大文字に変更する Lambda 関数を含むファイルを作成します。例えば、Python で記述された次の関数を使用できます。この関数は、`transform.py` という名前のファイルに保存してください。
```
import boto3
import requests
from botocore.config import Config
# This function capitalizes all text in the original object
def lambda_handler(event, context):
object_context = event["getObjectContext"]
# Get the presigned URL to fetch the requested original object
# from S3
s3_url = object_context["inputS3Url"]
# Extract the route and request token from the input context
request_route = object_context["outputRoute"]
request_token = object_context["outputToken"]
# Get the original S3 object using the presigned URL
response = requests.get(s3_url)
original_object = response.content.decode("utf-8")
# Transform all text in the original object to uppercase
# You can replace it with your custom code based on your use case
transformed_object = original_object.upper()
# Write object back to S3 Object Lambda
s3 = boto3.client('s3', config=Config(signature_version='s3v4'))
# The WriteGetObjectResponse API sends the transformed data
# back to S3 Object Lambda and then to the user
s3.write_get_object_response(
Body=transformed_object,
RequestRoute=request_route,
RequestToken=request_token)
# Exit the Lambda function: return the status code
return {'status_code': 200}
```
**注記**
前述の例の Lambda 関数は、リクエストされたオブジェクト全体をメモリにロードしてから、変換してクライアントに返します。または、オブジェクト全体をメモリにロードしないようにするために、S3 からオブジェクトをストリーミングすることもできます。この方法は、大きなオブジェクトを扱うときに役立ちます。Object Lambda アクセスポイントを使用したレスポンスのストリーミングの詳細については、[Lambdaでの `GetObject` リクエストの処理](olap-writing-lambda.md#olap-getobject-response) にあるストリーミングの例を参照してください。
S3 Object Lambda アクセスポイントで使用する Lambda 関数を記述する場合、この関数は S3 Object Lambda が Lambda 関数に提供する入力イベントコンテキストに基づいています。イベントコンテキストは、S3 Object Lambda から Lambda に渡されたイベントで行われたリクエストに関する情報を提供します。これには、Lambda 関数の作成に使用するパラメータが含まれています。
前述の Lambda 関数の作成に使用されるフィールドは次のとおりです。
`getObjectContext` のフィールドは、Amazon S3 および S3 Object Lambda への接続に関する入力および出力の詳細を意味します。以下のフィールドがあります。
+ `inputS3Url` – Lambda 関数がサポートするアクセスポイントから元のオブジェクトをダウンロードするために使用できる署名付き URL です。Lambda 関数は、署名付き URL を使用することにより、元のオブジェクトを取得するために Amazon S3 の読み取り許可を必要とせず、呼び出しごとに処理されたオブジェクトにのみアクセスできます。
+ `outputRoute` – Lambda 関数が変換したオブジェクトを戻すために `WriteGetObjectResponse` を呼び出すときに S3 Object Lambda URL に追加されるルーティングトークン。
+ `outputToken` – 変換されたオブジェクトを送り返すときに、`WriteGetObjectResponse` 呼び出しを元の呼び出し元と照合するために S3 Object Lambda によって使用されるトークンです。
イベントコンテキスト内のすべてのフィールドの詳細については、「[イベントコンテキストの形式と使用法](olap-event-context.md) および [S3 Object Lambda アクセスポイントの Lambda 関数の記述](olap-writing-lambda.md)」を参照してください。
1. ローカルターミナルで次のコマンドを入力し、`virtualenv` パッケージをインストールします。
```
python -m pip install virtualenv
```
1. ローカルターミナルで、前に作成した `object-lambda` フォルダを開き、次のコマンドを入力して、`venv` という名前の仮想環境を作成し、初期化します。
```
python -m virtualenv venv
```
1. 仮想環境をアクティブ化するには、次のコマンドを入力して環境のフォルダから `activate` ファイルを実行します。
**macOS ユーザー**の場合は、このコマンドを実行します。
```
source venv/bin/activate
```
**Windows ユーザー**の場合は、このコマンドを実行します。
```
.\venv\Scripts\activate
```
ここで、コマンドプロンプトが変わり、仮想環境がアクティブであることを示す **(venv)** が表示されます。
1. 必要なライブラリをインストールするには、`venv` 仮想環境で、以下のコマンドを行単位で実行します。
これらのコマンドは、`lambda_handler` Lambda 関数の依存関係の更新バージョンをインストールします。これらの依存関係は、AWS SDK for Python (Boto3) とリクエストモジュールです。
```
pip3 install boto3
```
```
pip3 install requests
```
1. 仮想環境を無効にするには、次のコマンドを実行します。
```
deactivate
```
1. インストール済みライブラリを含むデプロイパッケージを `object-lambda` ディレクトリのルートにある `lambda.zip` という名前の `.zip` ファイルで作成し、以下のコマンドをローカルターミナルで行単位で実行します。
**ヒント**
以下のコマンドは、特定の環境で動作するように調整する必要がある場合があります。例えば、ライブラリは `site-packages` または `dist-packages` であり、最初のフォルダは`lib` または `lib64` です。また、`python` フォルダには、別の Python バージョンで名前が付けられている可能性があります。特定のパッケージを見つけるには、`pip show` コマンドを使用します。
**macOS ユーザー**の場合は、このコマンドを実行します。
```
cd venv/lib/python3.8/site-packages
```
```
zip -r ../../../../lambda.zip .
```
**Windows ユーザー**の場合は、このコマンドを実行します。
```
cd .\venv\Lib\site-packages\
```
```
powershell Compress-Archive * ../../../lambda.zip
```
最後のコマンドは、デプロイメントパッケージを `object-lambda` ディレクトリのルートに保存します。
1. デプロイパッケージのルートに関数コードファイル `transform.py` を追加します。
**macOS ユーザー**の場合は、このコマンドを実行します。
```
cd ../../../../
```
```
zip -g lambda.zip transform.py
```
**Windows ユーザー**の場合は、このコマンドを実行します。
```
cd ..\..\..\
```
```
powershell Compress-Archive -update transform.py lambda.zip
```
このステップを完了すると、以下のようなディレクトリ構造になります。
```
lambda.zip$
│ transform.py
│ __pycache__
| boto3/
│ certifi/
│ pip/
│ requests/
...
```
### 実行ロールを使用した Lambda 関数の作成 (コンソール)
1. AWS マネジメントコンソール にサインインして AWS Lambda コンソール ([https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)) を開きます。
1. 左側のナビゲーションペインで、**[関数]** を選択します。
1. **関数の作成** を選択します。
1. **Author from scratch** を選択します。
1. **基本的な情報** で、以下の作業を行います。
1. **[関数名]** に「**tutorial-object-lambda-function**」と入力します。
1. [**ランタイム**] で、**Python 3.8** またはそれ以降のバージョンを選択します。
1. [**デフォルト実行ロールの変更**] セクションを展開します。[**実行ロール**] で、[**基本的な Lambda 許可で新しいロールを作成**] を選択します。
このチュートリアルの[ステップ 5](#ol-upper-step5) で、**AmazonS3ObjectLambdaExecutionRolePolicy** をこの Lambda 関数の実行ロールにアタッチします。
1. 残りの設定はデフォルト値のままにしておきます。
1. [**関数の作成**] を選択してください。
### .zip ファイルアーカイブを使用して Lambda 関数コードをデプロイし、Lambda 関数を設定 (コンソール)
1. AWS Lambda コンソール ([https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)) で、左のナビゲーションペインの**関数**を選択します。
1. 前に作成した Lambda 関数を選択します (例、**tutorial-object-lambda-function**)。
1. Lambda 関数の詳細ページで、[**コード**] を選択します。[**コードソース**] セクションで、[**からアップロード**]、[**.zip ファイル**] の順に選択します。
1. [**アップロード**] を選択して、ローカルの `.zip` ファイルを選択します。
1. 前に作成した `lambda.zip` ファイルを選択し、[**開く**] を選択します。
1. **[保存]** を選択します。
1. [**ランタイム設定**] セクションで、[**編集**] を選択します。
1. [**ランタイム設定の編集**] ページで、**ランタイム**が **Python 3.8** またはそれ以降のバージョンに設定されていることを確認します。
1. Lambda ランタイムに Lambda 関数コード内のどのハンドラメソッドを呼び出すかを指示するには、[**ハンドラー**] に **transform.lambda\$1handler** を入力します。
Python で関数を設定するとき、ハンドラー設定の値は、ファイル名と、ハンドラーモジュールの名前を、ドットで区切ったものになります。例えば、`transform.lambda_handler` は、`transform.py` ファイルで定義された `lambda_handler` メソッドを呼び出します。
1. **[保存]** を選択します。
1. (オプション) Lambda 関数の詳細ページで、[**設定**] タブを選択します。左のナビゲーションペインで、[**一般的な設定**] を選択してから、[**編集**] を選択します。[**タイムアウト**] フィールドに、**1** 分 **0** 秒と入力します。残りの設定はデフォルト値のままにして、[**保存**] を選択します。
**タイムアウト**は、Lambda で関数が停止するまでに許可される実行時間の長さです。デフォルト値は 3 秒です。S3 Object Lambda によって使用される Lambda 関数の最大持続時間は 60 秒です。料金は、設定されたメモリの量とコードの実行時間に基づいて請求されます。
## ステップ 5: Lambda 関数の実行ロールの IAM ポリシーを設定する
Lambda 関数がカスタマイズされたデータと応答ヘッダーを `GetObject` 呼び出し元に提供できるようにするには、Lambda 関数の実行ロールに `WriteGetObjectResponse` API を呼び出すための IAM 許可が必要です。
**IAM ポリシーを Lambda 関数ロールにアタッチするには**
1. AWS Lambda コンソール ([https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)) で、左のナビゲーションペインの**関数**を選択します。
1. [ステップ 4](#ol-upper-step4) で作成した関数 (たとえば、**tutorial-object-lambda-function**) を選択します。
1. Lambda 関数の詳細ページで、[**設定**] タブを選択してから、左のナビゲーションペインの [**許可**] を選択します。
1. [**実行ロール**] で、[**ロール名**] のリンクを選択します。IAM コンソールが開きます。
1. Lambda 関数の実行ロールの IAM コンソールの **[Summary]** (概要) ページで、**[Permissions]** (許可) タブを選択します。**[Add Permissions]** (許可を追加) メニューから **[Attach policies]** (ポリシーを添付) を選択します。
1. [**許可のアタッチ**] ページで、[検索] ボックスに **AmazonS3ObjectLambdaExecutionRolePolicy** を入力して、ポリシーのリストをフィルタリングします。**AmazonS3ObjectLambdaExecutionRolePolicy** ポリシーの名前の横にあるチェックボックスを選択します。
1. **ポリシーのアタッチ** を選択します。
## ステップ 6: Object Lambda アクセスポイントの作成
S3 Object Lambda アクセスポイントは、S3 GET リクエストから Lambda 関数を直接呼び出す柔軟性を提供し、関数が S3 アクセスポイントから取得したデータを処理できるようにします。S3 Object Lambda アクセスポイントを作成および設定するときは、Lambda が使用するカスタムパラメータとして JSON 形式のイベントコンテキストを呼び出し、提供する Lambda 関数を指定する必要があります。
**S3 Object Lambda アクセスポイントを作成するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左のナビゲーションペインで、[**Object Lambda アクセスポイント**] を選択します。
1. [**Object Lambda アクセスポイント**] ページで、[**Object Lambda アクセスポイントの作成**] を選択します。
1. **Object Lambda アクセスポイント名**] に、Object Lambda アクセスポイントに使用する名前を入力します (例、**tutorial-object-lambda-accesspoint**)。
1. **[サポートするアクセスポイント]** で、[ステップ 3](#ol-upper-step3) で作成した標準アクセスポイントを入力または参照します (**tutorial-access-point** など)。次に、**[サポートするアクセスポイントの選択]** を選択します。
1. **S3 API** の場合、Lambda 関数が処理する S3 バケットからオブジェクトを取得するには、**[GetObject]** を選択します。
1. **[Lambda 関数の呼び出し]** では、このチュートリアルでは、次の 2 つのオプションのいずれかを選択できます。
+ **[アカウントの関数から選択]** を選択し、**[Lambda 関数]** ドロップダウンリストから、[ステップ 4](#ol-upper-step4) (例、**tutorial-object-lambda-function**) で作成したLambda 関数を選択します。
+ [**ARN を入力**] を選択し、[ステップ 4](#ol-upper-step4) で作成した Lambda 関数の Amazon リソースネーム (ARN) を入力します。
1. [**Lambda 関数のバージョン**] で、**\$1LATEST** ([ステップ 4](#ol-upper-step4) で作成した Lambda 関数の最新バージョン) を選択します。
1. (オプション) Lambda 関数で、範囲とパート番号によって GET リクエストを認識および処理する必要がある場合は、[**Lambda 関数は、範囲を使用してリクエストをサポート**] および [**Lambda 関数は、パート番号を使用してリクエストをサポート**] を選択します。それ以外の場合は、これらの 2 つのチェックボックスをオフにします。
S3 Object Lambda で範囲またはパート番号を使用する方法の詳細については、「[Range および partNumber ヘッダーの操作](range-get-olap.md)」を参照してください。
1. (オプション) [**ペイロード - *オプション***] で JSON テキストを追加して、Lambda 関数に追加情報を提供します。
ペイロードは、特定の S3 Object Lambda アクセスポイントからのすべての呼び出しに対する入力として、Lambda 関数に提供できるオプションの JSON テキストです。同じ Lambda 関数を呼び出す複数の Object Lambda アクセスポイントの動作をカスタマイズして、異なるパラメータを使用してペイロードを設定できます。これにより、Lambda 関数の柔軟性が向上します。
ペイロードの詳細については、「[イベントコンテキストの形式と使用法](olap-event-context.md)」を参照してください。
1. (オプション) **[リクエストメトリクス - *オプション*]** で、**[無効]** または **[有効]** を選択して、Amazon S3 モニタリングを Object Lambda アクセスポイントに追加します。リクエストメトリクスには、Amazon CloudWatch の標準料金が課金されます。詳細については、「[CloudWatch 料金表](https://aws.amazon.com/cloudwatch/pricing/)」を参照してください。
1. [**Object Lambda アクセスポイントポリシー-*オプション***] で、デフォルトの設定を保持します。
(オプション) リソースポリシーを設定できます。このリソースポリシーは、指定された Object Lambda アクセスポイントを使用する `GetObject` API 許可を付与します。
1. 残りの設定はデフォルト値のままにしておき、[**Object Lambda アクセスポイントの作成**] を選択します。
## ステップ 7: 変換されたデータを表示する
これで、S3 Object Lambda は、ユースケースに合わせてデータを変換する準備が整いました。このチュートリアルでは、S3 Object Lambda はオブジェクト内のすべてのテキストを大文字に変換します。
**Topics**
+ [S3 Object Lambda アクセスポイントの変換済みデータの表示](#ol-upper-step7-check-data)
+ [Python スクリプトを実行して、元のデータと変換されたデータを出力する](#ol-upper-step7-python-print)
### S3 Object Lambda アクセスポイントの変換済みデータの表示
S3 Object Lambda アクセスポイントを使用してファイルの取得をリクエストすると、S3 Object Lambda への `GetObject` API 呼び出しが行われます。S3 Object Lambda は Lambda 関数を呼び出してデータを変換し、変換されたデータを標準 S3 `GetObject` API への応答として返します。
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左のナビゲーションペインで、[**Object Lambda アクセスポイント**] を選択します。
1. [**Object Lambda アクセスポイント**] ページで、[ステップ 6](#ol-upper-step6) で作成した S3 Object Lambda アクセスポイントを選択します (例、**tutorial-object-lambda-accesspoint**)。
1. S3 Object Lambda アクセスポイントの [**オブジェクト**] タブで、[ステップ 2](#ol-upper-step2) で S3 バケットにアップロードしたファイルと同じ名前のファイルを選択します(例、`tutorial.txt`)。
このファイルには、変換されたすべてのデータが含まれているはずです。
1. 変換されたデータを表示するには、[**開く**] または [**ダウンロード**] を選択します。
### Python スクリプトを実行して、元のデータと変換されたデータを出力する
S3 Object Lambda は、既存のアプリケーションで使用できます。これを行うには、アプリケーション設定を更新して、[ステップ 6](#ol-upper-step6) で、S3 からのデータを作成した新しい S3 Object Lambda アクセスポイント ARN を使用してデータを取得します。
次の Python スクリプトの例では、S3 バケットからの元のデータと S3 Object Lambda アクセスポイントからの変換されたデータの両方を出力します。
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左のナビゲーションペインで、[**Object Lambda アクセスポイント**] を選択します。
1. [**Object Lambda アクセスポイント**] ページで、[ステップ 6](#ol-upper-step6) で作成した S3 Object Lambda アクセスポイントの左にあるラジオブタンを選択します (例、**tutorial-object-lambda-accesspoint**)。
1. [**ARN のコピー**] を選択します。
1. 後で使用するために ARN を保存します。
1. ローカルマシンで Python スクリプトを記述して、S3 バケットからの元のデータ (例えば、`tutorial.txt`) と S3 Object Lambda アクセスポイントからの変換されたデータ (例えば、`tutorial.txt`) の両方を出力します。次のサンプルスクリプトを使用できます。
```
import boto3
from botocore.config import Config
s3 = boto3.client('s3', config=Config(signature_version='s3v4'))
def getObject(bucket, key):
objectBody = s3.get_object(Bucket = bucket, Key = key)
print(objectBody["Body"].read().decode("utf-8"))
print("\n")
print('Original object from the S3 bucket:')
# Replace the two input parameters of getObject() below with
# the S3 bucket name that you created in Step 1 and
# the name of the file that you uploaded to the S3 bucket in Step 2
getObject("tutorial-bucket",
"tutorial.txt")
print('Object transformed by S3 Object Lambda:')
# Replace the two input parameters of getObject() below with
# the ARN of your S3 Object Lambda Access Point that you saved earlier and
# the name of the file with the transformed data (which in this case is
# the same as the name of the file that you uploaded to the S3 bucket
# in Step 2)
getObject("arn:aws:s3-object-lambda:us-west-2:111122223333:accesspoint/tutorial-object-lambda-accesspoint",
"tutorial.txt")
```
1. Python スクリプトにカスタム名 (`tutorial_print.py` など) を付けて、[ステップ 4](#ol-upper-step4) でローカルマシンに作成したフォルダ (`object-lambda` など) に保存します。
1. ローカルターミナルで、[ステップ 4](#ol-upper-step4) で作成したディレクトリ (例えば、`object-lambda`) のルートから次のコマンドを実行します。
```
python3 tutorial_print.py
```
元のデータと変換されたデータ(すべて大文字)の両方がターミナルに表示されます。例えば、次のようなテキストが表示されます。
```
Original object from the S3 bucket:
Amazon S3 Object Lambda Tutorial:
You can add your own code to process data retrieved from S3 before
returning it to an application.
Object transformed by S3 Object Lambda:
AMAZON S3 OBJECT LAMBDA TUTORIAL:
YOU CAN ADD YOUR OWN CODE TO PROCESS DATA RETRIEVED FROM S3 BEFORE
RETURNING IT TO AN APPLICATION.
```
## ステップ 8: クリーンアップする
学習のためだけに S3 Object Lambda によってデータを変換した場合は、割り当てた AWS リソースを削除して、料金が発生しないようにします。
**Topics**
+ [Object Lambda アクセスポイントの削除](#ol-upper-step8-delete-olap)
+ [S3 アクセスポイントを削除する](#ol-upper-step8-delete-ap)
+ [Lambda 関数の実行ロールを削除する](#ol-upper-step8-delete-lambda-role)
+ [Lambda 関数を削除する](#ol-upper-step8-delete-lambda-function)
+ [CloudWatch Logs グループを削除する](#ol-upper-step8-delete-cloudwatch)
+ [S3 ソースバケットの元のファイルを削除する](#ol-upper-step8-delete-file)
+ [S3 ソースバケットを削除する](#ol-upper-step8-delete-bucket)
+ [IAM ユーザーを削除する](#ol-upper-step8-delete-user)
### Object Lambda アクセスポイントの削除
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左のナビゲーションペインで、[**Object Lambda アクセスポイント**] を選択します。
1. [**Object Lambda アクセスポイント**] ページで、[ステップ 6](#ol-upper-step6) で作成した S3 Object Lambda アクセスポイントの左にあるラジオブタンを選択します (例、**tutorial-object-lambda-accesspoint**)。
1. **[削除]** を選択します。
1. 表示されるテキストフィールドにアクセスポイントの名前を入力して、[**削除**] を選択し、bject Lambda アクセスポイントを削除することを確認します。
### S3 アクセスポイントを削除する
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左のナビゲーションペインで、[**アクセスポイント**] を選択します。
1. [ステップ 3](#ol-upper-step3) で作成したアクセスポイントに移動し (例、**tutorial-access-point**)、アクセスポイントの名前の横にあるラジオボタンを選択します。
1. **[削除]** を選択します。
1. 表示されるテキストフィールドにアクセスポイントの名前を入力して、アクセスポイントを削除することを確認し、[**削除**] を選択します。
### Lambda 関数の実行ロールを削除する
1. AWS マネジメントコンソール にサインインして AWS Lambda コンソール ([https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)) を開きます。
1. 左側のナビゲーションペインで、[**関数**] を選択します。
1. [ステップ 4](#ol-upper-step4) で作成した関数 (例、**tutorial-object-lambda-function**) を選択します。
1. Lambda 関数の詳細ページで、[**設定**] タブを選択してから、左のナビゲーションペインの [**許可**] を選択します。
1. [**実行ロール**] で、[**ロール名**] のリンクを選択します。IAM コンソールが開きます。
1. Lambda 関数の実行ロールの IAM コンソールの [**概要**] ページで、[**ロールの削除**] を選択します。
1. **ロールの削除**ダイアログボックスで、[**はい、削除します**] をクリックします。
### Lambda 関数を削除する
1. AWS Lambda コンソール ([https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)) で、左のナビゲーションペインの**関数**を選択します。
1. [ステップ 4](#ol-upper-step4) で作成した関数名の左にあるチェックボックスを選択します (例、**tutorial-object-lambda-function**)。
1. **[アクション]**、**[削除]** の順に選択します。
1. **[関数の削除]** ダイアログボックスで、**[削除]** を選択します。
### CloudWatch Logs グループを削除する
1. CloudWatch コンソールの [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) を開いてください。
1. 左側のナビゲーションペインで、**[ロググループ]** をクリックします。
1. [ステップ 4](#ol-upper-step4) で作成した Lambda 関数で終わる名前のロググループを検索します(例、**tutorial-object-lambda-function**)。
1. ロググループの名前の左にあるチェックボックスを選択します。
1. [**アクション**] を選択してから、[**ロググループの削除**] を選択します。
1. **[ロググループの削除]** ダイアログボックスで、**[削除]** をクリックします。
### S3 ソースバケットの元のファイルを削除する
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、[**バケット**] を選択します。
1. **バケット名**] リストで、[ステップ 2](#ol-upper-step2) で元のファイルをアップロードしたバケットの名前を選択します(例、**tutorial-bucket**)。
1. 削除するオブジェクトの名前の左にあるチェックボックスを選択します (例、`tutorial.txt`)。
1. **[削除]** を選択します。
1. [**オブジェクトの削除**] ページの [**オブジェクトを完全に削除しますか?**] セクションで、テキストボックスに「**permanently delete**」と入力して、このオブジェクトを削除することを確認します。
1. **オブジェクトの削除** を選択します。
### S3 ソースバケットを削除する
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、[**バケット**] を選択します。
1. [**バケット**] リストで、[ステップ 1](#ol-upper-step1) で作成したバケットの名前の横にあるラジオボタンを選択します (例、**tutorial-bucket**)。
1. **[削除]** を選択します。
1. [**バケットを削除する**] ページで、テキストフィールドにバケット名を入力することでバケットを削除することを確認し、[**バケットを削除する**] を選択します。
### IAM ユーザーを削除する
1. AWS マネジメントコンソール にサインインして、IAM コンソール [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) を開きます。
1. 左のナビゲーションペインで、[**ユーザー**] を選択し、削除するユーザー名の横にあるチェックボックスを選択します。
1. ページの上部で、[**削除**] を選択します。
1. [***ユーザー名*を削除しますか?**] ダイアログボックスで、テキスト入力フィールドにユーザー名を入力し、ユーザーの削除を確認します。**[削除]** を選択します。
## 次のステップ
このチュートリアルを完了すると、ユースケースの Lambda 関数をカスタマイズし、標準 S3 GET リクエストによって返されるデータを変更できます。
S3 Object Lambda の一般的なユースケースを以下に示します。
+ セキュリティとコンプライアンスのために機密データをマスキングします。
詳細については、「[チュートリアル: S3 Object Lambda と Amazon Comprehend を使用した PII データの検出と編集](tutorial-s3-object-lambda-redact-pii.md)」を参照してください。
+ 特定の情報を配信するために、特定のデータ行をフィルタリングします。
+ 他のサービスやデータベースからの情報でデータ強化します。
+ アプリケーション互換性のために XML から JSON への変換など、データ形式間の変換を行います。
+ ダウンロード中のファイルを圧縮または解凍します。
+ 画像のサイズ変更とウォーターマークを行います。
詳細については、「[チュートリアル: S3 Object Lambda を使用して、取得時に画像に動的に透かしを入れる](https://aws.amazon.com/getting-started/hands-on/amazon-s3-object-lambda-to-dynamically-watermark-images/?ref=docs_gateway/amazons3/tutorial-s3-object-lambda-uppercase.html)」を参照してください。
+ データにアクセスするためのカスタム承認規則を実装します。
S3 Object Lambda, の詳細については、「[S3 Object Lambda を使用したオブジェクトの変換](transforming-objects.md)」を参照してください。
# チュートリアル: S3 Object Lambda と Amazon Comprehend を使用した PII データの検出と編集
**注記**
2025 年 11 月 7 日現在、S3 Object Lambda は、現在サービスを使用している既存のお客様、および一部の AWS パートナーネットワーク (APN) パートナーのみが利用できます。S3 Object Lambda と同様の機能の詳細については、「[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)」を参照してください。
複数のアプリケーションおよびユーザーがアクセスするための共有データセットに Amazon S3 を使用する場合、個人を特定できる情報 (PII) などの特権情報を許可されたエンティティのみに制限することが重要です。例えば、マーケティングアプリケーションが PII を含むデータを使用する場合、データのプライバシー要件を満たすために、まず PII データをマスクする必要があります。また、分析アプリケーションで製造オーダーのインベントリデータセットを使用する場合、意図しないデータ漏洩を防ぐために、まず顧客のクレジットカード情報を編集する必要があります。
[S3 Object Lambda](https://aws.amazon.com/s3/features/object-lambda) と Amazon Comprehend により事前に構築された AWS Lambda 関数を使用すると、S3 から取得した PII データを、アプリケーションに返す前に保護できます。具体的な内容は以下のとおりです。組み込みの [Lambda 関数](https://aws.amazon.com/lambda/)を編集関数として作使用し、S3 Object Lambda アクセスポイントにアタッチします。アプリケーション (分析アプリケーションなど) が[標準 S3 GET リクエスト](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)を送信する場合、S3 Object Lambda アクセスポイントを介して行われたこれらのリクエストは、事前作成された編集用 Lambda 関数を呼び出し、サポートしている S3 アクセスポイントを介して基盤となるデータソースから取得した PII データを検出して修正します。次に、S3 Object Lambda アクセスポイントは、編集された結果をアプリケーションに返します。
![\[これは、S3 Object Lambda ワークフロー図です。\]](http://docs.aws.amazon.com/ja_jp/AmazonS3/latest/userguide/images/ol-comprehend-image-global.png)
プロセスでは、事前に構築された Lambda 関数は [Amazon Comprehend](https://aws.amazon.com/comprehend/) (自然言語処理 (NLP) サービス) を使用して、PII がテキストにどのように存在するかに関係なく (数値、または単語と数字の組み合わせなど)、PII の表現方法のバリエーションをキャプチャします。Amazon Comprehend は、テキスト内のコンテキストを使用して、4 桁の数字が PIN、社会保障番号 (SSN) の最後の 4 桁の数字であるか、または年であるかを理解することもできます。Amazon Comprehend は UTF-8 形式のテキストファイルを処理し、精度に影響を与えずに PII を大規模に保護します。詳細については、*Amazon Comprehend デベロッパーガイド*の「[Amazon Comprehend とは?](https://docs.aws.amazon.com/comprehend/latest/dg/what-is.html)」を参照してください。
**目的**
このチュートリアルでは、事前に構築された Lambda 関数 `ComprehendPiiRedactionS3ObjectLambda` で S3 Object Lambda を使用する方法を学習します。この関数は、Amazon Comprehend を使用して PII エンティティを検出します。次に、これらのエンティティをアスタリスクに置き換えて墨消しします。PII を編集することで、機密データを隠すことができ、セキュリティとコンプライアンスに役立ちます。
また、[AWS Serverless Application Repository](https://aws.amazon.com/serverless/serverlessrepo/) で事前作成された AWS Lambda 関数を操作して、S3 Object Lambda と連携してデプロイメントを容易にする方法も学びます。
**Topics**
+ [前提条件: 許可を持つ IAM ユーザーを作成する](#ol-pii-prerequisites)
+ [ステップ 1: S3 バケットを作成する](#ol-pii-step1)
+ [ステップ 2: S3 バケットにファイルをアップロード](#ol-pii-step2)
+ [ステップ 3: S3 アクセスポイントの作成](#ol-pii-step3)
+ [ステップ 4: 事前構築された Lambda 関数の設定とデプロイ](#ol-pii-step4)
+ [ステップ 5: S3 Object Lambda アクセスポイントの作成](#ol-pii-step5)
+ [ステップ 6: S3 Object Lambda アクセスポイントを使用して、編集されたファイルを取得する](#ol-pii-step6)
+ [ステップ 7: クリーンアップ](#ol-pii-step7)
+ [次のステップ](#ol-pii-next-steps)
## 前提条件: 許可を持つ IAM ユーザーを作成する
このチュートリアルを開始する前に、正しいアクセス許可を持つ AWS Identity and Access Management ユーザー (IAM ユーザー) としてサインインできる AWS アカウントが必要です。
チュートリアル用の IAM ユーザーを作成できます。このチュートリアルを完了するには、IAM ユーザーが次の IAM ポリシーをアタッチして、関連する AWS リソースにアクセスし、特定のアクションを実行する必要があります。
**注記**
このチュートリアルでは、わかりやすいように IAM ユーザーを作成して使用します。このチュートリアルを完了したら、忘れずに「[IAM ユーザーを削除する](#ol-pii-step8-delete-user)」を行います。本番環境で使用する場合は、「*IAM ユーザーガイド*」の「[IAM でのセキュリティのベストプラクティス](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html)」に従うことをお勧めします。ベストプラクティスでは、人間のユーザーと ID プロバイダーとのフェデレーションにより、一時的な認証情報を使用して AWS にアクセスする必要があります。追加のベストプラクティスとして、ワークロードでは一時的な認証情報で IAM ロールを使用し、AWS にアクセス必要があります。AWS IAM アイデンティティセンター を使用して一時的な認証情報を持つユーザーを作成する方法については、「*AWS IAM アイデンティティセンター ユーザーガイド*」の「[Getting started](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html)」を参照してください。
このチュートリアルでは、フルアクセスポリシーも使用します。実稼働環境では、代わりに、[セキュリティのベストプラクティス](security-best-practices.md#security-best-practices-prevent)に従って、ユースケースに必要な最小限の許可のみを付与することをお勧めします。
IAM ユーザーには次のものが必要です。AWS マネージドポリシー:
+ [AmazonS3FullAccess](https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AmazonS3FullAccess$jsonEditor) – Object Lambda アクセスポイントを作成および使用するための許可を含む、すべての Amazon S3 アクションに対する許可を付与します。
+ [AWSLambda\$1FullAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSLambda_FullAccess$jsonEditor) – すべての Lambda アクションに許可を付与します。
+ [AWSCloudFormationFullAccess](https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AWSCloudFormationFullAccess$serviceLevelSummary) – すべてのAWS CloudFormationのアクションに許可を付与します。
+ [IAMFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/IAMFullAccess$jsonEditor) – すべての IAM アクションに許可を付与します。
+ [IAMAccessAnalyzerReadOnlyAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/IAMAccessAnalyzerReadOnlyAccess$jsonEditor) – IAM Access Analyzer によって提供されるすべてのアクセス情報を読み取る許可を付与します。
IAM ユーザーを作成するときに、これらの既存のポリシーを直接アタッチできます。IAM ユーザーを作成する方法の詳細については、**「IAM ユーザーガイド」の「[IAM ユーザーの作成 (コンソール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html#id_users_create_console)」を参照してください。
さらに、IAM ユーザーにはカスタマーマネージドポリシーが必要です。IAM ユーザーにすべての AWS Serverless Application Repository リソースとアクションへの許可を付与するには、IAM ポリシーを作成し、ポリシーを IAM ユーザーにアタッチする必要があります。
**IAM ポリシーを作成して IAM ユーザーにアタッチするには**
1. AWS マネジメントコンソール にサインインして、IAM コンソール [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) を開きます。
1. 左のナビゲーションペインの **[ポリシー]** を選択します。
1. [**Create policy (ポリシーの作成)**] を選択します。
1. **Service** の [**Visual editor**] タブで、[**サービスの選択**] を選択します。次に、[**Serverless Application Repository**] を選択します。
1. [**アクション**] の [**手動アクション**] の下で、このチュートリアルでは、[**すべての Serverless Application Repository アクション (serverlessrepo:\$1)**] を選択します。
セキュリティのベストプラクティスとは、ユーザーが必要とするアクションとリソースに対する許可を、ユースケースに基づいて付与することです。詳細については、*IAM ユーザーガイド*の「[IAM でのセキュリティベストプラクティス](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html)」を参照してください。
1. [**リソース**] で、このチュートリアルでは、[**すべてのリソース**] を選択します。
ベストプラクティスは、特定のアカウントの特定のリソースに対してのみ許可を定義することです。または、条件キーを使用して、最小の特権を付与することもできます。詳細については、[IAM ユーザーガイド](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege)の「*最小限の特権を付与*」を参照してください。
1. [**Next: Tags (次へ: タグ)**] を選択します。
1. **[次へ: レビュー]** を選択します。
1. **[ポリシーの確認]** ページで、作成するポリシーの **[名前]** (例、**tutorial-serverless-application-repository**) と **[説明]** (オプション) を入力します。ポリシー概要を確認して、目的のアクセス許可を付与していることを確認し、**[Create policy]** (ポリシーの作成) を選択して新しいポリシーを保存します。
1. 左のナビゲーションペインで、**[ユーザー]** を選択します。次に、このチュートリアルの IAM ユーザーを選択します。
1. 選択したユーザーの [**概要**] ページで、[**許可**] タブを選択してから、[**許可を追加**] を選択します。
1. [**権限の付与**] で、[**既存のポリシーを直接アタッチします**] を選択します。
1. 今、作成したポリシーの横にあるチェックボックスを選択し (例、**tutorial-serverless-application-repository**)、次に [**次へ: レビュー**] を選択します。
1. [**許可概要**] で、概要を確認し、意図したポリシーを付与したことを確認します。次に、[**許可を追加**] を選択します。
## ステップ 1: S3 バケットを作成する
変換する元のデータを保存するバケットを作成します。
**注記**
Amazon FSx for OpenZFS ボリュームなどの別のデータソースにアクセスポイントをアタッチできますが、このチュートリアルでは S3 バケットにアタッチされたサポートアクセスポイントを使用します。
**バケットを作成するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、[**バケット**] を選択します。
1. [**Create bucket (バケットの作成)**] を選択します。
**[バケットの作成]** ページが開きます。
1. [**バケット名**] に、バケットの名前 (例、**tutorial-bucket**) を入力します。
Amazon S3 のバケット命名規則の詳細については、「[汎用バケットの命名規則](bucketnamingrules.md)」を参照してください。
1. [**リージョン**] で、バケットを保存する AWS リージョン を選択します。
バケットのリージョンの詳細については、「[汎用バケットの概要](UsingBucket.md)」を参照してください。
1. [**このバケットのパブリックアクセス設定をブロック**] で、デフォルト設定 (**ブロック*すべて*パブリックアクセス**が有効) のままであることを確認します。
ユースケースでオフにする必要のある設定が 1 つ以上あることがわかっている場合を除き、すべてのブロックパブリックアクセス設定を有効にしておくことをお勧めします。パブリックアクセスのブロックの詳細については、[Amazon S3 ストレージへのパブリックアクセスのブロック](access-control-block-public-access.md) を参照してください。
1. 残りの設定はデフォルトのままにしておきます。
(オプション) 特定のユースケースに追加のバケット設定を設定する場合は、「[汎用バケットの作成](create-bucket-overview.md)」を参照してください。
1. **[バケットを作成]** を選択します。
## ステップ 2: S3 バケットにファイルをアップロード
名前、銀行情報、電話番号、SSN など、さまざまなタイプの既知の PII データを含むテキストファイルを S3 バケットにアップロードします。このテキストファイルは、このチュートリアルの後半で PII を編集します。
例えば、次の `tutorial.txt` ファイルをアップロードできます。これは、Amazon Comprehend からの入力ファイルの例です。
```
Hello Zhang Wei, I am John. Your AnyCompany Financial Services,
LLC credit card account 1111-0000-1111-0008 has a minimum payment
of $24.53 that is due by July 31st. Based on your autopay settings,
we will withdraw your payment on the due date from your
bank account number XXXXXX1111 with the routing number XXXXX0000.
Your latest statement was mailed to 100 Main Street, Any City,
WA 98121.
After your payment is received, you will receive a confirmation
text message at 206-555-0100.
If you have questions about your bill, AnyCompany Customer Service
is available by phone at 206-555-0199 or
email at support@anycompany.com.
```
**バケットにファイルをアップロードするには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、[**バケット**] を選択します。
1. **[バケット]** リストで、[ステップ 1](#ol-pii-step1) で作成したバケットの名前を選択し (**tutorial-bucket** など)、ファイルをアップロードします。
1. バケットの **[オブジェクト]** タブで、**[アップロード]** を選択します。
1. [**アップロード**] ページの [**ファイルとフォルダ**] の下で、[**ファイルを追加**] を選択します。
1. アップロードするファイルを選択し、続いて **[オープン]** を選択します。例えば、前述した `tutorial.txt` ファイルの例をアップロードできます。
1. **アップロード** を選択します。
## ステップ 3: S3 アクセスポイントの作成
S3 Object Lambda アクセスポイントを使用して元のデータにアクセスし、変換するには、S3 アクセスポイントを作成し、[ステップ 1](#ol-pii-step1) で作成した S3 バケットに関連付けます。アクセスポイントは、変換するオブジェクトと同じ AWS リージョン に存在する必要があります。
このチュートリアルの後半では、このアクセスポイントを Object Lambda アクセスポイントのサポートアクセスポイントとして使用します。
**アクセスポイントを作成するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール ([https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)) を開きます。
1. 左のナビゲーションペインで、[**アクセスポイント**] を選択します。
1. [**アクセスポイント**] ページで、[**アクセスポイントの作成**] を選択します。
1. **[アクセスポイント名]** フィールドに、アクセスポイントの名前を入力します (**tutorial-pii-access-point** など)。
アクセスポイントの名前付けの詳細については、「[アクセスポイントの命名規則](access-points-restrictions-limitations-naming-rules.md#access-points-names)」を参照してください。
1. **[データソース]** フィールドに、[ステップ 1](#ol-pii-step1) で作成したバケットの名前を入力します (**tutorial-bucket** など)。S3 は、アクセスポイントをこのバケットにアタッチします。
(オプション) **[S3 を参照]** を選択して、アカウント内のバケットを参照および検索できます。**[S3 を参照]** を選択した場合は、目的のバケットを選択し、**[パスの選択]** を選択して、**[バケット名]** フィールドにバケットの名前を入力します。
1. [**ネットワークオリジン**] で、[**インターネット**] を選択します。
アクセスポイントのネットワークオリジンの詳細については、「[Virtual Private Cloud に制限されたアクセスポイントの作成](access-points-vpc.md)」を参照してください。
1. デフォルトでは、アクセスポイントに対してすべてのブロックパブリックアクセス設定が有効になります。**パブリックアクセスブロック設定**は、*すべて*を有効にしておくことを推奨します。詳細については、「[汎用バケットのアクセスポイントへのパブリックアクセスの管理](access-points-bpa-settings.md)」を参照してください。
1. その他のすべてのアクセスポイント設定で、デフォルトの設定を保持します。
(オプション) アクセスポイントの設定は、ユースケースをサポートするように変更できます。このチュートリアルでは、デフォルトの設定を保持することをお勧めします。
(オプション) アクセスポイントへのアクセスを管理する必要がある場合は、アクセスポイントポリシーを指定できます。詳細については、「[アクセスポイントのポリシーの例](access-points-policies.md#access-points-policy-examples)」を参照してください。
1. **[アクセスポイントを作成]** を選択します。
## ステップ 4: 事前構築された Lambda 関数の設定とデプロイ
PII データを編集するには、事前に構築された AWS Lambda関数 `ComprehendPiiRedactionS3ObjectLambda` を S3 Object Lambda アクセスポイントと共に設定、デプロイします。
**Lambda 関数の設定とデプロイ**
1. AWS マネジメントコンソール にサインインし、AWS Serverless Application Repository で [https://console.aws.amazon.com/lambda/home#/create/app?applicationId=arn:aws:serverlessrepo:us-east-1:839782855223:applications/ComprehendPiiRedactionS3ObjectLambda](https://console.aws.amazon.com/lambda/home#/create/app?applicationId=arn:aws:serverlessrepo:us-east-1:839782855223:applications/ComprehendPiiRedactionS3ObjectLambda) 関数を表示します。
1. [**アプリケーション名**] の下の [**アプリケーションの設定**] では、このチュートリアルのデフォルト値 (`ComprehendPiiRedactionS3ObjectLambda`) を保持します。
(オプション) このアプリケーションに付ける名前を入力できます。同じ共有データセットに対して異なるアクセスニーズを持つ複数の Lambda 関数を設定する場合は、これを行うことをお勧めします。
1. [**MaskCharacter**] で、デフォルト値 (`*`) を保持します。マスク文字は、編集された PII エンティティの各文字を置き換えます。
1. [**MaskMode**] で、デフォルト値 (**MASK**) を保持します。**MaskMode** の値は、PII エンティティを `MASK` 文字または `PII_ENTITY_TYPE` 値に変更することを指定します。
1. 指定したタイプのデータを墨消しするには、[**PiiEntityTypes**] で、デフォルト値の **ALL** を保持します。**PiiEntityTypes** の値は、墨消しの対象となる PII エンティティタイプを指定します。
サポートされる PII エンティティタイプの一覧の詳細については、*Amazon Comprehend デベロッパーガイド*の[個人を特定できる情報 (PII) の検出](https://docs.aws.amazon.com/comprehend/latest/dg/how-pii.html)を参照してください。
1. 残りの設定はデフォルト値のままにしておきます。
(オプション) 特定のユースケースに対して追加の設定を構成する場合は、ページの左側の **Readme ファイル**セクションを参照してください。
1. [**I acknowledge that this app creates custom IAM roles (このアプリでカスタム IAM ロールを作成することを認識しています)**] チェックボックスをオンにします。
1. **[デプロイ]** をクリックします。
1. 新しいアプリケーションのページの [**リソース**] で、デプロイする Lambda 関数の [**論理 ID**] を選択して、Lambda 関数ページで関数を確認します。
## ステップ 5: S3 Object Lambda アクセスポイントの作成
S3 Object Lambda アクセスポイントは、S3 GET リクエストから Lambda 関数を直接呼び出す柔軟性を提供し、関数が S3 アクセスポイントから取得した PII データを編集できるようにします。S3 Object Lambda アクセスポイントを作成および設定するときは、変更する Lambda 関数を指定して、Lambda が使用するカスタムパラメータとして JSON 形式のイベントコンテキストを呼び出し、提供する必要があります。
イベントコンテキストは、S3 Object Lambda から Lambda に渡されたイベントで行われたリクエストに関する情報を提供します。イベントコンテキスト内のすべてのフィールドの詳細については、「 [イベントコンテキストの形式と使用法](olap-event-context.md)」を参照してください。
**S3 Object Lambda アクセスポイントを作成するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左のナビゲーションペインで、[**Object Lambda アクセスポイント**] を選択します。
1. [**Object Lambda アクセスポイント**] ページで、[**Object Lambda アクセスポイントの作成**] を選択します。
1. **Object Lambda アクセスポイント名**] に、Object Lambda アクセスポイントに使用する名前を入力します (例、**tutorial-pii-object-lambda-accesspoint**)。
1. **[サポートするアクセスポイント]** で、[ステップ 3](#ol-pii-step3) で作成した標準アクセスポイントを入力または参照します (**tutorial-pii-access-point** など)。次に、**[サポートするアクセスポイントの選択]** を選択します。
1. **S3 API** の場合、Lambda 関数が処理する S3 バケットからオブジェクトを取得するには、**[GetObject]** を選択します。
1. **[Lambda 関数の呼び出し]** では、このチュートリアルでは、次の 2 つのオプションのいずれかを選択できます。
+ **[アカウントの関数から選択]** を選択し、**[Lambda 関数]** ドロップダウンリストから、[ステップ 4](#ol-pii-step4) (例、**serverlessrepo-ComprehendPiiRedactionS3ObjectLambda**) でデプロイしたLambda 関数を選択します。
+ **ARN を入力**] を選択し、[ステップ 4](#ol-pii-step4) で作成した Lambda 関数の Amazon リソースネーム (ARN) を入力します。
1. [**Lambda 関数のバージョン**] で、**\$1LATEST** ([ステップ 4](#ol-pii-step4) でデプロイした Lambda 関数の最新バージョン) を選択します。
1. (オプション) Lambda 関数で、範囲とパート番号によって GET リクエストを認識および処理する必要がある場合は、[**Lambda 関数は、範囲を使用してリクエストをサポート**] および [**Lambda 関数は、パート番号を使用してリクエストをサポート**] を選択します。それ以外の場合は、これらの 2 つのチェックボックスをオフにします。
S3 Object Lambda で範囲またはパート番号を使用する方法の詳細については、「[Range および partNumber ヘッダーの操作](range-get-olap.md)」を参照してください。
1. (オプション) [**ペイロード - *オプション***] で JSON テキストを追加して、Lambda 関数に追加情報を提供します。
ペイロードは、特定の S3 Object Lambda アクセスポイントからのすべての呼び出しに対する入力として、Lambda 関数に提供できるオプションの JSON テキストです。同じ Lambda 関数を呼び出す複数の Object Lambda アクセスポイントの動作をカスタマイズして、異なるパラメータを使用してペイロードを設定できます。これにより、Lambda 関数の柔軟性が向上します。
ペイロードの詳細については、「[イベントコンテキストの形式と使用法](olap-event-context.md)」を参照してください。
1. (オプション) **[リクエストメトリクス - *オプション*]** で、**[無効]** または **[有効]** を選択して、Amazon S3 モニタリングを Object Lambda アクセスポイントに追加します。リクエストメトリクスには、Amazon CloudWatch の標準料金が課金されます。詳細については、「[CloudWatch 料金表](https://aws.amazon.com/cloudwatch/pricing/)」を参照してください。
1. [**Object Lambda アクセスポイントポリシー-*オプション***] で、デフォルトの設定を保持します。
(オプション) リソースポリシーを設定できます。このリソースポリシーは、指定された Object Lambda アクセスポイントを使用する `GetObject` API 許可を付与します。
1. 残りの設定はデフォルト値のままにしておき、[**Object Lambda アクセスポイントの作成**] を選択します。
## ステップ 6: S3 Object Lambda アクセスポイントを使用して、編集されたファイルを取得する
これで、S3 Object Lambda は元のファイルから PII データを編集する準備が整いました。
**S3 Object Lambda アクセスポイントを使用して、編集されたファイルを取得するには**
S3 Object Lambda アクセスポイントを使用してファイルの取得をリクエストすると、S3 Object Lambda への `GetObject` API 呼び出しが行われます。S3 Object Lambda は Lambda 関数を呼び出して PII データを変換し、変換されたデータを標準 S3 `GetObject` API への応答として返します。
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左のナビゲーションペインで、[**Object Lambda アクセスポイント**] を選択します。
1. [**Object Lambda アクセスポイント**] ページで、[ステップ 5](#ol-pii-step5) で作成した S3 Object Lambda アクセスポイントを選択します (例、**tutorial-pii-object-lambda-accesspoint**)。
1. S3 Object Lambda アクセスポイントの [**オブジェクト**] タブで、[ステップ 2](#ol-pii-step2) で S3 バケットにアップロードしたファイルと同じ名前のファイルを選択します(例、`tutorial.txt`)。
このファイルには、変換されたすべてのデータが含まれているはずです。
1. 変換されたデータを表示するには、[**開く**] または [**ダウンロード**] を選択します。
次の例に示すように、編集されたファイルを確認できます。
```
Hello *********. Your AnyCompany Financial Services,
LLC credit card account ******************* has a minimum payment
of $24.53 that is due by *********. Based on your autopay settings,
we will withdraw your payment on the due date from your
bank account ********** with the routing number *********.
Your latest statement was mailed to **********************************.
After your payment is received, you will receive a confirmation
text message at ************.
If you have questions about your bill, AnyCompany Customer Service
is available by phone at ************ or
email at **********************.
```
## ステップ 7: クリーンアップ
学習のためだけに S3 Object Lambda によってデータを編集した場合は、割り当てた AWS リソースを削除して、料金が発生しないようにします。
**Topics**
+ [Object Lambda アクセスポイントの削除](#ol-pii-step8-delete-olap)
+ [S3 アクセスポイントを削除する](#ol-pii-step8-delete-ap)
+ [Lambda 関数を削除する](#ol-pii-step8-delete-lambda-function)
+ [CloudWatch Logs グループを削除する](#ol-pii-step8-delete-cloudwatch)
+ [S3 ソースバケットの元のファイルを削除する](#ol-pii-step8-delete-file)
+ [S3 ソースバケットを削除する](#ol-pii-step8-delete-bucket)
+ [Lambda 関数の IAM ロールを削除する](#ol-pii-step8-delete-lambda-role)
+ [IAM ユーザーのカスタマーマネージドポリシーを削除する](#ol-pii-step8-delete-function-policy)
+ [IAM ユーザーを削除する](#ol-pii-step8-delete-user)
### Object Lambda アクセスポイントの削除
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左のナビゲーションペインで、[**Object Lambda アクセスポイント**] を選択します。
1. [**Object Lambda アクセスポイント**] ページで、[ステップ 5](#ol-pii-step5) で作成した S3 Object Lambda アクセスポイントの左にあるオプションブタンを選択します (例、**tutorial-pii-object-lambda-accesspoint**)。
1. **[削除]** を選択します。
1. 表示されるテキストフィールドにアクセスポイントの名前を入力して、[**削除**] を選択し、bject Lambda アクセスポイントを削除することを確認します。
### S3 アクセスポイントを削除する
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左のナビゲーションペインで、[**アクセスポイント**] を選択します。
1. [ステップ 3](#ol-pii-step3) で作成したアクセスポイントに移動し (例、**tutorial-pii-access-point**)、アクセスポイントの名前の横にあるオプションボタンを選択します。
1. **[削除]** を選択します。
1. 表示されるテキストフィールドにアクセスポイントの名前を入力して、アクセスポイントを削除することを確認し、[**削除**] を選択します。
### Lambda 関数を削除する
1. AWS Lambda コンソール ([https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)) で、左のナビゲーションペインの**関数**を選択します。
1. [ステップ 4](#ol-pii-step4) で作成した関数 (例、**serverlessrepo-ComprehendPiiRedactionS3ObjectLambda**) を選択します。
1. **[アクション]**、**[削除]** の順に選択します。
1. **[関数の削除]** ダイアログボックスで、**[削除]** を選択します。
### CloudWatch Logs グループを削除する
1. CloudWatch コンソールの [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) を開いてください。
1. 左側のナビゲーションペインで、**[ロググループ]** をクリックします。
1. [ステップ 4](#ol-pii-step4) で作成した Lambda 関数で終わる名前のロググループを検索します(例、**serverlessrepo-ComprehendPiiRedactionS3ObjectLambda**)。
1. [**アクション**] を選択してから、[**ロググループの削除**] を選択します。
1. **[ロググループの削除]** ダイアログボックスで、**[削除]** をクリックします。
### S3 ソースバケットの元のファイルを削除する
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、[**バケット**] を選択します。
1. **バケット名**] リストで、[ステップ 2](#ol-pii-step2) で元のファイルをアップロードしたバケットの名前を選択します(例、**tutorial-bucket**)。
1. 削除するオブジェクトの名前の左にあるチェックボックスを選択します (例、`tutorial.txt`)。
1. **[削除]** を選択します。
1. [**オブジェクトの削除**] ページの [**オブジェクトを完全に削除しますか?**] セクションで、テキストボックスに「**permanently delete**」と入力して、このオブジェクトを削除することを確認します。
1. **オブジェクトの削除** を選択します。
### S3 ソースバケットを削除する
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、[**バケット**] を選択します。
1. [**バケット**] リストで、[ステップ 1](#ol-pii-step1) で作成したバケットの名前の横にあるラジオボタンを選択します (例、**tutorial-bucket**)。
1. **[削除]** を選択します。
1. [**バケットを削除する**] ページで、テキストフィールドにバケット名を入力することでバケットを削除することを確認し、[**バケットを削除する**] を選択します。
### Lambda 関数の IAM ロールを削除する
1. AWS マネジメントコンソール にサインインして、IAM コンソール [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) を開きます。
1. 左のナビゲーションペインで、[**ロール**] を選択し、削除するロール名の隣にあるチェックボックスを選択します。ロール名は、[ステップ 4](#ol-pii-step4) でデプロイした Lambda 関数の名前で始まります (例、**serverlessrepo-ComprehendPiiRedactionS3ObjectLambda**)。
1. **[削除]** を選択します。
1. [**削除**] ダイアログボックスで、テキスト入力フィールドにロール名を入力し、ユーザーの削除を確認します。その後、**[削除]** をクリックします。
### IAM ユーザーのカスタマーマネージドポリシーを削除する
1. AWS マネジメントコンソール にサインインして、IAM コンソール [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) を開きます。
1. 左のナビゲーションペインの **[ポリシー]** を選択します。
1. [**ポリシー**] ページで、[[前提条件](#ol-pii-prerequisites)] で作成したカスタマーマネージドポリシーの名前 (例、**tutorial-serverless-application-repository**) を検索ボックスに入力して、ポリシーのリストをフィルタリングします。削除するアポリシーの名前の横にあるオプションボタンを選択します。
1. **[アクション]**、**[削除]** の順に選択します。
1. 表示されるテキストフィールドにポリシーの名前を入力して、このポリシーを削除することを確認し、[**削除**] を選択します。
### IAM ユーザーを削除する
1. AWS マネジメントコンソール にサインインして、IAM コンソール [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) を開きます。
1. 左のナビゲーションペインで、[**ユーザー**] を選択し、削除するユーザー名の横にあるチェックボックスを選択します。
1. ページの上部で、[**削除**] を選択します。
1. [***ユーザー名*を削除しますか?**] ダイアログボックスで、テキスト入力フィールドにユーザー名を入力し、ユーザーの削除を確認します。**[削除]** を選択します。
## 次のステップ
このチュートリアルを完了すると、次の関連するユースケースをさらに調べることができます。
+ 複数の S3 Object Lambda アクセスポイントを作成し、データアクセサーのビジネスニーズに応じて特定の種類の PII を変更するように構成された事前構築済みの Lambda 関数でそれらを有効にすることができます。
各タイプのユーザーは IAM ロールを引き受け、1 つの S3 Object Lambda アクセスポイント(IAM ポリシーで管理)にのみアクセスできます。次に、異なる編集ユースケース用に設定されたそれぞれの `ComprehendPiiRedactionS3ObjectLambda` Lambda 関数を異なる S3 Object Lambda アクセスポイントにアタッチします。S3 Object Lambda アクセスポイントごとに、共有データセットを保存する S3 バケットからデータを読み取るためのサポートする S3 アクセスポイントを持つことができます。
ユーザーが、S3 アクセスポイントを介してのみバケットから読み取ることを許可する、S3 バケットポリシーを作成する方法については、「[アクセスポイントを使用するための IAM ポリシーの設定](access-points-policies.md)」を参照してください。
Lambda 関数、S3 アクセスポイント、および S3 Object Lambda アクセスポイントにアクセスする許可をユーザーに付与する方法の詳細については、「[Object Lambda アクセスポイントの IAM ポリシーの設定](olap-policies.md)」を参照してください。
+ 独自の Lambda 関数を構築し、カスタマイズした Lambda 関数で S3 Object Lambda を使用し、特定のデータニーズを満たすことができます。
例えば、さまざまなデータ値を調べるには、S3 Object Lambda と、追加の [Amazon Comprehend の機能](https://aws.amazon.com/comprehend/features/)(エンティティ認識、キーフレーズ認識、センチメント分析、ドキュメントの分類など)を使用して、データを処理できます。また、S3 Object Lambda を [Amazon Comprehend Medical](https://aws.amazon.com/comprehend/medical/) (HIPAA 適格な NLP サービス) と共に使用して、コンテキストに応じた方法でデータを分析および抽出できます。
S3 Object Lambda および独自の Lambda 関数を使用してデータを変換する方法の詳細については、「[チュートリアル: S3 Object Lambda を使用したアプリケーションのデータの変換](tutorial-s3-object-lambda-uppercase.md)」を参照してください。
# S3 Object Lambda のデバッグとトラブルシューティング
**注記**
2025 年 11 月 7 日現在、S3 Object Lambda は、現在サービスを使用している既存のお客様、および一部の AWS パートナーネットワーク (APN) パートナーのみが利用できます。S3 Object Lambda と同様の機能の詳細については、「[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)」を参照してください。
Amazon S3 Object Lambda アクセスポイントへのリクエストにより、Lambda 関数の呼び出しまたは実行で何か問題が発生したときに、新しいエラーレスポンスが発生することがあります。このようなエラーは、標準の Amazon S3 エラーと同じ形式に従います。S3 Object Lambda エラーについては、*Amazon Simple Storage Service API リファレンス*の [S3 Object Lambda エラーコードリスト](https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#S3ObjectLambdaErrorCodeList)を参照してください。
一般的な Lambda 関数のデバッグの詳細については、*AWS Lambda デベロッパーガイド*の[「Lambda アプリケーションのモニタリングとトラブルシューティング」](https://docs.aws.amazon.com/lambda/latest/dg/lambda-monitoring.html )を参照してください。
Amazon S3 の標準エラーについては、*Amazon Simple Storage Service API リファレンス*の[エラーレスポンス](https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html)を参照してください。
Object Lambda アクセスポイントに対して Amazon CloudWatch のリクエストメトリクスを有効にできます。このメトリクスは、アクセスポイントの動作パフォーマンスのモニタリングに役立ちます。リクエストメトリクスは、Object Lambda アクセスポイントの作成中もしくは作成後に有効にできます。詳細については、「[CloudWatch の S3 Object Lambda リクエスト](metrics-dimensions.md#olap-cloudwatch-metrics)」を参照してください。
Object Lambda アクセスポイントに対して行われたリクエストについて、より詳細なログを取得するには、AWS CloudTrail データイベントを有効にできます。詳細については、*AWS CloudTrail ユーザーガイド*の「[証跡へのデータイベントのログ記録](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html)」を参照してください。
S3 Object Lambda チュートリアルについては、以下を参照してください。
+ [チュートリアル: S3 Object Lambda を使用したアプリケーションのデータの変換](tutorial-s3-object-lambda-uppercase.md)
+ [チュートリアル: S3 Object Lambda と Amazon Comprehend を使用した PII データの検出と編集](tutorial-s3-object-lambda-redact-pii.md)
+ [チュートリアル: S3 Object Lambda を使用して、取得時に画像に動的に透かしを入れる](https://aws.amazon.com/getting-started/hands-on/amazon-s3-object-lambda-to-dynamically-watermark-images/?ref=docs_gateway/amazons3/transforming-objects.html)
標準のアクセスポイントの詳細については、[アクセスポイントを使用した共有データセットへのアクセスの管理](access-points.md) を参照してください。
バケットの操作方法の詳細については、「[汎用バケットの概要](UsingBucket.md)」を参照してください。オブジェクトの操作方法の詳細については、[Amazon S3 オブジェクトの概要](UsingObjects.md) を参照してください。