# 教程：使用 Amazon S3 触发器创建缩略图
在本教程中，您将创建并配置 Lambda 函数，用于调整添加到 Amazon Simple Storage Service（Amazon S3）存储桶的图像大小。当您向存储桶添加图像文件时，Amazon S3 会调用您的 Lambda 函数。然后，该函数会创建图像的缩略图版本，并将其输出到不同的 Amazon S3 存储桶。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_resources.png)
要完成本教程，请执行以下步骤：
1. 创建源和目标 Amazon S3 存储桶并上传示例图片。
1. 创建一个 Lambda 函数，用于调整图像大小并将缩略图输出到 Amazon S3 存储桶。
1. 配置一个 Lambda 触发器，该触发器将在对象上传到源存储桶时调用函数。
1. 若要测试您的函数，先使用虚拟事件，然后将图像上传到源存储桶。
完成这些步骤后，您将了解如何使用 Lambda 对添加到 Amazon S3 存储桶的对象执行文件处理任务。您可以使用 AWS Command Line Interface 或 AWS CLI (AWS 管理控制台) 完成此教程。
如果您相同通过更简单的示例来了解如何为 Lambda 配置 Amazon S3 触发器，则可以参阅[教程：使用 Amazon S3 触发器调用 Lambda 函数](https://docs.aws.amazon.com/lambda/latest/dg/with-s3-example.html)。
**Topics**
+ [先决条件](#with-s3-example-prereqs)
+ [创建两个 Amazon S3 存储桶](#with-s3-tutorial-prepare-create-buckets)
+ [将测试图片上传到源存储桶](#with-s3-tutorial-test-image)
+ [创建权限策略](#with-s3-tutorial-create-policy)
+ [创建执行角色](#with-s3-tutorial-create-execution-role)
+ [创建函数部署包](#with-s3-tutorial-create-function-package)
+ [创建 Lambda 函数](#with-s3-tutorial-create-function-createfunction)
+ [配置 Amazon S3 来调用函数](#with-s3-tutorial-configure-s3-trigger)
+ [使用虚拟事件测试 Lambda 函数](#with-s3-tutorial-dummy-test)
+ [使用 Amazon S3 触发器测试函数](#with-s3-tutorial-test-s3)
+ [清除资源](#s3-tutorial-cleanup)
## 先决条件
如果您想使用 AWS CLI 来完成教程，请安装[最新版本的 AWS Command Line Interface]()。
对于 Lambda 函数代码，您可以使用 Python 或 Node.js。为您要使用的语言安装语言支持工具和软件包管理器。
### 安装 AWS Command Line Interface
如果您尚未安装 AWS Command Line Interface，请按照[安装或更新最新版本的 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) 中的步骤进行安装。
本教程需要命令行终端或 Shell 来运行命令。在 Linux 和 macOS 中，可使用您首选的 Shell 和程序包管理器。
**注意**
在 Windows 中，操作系统的内置终端不支持您经常与 Lambda 一起使用的某些 Bash CLI 命令（例如 `zip`）。[安装 Windows Subsystem for Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10)，获取 Ubuntu 和 Bash 与 Windows 集成的版本。
## 创建两个 Amazon S3 存储桶
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps1.png)
先创建两个 Amazon S3 存储桶。第一个存储桶是您要向其上传图像的源存储桶。第二个存储桶是 Lambda 用来保存调用函数时调整大小后的缩略图。
------
#### [ AWS 管理控制台 ]
**创建 Amazon S3 存储桶（控制台）**
1. 打开 [Amazon S3 控制台](https://console.aws.amazon.com/s3)并选择**通用存储桶**页面。
1. 选择最接近您地理位置的 AWS 区域。您可以使用屏幕顶部的下拉列表更改区域。在本教程的后面部分，您必须在同个区域中创建 Lambda 函数。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/console_region_select.png)
1. 选择 **Create bucket**（创建存储桶）。
1. 在 **General configuration**（常规配置）下，执行以下操作：
1. 对于**存储桶类型**，确保选中**通用型**。
1. 对于**存储桶名称**，输入符合 Amazon S3 存储桶[命名规则](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html)的全局唯一名称。存储桶名称只能由小写字母、数字、句点（.）和连字符（-）组成。
1. 将所有其他选项设置为默认值并选择**创建存储桶**。
1. 重复步骤 1 到 5 以创建自己的目标存储桶。在**存储桶名称**中输入 `amzn-s3-demo-source-bucket-resized`，其中 `amzn-s3-demo-source-bucket` 是您刚刚创建的源存储桶的名称。
------
#### [ AWS CLI ]
**创建 Amazon S3 存储桶（AWS CLI）**
1. 运行以下 CLI 命令来创建自己的源存储桶。您为存储桶选择的名称必须具有全局唯一性，并遵守 Amazon S3 [存储桶命名规则](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html)。名称只能由小写字母、数字、句点（.）和连字符（-）组成。对于 `region` 和 `LocationConstraint`，请选择最接近您地理位置的 [AWS 区域](https://docs.aws.amazon.com/general/latest/gr/lambda-service.html)。
```
aws s3api create-bucket --bucket amzn-s3-demo-source-bucket --region us-east-1 \
--create-bucket-configuration LocationConstraint=us-east-1
```
在本教程的后面部分，您必须在与源存储桶相同的 AWS 区域 中创建 Lambda 函数，因此请记下您选择的区域。
1. 运行以下命令来创建自己的目标存储桶。对于存储桶名称，必须使用 `amzn-s3-demo-source-bucket-resized`，其中 `amzn-s3-demo-source-bucket` 是您在步骤 1 中创建的源存储桶名称。对于 `region` 和 `LocationConstraint`，请选择与用于创建源存储桶时相同的 AWS 区域。
```
aws s3api create-bucket --bucket amzn-s3-demo-source-bucket-resized --region us-east-1 \
--create-bucket-configuration LocationConstraint=us-east-1
```
------
## 将测试图片上传到源存储桶
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps2.png)
在本教程的后面部分，您将使用 AWS CLI 或 Lambda 控制台调用 Lambda 函数以对其进行测试。要确认函数是否正常运行，您的源存储桶需要包含测试图片。此图像可以是您选择的任何 JPG 或 PNG 文件。
------
#### [ AWS 管理控制台 ]
**将测试图片上传到源存储桶（控制台）**
1. 打开 Amazon S3 控制台的[存储桶](https://console.aws.amazon.com/s3/buckets)页面。
1. 选择您在上一步中创建的源存储桶。
1. 选择**上传**。
1. 选择**添加文件**，然后使用文件选择器选择要上传的对象。
1. 选择**打开**，然后选择**上传**。
------
#### [ AWS CLI ]
**将测试图片上传到源存储桶（AWS CLI）**
+ 在包含要上传的图像的目录中，运行以下 CLI 命令。将 `--bucket` 参数替换为源存储桶的名称。对于`--key` 和 `--body` 参数，请使用测试图像的文件名。
```
aws s3api put-object --bucket amzn-s3-demo-source-bucket --key HappyFace.jpg --body ./HappyFace.jpg
```
------
## 创建权限策略
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps3.png)
创建 Lambda 函数的第一步是创建权限策略。此策略为函数提供访问其他 AWS 资源所需的权限。在本教程中，此策略授予了 Lambda 对 Amazon S3 存储桶的读取和写入权限，并允许其写入 Amazon CloudWatch Logs。
------
#### [ AWS 管理控制台 ]
**创建策略（控制台）**
1. 打开 AWS Identity and Access Management IAM 控制台的 [Policies（策略）页面](https://console.aws.amazon.com/iamv2/home#policies)。
1. 选择**创建策略**。
1. 选择 **JSON** 选项卡，然后将以下自定义策略粘贴到 JSON 编辑器中。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:PutLogEvents",
"logs:CreateLogGroup",
"logs:CreateLogStream"
],
"Resource": "arn:aws:logs:*:*:*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::*/*"
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": "arn:aws:s3:::*/*"
}
]
}
```
1. 选择**下一步**。
1. 在**策略详细信息**下，为**策略名称**输入 `LambdaS3Policy`。
1. 选择**创建策略**。
------
#### [ AWS CLI ]
**创建策略（AWS CLI）**
1. 将下列 JSON 保存在名为 `policy.json` 的文件中。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:PutLogEvents",
"logs:CreateLogGroup",
"logs:CreateLogStream"
],
"Resource": "arn:aws:logs:*:*:*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::*/*"
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": "arn:aws:s3:::*/*"
}
]
}
```
1. 在保存 JSON 策略文档的目录中，运行以下 CLI 命令。
```
aws iam create-policy --policy-name LambdaS3Policy --policy-document file://policy.json
```
------
## 创建执行角色
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps4.png)
执行角色是一个 IAM 角色，用于向 Lambda 函数授予访问 AWS 服务 和资源的权限。要授予函数读取和写入 Amazon S3 存储桶的权限，您需要附加上一步中创建的权限策略。
------
#### [ AWS 管理控制台 ]
**创建执行角色并附加权限策略（控制台）**
1. 打开（IAM）控制台的[角色](https://console.aws.amazon.com/iamv2/home#roles)页面。
1. 选择**创建角色**。
1. 在**可信实体类型**中选择 **AWS 服务**，在**使用案例**中选择 **Lambda**。
1. 选择**下一步**。
1. 执行以下操作添加您在上一步中创建的权限策略：
1. 在策略搜索框中，输入 `LambdaS3Policy`。
1. 在搜索结果中，选中 `LambdaS3Policy` 的复选框。
1. 选择**下一步**。
1. 在**角色详细信息**下的**角色名称**中输入 `LambdaS3Role`。
1. 选择**创建角色**。
------
#### [ AWS CLI ]
**创建执行角色并附加权限策略（AWS CLI）**
1. 将下列 JSON 保存在名为 `trust-policy.json` 的文件中。此信任策略允许 Lambda 通过向服务主体 `lambda.amazonaws.com` 授予调用 AWS Security Token Service（AWS STS）`AssumeRole` 操作的权限来使用该角色的权限。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. 在保存 JSON 信任策略文档的目录中，运行以下 CLI 命令来创建执行角色。
```
aws iam create-role --role-name LambdaS3Role --assume-role-policy-document file://trust-policy.json
```
1. 要附加您在上一步中创建的权限策略，请运行以下 CLI 命令。将策略 ARN 中的 AWS 账户 号码替换为自己的账号。
```
aws iam attach-role-policy --role-name LambdaS3Role --policy-arn arn:aws:iam::123456789012:policy/LambdaS3Policy
```
------
## 创建函数部署包
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps5.png)
要创建函数，您需要创建包含函数代码和所有依赖项的*部署包*。对于此 `CreateThumbnail` 函数，您的函数代码使用单独的库来调整图像大小。按照所选语言的说明创建包含所需库的部署包。
------
#### [ Node.js ]
**创建部署包（Node.js）**
1. 为您的函数代码和依赖项创建一个名为 `lambda-s3` 的目录并导航到此目录。
```
mkdir lambda-s3
cd lambda-s3
```
1. 使用 `npm` 创建新的 Node.js 项目。要在交互式体验中接受提供的默认选项，请按 `Enter`。
```
npm init
```
1. 将以下函数代码保存在名为 `index.mjs` 的文件中。请务必将 `us-east-1` 替换您创建源存储桶和目标存储桶时所在的 AWS 区域。
```
// dependencies
import { S3Client, GetObjectCommand, PutObjectCommand } from '@aws-sdk/client-s3';
import { Readable } from 'stream';
import sharp from 'sharp';
import util from 'util';
// create S3 client
const s3 = new S3Client({region: 'us-east-1'});
// define the handler function
export const handler = async (event, context) => {
// Read options from the event parameter and get the source bucket
console.log("Reading options from event:\n", util.inspect(event, {depth: 5}));
const srcBucket = event.Records[0].s3.bucket.name;
// Object key may have spaces or unicode non-ASCII characters
const srcKey = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, " "));
const dstBucket = srcBucket + "-resized";
const dstKey = "resized-" + srcKey;
// Infer the image type from the file suffix
const typeMatch = srcKey.match(/\.([^.]*)$/);
if (!typeMatch) {
console.log("Could not determine the image type.");
return;
}
// Check that the image type is supported
const imageType = typeMatch[1].toLowerCase();
if (imageType != "jpg" && imageType != "png") {
console.log(`Unsupported image type: ${imageType}`);
return;
}
// Get the image from the source bucket. GetObjectCommand returns a stream.
try {
const params = {
Bucket: srcBucket,
Key: srcKey
};
var response = await s3.send(new GetObjectCommand(params));
var stream = response.Body;
// Convert stream to buffer to pass to sharp resize function.
if (stream instanceof Readable) {
var content_buffer = Buffer.concat(await stream.toArray());
} else {
throw new Error('Unknown object stream type');
}
} catch (error) {
console.log(error);
return;
}
// set thumbnail width. Resize will set the height automatically to maintain aspect ratio.
const width = 200;
// Use the sharp module to resize the image and save in a buffer.
try {
var output_buffer = await sharp(content_buffer).resize(width).toBuffer();
} catch (error) {
console.log(error);
return;
}
// Upload the thumbnail image to the destination bucket
try {
const destparams = {
Bucket: dstBucket,
Key: dstKey,
Body: output_buffer,
ContentType: "image"
};
const putResult = await s3.send(new PutObjectCommand(destparams));
} catch (error) {
console.log(error);
return;
}
console.log('Successfully resized ' + srcBucket + '/' + srcKey +
' and uploaded to ' + dstBucket + '/' + dstKey);
};
```
1. 在 `lambda-s3` 目录中，使用 npm 安装 sharp 库。请注意，最新版本的 sharp（0.33）与 Lambda 不兼容。安装版本 0.32.6 以完成本教程。
```
npm install sharp@0.32.6
```
npm `install` 命令会为模块创建 `node_modules` 目录。完成此步骤后，目录结构应如下所示：
```
lambda-s3
|- index.mjs
|- node_modules
| |- base64js
| |- bl
| |- buffer
...
|- package-lock.json
|- package.json
```
1. 创建一个包含函数代码和依赖项的部署包。在 MacOS 或 Linux 中，运行以下命令。
```
zip -r function.zip .
```
在 Windows 中，使用您首选的 ZIP 实用工具来创建 .zip 文件。确保您的 `index.mjs`、`package.json`、和 `package-lock.json` 文件以及您的 `node_modules` 目录都在.zip 文件的根目录中。
------
#### [ Python ]
**创建部署包（Python）**
1. 将代码示例保存为名为 `lambda_function.py` 的文件。
```
import boto3
import os
import sys
import uuid
from urllib.parse import unquote_plus
from PIL import Image
import PIL.Image
s3_client = boto3.client('s3')
def resize_image(image_path, resized_path):
with Image.open(image_path) as image:
image.thumbnail(tuple(x / 2 for x in image.size))
image.save(resized_path)
def lambda_handler(event, context):
for record in event['Records']:
bucket = record['s3']['bucket']['name']
key = unquote_plus(record['s3']['object']['key'])
tmpkey = key.replace('/', '')
download_path = '/tmp/{}{}'.format(uuid.uuid4(), tmpkey)
upload_path = '/tmp/resized-{}'.format(tmpkey)
s3_client.download_file(bucket, key, download_path)
resize_image(download_path, upload_path)
s3_client.upload_file(upload_path, '{}-resized'.format(bucket), 'resized-{}'.format(key))
```
1. 在创建 `lambda_function.py` 文件的同一目录中，创建一个名为 `package` 的新目录并安装 [Pillow（PIL）](https://pypi.org/project/Pillow/)库和 适用于 Python (Boto3) 的 AWS SDK。虽然 Lambda Python 运行时系统包含 Boto3 SDK 的一个版本，但建议您将所有函数的依赖项添加到部署包中，即使这些依赖项已经包含在了运行时系统中。有关更多信息，请参阅 [Python 中的运行时系统依赖项](https://docs.aws.amazon.com/lambda/latest/dg/python-package.html#python-package-dependencies)。
```
mkdir package
pip install \
--platform manylinux2014_x86_64 \
--target=package \
--implementation cp \
--python-version 3.12 \
--only-binary=:all: --upgrade \
pillow boto3
```
Pillow 库包含 C/C\$1\$1 代码。通过使用 `--platform manylinux_2014_x86_64` 和 `--only-binary=:all:` 选项，pip 将下载并安装包含与 Amazon Linux 2 操作系统兼容的预编译二进制文件的 Pillow 版本。这可以确保无论本地构建计算机的操作系统和架构如何，部署包都能在 Lambda 执行环境中正常发挥作用。
1. 创建包含应用程序代码和 Pillow 以及 Boto3 库的 zip 文件。在 Linux 或 MacOS 中，从命令行界面运行以下命令。
```
cd package
zip -r ../lambda_function.zip .
cd ..
zip lambda_function.zip lambda_function.py
```
在 Windows 中，使用您首选的压缩工具来创建 `lambda_function.zip` 文件。确保您的 `lambda_function.py` 文件和包含依赖项的文件夹都位于.zip 文件的根目录下。
您也可以使用 Python 虚拟环境创建部署包。请参阅 [将 .zip 文件归档用于 Python Lambda 函数](python-package.md)。
------
## 创建 Lambda 函数
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps6.png)
您也可以使用 AWS CLI 或 Lambda 控制台创建 Lambda 函数。按照所选语言的说明创建函数。
------
#### [ AWS 管理控制台 ]
**创建函数（控制台）**
要使用控制台创建 Lambda 函数，首先要创建包含一些“Hello world”代码的基本函数。然后，通过上传在上一步中创建的 .zip 或 JAR 文件，将此代码替换为自己的函数代码。
1. 打开 Lamba 控制台的[函数](https://console.aws.amazon.com/lambda/home#/functions)页面。
1. 确保您在创建 Amazon S3 存储桶所在的同一 AWS 区域 内操作。您可以使用屏幕顶部的下拉列表更改区域。
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/console_region_select.png)
1. 选择**创建函数**。
1. 选择**从头开始创作**。
1. 在**基本信息**中，执行以下操作：
1. 对于 **Function name（函数名称）**，请输入 `CreateThumbnail`。
1. 对于**运行时**，根据您为函数选择的语言，选择 **Node.js 22.x** 或 **Python 3.12**。
1. 对于**架构**，选择 **x86\$164**。
1. 在**更改默认执行角色**选项卡中，执行以下操作：
1. 展开选项卡，然后选择**使用现有角色**。
1. 选择您之前创建的 `LambdaS3Role`。
1. 选择**创建函数**。
**上传函数代码（控制台）**
1. 在**代码源**窗格中，选择**上传自**。
1. 选择 **.zip 文件**。
1. 选择**上传**。
1. 在文件选择器中，选择 .zip 文件，然后选择**打开**。
1. 选择**保存**。
------
#### [ AWS CLI ]
**创建函数（AWS CLI）**
+ 运行您所选语言的 CLI 命令。对于 `role` 参数，确保将 `123456789012` 替换为自己的 AWS 账户 ID。对于 `region` 参数，将 `us-east-1` 替换为在其中创建 Amazon S3 存储桶的区域。
+ 对于 **Node.js**，从包含 `function.zip` 文件的目录中运行以下命令。
```
aws lambda create-function --function-name CreateThumbnail \
--zip-file fileb://function.zip --handler index.handler --runtime nodejs24.x \
--timeout 10 --memory-size 1024 \
--role arn:aws:iam::123456789012:role/LambdaS3Role --region us-east-1
```
+ 对于 **Python**，从包含 `lambda_function.zip` 文件的目录中运行以下命令。
```
aws lambda create-function --function-name CreateThumbnail \
--zip-file fileb://lambda_function.zip --handler lambda_function.lambda_handler \
--runtime python3.14 --timeout 10 --memory-size 1024 \
--role arn:aws:iam::123456789012:role/LambdaS3Role --region us-east-1
```
------
## 配置 Amazon S3 来调用函数
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps7.png)
要在将图像上传到源存储桶时运行 Lambda 函数，您需要为函数配置触发器。您可以使用控制台或 AWS CLI 配置 Amazon S3 触发器。
**重要**
此程序将 Amazon S3 存储桶配置为每次在此存储桶中创建对象时调用您的函数。请确保仅在源存储桶上配置。如果您的 Lambda 函数在调用此函数的同一个存储桶中创建对象，则可以[在循环中持续调用](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/recursive-runaway)您的函数。这可能会导致您的 AWS 账户 产生额外费用。
------
#### [ AWS 管理控制台 ]
**配置 Amazon S3 触发器（控制台）**
1. 打开 Lambda 控制台的[函数页面](https://console.aws.amazon.com/lambda/home#/functions)，然后选择函数 (`CreateThumbnail`)。
1. 选择**添加触发器**。
1. 选择 **S3**。
1. 在**存储桶**下，选择自己的源存储桶。
1. 在**事件类型**下，选择**所有对象创建事件**。
1. 在**递归调用**下，选中复选框以确认知晓不建议使用相同的 Amazon S3 存储桶用于输入和输出。您可以阅读 Serverless Land 中的 [Recursive patterns that cause run-away Lambda functions](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/recursive-runaway)，进一步了解 Lambda 中的递归调用模式。
1. 选择**添加**。
在您使用 Lambda 控制台创建触发器时，Lambda 会自动创建[基于资源的策略](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html)，授予您选择的服务调用函数的权限。
------
#### [ AWS CLI ]
**配置 Amazon S3 触发器（AWS CLI）**
1. 要让 Amazon S3 源存储桶在添加图像文件时调用函数，您首先需要使用[基于资源的策略](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html)为函数配置权限。基于资源的策略声明授予其他 AWS 服务 调用您函数的权限。要授予 Amazon S3 调用函数的权限，请运行以下 CLI 命令。请务必将 `source-account` 参数替换为您的 AWS 账户 ID 并使用自己的源存储桶名称。
```
aws lambda add-permission --function-name CreateThumbnail \
--principal s3.amazonaws.com --statement-id s3invoke --action "lambda:InvokeFunction" \
--source-arn arn:aws:s3:::amzn-s3-demo-source-bucket \
--source-account 123456789012
```
您使用此命令定义的策略允许 Amazon S3 仅在源存储桶上执行操作时调用函数。
**注意**
虽然 Amazon S3 存储桶名称具有全局唯一性，但在使用基于资源的策略时，最佳做法是指定存储桶必须属于您的账户。这是因为，如果删除一个存储桶，则另一个 AWS 账户 账户可能会创建具有相同 Amazon 资源名称（ARN）的存储桶。
1. 将下列 JSON 保存在名为 `notification.json` 的文件中。在应用到您的源存储桶时，此 JSON 会将存储桶配置为在每次添加新对象时向 Lambda 函数发送通知。将 Lambda 函数 ARN 中的 AWS 账户 号码和 AWS 区域 替换为您自己的账号和区域。
```
{
"LambdaFunctionConfigurations": [
{
"Id": "CreateThumbnailEventConfiguration",
"LambdaFunctionArn": "arn:aws:lambda:us-east-1:123456789012:function:CreateThumbnail",
"Events": [ "s3:ObjectCreated:Put" ]
}
]
}
```
1. 运行以下 CLI 命令，将您创建的 JSON 文件中的通知设置应用到源存储桶。将 `amzn-s3-demo-source-bucket` 替换为源存储桶的名称。
```
aws s3api put-bucket-notification-configuration --bucket amzn-s3-demo-source-bucket \
--notification-configuration file://notification.json
```
要了解有关 `put-bucket-notification-configuration` 命令和 `notification-configuration` 选项的更多信息，请参阅 *AWS CLI 命令参考*中的 [put-bucket-notification-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-bucket-notification-configuration.html)。
------
## 使用虚拟事件测试 Lambda 函数
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps8.png)
在通过向 Amazon S3 源存储桶添加图像文件来测试整个设置之前，您可以通过使用虚拟事件调用 Lambda 函数来测试此函数是否正常运行。Lambda 中的事件是 JSON 格式的文档，其中包含要处理的函数数据。Amazon S3 调用您的函数时，发送到函数的事件包含存储桶名称、存储桶 ARN 和对象键等信息。
------
#### [ AWS 管理控制台 ]
**使用虚拟事件测试 Lambda 函数（控制台）**
1. 打开 Lambda 控制台的[函数页面](https://console.aws.amazon.com/lambda/home#/functions)，然后选择函数 (`CreateThumbnail`)。
1. 选择**测试**选项卡。
1. 要创建测试事件，在**测试事件**窗格中，执行以下操作：
1. 在**测试事件操作**下，选择**创建新事件**。
1. 对于**事件名称**，输入 **myTestEvent**。
1. 在**模板**中，选择 **S3 Put**。
1. 将以下参数的值替换为您自己的值。
+ 对于 `awsRegion`，将 `us-east-1` 替换为在其中创建 Amazon S3 存储桶的 AWS 区域。
+ 对于 `name`，将 `amzn-s3-demo-bucket` 替换为您自己的 Amazon S3 源存储桶的名称。
+ 对于 `key`，将 `test%2Fkey` 替换为您在步骤 [将测试图片上传到源存储桶](#with-s3-tutorial-test-image) 中上传到源存储桶的测试对象的文件名。
```
{
"Records": [
{
"eventVersion": "2.0",
"eventSource": "aws:s3",
"awsRegion": "us-east-1",
"eventTime": "1970-01-01T00:00:00.000Z",
"eventName": "ObjectCreated:Put",
"userIdentity": {
"principalId": "EXAMPLE"
},
"requestParameters": {
"sourceIPAddress": "127.0.0.1"
},
"responseElements": {
"x-amz-request-id": "EXAMPLE123456789",
"x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH"
},
"s3": {
"s3SchemaVersion": "1.0",
"configurationId": "testConfigRule",
"bucket": {
"name": "amzn-s3-demo-bucket",
"ownerIdentity": {
"principalId": "EXAMPLE"
},
"arn": "arn:aws:s3:::amzn-s3-demo-bucket"
},
"object": {
"key": "test%2Fkey",
"size": 1024,
"eTag": "0123456789abcdef0123456789abcdef",
"sequencer": "0A1B2C3D4E5F678901"
}
}
}
]
}
```
1. 选择**保存**。
1. 在**测试事件**窗格中，选择**测试**。
1. 要检查您的函数是否已创建图像的调整大小版本并将其存储在目标 Amazon S3 存储桶中，请执行以下操作：
1. 打开 Amazon S3 控制台的[存储桶页面](https://console.aws.amazon.com/s3/buckets)。
1. 选择目标存储桶并确认调整大小的文件已在**对象**窗格中列出。
------
#### [ AWS CLI ]
**使用虚拟事件测试 Lambda 函数（AWS CLI）**
1. 将下列 JSON 保存在名为 `dummyS3Event.json` 的文件中。将以下参数的值替换为您自己的值：
+ 对于 `awsRegion`，将 `us-east-1` 替换为在其中创建 Amazon S3 存储桶的 AWS 区域。
+ 对于 `name`，将 `amzn-s3-demo-bucket` 替换为您自己的 Amazon S3 源存储桶的名称。
+ 对于 `key`，将 `test%2Fkey` 替换为您在步骤 [将测试图片上传到源存储桶](#with-s3-tutorial-test-image) 中上传到源存储桶的测试对象的文件名。
```
{
"Records": [
{
"eventVersion": "2.0",
"eventSource": "aws:s3",
"awsRegion": "us-east-1",
"eventTime": "1970-01-01T00:00:00.000Z",
"eventName": "ObjectCreated:Put",
"userIdentity": {
"principalId": "EXAMPLE"
},
"requestParameters": {
"sourceIPAddress": "127.0.0.1"
},
"responseElements": {
"x-amz-request-id": "EXAMPLE123456789",
"x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH"
},
"s3": {
"s3SchemaVersion": "1.0",
"configurationId": "testConfigRule",
"bucket": {
"name": "amzn-s3-demo-bucket",
"ownerIdentity": {
"principalId": "EXAMPLE"
},
"arn": "arn:aws:s3:::amzn-s3-demo-bucket"
},
"object": {
"key": "test%2Fkey",
"size": 1024,
"eTag": "0123456789abcdef0123456789abcdef",
"sequencer": "0A1B2C3D4E5F678901"
}
}
}
]
}
```
1. 在保存 `dummyS3Event.json` 文件的目录中，运行以下 CLI 命令来调用函数。此命令通过指定 `RequestResponse` 作为调用类型参数的值来同步调用 Lambda 函数。要了解有关同步和异步调用的更多信息，请参阅[调用 Lambda 函数](https://docs.aws.amazon.com/lambda/latest/dg/lambda-invocation.html)。
```
aws lambda invoke --function-name CreateThumbnail \
--invocation-type RequestResponse --cli-binary-format raw-in-base64-out \
--payload file://dummyS3Event.json outputfile.txt
```
如果您使用的是 AWS CLI 版本 2，则 cli-binary-format 选项必填。要将其设为默认设置，请运行 `aws configure set cli-binary-format raw-in-base64-out`。有关更多信息，请参阅[AWS CLI 支持的全局命令行选项](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list)。
1. 验证您的函数是否已创建图像的缩略图版本并已保存到目标 Amazon S3 存储桶中。运行以下 CLI 命令，将 `amzn-s3-demo-source-bucket-resized` 替换为自己的目标存储桶的名称。
```
aws s3api list-objects-v2 --bucket amzn-s3-demo-source-bucket-resized
```
您应该可以看到类似于如下所示的输出内容。`Key` 参数显示调整大小后的图像文件的文件名。
```
{
"Contents": [
{
"Key": "resized-HappyFace.jpg",
"LastModified": "2023-06-06T21:40:07+00:00",
"ETag": "\"d8ca652ffe83ba6b721ffc20d9d7174a\"",
"Size": 2633,
"StorageClass": "STANDARD"
}
]
}
```
------
## 使用 Amazon S3 触发器测试函数
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-tutorial/s3thumb_tut_steps9.png)
此时，您已确认 Lambda 函数运行正常，您可以通过向 Amazon S3 源存储桶添加图像文件来测试完整设置。将图像添加到源存储桶时，应自动调用 Lambda 函数。函数会创建文件已调整大小的版本并将其存储在目标存储桶中。
------
#### [ AWS 管理控制台 ]
**使用 Amazon S3 触发器测试 Lambda 函数（控制台）**
1. 要将图像上传到 Amazon S3 存储桶，请执行以下操作：
1. 打开 Amazon S3 控制台的[存储桶](https://console.aws.amazon.com/s3/buckets)页面，然后选择您的源存储桶。
1. 选择**上传**。
1. 选择**添加文件**，然后使用文件选择器选择要上传的图像文件。您的图像对象可以是任何.jpg 或.png 文件。
1. 选择**打开**，然后选择**上传**。
1. 执行以下操作，验证 Lambda 是否已将调整大小后的图像文件保存在目标存储桶中：
1. 导航回 Amazon S3 控制台的[存储桶](https://console.aws.amazon.com/s3/buckets)页面，然后选择您的目标存储桶。
1. 在**对象**窗格中，您现在应该能看到两个已调整大小的图像文件，其中一个来自 Lambda 函数的每次测试。要下载已调整大小的图像，请选择所需文件，然后选择**下载**。
------
#### [ AWS CLI ]
**使用 Amazon S3 触发器测试 Lambda 函数（AWS CLI）**
1. 在包含要上传的图像的目录中，运行以下 CLI 命令。将 `--bucket` 参数替换为源存储桶的名称。对于`--key` 和 `--body` 参数，请使用测试图像的文件名。您的测试图像可以是任何.jpg 或.png 文件。
```
aws s3api put-object --bucket amzn-s3-demo-source-bucket --key SmileyFace.jpg --body ./SmileyFace.jpg
```
1. 验证您的函数是否已创建图像的缩略图版本并已保存到目标 Amazon S3 存储桶中。运行以下 CLI 命令，将 `amzn-s3-demo-source-bucket-resized` 替换为自己的目标存储桶的名称。
```
aws s3api list-objects-v2 --bucket amzn-s3-demo-source-bucket-resized
```
如果函数成功运行，您将看到类似于以下内容的输出。您的目标存储桶现在应该包含两个已调整大小的文件。
```
{
"Contents": [
{
"Key": "resized-HappyFace.jpg",
"LastModified": "2023-06-07T00:15:50+00:00",
"ETag": "\"7781a43e765a8301713f533d70968a1e\"",
"Size": 2763,
"StorageClass": "STANDARD"
},
{
"Key": "resized-SmileyFace.jpg",
"LastModified": "2023-06-07T00:13:18+00:00",
"ETag": "\"ca536e5a1b9e32b22cd549e18792cdbc\"",
"Size": 1245,
"StorageClass": "STANDARD"
}
]
}
```
------
## 清除资源
除非您想要保留为本教程创建的资源，否则可立即将其删除。通过删除您不再使用的 AWS 资源，可防止您的 AWS 账户 产生不必要的费用。
**删除 Lambda 函数**
1. 打开 Lamba 控制台的 [Functions（函数）页面](https://console.aws.amazon.com/lambda/home#/functions)。
1. 选择您创建的函数。
1. 依次选择**操作**和**删除**。
1. 在文本输入字段中键入 **confirm**，然后选择 **Delete**（删除）。
**删除您创建的策略**
1. 打开 IAM 控制台的 [Policies（策略）页面](https://console.aws.amazon.com/iam/home#/policies)。
1. 选择您创建的策略 (**AWSLambdaS3Policy**)。
1. 选择 **Policy actions**（策略操作）、**Delete**（删除）。
1. 选择 **Delete**（删除）。
**删除执行角色**
1. 打开 IAM 控制台的[角色页面](https://console.aws.amazon.com/iam/home#/roles)。
1. 选择您创建的执行角色。
1. 选择**删除**。
1. 在文本输入字段中输入角色名称，然后选择 **Delete**（删除）。
**删除 S3 存储桶**
1. 打开 [Amazon S3 控制台](https://console.aws.amazon.com//s3/home#)。
1. 选择您创建的存储桶。
1. 选择**删除**。
1. 在文本输入字段中输入存储桶的名称。
1. 选择**删除存储桶**。