Impresión en el registro Uso de una biblioteca de registro Uso de los controles de registro avanzados de Lambda con Python Visualización de los registros en la consola de Lambda Visualización de los registros en la consola CloudWatch Visualización de los registros con AWS CLI Eliminación de registros Herramientas y bibliotecas Uso de Powertools para AWS Lambda (Python) y AWS SAM para el registro estructurado Uso de Powertools para AWS Lambda (Python) y AWS CDK para el registro estructurado

Registro de funciones de AWS Lambda en Python

AWS Lambdasupervisa automáticamente las funciones de Lambda y envía las entradas de registro a Amazon. CloudWatch La función Lambda incluye un grupo de CloudWatch registros y un flujo de registros para cada instancia de la función. El entorno de tiempo de ejecución de Lambda envía detalles sobre cada invocación y otros resultados del código de su función al flujo de registro. Para obtener más información sobre CloudWatch los registros, consulteUso de CloudWatch registros de Amazon con AWS Lambda.

Para generar registros a partir del código de función, puede utilizar el módulo logging integrado. Para entradas más detalladas, puede utilizar cualquier biblioteca de registro que escriba en stdout o stderr.

Impresión en el registro

Para enviar el resultado básico a los registros, puede utilizar un método print en su función. En el siguiente ejemplo, se registran los valores del grupo y la transmisión de CloudWatch registros y del objeto de evento.

Tenga en cuenta que si su función genera registros mediante print sentencias de Python, Lambda solo puede enviar resultados de registro a CloudWatch Logs en formato de texto sin formato. Para capturar registros en JSON estructurado, debe utilizar una biblioteca de registros compatible. Para obtener más información, consulte Uso de los controles de registro avanzados de Lambda con Python.

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

ejemplo salida del registro


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

El tiempo de ejecución de Python registra las líneas START, END y REPORT de cada invocación. La línea REPORT incluye los siguientes datos:

Campos de datos de línea REPORT

RequestId— El identificador de solicitud único para la invocación.
Duración: la cantidad de tiempo que el método de controlador de función pasó procesando el evento.
Duración facturada: la cantidad de tiempo facturado por la invocación.
Tamaño de memoria: la cantidad de memoria asignada a la función.
Máximo de memoria usada: la cantidad de memoria utilizada por la función.
Duración de inicio: para la primera solicitud servida, la cantidad de tiempo que tardó el tiempo de ejecución en cargar la función y ejecutar código fuera del método del controlador.
XRAY TraceId: en el caso de las solicitudes rastreadas, el ID de AWS X-Rayrastreo.
SegmentId— Para las solicitudes de rastreo, el identificador del segmento de X-Ray.
Muestras: para solicitudes rastreadas, el resultado del muestreo.

Uso de una biblioteca de registro

Para obtener registros más detallados, utilice el módulo de registro en la biblioteca estándar o en cualquier biblioteca de registro de terceros que escriba en stdout o stderr.

Para los tiempos de ejecución de Python compatibles, puede elegir si los registros creados con el módulo logging estándar se capturan en texto sin formato o JSON. Para obtener más información, consulte Uso de los controles de registro avanzados de Lambda con Python.

Actualmente, el formato de registro predeterminado para todos los tiempos de ejecución de Python es texto sin formato. El siguiente ejemplo muestra cómo las salidas de registro creadas con el logging módulo estándar se capturan en texto plano en CloudWatch los registros.


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)

La salida de logger incluye el nivel de registro, la marca de tiempo y el ID de la solicitud.


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

Cuando el formato de registro de la función está establecido en texto sin formato, la configuración de nivel de registro predeterminada para los tiempos de ejecución de Python es WARN. Esto significa que Lambda solo envía salidas de registro de nivel WARN y de nivel inferior a CloudWatch Logs. Para cambiar el nivel de registro predeterminado, utilice el método setLevel() de logging de Python como se muestra en este código de ejemplo. Si establece el formato de registro de la función en JSON, le recomendamos que configure el nivel de registro de la función mediante los controles de registro avanzados de Lambda y no configure el nivel de registro en el código. Para obtener más información, consulte Uso del filtrado a nivel de registro con Python

Uso de los controles de registro avanzados de Lambda con Python

Para tener más control sobre cómo se registran, procesan y consumen los registros de sus funciones, puede configurar las siguientes opciones de registro para los tiempos de ejecución de Lambda Python admitidos:

Formato de registro: seleccione entre texto sin formato y el formato JSON estructurado para los registros de su función
Nivel de registro: para los registros en formato JSON, elija el nivel de detalle de los registros que Lambda envía a Amazon CloudWatch, como ERROR, DEBUG o INFO
Grupo de registros: elija el grupo de CloudWatch registros al que su función envía los registros

Para obtener más información sobre estas opciones de registro e instrucciones sobre cómo configurar la función para utilizarlas, consulte Configuración de controles de registro avanzados para su función de Lambda.

Para utilizar las opciones de formato de registro y nivel de registro con las funciones de Lambda de Python, consulte las instrucciones en las siguientes secciones.

Uso de registros JSON estructurados con Python

Si selecciona JSON para el formato de registro de la función, Lambda enviará los registros generados por la biblioteca de registro estándar de Python a CloudWatch un JSON estructurado. Cada objeto de registro JSON contiene, por lo menos, cuatro pares clave-valor con las siguientes claves:

"timestamp": la hora en que se generó el mensaje de registro
"level": el nivel de registro asignado al mensaje
"message": el contenido del mensaje de registro
"requestId": el ID de solicitud único para la invocación de la función

La biblioteca de logging de Python también puede agregar pares clave-valor adicionales, como "logger", a este objeto JSON.

Los ejemplos de las siguientes secciones muestran cómo las salidas de registro generadas con la logging biblioteca de Python se capturan en CloudWatch los registros al configurar el formato de registro de la función como JSON.

Tenga en cuenta que si utiliza el método print para generar salidas de registro básicos como se describe en Impresión en el registro, Lambda capturará estas salidas como texto sin formato, incluso si configura el formato de registro de la función como JSON.

Salidas de registro JSON estándar mediante la biblioteca de registro de Python

En el siguiente ejemplo, el fragmento de código y la salida del registro muestran cómo las salidas de registro estándar generadas con la logging biblioteca de Python se capturan en CloudWatch los registros cuando el formato de registro de la función está establecido en JSON.

ejemplo Código de registro de Python


import logging  
logger = logging.getLogger()

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

ejemplo Entrada de registro JSON


{
    "timestamp":"2023-10-27T19:17:45.586Z",
    "level":"INFO",
    "message":"Inside the handler function",
    "logger": "root",
    "requestId":"79b4f56e-95b1-4643-9700-2807f4e68189"
}

Registro de parámetros adicionales en JSON

Si el formato de registro de la función está establecido en JSON, también puede registrar parámetros adicionales con la logging biblioteca estándar de Python mediante la extra palabra clave para pasar un diccionario de Python a la salida del registro.

ejemplo Código de registro de Python


import logging

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

ejemplo Entrada de registro 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
  ]
}

Registro de excepciones en JSON

El siguiente fragmento de código muestra cómo se capturan las excepciones de Python en la salida del registro de su función cuando configura el formato de registro como JSON. Tenga en cuenta que a las salidas de registro generadas mediante logging.exception se les asigna el nivel de registro ERROR.

ejemplo Código de registro de Python


import logging

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

ejemplo Entrada de registro 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"
}

Registros estructurados en JSON con otras herramientas de registro

Si su código ya usa otra biblioteca de registro, como Powertools para AWS Lambda, para producir registros estructurados en JSON, no necesita realizar ningún cambio. AWS Lambda no codifica dos veces ningún registro que ya esté codificado en JSON. Incluso si configuras la función para usar el formato de registro JSON, los resultados del registro aparecen CloudWatch en la estructura JSON que definas.

El siguiente ejemplo muestra cómo las salidas de registro generadas con el AWS Lambda paquete Powertools for se capturan en CloudWatch los registros. El formato de la salida de este registro es el mismo independientemente de si la configuración de registro de la función está establecida en JSON o TEXT. Para obtener más información acerca del uso de Powertools para AWS Lambda, consulte Uso de Powertools para AWS Lambda (Python) y AWS SAM para el registro estructurado y Uso de Powertools para AWS Lambda (Python) y AWS CDK para el registro estructurado

ejemplo Fragmento de código de registro de Python (usando Powertools para AWS Lambda)


from aws_lambda_powertools import Logger

logger = Logger()

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

ejemplo Entrada de registro JSON (usando 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" 
}

Uso del filtrado a nivel de registro con Python

Al configurar el filtrado a nivel de registro, puede elegir enviar solo los registros de un nivel de registro determinado o inferior a Logs. CloudWatch Para obtener información sobre cómo configurar el filtrado a nivel de registro para su función, consulte Filtrado a nivel de registro.

Para que AWS Lambda filtre los registros de las aplicaciones según su nivel de registro, la función debe usar registros con formato JSON. Puede lograr esto de dos maneras:

Cree salidas de registro con la biblioteca logging estándar de Python y configure su función para que utilice el formato de registro JSON. A continuación, AWS Lambda filtra las salidas del registro utilizando el par clave-valor “nivel” del objeto JSON descrito en Uso de registros JSON estructurados con Python. Para obtener información sobre cómo configurar el formato de registro de la función, consulte Configuración de controles de registro avanzados para su función de Lambda.
Utilice otra biblioteca o método de registro para crear registros estructurados en JSON en su código que incluyan un par clave-valor “nivel” que defina el nivel de la salida del registro. Por ejemplo, puede utilizar Powertools para AWS Lambda con el objetivo de generar salidas de registros JSON estructurados a partir de su código.

También puede utilizar una instrucción de impresión para generar un objeto JSON que contenga un identificador de nivel de registro. La siguiente declaración de impresión produce una salida con formato JSON en la que el nivel de registro se establece en INFO. AWS Lambdaenviará el objeto JSON a CloudWatch Logs si el nivel de registro de la función está establecido en INFO, DEBUG o TRACE.
```
print('{"msg":"My log message", "level":"info"}')
```

Para que Lambda filtre los registros de la función, también debe incluir un par clave-valor "timestamp" en la salida del registro JSON. La hora debe especificarse con un formato de marca de tiempo RFC 3339 válido. Si no proporciona una marca de tiempo válida, Lambda asignará al registro el nivel INFO y agregará una marca de tiempo por usted.

Visualización de los registros en la consola de Lambda

Puede utilizar la consola de Lambda para ver la salida del registro después de invocar una función de Lambda.

Si su código se puede probar desde el editor de código integrado, encontrará los registros en los resultados de ejecución. Cuando utilice la característica de prueba de la consola para invocar una función, encontrará la Salida de registro en la sección de Detalles.

Visualización de los registros en la consola CloudWatch

Puede utilizar la CloudWatch consola de Amazon para ver los registros de todas las invocaciones de funciones de Lambda.

Para ver los registros en la consola CloudWatch

Abra la página de grupos de registros en la CloudWatch consola.
Elija el grupo de registros para su función (your-function-name/aws/lambda/).
Elija una secuencia de registro.

Cada flujo de registro se corresponde con una instancia de su función. Aparece un flujo de registro cuando actualiza la función de Lambda y cuando se crean instancias adicionales para manejar varias invocaciones simultáneas. Para encontrar registros para una invocación específica, le recomendamos que interfiera su función con AWS X-Ray. X-Ray registra los detalles sobre la solicitud y el flujo de registro en el seguimiento.

Para utilizar una aplicación de ejemplo que correlacione registros y trazas con X-Ray, consulte Aplicación de ejemplo de procesamiento de errores para AWS Lambda.

Visualización de los registros con AWS CLI

La AWS CLI es una herramienta de código abierto que lo habitlita para interactuar con los servicios de AWS mediante el uso de comandos en el shell de la línea de comandos. Para completar los pasos de esta sección, debe disponer de lo siguiente:

Puede utilizar la CLI de AWS CLI para recuperar registros de una invocación mediante la opción de comando --log-type. La respuesta contiene un campo LogResult que contiene hasta 4 KB de registros con codificación base64 a partir de la invocación.

ejemplo recuperar un ID de registro

En el ejemplo siguiente se muestra cómo recuperar un ID de registro del campo LogResult para una función denominada my-function.


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

Debería ver los siguientes datos de salida:


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

ejemplo decodificar los registros

En el mismo símbolo del sistema, utilice la utilidad base64 para decodificar los registros. En el ejemplo siguiente se muestra cómo recuperar registros codificados en base64 para 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

La opción cli-binary-format es obligatoria si va a utilizar la versión 2 de la AWS CLI. Para que esta sea la configuración predeterminada, ejecute aws configure set cli-binary-format raw-in-base64-out. Para obtener más información, consulte Opciones de la línea de comandos globales compatibles con AWS CLI en la Guía del usuario de la AWS Command Line Interface versión 2.

Debería ver los siguientes datos de salida:


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

La utilidad base64 está disponible en Linux, macOS y Ubuntu en Windows. Es posible que los usuarios de macOS necesiten usar base64 -D.

ejemplo get-logs.sh script

En el mismo símbolo del sistema, utilice el siguiente script para descargar los últimos cinco eventos de registro. El script utiliza sed para eliminar las comillas del archivo de salida y permanece inactivo durante 15 segundos para dar tiempo a que los registros estén disponibles. La salida incluye la respuesta de Lambda y la salida del comando get-log-events.

Copie el contenido de la siguiente muestra de código y guárdelo en su directorio de proyecto 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

ejemplo macOS y Linux (solamente)

En el mismo símbolo del sistema, es posible que los usuarios de macOS y Linux necesiten ejecutar el siguiente comando para asegurarse de que el script es ejecutable.


chmod -R 755 get-logs.sh

ejemplo recuperar los últimos cinco eventos de registro

En el mismo símbolo del sistema, ejecute el siguiente script para obtener los últimos cinco eventos de registro.


./get-logs.sh

Debería ver los siguientes datos de salida:


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

Eliminación de registros

Los grupos de registro no se eliminan automáticamente cuando se elimina una función. Para evitar almacenar registros indefinidamente, elimine el grupo de registros o configure un periodo de retención después de lo cual los registros se eliminan automáticamente.

Herramientas y bibliotecas

Powertools para AWS Lambda (Python) es un kit de herramientas para desarrolladores destinado a implementar prácticas recomendadas sin servidor y aumentar la velocidad de los desarrolladores. La utilidad de logger proporciona un logger optimizado para Lambda que incluye información adicional sobre el contexto de la función en todas las funciones con un resultado estructurado como JSON. Utilice esta utilidad para hacer lo siguiente:

Capturar campos clave del contexto de Lambda, arranque en frío y resultados de registro de estructuras como JSON
Registrar los eventos de invocación de Lambda cuando se le indique (desactivado de forma predeterminada)
Imprimir todos los registros solo para un porcentaje de las invocaciones mediante el muestreo de registros (desactivado de forma predeterminada)
Agregar claves adicionales al registro estructurado en cualquier momento
Utilizar un formateador de registros personalizado (traiga su propio formateador) para generar registros en una estructura compatible con el RFC de registro de su organización

Uso de Powertools para AWS Lambda (Python) y AWS SAM para el registro estructurado

Siga los pasos que figuran a continuación para descargar, crear e implementar una aplicación de muestra “Hola, mundo” de Python con módulos de Powertools para Python integrados mediante el AWS SAM. Esta aplicación implementa un backend de API básico y utiliza Powertools para emitir registros, métricas y seguimiento. Consta de un punto de conexión de Amazon API Gateway y una función de Lambda. Al enviar una solicitud GET al punto final de API Gateway, la función Lambda invoca, envía registros y métricas mediante el formato de métrica integrada y envía CloudWatch seguimientos a. AWS X-Ray La función devuelve el mensaje hello world.

Requisitos previos

Para completar los pasos de esta sección, debe disponer de lo siguiente:

Python 3.9
Versión 2 de la AWS CLI
Versión 1.75 o posterior de la CLI de AWS SAM. Si tiene una versión anterior de la CLI de AWS SAM, consulte Actualización de la CLI de AWS SAM.

Implementar una aplicación de ejemplo de AWS SAM

Inicialice la aplicación con la plantilla “Hola, mundo” de Python.


sam init --app-template hello-world-powertools-python --name sam-app --package-type Zip --runtime python3.9 --no-tracing

Compile la aplicación.
```
cd sam-app && sam build
```
Implemente la aplicación.
```
sam deploy --guided
```
Siga las indicaciones que aparecen en pantalla. Para aceptar las opciones predeterminadas proporcionadas en la experiencia interactiva, oprima Enter.

nota
HelloWorldFunction Es posible que no se haya definido la autorización, ¿está bien? , asegúrate de entrary.

Obtenga la URL de la aplicación implementada:


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

Invoque el punto de conexión de la API:
```
curl GET <URL_FROM_PREVIOUS_STEP>
```
Si se realiza de forma correcta, verá el siguiente resultado:
```
{"message":"hello world"}
```

Para obtener los registros de la función, ejecute sam logs. Para obtener más información, consulte Uso de registros en la Guía para desarrolladores de AWS Serverless Application Model.


sam logs --stack-name sam-app

El resultado del registro tendrá este aspecto:


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

Se trata de un punto de conexión de API pública al que se puede acceder a través de Internet. Se recomienda eliminar el punto de conexión después de las pruebas.
```
sam delete
```

Administración de retención de registros

Los grupos de registro no se eliminan automáticamente cuando se elimina una función. Para evitar almacenar los registros de forma indefinida, elimine el grupo de registros o configure un período de retención tras el cual CloudWatch se eliminen automáticamente los registros. Para configurar la retención de registros, agregue lo siguiente a la plantilla de 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 de Powertools para AWS Lambda (Python) y AWS CDK para el registro estructurado

Siga los pasos que figuran a continuación para descargar, crear e implementar una aplicación de muestra “Hola, mundo” de Python con módulos integrados de Powertools para AWS Lambda (Python) mediante AWS CDK. Esta aplicación implementa un backend de API básico y utiliza Powertools para emitir registros, métricas y seguimiento. Consta de un punto de conexión de Amazon API Gateway y una función de Lambda. Al enviar una solicitud GET al punto final de API Gateway, la función Lambda invoca, envía registros y métricas mediante el formato de métrica integrada y envía CloudWatch seguimientos a. AWS X-Ray La función devuelve el mensaje hello world.

Requisitos previos

Para completar los pasos de esta sección, debe disponer de lo siguiente:

Python 3.9
Versión 2 de la AWS CLI
Versión 2 de la AWS CDK
Versión 1.75 o posterior de la CLI de AWS SAM. Si tiene una versión anterior de la CLI de AWS SAM, consulte Actualización de la CLI de AWS SAM.

Implementar una aplicación de ejemplo de AWS CDK

Cree un directorio de proyecto para la nueva aplicación.
```
mkdir hello-world
cd hello-world
```
Inicialice la aplicación.
```
cdk init app --language python
```
Instale las dependencias de Python.
```
pip install -r requirements.txt
```
Cree un directorio lambda_function en la carpeta raíz.
```
mkdir lambda_function
cd lambda_function
```

Cree un archivo app.py y agregue el siguiente código al archivo. Se trata del código de la función de 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 el directorio hello_world. Debería ver un archivo llamado hello_world_stack.py.
```
cd ..
cd hello_world
```

Abra hello_world_stack.py y agregue el siguiente código al archivo. Contiene el Constructor Lambda, que crea la función Lambda, configura las variables de entorno para Powertools y establece la retención de registros en una semana, y el Constructor ApiGatewayv 1, que crea la 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")

Implemente la aplicación.
```
cd ..
cdk deploy
```

Obtenga la URL de la aplicación implementada:


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

Invoque el punto de conexión de la API:
```
curl GET <URL_FROM_PREVIOUS_STEP>
```
Si se realiza de forma correcta, verá el siguiente resultado:
```
{"message":"hello world"}
```

Para obtener los registros de la función, ejecute sam logs. Para obtener más información, consulte Uso de registros en la Guía para desarrolladores de AWS Serverless Application Model.


sam logs --stack-name HelloWorldStack

El resultado del registro tendrá este aspecto:


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

Se trata de un punto de conexión de API pública al que se puede acceder a través de Internet. Se recomienda eliminar el punto de conexión después de las pruebas.
```
cdk destroy
```

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Context

Pruebas