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à. # Registrare e monitorare le funzioni Lambda con Python AWS Lambda monitora automaticamente le funzioni Lambda e invia le voci di registro ad Amazon. CloudWatch La funzione Lambda include un gruppo di log CloudWatch Logs e un flusso di log per ogni istanza della funzione. L'ambiente di runtime di Lambda invia al flusso di log i dettagli su ogni invocazione e altri output dal codice della funzione. Per ulteriori informazioni sui CloudWatch registri, consulta. [Lambda invia automaticamente i log delle funzioni a CloudWatch Logs.](monitoring-cloudwatchlogs.md) Per l'output dei log dal codice della funzione, puoi utilizzare il modulo di [https://docs.python.org/3/library/logging.html](https://docs.python.org/3/library/logging.html) integrato. Per ottenere voci più dettagliate, puoi utilizzare qualunque libreria di log che scrive in `stdout` o `stderr`. ## Stampa nel log Per inviare l'output base ai log, puoi utilizzare un metodo `print` nella funzione. L'esempio seguente registra i valori del gruppo e del flusso di log CloudWatch Logs e dell'oggetto evento. Nota che se la tua funzione genera log usando istruzioni Python`print`, Lambda può inviare output di log a Logs solo in formato testo semplice. CloudWatch Per acquisire i log in formato JSON strutturato, è necessario utilizzare una libreria di registrazione supportata. Per ulteriori informazioni, consulta [Utilizzo dei controlli di registrazione avanzati di Lambda con Python](#python-logging-advanced). **Example lambda\$1function.py** ``` import os def lambda_handler(event, context): print('## ENVIRONMENT VARIABLES') print(os.environ['AWS_LAMBDA_LOG_GROUP_NAME']) print(os.environ['AWS_LAMBDA_LOG_STREAM_NAME']) print('## EVENT') print(event) ``` **Example Output log** ``` START RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Version: $LATEST ## ENVIRONMENT VARIABLES /aws/lambda/my-function 2025/08/31/[$LATEST]3893xmpl7fac4485b47bb75b671a283c ## EVENT {'key': 'value'} END RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 REPORT RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Duration: 15.74 ms Billed Duration: 147 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 130.49 ms XRAY TraceId: 1-5e34a614-10bdxmplf1fb44f07bc535a1 SegmentId: 07f5xmpl2d1f6f85 Sampled: true ``` Il runtime di Python registra `START`, `END` e `REPORT` per ogni chiamata. La riga `REPORT` include i seguenti dati: **Campi dati della riga REPORT** + **RequestId**— L'ID univoco della richiesta per la chiamata. + **Durata** – La quantità di tempo che il metodo del gestore della funzione impiega durante l'elaborazione dell'evento. + **Durata fatturata** – La quantità di tempo fatturata per la chiamata. + **Dimensioni memoria** – La quantità di memoria allocata per la funzione. + **Quantità max utilizzata** – La quantità di memoria utilizzata dalla funzione. Quando le invocazioni condividono un ambiente di esecuzione, Lambda riporta la memoria massima utilizzata in tutte le invocazioni. Questo comportamento potrebbe comportare un valore riportato superiore al previsto. + **Durata Init** – Per la prima richiesta servita, la quantità di tempo impiegato dal runtime per caricare la funzione ed eseguire il codice al di fuori del metodo del gestore. + **XRAY TraceId** [— Per le richieste tracciate, l'ID di traccia.AWS X-Ray](services-xray.md) + **SegmentId**— Per le richieste tracciate, l'ID del segmento X-Ray. + **Campionato** – Per le richieste tracciate, il risultato del campionamento. ## Utilizzo di una libreria di log Per registri più dettagliati, utilizza il modulo di [log](https://docs.python.org/3/library/logging.html) nella libreria standard o qualunque libreria di log di terzi che scrive in `stdout` o `stderr`. Per i runtime Python supportati, puoi scegliere se i log creati utilizzando il modulo `logging` standard vengono acquisiti in testo normale o JSON. Per ulteriori informazioni, consulta [Utilizzo dei controlli di registrazione avanzati di Lambda con Python](#python-logging-advanced). Attualmente, il formato di log predefinito per tutti i runtime di Python è il testo normale. L'esempio seguente mostra come gli output di registro creati utilizzando il `logging` modulo standard vengono acquisiti in testo semplice in Logs. CloudWatch ``` import os import logging logger = logging.getLogger() logger.setLevel("INFO") def lambda_handler(event, context): logger.info('## ENVIRONMENT VARIABLES') logger.info(os.environ['AWS_LAMBDA_LOG_GROUP_NAME']) logger.info(os.environ['AWS_LAMBDA_LOG_STREAM_NAME']) logger.info('## EVENT') logger.info(event) ``` L'output di `logger` include il livello del log, il timestamp e l'ID della richiesta. ``` START RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Version: $LATEST [INFO] 2025-08-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## ENVIRONMENT VARIABLES [INFO] 2025-08-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 /aws/lambda/my-function [INFO] 2025-08-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 2025/01/31/[$LATEST]1bbe51xmplb34a2788dbaa7433b0aa4d [INFO] 2025-08-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## EVENT [INFO] 2025-08-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 {'key': 'value'} END RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 REPORT RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Duration: 2.75 ms Billed Duration: 117 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 113.51 ms XRAY TraceId: 1-5e34a66a-474xmpl7c2534a87870b4370 SegmentId: 073cxmpl3e442861 Sampled: true ``` **Nota** Quando il formato di log della funzione è impostato su testo semplice, l'impostazione predefinita a livello di log per i runtime Python è WARN. Ciò significa che Lambda invia solo output di log di livello WARN e inferiore a Logs. CloudWatch Per modificare il livello di log predefinito, utilizza il metodo `logging` `setLevel()` di Python come mostrato in questo codice di esempio. Se imposti il formato di log della funzione su JSON, consigliamo di configurare il livello di log della funzione utilizzando i controlli di registrazione avanzati di Lambda e non impostando il livello di log nel codice. Per ulteriori informazioni, consulta [Utilizzo del filtraggio a livello di log con Python](#python-logging-levels) ## Utilizzo dei controlli di registrazione avanzati di Lambda con Python Per avere un maggiore controllo sul modo in cui i log delle tue funzioni vengono acquisiti, elaborati e utilizzati, puoi configurare le seguenti opzioni di registrazione per i runtime Python di Lambda supportati: + **Formato di log**: scegli tra i formati di testo normale e JSON strutturato per i log della funzione + **Livello di log**: per i log in formato JSON, scegli il livello di dettaglio dei log che Lambda invia ad CloudWatch Amazon, come ERROR, DEBUG o INFO + Gruppo di **log: scegli il gruppo** di log a cui la CloudWatch funzione invia i log Per ulteriori informazioni su queste opzioni di registrazione e istruzioni su come configurare la funzione per utilizzarle, consulta la pagina [Configurazione dei controlli di registrazione avanzati per le funzioni Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced). Per ulteriori informazioni sull'utilizzo delle opzioni di formato e livello di log con le funzioni Lambda in Python, consulta le istruzioni nelle sezioni seguenti. ### Utilizzo di log JSON strutturati con Python Se selezioni JSON per il formato di log della tua funzione, Lambda invierà i log in uscita dalla libreria di registrazione standard Python in un formato JSON strutturato. CloudWatch Ogni oggetto di log JSON contiene almeno quattro coppie chiave-valore con le seguenti chiavi: + `"timestamp"`: l'ora in cui è stato generato il messaggio di log + `"level"`: il livello di log assegnato al messaggio + `"message"`: il contenuto del messaggio di log + `"requestId"`: l'ID di richiesta univoco dell'invocazione alla funzione La libreria `logging` di Python può anche aggiungere a tale oggetto JSON ulteriori coppie chiave-valore, come `"logger"`. Gli esempi nelle sezioni seguenti mostrano come gli output di log generati utilizzando la libreria `logging` Python vengono acquisiti CloudWatch in Logs quando si configura il formato di log della funzione come JSON. Tieni presente che se usi il metodo `print` per generare output log di base come descritto in [Stampa nel log](#python-logging-output), Lambda acquisirà questi output come testo normale anche se configuri il formato di registrazione della funzione come JSON. #### Output log JSON standard che utilizzano la libreria di registrazione di Python Il seguente frammento di codice e l'output di registro mostrano come gli output di log standard generati utilizzando la `logging` libreria Python vengono acquisiti in CloudWatch Logs quando il formato di log della funzione è impostato su JSON. **Example Codice di registrazione di Python** ``` import logging logger = logging.getLogger() def lambda_handler(event, context): logger.info("Inside the handler function") ``` **Example Record di log JSON** ``` { "timestamp":"2025-10-27T19:17:45.586Z", "level":"INFO", "message":"Inside the handler function", "logger": "root", "requestId":"79b4f56e-95b1-4643-9700-2807f4e68189" } ``` #### Registrazione di parametri aggiuntivi in JSON Quando il formato dei log della funzione è impostato su JSON, è possibile registrare ulteriori parametri con la libreria standard `logging` di Python utilizzando la parola chiave `extra` per passare un dizionario Python all'output dei log. **Example Codice di registrazione di Python** ``` import logging def lambda_handler(event, context): logging.info( "extra parameters example", extra={"a":"b", "b": [3]}, ) ``` **Example Record di log JSON** ``` { "timestamp": "2025-11-02T15:26:28Z", "level": "INFO", "message": "extra parameters example", "logger": "root", "requestId": "3dbd5759-65f6-45f8-8d7d-5bdc79a3bd01", "a": "b", "b": [ 3 ] } ``` #### Registrazione delle eccezioni in JSON Il seguente frammento di codice mostra come le eccezioni Python vengono acquisite nell'output log della funzione quando si configura JSON come formato di log. Nota che agli output log generati utilizzando `logging.exception` viene assegnato il livello di log ERROR. **Example Codice di registrazione di Python** ``` import logging def lambda_handler(event, context): try: raise Exception("exception") except: logging.exception("msg") ``` **Example Record di log JSON** ``` { "timestamp": "2025-11-02T16:18:57Z", "level": "ERROR", "message": "msg", "logger": "root", "stackTrace": [ " File \"/var/task/lambda_function.py\", line 15, in lambda_handler\n raise Exception(\"exception\")\n" ], "errorType": "Exception", "errorMessage": "exception", "requestId": "3f9d155c-0f09-46b7-bdf1-e91dab220855", "location": "/var/task/lambda_function.py:lambda_handler:17" } ``` #### Log JSON strutturati con altri strumenti di registrazione Se il codice utilizza già un'altra libreria di registrazione, come Powertools for, per produrre log strutturati JSON AWS Lambda, non è necessario apportare alcuna modifica. AWS Lambda non codifica due volte i log che sono già codificati in JSON. Anche se configuri la tua funzione per utilizzare il formato di registro JSON, i tuoi output di registrazione vengono visualizzati nella struttura JSON che definisci. CloudWatch L'esempio seguente mostra come gli output di log generati utilizzando il pacchetto Powertools for AWS Lambda vengono acquisiti in Logs. CloudWatch Il formato di questo output log è lo stesso indipendentemente dal fatto che la configurazione di registrazione della funzione sia impostata su JSON o TEXT. Per ulteriori informazioni sull'utilizzo di Powertools per, vedere e AWS Lambda[Utilizzo di Powertools per AWS Lambda (Python) AWS SAM e per la registrazione strutturata](#python-logging-sam) [Utilizzo di Powertools per AWS Lambda (Python) AWS CDK e per la registrazione strutturata](#python-logging-powertools-cdk) **Example Frammento di codice di registrazione Python (usando Powertools for) AWS Lambda** ``` from aws_lambda_powertools import Logger logger = Logger() def lambda_handler(event, context): logger.info("Inside the handler function") ``` **Example Record di registro JSON (utilizzando Powertools per) AWS Lambda** ``` { "level": "INFO", "location": "lambda_handler:7", "message": "Inside the handler function", "timestamp": "2025-10-31 22:38:21,010+0000", "service": "service_undefined", "xray_trace_id": "1-654181dc-65c15d6b0fecbdd1531ecb30" } ``` ### Utilizzo del filtraggio a livello di log con Python Configurando il filtraggio a livello di registro, puoi scegliere di inviare solo i log di un determinato livello di registrazione o inferiore a Logs. CloudWatch Per informazioni su come configurare il filtraggio a livello di log della funzione, consulta la pagina [Filtraggio a livello di log](monitoring-cloudwatchlogs-log-level.md). Per AWS Lambda filtrare i log delle applicazioni in base al relativo livello di registro, la funzione deve utilizzare log in formato JSON. Puoi farlo in due modi: + Crea output log utilizzando la libreria standard `logging` di Python e configura la funzione affinché utilizzi JSON come formato di log. Successivamente, AWS Lambda filtra gli output log utilizzando la coppia chiave-valore "livello" nell'oggetto JSON descritto in [Utilizzo di log JSON strutturati con Python](#python-logging-JSON). Per informazioni su come configurare il formato di log della funzione, consulta la pagina [Configurazione dei controlli di registrazione avanzati per le funzioni Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced). + Utilizza un'altra libreria o metodo di registrazione per creare nel codice dei log JSON strutturati che includono una coppia chiave-valore "livello" che definisce il livello dell'output log. Ad esempio, puoi utilizzare Powertools per AWS Lambda generare output di log strutturati JSON dal tuo codice. Inoltre, è possibile utilizzare un'istruzione di stampa per generare un oggetto JSON contenente un identificatore a livello di log. La seguente istruzione print produce un output in formato JSON in cui il livello di registro è impostato su INFO. AWS Lambda invierà l'oggetto JSON a CloudWatch Logs se il livello di registrazione della funzione è impostato su INFO, DEBUG o TRACE. ``` print('{"msg":"My log message", "level":"info"}') ``` Per consentire a Lambda di filtrare i log della funzione, è necessario includere anche una coppia chiave-valore `"timestamp"` nell'output log JSON. L'ora deve essere specificata in un formato di timestamp [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) valido. Se non fornisci un timestamp valido, Lambda assegnerà al log il livello INFO e aggiungerà un timestamp per tuo conto. ## Visualizzazione dei log nella console Lambda È possibile utilizzare la console Lambda per visualizzare l'output del log dopo aver richiamato una funzione Lambda. Se il codice può essere testato dall'editor del **codice** incorporato, troverai i log nei **risultati dell’esecuzione**. Quando utilizzi la funzionalità di test della console per richiamare una funzione, troverai l’**output del log** nella sezione **Dettagli**. ## Visualizzazione dei log nella console CloudWatch Puoi utilizzare la CloudWatch console Amazon per visualizzare i log di tutte le chiamate di funzioni Lambda. **Per visualizzare i log sulla console CloudWatch** 1. Apri la [pagina Registra gruppi](https://console.aws.amazon.com/cloudwatch/home?#logs:) sulla CloudWatch console. 1. Scegli il gruppo di log per la tua funzione (***your-function-name*/aws/lambda/**). 1. Creare un flusso di log. Ogni flusso di log corrisponde a un'[istanza della funzione](lambda-runtime-environment.md). Viene visualizzato un flusso di log quando aggiorni la funzione Lambda e quando vengono create istanze aggiuntive per gestire le chiamate simultanee. Per trovare i log per una chiamata specifica, consigliamo di strumentare la funzione con. AWS X-Ray X-Ray registra i dettagli sulla richiesta e il flusso di log nella traccia. ## Visualizzazione dei log con AWS CLI AWS CLI È uno strumento open source che consente di interagire con i AWS servizi utilizzando i comandi nella shell della riga di comando. Per completare le fasi riportate in questa sezione, è necessario disporre della [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). È possibile utilizzare [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) per recuperare i log per una chiamata utilizzando l'opzione di comando `--log-type`. La risposta include un campo `LogResult` che contiene fino a 4 KB di log con codifica base64 del richiamo. **Example recuperare un ID di log** Nell'esempio seguente viene illustrato come recuperare un *ID di log* dal `LogResult` campo per una funzione denominata `my-function`. ``` aws lambda invoke --function-name my-function out --log-type Tail ``` Verrà visualizzato l’output seguente: ``` { "StatusCode": 200, "LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...", "ExecutedVersion": "$LATEST" } ``` **Example decodificare i log** Nello stesso prompt dei comandi, utilizzare l'`base64` utilità per decodificare i log. Nell'esempio seguente viene illustrato come recuperare i log codificati in base64 per `my-function`. ``` aws lambda invoke --function-name my-function out --log-type Tail \ --query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode ``` L'**cli-binary-format**opzione è obbligatoria se utilizzi la AWS CLI versione 2. Per rendere questa impostazione come predefinita, esegui `aws configure set cli-binary-format raw-in-base64-out`. Per ulteriori informazioni, consulta la pagina [AWS CLI supported global command line options](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) nella *Guida per l'utente di AWS Command Line Interface versione 2*. Verrà visualizzato l’output seguente: ``` START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST "AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib", END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed Duration: 80 ms Memory Size: 128 MB Max Memory Used: 73 MB ``` L'utilità `base64` è disponibile su Linux, macOS e [Ubuntu su Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Gli utenti macOS potrebbero dover utilizzare `base64 -D`. **Example Script get-logs.sh** Nello stesso prompt dei comandi, utilizzare lo script seguente per scaricare gli ultimi cinque eventi di log. Lo script utilizza `sed` per rimuovere le virgolette dal file di output e rimane in sospensione per 15 secondi in attesa che i log diventino disponibili. L'output include la risposta di Lambda e l'output del comando `get-log-events`. Copiare il contenuto del seguente esempio di codice e salvare nella directory del progetto Lambda come `get-logs.sh`. L'**cli-binary-format**opzione è obbligatoria se utilizzi la AWS CLI versione 2. Per rendere questa impostazione come predefinita, esegui `aws configure set cli-binary-format raw-in-base64-out`. Per ulteriori informazioni, consulta la pagina [AWS CLI supported global command line options](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) nella *Guida per l'utente di AWS Command Line Interface versione 2*. ``` #!/bin/bash aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out sed -i'' -e 's/"//g' out sleep 15 aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5 ``` **Example (solo) macOS e Linux** Nello stesso prompt dei comandi, gli utenti macOS e Linux potrebbero dover eseguire il seguente comando per assicurarsi che lo script sia eseguibile. ``` chmod -R 755 get-logs.sh ``` **Example recuperare gli ultimi cinque eventi di log** Nello stesso prompt dei comandi, eseguire lo script seguente per ottenere gli ultimi cinque eventi di log. ``` ./get-logs.sh ``` Verrà visualizzato l’output seguente: ``` { "StatusCode": 200, "ExecutedVersion": "$LATEST" } { "events": [ { "timestamp": 1559763003171, "message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n", "ingestionTime": 1559763003309 }, { "timestamp": 1559763003173, "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...", "ingestionTime": 1559763018353 }, { "timestamp": 1559763003173, "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n", "ingestionTime": 1559763018353 }, { "timestamp": 1559763003218, "message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n", "ingestionTime": 1559763018353 }, { "timestamp": 1559763003218, "message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n", "ingestionTime": 1559763018353 } ], "nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795", "nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080" } ``` ## Eliminazione dei log I gruppi di log non vengono eliminati automaticamente quando si elimina una funzione. Per evitare di archiviare i log a tempo indeterminato, eliminare il gruppo di log o [configurare un periodo di conservazione](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention) trascorso il quale i log vengono eliminati automaticamente. ## Utilizzo di altri strumenti di registrazione e librerie [Powertools for AWS Lambda (Python](https://docs.aws.amazon.com/powertools/python/)) è un toolkit per sviluppatori per implementare le migliori pratiche Serverless e aumentare la velocità degli sviluppatori. L'[utilità di registrazione](https://docs.aws.amazon.com/powertools/python/latest/core/logger/) fornisce un logger ottimizzato per Lambda che include informazioni aggiuntive sul contesto delle funzioni in tutte le funzioni con output strutturato come JSON. Utilizza l'utility per eseguire le seguenti operazioni: + Acquisizione di campi essenziali dal contesto Lambda, avvii a freddo e output di registrazione della struttura come JSON + Registrazione degli eventi di chiamata Lambda quando richiesto (disabilitata per impostazione predefinita) + Stampa di tutti i log solo per una percentuale di chiamate tramite campionamento dei log (disabilitata per impostazione predefinita) + Aggiunta di chiavi supplementari al log strutturato in qualsiasi momento + Utilizzo di un formattatore di log personalizzato (Bring Your Own Formatter) per generare i log in una struttura compatibile con Logging RFC dell'organizzazione ## Utilizzo di Powertools per AWS Lambda (Python) AWS SAM e per la registrazione strutturata Segui i passaggi riportati sotto per scaricare, creare e implementare un'applicazione Python Hello World di esempio con moduli [ Powertools per Python](https://docs.aws.amazon.com/powertools/python/latest/) integrati utilizzando AWS SAM. Questa applicazione implementa un backend dell'API di base e utilizza Powertools per l'emissione di log, parametri e tracce. Consiste in un endpoint Gateway Amazon API e in una funzione Lambda. Quando invii una richiesta GET all'endpoint API Gateway, la funzione Lambda richiama, invia log e metriche utilizzando Embedded Metric Format e invia tracce a. CloudWatch AWS X-Ray La funzione restituisce un messaggio `hello world`. **Prerequisiti** Per completare le fasi riportate in questa sezione, è necessario: + Python 3.9 + [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) + [AWS SAM CLI versione 1.75](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html) o successiva. Se disponi di una versione precedente della AWS SAM CLI, consulta [Aggiornamento](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade) della CLI. AWS SAM **Distribuisci un'applicazione di esempio AWS SAM** 1. Inizializza l'applicazione utilizzando il modello Python Hello World. ``` sam init --app-template hello-world-powertools-python --name sam-app --package-type Zip --runtime python3.9 --no-tracing ``` 1. Costruisci l'app. ``` cd sam-app && sam build ``` 1. Distribuire l'app. ``` sam deploy --guided ``` 1. Seguire le istruzioni visualizzate sullo schermo. Per accettare le opzioni predefinite fornite nell'esperienza interattiva, premi `Enter`. **Nota** Perché **HelloWorldFunction potrebbe non avere un'autorizzazione definita, va bene?** , assicurati di entrare`y`. 1. Ottieni l'URL dell'applicazione implementata: ``` aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text ``` 1. Richiama l'endpoint dell'API: ``` curl GET ``` In caso di esito positivo, vedrai questa risposta: ``` {"message":"hello world"} ``` 1. Per ottenere i log per la funzione, esegui [sam logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html). Per ulteriori informazioni, consulta l'argomento relativo all'[utilizzo dei log](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) nella *Guida per sviluppatori AWS Serverless Application Model *. ``` sam logs --stack-name sam-app ``` L'output del log ha la struttura seguente: ``` 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:50.371000 INIT_START Runtime Version: python:3.9.v16 Runtime Version ARN: arn:aws:lambda:us-east-1::runtime:07a48df201798d627f2b950f03bb227aab4a655a1d019c3296406f95937e2525 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.112000 START RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Version: $LATEST 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.114000 { "level": "INFO", "location": "hello:23", "message": "Hello world API - HTTP 200", "timestamp": "2025-02-03 14:59:51,113+0000", "service": "PowertoolsHelloWorld", "cold_start": true, "function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j", "function_memory_size": "128", "function_arn": "arn:aws:lambda:us-east-1:111122223333:function:sam-app-HelloWorldFunction-YBg8yfYtOc9j", "function_request_id": "d455cfc4-7704-46df-901b-2a5cce9405be", "correlation_id": "e73f8aef-5e07-436e-a30b-63e4b23f0047", "xray_trace_id": "1-63dd2166-434a12c22e1307ff2114f299" } 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 { "_aws": { "Timestamp": 1675436391126, "CloudWatchMetrics": [ { "Namespace": "Powertools", "Dimensions": [ [ "function_name", "service" ] ], "Metrics": [ { "Name": "ColdStart", "Unit": "Count" } ] } ] }, "function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j", "service": "PowertoolsHelloWorld", "ColdStart": [ 1.0 ] } 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 { "_aws": { "Timestamp": 1675436391126, "CloudWatchMetrics": [ { "Namespace": "Powertools", "Dimensions": [ [ "service" ] ], "Metrics": [ { "Name": "HelloWorldInvocations", "Unit": "Count" } ] } ] }, "service": "PowertoolsHelloWorld", "HelloWorldInvocations": [ 1.0 ] } 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 END RequestId: d455cfc4-7704-46df-901b-2a5cce9405be 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 REPORT RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Duration: 16.33 ms Billed Duration: 756 ms Memory Size: 128 MB Max Memory Used: 64 MB Init Duration: 739.46 ms XRAY TraceId: 1-63dd2166-434a12c22e1307ff2114f299 SegmentId: 3c5d18d735a1ced0 Sampled: true ``` 1. Questo è un endpoint API pubblico accessibile su Internet. È consigliabile eliminare l'endpoint dopo il test. ``` sam delete ``` ### Gestione della conservazione dei log I gruppi di log non vengono eliminati automaticamente quando si elimina una funzione. Per evitare di archiviare i log a tempo indeterminato, elimina il gruppo di log o configura un periodo di conservazione dopo il quale i log CloudWatch vengono eliminati automaticamente. Per configurare la conservazione dei log, aggiungi quanto segue al tuo modello: AWS SAM ``` Resources: HelloWorldFunction: Type: AWS::Serverless::Function Properties: # Omitting other properties LogGroup: Type: AWS::Logs::LogGroup Properties: LogGroupName: !Sub "/aws/lambda/${HelloWorldFunction}" RetentionInDays: 7 ``` ## Utilizzo di Powertools per AWS Lambda (Python) AWS CDK e per la registrazione strutturata Segui i passaggi seguenti per scaricare, creare e distribuire un'applicazione Hello World Python di esempio con i moduli [Powertools for AWS Lambda (Python) integrati](https://docs.aws.amazon.com/powertools/python/latest/) utilizzando il. AWS CDK Questa applicazione implementa un backend dell'API di base e utilizza Powertools per l'emissione di log, parametri e tracce. Consiste in un endpoint Gateway Amazon API e in una funzione Lambda. Quando invii una richiesta GET all'endpoint API Gateway, la funzione Lambda richiama, invia log e metriche utilizzando Embedded Metric Format e invia tracce a. CloudWatch AWS X-Ray La funzione restituisce un messaggio hello world. **Prerequisiti** Per completare le fasi riportate in questa sezione, è necessario: + Python 3.9 + [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) + [AWS CDK versione 2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_prerequisites) + [AWS SAM CLI versione 1.75](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html) o successiva. Se disponi di una versione precedente della AWS SAM CLI, consulta [Aggiornamento](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade) della CLI. AWS SAM **Distribuisci un'applicazione di esempio AWS CDK** 1. Crea una directory di progetto per la nuova applicazione. ``` mkdir hello-world cd hello-world ``` 1. Inizializza l'app. ``` cdk init app --language python ``` 1. Installa le dipendenze di Python. ``` pip install -r requirements.txt ``` 1. Crea una directory **lambda\$1function** nella cartella root. ``` mkdir lambda_function cd lambda_function ``` 1. Crea un file **app.py** e aggiungi il seguente codice al file. Questo è il codice per la funzione Lambda. ``` from aws_lambda_powertools.event_handler import APIGatewayRestResolver from aws_lambda_powertools.utilities.typing import LambdaContext from aws_lambda_powertools.logging import correlation_paths from aws_lambda_powertools import Logger from aws_lambda_powertools import Tracer from aws_lambda_powertools import Metrics from aws_lambda_powertools.metrics import MetricUnit app = APIGatewayRestResolver() tracer = Tracer() logger = Logger() metrics = Metrics(namespace="PowertoolsSample") @app.get("/hello") @tracer.capture_method def hello(): # adding custom metrics # See: https://docs.aws.amazon.com/powertools/python/latest//latest/core/metrics/ metrics.add_metric(name="HelloWorldInvocations", unit=MetricUnit.Count, value=1) # structured log # See: https://docs.aws.amazon.com/powertools/python/latest//latest/core/logger/ logger.info("Hello world API - HTTP 200") return {"message": "hello world"} # Enrich logging with contextual information from Lambda @logger.inject_lambda_context(correlation_id_path=correlation_paths.API_GATEWAY_REST) # Adding tracer # See: https://docs.aws.amazon.com/powertools/python/latest//latest/core/tracer/ @tracer.capture_lambda_handler # ensures metrics are flushed upon request completion/failure and capturing ColdStart metric @metrics.log_metrics(capture_cold_start_metric=True) def lambda_handler(event: dict, context: LambdaContext) -> dict: return app.resolve(event, context) ``` 1. Apri la directory **hello\$1world**. Dovrebbe essere visualizzato un file denominato **hello\$1world\$1stack.py**. ``` cd .. cd hello_world ``` 1. Apri **hello\$1world\$1stack.py** e aggiungi il seguente codice al file. Contiene il [Lambda Constructor](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_lambda.html), che crea la funzione Lambda, configura le variabili di ambiente per Powertools e imposta la conservazione dei log su una settimana, e il [costruttore ApiGatewayv 1, che crea l'API REST](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_apigateway.html). ``` from aws_cdk import ( Stack, aws_apigateway as apigwv1, aws_lambda as lambda_, CfnOutput, Duration ) from constructs import Construct class HelloWorldStack(Stack): def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None: super().__init__(scope, construct_id, **kwargs) # Powertools Lambda Layer powertools_layer = lambda_.LayerVersion.from_layer_version_arn( self, id="lambda-powertools", # Using AWS Lambda Powertools via Lambda Layer # This imports the Powertools layer which provides observability features for Lambda functions # For available versions, see: https://docs.aws.amazon.com/powertools/python/latest/#lambda-layer ) function = lambda_.Function(self, 'sample-app-lambda', runtime=lambda_.Runtime.PYTHON_3_9, layers=[powertools_layer], code = lambda_.Code.from_asset("./lambda_function/"), handler="app.lambda_handler", memory_size=128, timeout=Duration.seconds(3), architecture=lambda_.Architecture.X86_64, environment={ "POWERTOOLS_SERVICE_NAME": "PowertoolsHelloWorld", "POWERTOOLS_METRICS_NAMESPACE": "PowertoolsSample", "LOG_LEVEL": "INFO" } ) apigw = apigwv1.RestApi(self, "PowertoolsAPI", deploy_options=apigwv1.StageOptions(stage_name="dev")) hello_api = apigw.root.add_resource("hello") hello_api.add_method("GET", apigwv1.LambdaIntegration(function, proxy=True)) CfnOutput(self, "apiUrl", value=f"{apigw.url}hello") ``` 1. Distribuisci l'applicazione. ``` cd .. cdk deploy ``` 1. Ottieni l'URL dell'applicazione implementata: ``` aws cloudformation describe-stacks --stack-name HelloWorldStack --query 'Stacks[0].Outputs[?OutputKey==`apiUrl`].OutputValue' --output text ``` 1. Richiama l'endpoint dell'API: ``` curl GET ``` In caso di esito positivo, vedrai questa risposta: ``` {"message":"hello world"} ``` 1. Per ottenere i log per la funzione, esegui [sam logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html). Per ulteriori informazioni, consulta l'argomento relativo all'[utilizzo dei log](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) nella *Guida per sviluppatori AWS Serverless Application Model *. ``` sam logs --stack-name HelloWorldStack ``` L'output del log ha la struttura seguente: ``` 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:50.371000 INIT_START Runtime Version: python:3.9.v16 Runtime Version ARN: arn:aws:lambda:us-east-1::runtime:07a48df201798d627f2b950f03bb227aab4a655a1d019c3296406f95937e2525 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.112000 START RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Version: $LATEST 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.114000 { "level": "INFO", "location": "hello:23", "message": "Hello world API - HTTP 200", "timestamp": "2025-02-03 14:59:51,113+0000", "service": "PowertoolsHelloWorld", "cold_start": true, "function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j", "function_memory_size": "128", "function_arn": "arn:aws:lambda:us-east-1:111122223333:function:sam-app-HelloWorldFunction-YBg8yfYtOc9j", "function_request_id": "d455cfc4-7704-46df-901b-2a5cce9405be", "correlation_id": "e73f8aef-5e07-436e-a30b-63e4b23f0047", "xray_trace_id": "1-63dd2166-434a12c22e1307ff2114f299" } 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 { "_aws": { "Timestamp": 1675436391126, "CloudWatchMetrics": [ { "Namespace": "Powertools", "Dimensions": [ [ "function_name", "service" ] ], "Metrics": [ { "Name": "ColdStart", "Unit": "Count" } ] } ] }, "function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j", "service": "PowertoolsHelloWorld", "ColdStart": [ 1.0 ] } 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 { "_aws": { "Timestamp": 1675436391126, "CloudWatchMetrics": [ { "Namespace": "Powertools", "Dimensions": [ [ "service" ] ], "Metrics": [ { "Name": "HelloWorldInvocations", "Unit": "Count" } ] } ] }, "service": "PowertoolsHelloWorld", "HelloWorldInvocations": [ 1.0 ] } 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 END RequestId: d455cfc4-7704-46df-901b-2a5cce9405be 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 REPORT RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Duration: 16.33 ms Billed Duration: 756 ms Memory Size: 128 MB Max Memory Used: 64 MB Init Duration: 739.46 ms XRAY TraceId: 1-63dd2166-434a12c22e1307ff2114f299 SegmentId: 3c5d18d735a1ced0 Sampled: true ``` 1. Questo è un endpoint API pubblico accessibile su Internet. È consigliabile eliminare l'endpoint dopo il test. ``` cdk destroy ```