Introduzione ai test nel cloud con sam remote invoke - AWS Serverless Application Model
Utilizzo del comando sam remote invokeUtilizzo delle opzioni del comando sam remote invokeConfigura il file di configurazione del progettoEsempiLink correlati

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Introduzione ai test nel cloud con sam remote invoke

Utilizzate il AWS Serverless Application Model comando Command Line Interface (AWS SAM CLI) sam remote invoke per interagire con AWS le risorse supportate in. Cloud AWSÈ possibile utilizzare sam remote invoke per richiamare le seguenti risorse:

  • Amazon Kinesis Data Streams: invia record di dati alle applicazioni Kinesis Data Streams.

  • AWS Lambda— Richiama e passa eventi alle funzioni Lambda.

  • Amazon Simple Queue Service (Amazon SQS): invia messaggi alle code di Amazon SQS.

  • AWS Step Functions— Richiama le macchine a stati Step Functions per avviare l'esecuzione.

Per un'introduzione a AWS SAMCLI, vedereChe cos'è il? AWS SAMCLI.

Per un esempio di utilizzo sam remote invoke durante un tipico flusso di lavoro di sviluppo, vediFase 5: Interagite con la vostra funzione nel Cloud AWS.

Per utilizzarlosam remote invoke, installa il AWS SAMCLI completando quanto segue:

Ti consigliamo inoltre di eseguire l'aggiornamento alla versione più recente di. AWS SAMCLI Per ulteriori informazioni, consulta Aggiornamento del AWS SAMCLI.

Prima dell'usosam remote invoke, si consiglia una conoscenza di base di quanto segue:

Utilizzo del comando sam remote invoke

Prima di utilizzare questo comando, la risorsa deve essere distribuita su. Cloud AWS

Utilizza la seguente struttura di comandi ed esegui dalla directory principale del progetto:

$ sam remote invoke <arguments> <options>
Nota

Questa pagina mostrerà le opzioni fornite al prompt dei comandi. È inoltre possibile configurare le opzioni nel file di configurazione del progetto anziché passarle al prompt dei comandi. Per ulteriori informazioni, vedi Configura le impostazioni del progetto.

Per una descrizione degli sam remote invoke argomenti e delle opzioni, vederesam remote invoke.

Utilizzo con Kinesis Data Streams

È possibile inviare record di dati a un'applicazione Kinesis Data Streams. AWS SAM CLIInvierà il record di dati e restituirà uno shard ID e un numero di sequenza. Di seguito è riportato un esempio:

$ 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"
	}%
Per inviare un record di dati

  1. Fornisci un valore ID risorsa come argomento per l'applicazione Kinesis Data Streams. Per informazioni sugli ID di risorsa validi, consulta Resource ID.

  2. Fornisci il record di dati come evento da inviare all'applicazione Kinesis Data Streams. È possibile fornire l'evento dalla riga di comando utilizzando l'--eventopzione o da un file utilizzando. --event-file Se non fornisci un evento, AWS SAM CLI invia un evento vuoto.

Utilizzo con le funzioni Lambda

Puoi richiamare una funzione Lambda nel cloud e passare un evento vuoto o fornire un evento dalla riga di comando o da un file. AWS SAM CLIInvocherà la funzione Lambda e restituirà la sua risposta. Di seguito è riportato un esempio:

$ 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\"}"}%
Per richiamare una funzione Lambda

  1. Fornisci un valore ID risorsa come argomento per la tua funzione Lambda. Per informazioni sugli ID di risorsa validi, consulta Resource ID.

  2. Fornisci un evento da inviare alla tua funzione Lambda. Puoi fornire l'evento dalla riga di comando utilizzando l'--eventopzione o da un file utilizzando--event-file. Se non fornisci un evento, AWS SAM CLI invia un evento vuoto.

Funzioni Lambda configurate con lo streaming di risposte

Il sam remote invoke comando supporta le funzioni Lambda configurate per lo streaming di risposte. Puoi configurare una funzione Lambda per lo streaming delle risposte utilizzando la FunctionUrlConfig proprietà nei tuoi AWS SAM modelli. Quando si utilizzasam remote invoke, rileva AWS SAMCLI automaticamente la configurazione Lambda e la richiama con lo streaming di risposta.

Per vedere un esempio, consulta Richiama una funzione Lambda configurata per lo streaming di risposte.

Passa eventi di test condivisibili a una funzione Lambda nel cloud

Gli eventi di test condivisibili sono eventi di test che puoi condividere con altri nello stesso ambiente. Account AWS Per saperne di più, consulta Shareable test events nella AWS Lambda Developer Guide.

Accesso e gestione degli eventi di test condivisibili

È possibile utilizzare il AWS SAM CLI sam remote test-event comando per accedere e gestire eventi di test condivisibili. Ad esempio, puoi usare sam remote test-event per fare quanto segue:

  • Recupera eventi di test condivisibili dal registro degli EventBridge schemi di Amazon.

  • Modifica gli eventi di test condivisibili localmente e caricali nel registro dello EventBridge schema.

  • Elimina gli eventi di test condivisibili dal registro dello EventBridge schema.

Per ulteriori informazioni, consulta Introduzione al cloud testing con sam remote test-event.

Passa un evento di test condivisibile a una funzione Lambda nel cloud

Per passare un evento di test condivisibile dal registro degli EventBridge schemi alla tua funzione Lambda nel cloud, usa l'opzione e fornisci --test-event-name il nome dell'evento di test condivisibile. Di seguito è riportato un esempio:

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

Se salvi l'evento di test condivisibile localmente, puoi utilizzare l'--event-fileopzione e fornire il percorso del file e il nome dell'evento di test locale. Di seguito è riportato un esempio:

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

Uso di con Amazon SQS

Puoi inviare messaggi alle code di Amazon SQS. AWS SAM CLIRestituisce quanto segue:

  • ID messaggio

  • MD5 del corpo del messaggio

  • Metadati di risposta

Di seguito è riportato un esempio:

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

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

  1. Fornisci un valore ID risorsa come argomento per la coda Amazon SQS. Per informazioni sugli ID di risorsa validi, consulta Resource ID.

  2. Fornisci un evento da inviare alla tua coda Amazon SQS. Puoi fornire l'evento dalla riga di comando utilizzando l'--eventopzione o da un file utilizzando. --event-file Se non fornisci un evento, AWS SAM CLI invia un evento vuoto.

Utilizzo con Step Functions

È possibile richiamare una macchina a stati Step Functions per avviare l'esecuzione. AWS SAM CLIAttenderà il completamento del flusso di lavoro della macchina a stati e restituirà un output dell'ultimo passaggio dell'esecuzione. Di seguito è riportato un esempio:

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

Invoking Step Function HelloWorldStateMachine                                                                   
"Hello Developer World"%
Per richiamare una macchina a stati

  1. Fornisci un valore ID risorsa come argomento per la macchina a stati Step Functions. Per informazioni sugli ID di risorsa validi, vedete Resource ID.

  2. Fornisci un evento da inviare alla tua macchina a stati. È possibile fornire l'evento dalla riga di comando utilizzando l'--eventopzione o da un file utilizzando--event-file. Se non fornisci un evento, AWS SAM CLI invia un evento vuoto.

Utilizzo delle opzioni del comando sam remote invoke

Questa sezione descrive alcune delle opzioni principali che è possibile utilizzare con il sam remote invoke comando. Per un elenco completo delle opzioni, consultasam remote invoke.

Passa un evento alla tua risorsa

Utilizza le seguenti opzioni per passare eventi alle tue risorse nel cloud:

  • --event— Passa un evento dalla riga di comando.

  • --event-file— Passa un evento da un file.

Esempi Lambda

Si usa --event per passare un evento alla riga di comando come valore di stringa:

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

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

--event-fileUtilizzate per passare un evento da un file e fornire il percorso del file:

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

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

Passa un evento usandostdin:

$ 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 l'output di AWS SAMCLI risposta

Quando si richiama una risorsa supportata consam remote invoke, AWS SAMCLI restituisce una risposta che contiene quanto segue:

  • Metadati della richiesta: metadati associati alla richiesta. Ciò include l'ID della richiesta e l'ora di inizio della richiesta.

  • Risposta della risorsa: la risposta della risorsa dopo essere stata richiamata nel cloud.

È possibile utilizzare l'--outputopzione per configurare la risposta AWS SAM CLI in uscita. Sono disponibili i seguenti valori di opzione:

  • json— I metadati e la risposta delle risorse vengono restituiti in una JSON struttura. La risposta contiene l'SDKoutput completo.

  • text— I metadati vengono restituiti nella struttura del testo. La risposta della risorsa viene restituita nel formato di output della risorsa.

Di seguito è riportato un esempio di json output:

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

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

Quando si specifica un json output, viene restituita l'intera risposta astdout. Di seguito è riportato un esempio:

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

Di seguito è riportato un esempio di text output:

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

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

Quando si specifica un text output, viene restituito l'output del runtime della funzione Lambda (ad esempio, i log). stderr Il payload della funzione Lambda viene restituito a. stdout Di seguito è riportato un esempio:

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

Personalizza i parametri Boto3

Infattisam remote invoke, AWS SAM CLI utilizza l' AWS SDK for Python (Boto3) per interagire con le tue risorse nel cloud. È possibile utilizzare l'opzione per personalizzare i parametri. --parameter Boto3 Per un elenco dei parametri supportati che è possibile personalizzare, vedere--parameter.

Esempi

Invoca una funzione Lambda per convalidare i valori dei parametri e verificare le autorizzazioni:

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

Usa l'--parameteropzione più volte in un unico comando per fornire più parametri:

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

Altre opzioni

Per un elenco completo delle sam remote invoke opzioni, consultasam remote invoke.

Configura il file di configurazione del progetto

Per configurare sam remote invoke nel tuo file di configurazione, remote_invoke usalo nella tua tabella. Di seguito è riportato un esempio di samconfig.toml file che configura i valori predefiniti per il sam remote invoke comando.

...
version =0.1

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

Esempi

Per un esempio di base di utilizzosam remote invoke, consulta Testing AWS Lambda functions with AWS SAM remote nel blog di AWS Compute.

Esempi di Kinesis Data Streams

Esempi di base

Invia un record di dati a un'applicazione Kinesis Data Streams da un file. L'applicazione Kinesis Data Streams viene identificata fornendo un ARN per l'ID della risorsa:

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

Invia un evento fornito dalla riga di comando a un'applicazione 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"
}%

Ottieni l'ID fisico dell'applicazione Kinesis Data Streams. Quindi, fornisci un evento nella riga di comando:

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

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

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

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

Fornisci una stringa JSON nella riga di comando come 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"
}%

Invia un evento vuoto all'applicazione Kinesis Data Streams:

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

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

Restituisci la AWS SAM CLI risposta in 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
  }
}%

Restituisce l'output JSON su 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
  }
}%

Esempi Lambda

Esempi di base

Invoca una funzione Lambda fornendo l'ARN come ID di risorsa:

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

Invoca una funzione Lambda fornendo l'ID logico come ID di risorsa:

È inoltre necessario fornire il nome dello AWS CloudFormation stack utilizzando l'opzione. --stack-name Di seguito è riportato un esempio:

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

Se l'applicazione contiene una sola funzione Lambda, non è necessario specificarne l'ID logico. Puoi fornire solo l'--stack-nameopzione. Di seguito è riportato un esempio:

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

Invoca una funzione Lambda fornendo l'ID fisico come ID della risorsa:

L'ID fisico viene creato quando si distribuisce utilizzando. AWS CloudFormation

$ sam remote invoke sam-app-HelloWorldFunction-TZvxQRFNv0k4

Invoca una funzione Lambda di uno stack secondario:

Per questo esempio, la nostra applicazione contiene la seguente struttura di directory:

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

Per richiamare la childstack nostra funzione Lambda, eseguiamo quanto segue:

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

Richiama una funzione Lambda configurata per lo streaming di risposte

In questo esempio, utilizziamo il AWS SAMCLI per inizializzare una nuova applicazione serverless che contiene una funzione Lambda configurata per lo streaming della risposta. Distribuiamo la nostra applicazione Cloud AWS e la utilizziamo per interagire con sam remote invoke la nostra funzione nel cloud.

Iniziamo eseguendo il sam init comando per creare una nuova applicazione serverless. Selezioniamo il modello di avvio rapido Lambda Response Streaming e assegniamo un nome alla nostra applicazione. 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 il nostro progetto con la seguente struttura:

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

Di seguito è riportato un esempio del nostro codice di funzione 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();
	  }
	);

Di seguito è riportato un esempio del nostro template.yaml file. Lo streaming di risposta per la nostra funzione Lambda è configurato utilizzando la FunctionUrlConfig proprietà.

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

In genere, è possibile utilizzare sam build e sam deploy --guided creare e distribuire un'applicazione di produzione. In questo esempio, assumeremo un ambiente di sviluppo e utilizzeremo il sam sync comando per creare e distribuire la nostra applicazione.

Nota

Il sam sync comando è consigliato per ambienti di sviluppo. Per ulteriori informazioni, consulta Introduzione all'uso sam sync della sincronizzazione con Cloud AWS.

Prima dell'esecuzionesam sync, verifichiamo che il nostro progetto sia configurato correttamente nel nostro samconfig.toml file. Soprattutto, verifichiamo i valori di stack_name ewatch. Con questi valori specificati nel nostro file di configurazione, non è necessario fornirli nella riga di comando.

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

Successivamente, eseguiamo sam sync la creazione e la distribuzione della nostra applicazione. Poiché l'--watchopzione è configurata nel nostro file di configurazione, AWS SAMCLI creerà la nostra applicazione, distribuirà la nostra applicazione e controllerà le modifiche.

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

Ora che la nostra funzione è implementata nel cloud, possiamo usarla sam remote invoke per interagire con la nostra funzione. Rileva AWS SAMCLI automaticamente che la nostra funzione è configurata per lo streaming di risposte e inizia immediatamente a emettere una risposta in streaming della nostra funzione in tempo reale.

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

Quando modifichiamo il codice della nostra funzione, rileva e AWS SAMCLI implementa immediatamente le nostre modifiche. Ecco un esempio dell' AWS SAMCLIoutput dopo aver apportato modifiche al nostro codice di funzione:

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.

Ora possiamo sam remote invoke riutilizzarlo per interagire con la nostra funzione nel cloud e testare le nostre modifiche.

Esempi SQS

Esempi di base

Richiama una coda Amazon SQS fornendo l'ARN come ID di risorsa:

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

Esempi di Step Functions

Esempi di base

Richiama una macchina a stati fornendo il suo ID fisico come ID di risorsa:

Innanzitutto, sam list resources per ottenere il nostro ID fisico, utilizziamo:

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

Successivamente, invochiamo la nostra macchina a stati utilizzando l'ID fisico come ID di risorsa. Passiamo un evento alla riga di comando con l'--eventopzione:

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

Invoca una macchina a stati passando un evento vuoto:

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

Invoking Step Function HelloWorldStateMachine                                                                   
"Hello World"%

Per la documentazione relativa sam remote invoke e all'utilizzo di AWS SAMCLI, vedere quanto segue: