# Registro y supervisión de las funciones de Lambda de Python
AWS Lambda supervisa de forma automática funciones de Lambda y envía entradas de registros a Amazon CloudWatch. Su función de Lambda viene con un grupo de registros de Registros de CloudWatch y con un flujo de registro para cada instancia de su 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 acerca de Registros de CloudWatch, consulte [Envío de registros de funciones de Lambda a Registros de CloudWatch](monitoring-cloudwatchlogs.md).
Para generar registros a partir del código de función, puede utilizar el módulo [https://docs.python.org/3/library/logging.html](https://docs.python.org/3/library/logging.html) 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 de grupo de registro y flujo de Registros de CloudWatch y el objeto de evento.
Tenga en cuenta que, si su función genera registros mediante instrucciones de Python `print`, Lambda solo puede enviar las salidas de registro a Registros de CloudWatch 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](#python-logging-advanced).
**Example lambda\$1function.py**
```
import os
def lambda_handler(event, context):
print('## ENVIRONMENT VARIABLES')
print(os.environ['AWS_LAMBDA_LOG_GROUP_NAME'])
print(os.environ['AWS_LAMBDA_LOG_STREAM_NAME'])
print('## EVENT')
print(event)
```
**Example salida del registro**
```
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
```
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 ID 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. Cuando las invocaciones comparten un entorno de ejecución, Lambda informa de la memoria máxima utilizada en todas las invocaciones. Este comportamiento puede dar como resultado un valor notificado superior al esperado.
+ **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.
+ **TraceId de XRAY**: para las solicitudes rastreadas, el [ID de seguimientode AWS X-Ray](services-xray.md).
+ **SegmentId**: para solicitudes rastreadas, el ID 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](https://docs.python.org/3/library/logging.html) 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](#python-logging-advanced).
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 creados con el módulo `logging` estándar se capturan en texto sin formato en Registros de CloudWatch.
```
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] 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**
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 envía a Registros de CloudWatch solo las salidas de registro de nivel WARN e inferiores. 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](#python-logging-levels)
## 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 registro**: elija el grupo de registro de CloudWatch 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 las funciones de Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced).
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 su función, Lambda enviará los registros de salida utilizando la biblioteca de registros estándar de Python a CloudWatch como 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 `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 biblioteca `logging` de Python se capturan en Registros de CloudWatch cuando se configura 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](#python-logging-output), 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
El siguiente ejemplo de fragmento de código y de salidas de registro muestra cómo las salidas de registro estándar generadas con la biblioteca `logging` de Python se capturan en Registros de CloudWatch cuando se configura el formato de registro de la función como JSON.
**Example Código de registro de Python**
```
import logging
logger = logging.getLogger()
def lambda_handler(event, context):
logger.info("Inside the handler function")
```
**Example Entrada de registro JSON**
```
{
"timestamp":"2025-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
Cuando el formato de registros de la función se establece en JSON, tambien puede registrar parámetros adicionales con la biblioteca `logging` de Python estándar utilizando la clave `extra` para pasar a un diccionario de Python a la salida del registro.
**Example Código de registro de Python**
```
import logging
def lambda_handler(event, context):
logging.info(
"extra parameters example",
extra={"a":"b", "b": [3]},
)
```
**Example Entrada de registro 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
]
}
```
#### 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.
**Example Código de registro de Python**
```
import logging
def lambda_handler(event, context):
try:
raise Exception("exception")
except:
logging.exception("msg")
```
**Example Entrada de registro 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"
}
```
#### 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 configura su función para utilizar el formato de registro JSON, las salidas del registro aparecen en CloudWatch en la estructura JSON que defina.
El siguiente ejemplo muestra cómo se capturan en Registros de CloudWatch las salidas de registro generadas con el AWS Lambda paquete Powertools. 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](#python-logging-sam) y [Uso de Powertools para AWS Lambda (Python) y AWS CDK para el registro estructurado](#python-logging-powertools-cdk)
**Example 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")
```
**Example Entrada de registro JSON (usando 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"
}
```
### 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 específico o inferior a Registros de 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](monitoring-cloudwatchlogs-log-level.md).
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](#python-logging-JSON). 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 las funciones de Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced).
+ 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 instrucción de impresión produce una salida con formato JSON en la que el nivel de registro se establece en INFO. AWS Lambda enviará el objeto JSON a Registros de CloudWatch 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](https://www.ietf.org/rfc/rfc3339.txt) 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 de CloudWatch
Puede utilizar la consola Amazon CloudWatch para ver los registros de todas las invocaciones de funciones de Lambda.
**Visualización de los registros en la consola CloudWatch**
1. En la consola de CloudWatch, abra la [página de grupos de registro](https://console.aws.amazon.com/cloudwatch/home?#logs:).
1. Seleccione el grupo de registros para su función (**/aws/lambda/*your-function-name***).
1. Elija una secuencia de registro.
Cada flujo de registro se corresponde con una [instancia de su función](lambda-runtime-environment.md). Aparece un flujo de registro cuando actualiza la función de Lambda y cuando se crean instancias adicionales para gestionar 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.
## Visualización de los registros con AWS CLI
La AWS CLI es una herramienta de código abierto que lo habilita para interactuar con los servicios de AWS mediante el uso de comandos en el intérprete de comandos de la línea de comandos. Para completar los pasos de esta sección, debe disponer de la [versión 2 de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
Puede utilizar la [CLI de AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) 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.
**Example 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"
}
```
**Example 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](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) 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](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Es posible que los usuarios de macOS necesiten usar `base64 -D`.
**Example 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`.
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](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) en la *Guía del usuario de la AWS Command Line Interface versión 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 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
```
**Example 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](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention) después de lo cual los registros se eliminan automáticamente.
## Uso de otras herramientas y bibliotecas de registro
[Powertools para AWS Lambda (Python)](https://docs.aws.amazon.com/powertools/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](https://docs.aws.amazon.com/powertools/python/latest/core/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](https://docs.aws.amazon.com/powertools/python/latest/) 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. Cuando se envía una solicitud GET al punto de conexión de API Gateway, la función de Lambda se invoca, envía registros y métricas a CloudWatch mediante Embedded Metric Format y envía seguimiento 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
+ [AWS CLI versión 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS SAM Versión 1.75 o posterior de la CLI de](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Si tiene una versión anterior de la CLI de AWS SAM, consulte [Actualización de la CLI de AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade).
**Implementar una aplicación de ejemplo de AWS SAM**
1. 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
```
1. Compile la aplicación.
```
cd sam-app && sam build
```
1. Implemente la aplicación.
```
sam deploy --guided
```
1. Siga las indicaciones que aparecen en pantalla. Para aceptar las opciones predeterminadas proporcionadas en la experiencia interactiva, oprima `Enter`.
**nota**
En **HelloWorldFunction es posible que no tenga definida la autorización, ¿está bien?**, asegúrese de ingresar `y`.
1. 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
```
1. Invoque el punto de conexión de la API:
```
curl GET
```
Si se realiza de forma correcta, verá el siguiente resultado:
```
{"message":"hello world"}
```
1. Para obtener los registros de la función, ejecute [sam logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html). Para obtener más información, consulte [Uso de registros](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) en la *Guía para desarrolladores de AWS Serverless Application Model*.
```
sam logs --stack-name sam-app
```
El resultado del registro tendrá este aspecto:
```
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. 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 registros de forma indefinida, elimine el grupo de registros o configure un periodo de retención después del cual CloudWatch los eliminará de forma automática. 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)](https://docs.aws.amazon.com/powertools/python/latest/) 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. Cuando se envía una solicitud GET al punto de conexión de API Gateway, la función de Lambda se invoca, envía registros y métricas a CloudWatch mediante Embedded Metric Format y envía seguimiento 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
+ [AWS CLI versión 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS CDK versión 2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_prerequisites)
+ [AWS SAM Versión 1.75 o posterior de la CLI de](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Si tiene una versión anterior de la CLI de AWS SAM, consulte [Actualización de la CLI de AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade).
**Implementar una aplicación de ejemplo de AWS CDK**
1. Cree un directorio de proyecto para la nueva aplicación.
```
mkdir hello-world
cd hello-world
```
1. Inicialice la aplicación.
```
cdk init app --language python
```
1. Instale las dependencias de Python.
```
pip install -r requirements.txt
```
1. Cree un directorio **lambda\$1function** en la carpeta raíz.
```
mkdir lambda_function
cd lambda_function
```
1. 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.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 el directorio **hello\$1world**. Debería ver un archivo llamado **hello\$1world\$1stack.py**.
```
cd ..
cd hello_world
```
1. Abra **hello\$1world\$1stack.py** y agregue el siguiente código al archivo. Esto contiene el [constructor de Lambda](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_lambda.html), el cual crea la función de Lambda, configura variables de entorno para Powertools y establece la retención de registros en una semana, y el [constructor ApiGatewayV1](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_apigateway.html), el cual crea la API de REST.
```
from aws_cdk import (
Stack,
aws_apigateway as apigwv1,
aws_lambda as lambda_,
CfnOutput,
Duration
)
from constructs import Construct
class HelloWorldStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Powertools Lambda Layer
powertools_layer = lambda_.LayerVersion.from_layer_version_arn(
self,
id="lambda-powertools",
# Using AWS Lambda Powertools via Lambda Layer
# This imports the Powertools layer which provides observability features for Lambda functions
# For available versions, see: https://docs.aws.amazon.com/powertools/python/latest/#lambda-layer
)
function = lambda_.Function(self,
'sample-app-lambda',
runtime=lambda_.Runtime.PYTHON_3_9,
layers=[powertools_layer],
code = lambda_.Code.from_asset("./lambda_function/"),
handler="app.lambda_handler",
memory_size=128,
timeout=Duration.seconds(3),
architecture=lambda_.Architecture.X86_64,
environment={
"POWERTOOLS_SERVICE_NAME": "PowertoolsHelloWorld",
"POWERTOOLS_METRICS_NAMESPACE": "PowertoolsSample",
"LOG_LEVEL": "INFO"
}
)
apigw = apigwv1.RestApi(self, "PowertoolsAPI", deploy_options=apigwv1.StageOptions(stage_name="dev"))
hello_api = apigw.root.add_resource("hello")
hello_api.add_method("GET", apigwv1.LambdaIntegration(function, proxy=True))
CfnOutput(self, "apiUrl", value=f"{apigw.url}hello")
```
1. Implementación de la aplicación.
```
cd ..
cdk deploy
```
1. Obtenga la URL de la aplicación implementada:
```
aws cloudformation describe-stacks --stack-name HelloWorldStack --query 'Stacks[0].Outputs[?OutputKey==`apiUrl`].OutputValue' --output text
```
1. Invoque el punto de conexión de la API:
```
curl GET
```
Si se realiza de forma correcta, verá el siguiente resultado:
```
{"message":"hello world"}
```
1. Para obtener los registros de la función, ejecute [sam logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html). Para obtener más información, consulte [Uso de registros](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) en la *Guía para desarrolladores de AWS Serverless Application Model*.
```
sam logs --stack-name HelloWorldStack
```
El resultado del registro tendrá este aspecto:
```
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. 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
```