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 con il sam local comando Utilizzate il AWS Serverless Application Model comando Command Line Interface (AWS SAMCLI) `sam local` per testare localmente le vostre applicazioni serverless. Per un'introduzione a AWS SAMCLI, vedere[Che cos'è il? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli). ## Prerequisiti Per utilizzarlo`sam local`, AWS SAMCLI installate il compilando quanto segue: + [AWS SAM prerequisiti](prerequisites.md). + [Installa il AWS SAMCLI](install-sam-cli.md). Prima dell'uso`sam local`, si consiglia una conoscenza di base di quanto segue: + [Configurazione del AWS SAMCLI](using-sam-cli-configure.md). + [Crea la tua candidatura in AWS SAM](using-sam-cli-init.md). + [Introduzione alla costruzione con AWS SAM](using-sam-cli-build.md). + [Introduzione alla distribuzione con AWS SAM](using-sam-cli-deploy.md). ## Utilizzo del sam local comando Utilizzate il `sam local` comando con uno qualsiasi dei suoi sottocomandi per eseguire diversi tipi di test locali per l'applicazione. ``` $ sam local ``` Per ulteriori informazioni su ciascun sottocomando, vedere quanto segue: + **[Introduzione a sam local generate-event](using-sam-cli-local-generate-event.md)**— Genera Servizio AWS eventi per test locali. + **[Introduzione a sam local invoke](using-sam-cli-local-invoke.md)**— Avvia una chiamata una tantum di una funzione localmente. AWS Lambda + **[Introduzione a sam local start-api](using-sam-cli-local-start-api.md)**— Esegui le tue funzioni Lambda utilizzando un server HTTP locale. + **[Introduzione a sam local start-lambda](using-sam-cli-local-start-lambda.md)**— Esegui le tue funzioni Lambda utilizzando un server HTTP locale da utilizzare con o. AWS CLI SDKs # Introduzione ai test con sam local generate-event Utilizzate il AWS Serverless Application Model `sam local generate-event` sottocomando Command Line Interface (AWS SAMCLI) per generare esempi di payload di eventi supportati. Servizi AWS Potete quindi modificare e passare questi eventi alle risorse locali per i test. + Per un'introduzione a AWS SAMCLI, vedere [Che cos'è il? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli) + Per un elenco delle opzioni di `sam local generate-event` comando, vedere[sam local generate-event](sam-cli-command-reference-sam-local-generate-event.md). Un *evento* è un oggetto JSON che viene generato quando un Servizio AWS esegue un'azione o un'attività. Questi eventi contengono informazioni specifiche, come i dati elaborati o il timestamp dell'evento. La maggior parte Servizi AWS genera eventi e gli eventi di ogni servizio sono formattati in modo univoco per il relativo servizio. Gli eventi generati da un servizio vengono passati ad altri servizi come fonte di *eventi*. Ad esempio, un articolo inserito in un bucket Amazon Simple Storage Service (Amazon S3) può generare un evento. Questo evento può quindi essere utilizzato come origine dell'evento per una AWS Lambda funzione che elabora ulteriormente i dati. Gli eventi generati con `sam local generate-event` sono formattati nella stessa struttura degli eventi effettivi creati dal AWS servizio. È possibile modificare il contenuto di questi eventi e utilizzarli per testare le risorse dell'applicazione. ## Prerequisiti Per utilizzarlo`sam local generate-event`, AWS SAMCLI installate il completando quanto segue: + [AWS SAM prerequisiti](prerequisites.md). + [Installa il AWS SAMCLI](install-sam-cli.md). Prima dell'uso`sam local generate-event`, si consiglia una conoscenza di base di quanto segue: + [Configurazione del AWS SAMCLI](using-sam-cli-configure.md). + [Crea la tua candidatura in AWS SAM](using-sam-cli-init.md). + [Introduzione alla costruzione con AWS SAM](using-sam-cli-build.md). + [Introduzione alla distribuzione con AWS SAM](using-sam-cli-deploy.md). ## Genera eventi di esempio Usa il AWS SAMCLI `sam local generate-event` sottocomando per generare eventi per i supporti Servizi AWS. **Per visualizzare un elenco di quelli supportati Servizi AWS** 1. Esegui il seguente codice: ``` $ sam local generate-event ``` 1. Servizi AWS Verrà visualizzato l'elenco dei supportati. Di seguito è riportato un esempio: ``` $ sam local generate-event ... Commands: alb alexa-skills-kit alexa-smart-home apigateway appsync batch cloudformation ... ``` **Per generare un evento locale** 1. Esegui `sam local generate-event` e fornisci il nome del servizio supportato. Verrà visualizzato un elenco di tipi di eventi che è possibile generare. Di seguito è riportato un esempio: ``` $ sam local generate-event s3 Usage: sam local generate-event s3 [OPTIONS] COMMAND [ARGS]... Options: -h, --help Show this message and exit. Commands: batch-invocation Generates an Amazon S3 Batch Operations Invocation Event delete Generates an Amazon S3 Delete Event put Generates an Amazon S3 Put Event ``` 1. Per generare l'evento di esempio, esegui`sam local generate-event`, fornendo il servizio e il tipo di evento. ``` $ sam local generate-event ``` Di seguito è riportato un esempio: ``` $ sam local generate-event s3 put { "Records": [ { "eventVersion": "2.0", "eventSource": "aws:s3", "awsRegion": "us-east-1", "eventTime": "1970-01-01T00:00:00.000Z", "eventName": "ObjectCreated:Put", "userIdentity": { "principalId": "EXAMPLE" }, "requestParameters": { "sourceIPAddress": "127.0.0.1" }, "responseElements": { "x-amz-request-id": "EXAMPLE123456789", "x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH" }, "s3": { "s3SchemaVersion": "1.0", "configurationId": "testConfigRule", "bucket": { "name": "sam-s3-demo-bucket", "ownerIdentity": { "principalId": "EXAMPLE" }, "arn": "arn:aws:s3:::sam-s3-demo-bucket" }, "object": { "key": "test/key", "size": 1024, "eTag": "0123456789abcdef0123456789abcdef", "sequencer": "0A1B2C3D4E5F678901" } } } ] } ``` Questi eventi di esempio contengono valori segnaposto. È possibile modificare questi valori in modo che facciano riferimento alle risorse effettive dell'applicazione o ai valori per facilitare i test locali. **Per modificare un evento di esempio** 1. È possibile modificare gli eventi di esempio al prompt dei comandi. Per visualizzare le opzioni disponibili, esegui quanto segue: ``` $ sam local generate-event --help ``` Di seguito è riportato un esempio: ``` $ sam local generate-event s3 put --help Usage: sam local generate-event s3 put [OPTIONS] Options: --region TEXT Specify the region name you'd like, otherwise the default = us-east-1 --partition TEXT Specify the partition name you'd like, otherwise the default = aws --bucket TEXT Specify the bucket name you'd like, otherwise the default = example-bucket --key TEXT Specify the key name you'd like, otherwise the default = test/key --debug Turn on debug logging to print debug message generated by AWS SAM CLI and display timestamps. --config-file TEXT Configuration file containing default parameter values. [default: samconfig.toml] --config-env TEXT Environment name specifying default parameter values in the configuration file. [default: default] -h, --help Show this message and exit. ``` 1. Utilizzate una di queste opzioni al prompt dei comandi per modificare il payload dell'evento di esempio. Di seguito è riportato un esempio: ``` $ sam local generate-event s3 put--bucket sam-s3-demo-bucket { "Records": [ { "eventVersion": "2.0", "eventSource": "aws:s3", "awsRegion": "us-east-1", "eventTime": "1970-01-01T00:00:00.000Z", "eventName": "ObjectCreated:Put", "userIdentity": { "principalId": "EXAMPLE" }, "requestParameters": { "sourceIPAddress": "127.0.0.1" }, "responseElements": { "x-amz-request-id": "EXAMPLE123456789", "x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH" }, "s3": { "s3SchemaVersion": "1.0", "configurationId": "testConfigRule", "bucket": { "name": "sam-s3-demo-bucket", "ownerIdentity": { "principalId": "EXAMPLE" }, "arn": "arn:aws:s3:::sam-s3-demo-bucket" }, "object": { "key": "test/key", "size": 1024, "eTag": "0123456789abcdef0123456789abcdef", "sequencer": "0A1B2C3D4E5F678901" } } } ] } ``` ## Usa gli eventi generati per i test locali Salva gli eventi generati localmente e usa altri `sam local` sottocomandi per eseguire i test. **Per salvare gli eventi generati localmente** + Esegui il seguente codice: ``` $ sam local generate-event > ``` Di seguito è riportato un esempio di evento salvato come `s3.json` file nella `events` cartella del nostro progetto. ``` sam-app$ sam local generate-event s3 put --bucket amzn-s3-demo-bucket > events/s3.json ``` **Per utilizzare un evento generato per i test locali** + Passa l'evento con altri `sam local` sottocomandi utilizzando l'`--event`opzione. Di seguito è riportato un esempio di utilizzo dell'`s3.json`evento per richiamare la nostra funzione Lambda localmente: ``` sam-app$ sam local invoke --event events/s3.json S3JsonLoggerFunction Invoking src/handlers/s3-json-logger.s3JsonLoggerHandler (nodejs18.x) Local image is up-to-date Using local image: public.ecr.aws/lambda/nodejs:18-rapid-x86_64. Mounting /Users/.../sam-app/.aws-sam/build/S3JsonLoggerFunction as /var/task:ro,delegated, inside runtime container START RequestId: f4f45b6d-2ec6-4235-bc7b-495ec2ae0128 Version: $LATEST END RequestId: f4f45b6d-2ec6-4235-bc7b-495ec2ae0128 REPORT RequestId: f4f45b6d-2ec6-4235-bc7b-495ec2ae0128 Init Duration: 1.23 ms Duration: 9371.93 ms Billed Duration: 9372 ms Memory Size: 128 MB Max Memory Used: 128 MB ``` ## Ulteriori informazioni Per un elenco di tutte le `sam local generate-event` opzioni, consulta[sam local generate-event](sam-cli-command-reference-sam-local-generate-event.md). Per una dimostrazione dell'utilizzo`sam local`, vedi [AWS SAM per lo sviluppo locale. Test Cloud AWS delle risorse provenienti da ambienti di sviluppo locali](https://www.youtube.com/watch?v=NzPqMrdgD1s&list=PLJo-rJlep0ED198FJnTzhIB5Aut_1vDAd&index=24) nella *serie Serverless Land Sessions with SAM on YouTube*. # Introduzione ai test con sam local invoke Utilizzate il AWS Serverless Application Model `sam local invoke` sottocomando Command Line Interface (AWS SAMCLI) per avviare una chiamata una tantum di una funzione localmente. AWS Lambda + Per un'introduzione a, vedere AWS SAMCLI [Che cos'è il? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli) + Per un elenco delle opzioni di `sam local invoke` comando, vedere[sam local invoke](sam-cli-command-reference-sam-local-invoke.md). + Per un esempio di utilizzo `sam local invoke` durante un tipico flusso di lavoro di sviluppo, vedi[Passaggio 7: (Facoltativo) Testa l'applicazione localmente](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-test). **Nota** Non è consigliabile utilizzare le funzionalità di richiamo locale di SAM CLI in codice non attendibile. Per ottenere un isolamento completo dall'ambiente locale, esegui il codice direttamente nel servizio Lambda. **Nota** `sam local invoke`supporta funzioni durevoli con funzionalità di checkpoint e replay automatici. Quando si richiamano funzioni durevoli localmente, lo stato di esecuzione viene gestito automaticamente. ## Prerequisiti Per utilizzarlo`sam local invoke`, installa il AWS SAMCLI completando quanto segue: + [AWS SAM prerequisiti](prerequisites.md). + [Installa il AWS SAMCLI](install-sam-cli.md). Prima dell'uso`sam local invoke`, si consiglia una conoscenza di base di quanto segue: + [Configurazione del AWS SAMCLI](using-sam-cli-configure.md). + [Crea la tua candidatura in AWS SAM](using-sam-cli-init.md). + [Introduzione alla costruzione con AWS SAM](using-sam-cli-build.md). + [Introduzione alla distribuzione con AWS SAM](using-sam-cli-deploy.md). ## Richiama una funzione Lambda localmente Quando si esegue`sam local invoke`, si AWS SAMCLI presuppone che la directory di lavoro corrente sia la directory principale del progetto. AWS SAMCLICercheranno innanzitutto un `template.[yaml|yml]` file all'interno di una `.aws-sam` sottocartella. Se non viene trovato, AWS SAMCLI cercherà un `template.[yaml|yml]` file all'interno della directory di lavoro corrente. **Per richiamare una funzione Lambda localmente** 1. Dalla directory principale del progetto, esegui quanto segue: ``` $ sam local invoke ``` 1. Se l'applicazione contiene più di una funzione, fornite l'ID logico della funzione. Di seguito è riportato un esempio: ``` $ sam local invoke HelloWorldFunction ``` 1. AWS SAMCLICostruisce la tua funzione in un contenitore locale utilizzandoDocker. Quindi richiama la tua funzione e restituisce la risposta della tua funzione. Di seguito è riportato un esempio: ``` $ sam local invoke Invoking app.lambda_handler (python3.9) Local image is out of date and will be updated to the latest runtime. To skip this, pass in the parameter --skip-pull-image Building image.................................................................................................................... Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df Version: $LATEST END RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df REPORT RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df Init Duration: 1.09 ms Duration: 608.42 ms Billed Duration: 609 ms Memory Size: 128 MB Max Memory Used: 128 MB {"statusCode": 200, "body": "{\"message\": \"hello world\"}"}% ``` ### Gestione dei log Quando si utilizza`sam local invoke`, l'output del runtime della funzione Lambda (ad esempio, i log) viene emesso su e il risultato della funzione Lambda viene emesso su. `stderr` `stdout` Di seguito è riportato un esempio di una funzione Lambda di base: ``` def handler(event, context): print("some log") # this goes to stderr return "hello world" # this goes to stdout ``` È possibile salvare queste uscite standard. Di seguito è riportato un esempio: ``` $ sam local invoke 1> stdout.log ... $ cat stdout.log "hello world" $ sam local invoke 2> stderr.log ... $ cat stderr.log Invoking app.lambda_handler (python3.9) Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: 0b46e646-3bdf-4b58-8beb-242d00912c46 Version: $LATEST some log END RequestId: 0b46e646-3bdf-4b58-8beb-242d00912c46 REPORT RequestId: 0b46e646-3bdf-4b58-8beb-242d00912c46 Init Duration: 0.91 ms Duration: 589.19 ms Billed Duration: 590 ms Memory Size: 128 MB Max Memory Used: 128 MB ``` È possibile utilizzare questi output standard per automatizzare ulteriormente i processi di sviluppo locale. ## Opzioni ### Passa eventi personalizzati per richiamare la funzione Lambda Per passare un evento alla funzione Lambda, utilizzate l'`--event`opzione. Di seguito è riportato un esempio: ``` $ sam local invoke --event events/s3.json S3JsonLoggerFunction ``` È possibile creare eventi con il `sam local generate-event` sottocomando. Per ulteriori informazioni, consulta [Introduzione ai test con sam local generate-event](using-sam-cli-local-generate-event.md). ### Passa le variabili di ambiente quando richiami la funzione Lambda Se la tua funzione Lambda utilizza variabili di ambiente, puoi passarle durante i test locali con l'`--env-vars`opzione. Questo è un ottimo modo per testare una funzione Lambda localmente con i servizi dell'applicazione che sono già distribuiti nel cloud. Di seguito è riportato un esempio: ``` $ sam local invoke --env-vars locals.json ``` ### Specificate un modello o una funzione Per specificare un modello AWS SAMCLI a cui fare riferimento, utilizzate l'`--template`opzione. AWS SAMCLICaricherà solo quel AWS SAM modello e le risorse a cui punta. Per richiamare una funzione di un'applicazione o di uno stack annidato, fornisci l'ID logico dell'applicazione o dello stack insieme all'ID logico della funzione. Di seguito è riportato un esempio: ``` $ sam local invoke StackLogicalId/FunctionLogicalId ``` ### Prova una funzione Lambda dal tuo progetto Terraform Usa l'`--hook-name`opzione per testare localmente le funzioni Lambda dei tuoi Terraform progetti. Per ulteriori informazioni, consulta [Utilizzo di AWS SAMCLI with Terraform per il debug e il test locali](using-samcli-terraform.md). Di seguito è riportato un esempio: ``` $ sam local invoke --hook-name terraform --beta-features ``` ## Best practice Se la tua applicazione ha una `.aws-sam` directory in esecuzione`sam build`, assicurati di eseguirla `sam build` ogni volta che aggiorni il codice della funzione. Quindi, `sam local invoke` esegui per testare localmente il codice funzionale aggiornato. I test locali sono un'ottima soluzione per lo sviluppo e il test rapidi prima della distribuzione nel cloud. Tuttavia, i test locali non convalidano tutto, come le autorizzazioni tra le risorse nel cloud. Per quanto possibile, testa le tue applicazioni nel cloud. Ti consigliamo di [`sam sync`utilizzarlo](using-sam-cli-sync.md) per velocizzare i flussi di lavoro di test sul cloud. ## Esempi ### Genera un evento di esempio Amazon API Gateway e utilizzalo per richiamare una funzione Lambda localmente Innanzitutto, generiamo un payload di eventi API Gateway HTTP API Gateway e lo salviamo `events` nella nostra cartella. ``` $ sam local generate-event apigateway http-api-proxy > events/apigateway_event.json ``` Successivamente, modifichiamo la nostra funzione Lambda per restituire un valore di parametro dall'evento. ``` def lambda_handler(event, context): print("HelloWorldFunction invoked") return { "statusCode": 200, "body": json.dumps({ "message": event['queryStringParameters']['parameter2'], }), } ``` Successivamente, invochiamo localmente la nostra funzione Lambda e forniamo il nostro evento personalizzato. ``` $ sam local invoke --event events/apigateway_event.json Invoking app.lambda_handler (python3.9) Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/...sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Version: $LATEST some log END RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 REPORT RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Init Duration: 1.63 ms Duration: 564.07 ms Billed Duration: 565 ms Memory Size: 128 MB Max Memory Used: 128 MB {"statusCode": 200, "body": "{\"message\": \"value\"}"}% ``` ### Passa le variabili di ambiente quando richiami una funzione Lambda localmente Questa applicazione dispone di una funzione Lambda che utilizza una variabile di ambiente per il nome di una tabella Amazon DynamoDB. Di seguito è riportato un esempio della funzione definita nel modello: AWS SAM ``` AWSTemplateFormatVersion: 2010-09-09 Transform: AWS::Serverless-2016-10-31 ... Resources: getAllItemsFunction: Type: AWS::Serverless::Function Properties: Handler: src/get-all-items.getAllItemsHandler Description: get all items Policies: - DynamoDBReadPolicy: TableName: !Ref SampleTable Environment: Variables: SAMPLE_TABLE: !Ref SampleTable ... ``` Vogliamo testare localmente la nostra funzione Lambda facendola interagire con la nostra tabella DynamoDB nel cloud. Per fare ciò, creiamo il nostro file delle variabili di ambiente e lo salviamo nella directory principale del nostro progetto come. `locals.json` Il valore fornito qui per `SAMPLE_TABLE` fa riferimento alla nostra tabella DynamoDB nel cloud. ``` { "getAllItemsFunction": { "SAMPLE_TABLE": "dev-demo-SampleTable-1U991234LD5UM98" } } ``` Successivamente, eseguiamo `sam local invoke` e passiamo le nostre variabili di ambiente con l'`--env-vars`opzione. ``` $ sam local invoke getAllItemsFunction --env-vars locals.json Mounting /Users/...sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Version: $LATEST some log END RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 REPORT RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Init Duration: 1.63 ms Duration: 564.07 ms Billed Duration: 565 ms Memory Size: 128 MB Max Memory Used: 128 MB {"statusCode":200,"body":"{}"} ``` ## Ulteriori informazioni Per un elenco di tutte le `sam local invoke` opzioni, vedi[sam local invoke](sam-cli-command-reference-sam-local-invoke.md). Per una dimostrazione dell'utilizzo`sam local`, vedi [AWS SAM per lo sviluppo locale. Test Cloud AWS delle risorse provenienti da ambienti di sviluppo locali](https://www.youtube.com/watch?v=NzPqMrdgD1s&list=PLJo-rJlep0ED198FJnTzhIB5Aut_1vDAd&index=24) nella *serie Serverless Land Sessions with SAM on YouTube*. # Introduzione ai test con sam local start-api Utilizzate il AWS Serverless Application Model `sam local start-api` sottocomando Command Line Interface (AWS SAMCLI) per eseguire le AWS Lambda funzioni localmente e testarle tramite un host di server HTTP locale. Questo tipo di test è utile per le funzioni Lambda richiamate da un endpoint Amazon API Gateway. + Per un'introduzione a, consulta AWS SAMCLI [Che cos'è il? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli) + Per un elenco delle opzioni di `sam local start-api` comando, vedere[sam local start-api](sam-cli-command-reference-sam-local-start-api.md). + Per un esempio di utilizzo `sam local start-api` durante un tipico flusso di lavoro di sviluppo, vedi[Passaggio 7: (Facoltativo) Testa l'applicazione localmente](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-test). **Nota** `sam local start-api`supporta funzioni durevoli con funzionalità di checkpoint e replay automatici. Le funzioni durevoli funzionano perfettamente con l'endpoint API Gateway locale. ## Prerequisiti Per utilizzarlo`sam local start-api`, installa il AWS SAMCLI completando quanto segue: + [AWS SAM prerequisiti](prerequisites.md). + [Installa il AWS SAMCLI](install-sam-cli.md). Prima dell'uso`sam local start-api`, si consiglia una conoscenza di base di quanto segue: + [Configurazione del AWS SAMCLI](using-sam-cli-configure.md). + [Crea la tua candidatura in AWS SAM](using-sam-cli-init.md). + [Introduzione alla costruzione con AWS SAM](using-sam-cli-build.md). + [Introduzione alla distribuzione con AWS SAM](using-sam-cli-deploy.md). ## Usare sam local start-api Quando si esegue`sam local start-api`, si AWS SAMCLI presuppone che la directory di lavoro corrente sia la directory principale del progetto. AWS SAMCLICercheranno innanzitutto un `template.[yaml|yml]` file all'interno di una `.aws-sam` sottocartella. Se non viene trovato, AWS SAMCLI cercherà un `template.[yaml|yml]` file all'interno della directory di lavoro corrente. **Per avviare un server HTTP locale** 1. Dalla directory principale del progetto, esegui quanto segue: ``` $ sam local start-api ``` 1. AWS SAMCLICrea le tue funzioni Lambda in un Docker contenitore locale. Quindi restituisce l'indirizzo locale dell'endpoint del server HTTP. Di seguito è riportato un esempio: ``` $ sam local start-api Initializing the lambda functions containers. Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container Containers Initialization is done. Mounting HelloWorldFunction at http://127.0.0.1:3000/hello [GET] You can now browse to the above endpoints to invoke your functions. You do not need to restart/reload SAM CLI while working on your functions, changes will be reflected instantly/automatically. If you used sam build before running local commands, you will need to re-run sam build for the changes to be picked up. You only need to restart SAM CLI if you update your AWS SAM template 2023-04-12 14:41:05 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on http://127.0.0.1:3000 ``` 1. È possibile richiamare la funzione Lambda tramite il browser o il prompt dei comandi. Di seguito è riportato un esempio: ``` sam-app$ curl http://127.0.0.1:3000/hello {"message": "Hello world!"}% ``` 1. Quando apporti modifiche al codice della funzione Lambda, considera quanto segue per aggiornare il server HTTP locale: + Se l'applicazione non dispone di una `.aws-sam` directory e la funzione utilizza un linguaggio interpretato, AWS SAMCLI aggiornerà automaticamente la funzione creando un nuovo contenitore e ospitandolo. + Se l'applicazione dispone di una `.aws-sam` directory, è necessario eseguirla `sam build` per aggiornare la funzione. Quindi esegui `sam local start-api` nuovamente per ospitare la funzione. + Se la tua funzione utilizza un linguaggio compilato o se il tuo progetto richiede un supporto complesso per la creazione di pacchetti, esegui la tua soluzione di compilazione per aggiornare la funzione. Quindi esegui `sam local start-api` nuovamente per ospitare la funzione. ### Funzioni Lambda che utilizzano gli autorizzatori Lambda **Nota** Questa funzionalità è nuova nella AWS SAMCLI versione 1.80.0. Per eseguire l'aggiornamento, consulta [Aggiornamento del AWS SAMCLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade). Per le funzioni Lambda che utilizzano gli autorizzatori Lambda, richiameranno AWS SAMCLI automaticamente l'autorizzatore Lambda prima di richiamare l'endpoint della funzione Lambda. Di seguito è riportato un esempio di avvio di un server HTTP locale per una funzione che utilizza un autorizzatore Lambda: ``` $ sam local start-api 2023-04-17 15:02:13 Attaching import module proxy for analyzing dynamic imports AWS SAM CLI does not guarantee 100% fidelity between authorizers locally and authorizers deployed on AWS. Any application critical behavior should be validated thoroughly before deploying to production. Testing application behaviour against authorizers deployed on AWS can be done using the sam sync command. Mounting HelloWorldFunction at http://127.0.0.1:3000/authorized-request [GET] You can now browse to the above endpoints to invoke your functions. You do not need to restart/reload SAM CLI while working on your functions, changes will be reflected instantly/automatically. If you used sam build before running local commands, you will need to re-run sam build for the changes to be picked up. You only need to restart SAM CLI if you update your AWS SAM template 2023-04-17 15:02:13 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on http://127.0.0.1:3000 2023-04-17 15:02:13 Press CTRL+C to quit ``` Quando richiami l'endpoint della funzione Lambda tramite il server HTTP locale, il primo richiama AWS SAMCLI l'autorizzazione Lambda. Se l'autorizzazione ha esito positivo, AWS SAMCLI invocherà l'endpoint della funzione Lambda. Di seguito è riportato un esempio: ``` $ curl http://127.0.0.1:3000/authorized-request --header "header:my_token" {"message": "from authorizer"}% Invoking app.authorizer_handler (python3.8) Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.8-rapid-x86_64. Mounting /Users/.../sam-app/... as /var/task:ro,delegated, inside runtime container START RequestId: 38d3b472-a2c8-4ea6-9a77-9b386989bef0 Version: $LATEST END RequestId: 38d3b472-a2c8-4ea6-9a77-9b386989bef0 REPORT RequestId: 38d3b472-a2c8-4ea6-9a77-9b386989bef0 Init Duration: 1.08 ms Duration: 628.26 msBilled Duration: 629 ms Memory Size: 128 MB Max Memory Used: 128 MB Invoking app.request_handler (python3.8) Using local image: public.ecr.aws/lambda/python:3.8-rapid-x86_64. Mounting /Users/.../sam-app/... as /var/task:ro,delegated, inside runtime container START RequestId: fdc12255-79a3-4365-97e9-9459d06446ff Version: $LATEST END RequestId: fdc12255-79a3-4365-97e9-9459d06446ff REPORT RequestId: fdc12255-79a3-4365-97e9-9459d06446ff Init Duration: 0.95 ms Duration: 659.13 msBilled Duration: 660 ms Memory Size: 128 MB Max Memory Used: 128 MB No Content-Type given. Defaulting to 'application/json'. 2023-04-17 15:03:03 127.0.0.1 - - [17/Apr/2023 15:03:03] "GET /authorized-request HTTP/1.1" 200 - ``` ## Opzioni ### Riutilizza continuamente i contenitori per velocizzare le chiamate alle funzioni locali Per impostazione predefinita, AWS SAMCLI crea un nuovo contenitore ogni volta che la funzione viene richiamata tramite il server HTTP locale. Utilizzate l'`--warm-containers`opzione per riutilizzare automaticamente il contenitore per le chiamate di funzioni. Ciò velocizza il tempo necessario per AWS SAMCLI preparare la funzione Lambda per la chiamata locale. È possibile personalizzare ulteriormente questa opzione fornendo l'`eager`argomento or. `lazy` + `eager`— I contenitori per tutte le funzioni vengono caricati all'avvio e persistono tra una chiamata e l'altra. + `lazy`— I contenitori vengono caricati solo quando ogni funzione viene richiamata per la prima volta. Quindi persistono per ulteriori invocazioni. Di seguito è riportato un esempio: ``` $ sam local start-api --warm-containers eager ``` Quando usi `--warm-containers` e modifichi il codice della funzione Lambda: + Se l'applicazione ha una `.aws-sam` directory, eseguila `sam build` per aggiornare il codice della funzione negli artefatti di build dell'applicazione. + Quando viene rilevata una modifica al codice, spegne AWS SAMCLI automaticamente il contenitore delle funzioni Lambda. + Quando richiami nuovamente la funzione, crea AWS SAMCLI automaticamente un nuovo contenitore. ### Specificate un'immagine del contenitore da usare per le funzioni Lambda Per impostazione predefinita, AWS SAMCLI utilizza immagini di base Lambda da Amazon Elastic Container Registry (Amazon ECR) per richiamare le funzioni localmente. Usa l'`--invoke-image`opzione per fare riferimento a un'immagine del contenitore personalizzata. Di seguito è riportato un esempio: ``` $ sam local start-api --invoke-image public.ecr.aws/sam/emu-python3.8 ``` È possibile specificare la funzione da utilizzare con l'immagine del contenitore personalizzata. Di seguito è riportato un esempio: ``` $ sam local start-api --invoke-image Function1=amazon/aws/sam-cli-emulation-image-python3.8 ``` ### Specificate un modello da testare localmente Per specificare un modello AWS SAMCLI a cui fare riferimento, utilizzate l'`--template`opzione. AWS SAMCLICaricherà solo quel AWS SAM modello e le risorse a cui punta. Di seguito è riportato un esempio: ``` $ sam local start-api --template myTemplate.yaml ``` ### Specificate l'ambiente di sviluppo host della vostra funzione Lambda Per impostazione predefinita, il `sam local start-api` sottocomando crea un server HTTP utilizzando `localhost` un indirizzo IP. `127.0.0.1` È possibile personalizzare questi valori se l'ambiente di sviluppo locale è isolato dal computer locale. Utilizzate l'`--container-host`opzione per specificare un host. Di seguito è riportato un esempio: ``` $ sam local start-api --container-host host.docker.internal ``` Utilizzate l'`--container-host-interface`opzione per specificare l'indirizzo IP della rete host a cui devono collegarsi le porte del contenitore. Di seguito è riportato un esempio: ``` $ sam local start-api --container-host-interface 0.0.0.0 ``` ## Best practice Se l'applicazione ha una `.aws-sam` directory in esecuzione`sam build`, assicuratevi di eseguirla `sam build` ogni volta che aggiornate il codice della funzione. Quindi, `sam local start-api` esegui per testare localmente il codice funzionale aggiornato. I test locali sono un'ottima soluzione per lo sviluppo e il test rapidi prima della distribuzione nel cloud. Tuttavia, i test locali non convalidano tutto, come le autorizzazioni tra le risorse nel cloud. Per quanto possibile, testa le tue applicazioni nel cloud. Ti consigliamo di [`sam sync`utilizzarlo](using-sam-cli-sync.md) per velocizzare i flussi di lavoro di test sul cloud. ## Ulteriori informazioni Per un elenco di tutte le `sam local start-api` opzioni, consulta[sam local start-api](sam-cli-command-reference-sam-local-start-api.md). # Introduzione ai test con sam local start-lambda Usa il AWS SAMCLI sottocomando `sam local start-lambda` per richiamare la funzione Lambda tramite and. AWS CLI SDKs Questo comando avvia un endpoint locale che emula Lambda. + Per un'introduzione a, vedere AWS SAMCLI [Che cos'è il? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli) + Per un elenco delle opzioni di `sam local start-lambda` comando, vedere[sam local start-lambda](sam-cli-command-reference-sam-local-start-lambda.md). **Nota** `sam local start-lambda`supporta funzioni durevoli con funzionalità di checkpoint e replay automatici. Le funzioni durevoli funzionano perfettamente con l'endpoint Lambda locale. ## Prerequisiti Per utilizzarlo`sam local start-lambda`, installa il AWS SAMCLI completando quanto segue: + [AWS SAM prerequisiti](prerequisites.md). + [Installa il AWS SAMCLI](install-sam-cli.md). Prima dell'uso`sam local start-lambda`, si consiglia una conoscenza di base di quanto segue: + [Configurazione del AWS SAMCLI](using-sam-cli-configure.md). + [Crea la tua candidatura in AWS SAM](using-sam-cli-init.md). + [Introduzione alla costruzione con AWS SAM](using-sam-cli-build.md). + [Introduzione alla distribuzione con AWS SAM](using-sam-cli-deploy.md). ## Usare sam local start-lambda Quando si esegue`sam local start-lambda`, si AWS SAMCLI presuppone che la directory di lavoro corrente sia la directory principale del progetto. AWS SAMCLICercheranno innanzitutto un `template.[yaml|yml]` file all'interno di una `.aws-sam` sottocartella. Se non viene trovato, AWS SAMCLI cercherà un `template.[yaml|yml]` file all'interno della directory di lavoro corrente. **Per usare sam local start-lambda** 1. Dalla directory principale del progetto, esegui quanto segue: ``` $ sam local start-lambda ``` 1. AWS SAMCLICrea le tue funzioni Lambda in un Docker contenitore locale. Quindi invia l'indirizzo locale all'endpoint del server HTTP. Di seguito è riportato un esempio: ``` $ sam local start-lambda Initializing the lambda functions containers. Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../sam-app/hello_world as /var/task:ro,delegated, inside runtime container Containers Initialization is done. Starting the Local Lambda Service. You can now invoke your Lambda Functions defined in your template through the endpoint. 2023-04-13 07:25:43 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on http://127.0.0.1:3001 2023-04-13 07:25:43 Press CTRL+C to quit ``` 1. Usa AWS CLI o SDKs per richiamare la funzione Lambda localmente. Di seguito è riportato un esempio di utilizzo di: AWS CLI ``` $ aws lambda invoke --function-name "HelloWorldFunction" --endpoint-url "http://127.0.0.1:3001" --no-verify-ssl out.txt StatusCode: 200 (END) ``` Di seguito è riportato un esempio di utilizzo del AWS SDK comando forPython: ``` import boto3 from botocore.config import Config from botocore import UNSIGNED lambda_client = boto3.client('lambda', endpoint_url="http://127.0.0.1:3001", use_ssl=False, verify=False, config=Config(signature_version=UNSIGNED, read_timeout=1, retries={'max_attempts': 0} ) ) lambda_client.invoke(FunctionName="HelloWorldFunction") ``` ## Opzioni ### Specificare un modello Per specificare un modello AWS SAMCLI a cui fare riferimento, utilizzate l'`--template`opzione. AWS SAMCLICaricherà solo quel AWS SAM modello e le risorse a cui punta. Di seguito è riportato un esempio: ``` $ sam local start-lambda --template myTemplate.yaml ``` Per ulteriori informazioni sui AWS SAM modelli, vedere[AWS SAM anatomia del modello](sam-specification-template-anatomy.md). ## Best practice Se l'applicazione ha una `.aws-sam` directory in esecuzione`sam build`, assicurati di eseguirla `sam build` ogni volta che aggiorni il codice della funzione. Quindi, `sam local start-lambda` esegui per testare localmente il codice funzionale aggiornato. I test locali sono un'ottima soluzione per lo sviluppo e il test rapidi prima della distribuzione nel cloud. Tuttavia, i test locali non convalidano tutto, come le autorizzazioni tra le risorse nel cloud. Per quanto possibile, testa le tue applicazioni nel cloud. Ti consigliamo di [`sam sync`utilizzarlo](using-sam-cli-sync.md) per velocizzare i flussi di lavoro di test sul cloud. ## Ulteriori informazioni Per un elenco di tutte le `sam local start-lambda` opzioni, consulta[sam local start-lambda](sam-cli-command-reference-sam-local-start-lambda.md).