

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Introdução aos testes na nuvem com sam remote invoke
<a name="using-sam-cli-remote-invoke"></a>

Use o AWS Serverless Application Model comando Command Line Interface (AWS SAM CLI) `sam remote invoke` para interagir com AWS os recursos suportados no Nuvem AWS. Você pode usar `sam remote invoke` para invocar os seguintes recursos:
+ **Amazon Kinesis Data Streams** – Envie registros de dados para aplicativos do Kinesis Data Streams.
+ **AWS Lambda** - Invoque e transmita eventos para suas funções do Lambda.
+ **Amazon Simple Queue Service (Amazon SQS)** — Envie mensagens para filas do Amazon SQS.
+ **AWS Step Functions** – Invoque máquinas de estado do Step Functions para iniciar a execução.

Para uma introdução ao AWS SAMCLI, consulte [O que é o AWS SAMCLI?](what-is-sam-overview.md#what-is-sam-cli)

Para obter um exemplo de uso do `sam remote invoke` durante um fluxo de trabalho de desenvolvimento típico, consulte [Etapa 5: Interaja com sua função no Nuvem AWS](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-remote-invoke).

**Topics**
+ [Usando o comando de invocação remota do sam](#using-sam-cli-remote-invoke-use)
+ [Usando o comando de invocação remota do sam](#using-sam-cli-remote-invoke-options)
+ [Configure o arquivo de configuração do seu projeto](#using-sam-cli-remote-invoke-configure)
+ [Exemplos](#using-sam-cli-remote-invoke-examples)
+ [Links relacionados](#using-sam-cli-remote-invoke-links)

## Pré-requisitos
<a name="using-sam-cli-remote-invoke-prerequisites"></a>

Para usar `sam remote invoke`, instale o AWS SAM CLI fazendo o seguinte:
+ [AWS SAM pré-requisitos](prerequisites.md).
+ [Instale o AWS SAM CLI](install-sam-cli.md).

Também recomendamos atualizar para a versão mais recente do AWS SAMCLI. Para saber mais, consulte [Atualizar o AWS SAM CLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade).

Antes de usar `sam remote invoke`, recomendamos uma compreensão básica do seguinte:
+ [Configurando o AWS SAM CLI](using-sam-cli-configure.md).
+ [Crie seu aplicativo em AWS SAM](using-sam-cli-init.md).
+ [Introdução à construção com AWS SAM](using-sam-cli-build.md).
+ [Introdução à implantação com AWS SAM](using-sam-cli-deploy.md).
+ [Introdução ao uso sam sync para sincronizar com Nuvem AWS](using-sam-cli-sync.md).

## Usando o comando de invocação remota do sam
<a name="using-sam-cli-remote-invoke-use"></a>

Antes de usar esse comando, seu recurso deve ser implantado no Nuvem AWS.

Use a seguinte estrutura de comando e execute no diretório raiz do seu projeto:

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

**nota**  
Esta página mostrará as opções fornecidas no prompt de comando. Você também pode configurar opções no arquivo de configuração do seu projeto em vez de passá-las no prompt de comando. Para saber mais, [Definir configurações do projeto](using-sam-cli-configure.md#using-sam-cli-configure-project).

Para obter uma descrição dos argumentos e opções `sam remote invoke`, consulte [sam remote invoke](sam-cli-command-reference-remote-invoke.md).

### Usar com o Kinesis Data Streams
<a name="using-sam-cli-remote-invoke-use-kinesis"></a>

Você pode enviar registros de dados para um aplicativo do Kinesis Data Streams. Eles AWS SAM CLI enviarão seu registro de dados e retornarão um ID de fragmento e um número de sequência. Este é um exemplo:

```
$ 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"
	}%
```

**Para enviar um registro de dados**

1. Forneça um valor de ID de recurso como argumento para seu aplicativo Kinesis Data Streams. Para obter informações sobre recursos válidos IDs, consulte [ID do recurso](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id).

1. Forneça o registro de dados como um evento para enviar ao seu aplicativo Kinesis Data Streams. Você pode fornecer o evento na linha de comando usando a opção `--event` ou a partir de um arquivo usando `--event-file`. Se você não fornecer um evento, AWS SAM CLI ele enviará um evento vazio.

### Usar com funções do Lambda
<a name="using-sam-cli-remote-invoke-use-lambda"></a>

Você pode invocar uma função do Lambda na nuvem e transmitir um evento vazio ou fornecer um evento na linha de comando ou apartir de um arquivo. Eles AWS SAM CLI invocarão sua função Lambda e retornarão sua resposta. Este é um exemplo:

```
$ 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\"}"}%
```

**Para invocar uma função do Lambda**

1. Forneça um valor de ID de recurso como argumento para sua função do Lambda. Para obter informações sobre recursos válidos IDs, consulte [ID do recurso](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id).

1. Forneça um evento para enviar para sua função do Lambda. Você pode fornecer o evento na linha de comando usando a opção `--event` ou a partir de um arquivo usando `--event-file`. Se você não fornecer um evento, AWS SAM CLI ele enviará um evento vazio.

#### Funções Lambda configuradas com streaming de resposta
<a name="using-sam-cli-remote-invoke-invoke-stream"></a>

O comando `sam remote invoke` é compatível com funções do Lambda que são configuradas para transmitir respostas. Você pode configurar uma função Lambda para transmitir respostas usando a `FunctionUrlConfig` propriedade em seus AWS SAM modelos. Quando você usa `sam remote invoke`, AWS SAM CLI detecta automaticamente sua configuração do Lambda e invoca com streaming de resposta.

Para ver um exemplo, consulte [Invoque uma função do Lambda configurada para o streaming de respostas](#using-sam-cli-remote-invoke-examples-lambda-stream).

#### Transmita eventos de teste compartilháveis para uma função do Lambda na nuvem
<a name="using-sam-cli-remote-invoke-shareable"></a>

Eventos de teste compartilháveis são eventos de teste que você pode compartilhar com outros na mesma Conta da AWS. Para saber mais, consulte [Eventos de teste compartilháveis](https://docs.aws.amazon.com/lambda/latest/dg/testing-functions.html#creating-shareable-events) no *AWS Lambda Guia do desenvolvedor*.

##### Acessar e gerenciar eventos compartilháveis de teste
<a name="using-sam-cli-remote-invoke-shareable-access"></a>

Você pode usar o AWS SAM CLI `sam remote test-event` comando para acessar e gerenciar eventos de teste compartilháveis. Por exemplo, você pode usar `sam remote test-event` para fazer o seguinte:
+ Recupere eventos de teste compartilháveis do registro de EventBridge esquemas da Amazon.
+ Modifique eventos de teste compartilháveis localmente e carregue-os no registro do EventBridge esquema.
+ Exclua eventos de teste compartilháveis do registro do EventBridge esquema.

Para saber mais, consulte [Introdução aos testes em nuvem com sam remote test-event](using-sam-cli-remote-test-event.md).

##### Transmita um evento de teste compartilhável para uma função do Lambda na nuvem
<a name="using-sam-cli-remote-invoke-shareable-pass"></a>

Para passar um evento de teste compartilhável do registro do EventBridge esquema para sua função Lambda na nuvem, use a `--test-event-name` opção e forneça o nome do evento de teste compartilhável. Este é um exemplo:

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

Se você salvar o evento de teste compartilhável localmente, poderá usar a opção `--event-file` e fornecer o caminho do arquivo e o nome do evento de teste local. Este é um exemplo:

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

### Usar o com o Amazon SQS
<a name="using-sam-cli-remote-invoke-use-sqs"></a>

Você pode enviar mensagens para filas do Amazon SQS. O AWS SAM CLI retorna o seguinte:
+ ID da mensagem
+ MD5 do corpo da mensagem
+ Metadados de resposta

 Este é um exemplo:

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

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

**Para enviar uma mensagem**

1. Forneça um valor de ID de recurso como argumento para a fila do Amazon SQS. Para obter informações sobre recursos válidos IDs, consulte [ID do recurso](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id).

1. Forneça um evento para enviar para sua fila do Amazon SQS. Você pode fornecer o evento na linha de comando usando a opção `--event` ou a partir de um arquivo usando `--event-file`. Se você não fornecer um evento, AWS SAM CLI ele enviará um evento vazio.

### Usar com o Step Functions
<a name="using-sam-cli-remote-invoke-use-sf"></a>

Você pode invocar uma máquina de estado do Step Functions para iniciar a execução. O AWS SAM CLI aguardará a conclusão do fluxo de trabalho da máquina de estado e retornará uma saída da última etapa da execução. Este é um exemplo:

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

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

**Para invocar uma máquina de estado**

1. Forneça um valor de ID de recurso como argumento para a máquina de estado do Step Functions. Para obter informações sobre recursos válidos IDs, consulte [ID do recurso](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id).

1. Forneça um evento para enviar para sua máquina estadual. Você pode fornecer o evento na linha de comando usando a opção `--event` ou a partir de um arquivo usando `--event-file`. Se você não fornecer um evento, AWS SAM CLI ele enviará um evento vazio.

## Usando o comando de invocação remota do sam
<a name="using-sam-cli-remote-invoke-options"></a>

Esta seção aborda algumas das principais opções que você pode usar com o comando `sam remote invoke`. Para obter uma lista completa das opções, consulte [sam remote invoke](sam-cli-command-reference-remote-invoke.md).

### Passe um evento para seu recurso
<a name="using-sam-cli-remote-invoke-options-event"></a>

Use as seguintes opções para transmitir eventos para seus recursos na nuvem:
+ `--event` - Passe um evento na linha de comando.
+ `--event-file` - Passe um evento de um arquivo.

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

**Use `--event` para passar um evento na linha de comando como um valor de string:**

```
$ 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!\"}"}%
```

**Use `--event-file` para transmitir um evento de um arquivo e fornecer o caminho para o arquivo:**

```
$ 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\"}"}%
```

**Passe um evento usando `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\"}"}%
```

### Configurar a saída da resposta AWS SAM CLI
<a name="using-sam-cli-remote-invoke-options-output"></a>

Quando você invoca um recurso compatível com `sam remote invoke`, AWS SAMCLI retorna uma resposta que contém o seguinte:
+ **Metadados da solicitação** – Metadata associados à solicitação. Isso inclui o ID da solicitação e o horário de início da solicitação.
+ **Resposta do recurso** - A resposta do seu recurso após ser invocado na nuvem.

Você pode usar a `--output` opção para configurar a resposta AWS SAM CLI de saída. Os seguintes valores de opção estão disponíveis:
+ `json` - Os metadados e a resposta do recurso são retornados em uma estrutura JSON. A resposta contém a saída SDK completa.
+ `text` - Os metadados são retornados na estrutura do texto. A resposta do recurso é retornada no formato de saída do recurso.

A seguir, veja um exemplo de uma saída `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\\\"}\"}"
}%
```

Quando você especifica uma saída `json`, toda a resposta é retornada para `stdout`. Este é um exemplo:

```
$ 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\\\"}\"}"
}%
```

A seguir, veja um exemplo de uma saída `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\"}"}%
```

Quando você especifica uma saída `text`, a saída de runtime da função do Lambda (por exemplo, registros) é retornada para `stderr`. A carga útil da função do Lambda é retornada para `stdout`. Este é um exemplo:

```
$ 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\"}"}%
```

### Personalize os parâmetros Boto3
<a name="using-sam-cli-remote-invoke-options-boto3"></a>

Pois`sam remote invoke`, AWS SAM CLI ele utiliza o AWS SDK para Python (Boto3) para interagir com seus recursos na nuvem. Você pode usar a opção `--parameter` para personalizar os parâmetros Boto3. Para ver uma lista dos parâmetros, consulte `--parameter`.

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

**Invoque uma função do Lambda para validar os valores dos parâmetros e verificar as permissões:**

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

**Use a opção `--parameter` várias vezes em um único comando para fornecer vários parâmetros:**

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

### Outras opções
<a name="using-sam-cli-remote-invoke-options-other"></a>

Para obter uma lista completa das opções `sam remote invoke`, consulte [sam remote invoke](sam-cli-command-reference-remote-invoke.md).

## Configure o arquivo de configuração do seu projeto
<a name="using-sam-cli-remote-invoke-configure"></a>

Para configurar `sam remote invoke` em seu arquivo de configuração, use `remote_invoke` em sua tabela. Veja a seguir um exemplo de arquivo `samconfig.toml` que configura valores padrão para o comando `sam remote invoke`.

```
...
version =0.1

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

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

Para ver um exemplo básico de uso`sam remote invoke`, consulte [Teste de AWS Lambda funções com AWS SAM controle remoto](https://aws.amazon.com/blogs/compute/testing-aws-lambda-functions-with-aws-sam-remote-invoke/) no *blog de AWS computação.*

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

#### Exemplos básicos
<a name="using-sam-cli-remote-invoke-examples-kinesis-basic"></a>

**Envie um registro de dados para um aplicativo Kinesis Data Streams a partir de um arquivo. O aplicativo Kinesis Data Streams é identificado fornecendo um ARN para o ID do recurso:**

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

**Envie um evento fornecido na linha de comando para um aplicativo do 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"
}%
```

**Obtenha a ID física do aplicativo Kinesis Data Streams. Em seguida, forneça um evento na linha de comando:**

```
$ 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"
}%
```

**Forneça uma string JSON na linha de comando como um evento:**

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

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

**Envie um evento vazio para o aplicativo Kinesis Data Streams:**

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

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

**Retorne a AWS SAM CLI resposta no formato 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
  }
}%
```

**Retorne a saída JSON para 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
  }
}%
```

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

#### Exemplos básicos
<a name="using-sam-cli-remote-invoke-examples-lambda-basic"></a>

**Invoque uma função do Lambda fornecendo o ARN como ID do recurso:**

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

**Invoque uma função do Lambda fornecendo a ID lógica como uma ID de recurso:**

Você também deve fornecer o nome da CloudFormation pilha usando a `--stack-name` opção. Este é um exemplo:

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

Se seu aplicativo contiver uma única função do Lambda, você não precisará especificar sua ID lógica. Você pode fornecer somente a opção `--stack-name`. Este é um exemplo:

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

**Invoque uma função do Lambda fornecendo o ID físico como ID do recurso:**

O ID físico é criado quando você implanta usando CloudFormation.

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

**Invoque uma função do Lambda de uma pilha secundária:**

Neste exemplo, nosso aplicativo contém a seguinte estrutura de diretórios:

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

Para invocar a função do Lambda do nosso `childstack`, executamos o seguinte:

```
$ 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\": {}}"}%
```

#### Invoque uma função do Lambda configurada para o streaming de respostas
<a name="using-sam-cli-remote-invoke-examples-lambda-stream"></a>

Neste exemplo, usamos AWS SAM CLI para inicializar um novo aplicativo sem servidor que contém uma função do Lambda configurada para transmitir sua resposta. Implantamos nosso aplicativo no Nuvem AWS e usamos o `sam remote invoke` para interagir com nossa função na nuvem.

Começamos executando o comando `sam init` para criar um novo aplicativo sem servidor. Selecionamos o modelo de início rápido do **Lambda Response Streaming** e nomeamos nosso aplicativo. **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 SAMCLICria nosso projeto com a seguinte estrutura:

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

Veja a seguir um exemplo de nosso código de função do 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();
	  }
	);
```

Este é um exemplo de nosso arquivo `template.yaml`. O streaming de resposta para nossa função do Lambda é configurado usando a propriedade `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
```

Normalmente, você pode usar `sam build` e `sam deploy --guided` criar e implantar um aplicativo de produção. Neste exemplo, assumiremos um ambiente de desenvolvimento e usaremos o comando `sam sync` para criar e implantar nosso aplicativo.

**nota**  
O comando `sam sync` é recomendado para ambientes de desenvolvimento. Para saber mais, consulte [Introdução ao uso sam sync para sincronizar com Nuvem AWS](using-sam-cli-sync.md).

Antes de executar `sam sync`, verificamos se nosso projeto está configurado corretamente em nosso arquivo `samconfig.toml`. Mais importante ainda, verificamos os valores de `stack_name` e `watch`. Com esses valores especificados em nosso arquivo de configuração, não precisamos fornecê-los na linha de comando.

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

Em seguida, executamos `sam sync` para criar e implantar nosso aplicativo. Como a opção `--watch` está configurada em nosso arquivo de configuração, AWS SAMCLI criará o nosso aplicativo, implantará o nosso aplicativo e observará as alterações.

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

Agora que nossa função está implantada na nuvem, podemos usar `sam remote invoke` para interagir com nossa função. O AWS SAM  CLI deteca automaticamente que nossa função está configurada para streaming de resposta e imediatamente começa a gerar uma resposta transmitida de nossa função em tempo real.

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

Quando modificamos nosso código de função, AWS SAM CLI detecta instantaneamente e implanta imediatamente nossas alterações. Aqui está um exemplo da saída AWS SAMCLI após as alterações serem feitas em nosso código de função:

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

Agora podemos usar `sam remote invoke` novamente para interagir com nossa função na nuvem e testar nossas alterações.

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

#### Exemplos básicos
<a name="using-sam-cli-remote-invoke-examples-sqs-basic"></a>

**Invoque uma fila do Amazon SQS fornecendo o ARN como ID do recurso:**

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

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

#### Exemplos básicos
<a name="using-sam-cli-remote-invoke-examples-sf-basic"></a>

**Invoque uma máquina de estado fornecendo sua ID física como ID de recurso:**

Primeiro, usamos `sam list resources` para obter nossa identificação física:

```
$ 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"
  }
]
```

Em seguida, invocamos nossa máquina de estado usando o ID físico como ID do recurso. Transmitimos um evento na linha de comando com a opção `--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"%
```

**Invoque uma máquina de estado transmitindo um evento vazio:**

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

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

## Links relacionados
<a name="using-sam-cli-remote-invoke-links"></a>

Para obter a documentação relacionada `sam remote invoke` e o uso do AWS SAMCLI, consulte o seguinte:
+ [sam remote invoke](sam-cli-command-reference-remote-invoke.md)
+ [AWS SAM CLI solução de problemas](sam-cli-troubleshooting.md)