# 使用 S3 对象 Lambda 转换对象
**注意**
自 2025 年 11 月 7 日起，S3 对象 Lambda 仅可供当前在使用该服务的现有客户以及部分 AWS 合作伙伴网络（APN）合作伙伴使用。要了解与 S3 对象 Lambda 类似的功能，请在此处了解更多信息：[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)。
借助 Amazon S3 对象 Lambda，您可以将自己的代码添加到 Amazon S3 `GET`、`LIST` 和 `HEAD` 请求中，以便在数据返回到应用程序时修改和处理数据。您可以使用自定义代码修改由 S3 `GET` 请求返回的数据，以便执行筛选行、动态调整图像大小和给图像加水印、隐去机密数据等操作。您还可以使用 S3 对象 Lambda 修改 S3 `LIST` 请求的输出以创建存储桶中所有对象的自定义视图，以及修改 S3 `HEAD` 请求以修改对象元数据（如对象名称和大小）。您可以使用 S3 对象 Lambda 作为 Amazon CloudFront 分配的来源，以便为最终用户量身定制数据，例如自动调整图像大小、对旧格式进行转码（例如从 JPEG 转码为 WebP）或剥离元数据。有关更多信息，请参阅 AWS 博客文章[将 Amazon S3 对象 Lambda 与 Amazon CloudFront 结合使用](https://aws.amazon.com/blogs/aws/new-use-amazon-s3-object-lambda-with-amazon-cloudfront-to-tailor-content-for-end-users/)。在 AWS Lambda 函数的支持下，您的代码在完全由 AWS 管理的基础设施上运行。使用 S3 对象 Lambda 可以减少创建和存储数据的衍生副本或运行代理的需要，所有这些都无需更改应用程序。
**S3 对象 Lambda 的工作原理**
S3 对象 Lambda 使用 AWS Lambda 函数来自动处理标准 S3 `GET`、`LIST` 或 `HEAD` 请求的输出。AWS Lambda 是一种无服务器计算服务，它运行客户定义的代码，而无需管理底层计算资源。您可以编写和运行自己的自定义 Lambda 函数，根据您的特定使用案例定制数据转换。
配置 Lambda 函数后，您可以将其附加到 S3 对象 Lambda 服务端点（称为*对象 Lambda 接入点*）。对象 Lambda 接入点使用标准 S3 接入点（称为*支持接入点*）来访问数据。
当您向对象 Lambda 接入点发送请求时，Amazon S3 会自动调用您的 Lambda 函数。然后，使用 S3 `GET`、`LIST` 或 `HEAD` 请求通过对象 Lambda 接入点检索的任何数据都会将转换后的结果返回给应用程序。将正常处理所有其他请求，如下图所示。
![\[图中显示了 S3 对象 Lambda 的工作原理。\]](http://docs.aws.amazon.com/zh_cn/AmazonS3/latest/userguide/images/ObjectLamdaDiagram.png)
本节中的主题介绍了如何使用 S3 对象 Lambda。
**Topics**
+ [创建对象 Lambda 接入点](olap-create.md)
+ [使用 Amazon S3 对象 Lambda 接入点](olap-use.md)
+ [S3 对象 Lambda 接入点的安全注意事项](olap-security.md)
+ [为 S3 对象 Lambda 接入点编写 Lambda 函数](olap-writing-lambda.md)
+ [使用 AWS 构建的 Lambda 函数](olap-examples.md)
+ [S3 对象 Lambda 的最佳实践和指南](olap-best-practices.md)
+ [S3 对象 Lambda 教程](olap-tutorials.md)
+ [S3 对象 Lambda 调试和故障排除](olap-debugging-lambda.md)
# 创建对象 Lambda 接入点
**注意**
自 2025 年 11 月 7 日起，S3 对象 Lambda 仅可供当前在使用该服务的现有客户以及部分 AWS 合作伙伴网络（APN）合作伙伴使用。要了解与 S3 对象 Lambda 类似的功能，请在此处了解更多信息：[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)。
一个对象 Lambda 接入点恰好与一个标准接入点相关联，后者是在创建过程中指定的。要创建对象 Lambda 接入点，您需要以下资源：
+ **标准 S3 接入点。**当您使用对象 Lambda 接入点时，此标准接入点称为*支持接入点*，它附加到 S3 存储桶或适用于 OpenZFS 的 Amazon FSx 卷。有关创建标准接入点的信息，请参阅[创建接入点](creating-access-points.md)。
+ **AWS Lambda 函数。**您可以创建自己的 Lambda 函数，也可以使用预构建的函数。有关创建 Lambda 函数的更多信息，请参阅[为 S3 对象 Lambda 接入点编写 Lambda 函数](olap-writing-lambda.md)。有关预构建的函数的更多信息，请参阅 [使用 AWS 构建的 Lambda 函数](olap-examples.md)。
+ **（可选）AWS Identity and Access Management（IAM）策略。**Amazon S3 接入点支持 IAM 资源策略，您可以使用这些策略按资源、用户或其他条件控制接入点的使用。有关创建这些策略的更多信息，请参阅[为对象 Lambda 接入点配置 IAM 策略](olap-policies.md)。
以下各节介绍如何使用以下方法创建对象 Lambda 接入点：
+ 这些区域有：AWS 管理控制台
+ AWS Command Line Interface（AWS CLI）
+ AWS CloudFormation 模板
+ 这些区域有：AWS Cloud Development Kit (AWS CDK)
有关如何使用 REST API 创建对象 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)。
## 创建对象 Lambda 接入点
使用以下过程之一创建对象 Lambda 接入点。
### 使用 S3 控制台
**使用控制台创建对象 Lambda 接入点**
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在导航栏中，选择当前所显示 AWS 区域的名称。接下来，选择要切换到的区域。
1. 在左侧导航窗格中，选择 **Object Lambda 接入点**。
1. 在**对象 Lambda 接入点**页面上，选择**创建对象 Lambda 接入点**。
1. 对于**对象 Lambda 接入点名称**，输入要用于接入点的名称。
与标准接入点一样，对于对象 Lambda 接入点同样具有命名规则。有关更多信息，请参阅 [接入点的命名规则](access-points-restrictions-limitations-naming-rules.md#access-points-names)。
1. 对于 **Supporting Access Point**（支持接入点），请输入或浏览到要使用的标准接入点。接入点必须与要变换的对象位于同一 AWS 区域 位置。有关创建标准接入点的信息，请参阅[创建接入点](creating-access-points.md)。
1. 在**转换配置**下，您可以添加一个函数来转换对象 Lambda 接入点的数据。请执行以下操作之一：
+ 如果您的账户中已经有一个 AWS Lambda 函数，则可以在 **Invoke Lambda function**（调用 Lambda 函数）下选择该函数。在这里，您可以在您的 AWS 账户中输入 Lambda 函数的 Amazon 资源名称（ARN），也可以从下拉菜单中选择 Lambda 函数。
+ 如果您想使用 AWS 构建的函数，请在 **AWS 构建的函数**下选择函数名称，然后选择**创建 Lambda 函数**。这将带您进入 Lambda 控制台，您可以在其中将构建的函数部署到您的 AWS 账户中。有关构建的函数的更多信息，请参阅[使用 AWS 构建的 Lambda 函数](olap-examples.md)。
在 **S3 APIs**（S3 API）下，选择一个或多个要调用的 API 操作。对于所选的每个 API，您必须指定要调用的 Lambda 函数。
1. （可选）在 **Payload**（有效负载）下，添加要提供给 Lambda 函数作为输入的 JSON 文本。您可以为调用同一 Lambda 函数的不同对象 Lambda 接入点配置具有不同参数的负载，从而扩展 Lambda 函数的灵活性。
**重要**
使用对象 Lambda 接入点时，确保负载不包含任何机密信息。
1. （可选）对于 **Range and part number**（范围和分段编号），如果您要处理带有范围和分段编号标头的 `GET` 和 `HEAD` 请求，则必须启用此选项。启用此选项将确认您的 Lambda 函数可以识别和处理这些请求。有关范围标头和分段编号的更多信息，请参阅 [使用 Range 和 partNumber 标头](range-get-olap.md)。
1. （可选）对于**请求指标**，请选择**启用**或**禁用**，以将 Amazon S3 监控添加到对象 Lambda 接入点。请求指标按标准 Amazon CloudWatch 费率计费。
1. （可选）在**对象 Lambda 接入点策略**下，设置资源策略。资源策略授予针对指定对象 Lambda 接入点的权限，并可以按资源、用户或其他条件控制接入点的使用。有关对象 Lambda 接入点资源策略的更多信息，请参阅[为对象 Lambda 接入点配置 IAM 策略](olap-policies.md)。
1. 在**屏蔽此对象 Lambda 接入点的公共访问权限设置**下，选择要应用的屏蔽公共访问权限设置。默认情况下，为新的对象 Lambda 接入点启用所有屏蔽公共访问权限设置，建议您将默认设置保留为启用状态。Amazon S3 当前不支持在创建对象 Lambda 接入点之后更改对象 Lambda 接入点的屏蔽公共访问权限设置。
有关使用 Amazon S3 屏蔽公共访问权限的更多信息，请参阅[管理对通用存储桶的接入点的公共访问权限](access-points-bpa-settings.md)。
1. 请选择**创建对象 Lambda 接入点**。
### 使用 AWS CLI
**使用 AWS CloudFormation 模板创建对象 Lambda 接入点**
**注意**
要使用以下命令，请将 `user input placeholders` 替换为您自己的信息。
1. 在 [S3 对象 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 对象 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
```
您可以将此 AWS CloudFormation 模板配置为针对 `GET`、`HEAD` 和 `LIST` API 操作调用 Lambda。有关修改模板的默认配置的更多信息，请参阅[使用 CloudFormation 模板自动进行 S3 对象 Lambda 设置](olap-using-cfn-template.md)。
**使用 AWS CLI 创建对象 Lambda 接入点**
**注意**
要使用以下命令，请将 `user input placeholders` 替换为您自己的信息。
以下示例为账户 *`111122223333`* 中的存储桶 *`amzn-s3-demo-bucket1`* 创建了一个名为 *`my-object-lambda-ap`* 的对象 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. 请执行以下操作之一：
+ 在您的账户中创建一个 Lambda 函数，用于转换 Amazon S3 对象。有关创建 Lambda 函数的更多信息，请参阅[为 S3 对象 Lambda 接入点编写 Lambda 函数](olap-writing-lambda.md)。要将您的自定义函数与 AWS CLI 结合使用，请参阅《AWS Lambda 开发人员指南》**中的[将 Lambda 与 AWS CLI 结合使用](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` 命令以创建对象 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 策略文件。
添加对象 Lambda 接入点资源策略可以按资源、用户或其他条件控制接入点的使用。此资源策略为账户 *`444455556666`* 授予针对指定对象 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. （可选）指定负载。
有效负载是可选 JSON，您可以将其作为输入提供给 AWS Lambda 函数。您可以为调用同一 Lambda 函数的不同对象 Lambda 接入点配置具有不同参数的负载，从而扩展 Lambda 函数的灵活性。
以下对象 Lambda 接入点配置显示了带有两个参数的负载。
```
{
"SupportingAccessPoint": "AccessPointArn",
"CloudWatchMetricsEnabled": false,
"TransformationConfigurations": [{
"Actions": ["GetObject", "HeadObject", "ListObjects", "ListObjectsV2"],
"ContentTransformation": {
"AwsLambda": {
"FunctionArn": "FunctionArn",
"FunctionPayload": "{\"res-x\": \"100\",\"res-y\": \"100\"}"
}
}
}]
}
```
以下对象 Lambda 接入点配置显示具有一个参数以及启用了 `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\"}"
}
}
}]
}
```
**重要**
使用对象 Lambda 接入点时，确保负载不包含任何机密信息。
### 使用 AWS CloudFormation 控制台和模板
您可以使用 Amazon S3 提供的默认配置创建对象 Lambda 接入点。您可以从 [GitHub 存储库](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration)下载 AWS CloudFormation 模板和 Lambda 函数源代码，并部署这些资源以设置函数对象 Lambda 接入点。
有关修改 AWS CloudFormation 模板的默认配置的信息，请参阅[使用 CloudFormation 模板自动进行 S3 对象 Lambda 设置](olap-using-cfn-template.md)。
有关在没有模板的情况下使用 CloudFormation 配置对象 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 对象 Lambda 默认配置](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration)中下载 AWS Lambda 函数部署包 `s3objectlambda_deployment_package.zip`。
1. 将文件包上传到 Amazon S3 存储桶。
**使用 AWS CloudFormation 控制台创建对象 Lambda 接入点**
1. 在 [S3 对象 Lambda 默认配置](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration)中下载 AWS CloudFormation 模板 `s3objectlambda_defaultconfig.yaml`。
1. 登录 AWS 管理控制台并通过以下网址打开 AWS CloudFormation 控制台：[https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/)。
1. 请执行以下操作之一：
+ 如果您以前从未用过 AWS CloudFormation，请在 AWS CloudFormation 主页上选择 **Create stack**（创建堆栈）。
+ 如果之前用过 AWS CloudFormation，请在左侧导航窗格中选择 **Stacks**（堆栈）。选择 **Create stack**（创建堆栈），然后选择 **With new resources (standard)** [使用新资源（标准）]。
1. 对于 **Prerequisite - Prepare template**（先决条件 - 准备模板），请选择 **Template is ready**（模板已就绪）。
1. 对于 **Specify template**（指定模板），选择 **Upload a template file**（上传模板文件）并上传 `s3objectlambda_defaultconfig.yaml`。
1. 选择**下一步**。
1. 在 **Specify stack details**（指定堆栈详细信息）页面上，输入堆栈名称。
1. 在 **Parameters**（参数）部分中，指定在堆栈模板中定义的以下参数：
1. 对于 **CreateNewSupportingAccessPoint**，请执行以下操作之一：
+ 如果对于您上传了模板的 S3 存储桶已经有支持接入点，请选择 **false**。
+ 如果要为该存储桶创建新的接入点，请选择 **true**。
1. 对于 **EnableCloudWatchMonitoring**，根据您是否要启用 Amazon CloudWatch 请求指标和告警，选择 **true** 或 **false**。
1. （可选）对于 **LambdaFunctionPayload**，添加要提供给 Lambda 函数作为输入的 JSON 文本。您可以为调用同一 Lambda 函数的不同对象 Lambda 接入点配置具有不同参数的负载，从而扩展 Lambda 函数的灵活性。
**重要**
使用对象 Lambda 接入点时，确保负载不包含任何机密信息。
1. 对于 **LambdaFunctionRuntime**，输入适用于 Lambda 函数的首选运行时。可用的选项为 `nodejs14.x`、`python3.9`、`java11`。
1. 对于 **LambdaFunctionS3BucketName**，输入您在其中上传了部署文件包的 Amazon S3 存储桶名称。
1. 对于 **LambdaFunctionS3Key**，输入您在上传部署文件包时使用的 Amazon S3 对象密钥。
1. 对于 **LambdaFunctionS3ObjectVersion**，输入您在其中上传了部署文件包的 Amazon S3 对象版本。
1. 对于 **ObjectLambdaAccessPointName**，输入对象 Lambda 接入点的名称。
1. 对于 **S3BucketName**，输入将与对象 Lambda 接入点相关联的 Amazon S3 存储桶名称。
1. 对于 **SupportingAccessPointName**，输入支持接入点的名称。
**注意**
这是与您在上一步中选择的 Amazon S3 存储桶相关联的接入点。如果您没有任何与 Amazon S3 存储桶相关联的接入点，则可以配置模板，以通过为 **CreateNewSupportingAccessPoint** 选择 **true** 来为您创建一个此类接入点。
1. 选择 **Next**(下一步)。
1. 在**配置堆栈选项**页面上，请选择**下一步**。
有关此页面上的可选设置的更多信息，请参阅《AWS CloudFormation 用户指南》**中的[设置 AWS CloudFormation 堆栈选项](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-add-tags.html)。
1. 在 **Review**（查看）页面中，请选择 **Create stack**（创建堆栈）。
### 使用 AWS Cloud Development Kit (AWS CDK)
有关使用 AWS CDK 配置对象 Lambda 接入点的更多信息，请参阅《AWS Cloud Development Kit (AWS CDK) API 参考》**中的 [`AWS::S3ObjectLambda` 构造库](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-s3objectlambda-readme.html)。
# 使用 CloudFormation 模板自动进行 S3 对象 Lambda 设置
**注意**
自 2025 年 11 月 7 日起，S3 对象 Lambda 仅可供当前在使用该服务的现有客户以及部分 AWS 合作伙伴网络（APN）合作伙伴使用。要了解与 S3 对象 Lambda 类似的功能，请在此处了解更多信息：[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)。
您可以使用 AWS CloudFormation 模板快速创建 Amazon S3 对象 Lambda 接入点。CloudFormation 模板会自动创建相关资源、配置 AWS Identity and Access Management（IAM）角色并设置 AWS Lambda 函数，该函数可通过对象 Lambda 接入点自动处理请求。使用 CloudFormation 模板，您可以实施最佳实践、改善安全状况并减少手动流程导致的错误。
此 [GitHub 存储库](https://github.com/aws-samples/amazon-s3-object-lambda-default-configuration)包含 CloudFormation 模板和 Lambda 函数源代码。有关如何使用模板的说明，请参阅[创建对象 Lambda 接入点](olap-create.md)。
模板中提供的 Lambda 函数未运行任何转换。相反，它按原样从底层数据来源返回对象。您可以克隆函数并添加自己的转换代码，以便在数据返回到应用程序时修改和处理数据。有关修改函数的更多信息，请参阅[修改 Lambda 函数](#modifying-lambda-function)和[为 S3 对象 Lambda 接入点编写 Lambda 函数](olap-writing-lambda.md)。
## 修改模板。
**创建新的支持接入点**
S3 对象 Lambda 使用两个接入点，一个对象 Lambda 接入点和一个标准 S3 接入点（称为*支持接入点*）。当您向对象 Lambda 接入点发出请求时，S3 会代表您调用 Lambda，或将请求委派给支持接入点，具体取决于 S3 对象 Lambda 配置。在部署模板时，您可以通过将以下参数作为 `aws cloudformation deploy` 命令的一部分来创建一个新的支持接入点。
```
CreateNewSupportingAccessPoint=true
```
**配置函数有效负载**
在部署模板时，可以通过将以下参数作为 `aws cloudformation deploy` 命令的一部分传递，配置有效负载为 Lambda 函数提供补充数据。
```
LambdaFunctionPayload="format=json"
```
**启用 Amazon CloudWatch 监控**
您可以在部署模板时通过将以下参数作为 `aws cloudformation deploy` 命令的一部分来启用 CloudWatch 监视。
```
EnableCloudWatchMonitoring=true
```
此参数将为 Amazon S3 请求指标启用对象 Lambda 接入点，并创建两个 CloudWatch 告警来监控客户端和服务器端错误。
**注意**
Amazon CloudWatch 的使用将产生额外费用。有关 Amazon S3 请求指标的更多信息，请参阅[监控和记录接入点](access-points-monitoring-logging.md)。
有关定价详细信息，请参阅 [CloudWatch 定价](https://aws.amazon.com/cloudwatch/pricing/)。
**配置预配置并发**
要减少延迟，您可以通过编辑模板以在 `Resources` 之下包含以下各行，从而为支持对象 Lambda 接入点的 Lambda 函数配置预调配并发。
```
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 模板创建的对象 Lambda 接入点可以处理 `Range` 和 `partNumber` 参数。Lambda 函数将请求的范围或段编号应用于转换后的对象。为此，此函数必须下载整个对象并运行转换。在某些情况下，转换后的对象范围可能会精确映射到源对象范围。这意味着，在源对象上请求字节范围 A-B 并运行转换，可能会产生与请求整个对象、运行转换以及在转换后的对象上返回字节范围 A-B 相同的结果。
在这种情况下，您可以更改 Lambda 函数实现，以便将范围或段编号直接应用于源对象。这种方法减少了所需的总体函数延迟和内存。有关更多信息，请参阅 [使用 Range 和 partNumber 标头](range-get-olap.md)。
**禁用 `Range` 和 `partNumber` 处理**
默认情况下，由 CloudFormation 模板创建的对象 Lambda 接入点可以处理 `Range` 和 `partNumber` 参数。如果不需要此行为，可以通过从模板中移除以下各行来禁用它。
```
AllowedFeatures:
- GetObject-Range
- GetObject-PartNumber
- HeadObject-Range
- HeadObject-PartNumber
```
**转换大型对象**
默认情况下，Lambda 函数会处理内存中的整个对象，然后才能开始将响应流式传输到 S3 对象 Lambda。您可以在执行转换时修改函数以流式传输响应。这样做有助于减少转换延迟和 Lambda 函数内存大小。有关实施示例，请参阅 [Stream compressed content example](olap-writing-lambda.md#olap-getobject-response)（流式压缩内容示例）。
# 使用 Amazon S3 对象 Lambda 接入点
**注意**
自 2025 年 11 月 7 日起，S3 对象 Lambda 仅可供当前在使用该服务的现有客户以及部分 AWS 合作伙伴网络（APN）合作伙伴使用。要了解与 S3 对象 Lambda 类似的功能，请在此处了解更多信息：[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)。
通过 Amazon S3 对象 Lambda 接入点发出请求与通过其他接入点发出请求的工作方式相同。有关如何通过接入点发出请求的更多信息，请参阅 [使用通用存储桶的 Amazon S3 接入点](using-access-points.md)。您可以使用 Amazon S3 控制台、AWS Command Line Interface（AWS CLI）、AWS SDK 或 Amazon S3 REST API，通过对象 Lambda 接入点发出请求。
**重要**
对象 Lambda 接入点的 Amazon 资源名称（ARN）使用 `s3-object-lambda` 的服务名称。因此，对象 Lambda 接入点 ARN 以 `arn:aws::s3-object-lambda`（而不是 `arn:aws::s3`）开头，它与其他接入点结合使用。
## 如何查找对象 Lambda 接入点的 ARN
要将对象 Lambda 接入点与 AWS CLI 或 AWS SDK 结合使用，您需要知道对象 Lambda 接入点的 Amazon 资源名称（ARN）。以下示例说明如何通过使用 Amazon S3 控制台或 AWS CLI 查找对象 Lambda 接入点的 ARN。
### 使用 S3 控制台
**使用控制台查找对象 Lambda 接入点的 ARN**
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**对象 Lambda 接入点**。
1. 选择要复制其 ARN 的对象 Lambda 接入点旁边的选项按钮。
1. 请选择**复制 ARN**。
### 使用 AWS CLI
**使用 AWS CLI 查找对象 Lambda 接入点的 ARN**
1. 要检索与 AWS 账户 关联的对象 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 存储桶对象 Lambda 接入点使用存储桶式别名
当您创建对象 Lambda 接入点时，Amazon S3 会自动为您的对象 Lambda 接入点生成一个唯一的别名。您可以在接入点数据面板操作请求中使用此别名，而不使用 Amazon S3 存储桶名称或对象 Lambda 接入点 Amazon 资源名称（ARN）。有关这些操作的列表，请参阅[接入点兼容性](access-points-service-api-support.md)。
对象 Lambda 接入点别名是在与 Amazon S3 存储桶相同的命名空间中创建的。此别名自动生成，无法更改。对于现有对象 Lambda 接入点，会自动分配别名以供使用。对象 Lambda 接入点别名符合有效 Amazon S3 存储桶名称的所有要求，包括以下部分：
`Object Lambda Access Point name prefix-metadata--ol-s3`
**注意**
`--ol-s3` 后缀是为对象 Lambda 接入点别名预留的，不能用于存储桶或对象 Lambda 接入点名称。有关 Amazon S3 存储桶命名规则的更多信息，请参阅[通用存储桶命名规则](bucketnamingrules.md)。
以下示例显示了名为 `my-object-lambda-access-point` 的对象 Lambda 接入点的 ARN 和对象 Lambda 接入点别名。
+ **ARN** – `arn:aws:s3-object-lambda:region:account-id:accesspoint/my-object-lambda-access-point`
+ **对象 Lambda 接入点别名** – `my-object-lambda-acc-1a4n8yjrb3kda96f67zwrwiiuse1a--ol-s3`
当您使用对象 Lambda 接入点时，无需进行大量代码更改，即可使用对象 Lambda 接入点别名。
当您删除对象 Lambda 接入点时，对象 Lambda 接入点别名将变为非活动状态且未调配。
### 如何查找对象 Lambda 接入点的别名
#### 使用 S3 控制台
**使用控制台查找对象 Lambda 接入点的别名**
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**对象 Lambda 接入点**。
1. 对于要使用的对象 Lambda 接入点，复制**对象 Lambda 接入点别名**值。
#### 使用 AWS CLI
创建对象 Lambda 接入点时，Amazon S3 会自动生成对象 Lambda 接入点别名，如以下示例命令所示。要运行此命令，请将 `user input placeholders` 替换为您自己的信息。有关如何使用 AWS CLI 创建对象 Lambda 接入点的信息，请参阅[使用 AWS CLI 创建对象 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"
}
}
```
生成的对象 Lambda 接入点别名有两个字段：
+ `Value` 字段是对象 Lambda 接入点的别名值。
+ `Status` 字段是对象 Lambda 接入点别名的状态。如果状态为 `PROVISIONING`，则 Amazon S3 正在预调配对象 Lambda 接入点别名，并且该别名尚未准备就绪，无法使用。如果状态为 `READY`，则对象 Lambda 接入点别名已成功调配，并准备就绪可供使用。
有关 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)。
### 如何使用对象 Lambda 接入点别名
您可以使用对象 Lambda 接入点别名，而不是[接入点兼容性](access-points-service-api-support.md)中所列的操作的 Amazon S3 存储桶名称。
以下 `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"
}
```
如果请求中的对象 Lambda 接入点别名无效，则返回错误代码 `InvalidAccessPointAliasError`。有关 `InvalidAccessPointAliasError` 的更多信息，请参阅《Amazon Simple Storage Service API 参考》**中的[错误代码列表](https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#ErrorCodeList)。
对象 Lambda 接入点别名的限制与接入点别名的限制相同。有关接入点别名限制的更多信息，请参阅[接入点别名限制](access-points-naming.md#use-ap-alias-limitations)。
# S3 对象 Lambda 接入点的安全注意事项
**注意**
自 2025 年 11 月 7 日起，S3 对象 Lambda 仅可供当前在使用该服务的现有客户以及部分 AWS 合作伙伴网络（APN）合作伙伴使用。要了解与 S3 对象 Lambda 类似的功能，请在此处了解更多信息：[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)。
使用 Amazon S3 对象 Lambda，您可以借助使用 AWS Lambda 作为计算平台的规模和灵活性，在数据离开 Amazon 3 时对其执行自定义转换。S3 和 Lambda 在默认情况下保持安全，但是为了维持这种安全性，Lambda 函数的作者需要特别考虑一些注意事项。S3 对象 Lambda 要求所有访问都由经过身份验证的主体（无匿名访问）和 HTTPS 进行。
为降低安全风险，我们提出以下建议：
+ 将 Lambda 执行角色的范围限定为尽可能小的权限集。
+ 只要有可能，就确保您的 Lambda 函数通过提供的预签名 URL 访问 Amazon S3。
## 配置 IAM 策略
S3 接入点支持 AWS Identity and Access Management（IAM）资源策略，这些策略允许您按资源、用户或其他条件控制接入点的使用。有关更多信息，请参阅 [为对象 Lambda 接入点配置 IAM 策略](olap-policies.md)。
## 加密行为
由于对象 Lambda 接入点同时使用 Amazon S3 和 AWS Lambda，因此，加密行为会存在差异。有关默认 S3 加密行为的更多信息，请参阅[为 Amazon S3 存储桶设置默认服务器端加密行为](bucket-encryption.md)。
+ 将 S3 服务器端加密与对象 Lambda 接入点结合使用时，需要先将对象解密，然后再将其发送到 Lambda。将对象发送到 Lambda 后，将以未加密方式对其进行处理（如果是 `GET` 或 `HEAD` 请求）。
+ 为防止密钥被记录，S3 将拒绝针对以下对象的 `GET` 和 `HEAD` 请求：使用具有客户提供的密钥的服务器端加密（SSE-C）来加密的对象。但是，如果 Lambda 函数可以访问客户端提供的密钥，它仍可检索这些对象。
+ 将 S3 客户端加密与对象 Lambda 接入点结合使用时，请确保 Lambda 有权访问加密密钥，以便它可以解密和重新加密对象。
## 接入点安全性
S3 对象 Lambda 使用两个接入点，一个对象 Lambda 接入点和一个标准 S3 接入点（称为*支持接入点*）。当您向对象 Lambda 接入点发出请求时，S3 会代表您调用 Lambda，或将请求委派给支持接入点，具体取决于 S3 对象 Lambda 配置。当针对请求调用 Lambda 时，S3 将通过支持接入点，代表您向对象生成一个预签名 URL。您的 Lambda 函数将在调用此函数时接收此 URL 以作为输入。
您可以将 Lambda 函数设置为使用此预签名 URL 来检索原始对象，而不是直接调用 S3。通过使用此模型，您可以为对象应用更好的安全边界。您可以将通过 S3 存储桶或 S3 接入点进行的直接对象访问，限制为一组有限的 IAM 角色或用户。这种方法也可以防止您的 Lambda 函数受到[混淆代理问题](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html)的影响，发生混淆代理问题时，配置错误的函数具有与调用方不同的权限，可以允许或拒绝对于对象的访问（但原本不应如此）。
## 对象 Lambda 接入点公共访问权限
S3 对象 Lambda 不允许匿名访问和公有访问，因为 Amazon S3 必须向您的身份授权，才能完成任何 S3 对象 Lambda 请求。当通过对象 Lambda 接入点调用请求时，您必须对于已配置的 Lambda 函数拥有 `lambda:InvokeFunction` 权限。同样，当通过对象 Lambda 接入点调用其他 API 操作时，您必须拥有所需的 `s3:*` 权限。
如果不具有这些权限，则调用 Lambda 或委托给 S3 的请求将失败，并出现 HTTP 403 (Forbidden) [HTTP 403（禁止访问）] 错误。必须由经过身份验证的主体进行所有访问。如果您需要公有访问权限，可使用 Lambda@Edge 作为可能的替代方案。有关更多信息，请参阅 *Amazon CloudFront 开发人员指南*中的[使用 Lambda@Edge 在边缘进行自定义](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-at-the-edge.html)。
## 对象 Lambda 接入点 IP 地址
`describe-managed-prefix-lists` 子网支持网关虚拟私有云（VPC）端点，并与 VPC 端点的路由表相关。由于对象 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)。
# 为对象 Lambda 接入点配置 IAM 策略
**注意**
自 2025 年 11 月 7 日起，S3 对象 Lambda 仅可供当前在使用该服务的现有客户以及部分 AWS 合作伙伴网络（APN）合作伙伴使用。要了解与 S3 对象 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）资源策略，您可以使用这些策略按资源、用户或其他条件控制接入点的使用。您可以通过对象 Lambda 接入点上的可选资源策略或支持接入点上的资源策略来控制访问权限。有关分步示例，请参阅 [教程：使用 S3 对象 Lambda 转换应用程序的数据](tutorial-s3-object-lambda-uppercase.md) 和 [教程：使用 S3 对象 Lambda 和 Amazon Comprehend 检测和修订 PII 数据](tutorial-s3-object-lambda-redact-pii.md)。
以下四项资源必须已获得使用对象 Lambda 接入点的权限：
+ IAM 身份，例如用户或角色。有关 IAM 身份和最佳实践的更多信息，请参阅《IAM 用户指南》**中的 [IAM 身份（用户、用户组和角色）](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html)。
+ 连接到底层数据来源的标准接入点，例如 S3 存储桶或适用于 OpenZFS 的 Amazon FSx 卷。当您使用对象 Lambda 接入点时，此标准接入点称为*支持接入点*。
+ 对象 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`
+ 此存储桶上具有以下 ARN 的 Amazon S3 standard 接入点：
`arn:aws:s3:us-east-1:111122223333:accesspoint/my-access-point`
+ 具有以下 ARN 的对象 Lambda 接入点：
`arn:aws:s3-object-lambda:us-east-1:111122223333:accesspoint/my-object-lambda-ap`
+ 具有以下 ARN 的 AWS Lambda Lambda 函数：
`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 – 向用户授予使用对象 Lambda 接入点的必需权限的 IAM 策略**
以下 IAM 策略授予用户对 Lambda 函数、标准接入点和对象 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 执行角色的权限
当向对象 Lambda 接入点发出 `GET` 请求时，Lambda 函数需要将数据发送到 S3 对象 Lambda 接入点的权限。可通过对 Lambda 函数的执行角色启用 `s3-object-lambda:WriteGetObjectResponse` 权限来提供此权限。您可以创建新角色，或更新现有角色。
**注意**
仅当您发出 `GET` 请求时，函数才需要 `s3-object-lambda:WriteGetObjectResponse` 权限。
**在 IAM 控制台中创建执行角色**
1. 通过 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。
1. 在左侧导航窗格中，选择 **Roles（角色）**。
1. 选择 **Create role（创建角色）**。
1. 在 **Common use cases**（常用使用案例）下，请选择 **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. 选择 **Create role（创建角色）**。
1. 应用新创建的 **s3-object-lambda-role** 作为 Lambda 函数的执行角色。这可以在 Lambda 控制台中创建 Lambda 函数期间或之后完成。
有关执行角色的更多信息，请参阅 *AWS Lambda 开发人员指南*中的 [Lambda 执行角色](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html)。
## 将上下文键与对象 Lambda 接入点结合使用
S3 对象 Lambda 将评估与请求的连接或签名相关的上下文键，如 `s3-object-lambda:TlsVersion` 或 `s3-object-lambda:AuthType`。Amazon S3 评估所有其他上下文键，例如 `s3:prefix`。
## 对象 Lambda 接入点 CORS 支持
当 S3 对象 Lambda 收到来自浏览器的请求或包含 `Origin` 标头的请求时，S3 对象 Lambda 始终会添加 `"AllowedOrigins":"*"` 标头字段。
有关更多信息，请参阅 [使用跨源资源共享 (CORS)](cors.md)。
# 为 S3 对象 Lambda 接入点编写 Lambda 函数
**注意**
自 2025 年 11 月 7 日起，S3 对象 Lambda 仅可供当前在使用该服务的现有客户以及部分 AWS 合作伙伴网络（APN）合作伙伴使用。要了解与 S3 对象 Lambda 类似的功能，请在此处了解更多信息：[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)。
本节详细介绍如何编写与 Amazon S3 对象 Lambda 接入点结合使用的 AWS Lambda 函数。
要了解一些 S3 对象 Lambda 任务的完整端到端过程，请参阅以下内容：
+ [教程：使用 S3 对象 Lambda 转换应用程序的数据](tutorial-s3-object-lambda-uppercase.md)
+ [教程：使用 S3 对象 Lambda 和 Amazon Comprehend 检测和修订 PII 数据](tutorial-s3-object-lambda-redact-pii.md)
+ [教程：使用 S3 对象 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` 请求
本节假设您的对象 Lambda 接入点配置为对于 `GetObject` 调用 Lambda 函数。S3 对象 Lambda 包括 Amazon S3 API 操作 `WriteGetObjectResponse`，该操作可以让 Lambda 函数向 `GetObject` 调用方提供自定义数据和响应标头。
`WriteGetObjectResponse` 可根据您的处理需要，让您对状态代码、响应标头和响应正文进行广泛的控制。您可以使用 `WriteGetObjectResponse` 来响应整个变换对象、变换对象的某些部分或其他基于应用程序上下文的响应。以下部分介绍了使用 `WriteGetObjectResponse` API 操作的独特示例。
+ **示例 1：**使用 HTTP 状态代码 403（禁止访问）进行响应
+ **示例 2：** 通过转换后的图像进行响应
+ **示例 3：** 流式压缩内容
**示例 1：使用 HTTP 状态代码 403（禁止访问）进行响应**
您可以使用 `WriteGetObjectResponse` 根据对象的内容使用 HTTP 状态代码 403（禁止）进行响应。
------
#### [ 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` 请求会在一次调用中将整个对象返回给请求的应用程序。
------
#### [ 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 对象 Lambda 允许使用长达 60 秒的时间通过 `WriteGetObjectResponse` 请求来将完整响应发送给发起人，但实际可用时间可能会减少。例如，Lambda 函数超时可能少于 60 秒。在其他情况下，发起人可能会有更严格的超时。
要使原始调用方能够收到非 HTTP 状态代码 500（内部服务器错误）响应，必须完成 `WriteGetObjectResponse` 调用。如果 Lambda 函数返回时引发了异常或其他情况，则在调用 `WriteGetObjectResponse` API 操作之前，原始调用方将收到 500（内部服务器错误）响应。在完成响应所需的时间内引发的异常将导致截断对发起人的响应。如果 Lambda 函数从 `WriteGetObjectResponse` API 调用收到 HTTP 状态代码 200（OK）响应，即表示原始调用方已经发送了完整的请求。S3 对象 Lambda 会忽略 Lambda 函数的响应，无论是否抛出异常。
调用 `WriteGetObjectResponse` API 操作时，Amazon S3 需要事件上下文中的路由和请求令牌。有关更多信息，请参阅 [事件上下文格式和用法](olap-event-context.md)。
将 `WriteGetObjectResult` 请求与原始调用方连接起来需要这些路由和请求令牌参数。尽管重试 500（内部服务器错误）响应始终是适当的，但请注意，由于请求令牌是一个单一用途令牌，后续尝试使用它可能会导致 HTTP 状态代码 400（错误请求）响应。虽然使用路由和请求令牌调用 `WriteGetObjectResponse` 不需要从被调用的 Lambda 函数发出，但它必须由同一账户中的身份发出。还必须在 Lambda 函数完成执行之前完成调用。
## 在 Lambda 中处理 `HeadObject` 请求
本节假设您的对象 Lambda 接入点配置为对于 `HeadObject` 调用 Lambda 函数。Lambda 将收到一个 JSON 有效负载，其中包含名为 `headObjectContext` 的密钥。在上下文中，有一个名为 `inputS3Url` 的属性，它是 `HeadObject` 的支持接入点的预签名 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 函数应返回一个 JSON 对象，其中包含将针对 `HeadObject` 调用返回的标头和值。
下面的示例显示 `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` 请求
本节假设您的对象 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 函数应返回一个 JSON 对象，其中包含将从 S3 对象 Lambda 返回的状态码、列表 XML 结果或错误信息。
S3 对象 Lambda 不处理或验证 `listResultXml`，而是将其转发给 `ListObjects` 调用方。对于 `listBucketResult`，S3 对象 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` 请求
本节假设您的对象 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 函数应返回一个 JSON 对象，其中包含将从 S3 对象 Lambda 返回的状态码、列表 XML 结果或错误信息。
S3 对象 Lambda 不处理或验证 `listResultXml`，而是将其转发给 `ListObjectsV2` 调用方。对于 `listBucketResult`，S3 对象 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 对象 Lambda 仅可供当前在使用该服务的现有客户以及部分 AWS 合作伙伴网络（APN）合作伙伴使用。要了解与 S3 对象 Lambda 类似的功能，请在此处了解更多信息：[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)。
Amazon S3 对象 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 对象 Lambda 的输入和输出详细信息。
+ `inputS3Url` – 可用于从 Amazon S3 获取原始对象的预签名 URL。URL 是使用原始调用方的身份进行签名的，使用 URL 时该用户的权限将适用。如果 URL 中有签名标头，则 Lambda 函数必须将这些标头包含在对 Amazon S3 的调用中，`Host` 标头除外。
+ `outputRoute` – 在 Lambda 函数调用 `WriteGetObjectResponse` 时添加到 S3 对象 Lambda URL 的路由令牌。
+ `outputToken` – S3 对象 Lambda 使用的不透明令牌，用于将 `WriteGetObjectResponse` 调用与原始调用方相匹配。
+ `configuration` – 有关对象 Lambda 接入点的配置信息。
+ `accessPointArn` – 收到此请求的对象 Lambda 接入点的 Amazon 资源名称（ARN）。
+ `supportingAccessPointArn` – 在对象 Lambda 接入点配置中指定的支持接入点的 ARN。
+ `payload` – 应用于对象 Lambda 接入点配置的自定义数据。S3 对象 Lambda 将此数据视为不透明字符串，因此在使用前可能需要对其进行解码。
+ `userRequest` – 有关对 S3 对象 Lambda 的原始调用的信息。
+ `url` – S3 对象 Lambda 接收的请求的解码 URL，不包括任何与授权相关的查询参数。
+ `headers` – 字符串到字符串的映射，包含原始调用中的 HTTP 标头及其值，不包括任何与授权相关的标头。如果同一个标头多次出现，会将相同标头的每个实例中的值组合成一个以逗号分隔的列表。此映射中会保留原始标头的大小写。
+ `userIdentity` – 有关对 S3 对象 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` – 发出请求的 AWS 服务 的名称，例如 Amazon EC2 Auto Scaling 或 AWS Elastic Beanstalk。
+ `sessionIssuer` – 如果已使用临时安全证书发出请求，此元素提供有关证书获取方式的信息。
+ `protocolVersion` – 提供的上下文的版本 ID。此字段的格式为 `{Major Version}.{Minor Version}`。次要版本号始终是两位数字。对字段的语义进行任何删除或更改都将导致主要版本冲突，并且需要主动选择加入。Amazon S3 可以随时添加新字段，此时您可能会遇到次要版本冲突。由于软件部署的性质，您可能会同时看到多个次要版本处于使用状态。
# 使用 Range 和 partNumber 标头
**注意**
自 2025 年 11 月 7 日起，S3 对象 Lambda 仅可供当前在使用该服务的现有客户以及部分 AWS 合作伙伴网络（APN）合作伙伴使用。要了解与 S3 对象 Lambda 类似的功能，请在此处了解更多信息：[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)。
在 Amazon S3 对象 Lambda 中使用大型对象时，您可以使用 `Range` HTTP 标头从对象中下载指定的字节范围。要从相同对象中提取不同的字节范围，您可以使用到 Amazon S3 的并发连接。还可以指定 `partNumber` 参数（1 到 10000 之间的整数），它对于对象的指定分段执行范围内的请求。
由于您可能希望通过多种方法来处理包括 `Range` 或 `partNumber` 参数的请求，S3 对象 Lambda 不会将这些参数应用于转换后的对象。相反，您的 AWS Lambda 函数必须根据应用程序的需要实施此功能。
要对 S3 对象 Lambda 使用 `Range` 和 `partNumber` 参数，请执行以下操作：
+ 在对象 Lambda 接入点配置中启用这些参数。
+ 编写一个 Lambda 函数，以处理包含这些参数的请求。
以下步骤介绍了如何完成此操作。
## 步骤 1：配置对象 Lambda 接入点
默认情况下，对象 Lambda 接入点会对在标头或查询参数中包含 `Range` 或 `partNumber` 参数的任何 `GetObject` 或 `HeadObject` 请求响应 HTTP 状态代码 501（未实施）错误。
要使对象 Lambda 接入点能够接受此类请求，您必须在对象 Lambda 接入点配置的 `AllowedFeatures` 部分中加入 `GetObject-Range`、`GetObject-PartNumber`、`HeadObject-Range` 或 `HeadObject-PartNumber`。有关更新对象 Lambda 接入点配置的更多信息，请参阅[创建对象 Lambda 接入点](olap-create.md)。
## 步骤 2：在 Lambda 函数中实施 `Range` 或 `partNumber` 处理
当对象 Lambda 接入点使用范围内的 `GetObject` 或 `HeadObject` 请求调用 Lambda 函数时，`Range` 或 `partNumber` 参数将包含在事件上下文中。如下表所述，参数在事件上下文中的位置取决于使用的参数以及如何将其包含在对于对象 Lambda 接入点的原始请求中。
| 参数 | 事件上下文位置 |
| --- | --- |
| `Range`（标头） | `userRequest.headers.Range` |
| `Range`（查询参数） | `userRequest.url`（查询参数 `Range`） |
| `partNumber` | `userRequest.url`（查询参数 `partNumber`） |
**重要**
为对象 Lambda 接入点提供的预签名 URL 不包含原始请求中的 `Range` 或 `partNumber` 参数。请参阅以下选项，了解如何在 AWS Lambda 函数中处理这些参数。
在您提取 `Range` 或 `partNumber` 值后，您可以根据应用程序的需要采取以下方法之一：
1. **将请求的 `Range` 或 `partNumber` 映射到转换后的对象（建议）。**
处理 `Range` 或 `partNumber` 请求的最可靠方法是执行以下操作：
+ 从 Amazon S3 中检索完整的对象。
+ 转换对象。
+ 将请求的 `Range` 或 `partNumber` 参数应用于转换的对象。
为此，请使用提供的预签名 URL 从 Amazon S3 获取整个对象，然后根据需要处理该对象。对于 Lambda 函数以此方式处理 `Range` 函数的示例，请参阅 AWS Samples 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` 的对象的前三个字符。在转换前应用 `Range` 参数将仅检索 `abc`，然后反转数据，从而返回 `cba`。但是，如果在转换之后应用该参数，则函数将检索整个对象，将其反转，然后应用 `Range` 参数，以返回 `gfe`。由于这些结果不同，此函数在从 Amazon S3 中检索对象时不应应用 `Range` 参数。相反，它应该检索整个对象，执行转换，然后仅应用 `Range` 参数。
**警告**
在很多情况下，向预签名 URL 应用 `Range` 参数将导致 Lambda 函数或发出请求的客户端出现意外行为。除非您确定应用程序在从 Amazon S3 中仅检索部分对象时能够正常工作，否则我们建议您按照前面的方法 A 中所述检索和转换完整对象。
如果您的应用程序符合前面在方法 B 中介绍的条件，您可以简化您的 AWS Lambda 函数，方法是仅获取所请求的对象范围，然后在该范围内运行转换。
以下 Java 代码示例演示如何执行以下操作：
+ 从 `GetObject` 请求中检索 `Range` 标头。
+ 将 `Range` 标头添加到预签名 URL 中，Lambda 可以使用此标头从 Amazon S3 中检索请求的范围。
```
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 对象 Lambda 仅可供当前在使用该服务的现有客户以及部分 AWS 合作伙伴网络（APN）合作伙伴使用。要了解与 S3 对象 Lambda 类似的功能，请在此处了解更多信息：[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)。
AWS 提供了一些预构建的 AWS Lambda 函数，您可以将这些函数与 S3 对象 Lambda 结合使用，以检测和编辑个人身份信息（PII）以及解压缩 S3 对象。这些 Lambda 函数可在 AWS Serverless Application Repository 中使用。您可以在创建对象 Lambda 接入点时通过 AWS 管理控制台选择这些函数。
有关如何从 AWS Serverless Application Repository 部署无服务器应用程序的更多信息，请参阅《AWS Serverless Application Repository 开发人员指南》**中的[部署应用程序](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 函数，然后向对象 Lambda 接入点配置中添加此函数的 Amazon 资源名称（ARN）。
以下是此函数的示例 ARN：
```
arn:aws:serverlessrepo:us-east-1:111122223333:applications/ComprehendPiiAccessControlS3ObjectLambda
```
您可以使用以下 AWS Serverless Application Repository 链接在 AWS 管理控制台上添加或查看此函数：[ComprehendPiiAccessControlS3ObjectLambda](https://console.aws.amazon.com/lambda/home#/create/app?applicationId=arn:aws:serverlessrepo:us-east-1:839782855223:applications/ComprehendPiiAccessControlS3ObjectLambda)。
要在 GitHub 上查看此函数，请参阅 [Amazon Comprehend S3 对象 Lambda](https://github.com/aws-samples/amazon-comprehend-s3-object-lambdas)。
## 示例 2：PII 编辑
此 Lambda 函数使用 Amazon Comprehend，这是一项自然语言处理（NLP）服务，它使用机器学习发现文本中的见解和关系。此函数自动从 Amazon S3 存储桶的文档中编辑个人身份信息（PII），例如姓名、地址、日期、信用卡号和社会保障号码。
如果存储桶中具有包含信用卡号或银行账户信息等信息的文档，则可以将 PII Redction S3 对象 Lambda 函数配置为检测 PII，然后返回这些文档的副本，在这些文档中，已对 PII 实体类型进行了编辑。
要开始使用，请在您的账户中部署以下 Lambda 函数，然后向对象 Lambda 接入点配置中添加此函数的 ARN。
以下是此函数的示例 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 对象 Lambda](https://github.com/aws-samples/amazon-comprehend-s3-object-lambdas)。
要了解 PII 编辑中某些 S3 对象 Lambda 任务的完整端到端过程，请参阅[教程：使用 S3 对象 Lambda 和 Amazon Comprehend 检测和修订 PII 数据](tutorial-s3-object-lambda-redact-pii.md)。
## 示例 3：Decompression
Lambda 函数 `S3ObjectLambdaDecompression` 可以将存储在 Amazon S3 中的对象解压缩为六种压缩文件格式之一：`bzip2`、`gzip`、`snappy`、`zlib`、`zstandard` 和 `ZIP`。
要开始使用，请在您的账户中部署以下 Lambda 函数，然后向对象 Lambda 接入点配置中添加此函数的 ARN。
以下是此函数的示例 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 对象 Lambda 解压缩](https://github.com/aws-samples/amazon-s3-object-lambda-decompression)。
# S3 对象 Lambda 的最佳实践和指南
**注意**
自 2025 年 11 月 7 日起，S3 对象 Lambda 仅可供当前在使用该服务的现有客户以及部分 AWS 合作伙伴网络（APN）合作伙伴使用。要了解与 S3 对象 Lambda 类似的功能，请在此处了解更多信息：[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)。
使用 S3 对象 Lambda 时，请遵循以下最佳实践和指南来优化操作和性能。
**Topics**
+ [使用 S3 对象 Lambda](#olap-working-with)
+ [与 S3 对象 Lambda 结合使用的 AWS 服务](#olap-services)
+ [`Range` 和 `partNumber` 标头](#olap-managing-range-part)
+ [转换 `expiry-date`](#olap-console-download)
+ [使用 AWS CLI 和 AWS SDK](#olap-cli-sdk)
## 使用 S3 对象 Lambda
S3 对象 Lambda 仅支持处理 `GET`、`LIST` 和 `HEAD` 请求。任何其他请求都不会调用 AWS Lambda，而是返回标准的未转换 API 响应。每个 AWS 账户、每个区域最多可以创建 1000 个对象 Lambda 接入点。您使用的 AWS Lambda 函数必须与对象 Lambda 接入点位于同一 AWS 账户和区域中。
S3 对象 Lambda 允许使用长达 60 秒的时间将完整的响应流式传输到发起人。您的函数还受 AWS Lambda 默认限额的约束。有关更多信息，请参阅《AWS Lambda 开发人员指南》**中的 [Lambda 配额](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html)。
当 S3 对象 Lambda 调用您指定的 Lambda 函数时，您有责任确保指定的 Lambda 函数或应用程序从 Amazon S3 中覆盖或删除的任何数据都符合预期且正确。
您只能使用 S3 对象 Lambda 对于对象执行操作。您不能使用 S3 对象 Lambda 执行其他 Amazon S3 操作，例如修改或删除存储桶。有关支持接入点的 S3 操作的完整列表，请参阅[接入点与 S3 操作的兼容性](access-points-service-api-support.md#access-points-operations-support)。
除此列表之外，对象 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 对象 Lambda 结合使用的 AWS 服务
S3 对象 Lambda 可以连接 Amazon S3 和 AWS Lambda，也可以连接您选择的其他 AWS 服务，以交付与发出请求的应用程序相关的对象。与 S3 对象 Lambda 结合使用的所有 AWS 服务将继续受其各自服务水平协议（SLA）管控。例如，如有任何 AWS 服务不遵守其服务承诺，您将有资格获得该服务的 SLA 中介绍的服务积分。
## `Range` 和 `partNumber` 标头
使用大型对象时，您可以使用 `Range` HTTP 标头从对象中下载指定的字节范围。当您使用 `Range` 标头时，您的请求仅提取对象的指定部分。您还可以使用 `partNumber` 标头对于对象中的指定分段执行范围内的请求。
有关更多信息，请参阅 [使用 Range 和 partNumber 标头](range-get-olap.md)。
## 转换 `expiry-date`
您可以在 AWS 管理控制台上从对象 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`）和 适用于 Java 的 AWS SDK `TransferManager` 类与 S3 对象 Lambda 结合使用。
# S3 对象 Lambda 教程
**注意**
自 2025 年 11 月 7 日起，S3 对象 Lambda 仅可供当前在使用该服务的现有客户以及部分 AWS 合作伙伴网络（APN）合作伙伴使用。要了解与 S3 对象 Lambda 类似的功能，请在此处了解更多信息：[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)。
以下教程提供了一些 S3 对象 Lambda 任务的完整端到端过程。
采用 S3 对象 Lambda，可以添加自己的代码处理从 S3 检索的数据，然后再将其返回应用程序。以下每个教程都将在从 Amazon S3 检索出数据时对数据进行修改，而无需更改现有对象或维护数据的多个副本。第一个教程将演练如何向 S3 GET 请求添加 AWS Lambda 函数，来修改从 S3 中检索到的对象。第二个教程演示如何使用由 Amazon Comprehend 支持的预构建 Lambda 函数，在将从 S3 检索到的个人身份信息（PII）返回给应用程序之前为其提供保护。第三个教程使用 S3 对象 Lambda，在从 Amazon S3 检索到图像时为其添加水印。
+ [教程：使用 S3 对象 Lambda 转换应用程序的数据](tutorial-s3-object-lambda-uppercase.md)
+ [教程：使用 S3 对象 Lambda 和 Amazon Comprehend 检测和修订 PII 数据](tutorial-s3-object-lambda-redact-pii.md)
+ [教程：使用 S3 对象 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 对象 Lambda 转换应用程序的数据
**注意**
自 2025 年 11 月 7 日起，S3 对象 Lambda 仅可供当前在使用该服务的现有客户以及部分 AWS 合作伙伴网络（APN）合作伙伴使用。要了解与 S3 对象 Lambda 类似的功能，请在此处了解更多信息：[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)。
在 Amazon S3 中存储数据时，您可以轻松共享数据供多个应用程序使用。但是，每个应用程序可能具有独特的数据格式要求，可能需要针对特定用例修改或处理您的数据。例如，由电子商务应用程序创建的数据集可能包括个人识别信息（PII）。处理相同的数据以进行分析时，不需要此 PII，应该进行修订。但是，如果将同一数据集用于营销活动，可能需要使用其他详细信息来丰富数据，例如来自客户忠诚度数据库的信息。
采用 [S3 对象 Lambda](https://aws.amazon.com/s3/features/object-lambda)，可以添加自己的代码处理从 S3 检索的数据，然后再将其返回应用程序。具体来说，您可以配置 AWS Lambda 函数并将其附加到 S3 对象 Lambda 接入点。当应用程序通过 S3 对象 Lambda 接入点发送 [standard S3 GET requests](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) 时，将调用指定的 Lambda 函数，以处理通过 S3 支持接入点从底层数据来源检索到的任何数据。然后，S3 对象 Lambda 接入点将转换后的结果返回给应用程序。您可以创作和执行自己的自定义 Lambda 函数，根据您的特定用例定制 S3 对象 Lambda 数据转换，所有这些都不需要更改您的应用程序。
![\[这是 S3 对象 Lambda 工作流示意图。\]](http://docs.aws.amazon.com/zh_cn/AmazonS3/latest/userguide/images/ol-example-image-global.png)
**目标**
在本教程中，您将了解如何将自定义代码添加到标准 S3 GET 请求中，修改从 S3 检索到的请求对象，从而使该对象适合请求客户端或应用程序的需要。具体而言，您将了解如何通过 S3 对象 Lambda，将存储在 S3 存储桶中的原始对象中的所有文本转换为大写。
**注意**
本教程使用 Python 代码来转换数据，有关使用其它 AWS SDK 的示例，请参阅 AWS SDK 代码示例库中的 [Transform data for your application with 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：创建 S3 对象 Lambda 接入点](#ol-upper-step6)
+ [步骤 7：查看转换的数据](#ol-upper-step7)
+ [步骤 8：清除](#ol-upper-step8)
+ [后续步骤](#ol-upper-next-steps)
## 先决条件
在开始本教程之前，您必须具有 AWS 账户，您可使用具有正确权限的 AWS Identity and Access Management（IAM）用户登录此账户。您还必须安装 Python 3.8 或更高版本。
**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) - 授予对所有 Amazon S3 操作的权限，包括创建和使用对象 Lambda 接入点的权限。
+ [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)。最佳实践要求人类用户将联合身份验证与身份提供商结合使用，以使用临时凭证访问 AWS。另一项最佳实践是要求工作负载使用带有 IAM 角色的临时凭证访问 AWS。要了解如何使用 AWS IAM Identity Center 创建具有临时凭证的用户，请参阅《AWS IAM Identity Center 用户指南》**中的[入门](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 初学者指南》*中的[下载 Python](https://wiki.python.org/moin/BeginnersGuide/Download) 页面。
1. 打开本地终端或 shell 并运行以下命令以确定是否已安装 Python，如果已安装，确定已安装的版本。
```
python --version
```
1. 如果没有 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 或更高版本，则意味着 pi3 软件包管理器已成功安装。
```
pip --version
```
## 步骤 1：创建 S3 存储桶
创建存储桶来存储您计划转换的原始数据。
**注意**
可以为其它数据来源附加接入点，例如适用于 OpenZFS 的 Amazon FSx 卷，但本教程使用附加到 S3 存储桶的支持接入点。
**创建存储桶**
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**存储桶**。
1. 选择**创建存储桶**。
此时将打开**创建存储桶**页面。
1. 对于**存储桶名称**，输入您的存储桶名称（例如，**tutorial-bucket**）。
有关 Amazon S3 存储桶命名的更多信息，请参阅 [通用存储桶命名规则](bucketnamingrules.md)。
1. 对于**区域**，选择要放置存储桶的 AWS 区域。
有关存储桶区域的更多信息，请参阅 [通用存储桶概述](UsingBucket.md)。
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 对象 Lambda 接入点访问和转换原始数据，您必须创建一个 S3 接入点，并将其与您在[步骤 1](#ol-upper-step1) 中创建的 S3 存储桶关联。接入点必须与要变换的对象位于同一 AWS 区域 位置。
在本教程的后面部分，您将使用此接入点作为对象 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. 选择 **Create access point（创建接入点）**。
## 步骤 4：创建 Lambda 函数
要转换原始数据，请创建 Lambda 函数以与 S3 对象 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 流式传输对象，避免将整个对象加载到内存中。这种方法在处理大型对象时非常有用。有关使用对象 Lambda 接入点流式处理响应的详细信息，请参阅[在 Lambda 中处理 `GetObject` 请求](olap-writing-lambda.md#olap-getobject-response)中的流式处理示例。
编写 Lambda 函数以用于 S3 对象 Lambda 接入点时，该函数基于 S3 对象 Lambda 提供给 Lambda 函数的输入事件上下文。事件上下文提供有关在从 S3 对象 Lambda 传递到 Lambda 的事件中发出请求的信息。它包含用于创建 Lambda 函数的参数。
用于创建前面的 Lambda 函数的字段如下所示：
字段 `getObjectContext` 表示与 Amazon S3 和 S3 对象 Lambda连接的输入和输出详细信息。它具有以下字段：
+ `inputS3Url` - Lambda 函数可用于从支持接入点下载原始对象的预签名 URL。通过使用预签名 URL，Lambda 函数无需具有 Amazon S3 读取权限即可检索原始对象，只能访问每次调用处理的对象。
+ `outputRoute` - 当 Lambda 函数调用 `WriteGetObjectResponse` 以发回转换后的对象时，添加到 S3 对象 Lambda URL 的路由令牌。
+ `outputToken` - S3 对象 Lambda 在发送回转换对象时用于将 `WriteGetObjectResponse` 调用与原始调用方匹配的令牌。
有关事件上下文中所有字段的更多信息，请参阅 [事件上下文格式和用法](olap-event-context.md) 和 [为 S3 对象 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` 目录的根目录下，将已安装的库作为 `.zip` 文件（文件名为 `lambda.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. 选择 **Create function (创建函数)**。
1. 选择**从头开始创作**。
1. 在**基本信息**中，执行以下操作：
1. 对于 **Function name（函数名称）**，请输入 **tutorial-object-lambda-function**。
1. 适用于**运行时间**中，选择** Python 3.8 **或更高版本。
1. 展开**更改默认执行角色**部分。在**执行角色**中，选择**创建具有基本 Lambda 权限的新角色**。
在[步骤 5 ](#ol-upper-step5)中，在本教程的后面，您将** AmazonS3ObjectLambdaExecutionRolePolicy **附加到 Lambda 函数的执行角色上。
1. 对于其余设置，保留默认值。
1. 选择 **Create function（创建函数）**。
### 用 .zip 文件归档部署 Lambda 函数代码，并配置 Lambda 函数（控制台）
1. 在 AWS Lambda 控制台位于[ https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) 中，选择左侧导航窗格中的 **Functions**（函数）。
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 对象 Lambda 使用的 Lambda 函数的最大持续时间为 60 秒。定价基于配置的内存量和代码运行的时间量。
## 步骤 5：为 Lambda 函数的执行角色配置 IAM 策略
要使 Lambda 函数能够提供自定义的数据和响应标头 `GetObject` 调用者，Lambda 函数的执行角色必须具有 IAM 权限才能调用 `WriteGetObjectResponse` API。
**将 IAM 策略附加到 Lambda 函数角色**
1. 在 AWS Lambda 控制台位于 [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) 中，选择左侧导航窗格中的 **Functions**（函数）。
1. 选择您在[步骤 4](#ol-upper-step4) 中创建的函数（例如，**tutorial-object-lambda-function**）。
1. 在 Lambda 函数的详细信息页面上，选择**配置**选项卡，然后选择**Permissions（权限）**在左侧导航窗格中。
1. Unts**执行角色**中，选择 **Role name（角色名称）**。打开 IAM 控制台。
1. 在 IAM 控制台上对应于 Lambda 函数的执行角色的 **Summary**（摘要）页面上，选择 **Permissions**（权限）选项卡。然后，从 **Add Permissions**（添加权限）菜单中选择 **Attach policies**（附加策略）。
1. **在附加权限策略**页的搜索字段中输入 **AmazonS3ObjectLambdaExecutionRolePolicy** 策略的名称。选中 **AmazonS3ObjectLambdaExecutionRolePolicy** 政策名称旁边的复选框。
1. 选择**附加策略**。
## 步骤 6：创建 S3 对象 Lambda 接入点
S3 对象 Lambda 接入点提供了直接从 S3 GET 请求调用 Lambda 函数的灵活性，以便该函数可以处理从 S3 接入点检索的数据。创建和配置 S3 对象 Lambda 接入点时，必须指定 Lambda 函数以调用并提供 JSON 格式的事件上下文作为 Lambda 要使用的自定义参数。
**创建 S3 对象 Lambda 接入点**
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择 **Object Lambda 接入点**。
1. 在**对象 Lambda 接入点**页面上，选择**创建对象 Lambda 接入点**。
1. 对于**对象 Lambda 接入点名称**，输入想要用于对象 Lambda 接入点的名称（例如 **tutorial-object-lambda-accesspoint**）。
1. 适用于**支持接入点**中，输入或浏览到您在[步骤 3](#ol-upper-step3)（例如，**tutorial-access-point**），然后选择**选择支持的接入点**。
1. 对于 **S3 APIs**（S3 API），要从 S3 存储桶中检索对象以便 Lambda 函数进行处理，请选择 **GetObject**。
1. 对于**调用 Lambda 函数**，您可以为本教程选择以下两个选项之一。
+ 选择**从您的账户中的函数中选择**，然后在 **Lambda 函数**下拉列表中，选择您在[步骤 4](#ol-upper-step4) 中创建的 Lambda 函数（例如 **tutorial-object-lambda-function**）。
+ 选择**输入 ARN**，然后输入您在[步骤 4](#ol-upper-step4) 中创建的 Lambda 函数的 Amazon 资源名称（ARN）。
1. 适用于**Lambda 函数版本**，选择**\$1LATEST**（您在[步骤 4](#ol-upper-step4)中创建的最新版 Lambda 函数)。
1. （可选）如果您需要 Lambda 函数识别和处理带有范围和分段编号标头的 GET 请求，请选择 **Lambda 函数支持使用范围的请求**和 **Lambda 函数支持使用零件编号的请求**。否则，请清除这两个复选框。
有关如何将范围或分段编号与 S3 对象 Lambda 结合使用的更多信息，请参阅 [使用 Range 和 partNumber 标头](range-get-olap.md)。
1. （可选）在 **Payload（负载）- *可选***下，添加 JSON 文本，向 Lambda 函数提供其他信息。
负载是可选 JSON 文本，您可以将其作为来自特定 S3 对象 Lambda 接入点的所有调用的输入提供给 Lambda 函数。要自定义调用同一 Lambda 函数的多个对象 Lambda 接入点的行为，您可以使用不同的参数配置负载，从而扩展 Lambda 函数的灵活性。
更多有关路径模式的信息，请参阅 [事件上下文格式和用法](olap-event-context.md)。
1. （可选）对于**请求指标 – *可选***，选择**禁用**或**启用**，以便将 Amazon S3 监控添加到对象 Lambda 接入点。请求指标按标准 Amazon CloudWatch 费率计费。有关更多信息，请参阅 [CloudWatch 定价](https://aws.amazon.com/cloudwatch/pricing/)。
1. 在**对象 Lambda 接入点策略 - *可选***下，保留默认设置。
（可选）您可以设置资源策略。此资源策略授予 `GetObject` API 权限，以便使用指定的对象 Lambda 接入点。
1. 对于其余设置，保留默认值，然后选择**创建对象 Lambda 接入点**。
## 步骤 7：查看转换的数据
现在，S3 对象 Lambda 已准备好为您的使用案例转换您的数据。在本教程中，S3 对象 Lambda 将对象中的所有文本转换为大写。
**Topics**
+ [在 S3 对象 Lambda 接入点中查看转换后的数据](#ol-upper-step7-check-data)
+ [运行 Python 脚本以打印原始数据和转换数据](#ol-upper-step7-python-print)
### 在 S3 对象 Lambda 接入点中查看转换后的数据
当您请求通过 S3 对象 Lambda 接入点检索文件时，您需要对 S3 对象 Lambda 进行 `GetObject` API 调用。S3 对象 Lambda 调用 Lambda 函数来转换您的数据，然后返回转换后的数据作为对标准 S3 的响应 `GetObject` API 调用。
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**对象 Lambda 接入点**。
1. 在**对象 Lambda 接入点**页面上，选择您在[步骤 6](#ol-upper-step6) 中创建的 S3 对象 Lambda 接入点（例如，**tutorial-object-lambda-accesspoint**)。
1. 在 S3 对象 Lambda 接入点的**对象**选项卡中，选择具有相同名称的文件（例如 `tutorial.txt`）作为您在[步骤 2](#ol-upper-step2) 中上传到 S3 存储桶的文件。
此文件应包含所有转换的数据。
1. 要查看转换后的数据，请选择**打开**或者**下载**。
### 运行 Python 脚本以打印原始数据和转换数据
您可以将 S3 对象 Lambda 与现有应用程序结合使用。为此，请更新应用程序配置，以使用在[步骤 6](#ol-upper-step6) 中创建的新 S3 对象 Lambda 接入点 ARN 从 S3 检索数据。
以下示例 Python 脚本既打印来自 S3 存储桶的原始数据，也打印来自 S3 对象 Lambda 接入点的转换数据。
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**对象 Lambda 接入点**。
1. 在**对象 Lambda 接入点**页面上，选择在[步骤 6](#ol-upper-step6) 中创建的 S3 对象 Lambda 接入点左侧的单选按钮（例如，**tutorial-object-lambda-accesspoint**)。
1. 选择**复制 ARN**。
1. 保存 ARN 以供稍后使用。
1. 在本地计算机上编写 Python 脚本，以从 S3 存储桶中打印原始数据（例如，`tutorial.txt`）并从 S3 对象 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 对象 Lambda 创建静态网站，则删除您所分配的 AWS 资源，使其不再产生费用。
**Topics**
+ [删除对象 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 日志组](#ol-upper-step8-delete-cloudwatch)
+ [删除 S3 源存储桶中的原始文件](#ol-upper-step8-delete-file)
+ [删除 S3 源存储桶](#ol-upper-step8-delete-bucket)
+ [删除 IAM 用户](#ol-upper-step8-delete-user)
### 删除对象 Lambda 接入点
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**对象 Lambda 接入点**。
1. 在**对象 Lambda 接入点**页面上，选择在[步骤 6](#ol-upper-step6) 中创建的 S3 对象 Lambda 接入点左侧的单选按钮（例如，**tutorial-object-lambda-accesspoint**)。
1. 选择**删除**。
1. 通过在显示的文本字段中输入对象 Lambda 接入点的名称，确认要删除的对象 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 函数的详细信息页面上，选择**配置**选项卡，然后选择**Permissions（权限）**在左侧导航窗格中。
1. Unts**执行角色**中，选择 **Role name（角色名称）**。打开 IAM 控制台。
1. 在 Lambda 函数的执行角色 IAM 控制台的**摘要**页面上，选择**删除角色**。
1. 在 **Delete role**（删除角色）对话框中，选择 **Yes, delete**（是的，删除）。
### 删除 Lambda 函数
1. 在 AWS Lambda 控制台（位于 [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)）中，选择左侧导航窗格中的 **Functions**（函数）。
1. 选择您在[步骤4](#ol-upper-step4)中创建的函数名称左侧的复选框（例如，**tutorial-object-lambda-function**）。
1. 选择**操作**，然后选择**删除**。
1. 在**删除函数**对话框中，选择**删除**。
### 删除 CloudWatch 日志组
1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 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 对象 Lambda 的常见用例列表：
+ 屏蔽敏感数据以确保安全性和合规性。
有关更多信息，请参阅 [教程：使用 S3 对象 Lambda 和 Amazon Comprehend 检测和修订 PII 数据](tutorial-s3-object-lambda-redact-pii.md)。
+ 筛选某些数据行以提供特定信息。
+ 使用来自其他服务或数据库的信息增加数据。
+ 跨数据格式转换，例如将 XML 转换为 JSON 以实现应用程序兼容性。
+ 在下载文件时压缩或解压缩文件。
+ 调整图像大小和水印图像。
有关更多信息，请参阅[教程：使用 S3 对象 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 对象 Lambda 的更多信息，请参阅 [使用 S3 对象 Lambda 转换对象](transforming-objects.md)。
# 教程：使用 S3 对象 Lambda 和 Amazon Comprehend 检测和修订 PII 数据
**注意**
自 2025 年 11 月 7 日起，S3 对象 Lambda 仅可供当前在使用该服务的现有客户以及部分 AWS 合作伙伴网络（APN）合作伙伴使用。要了解与 S3 对象 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 对象 Lambda](https://aws.amazon.com/s3/features/object-lambda) 和预构建的 AWS Lambda 函数，您可以在将从 S3 检索 Amazon Comprehend 的 PII 数据返回到应用程序之前进行保护。具体来说，您可以使用预构建的 [Lambda 函数](https://aws.amazon.com/lambda/)作为编校函数，并将其附加到 S3 对象 Lambda 接入点。当应用程序（例如，分析应用程序）发送 [standard S3 GET requests](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) 时，这些通过 S3 对象 Lambda 接入点发出的请求将调用预构建的编校 Lambda 函数，以检测和编校通过 S3 支持接入点从底层数据来源检索到的 PII 数据。然后，S3 对象 Lambda 接入点将编校的结果返回到应用程序。
![\[这是 S3 对象 Lambda 工作流示意图。\]](http://docs.aws.amazon.com/zh_cn/AmazonS3/latest/userguide/images/ol-comprehend-image-global.png)
在此过程中，无论 PII 在文本中的存在方式如何（例如，数字或单词和数字的组合），预构建的 Lambda 函数均使用 [Amazon Comprehend](https://aws.amazon.com/comprehend/)，这是一种自然语言处理 (NLP) 服务，用于捕获 PII 表示方式的变化。Amazon Comprehend 甚至可以用文本中的上下文来了解 4 位数字是否是 PIN、社会保险号 (SSN) 的最后四个数字还是年份。Amazon Comprehend 处理 UTF-8 格式的任何文本文件，并可以大规模保护 PII，而不会影响准确性。有关更多信息，请参阅 *《Amazon Comprehend 开发人员指南》*中的[什么是 Amazon Comprehend？](https://docs.aws.amazon.com/comprehend/latest/dg/what-is.html)
**目标**
在本教程中，您将学习如何将 S3 对象 Lambda 与预构建的 Lambda 函数一起使用 `ComprehendPiiRedactionS3ObjectLambda`。此函数使用 Amazon Comprehend 来检测 PII 实体。然后，通过用星号替换这些实体来修订它们。通过修订 PII，您可以隐藏敏感数据，这有助于提高安全性和合规性。
您还可以了解在 [AWS Serverless Application Repository](https://aws.amazon.com/serverless/serverlessrepo/) 中如何使用和配置预构建的 AWS Lambda 函数与 S3 对象 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 对象 Lambda 接入点](#ol-pii-step5)
+ [步骤 6：使用 S3 对象 Lambda 接入点检索编校的文件](#ol-pii-step6)
+ [步骤 7：清除](#ol-pii-step7)
+ [后续步骤](#ol-pii-next-steps)
## 先决条件：创建具有权限的 IAM 用户
在开始本教程之前，您必须具有 AWS 账户，您可使用具有正确权限的 AWS Identity and Access Management 用户（IAM 用户）登录此账户。
您可以为此教程创建 IAM 用户。要完成本教程，您的 IAM 用户必须附加以下 IAM 策略才能访问相关 AWS 资源并执行特定操作。
**注意**
为简单起见，本教程创建并使用 IAM 用户。完成本教程后，请记住 [删除 IAM 用户](#ol-pii-step8-delete-user)。对于生产用途，我们建议您遵循《IAM 用户指南》**中的 [IAM 中的安全最佳实践](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html)。最佳实践要求人类用户将联合身份验证与身份提供商结合使用，以使用临时凭证访问 AWS。另一项最佳实践是要求工作负载使用带有 IAM 角色的临时凭证访问 AWS。要了解如何使用 AWS IAM Identity Center 创建具有临时凭证的用户，请参阅《AWS IAM Identity Center 用户指南》**中的[入门](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) - 授予对所有 Amazon S3 操作的权限，包括创建和使用对象 Lambda 接入点的权限。
+ [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. 在左侧导航窗格中，选择 **Policies（策略）**。
1. 选择**创建策略**。
1. 在**可视化编辑器**选项卡上，**服务**，选择**服务**。然后，选择 **Serverless Application Repository**。
1. 对于**操作**，在**手动操作**中，选择此教程中**所有 Serverless Application Repository 操作（serverlessrepo:\$1）**。
作为安全最佳实践，您应根据用例仅允许用户所需的操作和资源的权限。有关更多信息，请参阅 [《IAM 用户指南》](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html)中的 *IAM 安全最佳实践*。
1. 对于**资源**中，选择本教程中的**所有资源**。
作为最佳实践，您应仅为特定账户中的特定资源定义权限。您也可以使用条件键授予最低权限。有关更多信息，请参阅 *《IAM 用户指南》* 中的[授予最低权限](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege)。
1. 选择**下一步：标签**。
1. 选择**下一步：审核**。
1. 在**查看策略**页面上，为您正在创建的策略输入**名称**（例如 **tutorial-serverless-application-repository**）和**描述**（可选）。查看策略摘要以确保您授予了所需的权限，然后选择**创建策略**以保存新策略。
1. 在左侧导航窗格中，选择 **用户**。然后，为本教程选择 IAM 用户。
1. 在所选用户的**摘要**页面上，选择**权限**选项卡，然后选择**添加权限**。
1. 在 **Grant permissions (授予权限)** 下，选择 **Attach existing policies directly (直接挂载现有策略)**。
1. 选择刚创建的策略旁边的复选框（例如，**tutorial-serverless-application-repository**），然后选择**下一步：审查**。
1. 在**策略摘要**下，查看摘要确保附加了预期的策略。然后选择 **添加权限**。
## 步骤 1：创建 S3 存储桶
创建存储桶来存储您计划转换的原始数据。
**注意**
可以为其它数据来源附加接入点，例如适用于 OpenZFS 的 Amazon FSx 卷，但本教程使用附加到 S3 存储桶的支持接入点。
**创建存储桶**
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**存储桶**。
1. 选择**创建存储桶**。
此时将打开**创建存储桶**页面。
1. 对于**存储桶名称**，输入您的存储桶名称（例如，**tutorial-bucket**）。
有关 Amazon S3 存储桶命名的更多信息，请参阅 [通用存储桶命名规则](bucketnamingrules.md)。
1. 对于**区域**，选择要放置存储桶的 AWS 区域。
有关存储桶区域的更多信息，请参阅 [通用存储桶概述](UsingBucket.md)。
1. 对于**此存储桶的屏蔽公共访问权限设置**，保留默认值（**屏蔽*所有*公共访问权限**已启用）。
除非您需要为您的用例关闭一个或多个屏蔽公共访问权限设置，否则建议您将所有这些设置保持为启用状态。有关屏蔽公共访问权限的更多信息，请参阅 [阻止对您的 Amazon S3 存储的公有访问](access-control-block-public-access.md)。
1. 对于其余设置，保留默认值。
（可选）如果要为您的特定用例配置其他存储桶设置，请参阅 [创建通用存储桶](create-bucket-overview.md)。
1. 选择**创建存储桶**。
## 步骤 2：将文件上传到 S3 存储桶。
将包含各种类型的已知 PII 数据（如姓名、银行信息、电话号码和SSN）的文本文件作为原始数据上传到 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 对象 Lambda 接入点访问和转换原始数据，您必须创建一个 S3 接入点，并将其与您在[步骤 1](#ol-pii-step1) 中创建的 S3 存储桶关联。接入点必须与要转换的对象位于同一 AWS 区域中。
在本教程的后面部分，您将使用此接入点作为对象 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. 选择 **Create access point（创建接入点）**。
## 步骤 4：配置和部署预构建的 Lambda 函数
要编校 PII 数据，请配置和部署预构建的 AWS Lambda 函数 `ComprehendPiiRedactionS3ObjectLambda` 以便与 S3 对象 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. 对于其余设置，保留默认值。
（可选）如果要为特定用例配置其他设置，请参阅页面左侧的**自述文件**部分。
1. 选中 **I acknowledge that this app creates custom IAM roles (我确认此应用程序创建自定义 IAM 角色)** 旁边的复选框。
1. 选择**部署**。
1. 在新应用程序的页面上，在**资源**下，选择Lambda 函数的**逻辑 ID**，在 Lambda 函数页面上部署的 Lambda 函数。
## 步骤 5：创建 S3 对象 Lambda 接入点
S3 对象 Lambda 接入点提供了直接从 S3 GET 请求调用 Lambda 函数的灵活性，以便该函数可以编校从 S3 接入点检索的 PII 数据。创建和配置 S3 对象 Lambda 接入点时，必须指定要调用的编校 Lambda 函数，并以 JSON 格式提供事件上下文作为供 Lambda 使用的自定义参数。
事件上下文提供有关在从 S3 对象 Lambda 传递到 Lambda 的事件中发出请求的信息。有关事件上下文中所有字段的更多信息，请参阅 [事件上下文格式和用法](olap-event-context.md)。
**创建 S3 对象 Lambda 接入点**
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择 **Object Lambda 接入点**。
1. 在**对象 Lambda 接入点**页面上，选择**创建对象 Lambda 接入点**。
1. 对于**对象 Lambda 接入点名称**，输入想要用于对象 Lambda 接入点的名称（例如 **tutorial-pii-object-lambda-accesspoint**）。
1. 适用于**支持接入点**中，输入或浏览到您在[步骤 3](#ol-pii-step3)（例如，**tutorial-pii-access-point**），然后选择**选择支持的接入点**。
1. 对于 **S3 APIs**（S3 API），要从 S3 存储桶中检索对象以便 Lambda 函数进行处理，请选择 **GetObject**。
1. 对于**调用 Lambda 函数**，您可以为本教程选择以下两个选项之一。
+ 选择**从您的账户中的函数中选择**，并从 **Lambda 函数**下拉列表中选择您在[步骤 4](#ol-pii-step4) 中部署的 Lambda 函数（例如 **serverlessrepo-ComprehendPiiRedactionS3ObjectLambda**）。
+ 选择**输入 ARN**，然后输入您在[步骤 4](#ol-pii-step4) 中创建的 Lambda 函数的 Amazon 资源名称（ARN）。
1. 对于 **Lambda 函数版本**中，选择**\$1LATEST**（您在[步骤 4](#ol-pii-step4)中部署的最新版本 Lambda 函数)。
1. （可选）如果您需要 Lambda 函数识别和处理带有范围和分段编号标头的 GET 请求，选择 **Lambda 函数支持，使用范围的请求**和 **Lambda 函数支持带零件编号的请求**。否则，请清除这两个复选框。
有关如何将范围或分段编号与 S3 对象 Lambda 结合使用的更多信息，请参阅 [使用 Range 和 partNumber 标头](range-get-olap.md)。
1. （可选）在 **Payload（负载）- *可选***下，添加 JSON 文本，向 Lambda 函数提供其他信息。
负载是可选 JSON 文本，您可以将其作为来自特定 S3 对象 Lambda 接入点的所有调用的输入提供给 Lambda 函数。要自定义调用同一 Lambda 函数的多个对象 Lambda 接入点的行为，您可以使用不同的参数配置负载，从而扩展 Lambda 函数的灵活性。
更多有关路径模式的信息，请参阅 [事件上下文格式和用法](olap-event-context.md)。
1. （可选）对于**请求指标 – *可选***，选择**禁用**或**启用**，以便将 Amazon S3 监控添加到对象 Lambda 接入点。请求指标按标准 Amazon CloudWatch 费率计费。有关更多信息，请参阅 [CloudWatch 定价](https://aws.amazon.com/cloudwatch/pricing/)。
1. 在**对象 Lambda 接入点策略 - *可选***下，保留默认设置。
（可选）您可以设置资源策略。此资源策略授予 `GetObject` API 权限，以便使用指定的对象 Lambda 接入点。
1. 对于其余设置，保留默认值，选择**创建对象 Lambda 接入点**。
## 步骤 6：使用 S3 对象 Lambda 接入点检索编校的文件
现在，S3 对象 Lambda 已准备好从原始文件修订 PII 数据。
**使用 S3 对象 Lambda 接入点检索编校的文件**
当您请求通过 S3 对象 Lambda 接入点检索文件时，您需要对 S3 对象 Lambda 进行 `GetObject` API 调用。S3 对象 Lambda 调用 Lambda 函数来编辑 PII 数据，并将转换后的数据作为对标准 S3 `GetObject` API调用的响应返回。
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**对象 Lambda 接入点**。
1. 在**对象 Lambda 接入点**页面上，选择您在[步骤 5](#ol-pii-step5) 中创建的 S3 对象 Lambda 接入点（例如，**tutorial-pii-object-lambda-accesspoint**)。
1. 在 S3 对象 Lambda 接入点的**对象**选项卡中，选择具有相同名称的文件（例如 `tutorial.txt`）作为您在[步骤 2](#ol-pii-step2) 中上传到 S3 存储桶的文件。
此文件应包含所有转换的数据。
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 对象 Lambda 修订数据，请删除分配的 AWS 资源，以便不再累积费用。
**Topics**
+ [删除对象 Lambda 接入点](#ol-pii-step8-delete-olap)
+ [删除 S3 接入点](#ol-pii-step8-delete-ap)
+ [删除 Lambda 函数](#ol-pii-step8-delete-lambda-function)
+ [删除 CloudWatch 日志组](#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)
### 删除对象 Lambda 接入点
1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 在左侧导航窗格中，选择**对象 Lambda 接入点**。
1. 在**对象 Lambda 接入点**页面上，选择在[步骤 5](#ol-pii-step5) 中创建的 S3 对象 Lambda 接入点（例如，**tutorial-pii-object-lambda-accesspoint**）左侧的选项按钮。
1. 选择**删除**。
1. 通过在显示的文本字段中输入对象 Lambda 接入点的名称，确认要删除的对象 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 日志组
1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 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. 在**删除**对话框中，在文本输入字段中输入角色名称以确认删除。然后选择 **Delete**(删除)。
### 删除 IAM 用户的客户托管策略
1. 登录 AWS 管理控制台，然后通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。
1. 在左侧导航窗格中，选择 **Policies（策略）**。
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 对象 Lambda 接入点，并使用预构建的 Lambda 函数启用这些接入点，根据数据访问者的业务需要，将以不同方式配置这些函数，以编校特定类型的 PII。
每种类型的用户都代入一个 IAM 角色，且只能访问一个 S3 对象 Lambda 接入点（通过 IAM 策略进行托管）。然后，将为不同编校使用案例配置的每个 `ComprehendPiiRedactionS3ObjectLambda` Lambda 函数附加到不同的 S3 对象 Lambda 接入点。对于每个 S3 对象 Lambda 接入点，您可以拥有一个支持的 S3 接入点，以便从存储共享数据集的 S3 存储桶读取数据。
有关如何创建 S3 存储桶策略（仅允许用户通过 S3 接入点读取存储桶）的详细信息，请参阅 [配置使用接入点的 IAM 策略](access-points-policies.md)。
有关如何授予用户访问 Lambda 函数、S3 接入点和 S3 对象 Lambda 接入点的权限的更多信息，请参阅[为对象 Lambda 接入点配置 IAM 策略](olap-policies.md)。
+ 您可以构建自己的 Lambda 函数，并将 S3 对象 Lambda 与自定义的 Lambda 函数结合使用，满足您的特定数据需求。
例如，要探索各种数据值，您可以使用 S3 对象 Lambda 和自己的 Lambda 函数，该函数使用其他 [Amazon Comprehend 特征](https://aws.amazon.com/comprehend/features/)（例如实体识别、关键短语识别、情绪分析和文档分类）来处理数据。您也可以使用 S3 对象 Lambda 与 [Amazon Comprehend Medical](https://aws.amazon.com/comprehend/medical/)（符合 HIPAA 条件的 NLP 服务），用于以上下文感知的方式分析和提取数据。
有关如何使用 S3 对象 Lambda 和自己的 Lambda 函数转换数据的详细信息，请参阅 [教程：使用 S3 对象 Lambda 转换应用程序的数据](tutorial-s3-object-lambda-uppercase.md)。
# S3 对象 Lambda 调试和故障排除
**注意**
自 2025 年 11 月 7 日起，S3 对象 Lambda 仅可供当前在使用该服务的现有客户以及部分 AWS 合作伙伴网络（APN）合作伙伴使用。要了解与 S3 对象 Lambda 类似的功能，请在此处了解更多信息：[Amazon S3 Object Lambda availability change](https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazons3-ol-change.html)。
当 Lambda 函数调用或执行出现问题时，对 Amazon S3 对象 Lambda 接入点的请求可能会导致新的错误响应。这些错误的格式与标准 Amazon S3 错误的格式相同。有关 S3 对象 Lambda 错误的信息，请参阅 *Amazon Simple Storage Service API 参考*中的 [S3 对象 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)。
您可以在 Amazon CloudWatch 中为对象 Lambda 接入点启用请求指标。这些指标可帮助您监控接入点的运行性能。您可以在创建对象 Lambda 接入点期间或之后启用请求指标。有关更多信息，请参阅 [CloudWatch 中的 S3 对象 Lambda 请求指标](metrics-dimensions.md#olap-cloudwatch-metrics)。
要获取有关向对象 Lambda 接入点发出的请求的更精细的日志记录，您可以启用 AWS CloudTrail 数据事件。有关更多信息，请参阅 *AWS CloudTrail 用户指南*中的[记录数据事件以便跟踪](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html)。
有关 S3 对象 Lambda 教程，请参阅以下内容：
+ [教程：使用 S3 对象 Lambda 转换应用程序的数据](tutorial-s3-object-lambda-uppercase.md)
+ [教程：使用 S3 对象 Lambda 和 Amazon Comprehend 检测和修订 PII 数据](tutorial-s3-object-lambda-redact-pii.md)
+ [教程：使用 S3 对象 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)。