

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

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

使用 AWS Serverless Application Model Command Line Interface (AWS SAM CLI) `sam remote invoke`命令與 中支援 AWS 的資源互動 AWS 雲端。您可以使用 `sam remote invoke` 叫用下列資源：
+ **Amazon Kinesis Data Streams** – 將資料記錄傳送至 Kinesis Data Streams 應用程式。
+ **AWS Lambda** – 叫用事件並將其傳遞至 Lambda 函數。
+ **Amazon Simple Queue Service (Amazon SQS)** – 傳送訊息至 Amazon SQS 佇列。
+ **AWS Step Functions** – 叫用 Step Functions 狀態機器以開始執行。

如需 的簡介 AWS SAM CLI，請參閱 [什麼是 AWS SAM CLI？](what-is-sam-overview.md#what-is-sam-cli)

如需在典型開發工作流程`sam remote invoke`期間使用 的範例，請參閱 [步驟 5：與 中的函數互動 AWS 雲端](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-remote-invoke)。

**Topics**
+ [使用 sam 遠端叫用命令](#using-sam-cli-remote-invoke-use)
+ [使用 sam 遠端叫用命令選項](#using-sam-cli-remote-invoke-options)
+ [設定您的專案組態檔案](#using-sam-cli-remote-invoke-configure)
+ [範例](#using-sam-cli-remote-invoke-examples)
+ [相關連結](#using-sam-cli-remote-invoke-links)

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

若要使用 `sam remote invoke`，請完成下列步驟來 AWS SAM CLI安裝 ：
+ [AWS SAM 先決條件](prerequisites.md).
+ [安裝 AWS SAM CLI](install-sam-cli.md).

我們也建議您升級至最新版本的 AWS SAM CLI。如需詳細資訊，請參閱 [升級 AWS SAM CLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade)。

使用 之前`sam remote invoke`，我們建議對下列項目有基本的了解：
+ [設定 AWS SAM CLI](using-sam-cli-configure.md).
+ [在 中建立您的應用程式 AWS SAM](using-sam-cli-init.md).
+ [使用 建置 簡介 AWS SAM](using-sam-cli-build.md).
+ [使用 部署簡介 AWS SAM](using-sam-cli-deploy.md).
+ [使用 sam sync 同步至 的簡介 AWS 雲端](using-sam-cli-sync.md).

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

使用此命令之前，您的資源必須部署到 AWS 雲端。

使用下列命令結構，並從專案的根目錄執行 ：

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

**注意**  
此頁面會顯示命令提示中提供的選項。您也可以在專案的組態檔案中設定選項，而不是在命令提示字元中傳遞。如需進一步了解，請參閱 [設定專案設定](using-sam-cli-configure.md#using-sam-cli-configure-project)。

如需`sam remote invoke`引數和選項的說明，請參閱 [sam remote invoke](sam-cli-command-reference-remote-invoke.md)。

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

您可以將資料記錄傳送至 Kinesis Data Streams 應用程式。 AWS SAM CLI 會傳送您的資料記錄並傳回碎片 ID 和序號。以下是範例：

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

**傳送資料記錄**

1. 提供資源 ID 值做為 Kinesis Data Streams 應用程式的引數。如需有效資源 IDs的資訊，請參閱[資源 ID](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id)。

1. 提供資料記錄做為要傳送至 Kinesis Data Streams 應用程式的事件。您可以使用 `--event`選項在命令列提供事件，或使用 從 檔案提供事件`--event-file`。如果您不提供事件， AWS SAM CLI會傳送空事件。

### 使用 搭配 Lambda 函數
<a name="using-sam-cli-remote-invoke-use-lambda"></a>

您可以在雲端中叫用 Lambda 函數並傳遞空事件，或在命令列或從檔案提供事件。將調用您的 Lambda AWS SAM CLI函數並傳回其回應。以下是範例：

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

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

**叫用 Lambda 函數**

1. 提供資源 ID 值做為 Lambda 函數的引數。如需有效資源 IDs的資訊，請參閱[資源 ID](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id)。

1. 提供要傳送至 Lambda 函數的事件。您可以使用 `--event`選項在命令列提供事件，或使用 從 檔案提供事件`--event-file`。如果您不提供事件， AWS SAM CLI會傳送空事件。

#### 使用回應串流設定的 Lambda 函數
<a name="using-sam-cli-remote-invoke-invoke-stream"></a>

`sam remote invoke` 命令支援設定為串流回應的 Lambda 函數。您可以設定 Lambda 函數，使用 AWS SAM 範本中的 `FunctionUrlConfig` 屬性串流回應。當您使用 時`sam remote invoke`， AWS SAM CLI會自動偵測您的 Lambda 組態，並使用回應串流叫用 。

如需範例，請參閱 [叫用設定為串流回應的 Lambda 函數](#using-sam-cli-remote-invoke-examples-lambda-stream)。

#### 將可共用的測試事件傳遞至雲端中的 Lambda 函數
<a name="using-sam-cli-remote-invoke-shareable"></a>

可共用的測試事件是您可以在相同 中與其他人共用的測試事件 AWS 帳戶。若要進一步了解，請參閱《 *AWS Lambda 開發人員指南*》中的[可共用測試事件](https://docs.aws.amazon.com/lambda/latest/dg/testing-functions.html#creating-shareable-events)。

##### 存取和管理可共用的測試事件
<a name="using-sam-cli-remote-invoke-shareable-access"></a>

您可以使用 AWS SAM CLI`sam remote test-event`命令來存取和管理可共用的測試事件。例如，您可以使用 `sam remote test-event` 執行下列動作：
+ 從 Amazon EventBridge 結構描述登錄檔擷取可共用的測試事件。
+ 在本機修改可共用的測試事件，並將其上傳至 EventBridge 結構描述登錄檔。
+ 從 EventBridge 結構描述登錄檔中刪除可共用的測試事件。

如需詳細資訊，請參閱 [使用 進行雲端測試的簡介 sam remote test-event](using-sam-cli-remote-test-event.md)。

##### 將可共用的測試事件傳遞至雲端中的 Lambda 函數
<a name="using-sam-cli-remote-invoke-shareable-pass"></a>

若要將可共用測試事件從 EventBridge 結構描述登錄檔傳遞至雲端中的 Lambda 函數，請使用 `--test-event-name`選項並提供可共用測試事件的名稱。以下是範例：

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

如果您在本機儲存可共用的測試事件，您可以使用 `--event-file`選項，並提供本機測試事件的檔案路徑和名稱。以下是範例：

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

### 搭配使用 與 Amazon SQS
<a name="using-sam-cli-remote-invoke-use-sqs"></a>

您可以將訊息傳送至 Amazon SQS 佇列。 AWS SAM CLI 會傳回下列項目：
+ 訊息 ID
+ 訊息內文的 MD5 
+ 回應中繼資料

 以下是範例：

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

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

**傳送訊息**

1. 提供資源 ID 值做為 Amazon SQS 佇列的引數。如需有效資源 IDs的資訊，請參閱[資源 ID](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id)。

1. 提供要傳送至 Amazon SQS 佇列的事件。您可以使用 `--event`選項在命令列提供事件，或使用 從 檔案提供事件`--event-file`。如果您不提供事件， AWS SAM CLI會傳送空事件。

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

您可以叫用 Step Functions 狀態機器來開始執行。 AWS SAM CLI 會等待狀態機器工作流程完成，並傳回執行中最後一個步驟的輸出。以下是範例：

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

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

**叫用狀態機器**

1. 提供資源 ID 值做為 Step Functions 狀態機器的引數。如需有效資源 IDs的資訊，請參閱[資源 ID](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id)。

1. 提供事件以傳送至您的狀態機器。您可以使用 `--event`選項在命令列提供事件，或使用 從 檔案提供事件`--event-file`。如果您不提供事件， AWS SAM CLI會傳送空事件。

## 使用 sam 遠端叫用命令選項
<a name="using-sam-cli-remote-invoke-options"></a>

本節涵蓋您可以搭配 `sam remote invoke`命令使用的一些主要選項。如需選項的完整清單，請參閱 [sam remote invoke](sam-cli-command-reference-remote-invoke.md)。

### 將事件傳遞至您的 資源
<a name="using-sam-cli-remote-invoke-options-event"></a>

使用下列選項將事件傳遞至雲端中的資源：
+ `--event` – 在命令列傳遞事件。
+ `--event-file` – 從檔案傳遞事件。

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

**使用 在命令列`--event`傳遞事件做為字串值：**

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

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

**使用 從檔案`--event-file`傳遞事件並提供檔案的路徑：**

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

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

**使用 傳遞事件`stdin`：**

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

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

### 設定 AWS SAM CLI回應輸出
<a name="using-sam-cli-remote-invoke-options-output"></a>

當您使用 叫用支援的資源時`sam remote invoke`， AWS SAM CLI會傳回包含下列項目的回應：
+ **請求中繼資料** – 與請求相關聯的中繼資料。這包括請求 ID 和請求開始時間。
+ **資源回應** – 在雲端中調用資源之後的回應。

您可以使用 `--output`選項來設定 AWS SAM CLI輸出回應。下列選項值可供使用：
+ `json` – 中繼資料和資源回應會以JSON結構傳回。回應包含完整的SDK輸出。
+ `text` – 中繼資料會以文字結構傳回。資源回應會以資源的輸出格式傳回。

以下是`json`輸出的範例：

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

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

當您指定`json`輸出時，整個回應會傳回 `stdout`。以下是範例：

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

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

以下是`text`輸出的範例：

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

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

當您指定`text`輸出時，Lambda 函數執行期輸出 （例如日誌） 會傳回 `stderr`。Lambda 函數承載會傳回 `stdout`。以下是範例：

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

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

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

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

$ cat stdout.log

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

### 自訂Boto3參數
<a name="using-sam-cli-remote-invoke-options-boto3"></a>

對於 `sam remote invoke`， AWS SAM CLI利用適用於 Python 的 AWS SDK (Boto3) 與雲端中的資源互動。您可以使用 `--parameter`選項來自訂Boto3參數。如需您可以自訂的支援參數清單，請參閱 `--parameter`。

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

**叫用 Lambda 函數來驗證參數值和驗證許可：**

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

**在單一命令中多次使用 `--parameter`選項，以提供多個參數：**

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

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

如需`sam remote invoke`選項的完整清單，請參閱 [sam remote invoke](sam-cli-command-reference-remote-invoke.md)。

## 設定您的專案組態檔案
<a name="using-sam-cli-remote-invoke-configure"></a>

若要`sam remote invoke`在組態檔案中設定 ，請在 資料表`remote_invoke`中使用 。以下是`samconfig.toml`設定 `sam remote invoke`命令預設值的檔案範例。

```
...
version =0.1

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

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

如需使用 的基本範例`sam remote invoke`，請參閱 *AWS 運算部落格*中的[使用 AWS SAM 遠端 測試 AWS Lambda 函數](https://aws.amazon.com/blogs/compute/testing-aws-lambda-functions-with-aws-sam-remote-invoke/)。

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

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

**從 檔案將資料記錄傳送至 Kinesis Data Streams 應用程式。Kinesis Data Streams 應用程式是透過提供資源 ID 的 ARN 來識別：**

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

**將命令列提供的事件傳送至 Kinesis Data Streams 應用程式：**

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

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

**取得 Kinesis Data Streams 應用程式的實體 ID。然後，在命令列提供事件：**

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

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

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

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

**在命令列提供 JSON 字串做為事件：**

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

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

**將空事件傳送至 Kinesis Data Streams 應用程式：**

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

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

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

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

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

**將 JSON 輸出傳回 stdout：**

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

Putting record to Kinesis data stream KinesisStream                                                             

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

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

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

**透過提供 ARN 做為資源 ID 來叫用 Lambda 函數：**

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

**透過提供邏輯 ID 做為資源 ID 來叫用 Lambda 函數：**

您還必須使用 `--stack-name`選項提供 CloudFormation 堆疊名稱。以下是範例：

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

如果您的應用程式包含單一 Lambda 函數，則不必指定其邏輯 ID。您只能提供 `--stack-name`選項。以下是範例：

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

**透過提供實體 ID 做為資源 ID 來叫用 Lambda 函數：**

實體 ID 會在您使用 部署時建立 CloudFormation。

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

**叫用子堆疊的 Lambda 函數：**

在此範例中，我們的應用程式包含下列目錄結構：

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

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

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

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

#### 叫用設定為串流回應的 Lambda 函數
<a name="using-sam-cli-remote-invoke-examples-lambda-stream"></a>

在此範例中，我們使用 AWS SAM CLI來初始化新的無伺服器應用程式，其中包含設定為串流其回應的 Lambda 函數。我們將應用程式部署到 AWS 雲端 ，並使用 `sam remote invoke` 與雲端中的 函數互動。

首先執行 `sam init`命令來建立新的無伺服器應用程式。我們會選取 **Lambda 回應串流**快速入門範本，並將應用程式命名為 **lambda-streaming-nodejs-app**。

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

會使用下列結構 AWS SAM CLI建立我們的專案：

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

以下是 Lambda 函數程式碼的範例：

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

以下是我們的`template.yaml`檔案範例。使用 `FunctionUrlConfig` 屬性設定 Lambda 函數的回應串流。

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

一般而言，您可以使用 `sam build` 和 `sam deploy --guided`來建置和部署生產應用程式。在此範例中，我們將假設開發環境，並使用 `sam sync`命令來建置和部署我們的應用程式。

**注意**  
建議開發環境使用 `sam sync`命令。如需詳細資訊，請參閱 [使用 sam sync 同步至 的簡介 AWS 雲端](using-sam-cli-sync.md)。

在執行 之前`sam sync`，我們會驗證我們的專案是否已在 `samconfig.toml` 檔案中正確設定。最重要的是，我們會驗證 `stack_name`和 的值`watch`。有了組態檔案中指定的這些值，我們就不必在命令列提供這些值。

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

接下來，我們會執行 `sam sync`來建置和部署應用程式。由於 `--watch`選項是在我們的組態檔案中設定，因此 AWS SAM CLI會建置我們的應用程式、部署我們的應用程式，並留意變更。

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

現在我們的函式已部署到雲端，我們可以使用 `sam remote invoke` 與函式互動。 AWS SAM CLI 會自動偵測我們的函數已設定為回應串流，並立即開始即時輸出函數的串流回應。

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

當我們修改函數程式碼時， 會 AWS SAM CLI立即偵測並立即部署變更。以下是變更函數程式碼後輸出 AWS SAM CLI的範例：

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

我們現在可以`sam remote invoke`再次使用 與雲端中的 函式互動，並測試我們的變更。

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

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

**透過提供 ARN 做為資源 ID 來叫用 Amazon SQS 佇列：**

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

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

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

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

**透過提供其實體 ID 做為資源 ID 來叫用狀態機器：**

首先，我們使用 `sam list resources` 來取得實體 ID：

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

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

接著，我們使用實體 ID 做為資源 ID 來調用狀態機器。我們透過 `--event`選項在命令列傳入事件：

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

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

**透過傳遞空事件來叫用狀態機器：**

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

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

## 相關連結
<a name="using-sam-cli-remote-invoke-links"></a>

如需與 `sam remote invoke` 和使用 相關的文件 AWS SAM CLI，請參閱以下內容：
+ [sam remote invoke](sam-cli-command-reference-remote-invoke.md)
+ [AWS SAM CLI 故障診斷](sam-cli-troubleshooting.md)