

翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# でサーバーレスアプリケーションをテストする AWS SAM
<a name="serverless-test-and-debug"></a>

アプリケーションを記述して構築したら、アプリケーションが正しく機能することをテストできます。 AWS SAM コマンドラインインターフェイス (CLI) を使用すると、サーバーレスアプリケーションを AWS クラウドにアップロードする前にローカルでテストできます。アプリケーションをテストすることで、アプリケーションの機能、信頼性、パフォーマンスをすべて確認しながら、対処する必要がある問題 (バグ) を特定できます。

このセクションでは、アプリケーションをテストするために実行できる一般的な方法に関するガイダンスを提供します。このセクションのトピックでは、主に AWS クラウドにデプロイする前に実行できるローカルテストに焦点を当てています。デプロイ前にテストを行うことで、問題を積極的に特定し、デプロイの問題に関連する不要なコストを削減するのに役立ちます。このセクションの各トピックでは、実行できるテストについて説明し、yoxi include href? と指示します。これを使用する利点と、テストの実行方法を示す例を示します。アプリケーションをテストすることで、見つかった問題をデバッグする準備が整います。

**Topics**
+ [sam local コマンドを使用したテストの概要](using-sam-cli-local.md)
+ [を使用して Lambda 関数をローカルに呼び出す AWS SAM](serverless-sam-cli-using-invoke.md)
+ [を使用して API Gateway をローカルで実行する AWS SAM](serverless-sam-cli-using-start-api.md)
+ [sam remote test-event を使用したクラウドテストの概要](using-sam-cli-remote-test-event.md)
+ [sam remote invoke を使用したクラウドでのテストの概要](using-sam-cli-remote-invoke.md)
+ [を使用してローカル統合テストを自動化する AWS SAM](serverless-sam-cli-using-automated-tests.md)
+ [を使用してサンプルイベントペイロードを生成する AWS SAM](serverless-sam-cli-using-generate-event.md)
+ [耐久性のある関数のテストとデバッグ](test-and-debug-durable-functions.md)

# sam local コマンドを使用したテストの概要
<a name="using-sam-cli-local"></a>

 AWS Serverless Application Model コマンドラインインターフェイス (AWS 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 関数の 1 回限りの呼び出しをローカルで開始します。
+ **[sam local start-api の概要](using-sam-cli-local-start-api.md)** – ローカル HTTP サーバーを使用して Lambda 関数を実行します。
+ **[sam local start-lambda の概要](using-sam-cli-local-start-lambda.md)** – AWS CLI または SDKs で使用するローカル HTTP サーバーを使用して Lambda 関数を実行します。

# 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 のサービス はイベントを生成し、各サービスのイベントはそのサービスに合わせて独自にフォーマットされます。

1 つのサービスによって生成されたイベントは、イベントソースとして他のサービスに渡されます。例えば、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>

`sam local generate-event` サブコマンドを使用して AWS SAM CLI、サポートされている のイベントを生成します 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 」を参照してください。での *SAM シリーズを使用した Serverless Land Sessions 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 関数の 1 回限りの呼び出しをローカルで開始します。
+ の概要については 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 関数をローカルでテストします。詳細については[Terraform と連携させた AWS SAM CLI をローカルでのデバッグおよびテストに使用する方法](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>

このアプリケーションには、Amazon DynamoDB テーブル名の環境変数を使用する Lambda 関数が含まれています。テンプレートで定義されている 関数の例を次に示します 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 」を参照してください。での *SAM シリーズを使用した Serverless Land Sessions 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`サブコマンドを使用して、関数をローカルで実行し、ローカル HTTP サーバーホストを介してテストします AWS Lambda 。このタイプのテストは、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 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 は、Lambda 関数をローカル Docker コンテナに構築します。その後、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 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` サブコマンドは 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>

アプリケーションに `.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`sam local start-lambda`、 AWS CLI および SDKs。このコマンドは、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 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 は、Lambda 関数をローカル Docker コンテナに構築します。その後、ローカルアドレスを 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 関数をローカルで呼び出すことには、まざまな利点があります。これにより、関数のロジックをより迅速にテストできます。最初にローカルでテストすることで、クラウドでのテスト時やデプロイ時に問題が見つかる可能性を低くでき、不要なコストを回避するのにも役立ちます。さらに、ローカルでテストすることでデバッグが楽になります。

Lambda 関数は、[sam local invoke](sam-cli-command-reference-sam-local-invoke.md) コマンドを使用して関数の論理 ID とイベントファイルを指定することによってローカルで呼び出せます。また、**sam local invoke** は `stdin` をイベントとして受け取ります。イベントの詳細については、*AWS Lambda デベロッパーガイド*の「[イベント](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-event)」を参照してください。さまざまな AWS サービスのイベントメッセージ形式の詳細については、「 *AWS Lambda デベロッパーガイド*」の[「Using AWS Lambda with other services](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` オプションは 2 つのファイル形式をサポートしています。ファイル形式は、ファイルの内容に基づいて自動的に検出されます。

### JSON を使用した環境変数の宣言
<a name="serverless-sam-cli-using-invoke-environment-file-declaring"></a>

すべてのリソースにグローバルに適用する環境変数を宣言するには、次のような `Parameters` オブジェクトを指定します。

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

各リソースごとに別々の環境変数を宣言するには、以下のようにリソースごとにオブジェクトを指定します。

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

各リソースのオブジェクトを指定する場合、以下の識別子を使用できます (優先順位の高いものから順にリストされています)。

1. `logical_id`

1. `function_id`

1. `function_name`

1. フルパス識別子

環境変数を宣言するための前述の両方の方法を単一のファイルで使用できます。その場合、特定のリソースに対して指定した環境変数がグローバル環境変数よりも優先されます。

環境変数を JSON ファイル (`env.json` など) に保存します。

### .env ファイルを使用した環境変数の宣言
<a name="serverless-sam-cli-using-invoke-environment-file-dotenv"></a>

`.env` ファイルを使用して環境変数を宣言することもできます。`.env` ファイルで宣言された変数は、JSON 形式の `Parameters` オブジェクトに相当するすべての関数にグローバルに適用されます。

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

`.env` 形式は、コメント ( で始まる行`#`) と引用符で囲まれた値をサポートします。

**注記**  
`.env` 形式はグローバル環境変数のみをサポートします。関数固有の環境変数を宣言するには、JSON 形式を使用します。

### 環境変数の値のオーバーライド
<a name="serverless-sam-cli-using-invoke-environment-file-override"></a>

環境変数を環境変数ファイルで定義された変数で上書きするには、 引`--env-vars`数を コマンド**invoke**または **start-api** コマンドで使用します。例えば、次のようになります。

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

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

## レイヤー
<a name="serverless-sam-cli-using-invoke-layers"></a>

アプリケーションにレイヤーが含まれている場合、ローカルホスト上のレイヤーの問題をデバッグする方法の詳細については、「[で Lambda レイヤーを使用して効率を向上させる AWS SAM](serverless-sam-cli-layers.md)」を参照してください。

## 詳細情報
<a name="serverless-sam-cli-using-invoke-learn"></a>

関数をローカルで呼び出す実践的な例については、*「 完全な AWS SAM ワークショップ*」の[「モジュール 2 - ローカルで実行する](https://s12d.com/sam-ws-en-local)」を参照してください。

# を使用して API Gateway をローカルで実行する AWS SAM
<a name="serverless-sam-cli-using-start-api"></a>

Amazon API Gateway をローカルで実行することには、さまざまな利点があります。例えば、API Gateway をローカルで実行すると、 AWS クラウドにデプロイする前に API エンドポイントをローカルでテストできます。最初にローカルでテストすれば、多くの場合クラウドでのテストと開発を減らすことができ、コスト削減に役立ちます。さらに、ローカルでの実行はデバッグを容易にします。

HTTP リクエスト/レスポンス機能のテストに使用できる API Gateway のローカルインスタンスを起動するには、 `sam local start-api` AWS SAM CLI コマンドを使用します。この機能にはホットリロードが搭載されているので、関数をすばやく開発して繰り返し実行することができます。

**注記**  
「ホットリロード」とは、変更されたファイルのみを更新し、アプリケーションの状態を維持することです。これに対して、「ライブリロード」では、アプリケーション全体が更新されるので、アプリケーションの状態が失われます。

`sam local start-api` コマンドを使用する手順については、「[sam local start-api を使用したテストの概要](using-sam-cli-local-start-api.md)」を参照してください。

デフォルトでは、 は AWS Lambda プロキシ統合 AWS SAM を使用し、 および `HttpApi``Api`リソースタイプの両方をサポートします。`HttpApi` リソースタイプのプロキシ統合の詳細については、*API Gateway デベロッパーガイド*の[「HTTP API の AWS Lambda プロキシ統合の使用 APIs](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 は、 `HttpApi`または `Api`イベントソースが定義されている AWS SAM テンプレート内の関数を自動的に検出します。関数は、定義された HTTP パスにマウントされます。

以下の `Api` 例では、`Ratings` 関数が `GET` リクエストの `/ratings` で `ratings.py:handler()` をマウントします。

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

以下は、`Api` レスポンスの例です。

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

関数のコードを変更する場合は、`sam 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>

アプリケーションにレイヤーが含まれている場合、ローカルホスト上のレイヤーの問題をデバッグする方法の詳細については、「[で 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 コマンドラインインターフェイス (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>

`sam remote test-event` コマンドを使用するには、以下のセットアップステップを実行します AWS SAM CLI。

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>

 AWS SAM CLI `sam remote test-event` コマンドには、共有可能なテストイベントにアクセスして管理するために使用できる以下のサブコマンドが用意されています。
+ `delete` — Amazon EventBridge スキーマレジストリから、共有可能なテストイベントを削除します。
+ `get` — EventBridge スキーマレジストリから共有可能なテストイベントを取得します。
+ `list` — EventBridge スキーマレジストリにある関数用の既存の共有可能なテストイベントを一覧表示します。
+ `put` — ローカルファイルのイベントを EventBridge スキーマレジストリに保存します。

を使用してこれらのサブコマンドを一覧表示するには AWS SAM CLI、以下を実行します。

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

### 共有可能なテストイベントを削除する
<a name="using-sam-cli-remote-test-event-use-delete"></a>

`delete` サブコマンドを以下と併せて使用することで、共有可能なテストイベントを削除できます。
+ 削除する共有可能なテストイベントの名前を指定します。
+ イベントに関連付けられた許容可能な Lambda 関数 ID を指定します。
+ Lambda 関数の論理 ID を指定する場合は、Lambda 関数に関連付けられた AWS CloudFormation スタック名も指定する必要があります。

以下に例を示します。

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

`delete` サブコマンドで使用するオプションのリストについては、「[sam remote test-event delete](sam-cli-command-reference-remote-test-event-delete.md)」を参照してください。以下を から実行することもできます AWS SAM CLI。

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

### 共有可能なテストイベントを取得する
<a name="using-sam-cli-remote-test-event-use-get"></a>

`get` サブコマンドを以下と併せて使用することで、EventBridge スキーマレジストリから共有可能なテストイベントを取得できます。
+ 取得する共有可能なテストイベントの名前を指定します。
+ イベントに関連付けられた許容可能な Lambda 関数 ID を指定します。
+ Lambda 関数の論理 ID を指定する場合は、Lambda 関数に関連付けられた AWS CloudFormation スタック名も指定する必要があります。

以下は、`sam-app` スタックの `HelloWorldFunction` Lambda 関数に関連付けられた `demo-event` という名前の共有可能なテストイベントを取得する例です。このコマンドでは、イベントをコンソールに出力します。

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

共有可能なテストイベントを使用して、 `sam remote invoke` コマンド AWS クラウド を使用して で 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 スキーマレジストリから共有可能なテストイベントを取得してローカルで変更し、そのローカルテストイベントを AWS クラウドの Lambda 関数で使用できます。以下に例を示します。

1. **共有可能なテストイベントを取得する** — `sam remote test-event get` サブコマンドを使用して、特定の Lambda 関数の共有可能なテストイベントを取得し、ローカルに保存します。

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

1. **共有可能なテストイベントを変更する** — 任意のテキストエディタを使用して、共有可能なテストイベントを変更します。

1. **共有可能なテストイベントを使用する** — `sam remote invoke` コマンドを使用して、`--event-file` でイベントのファイルパスと名前を指定します。

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

### 共有可能なテストイベントを取得し、変更、アップロード、使用する
<a name="using-sam-cli-remote-test-event-manage-example2"></a>

EventBridge スキーマレジストリから共有可能なテストイベントを取得し、ローカルで変更してアップロードできます。その後、共有可能なテストイベントを AWS クラウドの Lambda 関数に直接渡すことができます。以下に例を示します。

1. **共有可能なテストイベントを取得する** — `sam remote test-event get` サブコマンドを使用して、特定の Lambda 関数の共有可能なテストイベントを取得し、ローカルに保存します。

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

1. **共有可能なテストイベントを変更する** — 任意のテキストエディタを使用して、共有可能なテストイベントを変更します。

1. **共有可能なテストイベントをアップロードする** — `sam remote test-event put` サブコマンドを使用して、共有可能なテストイベントを EventBridge スキーマレジストリにアップロードして保存します。この例では、共有可能なテストの古いバージョンを上書きする `--force` オプションを使用しています。

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

1. **共有可能なテストイベントを Lambda 関数に渡す** — `sam remote invoke` コマンドを使用して、共有可能なテストイベントを AWS クラウドの Lambda 関数に直接渡します。

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

# sam remote invoke を使用したクラウドでのテストの概要
<a name="using-sam-cli-remote-invoke"></a>

 AWS Serverless Application Model コマンドラインインターフェイス (AWS SAM CLI) `sam remote invoke` コマンドを使用して、 でサポートされている AWS リソースを操作します AWS クラウド。`sam remote invoke` を使用して、次のリソースを呼び出します。
+ **Amazon Kinesis Data Streams** — Kinesis Data Streams アプリケーションにデータレコードを送信します。
+ **AWS Lambda** – イベントを呼び出して Lambda 関数に渡します。
+ **Amazon Simple Queue Service (Amazon SQS)** – Amazon SQS キューにメッセージを送信します。
+ **AWS Step Functions** – Step Functions ステートマシンを呼び出して実行を開始します。

の概要については AWS 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 remote invoke コマンドの使用](#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 remote invoke コマンドの使用
<a name="using-sam-cli-remote-invoke-use"></a>

このコマンドを使用する前に、リソースが AWS クラウドにデプロイされている必要があります。

次のコマンド構造を使用し、プロジェクトのルート ディレクトリから実行します。

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

**注記**  
このページでは、コマンドプロンプトで提供されるオプションについて説明します。オプションは、コマンドプロンプトで渡す代わりに、プロジェクトの設定ファイルで設定することもできます。詳細については、「[プロジェクト設定を構成する](using-sam-cli-configure.md#using-sam-cli-configure-project)」を参照してください。

`sam remote invoke` 引数とオプションの説明については、「[sam remote invoke](sam-cli-command-reference-remote-invoke.md)」を参照してください。

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

データレコードを Kinesis Data Streams アプリケーションに送信できます。 AWS SAM CLI はデータレコードを送信し、シャード ID とシーケンス番号を返します。以下に例を示します。

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

**データレコードを送信するには**

1. Kinesis Data Streams アプリケーションの引数としてリソース ID 値を指定します。有効なリソース ID については、「[リソース 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. Lambda 関数の引数としてリソース ID の値を指定します。有効なリソース ID については、「[リソース 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 関数をサポートします。 AWS SAM テンプレートの `FunctionUrlConfig`プロパティを使用してレスポンスをストリーミングするように Lambda 関数を設定できます。`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>

`sam remote test-event` コマンドを使用して AWS SAM CLI、共有可能なテストイベントにアクセスして管理できます。例えば、`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. Amazon SQS キューの引数としてリソース ID 値を指定します。有効なリソース ID については、「[リソース ID](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id)」を参照してください。

1. Amazon SQSキューに送信するイベントを指定します。イベントは、`--event` オプションを使用してコマンドラインで提供することも、`--event-file` を使用してファイルから提供することもできます。イベントを指定しない場合、 AWS SAM CLI は空のイベントを送信します。

### Step Functions を使って実行する
<a name="using-sam-cli-remote-invoke-use-sf"></a>

Step Functions ステート マシンを呼び出して実行を開始できます。 AWS SAM CLI はステートマシンワークフローが完了するのを待ち、実行の最後のステップの出力を返します。以下に例を示します。

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

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

**ステートマシンを呼び出すには**

1. Step Functions ステートマシンの引数としてリソース ID の値を指定します。有効なリソース ID については、「[リソース 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 SAMCLI レスポンス出力を設定します。
<a name="using-sam-cli-remote-invoke-options-output"></a>

`sam remote invoke` でサポートされているリソースをで呼び出すと、 AWS SAMCLI は次の内容を含むレスポンスを返します。
+ **リクエストメタデータ** – リクエストに関連するメタデータです。これには、リクエスト ID とリクエスト開始時間が含まれます。
+ **Resource Response** — クラウド内で呼び出された後のリソースからのレスポンスです。

`--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、 は AWS SDK for Python (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"
```

**1 つのコマンドで `--parameter` オプションを複数回使用して、複数のパラメータを指定することができます。**

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

### その他のオプション
<a name="using-sam-cli-remote-invoke-options-other"></a>

`sam remote invoke` オプションの完全なリストについては、「[sam remote invoke](sam-cli-command-reference-remote-invoke.md)」を参照してください。

## プロジェクト設定ファイルを設定する
<a name="using-sam-cli-remote-invoke-configure"></a>

設定ファイルで `sam remote invoke` を設定するには、テーブルで `remote_invoke` を使用します。以下は、`sam remote invoke` コマンドのデフォルト値を設定する `samconfig.toml` ファイルの例です。

```
...
version =0.1

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

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

を使用する基本的な例については`sam remote invoke`、 *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"
}%
```

**JSON 形式でレスポンスを返します AWS SAM CLI。**

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

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

**JSON 出力を標準出力に返します。**

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

Putting record to Kinesis data stream KinesisStream                                                             

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

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

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

**ARN をリソース ID として指定して Lambda 関数を呼び出します。**

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

**論理 ID をリソース ID として指定して Lambda 関数を呼び出します。**

また、 `--stack-name`オプションを使用して CloudFormation スタック名を指定する必要があります。以下に例を示します。

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

アプリケーションに単一の Lambda 関数が含まれている場合、その論理 ID を指定する必要はありません。`--stack-name` オプションのみを指定できます。以下に例を示します。

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

**物理 ID をリソース ID として指定して Lambda 関数を呼び出します。**

物理 ID は、 を使用してデプロイするときに作成されます CloudFormation。

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

**子スタックの Lambda 関数を呼び出します。**

この例では、アプリケーションには次のディレクトリ構造が含まれています。

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

`childstack` の Lambda 関数を呼び出すには、以下を実行します。

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

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

#### レスポンスをストリーミングするように設定された Lambda 関数を呼び出す
<a name="using-sam-cli-remote-invoke-examples-lambda-stream"></a>

この例では、 AWS SAM CLI を使用して、レスポンスをストリーミングするように設定された Lambda 関数が含まれる新しいサーバーレスアプリケーションを初期化します。アプリケーションを にデプロイ AWS クラウド し`sam remote invoke`、 を使用してクラウド内の 関数を操作します。

まず、`sam init` コマンドを実行して新しいサーバーレスアプリケーションを作成することから始めます。**[Lambda レスポンスストリーミング]** クイックスタートテンプレートを選択して、アプリケーションに **lambda-streaming-nodejs-app** という名前を付けます。

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

は AWS 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` ファイルの例です。Lambda 関数のレスポンスストリーミングは、`FunctionUrlConfig` プロパティを使用して設定されます。

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

通常は、`sam build` および `sam deploy --guided` を使用して本番アプリケーションを構築し、デプロイすることができます。この例では、開発環境を想定し、アプリケーションを構築してデプロイするために `sam sync` コマンドを使用します。

**注記**  
`sam sync` コマンドは開発環境に推奨されます。詳細については[を使用して sam sync に同期する方法の概要 AWS クラウド](using-sam-cli-sync.md)を参照してください。

`sam sync` を実行する前に、プロジェクトが `samconfig.toml` ファイル内で正しく設定されていることを確認します。最も重要なのは、`stack_name` と `watch` の値を確認することです。設定ファイル内でこれらの値が指定されていれば、コマンドラインでそれらを指定する必要がありません。

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

次に、`sam sync` を実行してアプリケーションを構築し、デプロイします。設定ファイルで `--watch` オプションが設定されていることから、 AWS SAM CLI がアプリケーションを構築し、アプリケーションをデプロイして、変更を監視します。

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

関数がクラウドにデプロイされたので、`sam remote invoke` を使用して関数とやり取りできるようになりました。 AWS SAM CLI は、関数がレスポンスストリーミング用に設定されていることを自動的に検出し、関数のストリーミングされたレスポンスのリアルタイムでの出力を直ちに開始します。

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

関数コードを変更すると、 AWS SAM CLI が変更を即座に検出して、それらを直ちにデプロイします。以下は、関数コードに変更を行った後の AWS SAM CLI 出力の例です。

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

これで、`sam remote invoke` を再度使用して、クラウド内の関数とやり取りし、変更をテストできるようになりました。

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

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

**ARN をリソース ID として指定して Amazon SQS キューを呼び出します。**

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

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

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

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

**物理 ID をリソース ID として指定してステートマシンを呼び出します。**

まず、`sam list resources` を使用して物理 ID を取得します。

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

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

次に、物理 ID をリソース ID として使用してステートマシンを呼び出します。コマンドラインで `--event` オプションを指定してイベントを渡します。

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

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

**空のイベントを渡してステートマシンを呼び出します。**

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

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

## 関連リンク
<a name="using-sam-cli-remote-invoke-links"></a>

`sam remote invoke` および の使用に関するドキュメントについては AWS SAM CLI、以下を参照してください。
+ [sam remote invoke](sam-cli-command-reference-remote-invoke.md)
+ [AWS SAMCLI トラブルシューティング](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 関数を呼び出し、レスポンスを待機し、レスポンスが期待どおりであることを確認します。統合テストをローカルで実行するには、前のステップで起動したローカル Lambda エンドポイントを呼び出すための Lambda Invoke API コールを送信するように AWS SDK を設定する必要があります。

   以下は Python の例です (他の言語 AWS SDKs の設定は似ています）。

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

   このコードは、`running_locally` を `False` に設定することによって、デプロイされた Lambda 関数のテストに使用できます。これにより、 AWS クラウド AWS Lambda で に接続するように AWS SDK がセットアップされます。

# を使用してサンプルイベントペイロードを生成する AWS SAM
<a name="serverless-sam-cli-using-generate-event"></a>

Lambda 関数をテストするには、他の AWS サービスによってトリガーされたときに Lambda 関数が受け取るデータを模倣するサンプルイベントペイロードを生成してカスタマイズできます。これには、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>

**問題:** 関数は耐久性のある関数として動作しません。

**解決方法:**
+ SAM テンプレートで `DurableConfig`が設定されていることを確認します。
+ 関数コードが耐久性のある関数 SDK メソッド (例: `context.wait()`) を使用していることを確認します。
+ サポートされているランタイム (TypeScript、JavaScript、Python) を使用していることを確認します。

### 実行履歴を取得できません
<a name="test-and-debug-durable-functions-troubleshooting-history"></a>

**問題:** `local execution history` コマンドは結果を返しません。

**解決方法:**
+ 実行 ID が正しいことを確認する
+ 関数が少なくとも 1 回呼び出されたことを確認します。

### コールバックコマンドが機能しない
<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) - 実行履歴