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à. # Lambda invia automaticamente i log delle funzioni a CloudWatch Logs. Per impostazione predefinita, Lambda acquisisce automaticamente i log per tutte le chiamate di funzione e li invia a CloudWatch Logs, a condizione che il ruolo di esecuzione della funzione disponga delle autorizzazioni necessarie. Per impostazione predefinita, questi log sono archiviati in un gruppo di log denominato** /aws/lambda/. Per migliorare il debug, puoi inserire istruzioni di registrazione personalizzate nel codice, che Lambda integrerà perfettamente con CloudWatch Logs. Se desideri che la tua funzione invii i log a un altro gruppo, puoi configurarlo utilizzando la console Lambda, AWS CLI o l'API Lambda. Per ulteriori informazioni, consulta [Configurazione dei gruppi di CloudWatch log](monitoring-cloudwatchlogs-loggroups.md). Puoi visualizzare i log per le funzioni Lambda tramite la console Lambda, la console CloudWatch, la console AWS Command Line Interface (AWS CLI) o l'API CloudWatch. Per ulteriori informazioni, consulta la pagina [Visualizzazione dei CloudWatch log per le funzioni Lambda](monitoring-cloudwatchlogs-view.md). **Nota** Potrebbero essere necessari da 5 a 10 minuti prima che i log vengano visualizzati dopo una chiamata di funzione. ## Autorizzazioni IAM richieste Il [ruolo di esecuzione](lambda-intro-execution-role.md) richiede la seguente autorizzazione per caricare i log in CloudWatch Logs: + `logs:CreateLogGroup` + `logs:CreateLogStream` + `logs:PutLogEvents` Per ulteriori informazioni, consulta [Utilizzo delle policy basate su identità (policy IAM) per CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-identity-based-access-control-cwl.html) nella *Guida per l'utente di Amazon CloudWatch*. È possibile aggiungere le autorizzazioni CloudWatch Logs utilizzando la policy gestita `AWSLambdaBasicExecutionRole` AWS fornita da Lambda. Per aggiungere questa policy al ruolo, esegui il seguente comando: ``` aws iam attach-role-policy --role-name your-role --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole ``` Per ulteriori informazioni, consulta [Utilizzo delle politiche AWS gestite nel ruolo di esecuzione](permissions-managed-policies.md). ## Prezzi Non sono previsti costi aggiuntivi per l'utilizzo dei log di Lambda, ma vengono applicati i costi CloudWatch Logs standard. Per ulteriori informazioni, consultare la pagina dei [prezzi di CloudWatch](https://aws.amazon.com/cloudwatch/pricing/) # Configurazione dei gruppi di CloudWatch log Per impostazione predefinita, crea CloudWatch automaticamente un gruppo di log denominato in base alla funzione quando viene richiamata `/aws/lambda/` per la prima volta. Per configurare la tua funzione per l'invio dei log a un gruppo di log esistente o per creare un nuovo gruppo di log per la funzione, puoi utilizzare la console Lambda o la AWS CLI. Puoi anche configurare gruppi di log personalizzati utilizzando i comandi API [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)e [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)Lambda e la risorsa AWS Serverless Application Model (AWS SAM) [AWS: :Serverless: :Function](). È possibile configurare più funzioni Lambda per inviare i log allo stesso CloudWatch gruppo di log. Ad esempio, è possibile utilizzare un singolo gruppo di log per archiviare i log per tutte le funzioni Lambda che costituiscono una particolare applicazione. Quando si utilizza un gruppo di log personalizzato per una funzione Lambda, i flussi di log creati da Lambda includono il nome e la versione della funzione. Ciò garantisce che la mappatura tra i messaggi di log e le funzioni venga preservata, anche se si utilizza lo stesso gruppo di log per più funzioni. Il formato di denominazione per i flussi di log per i gruppi di log personalizzati segue questa convenzione: ``` YYYY/MM/DD/[][] ``` Tieni presente che quando configuri un gruppo di log personalizzato, il nome selezionato per il gruppo di log deve seguire le regole di denominazione dei [CloudWatch log](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogGroup.html). Inoltre, i nomi dei gruppi di log personalizzati non devono cominciare con la stringa `aws/`. Se crei un gruppo di log personalizzato che comincia con `aws/`, Lambda non sarà in grado di crearlo. Di conseguenza, i log della funzione non verranno inviati a. CloudWatch **Modifica del gruppo di log di una funzione (console)** 1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda. 1. Scegliere una funzione. 1. Nella pagina di configurazione della funzione, scegli **Strumenti di monitoraggio e gestione**. 1. Nel riquadro **Configurazione della registrazione**, scegli **Modifica**. 1. **Nel riquadro **Logging group**, per il **gruppo di CloudWatch log**, scegli Personalizzato.** 1. In **Gruppo di log personalizzato**, inserisci il nome del gruppo di CloudWatch log a cui desideri che la funzione invii i log. Se immetti il nome di un gruppo di log esistente, la funzione utilizzerà quel gruppo. Se non esiste alcun gruppo di log con il nome immesso, Lambda creerà un nuovo gruppo di log per la funzione con tale nome. **Modifica del gruppo di log di una funzione (AWS CLI)** + Per modificare il gruppo di log di una funzione esistente, utilizza il comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html). ``` aws lambda update-function-configuration \ --function-name myFunction \ --logging-config LogGroup=myLogGroup ``` **Definizione di un gruppo di log personalizzato durante la creazione di una funzione (AWS CLI)** + Per specificare un gruppo di log personalizzato quando si crea una nuova funzione Lambda utilizzando AWS CLI, utilizzare l'`--logging-config`opzione. Il comando di esempio seguente crea una funzione Lambda Node.js che invia i log a un gruppo di log denominato `myLogGroup`. ``` aws lambda create-function \ --function-name myFunction \ --runtime nodejs24.x \ --handler index.handler \ --zip-file fileb://function.zip \ --role arn:aws:iam::123456789012:role/LambdaRole \ --logging-config LogGroup=myLogGroup ``` ## Autorizzazioni del ruolo di esecuzione Per inviare i log a CloudWatch Logs, la funzione deve disporre dell'autorizzazione [logs](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html):. PutLogEvents Quando configuri il gruppo di log della tua funzione utilizzando la console Lambda, Lambda aggiungerà questa autorizzazione al ruolo nelle seguenti condizioni: + La destinazione del servizio è impostata su Logs CloudWatch + Il ruolo di esecuzione della funzione non dispone delle autorizzazioni per caricare i log in CloudWatch Logs (la destinazione predefinita) **Nota** Lambda non aggiunge alcuna autorizzazione Put per le destinazioni di log di Amazon S3 o Firehose. Quando Lambda aggiunge questo permesso, concede alla funzione il permesso di inviare i log a qualsiasi gruppo di log CloudWatch Logs. Per evitare che Lambda aggiorni automaticamente il ruolo di esecuzione della funzione e modificarlo invece manualmente, espandi **Autorizzazioni** e deseleziona **Aggiungi autorizzazioni richieste.** Quando configuri il gruppo di log della tua funzione utilizzando AWS CLI, Lambda non aggiungerà automaticamente l'`logs:PutLogEvents`autorizzazione. Aggiungi l'autorizzazione al ruolo di esecuzione della tua funzione, se non ne dispone già. Questa autorizzazione è inclusa nella politica [AWSLambdaBasicExecutionRole](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole$jsonEditor)gestita. ## CloudWatch registrazione per istanze gestite Lambda Quando si utilizzano [le istanze gestite da Lambda](lambda-managed-instances.md), ci sono ulteriori considerazioni per l'invio dei log ai log: CloudWatch ### Requisiti di rete VPC Le istanze gestite Lambda vengono eseguite su istanze di proprietà del cliente all'interno EC2 del tuo VPC. Per inviare i log a CloudWatch Logs and trace to X-Ray, devi assicurarti che AWS APIs siano instradabili dal tuo VPC. A questo scopo, sono disponibili numerose opzioni: + **AWS PrivateLink (consigliato)**: [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/what-is-privatelink.html)Da utilizzare per creare endpoint VPC per i servizi CloudWatch Logs e X-Ray. Ciò consente alle istanze di accedere a questi servizi in modo privato senza richiedere un gateway Internet o un gateway NAT. Per ulteriori informazioni, consulta [Utilizzo dei CloudWatch log con gli endpoint VPC dell'interfaccia](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch-logs-and-interface-VPC.html). + Gateway **NAT: configura un gateway** NAT per consentire l'accesso a Internet in uscita dalle sottoreti private. + **Gateway Internet**: per le sottoreti pubbliche, assicurati che il tuo VPC abbia un gateway Internet configurato. Se CloudWatch Logs o APIs X-Ray non sono instradabili dal tuo VPC, i log e le tracce delle funzioni non verranno consegnati. ### Richiamazioni simultanee e attribuzione dei log Gli ambienti di esecuzione di Lambda Managed Instances possono elaborare più chiamate contemporaneamente. Quando vengono eseguite più chiamate contemporaneamente, le relative voci di registro vengono interlacciate nello stesso flusso di log. Per filtrare e analizzare efficacemente i log delle chiamate simultanee, è necessario assicurarsi che ogni voce di registro includa l'ID della richiesta. AWS Consigliamo uno dei seguenti approcci: + **Usa logger di runtime Lambda predefiniti (consigliato)**: le librerie di registrazione predefinite fornite dai runtime gestiti da Lambda includono automaticamente l'ID della richiesta in ogni voce di registro. + **Implementa la registrazione JSON strutturata**: se stai creando un [runtime personalizzato o hai bisogno di una registrazione personalizzata](runtimes-custom.md), implementa log in formato JSON che includono l'ID della richiesta in ogni voce. Le istanze gestite Lambda supportano solo il formato di log JSON. Includi il `requestId` campo nei log JSON per abilitare il filtraggio per chiamata: ``` { "timestamp": "2025-01-15T10:30:00.000Z", "level": "INFO", "requestId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890", "message": "Processing request" } ``` Con l'attribuzione dell'ID della richiesta, puoi filtrare le voci di registro di CloudWatch Logs per una chiamata specifica utilizzando le query di Logs Insights. CloudWatch Esempio: ``` fields @timestamp, @message | filter requestId = "a1b2c3d4-e5f6-7890-abcd-ef1234567890" | sort @timestamp asc ``` Per ulteriori informazioni sui requisiti di registrazione delle istanze gestite di Lambda, vedere. [Comprendere l'ambiente di esecuzione di Lambda Managed Instances](lambda-managed-instances-execution-environment.md) # Visualizzazione dei CloudWatch log per le funzioni Lambda Puoi visualizzare CloudWatch i log di Amazon per la tua funzione Lambda utilizzando la console Lambda, CloudWatch la console o il (). AWS Command Line Interface AWS CLI Segui le istruzioni riportate nelle sezioni seguenti per accedere ai log della funzione. ## Trasmetti in streaming i log delle funzioni con Logs Live Tail CloudWatch Amazon CloudWatch Logs Live Tail ti aiuta a risolvere rapidamente i problemi delle tue funzioni visualizzando un elenco in streaming di nuovi eventi di registro direttamente nella console Lambda. Puoi visualizzare e filtrare i log importati dalle funzioni Lambda in tempo reale, in modo da poter rilevare e risolvere rapidamente i problemi. **Nota** Le sessioni Live Tail comportano costi al minuto in base al tempo di utilizzo della sessione. Per ulteriori informazioni sui prezzi, consulta la pagina [ CloudWatch dei prezzi di Amazon](https://aws.amazon.com/cloudwatch/pricing/). ### Confronto tra Live Tail e --log-type Tail Esistono diverse differenze tra CloudWatch Logs Live Tail e l'opzione [LogType: Tail](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html#lambda-Invoke-request-LogType) nell'API Lambda `--log-type Tail` (in AWS CLI): + `--log-type Tail` restituisce solo i primi 4 KB dei log di invocazione. Live Tail non condivide questo limite e può ricevere fino a 500 eventi del log al secondo. + `--log-type Tail` acquisisce e invia i log con la risposta, il che può influire sulla latenza di risposta della funzione. Live Tail non influisce sulla latenza di risposta della funzione. + `--log-type Tail` supporta solo chiamate sincrone. Live Tail funziona sia per le invocazioni sincrone che asincrone. **Nota** [Lambda Managed Instances](lambda-managed-instances.md) non supporta l'opzione. `--log-type Tail` Usa CloudWatch Logs Live Tail o interroga direttamente CloudWatch Logs per visualizzare i log delle funzioni delle istanze gestite. ### Permissions Le seguenti autorizzazioni sono necessarie per avviare e interrompere CloudWatch le sessioni di Logs Live Tail: + `logs:DescribeLogGroups` + `logs:StartLiveTail` + `logs:StopLiveTail` ### Avviare una sessione Live Tail nella console Lambda 1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda. 1. Scegliere il nome della funzione. 1. Seleziona la scheda **Test**. 1. Nel riquadro **Test event**, scegli **CloudWatch Logs** Live Tail. 1. Per **Seleziona gruppi di log**, il gruppo di log della funzione è selezionato per impostazione predefinita. È possibile selezionare fino a cinque gruppi di log alla volta. 1. (Facoltativo) Per visualizzare solo gli eventi del log che contengono determinate parole o altre stringhe, inserisci la parola o la stringa nella casella **Aggiungi modello di filtro**. I filtri fanno distinzione tra maiuscole e minuscole. Puoi includere più termini e operatori di modelli in questo campo, comprese le espressioni regolari (regex). Per ulteriori informazioni sulla sintassi dei pattern, consulta [Filter pattern syntax](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html). nella *Amazon CloudWatch Logs* User Guide. 1. Scegli **Avvia**. I log eventi corrispondenti vengono visualizzati nella finestra. 1. Per arrestare la sessione Live Tail, scegli **Arresta**. **Nota** La sessione Live Tail si interrompe automaticamente dopo 15 minuti di inattività o quando la sessione della console Lambda scade. ## Accedere ai log della funzione tramite la console 1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda. 1. Seleziona una funzione. 1. Selezionare la scheda **Monitor (Monitora)**. 1. Scegli **Visualizza CloudWatch i log** per aprire la console. CloudWatch 1. Scorri verso il basso e scegli il **flusso di log** per le invocazioni delle funzioni che desideri esaminare. ![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/log-stream.png) Ogni istanza di una funzione Lambda ha un flusso di log dedicato. Se una funzione aumenta, ogni istanza simultanea ha il suo flusso di log. Ogni volta che viene creato un nuovo ambiente di esecuzione in risposta a una chiamata, viene generato un nuovo flusso di log. La convenzione di denominazione per i flussi di log è: ``` YYYY/MM/DD[Function version][Execution environment GUID] ``` Un singolo ambiente di esecuzione scrive sullo stesso flusso di log durante il suo ciclo di vita. Il flusso di log contiene i messaggi provenienti da quell'ambiente di esecuzione e anche qualsiasi output del codice della funzione Lambda. Ogni messaggio ha un timestamp, compresi i log personalizzati. Anche se la funzione non registra alcun output dal codice, vengono generate tre istruzioni di log minime per ogni invocazione (START, END e REPORT): ![\[monitoraggio dell'osservabilità (figura 3)\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/monitoring-observability-figure-3.png) Questi log mostrano: + **RequestId**— si tratta di un ID univoco generato per richiesta. Se la funzione Lambda ritenta una richiesta, questo ID non cambia e viene visualizzato nei log per ogni tentativo successivo. + **Start/End**: contrassegnano una singola chiamata ai segnalibri, quindi ogni riga di registro compresa tra queste appartiene alla stessa invocazione. + **Durata: il tempo** totale di invocazione per la funzione di gestione, codice escluso. `INIT` + **Durata fatturata**: applica la logica di arrotondamento ai fini della fatturazione. + **Dimensione della memoria**: la quantità di memoria allocata alla funzione. + **Memoria massima utilizzata**: la quantità massima di memoria utilizzata durante la chiamata. + **Durata di inizializzazione**: il tempo impiegato per eseguire la `INIT` sezione di codice, al di fuori del gestore principale. ## Accedi ai 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 si utilizza 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" } ``` ## Analisi dei log e registrazione strutturata Con CloudWatch Logs Insights, puoi cercare e analizzare i dati di registro utilizzando una [sintassi di query](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html) specializzata. Esegue interrogazioni su più gruppi di log e fornisce potenti filtri utilizzando il pattern matching tra espressioni [glob](https://en.wikipedia.org/wiki/Glob_(programming)) e [regolari](https://en.wikipedia.org/wiki/Regular_expression). Puoi sfruttare queste funzionalità implementando la registrazione strutturata nelle tue funzioni Lambda. La registrazione strutturata organizza i log in un formato predefinito, semplificando le interrogazioni. L'utilizzo dei livelli di registro è un primo passo importante per generare log compatibili con i filtri che separano i messaggi informativi dagli avvisi o dagli errori. Ad esempio, si consideri il seguente codice Node.js: ``` exports.handler = async (event) => { console.log("console.log - Application is fine") console.info("console.info - This is the same as console.log") console.warn("console.warn - Application provides a warning") console.error("console.error - An error occurred") } ``` Il file di CloudWatch registro risultante contiene un campo separato che specifica il livello di registro: ![\[monitoraggio dell'osservabilità (figura 10)\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/monitoring-observability-figure-10.png) Una query di CloudWatch Logs Insights può quindi filtrare a livello di registro. Ad esempio, per ricercare solo gli errori, è possibile utilizzare la seguente query: ``` fields @timestamp, @message | filter @message like /ERROR/ | sort @timestamp desc ``` ### Registrazione strutturata JSON JSON è comunemente usato per fornire una struttura per i log delle applicazioni. Nell'esempio seguente, i log sono stati convertiti in JSON per generare tre valori distinti: ![\[monitoraggio dell'osservabilità (figura 11)\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/monitoring-observability-figure-11.png) La funzionalità CloudWatch Logs Insights rileva automaticamente i valori nell'output JSON e analizza i messaggi come campi, senza la necessità di glob o espressioni regolari personalizzate. Utilizzando i log strutturati in JSON, la seguente query trova le invocazioni in cui il file caricato era più grande di 1 MB, il tempo di caricamento era superiore a 1 secondo e l'invocazione non era un avvio a freddo: ``` fields @message | filter @message like /INFO/ | filter uploadedBytes > 1000000 | filter uploadTimeMS > 1000 | filter invocation != 1 ``` Questa query potrebbe produrre il seguente risultato: ![\[monitoraggio dell'osservabilità (figura 12)\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/monitoring-observability-figure-12.png) I campi rilevati in JSON vengono compilati automaticamente nel menu *Campi rilevati* sul lato destro. I campi standard emessi dal servizio Lambda hanno il prefisso '@' e puoi eseguire query su questi campi nello stesso modo. I log Lambda includono sempre i campi @timestamp, @logStream, @message, @requestId, @duration, @billedDuration, @type, @maxMemoryUsed, @memorySize. Se X-Ray è abilitato per una funzione, i log includono anche @ e @xrayTraceId . xraySegmentId Quando un'origine di AWS eventi come Amazon S3, Amazon SQS o EventBridge Amazon richiama la tua funzione, l'intero evento viene fornito alla funzione come input di un oggetto JSON. Registrando questo evento nella prima riga della funzione, puoi quindi eseguire query su qualsiasi campo annidato utilizzando Logs Insights. CloudWatch ### Query utili di Insights La tabella seguente mostra esempi di query Insights che possono essere utili per il monitoraggio delle funzioni Lambda. | Description | Esempio di sintassi della query | | --- | --- | | Gli ultimi 100 errori | ``` fields Timestamp, LogLevel, Message \| filter LogLevel == "ERR" \| sort @timestamp desc \| limit 100 ``` | | Le prime 100 invocazioni con il fatturato più alto | ``` filter @type = "REPORT" \| fields @requestId, @billedDuration \| sort by @billedDuration desc \| limit 100 ``` | | Percentuale di avvii a freddo sul totale delle invocazioni | ``` filter @type = "REPORT" \| stats sum(strcontains(@message, "Init Duration"))/count(*) * 100 as coldStartPct, avg(@duration) by bin(5m) ``` | | Rapporto percentile della durata Lambda | ``` filter @type = "REPORT" \| stats avg(@billedDuration) as Average, percentile(@billedDuration, 99) as NinetyNinth, percentile(@billedDuration, 95) as NinetyFifth, percentile(@billedDuration, 90) as Ninetieth by bin(30m) ``` | | Rapporto percentile sull'utilizzo della memoria Lambda | ``` filter @type="REPORT" \| stats avg(@maxMemoryUsed/1024/1024) as mean_MemoryUsed, min(@maxMemoryUsed/1024/1024) as min_MemoryUsed, max(@maxMemoryUsed/1024/1024) as max_MemoryUsed, percentile(@maxMemoryUsed/1024/1024, 95) as Percentile95 ``` | | Invocazioni che utilizzano il 100% della memoria assegnata | ``` filter @type = "REPORT" and @maxMemoryUsed=@memorySize \| stats count_distinct(@requestId) by bin(30m) ``` | | Memoria media utilizzata tra le invocazioni | ``` avgMemoryUsedPERC, avg(@billedDuration) as avgDurationMS by bin(5m) ``` | | Visualizzazione delle statistiche sulla memoria | ``` filter @type = "REPORT" \| stats max(@maxMemoryUsed / 1024 / 1024) as maxMemMB, avg(@maxMemoryUsed / 1024 / 1024) as avgMemMB, min(@maxMemoryUsed / 1024 / 1024) as minMemMB, (avg(@maxMemoryUsed / 1024 / 1024) / max(@memorySize / 1024 / 1024)) * 100 as avgMemUsedPct, avg(@billedDuration) as avgDurationMS by bin(30m) ``` | | Invocazioni in cui Lambda è uscita | ``` filter @message like /Process exited/ \| stats count() by bin(30m) ``` | | Invocazioni scadute | ``` filter @message like /Task timed out/ \| stats count() by bin(30m) ``` | | Rapporto sulla latenza | ``` filter @type = "REPORT" \| stats avg(@duration), max(@duration), min(@duration) by bin(5m) ``` | | Memoria sovradimensionata | ``` filter @type = "REPORT" \| stats max(@memorySize / 1024 / 1024) as provisonedMemMB, min(@maxMemoryUsed / 1024 / 1024) as smallestMemReqMB, avg(@maxMemoryUsed / 1024 / 1024) as avgMemUsedMB, max(@maxMemoryUsed / 1024 / 1024) as maxMemUsedMB, provisonedMemMB - maxMemUsedMB as overProvisionedMB ``` | ## Visualizzazione dei log e pannelli di controllo Per qualsiasi query di CloudWatch Logs Insights, puoi esportare i risultati in formato markdown o CSV. In alcuni casi, potrebbe essere più utile creare [visualizzazioni a partire dalle query](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_Insights-Visualizing-Log-Data.html), purché esista almeno una funzione di aggregazione. La `stats` funzione consente di definire aggregazioni e raggruppamenti. L'esempio precedente di *logInsightsJSON* filtrava in base alla dimensione e al tempo di caricamento ed escludeva le prime invocazioni. Ciò ha prodotto una tabella di dati. Per monitorare un sistema di produzione, può essere più utile visualizzare le dimensioni minime, massime e medie dei file per individuare i valori anomali. Per fare ciò, applica la funzione stats agli aggregati richiesti e raggruppa in base a un valore temporale come ogni minuto: Ad esempio, si consideri la seguente interrogazione. Questa è la stessa query di esempio della [Registrazione strutturata JSON](#querying-logs-json) sezione, ma con funzioni di aggregazione aggiuntive: ``` fields @message | filter @message like /INFO/ | filter uploadedBytes > 1000000 | filter uploadTimeMS > 1000 | filter invocation != 1 | stats min(uploadedBytes), avg(uploadedBytes), max(uploadedBytes) by bin (1m) ``` Abbiamo incluso questi aggregati perché potrebbe essere più utile visualizzare le dimensioni minime, massime e medie dei file per individuare i valori anomali. **Puoi visualizzare i risultati nella scheda Visualizzazione:** ![\[monitoraggio dell'osservabilità (figura 14)\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/monitoring-observability-figure-14.png) Dopo aver completato la creazione della visualizzazione, puoi facoltativamente aggiungere il grafico a una dashboard. CloudWatch Per fare ciò, scegli **Aggiungi al pannello di controllo** sopra la visualizzazione. Ciò aggiunge la query come widget e consente di selezionare intervalli di aggiornamento automatici, semplificando il monitoraggio continuo dei risultati: ![\[monitoraggio dell'osservabilità (figura 15)\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/monitoring-observability-figure-15.png)