Imprimir para o log Usar uma biblioteca de registro em log Usar controles avançados de registro em log do Lambda com Python Visualização de logs no console do Lambda Visualização de logs no console do CloudWatch Visualização de logs com a AWS CLI Excluir logs Ferramentas e bibliotecas Uso do Powertools para AWS Lambda (Python) e do AWS SAM para registro em log estruturado Uso do Powertools para AWS Lambda (Python) e do AWS CDK para registro em log estruturado

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 Usar os logs do CloudWatch Logs com o Lambda.

Para gerar logs do seu código de função, use o módulo integrado logging. 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 Para mais informações.

exemplo 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)

exemplo saída do log


START RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Version: $LATEST
## ENVIRONMENT VARIABLES
/aws/lambda/my-function
2023/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: 16 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.
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 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.

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]  2023-08-31T22:12:58.534Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    ## ENVIRONMENT VARIABLES
[INFO]  2023-08-31T22:12:58.534Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    /aws/lambda/my-function
[INFO]  2023-08-31T22:12:58.534Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    2023/01/31/[$LATEST]1bbe51xmplb34a2788dbaa7433b0aa4d
[INFO]  2023-08-31T22:12:58.535Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    ## EVENT
[INFO]  2023-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: 3 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

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.

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

exemplo Código de log do Python


import logging  
logger = logging.getLogger()

def lambda_handler(event, context):
    logger.info("Inside the handler function")

exemplo Registro em log JSON


{
    "timestamp":"2023-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.

exemplo Código de log do Python


import logging

def lambda_handler(event, context):
    logging.info(
        "extra parameters example", 
        extra={"a":"b", "b": [3]},
    )

exemplo Registro em log JSON


{
  "timestamp": "2023-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.

exemplo Código de log do Python


import logging

def lambda_handler(event, context):
    try:
        raise Exception("exception")
    except:
        logging.exception("msg")

exemplo Registro em log JSON


{
  "timestamp": "2023-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 e Uso do Powertools para AWS Lambda (Python) e do AWS CDK para registro em log estruturado.

exemplo 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")

exemplo Registro em log JSON (usando o Powertools para AWS Lambda)


{ 
    "level": "INFO", 
    "location": "lambda_handler:7", 
    "message": "Inside the handler function", 
    "timestamp": "2023-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.

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

Você pode 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

Você pode usar o console do Amazon CloudWatch para exibir registros de todas as invocações da função do Lambda.

Para visualizar logs no console do CloudWatch

No console do Amazon CloudWatch, abra a página Log groups (Grupos de log).
Escolha o grupo de logs de sua função (/aws/lambda/nome-de-sua-função).
Escolha um stream de logs.

Cada fluxo de log corresponde a uma instância da sua função. Uma transmissão de logs é exibida quando você atualiza sua função do Lambda e quando mais instâncias são criadas para lidar com várias 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 executar as etapas desta seção, você deve ter o seguinte:

Você pode usar a AWS CLI 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.

exemplo 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"
}

exemplo 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 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. Os usuários do macOS precisam usar base64 -D.

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


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

exemplo 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

exemplo 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 ouconfigurar um período de retençãoapó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) é 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 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 do Hello World com os módulos integrados do Powertools for Python 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
AWS SAM CLI versão 1.75 ou posterior. Se você tiver uma versão mais antiga da CLI do AWS SAM, consulte Atualizando a CLI do AWS SAM.

Implantar uma aplicação de exemplo do AWS SAM

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

Crie a aplicação.
```
cd sam-app && sam build
```
Implante o aplicativo.
```
sam deploy --guided
```
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.

Obtenha o URL da aplicação implantada:


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

Invoque o endpoint da API:
```
curl GET <URL_FROM_PREVIOUS_STEP>
```
Se tiver êxito, você verá esta resposta:
```
{"message":"hello world"}
```

Para obter os logs da função, execute sam logs. Para obter mais informações, consulte Trabalhar com logs 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:


2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:50.371000 INIT_START Runtime Version: python:3.9.v16    Runtime Version ARN: arn:aws:lambda:us-east-1::runtime:07a48df201798d627f2b950f03bb227aab4a655a1d019c3296406f95937e2525
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.112000 START RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Version: $LATEST
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.114000 {
  "level": "INFO",
  "location": "hello:23",
  "message": "Hello world API - HTTP 200",
  "timestamp": "2023-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"
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-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
  ]
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.126000 {
  "_aws": {
    "Timestamp": 1675436391126,
    "CloudWatchMetrics": [
      {
        "Namespace": "Powertools",
        "Dimensions": [
          [
            "service"
          ]
        ],
        "Metrics": [
          {
            "Name": "HelloWorldInvocations",
            "Unit": "Count"
          }
        ]
      }
    ]
  },
  "service": "PowertoolsHelloWorld",
  "HelloWorldInvocations": [
    1.0
  ]
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.128000 END RequestId: d455cfc4-7704-46df-901b-2a5cce9405be
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.128000 REPORT RequestId: d455cfc4-7704-46df-901b-2a5cce9405be    Duration: 16.33 ms    Billed Duration: 17 ms    Memory Size: 128 MB    Max Memory Used: 64 MB    Init Duration: 739.46 ms    
XRAY TraceId: 1-63dd2166-434a12c22e1307ff2114f299    SegmentId: 3c5d18d735a1ced0    Sampled: true

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 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
AWS CDK versão 2
AWS SAM CLI versão 1.75 ou posterior. Se você tiver uma versão mais antiga da CLI do AWS SAM, consulte Atualizando a CLI do AWS SAM.

Implantar uma aplicação de exemplo do AWS CDK

Crie um diretório de projeto para sua aplicação.
```
mkdir hello-world
cd hello-world
```
Inicialize a aplicação.
```
cdk init app --language python
```
Instale as dependências do Python.
```
pip install -r requirements.txt
```
Crie um diretório lambda_function na pasta raiz.
```
mkdir lambda_function
cd lambda_function
```

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.powertools.aws.dev/lambda-python/latest/core/metrics/
    metrics.add_metric(name="HelloWorldInvocations", unit=MetricUnit.Count, value=1)

    # structured log
    # See: https://docs.powertools.aws.dev/lambda-python/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.powertools.aws.dev/lambda-python/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)

Abra o diretório hello_world. Você verá um arquivo chamado hello-world-stack.py.
```
cd ..
cd hello_world
```

Abra o hello_world_stack.py e adicione o código a seguir ao arquivo. Ele contém o construtor do Lambda, 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, 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",
            # At the moment we wrote this example, the aws_lambda_python_alpha CDK constructor is in Alpha, o we use layer to make the example simpler
            # See https://docs.aws.amazon.com/cdk/api/v2/python/aws_cdk.aws_lambda_python_alpha/README.html
            # Check all Powertools layers versions here: https://docs.powertools.aws.dev/lambda-python/latest/#lambda-layer
            layer_version_arn=f"arn:aws:lambda:{self.region}:017000801446:layer:AWSLambdaPowertoolsPythonV2:21"
        )

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

Implante o aplicativo.
```
cd ..
cdk deploy
```

Obtenha o URL da aplicação implantada:


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

Invoque o endpoint da API:
```
curl GET <URL_FROM_PREVIOUS_STEP>
```
Se tiver êxito, você verá esta resposta:
```
{"message":"hello world"}
```

Para obter os logs da função, execute sam logs. Para obter mais informações, consulte Trabalhar com logs no Guia do desenvolvedor do AWS Serverless Application Model.


sam logs --stack-name HelloWorldStack

O resultado de saída do log se parece com:


2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:50.371000 INIT_START Runtime Version: python:3.9.v16    Runtime Version ARN: arn:aws:lambda:us-east-1::runtime:07a48df201798d627f2b950f03bb227aab4a655a1d019c3296406f95937e2525
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.112000 START RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Version: $LATEST
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.114000 {
  "level": "INFO",
  "location": "hello:23",
    "message": "Hello world API - HTTP 200",
  "timestamp": "2023-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"
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-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
  ]
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.126000 {
  "_aws": {
    "Timestamp": 1675436391126,
    "CloudWatchMetrics": [
      {
        "Namespace": "Powertools",
        "Dimensions": [
          [
            "service"
          ]
        ],
        "Metrics": [
          {
            "Name": "HelloWorldInvocations",
            "Unit": "Count"
          }
        ]
      }
    ]
  },
  "service": "PowertoolsHelloWorld",
  "HelloWorldInvocations": [
    1.0
  ]
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.128000 END RequestId: d455cfc4-7704-46df-901b-2a5cce9405be
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.128000 REPORT RequestId: d455cfc4-7704-46df-901b-2a5cce9405be    Duration: 16.33 ms    Billed Duration: 17 ms    Memory Size: 128 MB    Max Memory Used: 64 MB    Init Duration: 739.46 ms    
XRAY TraceId: 1-63dd2166-434a12c22e1307ff2114f299    SegmentId: 3c5d18d735a1ced0    Sampled: true

Este é um endpoint de API pública que é acessado pela Internet. Recomendamos excluir o endpoint após o teste.
```
cdk destroy
```

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Contexto

Testar