Introducción a las pruebas en la nube con sam remote invoke - AWS Serverless Application Model
Uso del comando sam remote invokeUso de las opciones del comando sam remote invokeConfigure el archivo de configuración de su proyectoEjemplosVínculos relacionados

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

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. Puede utilizar sam remote invoke para invocar los recursos siguientes:

  • Amazon Kinesis Data Streams: envíe registros de datos a las aplicaciones de Kinesis Data Streams.

  • AWS Lambda: invoque y pase eventos a sus funciones de Lambda.

  • Amazon Simple Queue Service (Amazon SQS): envíe mensajes a colas de Amazon SQS.

  • AWS Step Functions: invoque 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.

Para ver un ejemplo de uso de sam remote invoke durante un flujo de trabajo de desarrollo típico, consulte Paso 5: Interactúa con tu función en el Nube de AWS.

Para usar sam remote invoke, complete lo siguiente para instalar la CLI de AWS SAM:

También recomendamos actualizar a la última versión de AWS SAMCLI. Para obtener más información, consulte Actualización de la CLI de AWS SAM.

Antes de usar sam remote invoke, se recomienda tener conocimientos básicos de lo siguiente:

Uso del comando sam remote invoke

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

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

Para obtener una descripción de los argumentos sam remote invoke y las opciones, consulte sam remote invoke.

Uso con Kinesis Data Streams

Puede enviar registros de datos a una aplicación de Kinesis Data Streams. AWS SAM CLIEnviará su registro de datos y devolverá un ID 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. Proporcione un valor de ID de recurso como argumento para su aplicación Kinesis Data Streams. Para obtener información sobre los ID de recursos válidos, consulte el ID de recurso.

  2. Proporcione el registro de datos como un evento para enviarlo a la aplicación Kinesis Data Streams. Puede 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

Puede 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. Proporcione un valor de ID de recurso como argumento para su función de Lambda. Para obtener información sobre los ID de recursos válidos, consulte el ID de recurso.

  2. Proporcione un evento para que lo envíe a su función de Lambda. Puede 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

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 utilice 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, consulte Invocación de una función de Lambda configurada para transmitir respuestas.

Transfiera eventos de prueba que se puedan compartir a una función de Lambda en la nube

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, consulte los Eventos de prueba que se puedan compartir en la Guía para desarrolladores de AWS Lambda .

Acceso y administración de eventos de prueba que se puedan compartir

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.

Transfiera un evento de prueba que se pueda compartir a una función de Lambda en la nube

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 Amazon SQS

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. Proporcione un valor de ID de recurso como argumento para la cola de Amazon SQS. Para obtener información sobre los ID de recursos válidos, consulte el ID de recurso.

  2. Indique un evento para que lo envíe a la cola de Amazon SQS. Puede 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

Puede 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. Proporcione un valor de ID de recurso como argumento para la máquina de estado de Step Functions. Para obtener información sobre los ID de recursos válidos, consulte el ID de recurso.

  2. Proporcione un evento para enviarlo a su máquina de estado. Puede 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

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, consulte sam remote invoke.

Paso de un evento al recurso

Utilice 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

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

Configure la salida de respuesta de la CLI de AWS SAM

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

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

Ejemplos

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"

Utilice 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

Para obtener una lista completa de opciones sam remote invoke, consulte sam remote invoke.

Configure el archivo de configuración de su proyecto

Para configurar sam remote invoke en su archivo de configuración, utilice 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

Para ver un ejemplo básico de usosam remote invoke, consulta Probar AWS Lambda funciones con AWS SAM control remoto en el blog de AWS informática.

Ejemplos de Kinesis Data Streams

Ejemplos básicos

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

Obtenga el ID físico de la aplicación Kinesis Data Streams. A continuación, proporcione 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"
}%

Proporcione 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

Ejemplos básicos

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 debe proporcionar el nombre de la AWS 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 especifique su ID lógico. Solo puede 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, proporcione el identificador físico como identificador de recurso:

El ID físico se crea cuando se implementa utilizando AWS 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

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, consulte Introducción al uso sam sync de la sincronización con Nube de AWS.

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, ejecute 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-samclisourcebucket-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

Ejemplos básicos

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

Ejemplos básicos

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

En primer lugar, use 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, invoque 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"%

Para obtener documentación relacionada sam remote invoke con el uso de la AWS SAMCLI, consulte lo siguiente: