# 教程：使用 Amazon S3 触发器调用 Lambda 函数
<a name="with-s3-example"></a>

在本教程中，您将使用控制台创建 Lambda 函数，然后为 Amazon Simple Storage Service（Amazon S3）存储桶配置触发器。每次向 Amazon S3 存储桶添加对象时，函数都会运行并将该对象类型输出到 Amazon CloudWatch Logs 中。

![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-example/s3_tut_config.png)


本教程演示如何：

1. 创建 Amazon S3 存储桶。

1. 创建一个 Lambda 函数，该函数会在 Amazon S3 存储桶中返回对象的类型。

1. 配置一个 Lambda 触发器，该触发器将在对象上传到存储桶时调用函数。

1. 先后使用虚拟事件和触发器测试函数。

完成这些步骤后，您将了解如何配置 Lambda 函数，使其在向 Amazon S3 存储桶添加或删除对象时运行。您仅可以使用 AWS 管理控制台 完成此教程。

## 创建 Amazon S3 存储桶
<a name="with-s3-example-create-bucket"></a>

![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps1.png)


**创建 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. 将所有其他选项设置为默认值并选择**创建存储桶**。

## 将测试对象上传到存储桶
<a name="with-s3-example-upload-test-object"></a>

![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps2.png)


**要上传测试对象**

1. 打开 Amazon S3 控制台的[存储桶](https://console.aws.amazon.com/s3/buckets)页面，选择您在上一步中创建的存储桶。

1. 选择**上传**。

1. 选择**添加文件**，然后选择要上传的对象。您可以选择任何文件（例如 `HappyFace.jpg`）。

1. 选择**打开**，然后选择**上传**。

在本教程的后面部分，您要使用此对象测试 Lambda 函数。

## 创建权限策略
<a name="with-s3-example-create-policy"></a>

![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps3.png)


创建权限策略，允许 Lambda 从 Amazon S3 存储桶获取对象并写入 Amazon CloudWatch Logs。

**创建策略**

1. 打开 IAM 控制台的 [Policies（策略）页面](https://console.aws.amazon.com/iam/home#/policies)。

1. 选择**创建策略**。

1. 选择 **JSON** 选项卡，然后将以下自定义策略粘贴到 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:::*/*"
           }
       ]
   }
   ```

------

1. 选择**下一步：标签**。

1. 选择**下一步：审核**。

1. 在 **Review policy (查看策略)** 下，为策略 **Name (名称)** 输入 **s3-trigger-tutorial**。

1. 选择**创建策略**。

## 创建执行角色
<a name="with-s3-example-create-role"></a>

![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps4.png)


[执行角色](lambda-intro-execution-role.md)是一个 AWS Identity and Access Management（IAM）角色，用于向 Lambda 函数授予访问 AWS 服务 和资源的权限。在此步骤中，您要使用在之前步骤中创建的权限策略来创建执行角色。

**创建执行角色并附加自定义权限策略**

1. 打开 IAM 控制台的[角色页面](https://console.aws.amazon.com/iam/home#/roles)。

1. 选择**创建角色**。

1. 对于可信实体，选择 **AWS 服务**，对于使用案例，选择 **Lambda**。

1. 选择**下一步**。

1. 在策略搜索框中，输入 **s3-trigger-tutorial**。

1. 在搜索结果中，选择您创建的策略（`s3-trigger-tutorial`），然后选择 **Next**（下一步）。

1. 在 **Role details**（角色详细信息）下，为 **Role name**（角色名称）输入 **lambda-s3-trigger-role**，然后选择 **Create role**（创建角色）。

## 创建 Lambda 函数
<a name="with-s3-example-create-function"></a>

![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps5.png)


使用 Python 3.14 运行时系统在控制台中创建 Lambda 函数。

**创建 Lambda 函数**

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. 对于**函数名称**，输入 `s3-trigger-tutorial`。

   1. 对于**运行时系统**，选择 **Python 3.14**。

   1. 对于**架构**，选择 **x86\$164**。

1. 在**更改默认执行角色**选项卡中，执行以下操作：

   1. 展开选项卡，然后选择**使用现有角色**。

   1. 选择您之前创建的 `lambda-s3-trigger-role`。

1. 选择**创建函数**。

## 部署函数代码
<a name="with-s3-example-deploy-code"></a>

![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps6.png)


本教程使用 Python 3.14 运行时系统，但我们还提供了适用于其他运行时系统的示例代码文件。您可以选择以下框中的选项卡，查看适用于您感兴趣的运行时系统的代码。

Lambda 函数检索已上传对象的键名称和来自该对象从 Amazon S3 收到的 `event` 参数的存储桶名称。然后，该函数使用 适用于 Python (Boto3) 的 AWS SDK 中的 [get\$1object](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/s3/client/get_object.html) 方法来检索对象的元数据，包括已上传对象的内容类型（MIME 类型）。

**要部署函数代码**

1. 在下框中选择 **Python** 选项卡并复制代码。

------
#### [ .NET ]

**适用于 .NET 的 SDK**  
 查看 GitHub，了解更多信息。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda)存储库中查找完整示例，并了解如何进行设置和运行。
使用 .NET 将 S3 事件与 Lambda 结合使用。  

   ```
   // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   // SPDX-License-Identifier: Apache-2.0
   using System.Threading.Tasks;
   using Amazon.Lambda.Core;
   using Amazon.S3;
   using System;
   using Amazon.Lambda.S3Events;
   using System.Web;
   
   // Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
   [assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
   
   namespace S3Integration
   {
       public class Function
       {
           private static AmazonS3Client _s3Client;
           public Function() : this(null)
           {
           }
   
           internal Function(AmazonS3Client s3Client)
           {
               _s3Client = s3Client ?? new AmazonS3Client();
           }
   
           public async Task<string> Handler(S3Event evt, ILambdaContext context)
           {
               try
               {
                   if (evt.Records.Count <= 0)
                   {
                       context.Logger.LogLine("Empty S3 Event received");
                       return string.Empty;
                   }
   
                   var bucket = evt.Records[0].S3.Bucket.Name;
                   var key = HttpUtility.UrlDecode(evt.Records[0].S3.Object.Key);
   
                   context.Logger.LogLine($"Request is for {bucket} and {key}");
   
                   var objectResult = await _s3Client.GetObjectAsync(bucket, key);
   
                   context.Logger.LogLine($"Returning {objectResult.Key}");
   
                   return objectResult.Key;
               }
               catch (Exception e)
               {
                   context.Logger.LogLine($"Error processing request - {e.Message}");
   
                   return string.Empty;
               }
           }
       }
   }
   ```

------
#### [ Go ]

**适用于 Go 的 SDK V2**  
 查看 GitHub，了解更多信息。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda)存储库中查找完整示例，并了解如何进行设置和运行。
使用 Go 将 S3 事件与 Lambda 结合使用。  

   ```
   // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   // SPDX-License-Identifier: Apache-2.0
   package main
   
   import (
   	"context"
   	"log"
   
   	"github.com/aws/aws-lambda-go/events"
   	"github.com/aws/aws-lambda-go/lambda"
   	"github.com/aws/aws-sdk-go-v2/config"
   	"github.com/aws/aws-sdk-go-v2/service/s3"
   )
   
   func handler(ctx context.Context, s3Event events.S3Event) error {
   	sdkConfig, err := config.LoadDefaultConfig(ctx)
   	if err != nil {
   		log.Printf("failed to load default config: %s", err)
   		return err
   	}
   	s3Client := s3.NewFromConfig(sdkConfig)
   
   	for _, record := range s3Event.Records {
   		bucket := record.S3.Bucket.Name
   		key := record.S3.Object.URLDecodedKey
   		headOutput, err := s3Client.HeadObject(ctx, &s3.HeadObjectInput{
   			Bucket: &bucket,
   			Key:    &key,
   		})
   		if err != nil {
   			log.Printf("error getting head of object %s/%s: %s", bucket, key, err)
   			return err
   		}
   		log.Printf("successfully retrieved %s/%s of type %s", bucket, key, *headOutput.ContentType)
   	}
   
   	return nil
   }
   
   func main() {
   	lambda.Start(handler)
   }
   ```

------
#### [ Java ]

**适用于 Java 的 SDK 2.x**  
 查看 GitHub，了解更多信息。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda)存储库中查找完整示例，并了解如何进行设置和运行。
使用 Java 将 S3 事件与 Lambda 结合使用。  

   ```
   // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   // SPDX-License-Identifier: Apache-2.0
   package example;
   
   import software.amazon.awssdk.services.s3.model.HeadObjectRequest;
   import software.amazon.awssdk.services.s3.model.HeadObjectResponse;
   import software.amazon.awssdk.services.s3.S3Client;
   
   import com.amazonaws.services.lambda.runtime.Context;
   import com.amazonaws.services.lambda.runtime.RequestHandler;
   import com.amazonaws.services.lambda.runtime.events.S3Event;
   import com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification.S3EventNotificationRecord;
   
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   
   public class Handler implements RequestHandler<S3Event, String> {
       private static final Logger logger = LoggerFactory.getLogger(Handler.class);
       @Override
       public String handleRequest(S3Event s3event, Context context) {
           try {
             S3EventNotificationRecord record = s3event.getRecords().get(0);
             String srcBucket = record.getS3().getBucket().getName();
             String srcKey = record.getS3().getObject().getUrlDecodedKey();
   
             S3Client s3Client = S3Client.builder().build();
             HeadObjectResponse headObject = getHeadObject(s3Client, srcBucket, srcKey);
   
             logger.info("Successfully retrieved " + srcBucket + "/" + srcKey + " of type " + headObject.contentType());
   
             return "Ok";
           } catch (Exception e) {
             throw new RuntimeException(e);
           }
       }
   
       private HeadObjectResponse getHeadObject(S3Client s3Client, String bucket, String key) {
           HeadObjectRequest headObjectRequest = HeadObjectRequest.builder()
                   .bucket(bucket)
                   .key(key)
                   .build();
           return s3Client.headObject(headObjectRequest);
       }
   }
   ```

------
#### [ JavaScript ]

**SDK for JavaScript（v3）**  
 查看 GitHub，了解更多信息。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda)存储库中查找完整示例，并了解如何进行设置和运行。
使用 JavaScript 将 S3 事件与 Lambda 结合使用。  

   ```
   import { S3Client, HeadObjectCommand } from "@aws-sdk/client-s3";
   
   const client = new S3Client();
   
   export const handler = async (event, context) => {
   
       // Get the object from the event and show its content type
       const bucket = event.Records[0].s3.bucket.name;
       const key = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, ' '));
   
       try {
           const { ContentType } = await client.send(new HeadObjectCommand({
               Bucket: bucket,
               Key: key,
           }));
   
           console.log('CONTENT TYPE:', ContentType);
           return ContentType;
   
       } catch (err) {
           console.log(err);
           const message = `Error getting object ${key} from bucket ${bucket}. Make sure they exist and your bucket is in the same region as this function.`;
           console.log(message);
           throw new Error(message);
       }
   };
   ```
使用 TypeScript 将 S3 事件与 Lambda 结合使用。  

   ```
   // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   // SPDX-License-Identifier: Apache-2.0
   import { S3Event } from 'aws-lambda';
   import { S3Client, HeadObjectCommand } from '@aws-sdk/client-s3';
   
   const s3 = new S3Client({ region: process.env.AWS_REGION });
   
   export const handler = async (event: S3Event): Promise<string | undefined> => {
     // Get the object from the event and show its content type
     const bucket = event.Records[0].s3.bucket.name;
     const key = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, ' '));
     const params = {
       Bucket: bucket,
       Key: key,
     };
     try {
       const { ContentType } = await s3.send(new HeadObjectCommand(params));
       console.log('CONTENT TYPE:', ContentType);
       return ContentType;
     } catch (err) {
       console.log(err);
       const message = `Error getting object ${key} from bucket ${bucket}. Make sure they exist and your bucket is in the same region as this function.`;
       console.log(message);
       throw new Error(message);
     }
   };
   ```

------
#### [ PHP ]

**适用于 PHP 的 SDK**  
 查看 GitHub，了解更多信息。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda)存储库中查找完整示例，并了解如何进行设置和运行。
通过 PHP 将 S3 事件与 Lambda 结合使用。  

   ```
   <?php
   
   use Bref\Context\Context;
   use Bref\Event\S3\S3Event;
   use Bref\Event\S3\S3Handler;
   use Bref\Logger\StderrLogger;
   
   require __DIR__ . '/vendor/autoload.php';
   
   
   class Handler extends S3Handler 
   {
       private StderrLogger $logger;
       public function __construct(StderrLogger $logger)
       {
           $this->logger = $logger;
       }
       
       public function handleS3(S3Event $event, Context $context) : void
       {
           $this->logger->info("Processing S3 records");
   
           // Get the object from the event and show its content type
           $records = $event->getRecords();
           
           foreach ($records as $record) 
           {
               $bucket = $record->getBucket()->getName();
               $key = urldecode($record->getObject()->getKey());
   
               try {
                   $fileSize = urldecode($record->getObject()->getSize());
                   echo "File Size: " . $fileSize . "\n";
                   // TODO: Implement your custom processing logic here
               } catch (Exception $e) {
                   echo $e->getMessage() . "\n";
                   echo 'Error getting object ' . $key . ' from bucket ' . $bucket . '. Make sure they exist and your bucket is in the same region as this function.' . "\n";
                   throw $e;
               }
           }
       }
   }
   
   $logger = new StderrLogger();
   return new Handler($logger);
   ```

------
#### [ Python ]

**适用于 Python 的 SDK（Boto3）**  
 查看 GitHub，了解更多信息。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda)存储库中查找完整示例，并了解如何进行设置和运行。
使用 Python 将 S3 事件与 Lambda 结合使用。  

   ```
   # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   # SPDX-License-Identifier: Apache-2.0
   import json
   import urllib.parse
   import boto3
   
   print('Loading function')
   
   s3 = boto3.client('s3')
   
   
   def lambda_handler(event, context):
       #print("Received event: " + json.dumps(event, indent=2))
   
       # Get the object from the event and show its content type
       bucket = event['Records'][0]['s3']['bucket']['name']
       key = urllib.parse.unquote_plus(event['Records'][0]['s3']['object']['key'], encoding='utf-8')
       try:
           response = s3.get_object(Bucket=bucket, Key=key)
           print("CONTENT TYPE: " + response['ContentType'])
           return response['ContentType']
       except Exception as e:
           print(e)
           print('Error getting object {} from bucket {}. Make sure they exist and your bucket is in the same region as this function.'.format(key, bucket))
           raise e
   ```

------
#### [ Ruby ]

**适用于 Ruby 的 SDK**  
 查看 GitHub，了解更多信息。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda)存储库中查找完整示例，并了解如何进行设置和运行。
通过 Ruby 将 S3 事件与 Lambda 结合使用。  

   ```
   require 'json'
   require 'uri'
   require 'aws-sdk'
   
   puts 'Loading function'
   
   def lambda_handler(event:, context:)
     s3 = Aws::S3::Client.new(region: 'region') # Your AWS region
     # puts "Received event: #{JSON.dump(event)}"
   
     # Get the object from the event and show its content type
     bucket = event['Records'][0]['s3']['bucket']['name']
     key = URI.decode_www_form_component(event['Records'][0]['s3']['object']['key'], Encoding::UTF_8)
     begin
       response = s3.get_object(bucket: bucket, key: key)
       puts "CONTENT TYPE: #{response.content_type}"
       return response.content_type
     rescue StandardError => e
       puts e.message
       puts "Error getting object #{key} from bucket #{bucket}. Make sure they exist and your bucket is in the same region as this function."
       raise e
     end
   end
   ```

------
#### [ Rust ]

**适用于 Rust 的 SDK**  
 查看 GitHub，了解更多信息。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda)存储库中查找完整示例，并了解如何进行设置和运行。
使用 Rust 将 S3 事件与 Lambda 结合使用。  

   ```
   // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   // SPDX-License-Identifier: Apache-2.0
   use aws_lambda_events::event::s3::S3Event;
   use aws_sdk_s3::{Client};
   use lambda_runtime::{run, service_fn, Error, LambdaEvent};
   
   
   /// Main function
   #[tokio::main]
   async fn main() -> Result<(), Error> {
       tracing_subscriber::fmt()
           .with_max_level(tracing::Level::INFO)
           .with_target(false)
           .without_time()
           .init();
   
       // Initialize the AWS SDK for Rust
       let config = aws_config::load_from_env().await;
       let s3_client = Client::new(&config);
   
       let res = run(service_fn(|request: LambdaEvent<S3Event>| {
           function_handler(&s3_client, request)
       })).await;
   
       res
   }
   
   async fn function_handler(
       s3_client: &Client,
       evt: LambdaEvent<S3Event>
   ) -> Result<(), Error> {
       tracing::info!(records = ?evt.payload.records.len(), "Received request from SQS");
   
       if evt.payload.records.len() == 0 {
           tracing::info!("Empty S3 event received");
       }
   
       let bucket = evt.payload.records[0].s3.bucket.name.as_ref().expect("Bucket name to exist");
       let key = evt.payload.records[0].s3.object.key.as_ref().expect("Object key to exist");
   
       tracing::info!("Request is for {} and object {}", bucket, key);
   
       let s3_get_object_result = s3_client
           .get_object()
           .bucket(bucket)
           .key(key)
           .send()
           .await;
   
       match s3_get_object_result {
           Ok(_) => tracing::info!("S3 Get Object success, the s3GetObjectResult contains a 'body' property of type ByteStream"),
           Err(_) => tracing::info!("Failure with S3 Get Object request")
       }
   
       Ok(())
   }
   ```

------

1. 在 Lambda 控制台的**代码源**窗格中，将代码粘贴到代码编辑器中，替换 Lambda 创建的代码。

1. 在**部署**部分，选择**部署**以更新函数的代码：  
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)

## 创建 Amazon S3 触发器
<a name="with-s3-example-create-trigger"></a>

![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps7.png)


**创建 Amazon S3 触发器**

1. 在**函数概述**窗格中，选择**添加触发器**。  
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/overview-trigger.png)

1. 选择 **S3**。

1. 在**存储桶**下，选择您在本教程前面步骤中创建的存储桶。

1. 在**事件类型**下，确保已选择**所有对象创建事件**。

1. 在**递归调用**下，选中复选框以确认知晓不建议使用相同的 Amazon S3 存储桶用于输入和输出。

1. 选择**添加**。

**注意**  
当您使用 Lambda 控制台为 Lambda 函数创建 Amazon S3 触发器时，Amazon S3 会在您指定的存储桶上配置[事件通知](https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html)。在配置此事件通知之前，Amazon S3 会执行一系列检查以确认事件目标是否存在并具有所需的 IAM 策略。Amazon S3 还会对为该存储桶配置的任何其他事件通知执行这些测试。  
由于这项检查，如果存储桶之前为已不再存在的资源或没有所需权限策略的资源配置了事件目标，则 Amazon S3 将无法创建新的事件通知。您将看到以下错误消息，表明无法创建触发器：  

```
An error occurred when creating the trigger: Unable to validate the following destination configurations.
```
如果您之前使用同一存储桶为另一个 Lambda 函数配置了触发器，并且此后又删除了该函数或修改了其权限策略，则会看到此错误。

## 使用虚拟事件测试 Lambda 函数
<a name="with-s3-example-test-dummy-event"></a>

![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps8.png)


**要使用虚拟事件测试 Lambda 函数**

1. 在函数的 Lambda 控制台页面中，选择**测试**选项卡。  
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/test-tab.png)

1. 对于**事件名称**，输入 `MyTestEvent`。

1. 在**事件 JSON** 中，粘贴以下测试事件。请务必替换以下值：
   + 使用 `us-east-1` 替换要在其中创建 Amazon S3 存储桶的区域。
   + 将 `amzn-s3-demo-bucket` 的两个实例都替换为 Amazon S3 存储桶的名称。
   + 将 `test%2FKey` 替换为您之前上传到存储桶的测试对象的名称（例如，`HappyFace.jpg`）。

   ```
   {
     "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. 如果函数成功运行，您将在**执行结果**选项卡中看到如下输出。

   ```
   Response
   "image/jpeg"
   
   Function Logs
   START RequestId: 12b3cae7-5f4e-415e-93e6-416b8f8b66e6 Version: $LATEST
   2021-02-18T21:40:59.280Z    12b3cae7-5f4e-415e-93e6-416b8f8b66e6    INFO    INPUT BUCKET AND KEY:  { Bucket: 'amzn-s3-demo-bucket', Key: 'HappyFace.jpg' }
   2021-02-18T21:41:00.215Z    12b3cae7-5f4e-415e-93e6-416b8f8b66e6    INFO    CONTENT TYPE: image/jpeg
   END RequestId: 12b3cae7-5f4e-415e-93e6-416b8f8b66e6
   REPORT RequestId: 12b3cae7-5f4e-415e-93e6-416b8f8b66e6    Duration: 976.25 ms    Billed Duration: 977 ms    Memory Size: 128 MB    Max Memory Used: 90 MB    Init Duration: 430.47 ms        
   
   Request ID
   12b3cae7-5f4e-415e-93e6-416b8f8b66e6
   ```

### 使用 Amazon S3 触发器测试 Lambda 函数
<a name="with-s3-example-test-s3-trigger"></a>

![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/services-s3-example/s3trigger_tut_steps9.png)


要使用配置的触发器测试函数，请使用控制台将对象上传到 Amazon S3 存储桶。要验证 Lambda 函数是否按预期运行，请使用 CloudWatch Logs 查看函数的输出。

**要将对象上传到 Amazon S3 存储桶**

1. 打开 Amazon S3 控制台的[存储桶](https://console.aws.amazon.com/s3/buckets)页面，选择之前创建的存储桶。

1. 选择**上传**。

1. 选择**添加文件**，然后使用文件选择器选择要上传的对象。此对象可以是您选择的任何文件。

1. 选择**打开**，然后选择**上传**。

**使用 CloudWatch Logs 验证函数调用情况**

1. 打开 [CloudWatch 控制台](https://console.aws.amazon.com/cloudwatch/home)。

1. 确保您在创建 Lambda 函数所在相同的 AWS 区域 操作。您可以使用屏幕顶部的下拉列表更改区域。  
![\[\]](http://docs.aws.amazon.com/zh_cn/lambda/latest/dg/images/console_region_select.png)

1. 选择**日志**，然后选择**日志组**。

1. 选择函数 (`/aws/lambda/s3-trigger-tutorial`) 的日志组。

1. 在**日志流**下，选择最新的日志流。

1. 如果已正确调用函数来响应 Amazon S3 触发器，您会看到如下输出。您看到的 `CONTENT TYPE` 取决于上传到存储桶的文件类型。

   ```
   2022-05-09T23:17:28.702Z	0cae7f5a-b0af-4c73-8563-a3430333cc10	INFO	CONTENT TYPE: image/jpeg
   ```

## 清除资源
<a name="cleanup"></a>

除非您想要保留为本教程创建的资源，否则可立即将其删除。通过删除您不再使用的 AWS 资源，可防止您的 AWS 账户 产生不必要的费用。

**删除 Lambda 函数**

1. 打开 Lamba 控制台的 [Functions（函数）页面](https://console.aws.amazon.com/lambda/home#/functions)。

1. 选择您创建的函数。

1. 依次选择**操作**和**删除**。

1. 在文本输入字段中键入 **confirm**，然后选择**删除**。

**删除执行角色**

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. 选择**删除存储桶**。

## 后续步骤
<a name="next-steps"></a>

在 [教程：使用 Amazon S3 触发器创建缩略图](with-s3-tutorial.md) 中，Amazon S3 触发器会调用一个函数，该函数会为上传到存储桶的每个图像文件创建缩略图。本教程需要适度的AWS和 Lambda 领域知识水平。其展示了如何使用 AWS Command Line Interface（AWS CLI）来创建资源，以及如何为函数及其依赖项创建 .zip 文件存档部署包。