

本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# 使用 測試無伺服器應用程式 AWS SAM
<a name="serverless-test-and-debug"></a>

在撰寫和建置您的應用程式之後，您將準備好測試您的應用程式，以驗證應用程式是否正常運作。使用 AWS SAM 命令列界面 (CLI)，您可以在本機測試無伺服器應用程式，然後再將其上傳至 AWS 雲端。測試應用程式可協助您確認應用程式的功能、可靠性和效能，同時識別需要解決的問題 （錯誤）。

本節提供您可以遵循以測試應用程式的常見實務指引。本節中的主題主要著重於在 AWS 雲端部署之前，您可以進行的本機測試。部署前的測試可協助您主動識別問題，減少與部署問題相關的不必要的成本。本節中的每個主題都說明您可以執行的測試、告知 yoxi 包含 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 Command Line Interface (AWS SAM CLI) `sam local`命令在本機測試無伺服器應用程式。

如需 的簡介 AWS SAM CLI，請參閱 [什麼是 AWS SAM CLI？](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 命令列界面 (AWS SAM CLI) `sam local generate-event`子命令來產生受支援的事件承載範例 AWS 服務。然後，您可以修改這些事件並將其傳遞至本機資源進行測試。
+ 如需 的簡介 AWS SAM CLI，請參閱 [什麼是 AWS SAM CLI？](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)。

*事件*是在 AWS 服務 執行動作或任務時產生的 JSON 物件。這些事件包含特定資訊，例如已處理的資料或事件的時間戳記。大多數 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 SAM CLI`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 以取得本機開發。在 上的 *Serverless Land Sessions 中使用 SAM 系列YouTube*測試來自本機開發環境 AWS 雲端 的資源](https://www.youtube.com/watch?v=NzPqMrdgD1s&list=PLJo-rJlep0ED198FJnTzhIB5Aut_1vDAd&index=24)。

# 使用 進行測試的簡介 sam local invoke
<a name="using-sam-cli-local-invoke"></a>

使用 AWS Serverless Application Model 命令列界面 (AWS SAM CLI) `sam local invoke`子命令在本機啟動 AWS Lambda 函數的一次性調用。
+ 如需 的簡介 AWS SAM CLI，請參閱 [什麼是 AWS SAM CLI？](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 SAM CLI 只會載入該 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 CLITerraform進行本機偵錯和測試](using-samcli-terraform.md)。

以下是範例：

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

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

如果您的應用程式有執行 的`.aws-sam`目錄`sam build`，請務必`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"
    }
}
```

接下來，我們會使用 `--env-vars`選項執行`sam local invoke`並傳入環境變數。

```
$ 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 以取得本機開發。在 上的 *Serverless Land Sessions 中使用 SAM 系列YouTube*測試來自本機開發環境 AWS 雲端 的資源](https://www.youtube.com/watch?v=NzPqMrdgD1s&list=PLJo-rJlep0ED198FJnTzhIB5Aut_1vDAd&index=24)。

# 使用 進行測試的簡介 sam local start-api
<a name="using-sam-cli-local-start-api"></a>

使用 AWS Serverless Application Model 命令列界面 (AWS SAM CLI) `sam local start-api`子命令在本機執行函數 AWS Lambda ，並透過本機 HTTP 伺服器主機進行測試。這種類型的測試對於 Amazon API Gateway 端點調用的 Lambda 函數很有幫助。
+ 如需 的簡介 AWS SAM CLI，請參閱 [什麼是 AWS SAM CLI？](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 本機 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. 會在本機Docker容器中建置 Lambda AWS SAM CLI函數。然後，它會輸出 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>

**注意**  
此功能是 1.80.0 版的新功能 AWS SAM CLI。若要升級，請參閱[升級 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 SAM CLI 只會載入該 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`子命令會使用 `localhost` IP 地址為 的 建立 HTTP 伺服器`127.0.0.1`。如果您的本機開發環境與本機電腦隔離，您可以自訂這些值。

使用 `--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>

如果您的應用程式有執行 的`.aws-sam`目錄`sam build`，請務必`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 SAM CLI子命令透過 AWS CLI 和 SDKs `sam local start-lambda` 叫用 Lambda 函數。此命令會啟動模擬 Lambda 的本機端點。
+ 如需 的簡介 AWS SAM CLI，請參閱 [什麼是 AWS SAM CLI？](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 本機 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. 會在本機Docker容器中建置 Lambda AWS SAM CLI函數。然後，它會將本機地址輸出到您的 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)
   ```

   以下是使用適用於 的 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 SAM CLI 只會載入該 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>

如果您的應用程式有執行 的`.aws-sam`目錄`sam build`，請務必`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>

如果您的應用程式包含 layer，如需如何偵錯本機主機上 layer 問題的相關資訊，請參閱 [透過 使用 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 可讓您在本機測試 API 端點，然後再部署到 AWS 雲端。如果您先在本機進行測試，通常可以減少雲端的測試和開發，這有助於降低成本。此外，在本機執行 可讓偵錯更容易。

若要啟動可用於測試 HTTP 請求/回應功能的 API Gateway 本機執行個體，請使用`sam local start-api` AWS SAM CLI命令。此功能具有熱重新載入功能，讓您可以快速開發和迭代函數。

**注意**  
*熱重新載入*是指只重新整理變更的檔案，且應用程式的狀態保持不變。相反地，*即時重新載入*是重新整理整個應用程式時，應用程式的狀態會遺失。

如需使用 `sam local start-api`命令的指示，請參閱 [使用 進行測試的簡介 sam local start-api](using-sam-cli-local-start-api.md)。

根據預設， AWS SAM 會使用 AWS Lambda 代理整合，並支援 `HttpApi`和 `Api` 資源類型。如需`HttpApi`資源類型的代理整合詳細資訊，請參閱*《 API Gateway 開發人員指南*》中的[使用 HTTP APIs 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`範例中， `Ratings`函數`ratings.py:handler()`會在 掛載`/ratings``GET`請求：

```
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 build`命令`sam local start-api`來偵測您的變更。

## 環境變數檔案
<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>

如果您的應用程式包含 layer，如需如何偵錯本機主機上 layer 問題的相關資訊，請參閱 [透過 使用 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 SAM CLI版本。如需詳細資訊，請參閱 [升級 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 的可共用測試事件可由相同 中的使用者存取和管理 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>

`sam remote test-event` 命令 AWS SAM CLI提供下列子命令，您可以使用這些子命令來存取和管理可共用的測試事件：
+ `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 雲端 透過 `sam remote invoke`命令在 中測試 Lambda 函數。如需詳細資訊，請參閱 [將可共用的測試事件傳遞至雲端中的 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 結構描述登錄檔取得可共用的測試事件，在本機進行修改並上傳。然後，您可以將可共用的測試事件直接傳遞至 中的 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 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`命令將可共用測試事件直接傳遞至 中的 Lambda 函數 AWS 雲端：

   ```
   $ 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 Command Line Interface (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 SAM CLI，請參閱 [什麼是 AWS SAM CLI？](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 遠端叫用命令](#using-sam-cli-remote-invoke-use)
+ [使用 sam 遠端叫用命令選項](#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 SAM CLI。如需詳細資訊，請參閱 [升級 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 遠端叫用命令
<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 函數並傳遞空事件，或在命令列或從檔案提供事件。將調用您的 Lambda AWS SAM CLI函數並傳回其回應。以下是範例：

```
$ 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 函數。您可以設定 Lambda 函數，使用 AWS SAM 範本中的 `FunctionUrlConfig` 屬性串流回應。當您使用 時`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. 提供資源 ID 值做為 Step Functions 狀態機器的引數。如需有效資源 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 遠端叫用命令選項
<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`中使用 。以下是`samconfig.toml`設定 `sam remote invoke`命令預設值的檔案範例。

```
...
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`，請參閱 *AWS 運算部落格*中的[使用 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"
}%
```

**以 AWS SAM CLI JSON 格式傳回回應：**

```
$ 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 輸出傳回 stdout：**

```
$ 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
```

若要叫用 的 Lambda 函數`childstack`，我們會執行下列動作：

```
$ 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 SAM CLI建立我們的專案：

```
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`檔案範例。使用 `FunctionUrlConfig` 屬性設定 Lambda 函數的回應串流。

```
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 SAM CLI，請參閱以下內容：
+ [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 SDK 來使用測試資料叫用 Lambda 函數、等待回應，並確認回應是您所預期的。若要在本機執行整合測試，您應該設定 AWS SDK 傳送 Lambda 調用 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`設定為 來測試已部署的 Lambda 函數`False`。這會將 AWS SDK 設定為在 AWS 雲端中連線至 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) - 執行歷史記錄