# Registrar em log e monitorar funções do Lambda em Java O AWS Lambda monitora automaticamente as funções do Lambda e envia entradas de logs para o Amazon CloudWatch. Sua função do Lambda vem com um grupo de logs do CloudWatch Logs e uma transmissão de logs para cada instância de sua função. O ambiente de runtime do Lambda envia detalhes sobre cada invocação e outras saídas do código da função para o fluxo de logs. Para obter mais informações sobre o CloudWatch Logs, consulte [Enviar logs de função do Lambda para o CloudWatch Logs](monitoring-cloudwatchlogs.md). Para gerar os logs do código da sua função, use métodos no [java.lang.System](https://docs.oracle.com/javase/8/docs/api/java/lang/System.html) ou qualquer módulo de registro em log que grave em stdout ou stderr. **Topics** + [Criar uma função que retorna logs](#java-logging-output) + [Usar controles avançados de registro em log do Lambda com Java](#java-logging-advanced) + [Implementar registro em log avançado com Log4j2 e SLF4J](#java-logging-log4j2) + [Usar outras ferramentas e bibliotecas de registro em log](#java-tools-libraries) + [Uso do Powertools para AWS Lambda (Java) e do AWS SAM para registro em log estruturado](#java-logging-sam) + [Visualizar logs no console do Lambda](#java-logging-console) + [Visualização de logs no console do CloudWatch](#java-logging-cwconsole) + [Visualizar logs usando a AWS Command Line Interface (AWS CLI)](#java-logging-cli) + [Excluir logs](#java-logging-delete) + [Código de exemplo de registro em log](#java-logging-samples) ## Criar uma função que retorna logs Para gerar os logs do código da função, use métodos no [java.lang.System](https://docs.oracle.com/javase/8/docs/api/java/lang/System.html) ou qualquer módulo de registro em log que grave no `stdout` ou no `stderr`. A biblioteca [aws-lambda-java-core](java-package.md) fornece uma classe do logger chamada `LambdaLogger` que você pode acessar a partir do objeto de contexto. A classe do logger oferece suporte a logs de várias linhas. O exemplo a seguir usa o logger `LambdaLogger` fornecido pelo objeto de contexto. **Example Handler.java** ``` // Handler value: example.Handler public class Handler implements RequestHandler{ 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; } } ``` **Example formato do 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 ``` O runtime do Java registra em log as linhas `START`, `END` e `REPORT` para cada invocação. A linha do relatório fornece os seguintes detalhes: **RELATAR campos de dados de linha** + **RequestId**: o ID de solicitação exclusivo para a invocação. + **Duração**: a quantidade de tempo que o método de manipulador da função gastou processando o evento. + **Duração faturada**: a quantia de tempo faturada para a invocação. + **Tamanho da memória**: a quantidade de memória alocada para a função. + **Memória máxima utilizada**: a quantidade de memória utilizada pela função. Quando as invocações compartilham um ambiente de execução, o Lambda relata a memória máxima usada em todas as invocações. Esse comportamento pode resultar em um valor relatado maior do que o esperado. + **Duração inicial**: para a primeira solicitação atendida, a quantidade de tempo que o runtime levou para carregar a função e executar o código fora do método do handler. + **XRAY TraceId**: para solicitações rastreadas, o [ID de rastreamento do AWS X-Ray](services-xray.md). + **SegmentId**: para solicitações rastreadas, o ID do segmento do X-Ray. + **Amostragem**: para solicitações rastreadas, o resultado da amostragem. ## Usar controles avançados de registro em log do Lambda com Java Para dar mais controle sobre como os logs das funções são capturados, processados e consumidos, você pode configurar as seguintes opções de log para runtimes compatíveis do Java: + **Formato do log**: selecione entre texto simples e formato JSON estruturado para os logs da sua função. + **Nível de log**: para logs no formato JSON, escolha o nível de detalhe dos logs enviados pelo Lambda para o CloudWatch, como ERROR, DEBUG ou INFO. + **Grupo de logs**: escolha o grupo de logs do CloudWatch para o qual sua função envia logs. Para obter mais informações sobre essas opções de registro em log e instruções sobre como configurar a função para usá-las, consulte [Configurar controles avançados de registro em log para funções do Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced). Para usar as opções de formato de log e nível de log com as funções do Lambda para Java, consulte as orientações nas seções a seguir. ### Usar logs em formato JSON estruturado com Java Se você selecionar JSON para o formato de log da função, o Lambda enviará a saída de logs usando a classe `LambdaLogger` como JSON estruturado. Cada objeto de log JSON contém pelo menos quatro pares de valores-chave com as seguintes chaves: + `"timestamp"`: o horário em que a mensagem de log foi gerada. + `"level"`: o nível de log atribuído à mensagem. + `"message"`: o conteúdo da mensagem de log. + `"AWSrequestId"`: o ID de solicitação exclusivo para invocar a função. Dependendo do método de registro em log usado, as saídas de log da função capturadas no formato JSON também podem conter pares de valores de chave adicionais. Para atribuir um nível aos logs que você criar usando o logger `LambdaLogger`, você precisa fornecer um argumento `LogLevel` no comando de registro em log, conforme mostrado no exemplo a seguir. **Example Código de registro em log do Java** ``` LambdaLogger logger = context.getLogger(); logger.log("This is a debug log", LogLevel.DEBUG); ``` A saída de log desse exemplo de código seria capturada no CloudWatch Logs da seguinte forma: **Example Registro em log JSON** ``` { "timestamp":"2023-11-01T00:21:51.358Z", "level":"DEBUG", "message":"This is a debug log", "AWSrequestId":"93f25699-2cbf-4976-8f94-336a0aa98c6f" } ``` Se você não atribuir um nível à saída de log, o Lambda atribuirá automaticamente o nível INFO a ele. Se o código já usa outra biblioteca de logs para produzir logs JSON estruturados, você não precisa fazer nenhuma alteração. O Lambda não codifica duas vezes nenhum log que já esteja codificado em JSON. Mesmo que a função seja configurada para usar logs em formato JSON, suas saídas de log serão exibidas no CloudWatch com a estrutura JSON que você definiu. ### Usar a filtragem em nível de log com Java Para o AWS Lambda filtrar os logs de aplicação de acordo com o nível de log, a função precisa usar logs em formato JSON. Isso pode ser feito de duas maneiras: + Crie saídas de log usando o padrão `LambdaLogger` e configure a função para usar logs em formato JSON. Assim, o Lambda filtrará as saídas de log usando o par de valores-chave “nível” no objeto JSON descrito em [Usar logs em formato JSON estruturado com Java](#java-logging-advanced-JSON). Para saber como configurar o formato de log da função, consulte [Configurar controles avançados de registro em log para funções do Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced). + Use outro método ou biblioteca de logs para criar logs JSON estruturados no código, de modo que incluam um par de valores-chave de “nível” para definir o nível da saída de log. Também é possível usar qualquer biblioteca de logs que permita a gravação em logs JSON em `stdout` ou `stderr`. Por exemplo, é possível usar o Powertools para AWS Lambda ou o pacote Log4j2 para gerar saídas de log JSON estruturado do seu código. Consulte [Uso do Powertools para AWS Lambda (Java) e do AWS SAM para registro em log estruturado](#java-logging-sam) e [Implementar registro em log avançado com Log4j2 e SLF4J](#java-logging-log4j2) para saber mais. Ao configurar sua função para usar a filtragem em nível de log, você precisa selecionar entre as seguintes opções para o nível do logs enviados pelo Lambda para o CloudWatch Logs: | Nível de log | Uso padrão | | --- | --- | | TRACE (mais detalhes) | As informações mais detalhadas usadas para rastrear o caminho da execução do código | | DEBUG | Informações detalhadas para depuração do sistema | | INFORMAÇÕES | Mensagens que registram a operação normal da função | | WARN | Mensagens sobre possíveis erros que podem levar a um comportamento inesperado se não forem corrigidos | | ERRO | Mensagens sobre problemas que impedem que o código funcione conforme o esperado | | FATAL (menos detalhes) | Mensagens sobre erros graves que fazem a aplicação parar de funcionar | Para que o Lambda filtre os logs da função, você também precisa incluir um par de valores-chave `"timestamp"` na saída do log JSON. A hora deve ser especificada em um formato [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) válido de carimbo de data/hora. Se você não fornecer um carimbo de data/hora válido, o Lambda atribuirá ao log o nível INFO e adicionará um carimbo de data/hora. O Lambda envia logs do nível selecionado, e dos níveis inferiores, para o CloudWatch. Por exemplo, se você configurar um nível de log de WARN, o Lambda enviará logs correspondentes aos níveis WARN, ERROR e FATAL. ## Implementar registro em log avançado com Log4j2 e SLF4J **nota** O AWS Lambda não inclui o Log4j2 em seus runtimes gerenciados ou imagens de contêiner base. Portanto, estes não são afetados pelos problemas descritos em CVE-2021-44228, CVE-2021-45046 e CVE-2021-45105. Para casos em que uma função do cliente contém uma versão do Log4j2 impactada, aplicamos uma alteração aos [runtimes gerenciados](lambda-runtimes.md) e [imagens do contêiner base](java-image.md) do Lambda Java que ajuda a mitigar os problemas em CVE-2021-44228, CVE-2021-45046 e CVE-2021-45105. Como resultado dessa alteração, os clientes que usam o Log4J2 podem ver mais uma entrada de log, semelhante a “”. "`Transforming org/apache/logging/log4j/core/lookup/JndiLookup (java.net.URLClassLoader@...)`". Todas as strings de log que referenciem o mapeador jndi na saída Log4J2 serão substituídas por “”. "`Patched JndiLookup::lookup()`". Independentemente dessa mudança, é altamente recomendável que todos os clientes cujas funções incluam o Log4j2 atualizem para a versão mais recente. Especificamente, os clientes que usam a biblioteca aws-lambda-java-log4j2 em suas funções devem atualizar para a versão 1.5.0 (ou posterior) e reimplantar suas funções. Essa versão atualiza as dependências do utilitário Log4j2 subjacentes para a versão 2.17.0 (ou posterior). O binário aws-lambda-java-log4j2 atualizado está disponível no [repositório do Maven](https://repo1.maven.org/maven2/com/amazonaws/aws-lambda-java-log4j2/), e seu código-fonte está disponível no [Github](https://github.com/aws/aws-lambda-java-libs/tree/master/aws-lambda-java-log4j2). Por fim, observe que qualquer biblioteca relacionada ao **aws-lambda-java-log4j (v1.0.0 or 1.0.1)** **não** deve ser usada em **nenhuma** circunstância. Essas bibliotecas estão relacionadas à versão 1.x do log4j, que foi encerrada em 2015. Não há suporte, manutenção nem patches para essas bibliotecas, e elas apresentam vulnerabilidades de segurança conhecidas. Para personalizar a saída de log, oferecer suporte ao registro em log durante testes de unidade e registrar chamadas do AWS SDK em log, use o Apache Log4j2 com o SLF4J. O Log4j é uma biblioteca de registro em log para programas Java que permite configurar níveis de log e usar bibliotecas de appender. O SLF4J é uma biblioteca de fachada que permite alterar qual biblioteca você usa sem alterar o código da função. Para adicionar o ID de solicitação aos logs da sua função, use o appender na biblioteca [aws-lambda-java-log4j2](java-package.md). **Example [src/main/resources/log4j2.xml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/s3-java/src/main/resources/log4j2.xml): configuração do appender** ``` %d{yyyy-MM-dd HH:mm:ss} %X{AWSRequestId} %-5p %c{1} - %m%n ``` É possível decidir como os logs do Log4j2 são configurados para saídas em texto simples ou JSON especificando um layout nas tags `` e ``. Neste exemplo, no modo de texto, cada linha é precedida com a data, a hora, o ID da solicitação, o nível do log e o nome da classe. No modo JSON, `` é usado com uma configuração que está incluída na biblioteca `aws-lambda-java-log4j2`. O SLF4J é uma biblioteca de fachada para registro em log em código Java. No código da função, use o logger factory SLF4J para recuperar um logger com métodos para níveis de log como `info()` e `warn()`. Na configuração da compilação, inclua a biblioteca de registro em log e o adaptador SLF4J no classpath. Alterando as bibliotecas na configuração de compilação, é possível alterar o tipo de logger sem alterar o código da função. O SLF4J é necessário para capturar logs do SDK for Java. No exemplo de código a seguir, a classe de manipulador usa SLF4J para recuperar um logger. **Example [src/main/java/example/HandlerS3.java](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/java-events/src/main/java/example/HandlerS3.java): registro em log com o 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{ 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"; } } ``` Esse código gera uma saída de log semelhante à seguinte: **Example formato do 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/" } ``` A configuração de compilação usa dependências de runtime no appender e no adaptador SLF4J do Lambda, além de dependências de implementação no Log4J2. **Example build.gradle: dependências de registro em log** ``` 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 você executa seu código localmente para testes, o objeto de contexto com o logger do Lambda não está disponível e não há nenhum ID de solicitação para o appender do Lambda usar. Para obter exemplos de configurações de teste, consulte as aplicações de exemplo na próxima seção. ## Usar outras ferramentas e bibliotecas de registro em log O [Powertools para AWS Lambda (Java)](https://docs.aws.amazon.com/powertools/java/) é um kit de ferramentas para desenvolvedores para implementar as práticas recomendadas da tecnologia sem servidor e aumentar a velocidade do desenvolvedor. O [utilitário de logs](https://docs.aws.amazon.com/powertools/java/latest/core/logging/) fornece um registrador de logs otimizado para Lambda que inclui informações adicionais sobre o contexto da função em todas as suas funções, com saída estruturada como JSON. Use esse utilitário para fazer o seguinte: + Capturar campos-chave do contexto do Lambda, inicialização a frio e estruturas registrando em log a saída como JSON + Registrar em log eventos de invocação do Lambda quando instruído (desativado por padrão) + Imprimir todos os logs somente para uma porcentagem das invocações por meio da amostragem de logs (desativado por padrão) + Anexar chaves adicionais ao log estruturado a qualquer momento + Use um formatador de log personalizado (Bring Your Own Formatter) para gerar logs em uma estrutura compatível com o RFC de logs da sua organização ## Uso do Powertools para AWS Lambda (Java) e do AWS SAM para registro em log estruturado Siga as etapas abaixo para baixar, criar e implantar um exemplo da aplicação Hello World em Java com os módulos integrados do [Powertools para AWS Lambda (Java)](https://docs.aws.amazon.com/powertools/java/latest/) usando o AWS SAM. Esta aplicação implementa um backend de API básico e usa o Powertools para emitir logs, métricas e rastreamentos. Consiste em um endpoint do Amazon API Gateway e uma função do Lambda. Quando você envia uma solicitação GET ao endpoint do API Gateway, a função do Lambda invoca, envia logs e métricas usando o formato de métricas incorporadas ao CloudWatch e envia rastreamentos ao AWS X-Ray. A função retorna uma mensagem `hello world`. **Pré-requisitos** Para executar as etapas desta seção, você deve ter o seguinte: + Java 11 + [AWS CLI versão 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) + [AWS SAM CLI versão 1.75 ou posterior](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Se você tiver uma versão mais antiga da CLI do AWS SAM, consulte [Atualizando a CLI do AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade). **Implantar uma aplicação de exemplo do AWS SAM** 1. Inicialize a aplicação usando o modelo Java do Hello World. ``` sam init --app-template hello-world-powertools-java --name sam-app --package-type Zip --runtime java11 --no-tracing ``` 1. Crie a aplicação. ``` cd sam-app && sam build ``` 1. Implante o aplicativo. ``` sam deploy --guided ``` 1. Siga as instruções na tela. Para aceitar as opções padrão fornecidas na experiência interativa, pressione `Enter`. **nota** Em **HelloWorldFunction pode não ter autorização definida, tudo bem?**, certifique-se de inserir `y`. 1. Obtenha o URL da aplicação implantada: ``` aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text ``` 1. Invoque o endpoint da API: ``` curl -X GET ``` Se tiver êxito, você verá esta resposta: ``` {"message":"hello world"} ``` 1. Para obter os logs da função, execute [sam logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html). Para obter mais informações, consulte [Trabalhar com logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) no *Guia do desenvolvedor do AWS Serverless Application Model*. ``` sam logs --stack-name sam-app ``` O resultado de saída do log se parece com: ``` 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 2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.993000 Feb 03, 2023 9:24:36 AM com.amazonaws.xray.config.DaemonConfiguration 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 ``` 1. Este é um endpoint de API pública que é acessado pela Internet. Recomendamos excluir o endpoint após o teste. ``` sam delete ``` ### Gerenciar a retenção de logs Os grupos de logs não são excluídos automaticamente excluídos quando você exclui uma função. Para evitar armazenar logs por tempo indeterminado, exclua o grupo de logs ou configure um período de retenção após o qual o CloudWatch excluirá os logs automaticamente. Para configurar a retenção de logs, adicione o seguinte ao seu modelo do 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 ``` ## Visualizar logs no console do Lambda É possível usar o console do Lambda para exibir a saída do log depois de invocar uma função do Lambda. Se seu código puder ser testado no editor de **Código** incorporado, você encontrará logs nos **resultados de execução**. Ao usar o recurso de teste do console para invocar uma função, você encontrará **Saída de log** na seção **Detalhes**. ## Visualização de logs no console do CloudWatch É possível usar o console do Amazon CloudWatch para exibir logs de todas as invocações da função do Lambda. **Para visualizar logs no console do CloudWatch** 1. No console do Amazon CloudWatch, abra a [página Log groups](https://console.aws.amazon.com/cloudwatch/home?#logs:) (Grupos de log). 1. Escolha o grupo de logs de sua função (**/aws/lambda/*nome-de-sua-função***). 1. Escolha um stream de logs. Cada fluxo de log corresponde a uma [instância da sua função](lambda-runtime-environment.md). Um fluxo de logs é exibido quando você atualiza sua função do Lambda e quando mais instâncias são criadas para lidar com invocações simultâneas. Para localizar logs de uma invocação específica, recomendamos intrumentar sua função com AWS X-Ray. O X-Ray registra detalhes sobre a solicitação e o stream de logs no rastreamento. ## Visualizar logs usando a AWS Command Line Interface (AWS CLI) O AWS CLI é uma ferramenta de código aberto que permite interagir com os serviços do AWS usando comandos no shell da linha de comando. Para concluir as etapas desta seção, você deve ter a [versão 2 da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). É possível usar a [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) para recuperar logs de uma invocação usando a opção de comando `--log-type`. A resposta contém um campo `LogResult` com até 4 KB de logs codificados em base64 obtidos da invocação. **Example recuperar um ID de log** O exemplo a seguir mostra como recuperar um *ID de log* do campo `LogResult` para uma função chamada `my-function`. ``` aws lambda invoke --function-name my-function out --log-type Tail ``` A seguinte saída deverá ser mostrada: ``` { "StatusCode": 200, "LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...", "ExecutedVersion": "$LATEST" } ``` **Example decodificar os logs** No mesmo prompt de comando, use o utilitário `base64` para decodificar os logs. O exemplo a seguir mostra como recuperar logs codificados em base64 de `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 ``` A opção **cli-binary-format** será necessária se você estiver usando a AWS CLI versão 2. Para que essa seja a configuração padrão, execute `aws configure set cli-binary-format raw-in-base64-out`. Para obter mais informações, consulte [A AWS CLI comporta opções de linha de comando globais](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) no *Guia do usuário da AWS Command Line Interface versão 2*. A seguinte saída deverá ser mostrada: ``` 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 ``` O utilitário `base64` está disponível no Linux, macOS e [Ubuntu no Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Os usuários do macOS precisam usar `base64 -D`. **Example get-logs.sh script** No mesmo prompt de comando, use o script a seguir para fazer download dos últimos cinco eventos de log. O script usa `sed` para remover as aspas do arquivo de saída e fica inativo por 15 segundos para que os logs tenham tempo de ficar disponíveis. A saída inclui a resposta do Lambda, e a saída do comando `get-log-events`. Copie o conteúdo do exemplo de código a seguir e salve no diretório de seu projeto do Lambda como `get-logs.sh`. A opção **cli-binary-format** será necessária se você estiver usando a AWS CLI versão 2. Para que essa seja a configuração padrão, execute `aws configure set cli-binary-format raw-in-base64-out`. Para obter mais informações, consulte [A AWS CLI comporta opções de linha de comando globais](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) no *Guia do usuário da AWS Command Line Interface versão 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 macOS e Linux (somente)** No mesmo prompt de comando, os usuários do macOS e do Linux podem precisar executar o comando a seguir para garantir que o script seja executável. ``` chmod -R 755 get-logs.sh ``` **Example recuperar os últimos cinco eventos de log** No mesmo prompt de comando, execute o script a seguir para obter os últimos cinco eventos de log. ``` ./get-logs.sh ``` A seguinte saída deverá ser mostrada: ``` { "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" } ``` ## Excluir logs Os grupos de logs não são excluídos automaticamente excluídos quando você exclui uma função. Para evitar armazenar logs indefinidamente, exclua o grupo de logs ou[configurar um período de retenção](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention)após o qual os logs são excluídos automaticamente. ## Código de exemplo de registro em log O repositório do GitHub para este guia inclui aplicativos de exemplo que demonstram o uso de várias configurações de registro em log. Cada aplicativo de exemplo inclui scripts para fácil implantação e limpeza, um modelo do AWS SAM e recursos de suporte. **Aplicações de exemplo do Lambda em Java** + [example-java](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/example-java): uma função Java que demonstra como você pode usar o Lambda para processar pedidos. Essa função ilustra como definir e desserializar um objeto de evento de entrada personalizado, usar o AWS SDK e gerar logs de saída. + [java-basic](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/java-basic): uma coleção de funções Java mínimas com testes de unidade e configuração de registro em log variável. + [java-events](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/java-events): uma coleção de funções do Java contendo código básico sobre como lidar com eventos de vários serviços, como o Amazon API Gateway, o Amazon SQS e o Amazon Kinesis. Essas funções usam a versão mais recente da biblioteca [aws-lambda-java-events](java-package.md) (3.0.0 e versões mais recentes). Estes exemplos não exigem o AWS SDK como dependência. + [s3-java](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/s3-java): uma função em Java que processa eventos de notificação do Amazon S3 e usa a Java Class Library (JCL) para criar miniaturas de arquivos de imagem enviados por upload. + [layer-java](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-java): uma função Java que ilustra como usar uma camada do Lambda para empacotar dependências separadamente do código da função principal. O aplicativo de exemplo `java-basic` mostra uma configuração mínima de registro em log que oferece suporte a testes de registro em log. O código do manipulador usa o logger `LambdaLogger` fornecido pelo objeto de contexto. Para testes, a aplicação usa uma classe `TestLogger` personalizada que implementa a interface `LambdaLogger` com um logger Log4j2. Ele usa o SLF4J como fachada para compatibilidade com o AWS SDK. As bibliotecas de registro em log são excluídas da saída de compilação para manter o pacote de implantação pequeno.