Registrare e monitorare funzioni Lambda in Java - AWS Lambda
Creazione di una funzione che restituisce i registriUtilizzo dei controlli di registrazione avanzati di Lambda con JavaImplementazione della registrazione avanzata con Log4j2 e SLF4JStrumenti e librerieUtilizzo di Powertools per AWS Lambda (Java) e di AWS SAM per la registrazione strutturataVisualizzazione dei log nella console LambdaVisualizzazione dei registri nella console CloudWatchVisualizzazione dei log tramite la AWS Command Line Interface (AWS CLI)Eliminazione dei logCodice di registrazione dei log di esempio

Registrare e monitorare funzioni Lambda in Java

AWS Lambda monitora automaticamente le funzioni Lambda e invia le voci di log ad Amazon CloudWatch. La funzione Lambda viene fornita con un gruppo di log CloudWatch con un flusso di log per ogni istanza della funzione. L'ambiente di runtime di Lambda invia al flusso di log i dettagli su ogni invocazione e altri output dal codice della funzione. Per ulteriori informazioni sui log CloudWatch, consulta Lambda invia automaticamente i log delle funzioni a CloudWatch Logs..

Per generare output di log dal codice della funzione, puoi utilizzare i metodi di java.lang.System o qualsiasi modulo di registrazione che scriva in stdout o stderr.

Creazione di una funzione che restituisce i registri

Per i log di output del codice della funzione, puoi usare i metodi di java.lang.System o qualsiasi modulo di registrazione che scriva in stdout o stderr. La libreria aws-lambda-java-core fornisce una classe di logger denominata LambdaLogger a cui è possibile accedere dall'oggetto contestuale. La classe di logger supporta i log multilinea.

Nell'esempio seguente viene utilizzato il logger LambdaLogger fornito dall'oggetto contestuale.

Esempio Handler.java
// Handler value: example.Handler
public class Handler implements RequestHandler<Object, String>{
  Gson gson = new GsonBuilder().setPrettyPrinting().create();
  @Override
  public String handleRequest(Object event, Context context)
  {
    LambdaLogger logger = context.getLogger();
    String response = new String("SUCCESS");
    // log execution details
    logger.log("ENVIRONMENT VARIABLES: " + gson.toJson(System.getenv()));
    logger.log("CONTEXT: " + gson.toJson(context));
    // process event
    logger.log("EVENT: " + gson.toJson(event));
    return response;
  }
}
Esempio Formato dei log
START RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Version: $LATEST
ENVIRONMENT VARIABLES: 
{
    "_HANDLER": "example.Handler",
    "AWS_EXECUTION_ENV": "AWS_Lambda_java8",
    "AWS_LAMBDA_FUNCTION_MEMORY_SIZE": "512",
    ...
}
CONTEXT: 
{
    "memoryLimit": 512,
    "awsRequestId": "6bc28136-xmpl-4365-b021-0ce6b2e64ab0",
    "functionName": "java-console",
    ...
}
EVENT:
{
  "records": [
    {
      "messageId": "19dd0b57-xmpl-4ac1-bd88-01bbb068cb78",
      "receiptHandle": "MessageReceiptHandle",
      "body": "Hello from SQS!",
       ...
    }
  ]
}
END RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0
REPORT RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0	Duration: 198.50 ms	Billed Duration: 724 ms	Memory Size: 512 MB	Max Memory Used: 90 MB	Init Duration: 524.75 ms

Il runtime di Java registra START, END e REPORT per ogni chiamata. La riga del report fornisce i seguenti dettagli:

Campi dati della riga REPORT

  • RequestID – L'ID della richiesta univoco per la chiamata.

  • Durata – La quantità di tempo che il metodo del gestore della funzione impiega durante l'elaborazione dell'evento.

  • Durata fatturata – La quantità di tempo fatturata per la chiamata.

  • Dimensioni memoria – La quantità di memoria allocata per la funzione.

  • Quantità max utilizzata – La quantità di memoria utilizzata dalla funzione. Quando le invocazioni condividono un ambiente di esecuzione, Lambda riporta la memoria massima utilizzata in tutte le invocazioni. Questo comportamento potrebbe comportare un valore riportato superiore al previsto.

  • Durata Init – Per la prima richiesta servita, la quantità di tempo impiegato dal runtime per caricare la funzione ed eseguire il codice al di fuori del metodo del gestore.

  • XRAY TraceId – Per le richieste tracciate, l'ID di traccia AWS X-Ray.

  • SegmentId – Per le richieste tracciate, l'ID segmento X-Ray.

  • Campionato – Per le richieste tracciate, il risultato del campionamento.

Utilizzo dei controlli di registrazione avanzati di Lambda con Java

Per avere un maggiore controllo sul modo in cui i log delle tue funzioni vengono acquisiti, elaborati e utilizzati, puoi configurare le seguenti opzioni di registrazione per i runtime Java supportati:

  • Formato di log: scegli tra i formati di testo normale e JSON strutturato per i log della funzione

  • Livello di log: per i log in formato JSON, scegli il livello di dettaglio dei log che Lambda invia a CloudWatch, come ERROR, DEBUG o INFO

  • Gruppo di log: scegli il gruppo di log di CloudWatch a cui la funzione invia i log

Per ulteriori informazioni su queste opzioni di registrazione e istruzioni su come configurare la funzione per utilizzarle, consulta la pagina Configurazione dei controlli di registrazione avanzati per le funzioni Lambda.

Per utilizzare le opzioni del formato di log e del livello di log con le funzioni Lambda in Java, consulta le istruzioni nelle sezioni seguenti.

Utilizzo del formato di log JSON strutturato con Java

Se si seleziona JSON come formato di log della funzione, Lambda invierà gli output log utilizzando la classe LambdaLogger come JSON strutturati. Ogni oggetto di log JSON contiene almeno quattro coppie chiave-valore con le seguenti chiavi:

  • "timestamp": l'ora in cui è stato generato il messaggio di log

  • "level": il livello di log assegnato al messaggio

  • "message": il contenuto del messaggio di log

  • "AWSrequestId": l'ID di richiesta univoco dell'invocazione alla funzione

A seconda del metodo di registrazione di log utilizzato, gli output di log della funzione acquisiti in formato JSON possono contenere anche coppie di chiave-valore aggiuntive.

Per assegnare un livello ai log creati utilizzando il logger LambdaLogger, è necessario fornire un argomento LogLevel nel comando di registrazione, come mostrato nell'esempio seguente.

Esempio Codice di registrazione di Java
LambdaLogger logger = context.getLogger();
logger.log("This is a debug log", LogLevel.DEBUG);

L'output log di questo codice di esempio verrebbe acquisito in File di log CloudWatch come segue:

Esempio Record di log JSON
{
    "timestamp":"2023-11-01T00:21:51.358Z",
    "level":"DEBUG",
    "message":"This is a debug log",
    "AWSrequestId":"93f25699-2cbf-4976-8f94-336a0aa98c6f"
}

Se non assegni un livello all'output log, Lambda gli assegnerà automaticamente il livello INFO.

Se il codice utilizza già un'altra libreria di registrazione per generare log JSON strutturati, non è necessario apportare alcuna modifica. Lambda non codifica due volte i log già codificati in JSON. Anche se configuri la funzione affinché utilizzi il formato di log JSON, i tuoi output di registrazione vengono visualizzati in CloudWatch nella struttura JSON che definisci.

Utilizzo del filtraggio a livello di log con Java

Affinché AWS Lambda filtri i log delle applicazioni in base al relativo livello di log, la funzione deve utilizzare i log in formato JSON. Puoi farlo in due modi:

Quando configuri la funzione per utilizzare il filtraggio a livello di log, devi selezionare una delle seguenti opzioni per il livello di log che desideri che Lambda invii a File di log CloudWatch:

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

Per consentire a Lambda di filtrare i log della funzione, è necessario includere anche una coppia chiave-valore "timestamp" nell'output log JSON. L'ora deve essere specificata in un formato di timestamp RFC 3339 valido. Se non fornisci un timestamp valido, Lambda assegnerà al log il livello INFO e aggiungerà un timestamp per tuo conto.

Lambda invia a CloudWatch i log del livello selezionato e di livello inferiore. Ad esempio, se configuri un livello di log WARN, Lambda invierà i log corrispondenti ai livelli WARN, ERROR e FATAL.

Implementazione della registrazione avanzata con Log4j2 e SLF4J

Nota

AWS Lambda non include Log4j2 nei tempi di esecuzione gestiti o nelle immagini del container di base. Pertanto, non sono influenzati dai problemi descritti in CVE-2021-44228, CVE-2021-45046 e CVE-2021-45105.

Per i casi in cui una funzione cliente include una versione Log4j2 interessata, abbiamo applicato una modifica ai temèi di esecuzione gestiti Lambda Java e alle immagini del container di base che aiutano a mitigare i problemi in CVE-2021-44228, CVE-2021-45046 e CVE-2021-45105. Come risultato di questa modifica, i clienti che utilizzano Log4J2 potrebbero vedere una voce di log aggiuntiva, simile a "Transforming org/apache/logging/log4j/core/lookup/JndiLookup (java.net.URLClassLoader@...)". Tutte le stringhe di log che fanno riferimento al mappatore jndi nell'output Log4J2 saranno sostituite con "Patched JndiLookup::lookup()".

Indipendentemente da questa modifica, incoraggiamo fortemente tutti i clienti le cui funzioni includono Log4j2 ad aggiornare l'ultima versione. In particolare, i clienti che utilizzano la libreria aws-lambda-java-log4j2 devono eseguire l'aggiornamento alla versione 1.5.0 (o successiva) e ridistribuire le funzioni. Questa versione aggiorna le dipendenze dell'utility Log4j2 sottostanti alla versione 2.17.0 (o successiva). Il file binario aws-lambda-java-log4j2 è disponibile nel repository Maven e il codice sorgente è disponibile in Github.

Infine, tieni presente che tutte le librerie relative ad aws-lambda-java-log4j (v1.0.0 o 1.0.1) non devono essere utilizzate in nessuna circostanza. Queste librerie sono correlate alla versione 1.x di log4j, che ha raggiunto il fine vita nel 2015. Le librerie non sono supportate, non sono gestite, non sono corredate di patch e presentano vulnerabilità di sicurezza note.

Per personalizzare l'output log, supportare la registrazione durante i test di unità e registrare le chiamate dell'SDK AWS, utilizza Apache Log4j 2 con SLF4J. Log4j è una libreria di registrazione per i programmi Java che consente di configurare i livelli di log e utilizzare librerie appender. SLF4J è una libreria di tipo Facade che consente di modificare quale libreria si utilizza senza modificare il codice di funzione.

Per aggiungere l'ID richiesta ai log della funzione, usa l'appender nella libreria aws-lambda-java-log4j2.

Esempio src/main/resources/log4j2.xml – Configurazione dell'appender
<Configuration>
  <Appenders>
    <Lambda name="Lambda" format="${env:AWS_LAMBDA_LOG_FORMAT:-TEXT}">
       <LambdaTextFormat>
         <PatternLayout>
             <pattern>%d{yyyy-MM-dd HH:mm:ss} %X{AWSRequestId} %-5p %c{1} - %m%n </pattern>
         </PatternLayout>
       </LambdaTextFormat>
       <LambdaJSONFormat>
         <JsonTemplateLayout eventTemplateUri="classpath:LambdaLayout.json" />
       </LambdaJSONFormat>
     </Lambda>
   </Appenders>
   <Loggers>
     <Root level="${env:AWS_LAMBDA_LOG_LEVEL:-INFO}">
       <AppenderRef ref="Lambda"/>
     </Root>
     <Logger name="software.amazon.awssdk" level="WARN" />
     <Logger name="software.amazon.awssdk.request" level="DEBUG" />
   </Loggers>
 </Configuration>

Puoi decidere di configurare gli output dei log di Log4j2 in testo normale o JSON specificando un layout sotto i tag <LambdaTextFormat> e <LambdaJSONFormat>.

Con questa configurazione, in modalità di testo, ogni riga è preceduta da data, ora, ID richiesta, livello di log e nome della classe. In modalità JSON, viene utilizzato <JsonTemplateLayout> con una configurazione fornita insieme alla libreria aws-lambda-java-log4j2.

SLF4J è una libreria di tipo Facade per la registrazione in codice Java. Nel codice funzione, si utilizza la factory del logger SLF4J per recuperare un logger con metodi per i livelli di log quali info() e warn(). Nella configurazione di compilazione, includere la libreria di registrazione e l'adattatore SLF4J nel classpath. Modificando le librerie nella configurazione di compilazione, è possibile modificare il tipo di logger senza modificare il codice della funzione. SLF4J è richiesto per acquisire i log da SDK per Java.

Nell'esempio di codice seguente, la classe del gestore utilizza SLF4J per recuperare un logger.

Esempio src/main/java/example/HandlerS3.java: Registrazione con SLF4J
package example;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.S3Event;

import static org.apache.logging.log4j.CloseableThreadContext.put;


public class HandlerS3 implements RequestHandler<S3Event, String>{
    private static final Logger logger = LoggerFactory.getLogger(HandlerS3.class);

    @Override
    public String handleRequest(S3Event event, Context context) {
        for(var record : event.getRecords()) {
            try (var loggingCtx = put("awsRegion", record.getAwsRegion())) {
                loggingCtx.put("eventName", record.getEventName());
                loggingCtx.put("bucket", record.getS3().getBucket().getName());
                loggingCtx.put("key", record.getS3().getObject().getKey());

                logger.info("Handling s3 event");
            }
        }

        return "Ok";
    }
}

Questo codice genera output log simili al seguente:

Esempio Formato dei log
{
    "timestamp": "2023-11-15T16:56:00.815Z",
    "level": "INFO",
    "message": "Handling s3 event",
    "logger": "example.HandlerS3",
    "AWSRequestId": "0bced576-3936-4e5a-9dcd-db9477b77f97",
    "awsRegion": "eu-south-1",
    "bucket": "java-logging-test-input-bucket",
    "eventName": "ObjectCreated:Put",
    "key": "test-folder/"
}

La configurazione di compilazione prende le dipendenze di runtime sull'appender Lambda e sull'adattatore SLF4J e le dipendenze di implementazione su Log4j2.

Esempio build.gradle – Registrazione delle dipendenze
dependencies {
    ...
    'com.amazonaws:aws-lambda-java-log4j2:[1.6.0,)',
    'com.amazonaws:aws-lambda-java-events:[3.11.3,)',
    'org.apache.logging.log4j:log4j-layout-template-json:[2.17.1,)',
    'org.apache.logging.log4j:log4j-slf4j2-impl:[2.19.0,)',
    ...
}

Quando esegui localmente il codice per i test, l'oggetto contestuale con il logger Lambda non è disponibile e non esiste alcun ID richiesta che possa essere utilizzato dall'appender Lambda. Per configurazioni di test di esempio, consulta le applicazioni di esempio nella sezione successiva.

Utilizzo di altri strumenti di registrazione e librerie

Powertools per AWS Lambda (Java) è un toolkit rivolto agli sviluppatori per implementare le best practice serverless e aumentare la velocità di sviluppo. L'utilità di registrazione fornisce un logger ottimizzato per Lambda che include informazioni aggiuntive sul contesto delle funzioni in tutte le funzioni con output strutturato come JSON. Utilizza l'utility per eseguire le seguenti operazioni:

  • Acquisizione di campi essenziali dal contesto Lambda, avvii a freddo e output di registrazione della struttura come JSON

  • Registrazione degli eventi di chiamata Lambda quando richiesto (disabilitata per impostazione predefinita)

  • Stampa di tutti i log solo per una percentuale di chiamate tramite campionamento dei log (disabilitata per impostazione predefinita)

  • Aggiunta di chiavi supplementari al log strutturato in qualsiasi momento

  • Utilizzo di un formattatore di log personalizzato (Bring Your Own Formatter) per generare i log in una struttura compatibile con Logging RFC dell'organizzazione

Utilizzo di Powertools per AWS Lambda (Java) e di AWS SAM per la registrazione strutturata

Segui i passaggi riportati sotto per scaricare, creare e implementare un'applicazione Hello World in Java di esempio con i moduli Powertools per AWS Lambda (Java) integrati utilizzando AWS SAM. Questa applicazione implementa un backend dell'API di base e utilizza Powertools per l'emissione di log, parametri e tracce. Consiste in un endpoint Gateway Amazon API e in una funzione Lambda. Quando si invia una richiesta GET all'endpoint API Gateway, la funzione Lambda richiama, invia log e parametri a CloudWatch utilizzando Embedded Metric Format e invia le tracce a AWS X-Ray. La funzione restituisce un messaggio hello world.

Prerequisiti

Per completare le fasi riportate in questa sezione, è necessario:

Implementare un'applicazione AWS SAM di esempio

  1. Inizializza l'applicazione utilizzando il modello Java Hello World.

    sam init --app-template hello-world-powertools-java --name sam-app --package-type Zip --runtime java11 --no-tracing

  2. Costruisci l'app.

    cd sam-app && sam build

  3. Distribuire l'app.

    sam deploy --guided

  4. Seguire le istruzioni visualizzate sullo schermo. Per accettare le opzioni predefinite fornite nell'esperienza interattiva, premi Enter.

    Nota

    Per HelloWorldFunction potrebbe non avere l'autorizzazione definita, va bene?, assicurati di inserire y.

  5. Ottieni l'URL dell'applicazione implementata:

    aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text

  6. Richiama l'endpoint dell'API:

    curl -X GET <URL_FROM_PREVIOUS_STEP>

    In caso di esito positivo, vedrai questa risposta:

    {"message":"hello world"}

  7. Per ottenere i log per la funzione, esegui sam logs. Per ulteriori informazioni, consulta l'argomento relativo all'utilizzo dei log nella Guida per sviluppatori AWS Serverless Application Model.

    sam logs --stack-name sam-app

    L'output del log ha la struttura seguente:

    2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:34.095000 INIT_START Runtime Version: java:11.v15    Runtime Version ARN: arn:aws:lambda:eu-central-1::runtime:0a25e3e7a1cc9ce404bc435eeb2ad358d8fa64338e618d0c224fe509403583ca
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:34.114000 Picked up JAVA_TOOL_OPTIONS: -XX:+TieredCompilation -XX:TieredStopAtLevel=1
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:34.793000 Transforming org/apache/logging/log4j/core/lookup/JndiLookup (lambdainternal.CustomerClassLoader@1a6c5a9e)
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:35.252000 START RequestId: 7fcf1548-d2d4-41cd-a9a8-6ae47c51f765 Version: $LATEST
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.531000 {
  "_aws": {
    "Timestamp": 1675416276051,
    "CloudWatchMetrics": [
      {
        "Namespace": "sam-app-powerools-java",
        "Metrics": [
          {
            "Name": "ColdStart",
            "Unit": "Count"
          }
        ],
        "Dimensions": [
          [
            "Service",
            "FunctionName"
          ]
        ]
      }
    ]
  },
  "function_request_id": "7fcf1548-d2d4-41cd-a9a8-6ae47c51f765",
  "traceId": "Root=1-63dcd2d1-25f90b9d1c753a783547f4dd;Parent=e29684c1be352ce4;Sampled=1",
  "FunctionName": "sam-app-HelloWorldFunction-y9Iu1FLJJBGD",
  "functionVersion": "$LATEST",
  "ColdStart": 1.0,
  "Service": "service_undefined",
  "logStreamId": "2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81",
  "executionEnvironment": "AWS_Lambda_java11"
}
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.974000 Feb 03, 2023 9:24:36 AM com.amazonaws.xray.AWSXRayRecorder <init>
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.993000 Feb 03, 2023 9:24:36 AM com.amazonaws.xray.config.DaemonConfiguration <init>
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.993000 INFO: Environment variable AWS_XRAY_DAEMON_ADDRESS is set. Emitting to daemon on address XXXX.XXXX.XXXX.XXXX:2000.
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:37.331000 09:24:37.294 [main] INFO  helloworld.App - {"version":null,"resource":"/hello","path":"/hello/","httpMethod":"GET","headers":{"Accept":"*/*","CloudFront-Forwarded-Proto":"https","CloudFront-Is-Desktop-Viewer":"true","CloudFront-Is-Mobile-Viewer":"false","CloudFront-Is-SmartTV-Viewer":"false","CloudFront-Is-Tablet-Viewer":"false","CloudFront-Viewer-ASN":"16509","CloudFront-Viewer-Country":"IE","Host":"XXXX.execute-api.eu-central-1.amazonaws.com","User-Agent":"curl/7.86.0","Via":"2.0 f0300a9921a99446a44423d996042050.cloudfront.net (CloudFront)","X-Amz-Cf-Id":"t9W5ByT11HaY33NM8YioKECn_4eMpNsOMPfEVRczD7T1RdhbtiwV1Q==","X-Amzn-Trace-Id":"Root=1-63dcd2d1-25f90b9d1c753a783547f4dd","X-Forwarded-For":"XX.XXX.XXX.XX, XX.XXX.XXX.XX","X-Forwarded-Port":"443","X-Forwarded-Proto":"https"},"multiValueHeaders":{"Accept":["*/*"],"CloudFront-Forwarded-Proto":["https"],"CloudFront-Is-Desktop-Viewer":["true"],"CloudFront-Is-Mobile-Viewer":["false"],"CloudFront-Is-SmartTV-Viewer":["false"],"CloudFront-Is-Tablet-Viewer":["false"],"CloudFront-Viewer-ASN":["16509"],"CloudFront-Viewer-Country":["IE"],"Host":["XXXX.execute-api.eu-central-1.amazonaws.com"],"User-Agent":["curl/7.86.0"],"Via":["2.0 f0300a9921a99446a44423d996042050.cloudfront.net (CloudFront)"],"X-Amz-Cf-Id":["t9W5ByT11HaY33NM8YioKECn_4eMpNsOMPfEVRczD7T1RdhbtiwV1Q=="],"X-Amzn-Trace-Id":["Root=1-63dcd2d1-25f90b9d1c753a783547f4dd"],"X-Forwarded-For":["XXX, XXX"],"X-Forwarded-Port":["443"],"X-Forwarded-Proto":["https"]},"queryStringParameters":null,"multiValueQueryStringParameters":null,"pathParameters":null,"stageVariables":null,"requestContext":{"accountId":"XXX","stage":"Prod","resourceId":"at73a1","requestId":"ba09ecd2-acf3-40f6-89af-fad32df67597","operationName":null,"identity":{"cognitoIdentityPoolId":null,"accountId":null,"cognitoIdentityId":null,"caller":null,"apiKey":null,"principalOrgId":null,"sourceIp":"54.240.197.236","cognitoAuthenticationType":null,"cognitoAuthenticationProvider":null,"userArn":null,"userAgent":"curl/7.86.0","user":null,"accessKey":null},"resourcePath":"/hello","httpMethod":"GET","apiId":"XXX","path":"/Prod/hello/","authorizer":null},"body":null,"isBase64Encoded":false}
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:37.351000 09:24:37.351 [main] INFO  helloworld.App - Retrieving https://checkip.amazonaws.com
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:39.313000 {
  "function_request_id": "7fcf1548-d2d4-41cd-a9a8-6ae47c51f765",
  "traceId": "Root=1-63dcd2d1-25f90b9d1c753a783547f4dd;Parent=e29684c1be352ce4;Sampled=1",
  "xray_trace_id": "1-63dcd2d1-25f90b9d1c753a783547f4dd",
  "functionVersion": "$LATEST",
  "Service": "service_undefined",
  "logStreamId": "2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81",
  "executionEnvironment": "AWS_Lambda_java11"
}
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:39.371000 END RequestId: 7fcf1548-d2d4-41cd-a9a8-6ae47c51f765
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:39.371000 REPORT RequestId: 7fcf1548-d2d4-41cd-a9a8-6ae47c51f765    Duration: 4118.98 ms    Billed Duration: 5275 ms    Memory Size: 512 MB    Max Memory Used: 152 MB    Init Duration: 1155.47 ms    
XRAY TraceId: 1-63dcd2d1-25f90b9d1c753a783547f4dd    SegmentId: 3a028fee19b895cb    Sampled: true

  8. Questo è un endpoint API pubblico accessibile su Internet. È consigliabile eliminare l'endpoint dopo il test.

    sam delete

Gestione della conservazione dei log

I gruppi di log non vengono eliminati automaticamente quando si elimina una funzione. Affinché i log non siano archiviati a tempo indeterminato, elimina il gruppo di log o configura un periodo di conservazione trascorso il quale i log vengono eliminati automaticamente da CloudWatch. Per configurare la conservazione dei log, aggiungi quanto segue al tuo modello AWS SAM:

Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      # Omitting other properties

  LogGroup:
    Type: AWS::Logs::LogGroup
    Properties:
      LogGroupName: !Sub "/aws/lambda/${HelloWorldFunction}"
      RetentionInDays: 7

Visualizzazione dei log nella console Lambda

È possibile utilizzare la console Lambda per visualizzare l'output del log dopo aver richiamato una funzione Lambda.

Se il codice può essere testato dall'editor del codice incorporato, troverai i log nei risultati dell’esecuzione. Quando utilizzi la funzionalità di test della console per richiamare una funzione, troverai l’output del log nella sezione Dettagli.

Visualizzazione dei registri nella console CloudWatch

È possibile utilizzare la console Amazon CloudWatch per visualizzare i registri per tutti i richiami della funzione Lambda.

Per visualizzare i log nella console CloudWatch:

  1. Aprire la pagina Log groups (Gruppi di log) nella console di CloudWatch.

  2. Scegliere il gruppo di log della funzione (/aws/lambda/function-name).

  3. Creare un flusso di log.

Ogni flusso di log corrisponde a un'istanza della funzione. Nuovi flussi di log vengono visualizzati quando aggiorni la funzione Lambda e quando vengono create istanze aggiuntive per gestire più chiamate simultanee. Per trovare i registri per un richiamo specifico, si consiglia di utilizzare la funzione con AWS X-Ray. X-Ray registra i dettagli sulla richiesta e il flusso di log nella traccia.

Visualizzazione dei log tramite la AWS Command Line Interface (AWS CLI)

AWS CLI è uno strumento open source che consente di interagire con i servizi AWS tramite i comandi nella shell a riga di comando. Per completare le fasi riportate in questa sezione, è necessario disporre della AWS CLI versione 2.

È possibile utilizzare AWS CLI 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.

Esempio 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"
}
Esempio 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'opzione cli-binary-format è necessaria se si utilizza la versione 2 della AWS CLI. 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 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. Gli utenti macOS potrebbero dover utilizzare base64 -D.

Esempio 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'opzione cli-binary-format è necessaria se si utilizza la versione 2 della AWS CLI. 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 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
Esempio (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
Esempio recuperare gli ultimi cinque eventi di log

Nello stesso prompt dei comandi, eseguire lo script seguente per ottenere gli ultimi cinque eventi di log.

./get-logs.sh

Verrà visualizzato l'output seguente:

{
    "StatusCode": 200,
    "ExecutedVersion": "$LATEST"
}
{
    "events": [
        {
            "timestamp": 1559763003171,
            "message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
            "ingestionTime": 1559763003309
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r  \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r  \"key\": \"value\"\r}\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
            "ingestionTime": 1559763018353
        }
    ],
    "nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
    "nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}

Eliminazione dei log

I gruppi di log non vengono eliminati automaticamente quando si elimina una funzione. Per evitare di archiviare i log a tempo indeterminato, eliminare il gruppo di log o configurare un periodo di conservazione trascorso il quale i log vengono eliminati automaticamente.

Codice di registrazione dei log di esempio

Il repository GitHub per questa guida include applicazioni di esempio che illustrano l'uso di varie configurazioni di registrazione. Ogni applicazione di esempio include script per semplificare la distribuzione e la pulizia, un modello AWS SAM e risorse di supporto.

Applicazioni Lambda di esempio in Java

  • example-java — Una funzione Java che dimostra come utilizzare Lambda per elaborare gli ordini. Questa funzione illustra come definire e deserializzare un oggetto evento di input personalizzato, utilizzare l'SDK e registrare l'output. AWS

  • java-basic: una raccolta di funzioni Java minimali con unit test e configurazione della registrazione dei log delle variabili.

  • java-events: una raccolta di funzioni Java che contengono codice skeleton per la gestione degli eventi di vari servizi, ad esempio Gateway Amazon API, Amazon SQS e Amazon Kinesis. Queste funzioni utilizzano la versione più recente della libreria aws-lambda-java-events (3.0.0 e versioni successive). Questi esempi non richiedono SDK AWS come dipendenza.

  • s3-java – Una funzione Java che elabora gli eventi di notifica da Amazon S3 e utilizza la Java Class Library (JCL) per creare anteprime dai file di immagine caricati.

  • layer-java — Una funzione Java che illustra come utilizzare un livello Lambda per impacchettare dipendenze separate dal codice della funzione principale.

L'applicazione java-basic di esempio mostra una configurazione di registrazione minima che supporta i test di registrazione. Il codice del gestore utilizza il logger LambdaLogger fornito dall'oggetto contestuale. Per i test, l'applicazione utilizza una classe TestLogger personalizzata che implementa l'interfaccia LambdaLogger con un logger Log4j2. Utilizza SLF4J come facciata per la compatibilità con l'SDK AWS. Le librerie di logging sono escluse dall'output di compilazione per mantenere il pacchetto di implementazione di dimensioni ridotte.