# Registrar em log e monitorar funções do Lambda em Python 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 logs do seu código de função, use o módulo integrado [https://docs.python.org/3/library/logging.html](https://docs.python.org/3/library/logging.html). Para entradas mais detalhadas, você pode usar qualquer biblioteca de registro em log que grava em `stdout` ou `stderr`. ## Imprimir para o log Para enviar uma saída básica para os logs, use um método `print` em sua função. O exemplo a seguir registra em log os valores do fluxo e do grupo de logs do CloudWatch Logs e o objeto do evento. Se a sua função gera logs usando instruções Python `print`, o Lambda só poderá enviar saídas de log para o CloudWatch Logs em formato de texto simples. Para capturar logs em JSON estruturado, você precisa usar uma biblioteca de logs compatível. Consulte [Usar controles avançados de registro em log do Lambda com Python](#python-logging-advanced) para obter mais informações. **Example lambda\$1function.py** ``` import os def lambda_handler(event, context): print('## ENVIRONMENT VARIABLES') print(os.environ['AWS_LAMBDA_LOG_GROUP_NAME']) print(os.environ['AWS_LAMBDA_LOG_STREAM_NAME']) print('## EVENT') print(event) ``` **Example saída do log** ``` START RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Version: $LATEST ## ENVIRONMENT VARIABLES /aws/lambda/my-function 2025/08/31/[$LATEST]3893xmpl7fac4485b47bb75b671a283c ## EVENT {'key': 'value'} END RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 REPORT RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Duration: 15.74 ms Billed Duration: 147 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 130.49 ms XRAY TraceId: 1-5e34a614-10bdxmplf1fb44f07bc535a1 SegmentId: 07f5xmpl2d1f6f85 Sampled: true ``` O runtime do Python registra as linhas `START`, `END` e `REPORT` para cada invocação. A linha `REPORT` inclui os seguintes dados: **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 uma biblioteca de registro em log Para logs mais detalhados, use o módulo [registro em log](https://docs.python.org/3/library/logging.html) na biblioteca padrão ou em qualquer biblioteca de registro em log de terceiros que grava em `stdout` ou `stderr`. Para runtimes do Python compatíveis, você pode escolher se os registros criados usando o módulo `logging` padrão são capturados em texto simples ou JSON. Para saber mais, consulte [Usar controles avançados de registro em log do Lambda com Python](#python-logging-advanced). Atualmente, o formato padrão de log para todos os runtimes do Python é texto simples. O exemplo a seguir mostra como as saídas de log criadas usando o módulo `logging` padrão são capturadas em texto simples no CloudWatch Logs. ``` import os import logging logger = logging.getLogger() logger.setLevel("INFO") def lambda_handler(event, context): logger.info('## ENVIRONMENT VARIABLES') logger.info(os.environ['AWS_LAMBDA_LOG_GROUP_NAME']) logger.info(os.environ['AWS_LAMBDA_LOG_STREAM_NAME']) logger.info('## EVENT') logger.info(event) ``` A saída de `logger` inclui o nível do log, o timestamp e o ID da solicitação. ``` START RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Version: $LATEST [INFO] 2025-08-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## ENVIRONMENT VARIABLES [INFO] 2025-08-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 /aws/lambda/my-function [INFO] 2025-08-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 2025/01/31/[$LATEST]1bbe51xmplb34a2788dbaa7433b0aa4d [INFO] 2025-08-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## EVENT [INFO] 2025-08-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 {'key': 'value'} END RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 REPORT RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Duration: 2.75 ms Billed Duration: 117 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 113.51 ms XRAY TraceId: 1-5e34a66a-474xmpl7c2534a87870b4370 SegmentId: 073cxmpl3e442861 Sampled: true ``` **nota** Quando o formato de log da função é definido como texto sem formatação, a configuração padrão de nível de log para runtimes do Python é WARN. Isso significa que o Lambda só envia saídas de log de nível WARN e inferior para o CloudWatch Logs. Para alterar o nível de log padrão, use o método `logging` `setLevel()` do Python conforme mostrado neste código de exemplo. Se você definir o formato do log da função como JSON, recomendamos que você configure o nível de log da função usando os controles de registro em log avançados do Lambda e não definindo o nível de log no código. Para saber mais, consulte [Usar a filtragem em nível de log com Python](#python-logging-levels) ## Usar controles avançados de registro em log do Lambda com Python 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 registro em log para runtimes do Python compatíveis com o Lambda: + **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 Amazon 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 saber mais sobre como usar as opções de formato de log e nível de log com as funções do Lambda para Python, consulte as orientações nas seções a seguir. ### Usar logs JSON estruturados com Python Se você selecionar JSON para o formato de log da sua função, o Lambda enviará a saída de logs da biblioteca de logs padrão do Python para o CloudWatch 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. + `"requestId"`: o ID de solicitação exclusivo para invocar a função. A biblioteca `logging` do Python também pode adicionar pares de valores de chave, como `"logger"`, para esse objeto JSON. Os exemplos nas seções a seguir mostram como as saídas de log geradas usando a biblioteca `logging` do Python são capturadas no CloudWatch Logs quando você configura o formato de log da função como JSON. Se você usar o método `print` para produzir saídas básicas de log, conforme descrito em [Imprimir para o log](#python-logging-output), o Lambda capturará essas saídas como texto simples, mesmo se o formato de log da função for configurado como JSON. #### Saídas de log JSON padrão usando a biblioteca de logs do Python O exemplo de trecho de código e saída de log a seguir mostra como as saídas de log padrão geradas usando a biblioteca `logging` do Python são capturadas no CloudWatch Logs quando o formato de log da função é configurado como JSON. **Example Código de log do Python** ``` import logging logger = logging.getLogger() def lambda_handler(event, context): logger.info("Inside the handler function") ``` **Example Registro em log JSON** ``` { "timestamp":"2025-10-27T19:17:45.586Z", "level":"INFO", "message":"Inside the handler function", "logger": "root", "requestId":"79b4f56e-95b1-4643-9700-2807f4e68189" } ``` #### Registrar parâmetros extras em log JSON Quando o formato de log da sua função está definido como JSON, você também pode registrar parâmetros adicionais em log com a biblioteca `logging` do Python padrão usando a palavra-chave `extra` para passar um dicionário do Python para a saída do log. **Example Código de log do Python** ``` import logging def lambda_handler(event, context): logging.info( "extra parameters example", extra={"a":"b", "b": [3]}, ) ``` **Example Registro em log JSON** ``` { "timestamp": "2025-11-02T15:26:28Z", "level": "INFO", "message": "extra parameters example", "logger": "root", "requestId": "3dbd5759-65f6-45f8-8d7d-5bdc79a3bd01", "a": "b", "b": [ 3 ] } ``` #### Exceções de log em JSON O trecho de código a seguir mostra como as exceções do Python são capturadas na saída de log da função quando o formato de log é configurado como JSON. Observe que as saídas de log geradas usando `logging.exception` são atribuídas ao nível de log ERROR. **Example Código de log do Python** ``` import logging def lambda_handler(event, context): try: raise Exception("exception") except: logging.exception("msg") ``` **Example Registro em log JSON** ``` { "timestamp": "2025-11-02T16:18:57Z", "level": "ERROR", "message": "msg", "logger": "root", "stackTrace": [ " File \"/var/task/lambda_function.py\", line 15, in lambda_handler\n raise Exception(\"exception\")\n" ], "errorType": "Exception", "errorMessage": "exception", "requestId": "3f9d155c-0f09-46b7-bdf1-e91dab220855", "location": "/var/task/lambda_function.py:lambda_handler:17" } ``` #### Logs JSON estruturados com outras ferramentas de registro em log Se o código já usa outra biblioteca de logs, como o Powertools para AWS Lambda, para produzir logs JSON estruturados, você não precisará fazer nenhuma alteração. O AWS 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. O exemplo a seguir mostra como as saídas de log geradas usando o pacote Powertools para AWS Lambda são capturadas no CloudWatch Logs. O formato da saída de log é o mesmo, independentemente se a configuração de log da função for definida como JSON ou TEXT. Para obter mais informações sobre como usar o Powertools para AWS Lambda, consulte [Uso do Powertools para AWS Lambda (Python) e do AWS SAM para registro em log estruturado](#python-logging-sam) e [Uso do Powertools para AWS Lambda (Python) e do AWS CDK para registro em log estruturado](#python-logging-powertools-cdk). **Example Trecho de código de log em Python (usando o Powertools para AWS Lambda)** ``` from aws_lambda_powertools import Logger logger = Logger() def lambda_handler(event, context): logger.info("Inside the handler function") ``` **Example Registro em log JSON (usando o Powertools para AWS Lambda)** ``` { "level": "INFO", "location": "lambda_handler:7", "message": "Inside the handler function", "timestamp": "2025-10-31 22:38:21,010+0000", "service": "service_undefined", "xray_trace_id": "1-654181dc-65c15d6b0fecbdd1531ecb30" } ``` ### Usar a filtragem em nível de log com Python Ao configurar a filtragem em nível de log, você pode optar por enviar somente logs de um determinado nível, ou inferior, para o CloudWatch Logs. Para saber como configurar a filtragem em nível de log para a função, consulte [Filtragem em nível de log](monitoring-cloudwatchlogs-log-level.md). 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 a biblioteca `logging` padrão do Python e configure a função para usar logs em formato JSON. Dessa forma, o AWS Lambda filtra as saídas de log usando o par de valores-chave “nível” no objeto JSON descrito em [Usar logs JSON estruturados com Python](#python-logging-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. Por exemplo, você pode usar o Powertools para AWS Lambda para gerar saídas de log JSON estruturado do seu código. Também é possível usar uma instrução de impressão para gerar um objeto JSON que contenha um identificador de nível de log. A instrução de impressão a seguir produz uma saída em formato JSON em que o nível do leg é definido como INFO. O AWS Lambda enviará o objeto JSON para o CloudWatch Logs se o nível de log da função estiver definido como INFO, DEBUG ou TRACE. ``` print('{"msg":"My log message", "level":"info"}') ``` 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. ## Visualização de 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. ## Visualização de logs com a 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. ## Usar outras ferramentas e bibliotecas de registro em log O [Powertools para AWS Lambda (Python)](https://docs.aws.amazon.com/powertools/python/) é um kit de ferramentas para desenvolvedores para implementar práticas recomendadas da tecnologia sem servidor e aumentar a velocidade do desenvolvedor. O [utilitário Logger](https://docs.aws.amazon.com/powertools/python/latest/core/logger/) fornece um registrador 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 (Python) e do AWS SAM para registro em log estruturado Siga as etapas abaixo para baixar, construir e implantar um exemplo de aplicação Python Hello World com os módulos integrados do [Powertools for Python](https://docs.aws.amazon.com/powertools/python/latest/) com 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: + Python 3.9 + [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 Python do Hello World. ``` sam init --app-template hello-world-powertools-python --name sam-app --package-type Zip --runtime python3.9 --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 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/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:50.371000 INIT_START Runtime Version: python:3.9.v16 Runtime Version ARN: arn:aws:lambda:us-east-1::runtime:07a48df201798d627f2b950f03bb227aab4a655a1d019c3296406f95937e2525 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.112000 START RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Version: $LATEST 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.114000 { "level": "INFO", "location": "hello:23", "message": "Hello world API - HTTP 200", "timestamp": "2025-02-03 14:59:51,113+0000", "service": "PowertoolsHelloWorld", "cold_start": true, "function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j", "function_memory_size": "128", "function_arn": "arn:aws:lambda:us-east-1:111122223333:function:sam-app-HelloWorldFunction-YBg8yfYtOc9j", "function_request_id": "d455cfc4-7704-46df-901b-2a5cce9405be", "correlation_id": "e73f8aef-5e07-436e-a30b-63e4b23f0047", "xray_trace_id": "1-63dd2166-434a12c22e1307ff2114f299" } 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 { "_aws": { "Timestamp": 1675436391126, "CloudWatchMetrics": [ { "Namespace": "Powertools", "Dimensions": [ [ "function_name", "service" ] ], "Metrics": [ { "Name": "ColdStart", "Unit": "Count" } ] } ] }, "function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j", "service": "PowertoolsHelloWorld", "ColdStart": [ 1.0 ] } 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 { "_aws": { "Timestamp": 1675436391126, "CloudWatchMetrics": [ { "Namespace": "Powertools", "Dimensions": [ [ "service" ] ], "Metrics": [ { "Name": "HelloWorldInvocations", "Unit": "Count" } ] } ] }, "service": "PowertoolsHelloWorld", "HelloWorldInvocations": [ 1.0 ] } 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 END RequestId: d455cfc4-7704-46df-901b-2a5cce9405be 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 REPORT RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Duration: 16.33 ms Billed Duration: 756 ms Memory Size: 128 MB Max Memory Used: 64 MB Init Duration: 739.46 ms XRAY TraceId: 1-63dd2166-434a12c22e1307ff2114f299 SegmentId: 3c5d18d735a1ced0 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 ``` ## Uso do Powertools para AWS Lambda (Python) e do AWS CDK para registro em log estruturado Siga as etapas abaixo para baixar, criar e implantar um exemplo de aplicação Python do Hello World com os módulos integrados do [Powertools para AWS Lambda Python](https://docs.aws.amazon.com/powertools/python/latest/) usando o AWS CDK. 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 de hello world. **Pré-requisitos** Para executar as etapas desta seção, você deve ter o seguinte: + Python 3.9 + [AWS CLI versão 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) + [AWS CDK versão 2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_prerequisites) + [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 CDK** 1. Crie um diretório de projeto para sua aplicação. ``` mkdir hello-world cd hello-world ``` 1. Inicialize a aplicação. ``` cdk init app --language python ``` 1. Instale as dependências do Python. ``` pip install -r requirements.txt ``` 1. Crie um diretório **lambda\$1function** na pasta raiz. ``` mkdir lambda_function cd lambda_function ``` 1. Crie um arquivo **app.py** e adicione o código a seguir ao arquivo. Este é o código da função do Lambda. ``` from aws_lambda_powertools.event_handler import APIGatewayRestResolver from aws_lambda_powertools.utilities.typing import LambdaContext from aws_lambda_powertools.logging import correlation_paths from aws_lambda_powertools import Logger from aws_lambda_powertools import Tracer from aws_lambda_powertools import Metrics from aws_lambda_powertools.metrics import MetricUnit app = APIGatewayRestResolver() tracer = Tracer() logger = Logger() metrics = Metrics(namespace="PowertoolsSample") @app.get("/hello") @tracer.capture_method def hello(): # adding custom metrics # See: https://docs.aws.amazon.com/powertools/python/latest//latest/core/metrics/ metrics.add_metric(name="HelloWorldInvocations", unit=MetricUnit.Count, value=1) # structured log # See: https://docs.aws.amazon.com/powertools/python/latest//latest/core/logger/ logger.info("Hello world API - HTTP 200") return {"message": "hello world"} # Enrich logging with contextual information from Lambda @logger.inject_lambda_context(correlation_id_path=correlation_paths.API_GATEWAY_REST) # Adding tracer # See: https://docs.aws.amazon.com/powertools/python/latest//latest/core/tracer/ @tracer.capture_lambda_handler # ensures metrics are flushed upon request completion/failure and capturing ColdStart metric @metrics.log_metrics(capture_cold_start_metric=True) def lambda_handler(event: dict, context: LambdaContext) -> dict: return app.resolve(event, context) ``` 1. Abra o diretório **hello\$1world**. Você verá um arquivo chamado **hello-world-stack.py**. ``` cd .. cd hello_world ``` 1. Abra o **hello\$1world\$1stack.py** e adicione o código a seguir ao arquivo. Ele contém o [construtor do Lambda](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_lambda.html), que cria a função do Lambda, configura variáveis de ambiente para o Powertools e define a retenção de logs para uma semana, e o [construtor do ApiGatewayv1](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_apigateway.html), que cria a API REST. ``` from aws_cdk import ( Stack, aws_apigateway as apigwv1, aws_lambda as lambda_, CfnOutput, Duration ) from constructs import Construct class HelloWorldStack(Stack): def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None: super().__init__(scope, construct_id, **kwargs) # Powertools Lambda Layer powertools_layer = lambda_.LayerVersion.from_layer_version_arn( self, id="lambda-powertools", # Using AWS Lambda Powertools via Lambda Layer # This imports the Powertools layer which provides observability features for Lambda functions # For available versions, see: https://docs.aws.amazon.com/powertools/python/latest/#lambda-layer ) function = lambda_.Function(self, 'sample-app-lambda', runtime=lambda_.Runtime.PYTHON_3_9, layers=[powertools_layer], code = lambda_.Code.from_asset("./lambda_function/"), handler="app.lambda_handler", memory_size=128, timeout=Duration.seconds(3), architecture=lambda_.Architecture.X86_64, environment={ "POWERTOOLS_SERVICE_NAME": "PowertoolsHelloWorld", "POWERTOOLS_METRICS_NAMESPACE": "PowertoolsSample", "LOG_LEVEL": "INFO" } ) apigw = apigwv1.RestApi(self, "PowertoolsAPI", deploy_options=apigwv1.StageOptions(stage_name="dev")) hello_api = apigw.root.add_resource("hello") hello_api.add_method("GET", apigwv1.LambdaIntegration(function, proxy=True)) CfnOutput(self, "apiUrl", value=f"{apigw.url}hello") ``` 1. Implante o aplicativo. ``` cd .. cdk deploy ``` 1. Obtenha o URL da aplicação implantada: ``` aws cloudformation describe-stacks --stack-name HelloWorldStack --query 'Stacks[0].Outputs[?OutputKey==`apiUrl`].OutputValue' --output text ``` 1. Invoque o endpoint da API: ``` curl 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 HelloWorldStack ``` O resultado de saída do log se parece com: ``` 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:50.371000 INIT_START Runtime Version: python:3.9.v16 Runtime Version ARN: arn:aws:lambda:us-east-1::runtime:07a48df201798d627f2b950f03bb227aab4a655a1d019c3296406f95937e2525 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.112000 START RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Version: $LATEST 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.114000 { "level": "INFO", "location": "hello:23", "message": "Hello world API - HTTP 200", "timestamp": "2025-02-03 14:59:51,113+0000", "service": "PowertoolsHelloWorld", "cold_start": true, "function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j", "function_memory_size": "128", "function_arn": "arn:aws:lambda:us-east-1:111122223333:function:sam-app-HelloWorldFunction-YBg8yfYtOc9j", "function_request_id": "d455cfc4-7704-46df-901b-2a5cce9405be", "correlation_id": "e73f8aef-5e07-436e-a30b-63e4b23f0047", "xray_trace_id": "1-63dd2166-434a12c22e1307ff2114f299" } 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 { "_aws": { "Timestamp": 1675436391126, "CloudWatchMetrics": [ { "Namespace": "Powertools", "Dimensions": [ [ "function_name", "service" ] ], "Metrics": [ { "Name": "ColdStart", "Unit": "Count" } ] } ] }, "function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j", "service": "PowertoolsHelloWorld", "ColdStart": [ 1.0 ] } 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 { "_aws": { "Timestamp": 1675436391126, "CloudWatchMetrics": [ { "Namespace": "Powertools", "Dimensions": [ [ "service" ] ], "Metrics": [ { "Name": "HelloWorldInvocations", "Unit": "Count" } ] } ] }, "service": "PowertoolsHelloWorld", "HelloWorldInvocations": [ 1.0 ] } 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 END RequestId: d455cfc4-7704-46df-901b-2a5cce9405be 2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 REPORT RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Duration: 16.33 ms Billed Duration: 756 ms Memory Size: 128 MB Max Memory Used: 64 MB Init Duration: 739.46 ms XRAY TraceId: 1-63dd2166-434a12c22e1307ff2114f299 SegmentId: 3c5d18d735a1ced0 Sampled: true ``` 1. Este é um endpoint de API pública que é acessado pela Internet. Recomendamos excluir o endpoint após o teste. ``` cdk destroy ```