

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

# 使用 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)。