Registrare e monitorare funzioni Lambda in Java

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

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 aws-lambda-java-corelibreria fornisce una classe logger denominata a LambdaLogger cui è possibile accedere dall'oggetto context. La classe di logger supporta i log multilinea.

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

// 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;
  }
}

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: 200 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:

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:

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:

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.

LambdaLogger logger = context.getLogger();
logger.log("This is a debug log", LogLevel.DEBUG);

L'output di registro di questo codice di esempio verrebbe acquisito in CloudWatch Logs come segue:

{
    "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 tua funzione per utilizzare il formato di log JSON, i tuoi output di registrazione vengono visualizzati CloudWatch nella struttura JSON che definisci.

Utilizzo del filtraggio a livello di log con Java

Per AWS Lambda filtrare i log delle applicazioni in base al loro livello di registro, la funzione deve utilizzare log in formato JSON. Puoi farlo in due modi:

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

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 i log del livello selezionato e inferiore a. CloudWatch 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 J SLF4

Per personalizzare l'output dei log, supportare la registrazione durante i test unitari e registrare le chiamate AWS SDK, utilizzate Apache Log4j2 con SLF4 J. Log4j è una libreria di registrazione per programmi Java che consente di configurare i livelli di log e utilizzare le librerie di appender. SLF4J è una libreria di facciata che consente di modificare la libreria utilizzata senza modificare il codice della funzione.

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

<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 facciate per la registrazione del codice Java. Nel codice della funzione, si utilizza SLF4 J logger factory per recuperare un logger con metodi per i livelli di registro come e. info() warn() Nella configurazione di build, includi la libreria di registrazione e l'adattatore SLF4 J nel classpath. Modificando le librerie nella configurazione di build, è possibile modificare il tipo di logger senza modificare il codice della funzione. SLF4J è necessario per acquisire i log dall'SDK for Java.

Nel codice di esempio seguente, la classe handler utilizza SLF4 J per recuperare un logger.

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:

{
    "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 build richiede dipendenze di runtime dall'appender Lambda e dall'adattatore J SLF4 e dipendenze di implementazione da Log4j2.

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 for AWS Lambda (Java) è un toolkit per sviluppatori che implementa le migliori pratiche Serverless e aumenta la velocità degli sviluppatori. 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:

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

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

Gestione della conservazione dei log

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

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

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

Visualizzazione dei log nella console Lambda

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

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

Visualizzazione dei log nella console CloudWatch

Puoi utilizzare la CloudWatch console Amazon per visualizzare i log di tutte le chiamate di funzioni Lambda.

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 log per una chiamata specifica, ti consigliamo di strumentare la tua funzione con. AWS X-Ray X-Ray registra i dettagli sulla richiesta e il flusso di log nella traccia.

Visualizzazione dei log utilizzando () AWS Command Line InterfaceAWS 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.

È 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.

aws lambda invoke --function-name my-function out --log-type Tail

{
    "StatusCode": 200,
    "LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
    "ExecutedVersion": "$LATEST"
}

aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode

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

#!/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

chmod -R 755 get-logs.sh

./get-logs.sh

{
    "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

L' GitHub archivio di questa guida include applicazioni di esempio che dimostrano l'uso di varie configurazioni di registrazione. Ogni applicazione di esempio include script per facilitare la distribuzione e la pulizia, un AWS SAM modello e risorse di supporto.

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 SLF4 J come facciata per garantire 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.