

本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 使用以下命令测试您的无服务器应用程序 AWS SAM
<a name="serverless-test-and-debug"></a>

在编写和构建应用程序后，您将准备好测试您的应用程序以验证其是否正常运行。使用 AWS SAM 命令行界面 (CLI)，您可以先在本地测试您的无服务器应用程序，然后再将其上传到 AWS 云端。测试应用程序可帮助您确认应用程序的功能、可靠性和性能，同时识别需要解决的问题（错误）。

本节提供有关测试应用程序时可以遵循的常见做法的指导。本节中的主题主要侧重于在 AWS 云端部署之前可以进行的本地测试。部署前测试可帮助您主动发现问题，减少与部署问题相关的不必要成本。本节中的每个主题都描述了你可以执行的测试，告诉 yoxi include href？ u 使用它的优点，并包括向你展示如何执行测试的示例。测试应用程序后，您就可以调试发现的任何问题了。

**Topics**
+ [使用 sam local 命令进行测试简介](using-sam-cli-local.md)
+ [使用本地调用 Lambda 函数 AWS SAM](serverless-sam-cli-using-invoke.md)
+ [在本地运行 API Gateway AWS SAM](serverless-sam-cli-using-start-api.md)
+ [使用 sam remote test-event 进行云测试简介](using-sam-cli-remote-test-event.md)
+ [使用 sam remote invoke 在云中测试简介](using-sam-cli-remote-invoke.md)
+ [使用自动执行本地集成测试 AWS SAM](serverless-sam-cli-using-automated-tests.md)
+ [使用生成示例事件有效负载 AWS SAM](serverless-sam-cli-using-generate-event.md)
+ [测试和调试耐用函数](test-and-debug-durable-functions.md)

# 使用 sam local 命令进行测试简介
<a name="using-sam-cli-local"></a>

使用 AWS Serverless Application Model 命令行界面 (AWS SAMCLI) `sam local` 命令在本地测试您的无服务器应用程序。

有关简介 AWS SAMCLI，请参阅[那是什么 AWS SAMCLI？](what-is-sam-overview.md#what-is-sam-cli)。

## 先决条件
<a name="using-sam-cli-local-prerequisites"></a>

要使用 `sam local`，请完成以下操作安装 AWS SAM CLI。
+ [AWS SAM 先决条件](prerequisites.md).
+ [安装 AWS SAM CLI](install-sam-cli.md).

我们建议您在使用 `sam local` 之前初步了解以下主题：
+ [配置 AWS SAM CLI](using-sam-cli-configure.md).
+ [在中创建您的应用程序 AWS SAM](using-sam-cli-init.md).
+ [搭建简介 AWS SAM](using-sam-cli-build.md).
+ [使用部署简介 AWS SAM](using-sam-cli-deploy.md).

## 使用 sam local 命令
<a name="using-sam-cli-local-command"></a>

使用 `sam local` 命令及其任何子命令，为应用程序执行不同类型的本地测试。

```
$ sam local <subcommand>
```

要了解有关每个子命令的更多信息，请参阅以下内容：
+ **[sam local generate-event 简介](using-sam-cli-local-generate-event.md)**— 生成用于本地测试 AWS 服务 的事件。
+ **[sam local invoke 简介](using-sam-cli-local-invoke.md)** – 在本地启动 AWS Lambda 函数的一次性调用。
+ **[sam local start-api 简介](using-sam-cli-local-start-api.md)** – 使用本地 HTTP 服务器运行 Lambda 函数。
+ **[sam local start-lambda 简介](using-sam-cli-local-start-lambda.md)**— 使用本地 HTTP 服务器运行您的 Lambda 函数，以便与或一起使用。 AWS CLI SDKs

# 使用 sam local generate-event 进行测试简介
<a name="using-sam-cli-local-generate-event"></a>

使用 AWS Serverless Application Model Command Line Interface (AWS SAMCLI) `sam local generate-event` 子命令生成支持 AWS 服务的事件有效载荷示例。然后，您可以修改这些事件并将其传递给本地资源进行测试。
+ 有关简介 AWS SAMCLI，请参阅 [那是什么 AWS SAMCLI？](what-is-sam-overview.md#what-is-sam-cli)
+ 有关 `sam local generate-event` 命令选项的列表，请参阅 [sam local generate-event](sam-cli-command-reference-sam-local-generate-event.md)。

*事件*是一个 JSON 对象，在 AWS 服务 执行操作或任务时生成。这些事件包含特定信息，例如，已处理的数据或事件的时间戳。大多数 AWS 服务 都会生成事件，并且每项服务的事件都采用该服务独有的格式。

由某项服务生成的事件会作为*事件源*传递给其他服务。例如，置于 Amazon Simple Storage Service (Amazon S3) 存储桶中的项目可以生成事件。然后，可以将此事件用作 AWS Lambda 函数的事件源，以进一步处理数据。

使用生成的事件的格式与`sam local generate-event` AWS 服务创建的实际事件的结构相同。您可以修改这些事件的内容，并使用它们来测试应用程序中的资源。

## 先决条件
<a name="using-sam-cli-local-generate-event-prerequisites"></a>

要使用 `sam local generate-event`，请完成以下操作安装 AWS SAM CLI。
+ [AWS SAM 先决条件](prerequisites.md).
+ [安装 AWS SAM CLI](install-sam-cli.md).

我们建议您在使用 `sam local generate-event` 之前初步了解以下主题：
+ [配置 AWS SAM CLI](using-sam-cli-configure.md).
+ [在中创建您的应用程序 AWS SAM](using-sam-cli-init.md).
+ [搭建简介 AWS SAM](using-sam-cli-build.md).
+ [使用部署简介 AWS SAM](using-sam-cli-deploy.md).

## 生成示例事件
<a name="using-sam-cli-local-generate-event-generate"></a>

使用 AWS SAMCLI`sam local generate-event`子命令生成支持 AWS 服务的事件。

**查看支持的列表 AWS 服务**

1. 运行以下命令：

   ```
   $ sam local generate-event
   ```

1.  AWS 服务 将显示支持的列表。以下是示例：

   ```
   $ sam local generate-event
   ...
   Commands:
     alb
     alexa-skills-kit
     alexa-smart-home
     apigateway
     appsync
     batch
     cloudformation
     ...
   ```

**生成本地事件**

1. 运行 `sam local generate-event` 并提供受支持服务的名称。这将显示可生成的事件类型的列表。以下是示例：

   ```
   $ sam local generate-event s3
   
   Usage: sam local generate-event s3 [OPTIONS] COMMAND [ARGS]...
   
   Options:
     -h, --help  Show this message and exit.
   
   Commands:
     batch-invocation  Generates an Amazon S3 Batch Operations Invocation Event
     delete            Generates an Amazon S3 Delete Event
     put               Generates an Amazon S3 Put Event
   ```

1. 要生成示例事件，请运行 `sam local generate-event`，并提供服务和事件类型。

   ```
   $ sam local generate-event <service> <event>
   ```

   以下是示例：

   ```
   $ sam local generate-event s3 put
   {
     "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": "sam-s3-demo-bucket",
             "ownerIdentity": {
               "principalId": "EXAMPLE"
             },
             "arn": "arn:aws:s3:::sam-s3-demo-bucket"
           },
           "object": {
             "key": "test/key",
             "size": 1024,
             "eTag": "0123456789abcdef0123456789abcdef",
             "sequencer": "0A1B2C3D4E5F678901"
           }
         }
       }
     ]
   }
   ```

这些示例事件包含占位符值。您可以修改这些值以引用应用程序中的实际资源，也可以修改这些值以帮助进行本地测试。

**修改示例事件**

1. 您可以在命令提示符处修改示例事件。要查看选项，请运行以下命令：

   ```
   $ sam local generate-event <service> <event> --help
   ```

   以下是示例：

   ```
   $ sam local generate-event s3 put --help
   
   Usage: sam local generate-event s3 put [OPTIONS]
   
   Options:
     --region TEXT       Specify the region name you'd like, otherwise the
                         default = us-east-1
     --partition TEXT    Specify the partition name you'd like, otherwise the
                         default = aws
     --bucket TEXT       Specify the bucket name you'd like, otherwise the
                         default = example-bucket
     --key TEXT          Specify the key name you'd like, otherwise the default =
                         test/key
     --debug             Turn on debug logging to print debug message generated
                         by AWS SAM CLI and display timestamps.
     --config-file TEXT  Configuration file containing default parameter values.
                         [default: samconfig.toml]
     --config-env TEXT   Environment name specifying default parameter values in
                         the configuration file.  [default: default]
     -h, --help          Show this message and exit.
   ```

1. 在命令提示符处使用这些选项中的任何一个来修改示例事件有效负载。以下是示例：

   ```
   $ sam local generate-event s3 put--bucket sam-s3-demo-bucket
   
   {
     "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": "sam-s3-demo-bucket",
             "ownerIdentity": {
               "principalId": "EXAMPLE"
             },
             "arn": "arn:aws:s3:::sam-s3-demo-bucket"
           },
           "object": {
             "key": "test/key",
             "size": 1024,
             "eTag": "0123456789abcdef0123456789abcdef",
             "sequencer": "0A1B2C3D4E5F678901"
           }
         }
       }
     ]
   }
   ```

## 使用生成的事件进行本地测试
<a name="using-sam-cli-local-generate-event-use"></a>

将生成的事件保存在本地，然后使用其他 `sam local` 子命令进行测试。

**将生成的事件保存在本地**
+ 运行以下命令：

  ```
  $ sam local generate-event <service> <event> <event-option> > <filename.json>
  ```

  以下示例说明了如何将事件另存为项目的 `events` 文件夹中的 `s3.json` 文件。

  ```
  sam-app$ sam local generate-event s3 put --bucket amzn-s3-demo-bucket > events/s3.json
  ```

**使用生成的事件进行本地测试**
+ 使用 `--event` 选项将事件与其他 `sam local` 子命令一起传递。

  以下示例说明了如何使用 `s3.json` 事件在本地调用 Lambda 函数：

  ```
  sam-app$ sam local invoke --event events/s3.json S3JsonLoggerFunction
  
  Invoking src/handlers/s3-json-logger.s3JsonLoggerHandler (nodejs18.x)
  Local image is up-to-date
  Using local image: public.ecr.aws/lambda/nodejs:18-rapid-x86_64.
  
  Mounting /Users/.../sam-app/.aws-sam/build/S3JsonLoggerFunction as /var/task:ro,delegated, inside runtime container
  START RequestId: f4f45b6d-2ec6-4235-bc7b-495ec2ae0128 Version: $LATEST
  END RequestId: f4f45b6d-2ec6-4235-bc7b-495ec2ae0128
  REPORT RequestId: f4f45b6d-2ec6-4235-bc7b-495ec2ae0128  Init Duration: 1.23 ms  Duration: 9371.93 ms      Billed Duration: 9372 ms        Memory Size: 128 MB     Max Memory Used: 128 MB
  ```

## 了解详情
<a name="using-sam-cli-local-generate-event-learn"></a>

有关全部 `sam local generate-event` 选项的列表，请参阅 [sam local generate-event](sam-cli-command-reference-sam-local-generate-event.md)。

有关使用 `sam local` 的演示，请参阅[用于本地开发的AWS SAM 。在 SA *M 系列开启的 Serverless Land Sessions 中测试来自本地开发环境的 AWS 云 *资源](https://www.youtube.com/watch?v=NzPqMrdgD1s&list=PLJo-rJlep0ED198FJnTzhIB5Aut_1vDAd&index=24)。YouTube

# 使用 sam local invoke 进行测试简介
<a name="using-sam-cli-local-invoke"></a>

使用 AWS Serverless Application Model Command Line Interface (AWS SAMCLI) `sam local invoke` 子命令在本地启动对 AWS Lambda 函数的一次性调用。
+ 有关简介 AWS SAMCLI，请参阅 [那是什么 AWS SAMCLI？](what-is-sam-overview.md#what-is-sam-cli)
+ 有关 `sam local invoke` 命令选项的列表，请参阅 [sam local invoke](sam-cli-command-reference-sam-local-invoke.md)。
+ 有关在典型开发工作流程中使用 `sam local invoke` 的示例，请参阅[第 7 步：（可选）在本地测试应用程序](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-test)。

**注意**  
不建议在不受信任的代码中使用 SAM CLI 的本地调用功能。要与本地环境完全隔离，请直接在 Lambda 服务中执行代码。

**注意**  
`sam local invoke`支持具有自动检查点和重播功能的耐用功能。在本地调用耐久函数时，会自动管理执行状态。

## 先决条件
<a name="using-sam-cli-local-invoke-prerequisites"></a>

要使用 `sam local invoke`，请完成以下操作安装 AWS SAM CLI。
+ [AWS SAM 先决条件](prerequisites.md).
+ [安装 AWS SAM CLI](install-sam-cli.md).

我们建议您在使用 `sam local invoke` 之前初步了解以下主题：
+ [配置 AWS SAM CLI](using-sam-cli-configure.md).
+ [在中创建您的应用程序 AWS SAM](using-sam-cli-init.md).
+ [搭建简介 AWS SAM](using-sam-cli-build.md).
+ [使用部署简介 AWS SAM](using-sam-cli-deploy.md).

## 本地调用 Lambda 函数
<a name="using-sam-cli-local-invoke-use"></a>

当您运行 `sam local invoke` 时， AWS SAM CLI 会假设当前工作目录是项目的根目录。 AWS SAM CLI 会首先在 `.aws-sam` 子文件夹中查找 `template.[yaml|yml]` 文件。如果找不到， AWS SAM CLI 会在当前工作目录中查找 `template.[yaml|yml]` 文件。

**在本地调用 Lambda 函数**

1. 从项目的根目录中，运行以下命令：

   ```
   $ sam local invoke <options>
   ```

1. 如果应用程序包含多个函数，请提供函数的逻辑 ID。以下是示例：

   ```
   $ sam local invoke HelloWorldFunction
   ```

1.  AWS SAM CLI 会使用 Docker 在本地容器中构建函数。然后，它会调用函数并输出函数的响应。

   以下是示例：

   ```
   $ sam local invoke
   Invoking app.lambda_handler (python3.9)
   Local image is out of date and will be updated to the latest runtime. To skip this, pass in the parameter --skip-pull-image
   Building image....................................................................................................................
   Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64.
   
   Mounting /Users/.../sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container
   START RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df Version: $LATEST
   END RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df
   REPORT RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df  Init Duration: 1.09 ms  Duration: 608.42 ms       Billed Duration: 609 ms Memory Size: 128 MB     Max Memory Used: 128 MB
   {"statusCode": 200, "body": "{\"message\": \"hello world\"}"}%
   ```

### 管理日志
<a name="using-sam-cli-local-invoke-logs"></a>

使用 `sam local invoke` 时，Lambda 函数运行时输出（例如日志）会输出到 `stderr`，Lambda 函数结果会输出到 `stdout`。

以下是基础 Lambda 函数的示例：

```
def handler(event, context):
    print("some log") # this goes to stderr
    return "hello world" # this goes to stdout
```

您可以保存这些标准输出。以下是示例：

```
$ sam local invoke 1> stdout.log
...

$ cat stdout.log
"hello world"

$ sam local invoke 2> stderr.log
...

$ cat stderr.log
Invoking app.lambda_handler (python3.9)
Local image is up-to-date
Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64.
Mounting /Users/.../sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container
START RequestId: 0b46e646-3bdf-4b58-8beb-242d00912c46 Version: $LATEST
some log
END RequestId: 0b46e646-3bdf-4b58-8beb-242d00912c46
REPORT RequestId: 0b46e646-3bdf-4b58-8beb-242d00912c46  Init Duration: 0.91 ms  Duration: 589.19 ms Billed Duration: 590 ms Memory Size: 128 MB Max Memory Used: 128 MB
```

您可以使用这些标准输出来进一步自动化您的本地开发流程。

## 选项
<a name="using-sam-cli-local-invoke-options"></a>

### 传递自定义事件以调用 Lambda 函数
<a name="using-sam-cli-local-invoke-options-events"></a>

要将事件传递给 Lambda 函数，请使用 `--event` 选项。以下是示例：

```
$ sam local invoke --event events/s3.json S3JsonLoggerFunction
```

您可以使用 `sam local generate-event` 子命令创建事件。要了解更多信息，请参阅[使用 sam local generate-event 进行测试简介](using-sam-cli-local-generate-event.md)。

### 在调用 Lambda 函数时传递环境变量
<a name="using-sam-cli-local-invoke-options-env"></a>

如果 Lambda 函数使用环境变量，则您可以在本地测试期间使用 `--env-vars` 选项传递这些变量。这是使用已经部署在云中应用程序中的服务在本地测试 Lambda 函数的好方法。以下是示例：

```
$ sam local invoke --env-vars locals.json
```

### 指定模板或函数
<a name="using-sam-cli-local-invoke-options-specify"></a>

要为 AWS SAM CLI 指定要引用的模板，请使用 `--template` 选项。 AWS SAMCLI将只加载该 AWS SAM 模板及其指向的资源。

要调用嵌套应用程序或堆栈的函数，请提供应用程序或堆栈的逻辑 ID 以及函数逻辑 ID。以下是示例：

```
$ sam local invoke StackLogicalId/FunctionLogicalId
```

### 测试 Terraform 项目中的 Lambda 函数
<a name="using-sam-cli-local-invoke-options-terraform"></a>

使用 `--hook-name` 选项在本地测试 Terraform 项目中的 Lambda 函数。要了解更多信息，请参阅[使用 AWS SAM CLI 和 Terraform 进行本地调试和测试](using-samcli-terraform.md)。

以下是示例：

```
$ sam local invoke --hook-name terraform --beta-features
```

## 最佳实践
<a name="using-sam-cli-local-invoke-best"></a>

如果应用程序有无法运行 `sam build` 的 `.aws-sam` 目录，请务必在每次更新函数代码时都运行 `sam build`。然后，运行 `sam local invoke`，以在本地测试更新后的函数代码。

本地测试是部署到云中之前进行快速开发和测试的理想解决方案。但是，本地测试并不能验证所有内容，例如，不能验证云端资源之间的权限。尽可能在云端测试应用程序。我们建议[使用 `sam sync`](using-sam-cli-sync.md) 来加快云测试工作流程。

## 示例
<a name="using-sam-cli-local-invoke-examples"></a>

### 生成 Amazon API Gateway 示例事件并使用该事件在本地调用 Lambda 函数
<a name="using-sam-cli-local-invoke-examples-api"></a>

首先，生成 API Gateway HTTP API 事件有效负载并将其保存到 `events` 文件夹中。

```
$ sam local generate-event apigateway http-api-proxy > events/apigateway_event.json
```

然后，修改 Lambda 函数以从事件中返回参数值。

```
def lambda_handler(event, context):
    print("HelloWorldFunction invoked")
    return {
        "statusCode": 200,
        "body": json.dumps({
            "message": event['queryStringParameters']['parameter2'],
        }),
    }
```

然后，在本地调用 Lambda 函数并提供自定义事件。

```
$ sam local invoke --event events/apigateway_event.json

Invoking app.lambda_handler (python3.9)
Local image is up-to-date
Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64.

Mounting /Users/...sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container
START RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Version: $LATEST
some log
END RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8
REPORT RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8  Init Duration: 1.63 ms  Duration: 564.07 ms       Billed Duration: 565 ms Memory Size: 128 MB     Max Memory Used: 128 MB
{"statusCode": 200, "body": "{\"message\": \"value\"}"}%
```

### 在本地调用 Lambda 函数时传递环境变量
<a name="using-sam-cli-local-invoke-examples-env"></a>

此应用程序有一个 Lambda 函数，该函数使用环境变量作为 Amazon DynamoDB 表的名称。以下是 AWS SAM 模板中定义的函数的示例：

```
AWSTemplateFormatVersion: 2010-09-09
Transform: AWS::Serverless-2016-10-31
...
Resources:
  getAllItemsFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: src/get-all-items.getAllItemsHandler
      Description: get all items
      Policies:
        - DynamoDBReadPolicy:
            TableName: !Ref SampleTable
      Environment:
        Variables:
          SAMPLE_TABLE: !Ref SampleTable
...
```

我们要在本地测试 Lambda 函数，同时让它与云中的 DynamoDB 表进行交互。为此，我们创建环境变量文件，并将其保存在项目的根目录中，文件名为 `locals.json`。此处为`SAMPLE_TABLE`提供的值引用了云中的 DynamoDB 表。

```
{
    "getAllItemsFunction": {
        "SAMPLE_TABLE": "dev-demo-SampleTable-1U991234LD5UM98"
    }
}
```

然后，运行 `sam local invoke`，并使用 `--env-vars` 选项传入环境变量。

```
$ sam local invoke getAllItemsFunction --env-vars locals.json

Mounting /Users/...sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container
START RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Version: $LATEST
some log
END RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8
REPORT RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8  Init Duration: 1.63 ms  Duration: 564.07 ms       Billed Duration: 565 ms Memory Size: 128 MB     Max Memory Used: 128 MB
{"statusCode":200,"body":"{}"}
```

## 了解详情
<a name="using-sam-cli-local-invoke-learn"></a>

有关全部 `sam local invoke` 选项的列表，请参阅 [sam local invoke](sam-cli-command-reference-sam-local-invoke.md)。

有关使用 `sam local` 的演示，请参阅[用于本地开发的AWS SAM 。在 SA *M 系列开启的 Serverless Land Sessions 中测试来自本地开发环境的 AWS 云 *资源](https://www.youtube.com/watch?v=NzPqMrdgD1s&list=PLJo-rJlep0ED198FJnTzhIB5Aut_1vDAd&index=24)。YouTube

# 使用 sam local start-api 进行测试简介
<a name="using-sam-cli-local-start-api"></a>

使用 AWS Serverless Application Model Command Line Interface (AWS SAMCLI) `sam local start-api` 子命令在本地运行 AWS Lambda 函数并通过本地 HTTP 服务器主机进行测试。此类测试对由 Amazon API Gateway 端点调用的 Lambda 函数很有用。
+ 有关简介 AWS SAMCLI，请参阅 [那是什么 AWS SAMCLI？](what-is-sam-overview.md#what-is-sam-cli)
+ 有关 `sam local start-api` 命令选项的列表，请参阅 [sam local start-api](sam-cli-command-reference-sam-local-start-api.md)。
+ 有关在典型开发工作流程中使用 `sam local start-api` 的示例，请参阅[第 7 步：（可选）在本地测试应用程序](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-test)。

**注意**  
`sam local start-api`支持具有自动检查点和重播功能的耐用功能。耐用功能可与本地 API Gateway 端点无缝协作。

## 先决条件
<a name="using-sam-cli-local-start-api-prerequisites"></a>

要使用 `sam local start-api`，请完成以下操作安装 AWS SAM CLI。
+ [AWS SAM 先决条件](prerequisites.md).
+ [安装 AWS SAM CLI](install-sam-cli.md).

我们建议您在使用 `sam local start-api` 之前初步了解以下主题：
+ [配置 AWS SAM CLI](using-sam-cli-configure.md).
+ [在中创建您的应用程序 AWS SAM](using-sam-cli-init.md).
+ [搭建简介 AWS SAM](using-sam-cli-build.md).
+ [使用部署简介 AWS SAM](using-sam-cli-deploy.md).

## 使用 sam local start-api
<a name="using-sam-cli-local-start-api-use"></a>

当您运行 `sam local start-api` 时， AWS SAM CLI 会假设当前工作目录是项目的根目录。 AWS SAM CLI 会首先在 `.aws-sam` 子文件夹中查找 `template.[yaml|yml]` 文件。如果找不到， AWS SAM CLI 会在当前工作目录中查找 `template.[yaml|yml]` 文件。

**启动本地 HTTP 服务器**

1. 从项目的根目录中，运行以下命令：

   ```
   $ sam local start-api <options>
   ```

1.  AWS SAM CLI 会在本地 Docker 容器中构建 Lambda 函数。然后，它会输出 HTTP 服务器端点的本地地址。以下是示例：

   ```
   $ sam local start-api
   
   Initializing the lambda functions containers.
   Local image is up-to-date
   Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64.
   
   Mounting /Users/.../sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container
   Containers Initialization is done.
   Mounting HelloWorldFunction at http://127.0.0.1:3000/hello [GET]
   You can now browse to the above endpoints to invoke your functions. You do not need to restart/reload SAM CLI while working on your functions, changes will be reflected instantly/automatically. If you used sam build before running local commands, you will need to re-run sam build for the changes to be picked up. You only need to restart SAM CLI if you update your AWS SAM template
   2023-04-12 14:41:05 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
    * Running on http://127.0.0.1:3000
   ```

1. 您可以通过浏览器或命令提示符调用 Lambda 函数。以下是示例：

   ```
   sam-app$ curl http://127.0.0.1:3000/hello
   {"message": "Hello world!"}%
   ```

1. 如果您更改了 Lambda 函数代码，在刷新本地 HTTP 服务器时，请考虑以下几点：
   + 如果应用程序没有 `.aws-sam` 目录，并且函数使用解释性语言，则 AWS SAM CLI 会通过创建并托管新容器来自动更新函数。
   + 如果应用程序有 `.aws-sam` 目录，则您需要运行 `sam build` 以更新函数。然后再次运行 `sam local start-api` 以托管函数。
   + 如果函数使用编译语言，或者项目需要复杂的打包支持，请运行您自己的构建解决方案来更新函数。然后再次运行 `sam local start-api` 以托管函数。

### 使用 Lambda 授权方的 Lambda 函数
<a name="using-sam-cli-local-start-api-authorizers"></a>

**注意**  
这是 AWS SAM CLI 版本 1.80.0 中的新功能 要升级，请参阅 [升级 AWS SAM CLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade)。

对于使用 Lambda 授权方的 Lambda 函数， AWS SAM CLI 会在调用 Lambda 函数端点之前自动调用 Lambda 授权方。

以下示例说明了如何为使用 Lambda 授权方的函数启动本地 HTTP 服务器：

```
$ sam local start-api
2023-04-17 15:02:13 Attaching import module proxy for analyzing dynamic imports

AWS SAM CLI does not guarantee 100% fidelity between authorizers locally
and authorizers deployed on AWS. Any application critical behavior should
be validated thoroughly before deploying to production.

Testing application behaviour against authorizers deployed on AWS can be done using the sam sync command.

Mounting HelloWorldFunction at http://127.0.0.1:3000/authorized-request [GET]
You can now browse to the above endpoints to invoke your functions. You do not need to restart/reload SAM CLI while working on your functions, changes will be reflected instantly/automatically. If you used sam build before running local commands, you will need to re-run sam build for the changes to be picked up. You only need to restart SAM CLI if you update your AWS SAM template
2023-04-17 15:02:13 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on http://127.0.0.1:3000
2023-04-17 15:02:13 Press CTRL+C to quit
```

当您通过本地 HTTP 服务器调用 Lambda 函数端点时， AWS SAM CLI 会先调用 Lambda 授权方。如果授权成功， AWS SAM CLI 就会调用 Lambda 函数端点。以下是示例：

```
$ curl http://127.0.0.1:3000/authorized-request --header "header:my_token"
{"message": "from authorizer"}%

Invoking app.authorizer_handler (python3.8)
Local image is up-to-date
Using local image: public.ecr.aws/lambda/python:3.8-rapid-x86_64.

Mounting /Users/.../sam-app/... as /var/task:ro,delegated, inside runtime container
START RequestId: 38d3b472-a2c8-4ea6-9a77-9b386989bef0 Version: $LATEST
END RequestId: 38d3b472-a2c8-4ea6-9a77-9b386989bef0
REPORT RequestId: 38d3b472-a2c8-4ea6-9a77-9b386989bef0    Init Duration: 1.08 ms    Duration: 628.26 msBilled Duration: 629 ms    Memory Size: 128 MB    Max Memory Used: 128 MB
Invoking app.request_handler (python3.8)
Using local image: public.ecr.aws/lambda/python:3.8-rapid-x86_64.

Mounting /Users/.../sam-app/... as /var/task:ro,delegated, inside runtime container
START RequestId: fdc12255-79a3-4365-97e9-9459d06446ff Version: $LATEST
END RequestId: fdc12255-79a3-4365-97e9-9459d06446ff
REPORT RequestId: fdc12255-79a3-4365-97e9-9459d06446ff    Init Duration: 0.95 ms    Duration: 659.13 msBilled Duration: 660 ms    Memory Size: 128 MB    Max Memory Used: 128 MB
No Content-Type given. Defaulting to 'application/json'.
2023-04-17 15:03:03 127.0.0.1 - - [17/Apr/2023 15:03:03] "GET /authorized-request HTTP/1.1" 200 -
```

## 选项
<a name="using-sam-cli-local-start-api-options"></a>

### 持续重用容器以加快本地函数调用
<a name="using-sam-cli-local-start-api-options-warm"></a>

默认情况下，每次通过本地 HTTP 服务器调用函数时， AWS SAM CLI 都会创建新容器。使用 `--warm-containers` 选项可自动重用容器进行函数调用。这会缩短 AWS SAM CLI 为本地调用准备 Lambda 函数所需的时间。您可以通过提供 `eager` 或 `lazy` 参数进一步自定义此选项。
+ `eager` - 在启动时加载所有函数的容器，且并在调用之间持久存在。
+ `lazy` - 仅在首次调用每个函数时加载容器。加载的容器会保持不变，以供用于其他调用。

以下是示例：

```
$ sam local start-api --warm-containers eager
```

使用 `--warm-containers` 和修改 Lambda 函数代码时：
+ 如果应用程序有 `.aws-sam` 目录，请运行 `sam build` 以更新应用程序构建构件中的函数代码。
+ 如果检测到代码更改， AWS SAM CLI 会自动关闭 Lambda 函数容器。
+ 当您再次调用函数时， AWS SAM CLI 会自动创建新容器。

### 指定要用于 Lambda 函数的容器映像
<a name="using-sam-cli-local-start-api-options-specify"></a>

默认情况下， AWS SAM CLI 使用 Amazon Elastic Container Registry (Amazon ECR) 中的 Lambda 基本映像在本地调用函数。使用 `--invoke-image` 选项引用自定义容器映像。以下是示例：

```
$ sam local start-api --invoke-image public.ecr.aws/sam/emu-python3.8
```

您可以指定要与自定义容器映像一起使用的函数。以下是示例：

```
$ sam local start-api --invoke-image Function1=amazon/aws/sam-cli-emulation-image-python3.8
```

### 指定模板以在本地进行测试
<a name="using-sam-cli-local-start-api-options-template"></a>

要为 AWS SAM CLI 指定要引用的模板，请使用 `--template` 选项。 AWS SAMCLI将只加载该 AWS SAM 模板及其指向的资源。以下是示例：

```
$ sam local start-api --template myTemplate.yaml
```

### 指定 Lambda 函数的主机开发环境
<a name="using-sam-cli-local-start-api-options-dev"></a>

默认情况下，`sam local start-api` 子命令使用带有 IP 地址 `127.0.0.1` 的 `localhost` 来创建 HTTP 服务器。如果本地开发环境与本地计算机隔离，则可以自定义这些值。

使用 `--container-host` 选项指定主机。以下是示例：

```
$ sam local start-api --container-host host.docker.internal
```

使用 `--container-host-interface` 选项指定应与容器端口绑定的主机网络的 IP 地址。以下是示例：

```
$ sam local start-api --container-host-interface 0.0.0.0
```

## 最佳实践
<a name="using-sam-cli-local-start-api-best"></a>

如果应用程序有无法运行 `sam build` 的 `.aws-sam` 目录，请务必在每次更新函数代码时都运行 `sam build`。然后，运行 `sam local start-api`，以在本地测试更新后的函数代码。

本地测试是部署到云中之前进行快速开发和测试的理想解决方案。但是，本地测试并不能验证所有内容，例如，不能验证云端资源之间的权限。尽可能在云端测试应用程序。我们建议[使用 `sam sync`](using-sam-cli-sync.md) 来加快云测试工作流程。

## 了解详情
<a name="using-sam-cli-local-start-api-learn"></a>

有关全部 `sam local start-api` 选项的列表，请参阅 [sam local start-api](sam-cli-command-reference-sam-local-start-api.md)。

# 使用 sam local start-lambda 进行测试简介
<a name="using-sam-cli-local-start-lambda"></a>

使用 AWS SAMCLI子命令通过 AWS CLI 和调`sam local start-lambda`用您的 Lambda 函数。 SDKs此命令启动模拟 Lambda 的本地端点。
+ 有关简介 AWS SAMCLI，请参阅 [那是什么 AWS SAMCLI？](what-is-sam-overview.md#what-is-sam-cli)
+ 有关 `sam local start-lambda` 命令选项的列表，请参阅 [sam local start-lambda](sam-cli-command-reference-sam-local-start-lambda.md)。

**注意**  
`sam local start-lambda`支持具有自动检查点和重播功能的耐用功能。耐用函数可与本地 Lambda 端点无缝协作。

## 先决条件
<a name="using-sam-cli-local-start-api-prerequisites"></a>

要使用 `sam local start-lambda`，请完成以下操作安装 AWS SAM CLI。
+ [AWS SAM 先决条件](prerequisites.md).
+ [安装 AWS SAM CLI](install-sam-cli.md).

我们建议您在使用 `sam local start-lambda` 之前初步了解以下主题：
+ [配置 AWS SAM CLI](using-sam-cli-configure.md).
+ [在中创建您的应用程序 AWS SAM](using-sam-cli-init.md).
+ [搭建简介 AWS SAM](using-sam-cli-build.md).
+ [使用部署简介 AWS SAM](using-sam-cli-deploy.md).

## 使用 sam local start-lambda
<a name="using-sam-cli-local-start-lambda-use"></a>

当您运行 `sam local start-lambda` 时， AWS SAM CLI 会假设当前工作目录是项目的根目录。 AWS SAM CLI 会首先在 `.aws-sam` 子文件夹中查找 `template.[yaml|yml]` 文件。如果找不到， AWS SAM CLI 会在当前工作目录中查找 `template.[yaml|yml]` 文件。

**要使用 sam local start-lambda**

1. 从项目的根目录中，运行以下命令：

   ```
   $ sam local start-lambda <options>
   ```

1.  AWS SAM CLI 会在本地 Docker 容器中构建 Lambda 函数。然后，它会将本地地址输出到 HTTP 服务器端点。以下是示例：

   ```
   $ sam local start-lambda
   Initializing the lambda functions containers.
   Local image is up-to-date
   Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64.
   
   Mounting /Users/.../sam-app/hello_world as /var/task:ro,delegated, inside runtime container
   Containers Initialization is done.
   Starting the Local Lambda Service. You can now invoke your Lambda Functions defined in your template through the endpoint.
   2023-04-13 07:25:43 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
    * Running on http://127.0.0.1:3001
   2023-04-13 07:25:43 Press CTRL+C to quit
   ```

1. 使用 AWS CLI 或在本地调 SDKs 用您的 Lambda 函数。

   以下是一个使用 AWS CLI的示例：

   ```
   $ aws lambda invoke --function-name "HelloWorldFunction" --endpoint-url "http://127.0.0.1:3001" --no-verify-ssl out.txt
       
   StatusCode: 200
   (END)
   ```

   以下是使用 for AWS SDK 的示例Python：

   ```
   import boto3
   from botocore.config import Config
   from botocore import UNSIGNED
   
   lambda_client = boto3.client('lambda',
                                endpoint_url="http://127.0.0.1:3001",
                                use_ssl=False,
                                verify=False,
                                config=Config(signature_version=UNSIGNED,
                                              read_timeout=1,
                                              retries={'max_attempts': 0}
                                              )
                               )
   lambda_client.invoke(FunctionName="HelloWorldFunction")
   ```

## 选项
<a name="using-sam-cli-local-start-lambda-options"></a>

### 指定模板
<a name="using-sam-cli-local-start-lambda-options-template"></a>

要为 AWS SAM CLI 指定要引用的模板，请使用 `--template` 选项。 AWS SAMCLI将只加载该 AWS SAM 模板及其指向的资源。以下是示例：

```
$ sam local start-lambda --template myTemplate.yaml
```

有关 AWS SAM 模板的更多信息，请参阅[AWS SAM 模板解剖学](sam-specification-template-anatomy.md)。

## 最佳实践
<a name="using-sam-cli-local-start-lambda-best"></a>

如果应用程序有无法运行 `sam build` 的 `.aws-sam` 目录，请务必在每次更新函数代码时都运行 `sam build`。然后，运行 `sam local start-lambda`，以在本地测试更新后的函数代码。

本地测试是部署到云中之前进行快速开发和测试的理想解决方案。但是，本地测试并不能验证所有内容，例如，不能验证云端资源之间的权限。尽可能在云端测试应用程序。我们建议[使用 `sam sync`](using-sam-cli-sync.md) 来加快云测试工作流程。

## 了解详情
<a name="using-sam-cli-local-start-lambda-learn"></a>

有关全部 `sam local start-lambda` 选项的列表，请参阅 [sam local start-lambda](sam-cli-command-reference-sam-local-start-lambda.md)。

# 使用本地调用 Lambda 函数 AWS SAM
<a name="serverless-sam-cli-using-invoke"></a>

在云中进行测试或部署之前本地调用 Lambda 函数可以带来多种好处。它允许您更快地测试函数的逻辑。首先本地测试可减少在云中测试或部署期间发现问题的可能性，从而帮助您避免不必要的成本。此外，本地测试使调试变得更加容易。

您可以通过使用 [sam local invoke](sam-cli-command-reference-sam-local-invoke.md) 命令并提供函数的逻辑 ID 和事件文件，在本地调用 Lambda 函数。**sam local invoke** 还接受 `stdin` 作为事件。有关事件的更多信息，请参阅*《AWS Lambda 开发人员指南》*中的[事件](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-event)。有关来自不同 AWS 服务的事件消息格式的信息，请参阅*《AWS Lambda 开发者指南*》中的[AWS Lambda 与其他服务一起使用](https://docs.aws.amazon.com/lambda/latest/dg/lambda-services.html)。

**注意**  
不建议在不受信任的代码中使用 SAM CLI 的本地调用功能。要与本地环境完全隔离，请直接在 Lambda 服务中执行代码。

**注意**  
该**sam local invoke**命令与 AWS Command Line Interface (AWS CLI) 命令相对应[https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/invoke.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/invoke.html)。您可以使用任一命令调用 Lambda 函数。

必须在包含要调用的函数的项目目录中运行 **sam local invoke** 命令。

 示例：

```
# Invoking function with event file
$ sam local invoke "Ratings" -e event.json

# Invoking function with event via stdin
$ echo '{"message": "Hey, are you there?" }' | sam local invoke --event - "Ratings"

# For more options
$ sam local invoke --help
```

## 环境变量文件
<a name="serverless-sam-cli-using-invoke-environment-file"></a>

要在本地声明可覆盖模板中定义的值的环境变量，请执行以下操作：

1. 创建包含要覆盖的环境变量的 JSON 或`.env`文件。

1. 使用 `--env-vars` 参数覆盖模板中定义的值。

该`--env-vars`选项支持两种文件格式。根据文件内容自动检测文件格式。

### 使用 JSON 声明环境变量
<a name="serverless-sam-cli-using-invoke-environment-file-declaring"></a>

要声明可全局应用于所有资源的环境变量，请如下所示指定 `Parameters` 对象：

```
{
    "Parameters": {
        "TABLE_NAME": "localtable",
        "BUCKET_NAME": "amzn-s3-demo-bucket",
        "STAGE": "dev"
    }
}
```

要为每个资源声明不同的环境变量，请如下所示为每个资源指定对象：

```
{
    "MyFunction1": {
        "TABLE_NAME": "localtable",
        "BUCKET_NAME": "amzn-s3-demo-bucket",
    },
    "MyFunction2": {
        "TABLE_NAME": "localtable",
        "STAGE": "dev"
    }
}
```

为每个资源指定对象时，可以使用以下标识符，这些标识符按优先级从高到低的顺序列出：

1. `logical_id`

1. `function_id`

1. `function_name`

1. 完整路径标识符

您可以在单个文件中结合使用上述两种声明环境变量的方法。如果这样做，您为特定资源提供的环境变量会优先于全局环境变量。

将环境变量保存在 JSON 文件中，例如 `env.json`。

### 使用.env 文件声明环境变量
<a name="serverless-sam-cli-using-invoke-environment-file-dotenv"></a>

您也可以使用`.env`文件来声明环境变量。`.env`文件中声明的变量全局应用于所有函数，相当于 JSON 格式的`Parameters`对象。

```
TABLE_NAME=localtable
BUCKET_NAME=amzn-s3-demo-bucket
STAGE=dev
```

该`.env`格式支持注释（以开头的行`#`）和带引号的值。

**注意**  
该`.env`格式仅支持全局环境变量。要声明特定于函数的环境变量，请使用 JSON 格式。

### 覆盖环境变量值
<a name="serverless-sam-cli-using-invoke-environment-file-override"></a>

要使用环境变量文件中定义的变量覆盖环境变量，请将`--env-vars`参数与**invoke**或**start-api**命令一起使用。例如：

```
# Using a JSON file
sam local invoke --env-vars env.json

# Using a .env file
sam local invoke --env-vars .env
```

## 图层
<a name="serverless-sam-cli-using-invoke-layers"></a>

如果应用程序包含层，有关如何在本地主机上调试层的问题，请参阅[使用带有 Lambda 层的 Lambda 层来提高效率 AWS SAM](serverless-sam-cli-layers.md)。

## 了解详情
<a name="serverless-sam-cli-using-invoke-learn"></a>

有关在本地调用函数的动手示例，请参阅*完整 AWS SAM 研讨会*中的[模块 2-本地运行](https://s12d.com/sam-ws-en-local)。

# 在本地运行 API Gateway AWS SAM
<a name="serverless-sam-cli-using-start-api"></a>

在本地运行 Amazon API Gateway 可以带来多种好处。例如，在本地运行 API Gateway 可以让您在部署到 AWS 云端之前在本地测试 API 端点。如果您先在本地测试，则通常可以减少在云中的测试和开发，从而有助于降低成本。此外，在本地运行使调试变得更加容易。

要启动可用于测试 HTTP 请求/响应功能的 API Gateway 本地实例，请使用命令。`sam local start-api` AWS SAMCLI此功能具有热重载功能，让您可以快速开发和迭代函数。

**注意**  
*热重载*是指只刷新已更改的文件，并且应用程序的状态保持不变。相比之下，*实时重载*是指刷新整个应用程序，并且应用程序的状态会丢失。

有关使用 `sam local start-api` 命令的说明，请参阅 [使用 sam local start-api 进行测试简介](using-sam-cli-local-start-api.md)。

默认情况下， AWS SAM 使用 AWS Lambda 代理集成，同时支持两种`HttpApi``Api`资源类型。有关`HttpApi`资源类型的代理集成的更多信息，请参阅《*API Gateway 开发者*指南》 APIs中的[使用 HTTP 的 AWS Lambda 代理集成](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html)。有关代理与 `Api` 资源类型集成的更多信息，请参阅*《API Gateway 开发人员指南》*中的[理解 API Gateway Lambda 代理集成](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-create-api-as-simple-proxy)。

**示例**：

```
$ sam local start-api
```

AWS SAM 自动查找 AWS SAM 模板中已定义`HttpApi`或`Api`事件源的所有函数。然后，它将函数挂载在定义的 HTTP 路径中。

在以下 `Api` 示例中，对于 `GET` 请求，`Ratings` 函数将在 `/ratings` 中挂载 `ratings.py:handler()`：

```
Ratings:
  Type: AWS::Serverless::Function
  Properties:
    Handler: ratings.handler
    Runtime: python3.9
    Events:
      Api:
        Type: Api
        Properties:
          Path: /ratings
          Method: get
```

以下是 `Api` 响应示例：

```
// Example of a Proxy Integration response
exports.handler = (event, context, callback) => {
    callback(null, {
        statusCode: 200,
        headers: { "x-custom-header" : "my custom header value" },
        body: "hello world"
    });
}
```

如果您修改了函数的代码，请对 `sam local start-api` 运行 `sam build` 命令以检测您的更改。

## 环境变量文件
<a name="serverless-sam-cli-using-start-api-environment-variable"></a>

要在本地声明可覆盖模板中定义的值的环境变量，请执行以下操作：

1. 创建包含要覆盖的环境变量的 JSON 文件。

1. 使用 `--env-vars` 参数覆盖模板中定义的值。

### 声明环境变量
<a name="serverless-sam-cli-using-invoke-environment-file-declaring"></a>

要声明可全局应用于所有资源的环境变量，请如下所示指定 `Parameters` 对象：

```
{
    "Parameters": {
        "TABLE_NAME": "localtable",
        "BUCKET_NAME": "amzn-s3-demo-bucket",
        "STAGE": "dev"
    }
}
```

要为每个资源声明不同的环境变量，请如下所示为每个资源指定对象：

```
{
    "MyFunction1": {
        "TABLE_NAME": "localtable",
        "BUCKET_NAME": "amzn-s3-demo-bucket",
    },
    "MyFunction2": {
        "TABLE_NAME": "localtable",
        "STAGE": "dev"
    }
}
```

为每个资源指定对象时，可以使用以下标识符，这些标识符按优先级从高到低的顺序列出：

1. `logical_id`

1. `function_id`

1. `function_name`

1. 完整路径标识符

您可以在单个文件中结合使用上述两种声明环境变量的方法。如果这样做，您为特定资源提供的环境变量会优先于全局环境变量。

将环境变量保存在 JSON 文件中，例如 `env.json`。

### 覆盖环境变量值
<a name="serverless-sam-cli-using-start-api-environment-file-override"></a>

要用 JSON 文件中定义的变量覆盖环境变量，请将 `--env-vars` 参数与 **invoke** 或 **start-api** 命令一起使用。例如：

```
$ sam local start-api --env-vars env.json
```

## 图层
<a name="serverless-sam-cli-using-start-api-layers"></a>

如果应用程序包含层，有关如何在本地主机上调试层的问题，请参阅[使用带有 Lambda 层的 Lambda 层来提高效率 AWS SAM](serverless-sam-cli-layers.md)。

# 使用 sam remote test-event 进行云测试简介
<a name="using-sam-cli-remote-test-event"></a>

使用 AWS Serverless Application Model Command Line Interface (AWS SAM CLI) `sam remote test-event` 命令访问和管理 AWS Lambda 函数的可共享测试事件。

要了解有关可共享测试事件的更多信息，请参阅*《AWS Lambda 开发人员指南》*中的[可共享测试事件](https://docs.aws.amazon.com/lambda/latest/dg/testing-functions.html#creating-shareable-events)。

**Topics**
+ [设置 AWS SAM CLI 以使用 sam remote test-event](#using-sam-cli-remote-test-event-setup)
+ [使用 sam remote test-event 命令](#using-sam-cli-remote-test-event-use)
+ [使用可共享测试事件](#using-sam-cli-remote-test-event-invoke)
+ [管理可共享测试事件](#using-sam-cli-remote-test-event-manage)

## 先决条件
<a name="using-sam-cli-remote-test-event-prerequisites"></a>

要使用 `sam remote test-event`，请完成以下操作安装 AWS SAM CLI：
+ [AWS SAM 先决条件](prerequisites.md).
+ [安装 AWS SAM CLI](install-sam-cli.md).

如果您已经 AWS SAM CLI安装了，我们建议您升级到该版本的最新 AWS SAMCLI版本。要了解更多信息，请参阅[升级 AWS SAM CLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade)。

我们建议您在使用 `sam remote test-event` 之前初步了解以下主题：
+ [配置 AWS SAM CLI](using-sam-cli-configure.md).
+ [在中创建您的应用程序 AWS SAM](using-sam-cli-init.md).
+ [搭建简介 AWS SAM](using-sam-cli-build.md).
+ [使用部署简介 AWS SAM](using-sam-cli-deploy.md).
+ [使用同步sam sync到的简介 AWS 云](using-sam-cli-sync.md).

## 设置 AWS SAM CLI 以使用 sam remote test-event
<a name="using-sam-cli-remote-test-event-setup"></a>

要使用该 AWS SAM CLI`sam remote test-event`命令，请完成以下设置步骤：

1. **配置 AWS SAM CLI为使用你的 AWS 账户** — Lambda 的可共享测试事件可以由用户访问和管理 Lambda 中的可共享测试事件。 AWS 账户要将配置 AWS SAM CLI为使用你的 AWS 账户，请参阅[配置 AWS SAM CLI](using-sam-cli-configure.md)。

1. **为可共享的测试事件配置权限** – 要访问和管理可共享的测试事件，您必须具有适当的权限。要了解更多信息，请参阅*《AWS Lambda 开发人员指南》*中的[可共享测试事件](https://docs.aws.amazon.com/lambda/latest/dg/testing-functions.html#creating-shareable-events)。

## 使用 sam remote test-event 命令
<a name="using-sam-cli-remote-test-event-use"></a>

该 AWS SAM CLI`sam remote test-event`命令提供以下子命令，您可以使用这些子命令来访问和管理可共享的测试事件：
+ `delete`— 从 Amazon EventBridge 架构注册表中删除可共享的测试事件。
+ `get`— 从 EventBridge 架构注册表中获取可共享的测试事件。
+ `list`— 列出 EventBridge 架构注册表中某个函数的现有可共享测试事件。
+ `put`— 将事件从本地文件保存到 EventBridge 架构注册表。

要使用列出这些子命令 AWS SAM CLI，请运行以下命令：

```
$ sam remote test-event --help
```

### 删除可共享测试事件
<a name="using-sam-cli-remote-test-event-use-delete"></a>

您可以使用 `delete` 子命令以及以下操作来删除可共享的测试事件：
+ 提供要删除的可共享测试事件的名称。
+ 提供与事件关联的 Lambda 函数的可接受 ID。
+ 如果您要提供 Lambda 函数逻辑 ID，则还必须提供与 Lambda 函数关联的 AWS CloudFormation 堆栈名称。

以下是示例：

```
$ sam remote test-event delete HelloWorldFunction --stack-name sam-app --name demo-event
```

有关与 `delete` 子命令配合使用的选项列表，请参见 [sam remote test-event delete](sam-cli-command-reference-remote-test-event-delete.md)。您也可以从中运行以下命令 AWS SAM CLI：

```
$ sam remote test-event delete --help
```

### 获取可共享测试事件
<a name="using-sam-cli-remote-test-event-use-get"></a>

您可以使用`get`子命令以及以下命令从 EventBridge 架构注册表中获取可共享的测试事件：
+ 提供要获取的可共享测试事件的名称。
+ 提供与事件关联的 Lambda 函数的可接受 ID。
+ 如果您要提供 Lambda 函数逻辑 ID，则还必须提供与 Lambda 函数关联的 AWS CloudFormation 堆栈名称。

以下是获取名为 `demo-event` 的可共享测试事件的示例，该事件与 `sam-app` 堆栈的 `HelloWorldFunction` Lambda 函数相关联。此命令会将事件打印到您的控制台。

```
$ sam remote test-event get HelloWorldFunction --stack-name sam-app --name demo-event
```

要获取可共享的测试事件并将其保存到本地计算机，请使用 `--output-file` 选项并提供文件路径和名称。以下是将 `demo-event` 作为 `demo-event.json` 保存于当前工作目录的示例：

```
$ sam remote test-event get HelloWorldFunction --stack-name sam-app --name demo-event --output-file demo-event.json
```

有关与 `get` 子命令配合使用的选项列表，请参见 [sam remote test-event get](sam-cli-command-reference-remote-test-event-get.md)。您也可以从中运行以下命令 AWS SAM CLI：

```
$ sam remote test-event get --help
```

### 列出可共享测试事件
<a name="using-sam-cli-remote-test-event-use-list"></a>

您可以从架构注册表中列出特定 Lambda 函数的所有可共享测试事件。使用 `list` 子命令和以下操作：
+ 提供与事件关联的 Lambda 函数的可接受 ID。
+ 如果您要提供 Lambda 函数逻辑 ID，则还必须提供与 Lambda 函数关联的 CloudFormation 堆栈名称。

以下是获取与 `sam-app` 堆栈的 `HelloWorldFunction` Lambda 函数关联的所有可共享测试事件列表的示例：

```
$ sam remote test-event list HelloWorldFunction --stack-name sam-app
```

有关与 `list` 子命令配合使用的选项列表，请参见 [sam remote test-event list](sam-cli-command-reference-remote-test-event-list.md)。您也可以从中运行以下命令 AWS SAM CLI：

```
$ sam remote test-event list --help
```

### 保存可共享测试事件
<a name="using-sam-cli-remote-test-event-use-put"></a>

您可以将可共享的测试事件保存到 EventBridge 架构注册表中。使用 `put` 子命令和以下操作：
+ 提供与可共享测试事件关联的 Lambda 函数的可接受的 ID。
+ 提供可共享测试事件的名称。
+ 为要上传的本地事件提供文件路径和名称。

以下是将本地 `demo-event.json` 事件另存为 `demo-event` 并将其与 `sam-app` 堆栈的 `HelloWorldFunction` Lambda 函数关联的示例：

```
$ sam remote test-event put HelloWorldFunction --stack-name sam-app --name demo-event --file demo-event.json
```

如果 EventBridge 架构注册表中存在同名的可共享测试事件，则 AWS SAM CLI不会将其覆盖。要覆盖，请向您的命令添加 `--force` 选项。

有关与 `put` 子命令配合使用的选项列表，请参见 [sam remote test-event put](sam-cli-command-reference-remote-test-event-put.md)。您也可以从中运行以下命令 AWS SAM CLI：

```
$ sam remote test-event put --help
```

## 使用可共享测试事件
<a name="using-sam-cli-remote-test-event-invoke"></a>

使用可共享的测试事件通过命令在中 AWS 云 测试您的 Lambda 函数。`sam remote invoke`要了解更多信息，请参阅[将可共享的测试事件传递给云端的 Lambda 函数](using-sam-cli-remote-invoke.md#using-sam-cli-remote-invoke-shareable)。

## 管理可共享测试事件
<a name="using-sam-cli-remote-test-event-manage"></a>

本主题包含有关如何管理和使用可共享测试事件的示例。

### 获取可共享的测试事件，对其进行修改并使用
<a name="using-sam-cli-remote-test-event-manage-example1"></a>

您可以从 EventBridge 架构注册表中获取可共享的测试事件，在本地对其进行修改，然后将本地测试事件与您的 Lambda 函数一起使用。 AWS 云以下是示例：

1. **检索可共享的测试事件** – 使用 `sam remote test-event get` 子命令检索特定 Lambda 函数的可共享测试事件并将其保存在本地：

   ```
   $ sam remote test-event get HelloWorldFunction --stack-name sam-app --name demo-event --output-file demo-event.json
   ```

1. **修改可共享的测试事件** – 使用您选择的文本编辑器修改可共享的测试事件。

1. **使用可共享的测试事件** – 使用 `sam remote invoke` 命令并通过 `--event-file` 提供事件的文件路径和名称：

   ```
   $ sam remote invoke HelloWorldFunction --stack-name sam-app --event-file demo-event.json
   ```

### 获取可共享的测试事件，对其进行修改，上传并使用
<a name="using-sam-cli-remote-test-event-manage-example2"></a>

您可以从 EventBridge 架构注册表中获取可共享的测试事件，在本地对其进行修改，然后将其上传。然后，您可以将可共享的测试事件直接传递给 AWS 云中的 Lambda 函数。以下是示例：

1. **检索可共享的测试事件** – 使用 `sam remote test-event get` 子命令检索特定 Lambda 函数的可共享测试事件并将其保存在本地：

   ```
   $ sam remote test-event get HelloWorldFunction --stack-name sam-app --name demo-event --output-file demo-event.json
   ```

1. **修改可共享的测试事件** – 使用您选择的文本编辑器修改可共享的测试事件。

1. **上传可共享的测试事件**-使用`sam remote test-event put`子命令将可共享的测试事件上传并保存到架构注册表。 EventBridge 在此示例中，我们使用 `--force` 选项来覆盖可共享测试的旧版本：

   ```
   $ sam remote test-event put HelloWorldFunction --stack-name sam-app --name demo-event --file demo-event.json --force
   ```

1. **将可共享的测试事件传递给 Lambda 函数** – 使用 `sam remote invoke` 命令将可共享的测试事件直接传递给 AWS 云中的 Lambda 函数：

   ```
   $ sam remote invoke HelloWorldFunction --stack-name sam-app --test-event-name demo-event
   ```

# 使用 sam remote invoke 在云中测试简介
<a name="using-sam-cli-remote-invoke"></a>

使用 AWS Serverless Application Model 命令行界面 (AWS SAM CLI) `sam remote invoke` 命令与中支持的 AWS 资源进行交互 AWS 云。您可使用 `sam remote invoke` 调用以下资源：
+ **Amazon Kinesis Data Streams** – 向 Kinesis Data Streams 应用程序发送数据记录。
+ **AWS Lambda** – 调用事件并将其传递给 Lambda 函数。
+ **Amazon Simple Queue Service (Amazon SQS)** – 将消息发送到 Amazon SQS 队列。
+ **AWS Step Functions** – 调用 Step Functions 状态机以开始执行。

有关简介 AWS SAMCLI，请参阅 [那是什么 AWS SAMCLI？](what-is-sam-overview.md#what-is-sam-cli)

有关在典型开发工作流程中使用 `sam remote invoke` 的示例，请参阅[第 5 步：在中与你的函数进行交互 AWS 云](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-remote-invoke)。

**Topics**
+ [使用 sam remote invoke 命令](#using-sam-cli-remote-invoke-use)
+ [使用 sam remote invoke 命令选项](#using-sam-cli-remote-invoke-options)
+ [配置您的项目配置文件](#using-sam-cli-remote-invoke-configure)
+ [示例](#using-sam-cli-remote-invoke-examples)
+ [相关链接](#using-sam-cli-remote-invoke-links)

## 先决条件
<a name="using-sam-cli-remote-invoke-prerequisites"></a>

要使用 `sam remote invoke`，请完成以下操作安装 AWS SAM CLI：
+ [AWS SAM 先决条件](prerequisites.md).
+ [安装 AWS SAM CLI](install-sam-cli.md).

我们还建议升级到最新版本的 AWS SAMCLI。要了解更多信息，请参阅[升级 AWS SAM CLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade)。

我们建议您在使用 `sam remote invoke` 之前初步了解以下主题：
+ [配置 AWS SAM CLI](using-sam-cli-configure.md).
+ [在中创建您的应用程序 AWS SAM](using-sam-cli-init.md).
+ [搭建简介 AWS SAM](using-sam-cli-build.md).
+ [使用部署简介 AWS SAM](using-sam-cli-deploy.md).
+ [使用同步sam sync到的简介 AWS 云](using-sam-cli-sync.md).

## 使用 sam remote invoke 命令
<a name="using-sam-cli-remote-invoke-use"></a>

在使用此命令之前，必须将您的资源部署到 AWS 云。

使用以下命令结构并从项目根目录运行：

```
$ sam remote invoke <arguments> <options>
```

**注意**  
此页将显示在命令提示符处提供的选项。您也可以在项目的配置文件中配置选项，而不必在命令提示符下传递这些选项。要了解更多信息，[配置项目设置](using-sam-cli-configure.md#using-sam-cli-configure-project)。

有关 `sam remote invoke` 参数和选项的说明，请参阅 [sam remote invoke](sam-cli-command-reference-remote-invoke.md)。

### 使用 Kinesis Data Streams
<a name="using-sam-cli-remote-invoke-use-kinesis"></a>

您可以将数据记录发送到 Kinesis Data Streams 应用程序。 AWS SAM CLI将发送您的数据记录并返回分片 ID 和序列号。以下是示例：

```
$ sam remote invoke KinesisStream --stack-name kinesis-example --event hello-world
	
	Putting record to Kinesis data stream KinesisStream                                                             
	Auto converting value 'hello-world' into JSON '"hello-world"'. If you don't want auto-conversion, please provide
	a JSON string as event                                                                                          
	{
	  "ShardId": "shardId-000000000000",
	  "SequenceNumber": "49646251411914806775980850790050483811301135051202232322"
	}%
```

**发送数据记录**

1. 提供资源 ID 值作为 Kinesis Data Streams 应用程序的参数。有关有效资源的信息 IDs，请参阅[资源 ID](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id)。

1. 提供数据记录作为事件发送到 Kinesis Data Streams 应用程序。您可以使用 `--event` 选项在命令行中提供事件，也可以使用 `--event-file` 从文件中提供事件。如果您不提供事件，则会 AWS SAM CLI发送一个空事件。

### 与 Lambda 函数一起使用
<a name="using-sam-cli-remote-invoke-use-lambda"></a>

您可以在云中调用 Lambda 函数并传递空事件，或者在命令行或文件中提供事件。 AWS SAM CLI将调用您的 Lambda 函数并返回其响应。以下是示例：

```
$ sam remote invoke HelloWorldFunction --stack-name sam-app

Invoking Lambda Function HelloWorldFunction                                       
START RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9 Version: $LATEST
END RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9
REPORT RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9  Duration: 6.62 ms       Billed Duration: 7 ms     Memory Size: 128 MB     Max Memory Used: 67 MB  Init Duration: 164.06 ms
{"statusCode":200,"body":"{\"message\":\"hello world\"}"}%
```

**要调用 Lambda 函数**

1. 提供资源 ID 值作为 Lambda 函数的参数。有关有效资源的信息 IDs，请参阅[资源 ID](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id)。

1. 提供向 Lambda 函数发送的事件。您可以使用 `--event` 选项在命令行中提供事件，也可以使用 `--event-file` 从文件中提供事件。如果您不提供事件，则会 AWS SAM CLI发送一个空事件。

#### 配置了响应流式处理的 Lambda 函数
<a name="using-sam-cli-remote-invoke-invoke-stream"></a>

`sam remote invoke` 命令支持配置为流式传输响应的 Lambda 函数。您可以使用模板中的`FunctionUrlConfig`属性配置 Lambda 函数以流式传输响应。 AWS SAM 使用时 `sam remote invoke`， AWS SAM CLI 将自动检测您的 Lambda 配置并通过响应流式处理进行调用。

有关示例，请参阅[调用配置为流式传输响应的 Lambda 函数](#using-sam-cli-remote-invoke-examples-lambda-stream)。

#### 将可共享的测试事件传递给云端的 Lambda 函数
<a name="using-sam-cli-remote-invoke-shareable"></a>

可共享测试事件是您可与同一 AWS 账户中的其他人共享的测试事件。要了解更多信息，请参阅*《AWS Lambda 开发人员指南》*中的[可共享测试事件](https://docs.aws.amazon.com/lambda/latest/dg/testing-functions.html#creating-shareable-events)。

##### 访问和管理可共享测试事件
<a name="using-sam-cli-remote-invoke-shareable-access"></a>

您可以使用 AWS SAM CLI`sam remote test-event`命令来访问和管理可共享的测试事件。例如，您可以使用 `sam remote test-event` 来执行以下操作：
+ 从 Amazon EventBridge 架构注册表中检索可共享的测试事件。
+ 在本地修改可共享的测试事件并将其上传到 EventBridge 架构注册表。
+ 从 EventBridge 架构注册表中删除可共享的测试事件。

要了解更多信息，请参阅[使用 sam remote test-event 进行云测试简介](using-sam-cli-remote-test-event.md)。

##### 将可共享的测试事件传递给云中的 Lambda 函数
<a name="using-sam-cli-remote-invoke-shareable-pass"></a>

要将可共享的测试事件从 EventBridge 架构注册表传递到云中的 Lambda 函数，请使用`--test-event-name`选项并提供可共享测试事件的名称。以下是示例：

```
$ sam remote invoke HelloWorldFunction --stack-name sam-app --test-event-name demo-event
```

如果将可共享的测试事件保存在本地，则可以使用 `--event-file` 选项并提供本地测试事件的文件路径和名称。以下是示例：

```
$ sam remote invoke HelloWorldFunction --stack-name sam-app --event-file demo-event.json
```

### 将 与 Amazon SQS 结合使用
<a name="using-sam-cli-remote-invoke-use-sqs"></a>

您可以向 Amazon SQS 队列发送消息。 AWS SAM CLI返回以下内容：
+ 消息 ID
+ MD5 的邮件正文
+ 响应元数据

 以下是示例：

```
$ sam remote invoke MySqsQueue --stack-name sqs-example -event hello

Sending message to SQS queue MySqsQueue                                                                         
{
  "MD5OfMessageBody": "5d41402abc4b2a76b9719d911017c592",
  "MessageId": "05c7af65-9ae8-4014-ae28-809d6d8ec652"
}%
```

**发送邮件**

1. 提供资源 ID 值作为 Amazon SQS 队列的参数。有关有效资源的信息 IDs，请参阅[资源 ID](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id)。

1. 提供要发送给 Amazon SQS 队列的事件。您可以使用 `--event` 选项在命令行中提供事件，也可以使用 `--event-file` 从文件中提供事件。如果您不提供事件，则会 AWS SAM CLI发送一个空事件。

### 使用 Step Functions
<a name="using-sam-cli-remote-invoke-use-sf"></a>

您可调用 Step Functions 状态机以开始执行。 AWS SAM CLI将等待状态机工作流程完成并返回执行最后一步的输出。以下是示例：

```
$ sam remote invoke HelloWorldStateMachine --stack-name state-machine-example --event '{"is_developer": true}'

Invoking Step Function HelloWorldStateMachine                                                                   
"Hello Developer World"%
```

**要调用状态机**

1. 为 Step Functions 状态机提供一个资源 ID 值作为参数。有关有效资源的信息 IDs，请参阅[资源 ID](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id)。

1. 提供要发送到状态机的事件。您可以使用 `--event` 选项在命令行中提供事件，也可以使用 `--event-file` 从文件中提供事件。如果您不提供事件，则会 AWS SAM CLI发送一个空事件。

## 使用 sam remote invoke 命令选项
<a name="using-sam-cli-remote-invoke-options"></a>

本节介绍一些可用于 `sam remote invoke` 命令的主要选项。有关选项的完整列表，请参阅 [sam remote invoke](sam-cli-command-reference-remote-invoke.md)。

### 将活动传递给您的资源
<a name="using-sam-cli-remote-invoke-options-event"></a>

使用以下选项将事件传递给云中的资源：
+ `--event` – 在命令行传递事件。
+ `--event-file` – 从文件传递事件。

#### Lambda 示例
<a name="using-sam-cli-remote-invoke-options-event-lambda-examples"></a>

**使用 `--event` 在命令行中将事件作为字符串值传递：**

```
$ sam remote invoke HelloWorldFunction --stack-name sam-app --event '{"message": "hello!"}'

Invoking Lambda Function HelloWorldFunction                                                                                                                                                                                                                     
START RequestId: b992292d-1fac-4aa2-922a-c9dc5c6fceab Version: $LATEST
END RequestId: b992292d-1fac-4aa2-922a-c9dc5c6fceab
REPORT RequestId: b992292d-1fac-4aa2-922a-c9dc5c6fceab  Duration: 16.41 ms      Billed Duration: 17 ms  Memory Size: 128 MB     Max Memory Used: 67 MB  Init Duration: 185.96 ms
{"statusCode":200,"body":"{\"message\":\"hello!\"}"}%
```

**使用 `--event-file` 从文件传递事件并提供文件路径：**

```
$ cat event.json
			
{"message": "hello from file"}%    
			
$ sam remote invoke HelloWorldFunction --stack-name sam-app --event-file event.json       

Invoking Lambda Function HelloWorldFunction                                                                                                                                                                                                                     
START RequestId: 3bc71f7d-153a-4b1e-8c9a-901d91b1bec9 Version: $LATEST
END RequestId: 3bc71f7d-153a-4b1e-8c9a-901d91b1bec9
REPORT RequestId: 3bc71f7d-153a-4b1e-8c9a-901d91b1bec9  Duration: 21.15 ms      Billed Duration: 22 ms  Memory Size: 128 MB     Max Memory Used: 67 MB
{"statusCode":200,"body":"{\"message\":\"hello from file\"}"}%
```

**使用 `stdin` 传递事件：**

```
$ cat event.json
			
{"message": "hello from file"}%    
                                                                       
$ cat event.json | sam remote invoke HelloWorldFunction --stack-name sam-app --event-file -

Reading event from stdin (you can also pass it from file with --event-file)                               
Invoking Lambda Function HelloWorldFunction                                                               
START RequestId: 85ecc902-8ad0-4a2b-a8c8-9bb4f65f5a7a Version: $LATEST
END RequestId: 85ecc902-8ad0-4a2b-a8c8-9bb4f65f5a7a
REPORT RequestId: 85ecc902-8ad0-4a2b-a8c8-9bb4f65f5a7a  Duration: 1.36 ms       Billed Duration: 2 ms   Memory Size: 128 MB       Max Memory Used: 67 MB
{"statusCode":200,"body":"{\"message\":\"hello from file\"}"}%
```

### 配置 AWS SAM CLI 响应输出
<a name="using-sam-cli-remote-invoke-options-output"></a>

当您使用 `sam remote invoke` 调用支持的资源时， AWS SAM CLI 会返回包含以下内容的响应：
+ **请求元数据** – 与请求关联的元数据。这包括请求 ID 和请求开始时间。
+ **资源响应** – 在云中被调用后来自资源的响应。

您可以使用该`--output`选项来配置 AWS SAM CLI输出响应。以下选项值可用：
+ `json` – 元数据和资源响应以 JSON 结构返回。响应包含完整 SDK 输出。
+ `text` – 元数据以文本结构返回。资源响应以资源的输出格式返回。

下面是 `json` 输出的一个示例。

```
$ sam remote invoke --stack-name sam-app --output json

Invoking Lambda Function HelloWorldFunction                                                                                                                                                                                                                     
{
  "ResponseMetadata": {
    "RequestId": "3bdf9a30-776d-4a90-94a6-4cccc0fc7b41",
    "HTTPStatusCode": 200,
    "HTTPHeaders": {
      "date": "Mon, 19 Jun 2023 17:15:46 GMT",
      "content-type": "application/json",
      "content-length": "57",
      "connection": "keep-alive",
      "x-amzn-requestid": "3bdf9a30-776d-4a90-94a6-4cccc0fc7b41",
      "x-amzn-remapped-content-length": "0",
      "x-amz-executed-version": "$LATEST",
      "x-amz-log-result": "U1RBUlQgUmVxdWVzdElkOiAzYmRmOWEzMC03NzZkLTRhOTAtOTRhNi00Y2NjYzBmYzdiNDEgVmVyc2lvbjogJExBVEVTVApFTkQgUmVxdWVzdElkOiAzYmRmOWEzMC03NzZkLTRhOTAtOTRhNi00Y2NjYzBmYzdiNDEKUkVQT1JUIFJlcXVlc3RJZDogM2JkZjlhMzAtNzc2ZC00YTkwLTk0YTYtNGNjY2MwZmM3YjQxCUR1cmF0aW9uOiA4LjIzIG1zCUJpbGxlZCBEdXJhdGlvbjogOSBtcwlNZW1vcnkgU2l6ZTogMTI4IE1CCU1heCBNZW1vcnkgVXNlZDogNjggTUIJCg==",
      "x-amzn-trace-id": "root=1-64908d42-17dab270273fcc6b527dd6b8;sampled=0;lineage=2301f8dc:0"
    },
    "RetryAttempts": 0
  },
  "StatusCode": 200,
  "LogResult": "U1RBUlQgUmVxdWVzdElkOiAzYmRmOWEzMC03NzZkLTRhOTAtOTRhNi00Y2NjYzBmYzdiNDEgVmVyc2lvbjogJExBVEVTVApFTkQgUmVxdWVzdElkOiAzYmRmOWEzMC03NzZkLTRhOTAtOTRhNi00Y2NjYzBmYzdiNDEKUkVQT1JUIFJlcXVlc3RJZDogM2JkZjlhMzAtNzc2ZC00YTkwLTk0YTYtNGNjY2MwZmM3YjQxCUR1cmF0aW9uOiA4LjIzIG1zCUJpbGxlZCBEdXJhdGlvbjogOSBtcwlNZW1vcnkgU2l6ZTogMTI4IE1CCU1heCBNZW1vcnkgVXNlZDogNjggTUIJCg==",
  "ExecutedVersion": "$LATEST",
  "Payload": "{\"statusCode\":200,\"body\":\"{\\\"message\\\":\\\"hello world\\\"}\"}"
}%
```

当您指定 `json` 输出时，整个响应将返回到 `stdout`。以下是示例：

```
$ sam remote invoke --stack-name sam-app --output json 1> stdout.log

Invoking Lambda Function HelloWorldFunction           
                                                                                                                                                                                                          
$ cat stdout.log
			
{
  "ResponseMetadata": {
    "RequestId": "d30d280f-8188-4372-bc94-ce0f1603b6bb",
    "HTTPStatusCode": 200,
    "HTTPHeaders": {
      "date": "Mon, 19 Jun 2023 17:35:56 GMT",
      "content-type": "application/json",
      "content-length": "57",
      "connection": "keep-alive",
      "x-amzn-requestid": "d30d280f-8188-4372-bc94-ce0f1603b6bb",
      "x-amzn-remapped-content-length": "0",
      "x-amz-executed-version": "$LATEST",
      "x-amz-log-result": "U1RBUlQgUmVxdWVzdElkOiBkMzBkMjgwZi04MTg4LTQzNzItYmM5NC1jZTBmMTYwM2I2YmIgVmVyc2lvbjogJExBVEVTVApFTkQgUmVxdWVzdElkOiBkMzBkMjgwZi04MTg4LTQzNzItYmM5NC1jZTBmMTYwM2I2YmIKUkVQT1JUIFJlcXVlc3RJZDogZDMwZDI4MGYtODE4OC00MzcyLWJjOTQtY2UwZjE2MDNiNmJiCUR1cmF0aW9uOiA0LjE2IG1zCUJpbGxlZCBEdXJhdGlvbjogNSBtcwlNZW1vcnkgU2l6ZTogMTI4IE1CCU1heCBNZW1vcnkgVXNlZDogNjcgTUIJSW5pdCBEdXJhdGlvbjogMTU4LjM5IG1zCQo=",
      "x-amzn-trace-id": "root=1-649091fc-771473c7778689627a6122b7;sampled=0;lineage=2301f8dc:0"
    },
    "RetryAttempts": 0
  },
  "StatusCode": 200,
  "LogResult": "U1RBUlQgUmVxdWVzdElkOiBkMzBkMjgwZi04MTg4LTQzNzItYmM5NC1jZTBmMTYwM2I2YmIgVmVyc2lvbjogJExBVEVTVApFTkQgUmVxdWVzdElkOiBkMzBkMjgwZi04MTg4LTQzNzItYmM5NC1jZTBmMTYwM2I2YmIKUkVQT1JUIFJlcXVlc3RJZDogZDMwZDI4MGYtODE4OC00MzcyLWJjOTQtY2UwZjE2MDNiNmJiCUR1cmF0aW9uOiA0LjE2IG1zCUJpbGxlZCBEdXJhdGlvbjogNSBtcwlNZW1vcnkgU2l6ZTogMTI4IE1CCU1heCBNZW1vcnkgVXNlZDogNjcgTUIJSW5pdCBEdXJhdGlvbjogMTU4LjM5IG1zCQo=",
  "ExecutedVersion": "$LATEST",
  "Payload": "{\"statusCode\":200,\"body\":\"{\\\"message\\\":\\\"hello world\\\"}\"}"
}%
```

下面是 `text` 输出的一个示例。

```
$ sam remote invoke --stack-name sam-app --output text

Invoking Lambda Function HelloWorldFunction                                                                                                                                                                                                                     
START RequestId: 4dbacc43-1ec6-47c2-982b-9dc4620144d6 Version: $LATEST
END RequestId: 4dbacc43-1ec6-47c2-982b-9dc4620144d6
REPORT RequestId: 4dbacc43-1ec6-47c2-982b-9dc4620144d6  Duration: 9.13 ms       Billed Duration: 10 ms  Memory Size: 128 MB     Max Memory Used: 67 MB  Init Duration: 165.50 ms
{"statusCode":200,"body":"{\"message\":\"hello world\"}"}%
```

当您指定 `text` 输出时，Lambda 函数运行时系统输出（例如日志）将返回到 `stderr`。Lambda 函数的有效负载将返回到 `stdout`。以下是示例：

```
$ sam remote invoke --stack-name sam-app --output text 2> stderr.log

{"statusCode":200,"body":"{\"message\":\"hello world\"}"}% 
                                                                                                                                                                                                     
$ cat stderr.log

Invoking Lambda Function HelloWorldFunction
START RequestId: 82273c3b-aa3a-4d16-8f1c-1d2ad3ace891 Version: $LATEST
END RequestId: 82273c3b-aa3a-4d16-8f1c-1d2ad3ace891
REPORT RequestId: 82273c3b-aa3a-4d16-8f1c-1d2ad3ace891  Duration: 40.62 ms      Billed Duration: 41 ms  Memory Size: 128 MB     Max Memory Used: 68 MB

$ sam remote invoke --stack-name sam-app --output text 1> stdout.log
 
Invoking Lambda Function HelloWorldFunction                                                                                                                                                                                                                     
START RequestId: 74acaa9f-5b80-4a5c-b3b8-ffaccb84cbbd Version: $LATEST
END RequestId: 74acaa9f-5b80-4a5c-b3b8-ffaccb84cbbd
REPORT RequestId: 74acaa9f-5b80-4a5c-b3b8-ffaccb84cbbd  Duration: 2.31 ms       Billed Duration: 3 ms   Memory Size: 128 MB     Max Memory Used: 67 MB

$ cat stdout.log

{"statusCode":200,"body":"{\"message\":\"hello world\"}"}%
```

### 自定义 Boto3 参数
<a name="using-sam-cli-remote-invoke-options-boto3"></a>

对于`sam remote invoke`， AWS SAM CLI利用适用于 Python 的 AWS SDK (Boto3) 与你的云端资源进行交互。您可以使用 `--parameter` 选项自定义 Boto3 参数。有关可自定义受支持的参数的列表，请参阅 `--parameter`。

#### 示例
<a name="using-sam-cli-remote-invoke-options-boto3-examples"></a>

**调用 Lambda 函数来验证参数值并验证权限：**

```
$ sam remote invoke HelloWorldFunction --stack-name sam-app --parameter InvocationType="DryRun"
```

**在单个命令中多次使用 `--parameter` 选项以提供多个参数：**

```
$ sam remote invoke HelloWorldFunction --stack-name sam-app --parameter InvocationType="Event" --parameter LogType="None"
```

### 其他选项
<a name="using-sam-cli-remote-invoke-options-other"></a>

有关 `sam remote invoke` 选项的完整列表，请参阅 [sam remote invoke](sam-cli-command-reference-remote-invoke.md)。

## 配置您的项目配置文件
<a name="using-sam-cli-remote-invoke-configure"></a>

要在配置文件中配置 `sam remote invoke`，请在表中使用 `remote_invoke`。以下是配置 `sam remote invoke` 命令默认值的 `samconfig.toml` 文件示例。

```
...
version =0.1

[default]
...
[default.remote_invoke.parameters]
stack_name = "cloud-app"
event = '{"message": "Hello!"}'
```

## 示例
<a name="using-sam-cli-remote-invoke-examples"></a>

有关使用的基本示例`sam remote invoke`，请参阅 C *AWS ompute 博客*中的[使用 AWS SAM 远程测试 AWS Lambda 函数](https://aws.amazon.com/blogs/compute/testing-aws-lambda-functions-with-aws-sam-remote-invoke/)。

### Kinesis Data Streams 示例
<a name="using-sam-cli-remote-invoke-examples-kinesis"></a>

#### 基本示例
<a name="using-sam-cli-remote-invoke-examples-kinesis-basic"></a>

**将数据记录从文件发送到 Kinesis Data Streams 应用程序。Kinesis Data Streams 应用程序是通过提供资源 ID 的 ARN 来识别的：**

```
$ sam remote invoke arn:aws:kinesis:us-west-2:01234567890:stream/kinesis-example-KinesisStream-BgnLcAey4xUQ --event-file event.json
```

**将命令行中提供的事件发送到 Kinesis Data Streams 应用程序：**

```
$ sam remote invoke KinesisStream --stack-name kinesis-example --event hello-world

Putting record to Kinesis data stream KinesisStream                                                             
Auto converting value 'hello-world' into JSON '"hello-world"'. If you don't want auto-conversion, please provide
a JSON string as event                                                                                          
{
  "ShardId": "shardId-000000000000",
  "SequenceNumber": "49646251411914806775980903986194508740483329854174920706"
}%
```

**获取 Kinesis Data Streams 应用程序的物理 ID。然后，在命令行中提供一个事件：**

```
$ sam list resources --stack-name kinesis-example --output json

[
  {
    "LogicalResourceId": "KinesisStream",
    "PhysicalResourceId": "kinesis-example-KinesisStream-ZgnLcQey4xUQ"
  }
]

$ sam remote invoke kinesis-example-KinesisStream-ZgnLcQey4xUQ --event hello

Putting record to Kinesis data stream KinesisStream                                                             
Auto converting value 'hello' into JSON '"hello"'. If you don't want auto-conversion, please provide a JSON     
string as event                                                                                                 
{
  "ShardId": "shardId-000000000000",
  "SequenceNumber": "49646251411914806775980904340716841045751814812900261890"
}%
```

**在命令行中提供一个 JSON 字符串作为事件：**

```
$ sam remote invoke KinesisStream --stack-name kinesis-example --event '{"method": "GET", "body": ""}'                      

Putting record to Kinesis data stream KinesisStream                                                             
{
  "ShardId": "shardId-000000000000",
  "SequenceNumber": "49646251411914806775980904492868617924990209230536441858"
}%
```

**向 Kinesis Data Streams 应用程序发送一个空事件：**

```
$ sam remote invoke KinesisStream --stack-name kinesis-example

Putting record to Kinesis data stream KinesisStream                                                             
{
  "ShardId": "shardId-000000000000",
  "SequenceNumber": "49646251411914806775980904866469008589597168190416224258"
}%
```

**以 JSON 格式返回 AWS SAM CLI响应：**

```
$ sam remote invoke KinesisStream --stack-name kinesis-example --event '{"hello": "world"}' --output json

Putting record to Kinesis data stream KinesisStream                                                             
{
  "ShardId": "shardId-000000000000",
  "SequenceNumber": "49646251411914806775980905078409420803696667195489648642",
  "ResponseMetadata": {
    "RequestId": "ebbbd307-3e9f-4431-b67c-f0715e9e353e",
    "HTTPStatusCode": 200,
    "HTTPHeaders": {
      "x-amzn-requestid": "ebbbd307-3e9f-4431-b67c-f0715e9e353e",
      "x-amz-id-2": "Q3yBcgTwtPaQTV26IKclbECmZikUYOzKY+CzcxA84ZHgCkc5T2N/ITWg6RPOQcWw8Gn0tNPcEJBEHyVVqboJAPgCritqsvCu",
      "date": "Thu, 09 Nov 2023 18:13:10 GMT",
      "content-type": "application/x-amz-json-1.1",
      "content-length": "110"
    },
    "RetryAttempts": 0
  }
}%
```

**将 JSON 输出返回到标准输出：**

```
$ sam remote invoke KinesisStream --stack-name kinesis-example --event '{"hello": "world"}' --output json 1> stdout.log

Putting record to Kinesis data stream KinesisStream                                                             

$ cat stdout.log
{
  "ShardId": "shardId-000000000000",
  "SequenceNumber": "49646251411914806775980906397777867595039988349006774274",
  "ResponseMetadata": {
    "RequestId": "f4290006-d84b-b1cd-a9ee-28306eeb2939",
    "HTTPStatusCode": 200,
    "HTTPHeaders": {
      "x-amzn-requestid": "f4290006-d84b-b1cd-a9ee-28306eeb2939",
      "x-amz-id-2": "npCqz+IBKpoL4sQ1ClbUmxuJlbeA24Fx1UgpIrS6mm2NoIeV2qdZSN5AhNurdssykXajBrXaC9anMhj2eG/h7Hnbf+bPuotU",
      "date": "Thu, 09 Nov 2023 18:33:26 GMT",
      "content-type": "application/x-amz-json-1.1",
      "content-length": "110"
    },
    "RetryAttempts": 0
  }
}%
```

### Lambda 示例
<a name="using-sam-cli-remote-invoke-examples-lambda"></a>

#### 基本示例
<a name="using-sam-cli-remote-invoke-examples-lambda-basic"></a>

**通过提供 ARN 作为资源 ID 来调用 Lambda 函数：**

```
$ sam remote invoke arn:aws:lambda:us-west-2:012345678910:function:sam-app-HelloWorldFunction-ohRFEn2RuAvp
```

**通过提供逻辑 ID 作为资源 ID 来调用 Lambda 函数：**

您还必须使用`--stack-name`选项提供 CloudFormation 堆栈名称。以下是示例：

```
$ sam remote invoke HelloWorldFunction --stack-name sam-app
```

如果应用程序包含单个 Lambda 函数，则无需指定其逻辑 ID。您只能提供 `--stack-name` 选项。以下是示例：

```
$ sam remote invoke --stack-name sam-app
```

**通过提供物理 ID 作为资源 ID 来调用 Lambda 函数：**

物理 ID 是在使用进行部署时创建 CloudFormation的。

```
$ sam remote invoke sam-app-HelloWorldFunction-TZvxQRFNv0k4
```

**调用子堆栈的 Lambda 函数：**

在本示例中，应用程序包含以下目录结构：

```
lambda-example
├── childstack
│   ├── function
│   │   ├── __init__.py
│   │   ├── app.py
│   │   └── requirements.txt
│   └── template.yaml
├── events
│   └── event.json
├── samconfig.toml
└── template.yaml
```

要调用 `childstack` 的 Lambda 函数，我们运行以下命令：

```
$ sam remote invoke ChildStack/HelloWorldFunction --stack-name lambda-example

Invoking Lambda Function HelloWorldFunction                                                                     
START RequestId: 207a864b-e67c-4307-8478-365b004d4bcd Version: $LATEST
END RequestId: 207a864b-e67c-4307-8478-365b004d4bcd
REPORT RequestId: 207a864b-e67c-4307-8478-365b004d4bcd  Duration: 1.27 ms       Billed Duration: 2 ms   Memory Size: 128 MB     Max Memory Used: 36 MB  Init Duration: 111.07 ms
{"statusCode": 200, "body": "{\"message\": \"Hello\", \"received_event\": {}}"}%
```

#### 调用配置为流式传输响应的 Lambda 函数
<a name="using-sam-cli-remote-invoke-examples-lambda-stream"></a>

在此示例中，我们使用 AWS SAM CLI 来初始化一个新的无服务器应用程序，其包含配置为流式传输其响应的 Lambda 函数。我们将应用程序部署到 AWS 云 并使用与我们在云中的功能进行交互。`sam remote invoke`

我们首先运行 `sam init` 命令来创建新的无服务器应用程序。我们选择 **Lambda 响应流**快速入门模板并命名我们的应用程序。**lambda-streaming-nodejs-app**

```
$ sam init
	
	You can preselect a particular runtime or package type when using the `sam init` experience.
	Call `sam init --help` to learn more.
	
	Which template source would you like to use?
	        1 - AWS Quick Start Templates
	        2 - Custom Template Location
	Choice: 1
	
	Choose an AWS Quick Start application template
	        1 - Hello World Example
	        ...
	        9 - Lambda Response Streaming
	        ...
	        15 - Machine Learning
	Template: 9
	
	Which runtime would you like to use?
	        1 - go (provided.al2)
	        2 - nodejs18.x
	        3 - nodejs16.x
	Runtime: 2
	
	Based on your selections, the only Package type available is Zip.
	We will proceed to selecting the Package type as Zip.
	
	Based on your selections, the only dependency manager available is npm.
	We will proceed copying the template using npm.
	
	Would you like to enable X-Ray tracing on the function(s) in your application?  [y/N]: ENTER
	
	Would you like to enable monitoring using CloudWatch Application Insights?
	For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER
	
	Project name [sam-app]: lambda-streaming-nodejs-app
	
	    -----------------------
	    Generating application:
	    -----------------------
	    Name: lambda-streaming-nodejs-app
	    Runtime: nodejs18.x
	    Architectures: x86_64
	    Dependency Manager: npm
	    Application Template: response-streaming
	    Output Directory: .
	    Configuration file: lambda-streaming-nodejs-app/samconfig.toml
	    
	    Next steps can be found in the README file at lambda-streaming-nodejs-app/README.md
	        
	
	Commands you can use next
	=========================
	[*] Create pipeline: cd lambda-streaming-nodejs-app && sam pipeline init --bootstrap
	[*] Validate SAM template: cd lambda-streaming-nodejs-app && sam validate
	[*] Test Function in the Cloud: cd lambda-streaming-nodejs-app && sam sync --stack-name {stack-name} --watch
```

使用以下结构 AWS SAMCLI创建我们的项目：

```
lambda-streaming-nodejs-app
	├── README.md
	├── __tests__
	│   └── unit
	│       └── index.test.js
	├── package.json
	├── samconfig.toml
	├── src
	│   └── index.js
	└── template.yaml
```

以下是 Lambda 函数代码的示例：

```
exports.handler = awslambda.streamifyResponse(
	  async (event, responseStream, context) => {
	    const httpResponseMetadata = {
	      statusCode: 200,
	      headers: {
	        "Content-Type": "text/html",
	        "X-Custom-Header": "Example-Custom-Header"
	      }
	    };
	
	    responseStream = awslambda.HttpResponseStream.from(responseStream, httpResponseMetadata);
	    // It's recommended to use a `pipeline` over the `write` method for more complex use cases.
	    // Learn more: https://docs.aws.amazon.com/lambda/latest/dg/configuration-response-streaming.html
	    responseStream.write("<html>");
	    responseStream.write("<p>First write!</p>");
	
	    responseStream.write("<h1>Streaming h1</h1>");
	    await new Promise(r => setTimeout(r, 1000));
	    responseStream.write("<h2>Streaming h2</h2>");
	    await new Promise(r => setTimeout(r, 1000));
	    responseStream.write("<h3>Streaming h3</h3>");
	    await new Promise(r => setTimeout(r, 1000));
	
	    // Long strings will be streamed
	    const loremIpsum1 = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque vitae mi tincidunt tellus ultricies dignissim id et diam. Morbi pharetra eu nisi et finibus. Vivamus diam nulla, vulputate et nisl cursus, pellentesque vehicula libero. Cras imperdiet lorem ante, non posuere dolor sollicitudin a. Vestibulum ipsum lacus, blandit nec augue id, lobortis dictum urna. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Morbi auctor orci eget tellus aliquam, non maximus massa porta. In diam ante, pulvinar aliquam nisl non, elementum hendrerit sapien. Vestibulum massa nunc, mattis non congue vitae, placerat in quam. Nam vulputate lectus metus, et dignissim erat varius a.";
	    responseStream.write(`<p>${loremIpsum1}</p>`);
	    await new Promise(r => setTimeout(r, 1000));
	
	    responseStream.write("<p>DONE!</p>");
	    responseStream.write("</html>");
	    responseStream.end();
	  }
	);
```

以下是 `template.yaml` 文件的示例。Lambda 函数的响应流式传输是使用 `FunctionUrlConfig` 属性配置的。

```
AWSTemplateFormatVersion: '2010-09-09'
	Transform: AWS::Serverless-2016-10-31
	
	Description: >
	  Sample SAM Template for lambda-streaming-nodejs-app
	  
	Resources:
	  StreamingFunction:
	    Type: AWS::Serverless::Function
	    Properties:
	      CodeUri: src/
	      Handler: index.handler
	      Runtime: nodejs18.x
	      Architectures:
	        - x86_64
	      Timeout: 10
	      FunctionUrlConfig:
	        AuthType: AWS_IAM
	        InvokeMode: RESPONSE_STREAM
	
	Outputs:
	  StreamingFunction:
	    Description: "Streaming Lambda Function ARN"
	    Value: !GetAtt StreamingFunction.Arn
	  StreamingFunctionURL:
	    Description: "Streaming Lambda Function URL"
	    Value: !GetAtt StreamingFunctionUrl.FunctionUrl
```

通常，您可以使用 `sam build` 和 `sam deploy --guided` 来构建和部署生产应用程序。在此示例中，我们将假设开发环境并使用 `sam sync` 命令来构建和部署应用程序。

**注意**  
建议在开发环境中使用 `sam sync` 命令。要了解更多信息，请参阅[使用同步sam sync到的简介 AWS 云](using-sam-cli-sync.md)。

在运行 `sam sync` 之前，我们会验证 `samconfig.toml` 文件中的项目是否配置正确。最重要的是，我们会验证 `stack_name` 和 `watch` 的值。在配置文件中指定了这些值后，我们就不必在命令行中提供它们了。

```
version = 0.1
	
	[default]
	[default.global.parameters]
	stack_name = "lambda-streaming-nodejs-app"
	
	[default.build.parameters]
	cached = true
	parallel = true
	
	[default.validate.parameters]
	lint = true
	
	[default.deploy.parameters]
	capabilities = "CAPABILITY_IAM"
	confirm_changeset = true
	resolve_s3 = true
	s3_prefix = "lambda-streaming-nodejs-app"
	region = "us-west-2"
	image_repositories = []
	
	[default.package.parameters]
	resolve_s3 = true
	
	[default.sync.parameters]
	watch = true
	
	[default.local_start_api.parameters]
	warm_containers = "EAGER"
	
	[default.local_start_lambda.parameters]
	warm_containers = "EAGER"
```

接下来，我们运行 `sam sync` 来构建和部署应用程序。由于 `--watch` 选项是在我们的配置文件中配置的，因此 AWS SAM CLI 将构建应用程序、部署应用程序并注意更改。

```
$ sam sync
	
	The SAM CLI will use the AWS Lambda, Amazon API Gateway, and AWS StepFunctions APIs to upload your code   
	without                                                                                                   
	performing a CloudFormation deployment. This will cause drift in your CloudFormation stack.               
	**The sync command should only be used against a development stack**.                                     
	                                                                                                          
	Queued infra sync. Waiting for in progress code syncs to complete...                                      
	Starting infra sync.                                                                                      
	Building codeuri:                                                                                         
	/Users/.../lambda-streaming-nodejs-app/src runtime: nodejs18.x metadata: {} architecture: x86_64 functions: StreamingFunction  
	package.json file not found. Continuing the build without dependencies.                                   
	Running NodejsNpmBuilder:CopySource                                                                       
	
	Build Succeeded
	
	Successfully packaged artifacts and wrote output template to file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpavrzdhgp.
	Execute the following command to deploy the packaged template
	sam deploy --template-file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpavrzdhgp --stack-name <YOUR STACK NAME>
	
	
	        Deploying with following values
	        ===============================
	        Stack name                   : lambda-streaming-nodejs-app
	        Region                       : us-west-2
	        Disable rollback             : False
	        Deployment s3 bucket         : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
	        Capabilities                 : ["CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"]
	        Parameter overrides          : {}
	        Signing Profiles             : null
	
	Initiating deployment
	=====================
	
	
	2023-06-20 12:11:16 - Waiting for stack create/update to complete
	
	CloudFormation events from stack operations (refresh every 0.5 seconds)
	-----------------------------------------------------------------------------------------------------
	ResourceStatus            ResourceType              LogicalResourceId         ResourceStatusReason    
	-----------------------------------------------------------------------------------------------------
	CREATE_IN_PROGRESS        AWS::CloudFormation::St   lambda-streaming-         Transformation          
	                          ack                       nodejs-app                succeeded               
	CREATE_IN_PROGRESS        AWS::IAM::Role            StreamingFunctionRole     -                       
	CREATE_IN_PROGRESS        AWS::CloudFormation::St   AwsSamAutoDependencyLay   -                       
	                          ack                       erNestedStack                                     
	CREATE_IN_PROGRESS        AWS::IAM::Role            StreamingFunctionRole     Resource creation       
	                                                                              Initiated               
	CREATE_IN_PROGRESS        AWS::CloudFormation::St   AwsSamAutoDependencyLay   Resource creation       
	                          ack                       erNestedStack             Initiated               
	CREATE_COMPLETE           AWS::IAM::Role            StreamingFunctionRole     -                       
	CREATE_COMPLETE           AWS::CloudFormation::St   AwsSamAutoDependencyLay   -                       
	                          ack                       erNestedStack                                     
	CREATE_IN_PROGRESS        AWS::Lambda::Function     StreamingFunction         -                       
	CREATE_IN_PROGRESS        AWS::Lambda::Function     StreamingFunction         Resource creation       
	                                                                              Initiated               
	CREATE_COMPLETE           AWS::Lambda::Function     StreamingFunction         -                       
	CREATE_IN_PROGRESS        AWS::Lambda::Url          StreamingFunctionUrl      -                       
	CREATE_IN_PROGRESS        AWS::Lambda::Url          StreamingFunctionUrl      Resource creation       
	                                                                              Initiated               
	CREATE_COMPLETE           AWS::Lambda::Url          StreamingFunctionUrl      -                       
	CREATE_COMPLETE           AWS::CloudFormation::St   lambda-streaming-         -                       
	                          ack                       nodejs-app                                        
	-----------------------------------------------------------------------------------------------------
	
	CloudFormation outputs from deployed stack
	-------------------------------------------------------------------------------------------------------
	Outputs                                                                                               
	-------------------------------------------------------------------------------------------------------
	Key                 StreamingFunction                                                                 
	Description         Streaming Lambda Function ARN                                                     
	Value               arn:aws:lambda:us-west-2:012345678910:function:lambda-streaming-nodejs-app-       
	StreamingFunction-gUmhO833A0vZ                                                                        
	
	Key                 StreamingFunctionURL                                                              
	Description         Streaming Lambda Function URL                                                     
	Value               https://wxgkcc2dyntgtrwhf2dgdcvylu0rnnof.lambda-url.us-west-2.on.aws/             
	-------------------------------------------------------------------------------------------------------
	
	                                                                                                          
	Stack creation succeeded. Sync infra completed.                                                           
	                                                                                                          
	Infra sync completed.
```

现在函数已经部署到云端，我们可以使用 `sam remote invoke` 与函数进行交互。 AWS SAM CLI 自动检测到函数已配置为响应流式传输，并立即开始实时输出函数的流式响应。

```
$ sam remote invoke StreamingFunction
	
	Invoking Lambda Function StreamingFunction                                              
	{"statusCode":200,"headers":{"Content-Type":"text/html","X-Custom-Header":"Example-Custom-Header"}}<html><p>First write!</p><h1>Streaming h1</h1><h2>Streaming h2</h2><h3>Streaming h3</h3><p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque vitae mi tincidunt tellus ultricies dignissim id et diam. Morbi pharetra eu nisi et finibus. Vivamus diam nulla, vulputate et nisl cursus, pellentesque vehicula libero. Cras imperdiet lorem ante, non posuere dolor sollicitudin a. Vestibulum ipsum lacus, blandit nec augue id, lobortis dictum urna. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Morbi auctor orci eget tellus aliquam, non maximus massa porta. In diam ante, pulvinar aliquam nisl non, elementum hendrerit sapien. Vestibulum massa nunc, mattis non congue vitae, placerat in quam. Nam vulputate lectus metus, et dignissim erat varius a.</p><p>DONE!</p></html>START RequestId: 1e4cdf04-60de-4769-b3a2-c1481982deb4 Version: $LATEST
	END RequestId: 1e4cdf04-60de-4769-b3a2-c1481982deb4
	REPORT RequestId: 1e4cdf04-60de-4769-b3a2-c1481982deb4  Duration: 4088.66 ms    Billed Duration: 4089 ms        Memory Size: 128 MB     Max Memory Used: 68 MB  Init Duration: 168.45 ms
```

当我们修改函数代码时， AWS SAM CLI 会立即检测并立即部署我们的更改。以下是对函数代码进行更改后的 AWS SAM CLI 输出示例：

```
Syncing Lambda Function StreamingFunction...                                             
	Building codeuri:                                                                        
	/Users/.../lambda-streaming-nodejs-app/src runtime: nodejs18.x metadata: {} architecture:    
	x86_64 functions: StreamingFunction                                                      
	package.json file not found. Continuing the build without dependencies.                  
	Running NodejsNpmBuilder:CopySource                                                      
	Finished syncing Lambda Function StreamingFunction.                                      
	Syncing Layer StreamingFunctione9cfe924DepLayer...                                       
	SyncFlow [Layer StreamingFunctione9cfe924DepLayer]: Skipping resource update as the      
	content didn't change                                                                    
	Finished syncing Layer StreamingFunctione9cfe924DepLayer.
```

现在，我们可以再次使用 `sam remote invoke` 与云端函数进行交互并测试我们的更改。

### SQS 示例
<a name="using-sam-cli-remote-invoke-examples-sqs"></a>

#### 基本示例
<a name="using-sam-cli-remote-invoke-examples-sqs-basic"></a>

**通过提供 ARN 作为资源 ID 来调用 Amazon SQS 队列：**

```
$ sam remote invoke arn:aws:sqs:us-west-2:01234567890:sqs-example-4DonhBsjsW1b --event '{"hello": "world"}' --output json

Sending message to SQS queue MySqsQueue                                                                         
{
  "MD5OfMessageBody": "49dfdd54b01cbcd2d2ab5e9e5ee6b9b9",
  "MessageId": "4f464cdd-15ef-4b57-bd72-3ad225d80adc",
  "ResponseMetadata": {
    "RequestId": "95d39377-8323-5ef0-9223-ceb198bd09bd",
    "HTTPStatusCode": 200,
    "HTTPHeaders": {
      "x-amzn-requestid": "95d39377-8323-5ef0-9223-ceb198bd09bd",
      "date": "Wed, 08 Nov 2023 23:27:26 GMT",
      "content-type": "application/x-amz-json-1.0",
      "content-length": "106",
      "connection": "keep-alive"
    },
    "RetryAttempts": 0
  }
}%
```

### Step Functions 示例
<a name="using-sam-cli-remote-invoke-examples-sf"></a>

#### 基本示例
<a name="using-sam-cli-remote-invoke-examples-sf-basic"></a>

**通过提供物理 ID 作为资源 ID 来调用状态机：**

首先，我们使用 `sam list resources` 来获取物理 ID：

```
$ sam list resources --stack-name state-machine-example --output json

[
  {
    "LogicalResourceId": "HelloWorldStateMachine",
    "PhysicalResourceId": "arn:aws:states:us-west-2:513423067560:stateMachine:HelloWorldStateMachine-z69tFEUx0F66"
  },
  {
    "LogicalResourceId": "HelloWorldStateMachineRole",
    "PhysicalResourceId": "simple-state-machine-HelloWorldStateMachineRole-PduA0BDGuFXw"
  }
]
```

接下来，我们使用物理 ID 作为资源 ID 来调用状态机。我们通过 `--event` 选项在命令行传递事件：

```
$ sam remote invoke arn:aws:states:us-west-2:01234567890:stateMachine:HelloWorldStateMachine-z69tFEUx0F66 --event '{"is_developer": true}'

Invoking Step Function arn:aws:states:us-west-2:01234567890:stateMachine:HelloWorldStateMachine-z69tFEUx0F66   
"Hello Developer World"%
```

**通过传递一个空事件来调用状态机：**

```
$ sam remote invoke HelloWorldStateMachine --stack-name state-machine-example

Invoking Step Function HelloWorldStateMachine                                                                   
"Hello World"%
```

## 相关链接
<a name="using-sam-cli-remote-invoke-links"></a>

有关`sam remote invoke`和使用的文档 AWS SAMCLI，请参阅以下内容：
+ [sam remote invoke](sam-cli-command-reference-remote-invoke.md)
+ [AWS SAM CLI 故障排除](sam-cli-troubleshooting.md)

# 使用自动执行本地集成测试 AWS SAM
<a name="serverless-sam-cli-using-automated-tests"></a>

虽然您可以使用[使用 sam local invoke 进行测试简介](using-sam-cli-local-invoke.md)手动测试代码，但 AWS SAM 也可以使用自动集成测试来测试代码。集成测试可帮助您在开发周期的早期发现问题，提高代码质量，节省时间，同时降低成本。

要在中创作自动集成测试 AWS SAM，您需要先对本地 Lambda 函数运行测试，然后再部署到云端。 AWS [使用 sam local start-lambda 进行测试简介](using-sam-cli-local-start-lambda.md) 命令启动模拟 Lambda 调用端点的本地端点。您可以从自动测试中调用它。由于此端点模拟 Lambda 调用端点，因此您可以编写一次测试并针对本地 Lambda 函数或部署的 Lambda 函数运行测试（无需做任何修改）。您也可以对 CI/CD 管道中已部署的 AWS SAM 堆栈运行相同的测试。

以下是此过程的工作原理：

1. 启动本地 Lambda 端点。

   通过在包含您的 AWS SAM 模板的目录中运行以下命令来启动本地 Lambda 终端节点：

   ```
   sam local start-lambda
   ```

   此命令在 `http://127.0.0.1:3001` 处启动模拟 AWS Lambda的本地端点。您可以针对此本地 Lambda 端点运行自动测试。当您使用 AWS CLI 或 SDK 调用此终端节点时，它会在本地执行请求中指定的 Lambda 函数并返回响应。

1. 针对本地 Lambda 端点运行集成测试。

   在集成测试中，您可以使用 AWS 软件开发工具包调用带有测试数据的 Lambda 函数，等待响应，然后验证响应是否符合您的预期。要本地运行集成测试，您应配置 AWS 软件开发工具包以发送 Lambda Invoke API 调用，以调用上一步中启动的本地 Lambda 端点。

   以下是 Python 示例（其他语言 AWS SDKs 的配置类似）：

   ```
   import boto3
   import botocore
   
   # Set "running_locally" flag if you are running the integration test locally
   running_locally = True
   
   if running_locally:
   
       # Create Lambda SDK client to connect to appropriate Lambda endpoint
       lambda_client = boto3.client('lambda',
           region_name="us-west-2",
           endpoint_url="http://127.0.0.1:3001",
           use_ssl=False,
           verify=False,
           config=botocore.client.Config(
               signature_version=botocore.UNSIGNED,
               read_timeout=15,
               retries={'max_attempts': 0},
           )
       )
   else:
       lambda_client = boto3.client('lambda')
   
   
   # Invoke your Lambda function as you normally usually do. The function will run
   # locally if it is configured to do so
   response = lambda_client.invoke(FunctionName="HelloWorldFunction")
   
   # Verify the response
   assert response == "Hello World"
   ```

   您可以将 `running_locally` 设置为 `False`，使用此代码来测试已部署的 Lambda 函数。这将设置要在 AWS 云端连接的 AWS SDK。 AWS Lambda 

# 使用生成示例事件有效负载 AWS SAM
<a name="serverless-sam-cli-using-generate-event"></a>

要测试您的 Lambda 函数，您可以生成和自定义示例事件负载，这些负载会模仿您的 Lambda 函数在其他服务触发时将收到的数据。 AWS 其中包括 API Gateway、 CloudFormation、Amazon S3 等服务。

生成示例事件有效载荷可帮助您使用各种不同的输入来测试 Lambda 函数的行为，而无需在实时环境中工作。与手动创建 AWS 服务事件样本来测试函数相比，这种方法还可以节省时间。

要查看可以为其生成示例事件负载的服务的完整列表，请使用以下命令：

```
sam local generate-event --help
```

要查看可用于特定服务的选项列表，请使用以下命令：

```
sam local generate-event [SERVICE] --help
```

示例：

```
#Generates the event from S3 when a new object is created
sam local generate-event s3 put

# Generates the event from S3 when an object is deleted
sam local generate-event s3 delete
```

# 测试和调试耐用函数
<a name="test-and-debug-durable-functions"></a>

本地测试和调试耐久函数的工作方式与常规 Lambda 函数类似，自动支持检查点和重播。本指南涵盖常见的测试场景和故障排除技术。

## 本地测试工作流程
<a name="test-and-debug-durable-functions-workflow"></a>

在本地测试耐久函数时，工作流程不同于常规 Lambda 函数：

**耐用功能测试工作流程**

1. 构建您的应用程序：

   ```
   $ sam build
   ```

1. 调用你的耐用函数：

   ```
   $ sam local invoke MyDurableFunction --durable-execution-name test 
   ```

1. 如有必要，请查看执行历史记录：

   ```
   $ sam local execution history execution-id
   ```

## 常见测试场景
<a name="test-and-debug-durable-functions-scenarios"></a>

### 测试检查点行为
<a name="test-and-debug-durable-functions-scenarios-checkpoints"></a>

要测试你的函数是否正确检查点状态，请执行以下操作：

```
# Example Python durable function
def handler(event, context):
    # This will create a checkpoint
    context.wait(10)  # Wait 10 seconds
    
    # Function resumes here after wait
    return {"message": "Function resumed after wait"}
```

当您在本地调用此函数时，会自动处理等待时间。

### 测试回调场景
<a name="test-and-debug-durable-functions-scenarios-callbacks"></a>

对于等待外部回调的函数：

1. 启动等待回调的耐用函数

1. 在另一个终端中，解析回调：

   ```
   $ sam local callback succeed callback-id
   ```

1. 观察函数恢复执行

## 问题排查
<a name="test-and-debug-durable-functions-troubleshooting"></a>

### 耐用函数无法正常执行
<a name="test-and-debug-durable-functions-troubleshooting-config"></a>

**问题：**该函数的行为不像一个持久的函数。

**解决方案**
+ 验证您`DurableConfig`的 SAM 模板中是否已设置
+ 确保您的函数代码使用耐用的函数 SDK 方法（例如`context.wait()`）
+ 检查你使用的是支持的运行时（TypeScript、 JavaScript、Python）

### 无法检索执行历史记录
<a name="test-and-debug-durable-functions-troubleshooting-history"></a>

**问题：**该`local execution history`命令未返回任何结果。

**解决方案**
+ 验证执行 ID 是否正确
+ 检查该函数是否至少被调用过一次

### 回调命令不起作用
<a name="test-and-debug-durable-functions-troubleshooting-callbacks"></a>

**问题：**回调命令无法解决待处理的操作。

**解决方案**
+ 验证回调 ID 是否正确
+ 确保该函数实际上是在等待回调
+ 验证您使用的回调命令语法是否正确

## 调试技巧
<a name="test-and-debug-durable-functions-debugging"></a>
+ **使用执行历史记录**-查看执行历史记录以了解持久函数的流程
+ **增量测试**-从简单的等待操作开始，然后再添加复杂的逻辑
+ **使用详细日志-启用详细日志**记录以跟踪执行流程

## 了解详情
<a name="test-and-debug-durable-functions-learn"></a>

有关测试和调试的更多信息，请参阅：
+ [使用 sam local invoke 进行测试简介](using-sam-cli-local-invoke.md)-本地调用文档
+ [sam local execution history](sam-cli-command-reference-sam-local-execution-history.md)-执行历史