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à.
# Utilizzo dei registri delle funzioni Lambda
Per aiutarti a risolvere i problemi, AWS Lambda monitora automaticamente le funzioni Lambda per tuo conto. Puoi visualizzare i log delle funzioni Lambda utilizzando la console Lambda, la console, CloudWatch la AWS CLI(), AWS Command Line Interface l'API. CloudWatch Puoi anche configurare Lambda per inviare log ad Amazon S3 e Firehose.
Se il [ruolo di esecuzione](lambda-intro-execution-role.md) della funzione dispone delle autorizzazioni necessarie, Lambda acquisisce i log per tutte le richieste gestite dalla funzione e li invia ad CloudWatch Amazon Logs, che è la destinazione predefinita. Puoi anche usare la console Lambda per configurare Amazon S3 o Firehose come destinazioni di registrazione.
+ **CloudWatch Logs** è la destinazione di registrazione predefinita per le funzioni Lambda. CloudWatch Logs offre funzionalità di visualizzazione e analisi dei log in tempo reale, con supporto per la creazione di metriche e allarmi basati sui dati di registro.
+ **Amazon S3** è conveniente per lo storage a lungo termine e servizi come Athena possono essere utilizzati per analizzare i log. La latenza è in genere superiore.
+ **Firehose** offre lo streaming gestito dei log verso varie destinazioni. Se è necessario inviare log ad altri AWS servizi (ad esempio, OpenSearch Service o Redshift Data API) o piattaforme di terze parti (come Datadog, New Relic o Splunk), Firehose semplifica tale processo fornendo integrazioni predefinite. Puoi anche eseguire lo streaming su endpoint HTTP personalizzati senza configurare un'infrastruttura aggiuntiva.
## Scelta della destinazione del servizio a cui inviare i log
Nella scelta di un servizio come destinazione per i registri delle funzioni, tenete conto dei seguenti fattori chiave:
+ **La gestione dei costi varia in base al servizio.** Amazon S3 offre in genere l'opzione più economica per lo storage a lungo termine, mentre CloudWatch Logs consente di visualizzare log, elaborare log e configurare avvisi in tempo reale. I costi di Firehose includono sia il servizio di streaming che i costi associati alla destinazione a cui lo si configura per lo streaming.
+ **Le funzionalità di analisi differiscono tra i servizi.** CloudWatch Logs eccelle nel monitoraggio in tempo reale e si integra nativamente con altre CloudWatch funzionalità, come Logs Insights e Live Tail. Amazon S3 funziona bene con strumenti di analisi come Athena e può integrarsi con vari servizi, sebbene possa richiedere una configurazione aggiuntiva. Firehose semplifica lo streaming diretto verso AWS servizi specifici (come Service OpenSearch e Redshift Data API) e piattaforme di terze parti supportate (come Datadog e Splunk) fornendo integrazioni predefinite, riducendo potenzialmente il lavoro di configurazione.
+ **La configurazione e la facilità d'uso variano in base al servizio.** CloudWatch Logs è la destinazione di log predefinita: funziona immediatamente senza configurazioni aggiuntive e fornisce una visualizzazione e un'analisi dei log semplici tramite la console. CloudWatch Se hai bisogno di inviare i log ad Amazon S3, dovrai eseguire una configurazione iniziale nella console Lambda e configurare le autorizzazioni del bucket. Se avete bisogno di log inviati direttamente a servizi come OpenSearch Service o piattaforme di analisi di terze parti, Firehose può semplificare tale processo.
## Configurazione delle destinazioni dei log
AWS Lambda supporta più destinazioni per i registri delle funzioni. Questa guida spiega le destinazioni di registrazione disponibili e ti aiuta a scegliere l'opzione giusta per le tue esigenze. Indipendentemente dalla destinazione scelta, Lambda offre opzioni per controllare il formato, il filtraggio e la consegna dei log.
Lambda supporta sia i formati JSON che quelli di testo semplice per i log delle funzioni. I log strutturati JSON offrono una migliore ricercabilità e consentono l'analisi automatizzata, mentre i log di testo semplice offrono semplicità e costi di archiviazione potenzialmente ridotti. Puoi controllare quali log Lambda invia alla destinazione prescelta configurando i livelli di registro per i log di sistema e delle applicazioni. Il filtraggio consente di gestire i costi di archiviazione e semplifica la ricerca delle voci di registro pertinenti durante il debug.
Per istruzioni di configurazione dettagliate per ciascuna destinazione, consulta le seguenti sezioni:
+ [Lambda invia automaticamente i log delle funzioni a CloudWatch Logs.](monitoring-cloudwatchlogs.md)
+ [Invio dei log delle funzioni Lambda a Firehose](logging-with-firehose.md)
+ [Invio di log delle funzioni Lambda ad Amazon S3](logging-with-s3.md)
## Configurazione dei controlli di registrazione avanzati per le funzioni Lambda
Per darti un maggiore controllo sul modo in cui i log delle funzioni vengono acquisiti, elaborati e consumati, Lambda offre le seguenti opzioni di configurazione della registrazione:
+ **Formato di registro**: scegli tra testo semplice e formato JSON strutturato per i log della tua funzione.
+ **Livello di registro**: per i log strutturati JSON, scegli il livello di dettaglio dei log a cui Lambda invia, CloudWatch ad esempio`FATAL`,,`ERROR`,`WARN`, `INFO` e. `DEBUG` `TRACE`
+ **Gruppo di log**: scegli il gruppo di CloudWatch log a cui la funzione invia i log.
Per ulteriori informazioni sulla configurazione dei controlli di registrazione avanzati, consulta le seguenti sezioni:
+ [Configurazione dei formati di log JSON e testo normale](monitoring-cloudwatchlogs-logformat.md)
+ [Filtraggio a livello di log](monitoring-cloudwatchlogs-log-level.md)
+ [Configurazione dei gruppi di CloudWatch log](monitoring-cloudwatchlogs-loggroups.md)
# Configurazione dei formati di log JSON e testo normale
L'acquisizione degli output log come coppie chiave-valore JSON semplifica la ricerca e il filtraggio durante il debug delle funzioni. Con i log in formato JSON, puoi aggiungere ai log anche tag e informazioni contestuali. Questo può aiutarti a eseguire analisi automatizzate di grandi volumi di dati di log. A meno che il flusso di lavoro di sviluppo non si basi su strumenti esistenti che utilizzano i log Lambda in testo normale, ti consigliamo di selezionare JSON come formato di log.
**Istanze Lambda gestite**
Le istanze gestite Lambda supportano solo il formato di registro JSON. Quando crei una funzione Managed Instances, Lambda configura automaticamente il formato di registro in JSON e non è possibile modificarlo in testo semplice. Per ulteriori informazioni sulle istanze gestite, consulta. [Istanze Lambda gestite](lambda-managed-instances.md)
Per tutti i runtime gestiti da Lambda, puoi scegliere se inviare i log di sistema della funzione a CloudWatch Logs in formato testo semplice non strutturato o JSON. I log di sistema sono i log generati da Lambda e a volte vengono chiamati log eventi della piattaforma.
Per i [runtime supportati](#monitoring-cloudwatchlogs-logformat-supported), quando si utilizza uno dei metodi di registrazione integrati supportati, Lambda può anche generare i log delle applicazioni della funzione (i log generati dal codice della funzione) in formato JSON strutturato. Quando configuri il formato di log della funzione per questi runtime, la configurazione scelta si applica sia ai log di sistema sia a quelli delle applicazioni.
Per i runtime supportati, se la funzione utilizza una libreria o un metodo di registrazione supportato, non è necessario apportare modifiche al codice esistente per Lambda per acquisire i log in formato JSON strutturato.
**Nota**
L'utilizzo della formattazione dei log JSON aggiunge metadati aggiuntivi e codifica i messaggi di log come oggetti JSON contenenti una serie di coppie chiave-valore. Per questo motivo, la dimensione dei messaggi di log della funzione può aumentare.
## Runtime e metodi di registrazione supportati
Lambda attualmente supporta l'opzione di generare i log delle applicazioni in formato JSON strutturato per i seguenti runtime.
| Lingua | Versioni supportate |
| --- | --- |
| Java | Tutti i runtime Java eccetto Java 8 su Amazon Linux 1 |
| .NET | .NET 8 e versioni successive |
| Node.js | Node.js 16 e versioni successive |
| Python | Python 3.8 e versioni successive |
| Rust | N/A |
Affinché Lambda invii i log delle applicazioni della funzione CloudWatch in formato JSON strutturato, la funzione deve utilizzare i seguenti strumenti di registrazione integrati per generare i log:
+ **Java**: il logger o Log4j2. `LambdaLogger` Per ulteriori informazioni, consulta [Registrare e monitorare funzioni Lambda in Java](java-logging.md).
+ **.NET**: l'`ILambdaLogger`istanza sull'oggetto contestuale. Per ulteriori informazioni, consulta [Registrare e monitorare le funzioni Lambda con C\$1](csharp-logging.md).
+ **Node.js**: i metodi della console `console.trace` `console.debug``console.log`,`console.info`,`console.error`, e`console.warn`. Per ulteriori informazioni, consulta [Registrare e monitorare funzioni Lambda in Node.js](nodejs-logging.md).
+ **Python**: la libreria Python standard. `logging` Per ulteriori informazioni, consulta [Registrare e monitorare le funzioni Lambda con Python](python-logging.md).
+ **Rust**: La cassa. `tracing` Per ulteriori informazioni, consulta [Registrare e monitorare le funzioni Lambda con Rust](rust-logging.md).
Per altri runtime Lambda gestiti, Lambda attualmente supporta nativamente solo l'acquisizione dei log di sistema in formato JSON strutturato. Tuttavia, è ancora possibile acquisire i log delle applicazioni in formato JSON strutturato in qualsiasi runtime utilizzando strumenti di registrazione come Powertools per AWS Lambda generare output di log in formato JSON.
## Formati di log predefiniti
Attualmente, il formato di log predefinito per tutti i runtime Lambda è il testo normale. Per le istanze gestite Lambda, il formato di registro è sempre JSON e non può essere modificato.
Se utilizzi già librerie di registrazione come Powertools AWS Lambda per generare i log delle funzioni in formato strutturato JSON, non devi modificare il codice se selezioni la formattazione dei log JSON. Lambda non codifica due volte i log che sono già codificati in JSON, quindi i log delle applicazioni della funzione continueranno a essere acquisiti come prima.
## Formato JSON per i log di sistema
Quando configuri il formato di log della funzione come JSON, ogni elemento del log di sistema (evento della piattaforma) viene acquisito come un oggetto JSON contenente coppie chiave-valore con le seguenti chiavi:
+ `"time"`: l'ora in cui è stato generato il messaggio di log
+ `"type"`: il tipo di evento che viene registrato
+ `"record"`: il contenuto dell'output log
Il formato del valore `"record"` varia in base al tipo di evento registrato. Per ulteriori informazioni, consulta [Tipi di oggetti `Event` dell'API di telemetria](telemetry-schema-reference.md#telemetry-api-events). Per ulteriori informazioni sui livelli di log assegnati ai log eventi di sistema, consulta la pagina [Strumento di mappatura degli eventi a livello di log di sistema](monitoring-cloudwatchlogs-log-level.md#monitoring-cloudwatchlogs-log-level-mapping).
A titolo di confronto, i due esempi seguenti mostrano lo stesso output log in formato di testo normale e in formato JSON strutturato. Tieni presente che, nella maggior parte dei casi, i log eventi di sistema contengono più informazioni quando vengono emessi in formato JSON rispetto a quando vengono emessi in testo normale.
**Example testo normale:**
```
2024-03-13 18:56:24.046000 fbe8c1 INIT_START Runtime Version: python:3.12.v18 Runtime Version ARN: arn:aws:lambda:eu-west-1::runtime:edb5a058bfa782cb9cedc6d534ac8b8c193bc28e9a9879d9f5ebaaf619cd0fc0
```
**Example JSON strutturato:**
```
{
"time": "2024-03-13T18:56:24.046Z",
"type": "platform.initStart",
"record": {
"initializationType": "on-demand",
"phase": "init",
"runtimeVersion": "python:3.12.v18",
"runtimeVersionArn": "arn:aws:lambda:eu-west-1::runtime:edb5a058bfa782cb9cedc6d534ac8b8c193bc28e9a9879d9f5ebaaf619cd0fc0"
}
}
```
**Nota**
L'[Accesso ai dati di telemetria in tempo reale per le estensioni tramite l'API Telemetry](telemetry-api.md) emette sempre eventi della piattaforma come `START` e `REPORT` in formato JSON. La configurazione del formato dei log di sistema a cui Lambda invia CloudWatch non influisce sul comportamento dell'API Lambda Telemetry.
## Formato JSON per i log delle applicazioni
Quando configuri il formato di log della funzione come JSON, gli output di log delle applicazioni scritti utilizzando le librerie e i metodi di registrazione di log supportati vengono acquisiti come oggetti JSON che contengono coppie chiave-valore con le chiavi riportate di seguito.
+ `"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"` (Python, .NET e Node.js) o `"AWSrequestId"` (Java): l'ID di richiesta univoco per l'invocazione della funzione
A seconda del runtime e del metodo di registrazione di log utilizzato dalla funzione, questo oggetto JSON può anche contenere coppie di chiavi aggiuntive. Ad esempio, in Node.js, se la funzione utilizza metodi della `console` per registrare i log degli oggetti di errore con più argomenti, l'oggetto JSON conterrà coppie chiave-valore aggiuntive con le chiavi `errorMessage`, `errorType` e `stackTrace`. Per ulteriori informazioni sui log in formato JSON in diversi runtime Lambda, consulta [Registrare e monitorare le funzioni Lambda con Python](python-logging.md), [Registrare e monitorare funzioni Lambda in Node.js](nodejs-logging.md) e [Registrare e monitorare funzioni Lambda in Java](java-logging.md).
**Nota**
La chiave utilizzata da Lambda per il valore del timestamp è diversa per i log di sistema e i log delle applicazioni. Per i log di sistema, Lambda utilizza la chiave `"time"` per mantenere la coerenza con l'API di telemetria. Per i log delle applicazioni, Lambda segue le convenzioni dei runtime supportati e utilizza `"timestamp"`.
A titolo di confronto, i due esempi seguenti mostrano lo stesso output log in formato di testo normale e in formato JSON strutturato.
**Example testo normale:**
```
2024-10-27T19:17:45.586Z 79b4f56e-95b1-4643-9700-2807f4e68189 INFO some log message
```
**Example JSON strutturato:**
```
{
"timestamp":"2024-10-27T19:17:45.586Z",
"level":"INFO",
"message":"some log message",
"requestId":"79b4f56e-95b1-4643-9700-2807f4e68189"
}
```
## Impostazione del formato di log della funzione
Per configurare il formato di registro per la tua funzione, puoi usare la console Lambda o il AWS Command Line Interface ()AWS CLI. Puoi anche configurare il formato di registro di una funzione utilizzando i comandi [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)e l'API [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)Lambda, la risorsa AWS Serverless Application Model (AWS SAM) e la [AWS::Serverless::Function CloudFormation[AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)risorsa.
La modifica del formato di registro della funzione non influisce sui log esistenti archiviati in CloudWatch Logs. Solo i nuovi log utilizzeranno il formato aggiornato.
Se modifichi il formato di log della funzione in JSON e non imposti il livello di log, Lambda imposta in automatico il livello di log dell'applicazione e il livello di log del sistema della funzione su INFO. Ciò significa che Lambda invia solo output di log di livello INFO e inferiore a Logs. CloudWatch Per ulteriori informazioni sul filtraggio a livello di log di applicazioni e sistemi, consulta [Filtraggio a livello di log](monitoring-cloudwatchlogs-log-level.md)
**Nota**
Per i runtime Python, quando il formato di log della funzione è impostato su testo semplice, l'impostazione predefinita a livello di log è WARN. Ciò significa che Lambda invia solo output di log di livello WARN e inferiore a Logs. CloudWatch La modifica del formato di log della funzione in JSON modifica questo comportamento predefinito. Per ulteriori informazioni sulla registrazione di log in Python, consulta [Registrare e monitorare le funzioni Lambda con Python](python-logging.md).
Per le funzioni Node.js che emettono log in formato EMF (Embedded Metric Format), la modifica del formato di registro della funzione in JSON potrebbe comportare l'impossibilità di riconoscere le metriche. CloudWatch
**Importante**
Se la vostra funzione utilizza Powertools for AWS Lambda (TypeScript) o le librerie client EMF open source per emettere i log EMF, aggiornate le librerie [Powertools](https://github.com/aws-powertools/powertools-lambda-typescript) ed [EMF](https://www.npmjs.com/package/aws-embedded-metrics) alle versioni più recenti per assicurarvi che possa continuare ad analizzare i log correttamente. CloudWatch Se passi al formato di log JSON, ti consigliamo anche di eseguire dei test per garantire la compatibilità con i parametri incorporati della tua funzione. Per ulteriori consigli sulle funzioni node.js che emettono log EMF, consulta la pagina [Utilizzo di librerie client formato del parametro incorporato (EMF) con log JSON strutturati](nodejs-logging.md#nodejs-logging-advanced-emf).
**Configurazione del formato 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. In **Contenuto del log**, per **Formato del log** seleziona **Testo** o **JSON**.
1. Scegli **Save** (Salva).
**Modifica del formato di log di una funzione esistente (AWS CLI)**
+ Per modificare il formato 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). Imposta l'opzione `LogFormat` in `LoggingConfig` su `JSON` o `Text`.
```
aws lambda update-function-configuration \
--function-name myFunction \
--logging-config LogFormat=JSON
```
**Configurazione del formato di log durante la creazione di una funzione (AWS CLI)**
+ Per configurare il formato di log quando crei una nuova funzione, utilizza l'opzione `--logging-config` nel comando [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html). Impostare `LogFormat` su `JSON` o su `Text`. Il comando di esempio seguente crea una funzione Node.js che genera i log in formato JSON strutturato.
Se non specifichi un formato di log quando crei una funzione, Lambda utilizzerà il formato di log predefinito per la versione di runtime selezionata. Per informazioni sui formati di registrazione predefiniti, consulta la pagina [Formati di log predefiniti](#monitoring-cloudwatchlogs-format-default).
```
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 LogFormat=JSON
```
# Filtraggio a livello di log
Lambda può filtrare i log della funzione in modo che solo i log con un certo livello di dettaglio o inferiore vengano inviati a Logs. CloudWatch Puoi configurare il filtraggio a livello di log separatamente per i log di sistema della funzione (i log generati da Lambda) e i log delle applicazioni (i log generati dal codice della funzione).
Per [Runtime e metodi di registrazione supportati](monitoring-cloudwatchlogs-logformat.md#monitoring-cloudwatchlogs-logformat-supported), non è necessario apportare modifiche al codice della funzione per Lambda per filtrare i log delle applicazioni della funzione in Lambda.
Per tutti gli altri runtime e metodi di registrazione, il codice della funzione deve generare log eventi in `stdout` o `stderr` come oggetti in formato JSON contenenti una coppia chiave-valore con la chiave `"level"`. Ad esempio, Lambda interpreta il seguente output su `stdout` come un log di livello DEBUG.
```
print('{"level": "debug", "msg": "my debug log", "timestamp": "2024-11-02T16:51:31.587199Z"}')
```
Se il campo del valore `"level"` non è valido o è assente, Lambda assegnerà all'output log il livello INFO. Affinché Lambda utilizzi il campo timestamp, è necessario specificare l'ora in un formato 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.
Quando assegni un nome alla chiave timestamp, segui le convenzioni del runtime che stai utilizzando. Lambda supporta le convenzioni di denominazione più comuni utilizzate dai runtime gestiti.
**Nota**
Per utilizzare il filtraggio a livello di log, la funzione deve essere configurata per utilizzare il formato di log JSON. Attualmente, il formato di log predefinito per tutti i runtime gestiti da Lambda è il testo normale. Per informazioni su come impostare il formato di log della funzione su JSON, consulta la pagina [Impostazione del formato di log della funzione](monitoring-cloudwatchlogs-logformat.md#monitoring-cloudwatchlogs-set-format).
Per i log delle applicazioni (i log generati dal codice della funzione), puoi scegliere tra i seguenti livelli di log.
| Livello di log | Utilizzo standard |
| --- | --- |
| TRACE (dettaglio massimo) | Le informazioni più dettagliate utilizzate per tracciare il percorso di esecuzione del codice |
| DEBUG | Informazioni dettagliate per il debug del sistema |
| INFO | Messaggi che registrano il normale funzionamento della funzione |
| WARN | Messaggi relativi a potenziali errori che possono portare a comportamenti imprevisti se non risolti |
| ERRORE | Messaggi relativi a problemi che impediscono al codice di funzionare come previsto |
| FATAL (dettaglio minimo) | Messaggi relativi a errori gravi che causano l'interruzione del funzionamento dell'applicazione |
Quando si seleziona un livello di registro, Lambda invia i log a quel livello e successivamente a Logs. CloudWatch Ad esempio, se imposti il livello di log dell'applicazione di una funzione su WARN, Lambda non invia output log ai livelli INFO e DEBUG. Il livello di log dell'applicazione predefinito per il filtraggio dei log è INFO.
Quando Lambda filtra i log delle applicazioni della funzione, ai messaggi di log senza livello verrà assegnato il livello di log INFO.
Per i log di sistema (i log generati dal servizio Lambda), puoi scegliere tra i seguenti livelli di log.
| Livello di log | Utilizzo |
| --- | --- |
| DEBUG (dettaglio massimo) | Informazioni dettagliate per il debug del sistema |
| INFO | Messaggi che registrano il normale funzionamento della funzione |
| WARN (dettaglio minimo) | Messaggi relativi a potenziali errori che possono portare a comportamenti imprevisti se non risolti |
Quando si seleziona un livello di log, Lambda invia i log di quel livello e di livello inferiore. Ad esempio, se imposti il livello di log di sistema di una funzione su INFO, Lambda non invia output log a livello DEBUG.
Per impostazione predefinita, Lambda imposta il livello di log del sistema su INFO. Con questa impostazione, Lambda invia `"start"` e `"report"` registra automaticamente i messaggi a. CloudWatch Per ricevere log di sistema più o meno dettagliati, modifica il livello di log in DEBUG o WARN. Per visualizzare un elenco dei livelli di log a cui Lambda mappa i diversi log eventi di sistema, consulta la pagina [Strumento di mappatura degli eventi a livello di log di sistema](#monitoring-cloudwatchlogs-log-level-mapping).
## Configurazione del filtraggio a livello di log
Per configurare il filtro a livello di registro dell'applicazione e del sistema per la tua funzione, puoi utilizzare la console Lambda o il (). AWS Command Line Interface AWS CLI Puoi anche configurare il livello di registro di una funzione utilizzando i comandi [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)e l'API [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)Lambda, la risorsa AWS Serverless Application Model (AWS SAM) e la [AWS::Serverless::Function CloudFormation[AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)risorsa.
Tieni presente che se imposti il livello di log della funzione nel codice, questa impostazione ha la precedenza su qualsiasi altra impostazione del livello di log che configuri. Ad esempio, se utilizzi il metodo `logging` `setLevel()` di Python per impostare il livello di registrazione di log della funzione su INFO, questa impostazione ha la precedenza su un'impostazione di WARN configurata utilizzando la console Lambda.
**Configurazione del livello di log dell'applicazione o di sistema di una funzione esistente (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. In **Contenuto del log**, per **Formato del log** assicurati che sia selezionato **JSON**.
1. Utilizzando i pulsanti di opzione, seleziona i valori di **Livello di log dell'applicazione** e **Livello di log del sistema** desiderati per la funzione.
1. Scegli **Save** (Salva).
**Configurazione del livello di log dell'applicazione o di sistema di una funzione esistente (AWS CLI)**
+ Per modificare il livello di log dell'applicazione o del sistema di una funzione esistente, utilizza il comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html). Utilizza `--logging-config` per impostare `SystemLogLevel` su `DEBUG`, `INFO` o `WARN`. Imposta `ApplicationLogLevel` su `DEBUG`, `INFO`, `WARN`, `ERROR` o `FATAL`.
```
aws lambda update-function-configuration \
--function-name myFunction \
--logging-config LogFormat=JSON,ApplicationLogLevel=ERROR,SystemLogLevel=WARN
```
**Configurazione del filtraggio a livello di log durante la creazione di una funzione**
+ Per configurare il filtraggio a livello di log quando crei una nuova funzione, utilizza `--logging-config` per impostare le chiavi `SystemLogLevel` e `ApplicationLogLevel` nel comando [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html). Imposta `SystemLogLevel` su `DEBUG`, `INFO` o `WARN`. Imposta `ApplicationLogLevel` su `DEBUG`, `INFO`, `WARN`, `ERROR` o `FATAL`.
```
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 LogFormat=JSON,ApplicationLogLevel=ERROR,SystemLogLevel=WARN
```
## Strumento di mappatura degli eventi a livello di log di sistema
Per gli eventi di log a livello di sistema generati da Lambda, la tabella seguente definisce il livello di log assegnato a ciascun evento. Per ulteriori informazioni sugli eventi elencati nella tabella, consulta la pagina [Riferimento allo schema `Event` dell'API di telemetria Lambda](telemetry-schema-reference.md)
| Nome evento | Condizione | Livello di log assegnato |
| --- | --- | --- |
| initStart | runtimeVersion è impostato | INFO |
| initStart | runtimeVersion non è impostato | DEBUG |
| initRuntimeDone | status=success | DEBUG |
| initRuntimeDone | status=success | WARN |
| initReport | initializationType\$1=on-demand | INFO |
| initReport | initializationType=on-demand | DEBUG |
| initReport | status=success | WARN |
| restoreStart | runtimeVersion è impostato | INFO |
| restoreStart | runtimeVersion non è impostato | DEBUG |
| restoreRuntimeDone | status=success | DEBUG |
| restoreRuntimeDone | status=success | WARN |
| restoreReport | status=success | INFO |
| restoreReport | status=success | WARN |
| rapida | - | INFO |
| runtimeDone | status=success | DEBUG |
| runtimeDone | status=success | WARN |
| report | status=success | INFO |
| report | status=success | WARN |
| Estensione | state=success | INFO |
| Estensione | state\$1=success | WARN |
| logSubscription | - | INFO |
| telemetrySubscription | - | INFO |
| logsDropped | - | WARN |
**Nota**
L'[Accesso ai dati di telemetria in tempo reale per le estensioni tramite l'API Telemetry](telemetry-api.md) emette sempre il set completo di eventi della piattaforma. La configurazione del livello dei log di sistema a cui Lambda invia CloudWatch non influisce sul comportamento dell'API Lambda Telemetry.
## Filtraggio delle applicazioni a livello di log con runtime personalizzati
Quando configuri il filtraggio a livello di log dell'applicazione per la tua funzione, dietro le quinte Lambda imposta il livello di log dell'applicazione nel runtime utilizzando la variabile di ambiente `AWS_LAMBDA_LOG_LEVEL`. Lambda imposta anche il formato di log della funzione utilizzando la variabile di ambiente `AWS_LAMBDA_LOG_FORMAT`. Puoi utilizzare queste variabili per integrare i controlli di registrazione avanzati di Lambda in un [runtime personalizzato](runtimes-custom.md).
Per poter configurare le impostazioni di registrazione per una funzione utilizzando un runtime personalizzato con la console Lambda e APIs Lambda AWS CLI, configura il runtime personalizzato per controllare il valore di queste variabili di ambiente. È quindi possibile configurare i logger del runtime in base al formato di log e ai livelli di log selezionati.
# 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)
# Invio dei log delle funzioni Lambda a Firehose
La console Lambda offre ora la possibilità di inviare registri delle funzioni a Firehose. Ciò consente lo streaming in tempo reale dei log verso varie destinazioni supportate da Firehose, inclusi strumenti di analisi di terze parti ed endpoint personalizzati.
**Nota**
È possibile configurare i log delle funzioni Lambda da inviare a Firehose utilizzando la console AWS CLI Lambda e tutti gli SDK. AWS CloudFormation AWS
## Prezzi
Per informazioni sui prezzi, consulta i [prezzi di Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/#Vended_Logs).
## Autorizzazioni richieste per la destinazione del registro di Firehose
Quando si utilizza la console Lambda per configurare Firehose come destinazione di registro della funzione, è necessario:
1. Le [autorizzazioni IAM richieste](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-cloudwatchlogs.html#monitoring-cloudwatchlogs-prereqs) per utilizzare CloudWatch Logs with Lambda.
1. Per [configurare i filtri di abbonamento con Firehose](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/SubscriptionFilters.html#FirehoseExample). Questo filtro definisce quali eventi di log vengono distribuiti al tuo flusso Firehose.
## Invio dei log delle funzioni Lambda a Firehose
Nella console Lambda, è possibile inviare i log delle funzioni direttamente a Firehose dopo aver creato una nuova funzione. Per farlo, completa le seguenti fasi.
1. Accedi alla console di gestione e apri laconsole .
1. Scegli il nome della tua funzione.
1. Scegli la scheda **Configurazione**.
1. Scegliete la scheda **Strumenti operativi e di monitoraggio**.
1. Nel riquadro Configurazione della registrazione, scegli Modifica.
1. Nella sezione «Contenuto del registro», seleziona un formato di registro.
1. Nella sezione Step 1 (Fase 1) completare i passaggi seguenti.
1. Seleziona un servizio di destinazione.
1. Scegli un gruppo di log esistente o creane uno nuovo.
**Nota**
Se scegli un gruppo di log esistente per una destinazione Firehose, assicurati che il gruppo di log che scegli sia un tipo di gruppo di `Delivery` log.
1. Scegliete uno stream Firehose.
1. Verrà visualizzato il gruppo di log `Delivery` CloudWatch.
1. Selezionare **Salva**.
**Nota**
Se il ruolo IAM fornito nella console non dispone dell'autorizzazione richiesta, la configurazione della destinazione avrà esito negativo. Per risolvere questo problema, fare riferimento a Autorizzazioni richieste per la destinazione del registro di Firehose per fornire le autorizzazioni richieste.
## Registri multi-account
È possibile configurare Lambda per inviare i log al flusso di distribuzione di Firehose in un account diverso. AWS Ciò richiede l'impostazione di una destinazione e la configurazione delle autorizzazioni appropriate in entrambi gli account.
Per istruzioni dettagliate sulla configurazione della registrazione tra account, inclusi i ruoli e le policy IAM richiesti, consulta [Configurazione di un nuovo abbonamento tra account nella documentazione di CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CrossAccountSubscriptions.html) Logs.
# Invio di log delle funzioni Lambda ad Amazon S3
Puoi configurare la tua funzione Lambda per inviare i log direttamente ad Amazon S3 utilizzando la console Lambda. Questa funzionalità offre una soluzione economica per l'archiviazione dei log a lungo termine e consente potenti opzioni di analisi utilizzando servizi come Athena.
**Nota**
Puoi configurare i log delle funzioni Lambda da inviare ad Amazon S3 utilizzando la console AWS CLI Lambda e tutti gli SDK. AWS CloudFormation AWS
## Prezzi
Per informazioni sui prezzi, consulta i [prezzi di Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/#Vended_Logs).
## Autorizzazioni necessarie per la destinazione del log Amazon S3
Quando utilizzi la console Lambda per configurare Amazon S3 come destinazione dei log della tua funzione, devi:
1. Le [autorizzazioni IAM richieste](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-cloudwatchlogs.html#monitoring-cloudwatchlogs-prereqs) per utilizzare CloudWatch Logs with Lambda.
1. Da a [Configura un filtro di sottoscrizioni CloudWatch Logs per inviare i log delle funzioni Lambda ad Amazon S3](#using-cwl-subscription-filter-lambda-s3). Questo filtro definisce quali eventi di log vengono distribuiti al bucket Amazon S3.
## Configura un filtro di sottoscrizioni CloudWatch Logs per inviare i log delle funzioni Lambda ad Amazon S3
Per inviare i log da CloudWatch Logs ad Amazon S3, devi creare un filtro di sottoscrizione. Questo filtro definisce quali eventi di log vengono distribuiti al bucket Amazon S3. L'argomento deve trovarsi nella stessa Regione del bucket Amazon S3.
### Creazione di un filtro di sottoscrizione per Amazon S3
1. Crea un bucket Amazon Simple Storage Service (Amazon S3). Consigliamo di utilizzare un bucket creato appositamente per CloudWatch Logs. Tuttavia, se intendi utilizzare un bucket esistente, puoi passare alla fase 2.
Esegui il comando seguente, sostituendo il segnaposto Regione con la Regione che desideri utilizzare:
```
aws s3api create-bucket --bucket amzn-s3-demo-bucket2 --create-bucket-configuration LocationConstraint=region
```
**Nota**
`amzn-s3-demo-bucket2`è un esempio del nome del bucket Amazon S3. *È riservato.* Affinché questa procedura funzioni, è necessario sostituirla con il nome univoco del bucket Amazon S3.
Di seguito è riportato un output di esempio:
```
{
"Location": "/amzn-s3-demo-bucket2"
}
```
1. Crea il ruolo IAM che concede a File di log CloudWatch l'autorizzazione per inserire dati nel flusso. Questa policy include una chiave di contesto della condizione globale per prevenire il problema di sicurezza noto come "confused deputy". Per ulteriori informazioni sulla prevenzione del problema del "confused deputy", consulta .
1. In primo luogo, utilizza un editor di testo per creare una policy di attendibilità in un file `~/TrustPolicyForCWL.json`, come segue:
```
{
"Statement": {
"Effect": "Allow",
"Principal": { "Service": "logs.amazonaws.com" },
"Condition": {
"StringLike": {
"aws:SourceArn": "arn:aws:logs:region:123456789012:*"
}
},
"Action": "sts:AssumeRole"
}
}
```
1. Utilizza il comando create-role per creare un ruolo IAM, specificando il file della policy di attendibilità. Annota il valore Role.Arn restituito, poiché ne avrai bisogno anche in una fase successiva:
```
aws iam create-role \
--role-name CWLtoS3Role \
--assume-role-policy-document file://~/TrustPolicyForCWL.json
{
"Role": {
"AssumeRolePolicyDocument": {
"Statement": {
"Action": "sts:AssumeRole",
"Effect": "Allow",
"Principal": {
"Service": "logs.amazonaws.com"
},
"Condition": {
"StringLike": {
"aws:SourceArn": "arn:aws:logs:region:123456789012:*"
}
}
}
},
"RoleId": "AAOIIAH450GAB4HC5F431",
"CreateDate": "2015-05-29T13:46:29.431Z",
"RoleName": "CWLtoS3Role",
"Path": "/",
"Arn": "arn:aws:iam::123456789012:role/CWLtoS3Role"
}
}
```
1. Crea una policy di autorizzazioni per definire che operazioni possono essere eseguite da CloudWatch Logs nel tuo account. In primo luogo, utilizza un editor di testo per creare una policy di autorizzazione in un file `~/PermissionsForCWL.json`:
```
{
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:PutObject"],
"Resource": ["arn:aws:s3:::amzn-s3-demo-bucket2/*"]
}
]
}
```
Associa la policy di autorizzazioni al ruolo inserendo il comando seguente:
```
aws iam put-role-policy --role-name CWLtoS3Role --policy-name Permissions-Policy-For-S3 --policy-document file://~/PermissionsForCWL.json
```
1. Scegli un gruppo di log esistente o creane uno nuovo.
```
aws logs create-log-group --log-group-name my-logs --log-group-class DELIVERY --region REGION_NAME
```
1. Configurazione della destinazione
```
aws logs put-subscription-filter
--log-group-name my-logs
--filter-name my-lambda-delivery
--filter-pattern ""
--destination-arn arn:aws:s3:::amzn-s3-demo-bucket2
--role-arn arn:aws:iam::123456789012:role/CWLtoS3Role
--region REGION_NAME
```
## Invio di log delle funzioni Lambda ad Amazon S3
Nella console Lambda, puoi inviare i log delle funzioni direttamente ad Amazon S3 dopo aver creato una nuova funzione. Per farlo, completa le seguenti fasi.
1. Accedi alla console di gestione e apri laconsole .
1. Scegli il nome della tua funzione.
1. Scegli la scheda **Configurazione**.
1. Scegli la scheda Strumenti **operativi e di monitoraggio**.
1. Nel riquadro Configurazione della registrazione, scegli Modifica.
1. Nella sezione «Contenuto del registro», seleziona un formato di registro.
1. Nella sezione Step 1 (Fase 1) completare i passaggi seguenti.
1. Seleziona un servizio di destinazione.
1. Scegli un gruppo di log esistente o creane uno nuovo.
**Nota**
Se scegli un gruppo di log esistente per una destinazione Amazon S3, assicurati che il gruppo di log che scegli sia un tipo di gruppo di `Delivery` log.
1. Scegli un bucket Amazon S3 come destinazione per i log delle funzioni.
1. Verrà visualizzato il gruppo di log `Delivery` CloudWatch.
1. Selezionare **Salva**.
**Nota**
Se il ruolo IAM fornito nella console non dispone delle autorizzazioni richieste, la configurazione della destinazione avrà esito negativo. Per risolvere questo problema, consulta [Autorizzazioni richieste per la destinazione dei log di Amazon S3](#logging-s3-permissions).
## Registrazione multi-account
È possibile configurare Lambda per inviare i log a un bucket Amazon S3 in un account. AWS Ciò richiede l'impostazione di una destinazione e la configurazione delle autorizzazioni appropriate in entrambi gli account.
Per istruzioni dettagliate sulla configurazione della registrazione tra account, inclusi i ruoli e le policy IAM richiesti, consulta [Configurazione di un nuovo abbonamento tra account nella documentazione di CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CrossAccountSubscriptions.html) Logs.