

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Introducción a las pruebas en la nube con sam remote invoke
<a name="using-sam-cli-remote-invoke"></a>

Utilice el AWS Serverless Application Model comando Command Line Interface (AWS SAM CLI) `sam remote invoke` para interactuar con AWS los recursos compatibles en Nube de AWS. Puedes utilizar `sam remote invoke` para invocar los recursos siguientes:
+ **Amazon Kinesis Data Streams**: envía registros de datos a las aplicaciones de Kinesis Data Streams.
+ **AWS Lambda**: invoca y pasa eventos a sus funciones de Lambda.
+ **Amazon Simple Queue Service (Amazon SQS)**: envía mensajes a colas de Amazon SQS.
+ **AWS Step Functions**: invoca máquinas de estado de Step Functions para iniciar la ejecución.

Para obtener una introducción al AWS SAMCLI, consulte [¿Qué es el? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli)

Para ver un ejemplo de uso de `sam remote invoke` durante un flujo de trabajo de desarrollo típico, consulta [Paso 5: Interactúa con tu función en el Nube de AWS](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-remote-invoke).

**Topics**
+ [Uso del comando sam remote invoke](#using-sam-cli-remote-invoke-use)
+ [Uso de las opciones del comando sam remote invoke](#using-sam-cli-remote-invoke-options)
+ [Configura el archivo de configuración de su proyecto](#using-sam-cli-remote-invoke-configure)
+ [Ejemplos](#using-sam-cli-remote-invoke-examples)
+ [Vínculos relacionados](#using-sam-cli-remote-invoke-links)

## Requisitos previos
<a name="using-sam-cli-remote-invoke-prerequisites"></a>

Para usar `sam remote invoke`, completa lo siguiente para instalar la CLI de AWS SAM:
+ [AWS SAM requisitos previos](prerequisites.md).
+ [Instala la AWS SAM CLI](install-sam-cli.md).

También recomendamos actualizar a la última versión del AWS SAMCLI. Para obtener más información, consulta [Actualización de AWS SAM CLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade).

Antes de usar `sam remote invoke`, se recomienda tener conocimientos básicos de lo siguiente:
+ [Configuración de la AWS SAM de CLI](using-sam-cli-configure.md).
+ [Crea tu aplicación en AWS SAM](using-sam-cli-init.md).
+ [Introducción a la construcción con AWS SAM](using-sam-cli-build.md).
+ [Introducción a la implementación con AWS SAM](using-sam-cli-deploy.md).
+ [Introducción al uso sam sync de la sincronización con Nube de AWS](using-sam-cli-sync.md).

## Uso del comando sam remote invoke
<a name="using-sam-cli-remote-invoke-use"></a>

Antes de usar este comando, el recurso debe implementarse en la Nube de AWS.

Usa la siguiente estructura de comandos y ejecútela desde el directorio raíz del proyecto:

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

**nota**  
Esta página mostrará las opciones que se proporcionan en el símbolo del sistema. También puede configurar las opciones en el archivo de configuración del proyecto en lugar de pasarlas por la línea de comandos. Para obtener más información, [Configurar los ajustes del proyecto](using-sam-cli-configure.md#using-sam-cli-configure-project).

Para obtener una descripción de los argumentos `sam remote invoke` y las opciones, consulta [sam remote invoke](sam-cli-command-reference-remote-invoke.md).

### Uso con Kinesis Data Streams
<a name="using-sam-cli-remote-invoke-use-kinesis"></a>

Puede enviar registros de datos a una aplicación de Kinesis Data Streams. Le AWS SAM CLI enviará su registro de datos y le devolverá un identificador de fragmento y un número de secuencia. A continuación, se muestra un ejemplo:

```
$ 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 un registro de datos**

1. Proporciona un valor de ID de recurso como argumento para tu aplicación Kinesis Data Streams. Para obtener información sobre un recurso válido IDs, consulte el [ID del recurso.](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id)

1. Proporciona el registro de datos como un evento para enviarlo a la aplicación Kinesis Data Streams. Puedes proporcionar el evento en la línea de comandos mediante la opción `--event` o desde un archivo mediante `--event-file`. Si no proporciona un evento, AWS SAM CLI envía un evento vacío.

### Uso con funciones de Lambda
<a name="using-sam-cli-remote-invoke-use-lambda"></a>

Puedes invocar una función de Lambda en la nube y pasar un evento vacío o proporcionar un evento en la línea de comandos o desde un archivo. AWS SAM CLIInvocará la función Lambda y devolverá su respuesta. A continuación, se muestra un ejemplo:

```
$ 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 una función de Lambda**

1. Proporciona un valor de ID de recurso como argumento para su función de Lambda. Para obtener información sobre un recurso válido IDs, consulte el ID del [recurso](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id).

1. Proporciona un evento para que lo envía a su función de Lambda. Puedes proporcionar el evento en la línea de comandos mediante la opción `--event` o desde un archivo mediante `--event-file`. Si no proporciona un evento, AWS SAM CLI envía un evento vacío.

#### Funciones de Lambda configuradas con transmisión de respuestas
<a name="using-sam-cli-remote-invoke-invoke-stream"></a>

El comando `sam remote invoke` admite funciones de Lambda que están configuradas para transmitir respuestas. Puede configurar una función Lambda para transmitir las respuestas mediante la `FunctionUrlConfig` propiedad de sus AWS SAM plantillas. Cuando utiliza `sam remote invoke`, la CLI de AWS SAM detectará automáticamente su configuración de Lambda y la invocará con una transmisión de respuesta.

Para ver un ejemplo, consulta [Invocación de una función de Lambda configurada para transmitir respuestas](#using-sam-cli-remote-invoke-examples-lambda-stream).

#### Transfiera eventos de prueba que se puedan compartir a una función de Lambda en la nube
<a name="using-sam-cli-remote-invoke-shareable"></a>

Los eventos de prueba que se pueden compartir son aquellos que puede compartir con otros en la misma Cuenta de AWS. Para obtener más información, consulta los [Eventos de prueba que se puedan compartir](https://docs.aws.amazon.com/lambda/latest/dg/testing-functions.html#creating-shareable-events) en la *Guía para desarrolladores de AWS Lambda *.

##### Acceso y administración de eventos de prueba que se puedan compartir
<a name="using-sam-cli-remote-invoke-shareable-access"></a>

Puede usar el AWS SAM CLI `sam remote test-event` comando para acceder a los eventos de prueba que se pueden compartir y administrarlos. Por ejemplo, puede utilizar `sam remote test-event` para hacer lo siguiente:
+ Recupera eventos de prueba que se pueden compartir del registro de EventBridge esquemas de Amazon.
+ Modifique los eventos de prueba que se pueden compartir de forma local y cárguelos en el registro de EventBridge esquemas.
+ Elimine los eventos de prueba que se puedan compartir del registro de EventBridge esquemas.

Para obtener más información, consulte [Introducción a las pruebas en la nube con sam remote test-event](using-sam-cli-remote-test-event.md).

##### Transfiera un evento de prueba que se pueda compartir a una función de Lambda en la nube
<a name="using-sam-cli-remote-invoke-shareable-pass"></a>

Para pasar un evento de prueba que se pueda compartir del registro de EventBridge esquemas a la función Lambda en la nube, utilice la opción y proporcione `--test-event-name` el nombre del evento de prueba que se puede compartir. A continuación, se muestra un ejemplo:

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

Si guarda el evento de prueba que se puede compartir de forma local, puede usar la opción `--event-file` y proporcionar la ruta del archivo y el nombre del evento de prueba local. A continuación, se muestra un ejemplo:

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

### Uso de con Amazon SQS
<a name="using-sam-cli-remote-invoke-use-sqs"></a>

Puede enviar mensajes a las colas de Amazon SQS. AWS SAM CLIDevuelve lo siguiente:
+ Message ID
+ MD5 del cuerpo del mensaje
+ Metadatos de respuesta

 A continuación, se muestra un ejemplo:

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

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

**Cómo enviar un mensaje**

1. Proporciona un valor de ID de recurso como argumento para la cola de Amazon SQS. Para obtener información sobre un recurso válido IDs, consulte el [identificador del recurso](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id).

1. Indique un evento para que lo envía a la cola de Amazon SQS. Puedes proporcionar el evento en la línea de comandos mediante la opción `--event` o desde un archivo mediante `--event-file`. Si no proporciona un evento, AWS SAM CLI envía un evento vacío.

### Uso con Step Functions
<a name="using-sam-cli-remote-invoke-use-sf"></a>

Puedes invocar máquinas de estado de Step Functions para iniciar la ejecución. AWS SAM CLIEsperará a que se complete el flujo de trabajo de la máquina de estados y devolverá un resultado del último paso de la ejecución. A continuación, se muestra un ejemplo:

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

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

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

1. Proporciona un valor de ID de recurso como argumento para la máquina de estado de Step Functions. Para obtener información sobre un recurso válido IDs, consulte el [ID del recurso](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id).

1. Proporciona un evento para enviarlo a su máquina de estado. Puedes proporcionar el evento en la línea de comandos mediante la opción `--event` o desde un archivo mediante `--event-file`. Si no proporciona un evento, AWS SAM CLI envía un evento vacío.

## Uso de las opciones del comando sam remote invoke
<a name="using-sam-cli-remote-invoke-options"></a>

En esta sección se describen algunas de las opciones principales que puede utilizar con el comando `sam remote invoke`. Para obtener una lista completa de opciones, consulta [sam remote invoke](sam-cli-command-reference-remote-invoke.md).

### Paso de un evento al recurso
<a name="using-sam-cli-remote-invoke-options-event"></a>

Utiliza las siguientes opciones para transferir los eventos a sus recursos en la nube:
+ `--event`: permite pasar un evento desde la línea de comandos.
+ `--event-file`: permite pasar un evento desde un archivo.

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

**Se utiliza `--event` para pasar un evento a la línea de comandos como un valor de cadena:**

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

**Se utiliza `--event-file` para pasar un evento de un archivo y proporcionar la ruta al archivo:**

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

**Pase un evento mediante `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\"}"}%
```

### Configura la salida de respuesta de la CLI de AWS SAM
<a name="using-sam-cli-remote-invoke-options-output"></a>

Al invocar un recurso compatible con `sam remote invoke`, la CLI de AWS SAM devuelve una respuesta que contiene lo siguiente:
+ **Metadatos de la solicitud**: metadatos asociados a la solicitud. Esto incluye el identificador de la solicitud y la hora de inicio de la solicitud.
+ **Respuesta del recurso**: la respuesta de su recurso tras ser invocado en la nube.

Puede usar la `--output` opción para configurar la respuesta AWS SAM CLI de salida. Los valores siguientes están disponibles:
+ `json`: los metadatos y la respuesta del recurso se devuelven en una estructura JSON. La respuesta contiene el resultado completo del SDK.
+ `text`: los metadatos se devuelven en una estructura de texto. La respuesta del recurso se devuelve en el formato de salida del recurso.

A continuación, se muestra un ejemplo de una salida de `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\\\"}\"}"
}%
```

Al especificar un resultado `json`, se devuelve la respuesta completa a `stdout`. A continuación, se muestra un ejemplo:

```
$ 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 continuación, se muestra un ejemplo de una salida de `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\"}"}%
```

Al especificar un resultado `text`, se devuelve el resultado del tiempo de ejecución de la función de Lambda (por ejemplo, los registros) a `stderr`. Se devuelve la carga útil de la función de Lambda a `stdout`. A continuación, se muestra un ejemplo:

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

### Personalización de los parámetros Boto3
<a name="using-sam-cli-remote-invoke-options-boto3"></a>

Pues`sam remote invoke`, AWS SAM CLI utiliza el AWS SDK para Python (Boto3) para interactuar con sus recursos en la nube. Puedes utilizar la opción `--parameter` para personalizar los parámetros Boto3. Para ver una lista de los parámetros admitidos que puede personalizar, consulta `--parameter`.

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

**Invoque una función de Lambda para validar los valores de los parámetros y verificar los permisos:**

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

**Utiliza la opción `--parameter` varias veces en un solo comando para proporcionar varios parámetros:**

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

### Otras opciones
<a name="using-sam-cli-remote-invoke-options-other"></a>

Para obtener una lista completa de opciones `sam remote invoke`, consulta [sam remote invoke](sam-cli-command-reference-remote-invoke.md).

## Configura el archivo de configuración de su proyecto
<a name="using-sam-cli-remote-invoke-configure"></a>

Para configurar `sam remote invoke` en su archivo de configuración, utiliza `remote_invoke` en su tabla. El siguiente es un ejemplo de un archivo `samconfig.toml` que configura los valores predeterminados del comando `sam remote invoke`.

```
...
version =0.1

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

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

*Para ver un ejemplo básico de uso`sam remote invoke`, consulta Cómo [probar AWS Lambda funciones de forma AWS SAM remota](https://aws.amazon.com/blogs/compute/testing-aws-lambda-functions-with-aws-sam-remote-invoke/) en el AWS blog de informática.*

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

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

**Envíe un registro de datos a una aplicación de Kinesis Data Streams desde un achivo. La aplicación Kinesis Data Streams se identifica proporcionando un ARN para el ID del recurso:**

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

**Envíe un evento proporcionado en la línea de comandos a una aplicación de 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"
}%
```

**Obtén el ID físico de la aplicación Kinesis Data Streams. A continuación, proporciona un evento en la línea de comandos:**

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

**Proporciona una cadena JSON en la línea de comandos como un 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"
}%
```

**Envíe un evento vacío a la aplicación Kinesis Data Streams:**

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

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

**Devuelve la AWS SAM CLI respuesta en 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
  }
}%
```

**Devuelva la salida JSON a 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
  }
}%
```

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

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

**Invoque una función de Lambda al proporcionar el ARN como ID de recurso:**

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

**Invoque una función de Lambda al proporcionar el ID lógico como ID de recurso:**

También debes proporcionar el nombre de la CloudFormation pila mediante la `--stack-name` opción. A continuación, se muestra un ejemplo:

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

Si la aplicación contiene una sola función de Lambda, no es necesario que especifica su ID lógico. Solo puedes proporcionar la opción `--stack-name`. A continuación, se muestra un ejemplo:

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

**Para invocar una función de Lambda, proporciona el identificador físico como identificador de recurso:**

El ID físico se crea cuando se implementa utilizando CloudFormation.

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

**Invoque una función de Lambda de una pila secundaria:**

Para este ejemplo, nuestra aplicación contiene la siguiente estructura de directorios:

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

Para invocar la función de Lambda de nuestra `childstack`, ejecutamos lo siguiente:

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

#### Invocación de una función de Lambda configurada para transmitir respuestas
<a name="using-sam-cli-remote-invoke-examples-lambda-stream"></a>

En este ejemplo, utilizamos la CLI de AWS SAM para inicializar una nueva aplicación sin servidor que contiene una función de Lambda configurada para transmitir su respuesta. Implementamos nuestra aplicación en la nube Nube de AWS y la utilizamos `sam remote invoke` para interactuar con nuestra función en la nube.

Para empezar, es necesario ejecutar el comando `sam init` para crear una nueva aplicación sin servidor. Seleccionamos la plantilla de inicio rápido de **Lambda Response Streaming** y asignamos un nombre a nuestra aplicación. **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 SAMCLICrea nuestro proyecto con la siguiente estructura:

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

El siguiente es un ejemplo de nuestro código de la función de 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();
	  }
	);
```

A continuación, se presenta un ejemplo del archivo `template.yaml`. La transmisión de respuestas para nuestra función de Lambda se configura mediante la propiedad `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
```

Por lo general, puede usar `sam build` y `sam deploy --guided` para crear e implementar una aplicación de producción. En este ejemplo, accederemos a un entorno de desarrollo y utilizaremos el comando `sam sync` para crear e implementar nuestra aplicación.

**nota**  
Se recomienda usar el comando `sam sync` para entornos de desarrollo. Para obtener más información, consulta [Introducción al uso sam sync de la sincronización con Nube de AWS](using-sam-cli-sync.md).

Antes de ejecutar `sam sync`, debe verificar que el proyecto esté configurado correctamente en el archivo `samconfig.toml`. Asimismo, recuerde verificar los valores de `stack_name` y `watch`. Con estos valores especificados en el archivo de configuración, no es necesario proporcionarlos en la línea de comandos.

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

A continuación, ejecuta `sam sync` para crear e implementar nuestra aplicación. Como la opción `--watch` está configurada en nuestro archivo de configuración, la CLI de AWS SAM compilará la aplicación, la implementará y estará pendiente de los cambios.

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

Ahora que la función está implementada en la nube, puede utilizar `sam remote invoke` para interactuar con ella. La CLI de AWS SAM detecta automáticamente que la función está configurada para la transmisión de respuestas e inmediatamente comienza a generar una respuesta transmitida de la función en tiempo 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
```

Cuando modificamos el código de la función, la CLI de AWS SAM detecta los cambios realizados al instante y los implementa de inmediato. Este es un ejemplo del resultado de la CLI de AWS SAM después de realizar cambios en el código de nuestra función:

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

Ahora puede volver a utilizar `sam remote invoke` para interactuar con la función en la nube y probar los cambios.

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

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

**Invocar una cola de Amazon SQS al proporcionar el ARN como ID de 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
  }
}%
```

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

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

**Para invocar una máquina de estados, proporciona su ID físico como ID de recurso:**

En primer lugar, usa `sam list resources` para obtener el ID físico:

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

A continuación, invoca la máquina de estados mediante el ID físico como ID de recurso. Transmita un evento en la línea de comandos con la opción `--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 una máquina de estados pasando un evento vacío:**

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

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

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

Para obtener documentación relacionada `sam remote invoke` con el uso del AWS SAMCLI, consulte lo siguiente:
+ [sam remote invoke](sam-cli-command-reference-remote-invoke.md)
+ [Solución de problemas para AWS SAM CLI](sam-cli-troubleshooting.md)