# Registrar em log e monitorar funções do Lambda em Python AWS LambdaO 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 [`logging`](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\_function.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 envia 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 captura 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 de “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 log é definido como INFO. O AWS Lambda envia 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 atribui o nível INFO ao log e adiciona 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 pode ser usada para interagir com os serviços da AWS por meio de 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\_function** 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\_world**. Você verá um arquivo chamado **hello-world-stack.py**. ``` cd .. cd hello_world ``` 1. Abra o **hello\_world\_stack.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 with 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 ```