# Creación de funciones de Lambda con Python
Puede ejecutar código Python en AWS Lambda. Lambda ofrece [tiempos de ejecución](lambda-runtimes.md) para Python que ejecutan su código para procesar eventos. El código se ejecuta en un entorno que incluye el SDK for Python (Boto3), con credenciales de un rol de AWS Identity and Access Management (IAM) que usted administre. Para obtener más información sobre las versiones del SDK incluidas en los tiempos de ejecución de Python, consulte [Versiones del SDK incluidas en el tiempo de ejecución](#python-sdk-included).
Lambda admite los siguientes tiempos de ejecución de Python.
| Nombre | Identificador | Sistema operativo | Fecha de baja | Bloqueo de la función Crear | Bloqueo de la función Actualizar |
| --- | --- | --- | --- | --- | --- |
| Python 3.14 | `python3.14` | Amazon Linux 2023 | 30 de junio de 2029 | 31 de julio de 2029 | 31 de agosto de 2029 |
| Python 3.13 | `python3.13` | Amazon Linux 2023 | 30 de junio de 2029 | 31 de julio de 2029 | 31 de agosto de 2029 |
| Python 3.12 | `python3.12` | Amazon Linux 2023 | 31 de octubre de 2028 | 30 de noviembre de 2028 | 10 de enero de 2029 |
| Python 3.11 | `python3.11` | Amazon Linux 2 | 30 de junio de 2027 | 31 de julio de 2027 | 31 de agosto de 2027 |
| Python 3.10 | `python3.10` | Amazon Linux 2 | 31 de octubre de 2026 | 30 de noviembre de 2026 | 15 de enero de 2027 |
**Para crear una función Python**
1. Abra la [consola de Lambda](https://console.aws.amazon.com/lambda).
1. Seleccione **Creación de función**.
1. Configure los siguientes ajustes:
+ En **Nombre de la función**: ingrese el nombre de la función.
+ **Tiempo de ejecución**: elija **Python 3.14**.
1. Elija **Crear función**.
La consola crea una función de Lambda con un único archivo de origen llamado `lambda_function`. Puede editar este archivo y agregar más archivos en el editor de código integrado. En la sección **IMPLEMENTAR**, elija **Implementar** para actualizar el código de la función. A continuación, para ejecutar el código, seleccione **Crear evento de prueba** en la sección **EVENTOS DE PRUEBA**.
Su función de Lambda tiene un grupo de registros de Registros de CloudWatch. El tiempo de ejecución de la función envía detalles de cada invocación a Registros de CloudWatch. Se transmite cualquier [registro que su función genere](python-logging.md) durante la invocación. Si su función devuelve un error, Lambda formatea el error y lo devuelve al invocador.
**Topics**
+ [Versiones del SDK incluidas en el tiempo de ejecución](#python-sdk-included)
+ [Funciones de Python deshabilitadas](#python-disabled-features)
+ [Formato de respuesta](#python-response-format)
+ [Cierre correcto de las extensiones](#python-graceful-shutdown)
+ [Definir el controlador de funciones de Lambda en Python](python-handler.md)
+ [Uso de archivos .zip para funciones de Lambda en Python](python-package.md)
+ [Implementar funciones de Python Lambda con imágenes de contenedor](python-image.md)
+ [Uso de capas para funciones de Lambda en Python](python-layers.md)
+ [Uso del objeto de contexto Lambda para recuperar información de funciones de Python](python-context.md)
+ [Registro y supervisión de las funciones de Lambda de Python](python-logging.md)
+ [Prueba de funciones de AWS Lambda en Python](python-testing.md)
+ [Instrumentación del código Python en AWS Lambda](python-tracing.md)
## Versiones del SDK incluidas en el tiempo de ejecución
La versión del AWS SDK incluida en el tiempo de ejecución de Python depende de la versión del tiempo de ejecución y de su Región de AWS. Para encontrar la versión del SDK incluida en el tiempo de ejecución que está utilizando, cree una función de Lambda con el código siguiente.
```
import boto3
import botocore
def lambda_handler(event, context):
print(f'boto3 version: {boto3.__version__}')
print(f'botocore version: {botocore.__version__}')
```
## Funciones de Python deshabilitadas
En la siguiente tabla, se enumeran las funciones de Python que están deshabilitadas en los tiempos de ejecución administrados de Lambda y en las imágenes base de contenedor de Python. Estas características deben estar habilitadas cuando se compila el ejecutable en tiempo de ejecución de Python y no se pueden habilitar mediante una marca de tiempo de ejecución. Para usar estas características en Lambda, puede implementar su propia compilación de tiempo de ejecución de Python con estas funciones habilitadas, mediante una [imagen de contenedor](python-image.md#python-image-clients) o un [tiempo de ejecución personalizado](runtimes-custom.md).
| Característica de Python | Versiones de Python afectadas | Status |
| --- | --- | --- |
| Compilador justo a tiempo (JIT) | Python 3.13 y posteriores | El compilador JIT es experimental y no se recomienda para cargas de trabajo de producción. Por lo tanto, está deshabilitado en los tiempos de ejecución de Python en Lambda. |
| Subprocesamiento libre | Python 3.13 y posteriores | El subprocesamiento libre (opción para deshabilitar el bloqueo global del intérprete) está deshabilitado en las compilaciones de Python en Lambda debido al impacto en el rendimiento del código de un solo subproceso. |
## Formato de respuesta
En los tiempos de ejecución de Python 3.12 y posteriores, las funciones devuelven caracteres Unicode como parte de su respuesta JSON. Los tiempos de ejecución de Python anteriores devolvían secuencias con escape para caracteres Unicode en las respuestas. Por ejemplo, en Python 3.11, si devuelve una cadena Unicode como “こんにちは”, escapa a los caracteres Unicode y devuelve "\$1u3053\$1u3093\$1u306b\$1u3061\$1u306f". El tiempo de ejecución de Python 3.12 devuelve el “こんにちは” original.
El uso de respuestas Unicode reduce el tamaño de las respuestas de Lambda, lo que facilita el ajuste de respuestas más grandes al tamaño máximo de carga útil de 6 MB para las funciones sincrónicas. En el ejemplo anterior, la versión con escape es de 32 bytes, en comparación con los 17 bytes de la cadena Unicode.
Cuando actualice a Python 3.12 o tiempos de ejecución de Python posteriores, es posible que tenga que ajustar el código para tener en cuenta el nuevo formato de respuesta. Si el llamador espera un escape de Unicode, debe agregar código a la función de retorno para escapar del Unicode manualmente, o ajustar el llamador para que pueda manejar la devolución de Unicode.
## Cierre correcto de las extensiones
Los tiempos de ejecución de Python 3.12 y posteriores ofrecen capacidades mejoradas de cierre correcto para funciones con [extensiones externas.](lambda-extensions.md) Cuando Lambda cierra un entorno de ejecución, envía una señal `SIGTERM` al tiempo de ejecución y, a continuación, un evento `SHUTDOWN` a cada extensión externa registrada. Puede atrapar la señal `SIGTERM` en la función de Lambda y limpiar los recursos, como las conexiones a bases de datos, creados por la función.
Para obtener más información sobre el ciclo de vida del entorno de ejecución, consulte [Comprender el ciclo de vida del entorno de ejecución de Lambda](lambda-runtime-environment.md). Para ver ejemplos de cómo usar un cierre elegante con extensiones, consulte el [repositorio GitHub de muestras de AWS](https://github.com/aws-samples/graceful-shutdown-with-aws-lambda).
# Definir el controlador de funciones de Lambda en Python
El *controlador* de la función de Lambda es el método del código de la función que procesa eventos. Cuando se invoca una función, Lambda ejecuta el método del controlador. La función se ejecuta hasta que el controlador devuelve una respuesta, se cierra o se agota el tiempo de espera.
En esta página, se describe cómo trabajar con los controladores de funciones de Lambda en Python, incluidas las convenciones de nomenclatura, las firmas de controlador válidas y las prácticas recomendadas. Esta página también incluye un ejemplo de una función de Lambda de Python que recibe información sobre un pedido, genera un recibo en un archivo de texto y coloca este archivo en un bucket de Amazon Simple Storage Service (Amazon S3).
**Topics**
+ [Código de función de Lambda de Python de ejemplo](#python-handler-example)
+ [Convenciones de nomenclatura de controladores](#python-handler-naming)
+ [Uso del objeto de evento de Lambda](#python-handler-event)
+ [Acceso y uso del objeto de contexto de Lambda](#python-handler-context)
+ [Firmas de controlador válidas para los controladores de Python](#python-handler-signature)
+ [Devolver un valor](#python-handler-return)
+ [Uso de AWS SDK para Python (Boto3) en el controlador](#python-handler-sdk)
+ [Acceso a las variables de entorno](#python-handler-env-vars)
+ [Prácticas recomendadas de codificación para las funciones de Lambda en Python](#python-handler-best-practices)
## Código de función de Lambda de Python de ejemplo
El siguiente ejemplo de código de función de Lambda de Python recibe información sobre un pedido, genera un recibo en un archivo de texto y coloca este archivo en un bucket de Amazon S3:
**Example Función de Lambda de Python**
```
import json
import os
import logging
import boto3
# Initialize the S3 client outside of the handler
s3_client = boto3.client('s3')
# Initialize the logger
logger = logging.getLogger()
logger.setLevel("INFO")
def upload_receipt_to_s3(bucket_name, key, receipt_content):
"""Helper function to upload receipt to S3"""
try:
s3_client.put_object(
Bucket=bucket_name,
Key=key,
Body=receipt_content
)
except Exception as e:
logger.error(f"Failed to upload receipt to S3: {str(e)}")
raise
def lambda_handler(event, context):
"""
Main Lambda handler function
Parameters:
event: Dict containing the Lambda function event data
context: Lambda runtime context
Returns:
Dict containing status message
"""
try:
# Parse the input event
order_id = event['Order_id']
amount = event['Amount']
item = event['Item']
# Access environment variables
bucket_name = os.environ.get('RECEIPT_BUCKET')
if not bucket_name:
raise ValueError("Missing required environment variable RECEIPT_BUCKET")
# Create the receipt content and key destination
receipt_content = (
f"OrderID: {order_id}\n"
f"Amount: ${amount}\n"
f"Item: {item}"
)
key = f"receipts/{order_id}.txt"
# Upload the receipt to S3
upload_receipt_to_s3(bucket_name, key, receipt_content)
logger.info(f"Successfully processed order {order_id} and stored receipt in S3 bucket {bucket_name}")
return {
"statusCode": 200,
"message": "Receipt processed successfully"
}
except Exception as e:
logger.error(f"Error processing order: {str(e)}")
raise
```
Este archivo contiene las siguientes secciones de código:
+ Bloque `import`: utilice este bloque para incluir las bibliotecas que requiere la función de Lambda.
+ Inicialización global del cliente y el registrador del SDK: si se incluye código de inicialización fuera del controlador se aprovecha la reutilización del [entorno de ejecución](lambda-runtime-environment.md) para mejorar el rendimiento de la función. Consulte [Prácticas recomendadas de codificación para las funciones de Lambda en Python](#python-handler-best-practices) para obtener más información.
+ `def upload_receipt_to_s3(bucket_name, key, receipt_content):` se trata de una función auxiliar a la que llama la función `lambda_handler` principal.
+ `def lambda_handler(event, context):`: se trata de la **función del controlador principal** de su código, que contiene la lógica principal de la aplicación. Cuando Lambda invoca el controlador de funciones, el [tiempo de ejecución de Lambda](concepts-basics.md#gettingstarted-concepts-runtime) pasa dos argumentos a la función: el [objeto de evento](#python-handler-event) que contiene los datos que debe procesar la función y el [objeto de contexto](#python-handler-context) que contiene información sobre la invocación de la función.
## Convenciones de nomenclatura de controladores
El nombre del controlador de funciones definido en el momento de la creación de una función de Lambda se deriva de lo siguiente:
+ El nombre del archivo en el que se encuentra la función del controlador de Lambda.
+ El nombre de la función del controlador de Python.
En el ejemplo anterior, si el archivo tiene un nombre `lambda_function.py`, el controlador se especificará como `lambda_function.lambda_handler`. Este es el nombre de controlador predeterminado que se asigna a las funciones que se crean con la consola de Lambda.
Si crea una función en la consola con un nombre de archivo o un nombre de controlador de funciones diferente, debe editar el nombre del controlador predeterminado.
**Para cambiar el nombre de controlador de la función (consola)**
1. Abra la página [Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda y elija su función.
1. Elija la pestaña **Código**.
1. Desplácese hacia abajo hasta el panel **Configuración del tiempo de ejecución** y elija **Editar**.
1. En **Controlador**, ingrese el nuevo nombre del controlador de funciones.
1. Seleccione **Save**.
## Uso del objeto de evento de Lambda
Cuando Lambda invoca su función, pasa un argumento de [objeto de evento](concepts-basics.md#gettingstarted-concepts-event) al controlador de funciones. Los objetos JSON son el formato de eventos más común de las funciones de Lambda. En el ejemplo de código de la sección anterior, la función espera una entrada en el siguiente formato:
```
{
"Order_id": "12345",
"Amount": 199.99,
"Item": "Wireless Headphones"
}
```
Si otro Servicio de AWS invoca su función, el evento de entrada también es un objeto de formato JSON. El formato exacto del objeto de evento depende del servicio que invoque la función. Para ver el formato de evento de un servicio concreto, consulte la página correspondiente del capítulo [Invocar Lambda con eventos de otros servicios de AWS](lambda-services.md).
Si el evento de entrada tiene la forma de un objeto JSON, el tiempo de ejecución de Lambda convierte el objeto en un diccionario de Python. Para asignar valores en el JSON de entrada a las variables del código, utilice los métodos estándar del diccionario de Python, tal y como se ilustra en el código de ejemplo.
También puede pasar datos a la función como una matriz JSON o como cualquiera de los otros tipos de datos JSON válidos. La siguiente tabla define cómo el tiempo de ejecución de Python convierte estos tipos de JSON.
| Tipos de datos de JSON | Tipo de datos de Python |
| --- | --- |
| objeto | diccionario (dict) |
| matriz | lista (list) |
| número | número entero (int) o número en coma flotante (float) |
| cadena | cadena (str) |
| Booleano | Booleano (bool) |
| null | NoneType (NoneType) |
## Acceso y uso del objeto de contexto de Lambda
El objeto de contexto de Lambda contiene información sobre la invocación de la función y el entorno de ejecución. Lambda pasa el objeto de contexto a su función de forma automática cuando se invoca. Puede utilizar el objeto de contexto para generar información sobre la invocación de su función con fines de supervisión.
El objeto de contexto es una clase de Python que se define en el [cliente de interfaz del tiempo de ejecución de Lambda](https://github.com/aws/aws-lambda-python-runtime-interface-client/blob/main/awslambdaric/lambda_context.py). Para devolver el valor de cualquiera de las propiedades del objeto de contexto, utilice el método correspondiente en el objeto de contexto. Por ejemplo, el siguiente fragmento de código asigna el valor de la propiedad `aws_request_id` (el identificador de la solicitud de invocación) a una variable denominada `request`.
```
request = context.aws_request_id
```
Para obtener más información sobre el uso del objeto de contexto de Lambda y ver una lista completa de los métodos y propiedades disponibles, consulte [Uso del objeto de contexto Lambda para recuperar información de funciones de Python](python-context.md).
## Firmas de controlador válidas para los controladores de Python
Al definir la función de controlador en Python, la función debe tener dos argumentos. El primero de estos argumentos es el [objeto de evento](#python-handler-event) de Lambda y el segundo es el [objeto de contexto](#python-handler-context) de Lambda. Por convención, estos argumentos de entrada suelen tener como nombres `event` y `context`, pero puede darles cualquier nombre que desee. Si declara la función del controlador con un único argumento de entrada, Lambda generará un error cuando intente ejecutar la función. La forma más común de declarar una función de controlador en Python es la siguiente:
```
def lambda_handler(event, context):
```
También puede usar sugerencias de tipo de Python en la declaración de la función, como se muestra en el siguiente ejemplo:
```
from typing import Dict, Any
def lambda_handler(event: Dict[str, Any], context: Any) -> Dict[str, Any]:
```
Para utilizar la escritura especifica de AWS para los eventos generados por otros Servicios de AWS y para el objeto de contexto, agregue el paquete `aws-lambda-typing` al paquete de implementación de la función. Puede instalar esta biblioteca en su entorno de desarrollo si ejecuta `pip install aws-lambda-typing`. En el siguiente fragmento de código se muestra cómo usar sugerencias de tipo de AWS específicas. En este ejemplo, el evento esperado es un evento de Amazon S3.
```
from aws_lambda_typing.events import S3Event
from aws_lambda_typing.context import Context
from typing import Dict, Any
def lambda_handler(event: S3Event, context: Context) -> Dict[str, Any]:
```
No puede usar el tipo de función `async` de Python para su función de controlador.
## Devolver un valor
Si lo desea, el controlador puede devolver un valor que debe ser serializable en formato JSON. Los tipos de devolución más comunes incluyen `dict`, `list`, `str`, `int`, `float` y `bool`.
Lo que sucede con el valor devuelto depende del [tipo de invocación](lambda-invocation.md) y el [servicio](lambda-services.md) que invocó la función. Por ejemplo:
+ Si utiliza el tipo de invocación `RequestResponse` para [invocar una función de Lambda de manera sincrónica](invocation-sync.md), Lambda devuelve el resultado de la llamada a la función Python al cliente que invoca la función de Lambda (en la respuesta HTTP a la solicitud de invocación, serializado en JSON). Por ejemplo, la consola de AWS Lambda utiliza el tipo de invocación `RequestResponse`, por lo que al invocar la función utilizando la consola, esta mostrará el valor devuelto.
+ Si el controlador devuelve objetos que no se pueden serializar con `json.dumps`, el tiempo de ejecución devuelve un error.
+ Si el controlador devuelve `None`, al igual que hacen las funciones de Python sin una instrucción `return`, el runtime devuelve `null`.
+ Si se utiliza el tipo de invocación `Event` (una [invocación asíncrona](invocation-async.md)), el valor se descarta.
En el código de ejemplo, el controlador devuelve el siguiente diccionario de Python:
```
{
"statusCode": 200,
"message": "Receipt processed successfully"
}
```
El tiempo de ejecución de Lambda serializa este diccionario y lo devuelve al cliente que invocó la función como una cadena JSON.
**nota**
En Python 3.9 y versiones posteriores, Lambda incluye el valor requestId de la invocación en la respuesta de error.
## Uso de AWS SDK para Python (Boto3) en el controlador
A menudo, utilizará las funciones de Lambda para interactuar con otros Servicios de AWS y recursos. La forma más sencilla de interactuar con estos recursos es utilizar AWS SDK para Python (Boto3). Todos los [tiempos de ejecución de Lambda Python compatibles](lambda-runtimes.md#runtimes-supported) incluyen una versión del SDK para Python. Sin embargo, le recomendamos encarecidamente que incluya el SDK en el paquete de implementación de su función si su código necesita usarlo. Si incluye el SDK en el paquete de implementación, tendrá un control total sobre las dependencias y reducirá el riesgo de sufrir problemas de desalineación de las versiones con otras bibliotecas. Consulte [Dependencias de tiempo de ejecución en Python](python-package.md#python-package-dependencies) y [Compatibilidad con versiones anteriores](runtimes-update.md#runtime-update-compatibility) para obtener más información.
Si desea usar el SDK para Python en la función de Lambda, agregue la siguiente instrucción al bloque de importación al principio del código de la función:
```
import boto3
```
Use el comando `pip install` para agregar la biblioteca de `boto3` al paquete de implementación de la función. Para obtener instrucciones detalladas sobre cómo agregar dependencias a un paquete de implementación en formato .zip, consulte [Creación de un paquete de despliegue .zip con dependencias](python-package.md#python-package-create-dependencies). Para obtener más información sobre cómo agregar dependencias a las funciones de Lambda implementadas como imágenes de contenedor, consulte [Creación de una imagen a partir de una imagen base](python-image.md#python-image-create) o [Creación de imágenes a partir de una imagen base alternativa](python-image.md#python-alt-create).
Cuando usa `boto3` en su código, no necesita proporcionar ninguna credencial para inicializar un cliente. Por ejemplo, en el código de ejemplo, utilizamos la siguiente línea de código para inicializar un cliente de Amazon S3:
```
# Initialize the S3 client outside of the handler
s3_client = boto3.client('s3')
```
Con Python, Lambda crea automáticamente variables de entorno con credenciales. El SDK de `boto3` comprueba estas credenciales en las variables de entorno de la función durante la inicialización.
## Acceso a las variables de entorno
En el código del controlador, puede hacer referencia a [variables de entorno](configuration-envvars.md) mediante el método `os.environ.get`. En este código de ejemplo, hacemos referencia a la variable de entorno `RECEIPT_BUCKET` definida mediante la siguiente línea de código:
```
# Access environment variables
bucket_name = os.environ.get('RECEIPT_BUCKET')
```
No olvide incluir una instrucción `import os` en el bloque de importación al principio del código.
## Prácticas recomendadas de codificación para las funciones de Lambda en Python
Siga las directrices de la siguiente lista para utilizar las prácticas recomendadas de codificación al crear sus funciones de Lambda:
+ **Separe el controlador de Lambda de la lógica del núcleo.** Esto le permite probar las distintas unidades de la función con mayor facilidad. Por ejemplo, en Python, podría tener este aspecto:
```
def lambda_handler(event, context):
foo = event['foo']
bar = event['bar']
result = my_lambda_function(foo, bar)
def my_lambda_function(foo, bar):
// MyLambdaFunction logic here
```
+ **Controle las dependencias del paquete de implementación de la función.** El entorno de ejecución AWS Lambda contiene varias bibliotecas. Para los tiempos de ejecución de Node.js y Python, estos incluyen los AWS SDK. Para disponer del conjunto más reciente de características y actualizaciones de seguridad, Lambda actualizará periódicamente estas bibliotecas. Estas actualizaciones pueden introducir cambios sutiles en el comportamiento de la función de Lambda. Para disponer de un control total de las dependencias que utiliza la función, empaquete todas las dependencias con el paquete de implementación.
+ **Minimice la complejidad de las dependencias.** Son preferibles los marcos de trabajo más sencillos, ya que se cargan rápidamente al arrancar el [entorno de ejecución](lambda-runtime-environment.md).
+ **Minimice el tamaño del paquete de implementación de acuerdo con las necesidades de su tiempo de ejecución. ** Esto reducirá la cantidad de tiempo que tarda el paquete de implementación en descargarse y desempaquetarse antes de la invocación.
**Reutilice el entorno de ejecución para mejorar el rendimiento de la función.** Inicialice los clientes de SDK y las conexiones de base de datos fuera del controlador de funciones y almacene localmente en caché los recursos estáticos en el directorio `/tmp`. Las invocaciones posteriores procesadas por la misma instancia de su función pueden reutilizar estos recursos. Esto ahorra costes al reducir el tiempo de ejecución de la función.
Para evitar posibles filtraciones de datos entre las invocaciones, no utilice el entorno de ejecución para almacenar datos de usuario, eventos u otra información con implicaciones de seguridad. Si su función se basa en un estado mutable que no se puede almacenar en la memoria dentro del controlador, considere crear una función independiente o versiones independientes de una función para cada usuario.
**Utilice una directiva keep-alive para mantener conexiones persistentes.** Lambda purga las conexiones inactivas a lo largo del tiempo. Si intenta reutilizar una conexión inactiva al invocar una función, se producirá un error de conexión. Para mantener la conexión persistente, use la directiva keep-alive asociada al tiempo de ejecución. Para ver un ejemplo, consulte [Reutilización de conexiones con Keep-Alive en Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html).
**Utilice [variables de entorno](configuration-envvars.md) para pasar parámetros operativos a su función.** Por ejemplo, si está escribiendo en un bucket de Amazon S3, en lugar de codificar de forma rígida el nombre del bucket, configúrelo como una variable de entorno.
**Evite utilizar invocaciones recursivas** en la función de Lambda, en las que la función se invoca a sí misma o inicia un proceso que puede volver a invocarla. Esto podría producir un volumen no intencionado de invocaciones de la función y costos elevados. Si observa un volumen imprevisto de invocaciones, establezca la simultaneidad reservada de funciones en `0` inmediatamente para limitar todas las invocaciones de la función mientras actualiza el código.
**No utilice API no documentadas y no públicas** en el código de la función de Lambda. Para tiempos de ejecución administrados de AWS Lambda, Lambda aplica periódicamente actualizaciones funcionales y de seguridad a las API internas de Lambda. Estas actualizaciones de las API internas pueden ser incompatibles con versiones anteriores, lo que conlleva consecuencias no deseadas, como errores de invocación si su función depende de estas API no públicas. Consulte la [referencia de la API](https://docs.aws.amazon.com/lambda/latest/api/welcome.html) para obtener una lista de las API disponibles públicamente.
**Escriba el código idempotente.** Escribir el código idempotente para las funciones garantiza que los eventos duplicados se gestionen de la misma manera. El código debe validar y gestionar correctamente los eventos duplicados. Para obtener más información, consulte [¿Cómo puedo hacer que mi función de Lambda sea idempotente?](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-idempotent/).
# Uso de archivos .zip para funciones de Lambda en Python
El código de la función de AWS Lambda incluye un archivo .py que contiene el código del controlador de la función, junto con los paquetes y módulos adicionales de los que dependa el código. Para implementar este código de función en Lambda, se utiliza un *paquete de despliegue*. Este paquete puede ser un archivo de archivos .zip o una imagen de contenedor. Para obtener más información sobre el uso de imágenes de contenedores con Python, consulte [Implementar funciones de Lambda en Python con imágenes de contenedores](https://docs.aws.amazon.com/lambda/latest/dg/python-image.html).
Para crear un paquete de despliegue como un archivo de archivos .zip, puede emplear utilidad de archivado de archivos .zip incorporada de la herramienta de línea de comandos, o cualquier otra utilidad de archivos .zip, como [7zip](https://www.7-zip.org/download.html). En los ejemplos que se muestran en las siguientes secciones se supone que está utilizando una herramienta `zip` de línea de comandos en un entorno Linux o macOS. Para utilizar los mismos comandos en Windows, puede [instalar el Subsistema de Windows para Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) a fin de obtener una versión de Ubuntu y Bash integrada con Windows.
Tenga en cuenta que Lambda usa permisos de archivo de POSIX, por lo que puede necesitar [establecer permisos para la carpeta del paquete de despliegue](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-deployment-package-errors/) antes de crear el archivo de archivos .zip.
**Topics**
+ [Dependencias de tiempo de ejecución en Python](#python-package-dependencies)
+ [Creación de un paquete de despliegue .zip sin dependencias](#python-package-create-no-dependencies)
+ [Creación de un paquete de despliegue .zip con dependencias](#python-package-create-dependencies)
+ [Ruta de búsqueda de dependencias y bibliotecas incluidas en tiempo de ejecución](#python-package-searchpath)
+ [Uso de carpetas \$1\$1pycache\$1\$1](#python-package-pycache)
+ [Creación de paquetes de despliegue .zip con bibliotecas nativas](#python-package-native-libraries)
+ [Creación y actualización de funciones de Lambda en Python mediante archivos .zip](#python-package-create-update)
## Dependencias de tiempo de ejecución en Python
Para las funciones de Lambda que utilizan el tiempo de ejecución de Python, una dependencia puede ser cualquier paquete o módulo de Python. Cuando implemente la función mediante un archivo .zip, podrá agregar estas dependencias a su archivo .zip con el código de la función o utilizar una [capa de Lambda](chapter-layers.md). Una capa es un archivo .zip independiente que puede contener código adicional y otro contenido. Para obtener más información sobre el uso de las capas de Lambda en Python, consulte [Uso de capas para funciones de Lambda en Python](python-layers.md).
Los tiempos de ejecución de Python para Lambda incluyen el AWS SDK para Python (Boto3) y sus dependencias. Lambda proporciona el SDK en el tiempo de ejecución para los escenarios de implementación en los que no puede agregar sus propias dependencias. Estos escenarios incluyen la creación de funciones en la consola mediante el editor de código integrado o el uso de funciones en línea en AWS Serverless Application Model (AWS SAM) o plantillas de CloudFormation.
Lambda actualiza de manera periódica las bibliotecas del tiempo de ejecución de Python para incluir las actualizaciones y los parches de seguridad más recientes. Si la función usa la versión del SDK de Boto3 incluida en el tiempo de ejecución, pero el paquete de despliegue incluye las dependencias del SDK, esto puede provocar problemas de desalineación de versiones. Por ejemplo, el paquete de despliegue puede incluir la dependencia urllib3 del SDK. Cuando Lambda actualiza el SDK en el tiempo de ejecución, los problemas de compatibilidad entre la nueva versión del tiempo de ejecución y la versión de urllib3 del paquete de despliegue pueden provocar un error en la función.
**importante**
Para mantener un control total sobre las dependencias y evitar posibles problemas de desalineación de versiones, le recomendamos que agregue todas las dependencias de la función al paquete de despliegue, incluso si sus versiones están incluidas en el tiempo de ejecución de Lambda. Esto incluye el SDK de Boto3.
Para saber qué versión del SDK de Python (Boto3) se incluye en el tiempo de ejecución que está utilizando, consulte [Versiones del SDK incluidas en el tiempo de ejecución](lambda-python.md#python-sdk-included).
Según el [modelo de responsabilidad compartida de AWS](https://docs.aws.amazon.com/whitepapers/latest/aws-risk-and-compliance/shared-responsibility-model.html), usted es responsable de la administración de cualquier dependencia en los paquetes de despliegue de sus funciones. Esto incluye la aplicación de actualizaciones y parches de seguridad. Para actualizar las dependencias del paquete de despliegue de la función, primero cree un nuevo archivo .zip y, a continuación, cárguelo en Lambda. Para obtener más información, consulte [Creación de un paquete de despliegue .zip con dependencias](#python-package-create-dependencies) y [Creación y actualización de funciones de Lambda en Python mediante archivos .zip](#python-package-create-update).
## Creación de un paquete de despliegue .zip sin dependencias
Si el código de la función no tiene dependencias, el archivo .zip solo contiene el archivo .py con el código del controlador de la función. Utilice la utilidad zip que prefiera para crear un archivo .zip con el archivo .py en la raíz. Si el archivo .py no está en la raíz del archivo .zip, Lambda no podrá ejecutar el código.
Para obtener información sobre cómo implementar un archivo .zip para crear una nueva función de Lambda o actualizar una existente, consulte [Creación y actualización de funciones de Lambda en Python mediante archivos .zip](#python-package-create-update).
## Creación de un paquete de despliegue .zip con dependencias
Si el código de la función depende de paquetes o módulos adicionales, puede agregar estas dependencias al archivo .zip con el código de la función o utilizar una [capa de Lambda](python-layers.md). En las instrucciones de esta sección, se muestra cómo incluir las dependencias en el paquete de despliegue .zip. Para que Lambda ejecute el código, el archivo .py que contiene el código del controlador y todas las dependencias de la función deben estar instalados en la raíz del archivo .zip.
Supongamos que el código de la función se guarda en un archivo llamado `lambda_function.py`. Los siguientes comandos de la CLI crean un archivo .zip llamado `my_deployment_package.zip` que contiene el código de la función de y sus dependencias. Puede instalar las dependencias directamente en una carpeta del directorio de su proyecto o utilizar un entorno virtual de Python.
**Para crear el paquete de despliegue (directorio del proyecto)**
1. Desplácese hasta el directorio del proyecto que contiene su archivo de código fuente `lambda_function.py`. En este ejemplo, el directorio se llama `my_function`.
```
cd my_function
```
1. Cree un nuevo directorio llamado “package” en el que instalará sus dependencias.
```
mkdir package
```
Tenga en cuenta que, en el caso de un paquete de despliegue .zip, Lambda espera que el código fuente y sus dependencias estén en la raíz del archivo .zip. Sin embargo, instalar dependencias directamente en el directorio del proyecto puede introducir una gran cantidad de archivos y carpetas nuevos, lo que dificulta la navegación por el IDE. Aquí se crea un directorio `package` independiente para mantener las dependencias separadas del código fuente.
1. Instale las dependencias en el directorio `package`. En el siguiente ejemplo, se instala el SDK de Boto3 desde el Índice de paquetes de Python mediante pip. Si el código de la función usa paquetes de Python que ha creado usted mismo, guárdelos en el directorio `package`.
```
pip install --target ./package boto3
```
1. Cree un archivo .zip con las bibliotecas instaladas en la raíz.
```
cd package
zip -r ../my_deployment_package.zip .
```
Esto genera un archivo `my_deployment_package.zip` en el directorio del proyecto.
1. Agregue el archivo lambda\$1function.py a la raíz del archivo .zip.
```
cd ..
zip my_deployment_package.zip lambda_function.py
```
El archivo .zip debe tener una estructura de directorios plana, con el código del controlador de la función y todas las carpetas de dependencias instalados en la raíz de la siguiente manera.
```
my_deployment_package.zip
|- bin
| |-jp.py
|- boto3
| |-compat.py
| |-data
| |-docs
...
|- lambda_function.py
```
Si el archivo .py que contiene el código del controlador de la función no está en la raíz del archivo .zip, Lambda no podrá ejecutar el código.
**Creación del paquete de despliegue (entorno virtual)**
1. Cree y active un entorno virtual en el directorio del proyecto. En este ejemplo, el directorio del proyecto se llama `my_function`.
```
~$ cd my_function
~/my_function$ python3.14 -m venv my_virtual_env
~/my_function$ source ./my_virtual_env/bin/activate
```
1. Instale las bibliotecas necesarias con pip. En el siguiente ejemplo, se instala el SDK de Boto3.
```
(my_virtual_env) ~/my_function$ pip install boto3
```
1. Use `pip show` para encontrar la ubicación en su entorno virtual donde pip ha instalado sus dependencias.
```
(my_virtual_env) ~/my_function$ pip show
```
La carpeta en la que pip instala sus bibliotecas puede llamarse `site-packages` o `dist-packages`. Esta carpeta puede estar ubicada en el directorio `lib/python3.x` o `lib64/python3.x` (donde python3.x representa la versión de Python que está utilizando).
1. Desactive el entorno virtual.
```
(my_virtual_env) ~/my_function$ deactivate
```
1. Navegue al directorio que contiene las dependencias que instaló con pip y cree un archivo .zip en el directorio de su proyecto con las dependencias instaladas en la raíz. En este ejemplo, pip ha instalado sus dependencias en el directorio `my_virtual_env/lib/python3.14/site-packages`.
```
~/my_function$ cd my_virtual_env/lib/python3.14/site-packages
~/my_function/my_virtual_env/lib/python3.14/site-packages$ zip -r ../../../../my_deployment_package.zip .
```
1. Navegue hasta la raíz del directorio de su proyecto donde se encuentra el archivo .py que contiene el código del controlador y agréguelo a la raíz del paquete .zip. En este ejemplo, el nombre del archivo de código de la función es `lambda_function.py`.
```
~/my_function/my_virtual_env/lib/python3.14/site-packages$ cd ../../../../
~/my_function$ zip my_deployment_package.zip lambda_function.py
```
## Ruta de búsqueda de dependencias y bibliotecas incluidas en tiempo de ejecución
Cuando utilice una instrucción `import` en su código, el tiempo de ejecución de Python buscará en los directorios de su ruta de búsqueda hasta que encuentre el módulo o el paquete. De forma predeterminada, la primera ubicación que busca el tiempo de ejecución es el directorio en el que se descomprime y monta el paquete de despliegue .zip (`/var/task`). Si incluye una versión de una biblioteca incluida en el tiempo de ejecución de su paquete de implementación, la versión tendrá prioridad sobre la versión incluida en el tiempo de ejecución. Las dependencias del paquete de despliegue también tienen prioridad sobre las dependencias de las capas.
Cuando agregue una dependencia a una capa, Lambda la extraerá en `/opt/python/lib/python3.x/site-packages` (donde `python3.x` representa la versión del tiempo de ejecución que utiliza) o `/opt/python`. En la ruta de búsqueda, estos directorios tienen prioridad sobre los directorios que contienen las bibliotecas incluidas en el tiempo de ejecución y las bibliotecas instaladas con pip (`/var/runtime` y `/var/lang/lib/python3.x/site-packages`). Las bibliotecas de las capas de funciones tienen prioridad sobre las versiones incluidas en el tiempo de ejecución.
**nota**
En la imagen base y el tiempo de ejecución administrado de Python 3.11, AWS SDK y sus dependencias se instalan en el directorio `/var/lang/lib/python3.11/site-packages`.
Para ver la ruta de búsqueda completa de la función de Lambda, agregue el siguiente fragmento de código.
```
import sys
search_path = sys.path
print(search_path)
```
**nota**
Dado que las dependencias del paquete de despliegue o de las capas tienen prioridad sobre las bibliotecas incluidas en el tiempo de ejecución, esto puede provocar problemas de desalineación de versiones si incluye una dependencia del SDK, como urllib3, en su paquete sin incluir también el SDK. Si implementa su propia versión de una dependencia de Boto3, también debe implementar Boto3 como una dependencia en su paquete de despliegue. Le recomendamos que empaquete todas las dependencias de la función, incluso si sus versiones están incluidas en el tiempo de ejecución.
También puede agregar dependencias en una carpeta independiente dentro del paquete .zip. Por ejemplo, puede agregar una versión del SDK de Boto3 a una carpeta del paquete .zip llamada `common`. Cuando descomprima y monte el paquete .zip, esta carpeta se colocará dentro del directorio `/var/task`. Para usar una dependencia de una carpeta del paquete de despliegue .zip en su código, utilice una instrucción `import from`. Por ejemplo, para usar una versión de Boto3 de una carpeta denominada `common` en el paquete .zip, utilice la siguiente instrucción.
```
from common import boto3
```
## Uso de carpetas \$1\$1pycache\$1\$1
Le recomendamos que no incluya carpetas `__pycache__` en el paquete de despliegue de la función. Es posible que el código de bytes de Python que se compila en un equipo de compilación con una arquitectura o un sistema operativo diferentes no sea compatible con el entorno de ejecución de Lambda.
## Creación de paquetes de despliegue .zip con bibliotecas nativas
Si su función solo usa paquetes y módulos puros de Python, puede utilizar el comando `pip install` para instalar las dependencias en cualquier equipo de compilación local y crear el archivo .zip. Muchas bibliotecas populares de Python, incluidas NumPy y Pandas, no son puras de Python y contienen código escrito en C o C\$1\$1. Cuando agregue bibliotecas que contienen código C o C\$1\$1 a su paquete de despliegue, deberá compilar el paquete correctamente para garantizar que sea compatible con el entorno de ejecución de Lambda.
La mayoría de los paquetes disponibles en el Índice de paquetes de Python ([PyPI](https://pypi.org/)) están disponibles como “ruedas” (archivos .whl). Un archivo .whl es un tipo de archivo ZIP que contiene una distribución integrada con binarios precompilados para un sistema operativo y una arquitectura de conjunto de instrucciones en particular. Para que su paquete de despliegue sea compatible con Lambda, debe instalar la rueda para los sistemas operativos Linux y la arquitectura del conjunto de instrucciones de su función.
Es posible que algunos paquetes solo estén disponibles como distribuciones de código fuente. Para estos paquetes, debe compilar y crear los componentes de C o C\$1\$1 usted mismo.
Para ver qué distribuciones están disponibles para el paquete que necesita, haga lo siguiente:
1. Busque el nombre del paquete en la [página principal del Índice de paquetes de Python](https://pypi.org/).
1. Elija la versión del paquete que desea utilizar.
1. Seleccione **Descargar archivos**.
### Uso de distribuciones integradas (ruedas)
Para descargar una rueda que sea compatible con Lambda, utilice la opción `--platform` de pip.
Si la función de Lambda usa la arquitectura del conjunto de instrucciones **x86\$164**, ejecute el siguiente comando `pip install` para instalar una rueda compatible en su directorio `package`. Reemplace `--python 3.x` con la versión del tiempo de ejecución de Python que está utilizando.
```
pip install \
--platform manylinux2014_x86_64 \
--target=package \
--implementation cp \
--python-version 3.x \
--only-binary=:all: --upgrade \
```
Si la función usa la arquitectura del conjunto de instrucciones **arm64**, ejecute el siguiente comando. Reemplace `--python 3.x` con la versión del tiempo de ejecución de Python que está utilizando.
```
pip install \
--platform manylinux2014_aarch64 \
--target=package \
--implementation cp \
--python-version 3.x \
--only-binary=:all: --upgrade \
```
### Uso de distribuciones de código fuente
Si su paquete solo está disponible como distribución de código fuente, debe crear usted mismo las bibliotecas de C o C\$1\$1. Para que su paquete sea compatible con el entorno de ejecución de Lambda, debe crearlo en un entorno que utilice el mismo sistema operativo Amazon Linux. Para ello, cree su paquete en una instancia Linux de Amazon Elastic Compute Cloud (Amazon EC2).
Para obtener más información sobre cómo lanzar y conectarse a una instancia Linux de Amazon EC2, consulte [Get started with Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html) en la *Guía del usuario de Amazon EC2*.
## Creación y actualización de funciones de Lambda en Python mediante archivos .zip
Una vez que haya creado su paquete de implementación .zip, puede utilizarlo para crear una nueva función de Lambda o actualizar una existente. Puede implementar el paquete .zip a través de la consola, la AWS Command Line Interface y la API de Lambda. También puede crear y actualizar funciones de Lambda mediante AWS Serverless Application Model (AWS SAM) y CloudFormation.
El tamaño máximo de un paquete de despliegue .zip para Lambda es de 250 MB (descomprimido). Tenga en cuenta que este límite se aplica al tamaño combinado de todos los archivos que cargue, incluidas las capas de Lambda.
El tiempo de ejecución de Lambda necesita permiso para leer los archivos del paquete de implementación. En la notación octal de permisos de Linux, Lambda necesita 644 permisos para archivos no ejecutables (rw-r--r--) y 755 permisos (rwxr-xr-x) para directorios y archivos ejecutables.
En Linux y macOS, utilice el comando `chmod` para cambiar los permisos de los archivos y directorios del paquete de implementación. Por ejemplo, para conceder a un archivo no ejecutable los permisos correctos, ejecute el siguiente comando.
```
chmod 644
```
Para cambiar los permisos de los archivos en Windows, consulte [Set, View, Change, or Remove Permissions on an Object](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc731667(v=ws.10)) en la documentación de Microsoft Windows.
**nota**
Si no concede a Lambda los permisos necesarios para acceder a los directorios del paquete de implementación, Lambda establecerá los permisos de esos directorios en 755 (rwxr-xr-x).
### Creación y actualización de funciones con archivos .zip mediante la consola
Para crear una nueva función, primero debe crearla en la consola y, a continuación, cargar el archivo .zip. Para actualizar una función existente, abra la página de la función correspondiente y, a continuación, siga el mismo procedimiento para agregar el archivo .zip actualizado.
Si el archivo .zip tiene un tamaño inferior a 50 MB, puede crear o actualizar una función al cargarlo directamente desde su equipo local. Para archivos .zip de más de 50 MB, primero debe cargar su paquete en un bucket de Amazon S3. Para obtener instrucciones sobre cómo cargar un archivo en un bucket de Amazon S3 con la Consola de administración de AWS, consulte [Introducción a Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html). Para cargar archivos mediante la AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) en la *Guía del usuario de la AWS CLI*.
**nota**
No puede cambiar el [tipo de paquete de implementación](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip o imagen de contenedor) de una función existente. Por ejemplo, no se puede convertir una función de imagen de contenedor para utilizar un archivo .zip. Debe crear una nueva función.
**Para crear una nueva función (consola)**
1. Abra la [página Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda y elija **Crear función**.
1. Elija **Crear desde cero**.
1. En **Información básica**, haga lo siguiente:
1. En **Nombre de la función**, escriba el nombre de la función.
1. En **Tiempo de ejecución**, seleccione el tiempo de ejecución que desea utilizar.
1. (Opcional) Para **Arquitectura**, elija la arquitectura del conjunto de instrucciones para su función. La arquitectura predeterminada es x86\$164. Asegúrese de que el paquete de despliegue .zip para su función sea compatible con la arquitectura del conjunto de instrucciones que seleccione.
1. (Opcional) En **Permisos**, expanda **Cambiar función de ejecución predeterminada**. Puede crear un nuevo **Rol de ejecución** o utilizar uno existente.
1. Seleccione **Creación de función**. Lambda crea una función básica “Hola, mundo” mediante el tiempo de ejecución elegido.
**Para cargar un archivo .zip desde su equipo local (consola)**
1. En la [página Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda, elija la función para la que desea cargar el archivo .zip.
1. Seleccione la pestaña **Código**.
1. En el panel **Código fuente**, elija **Cargar desde**.
1. Elija un **archivo .zip**.
1. Para cargar el archivo .zip, haga lo siguiente:
1. Seleccione **Cargar** y, a continuación, seleccione su archivo .zip en el selector de archivos.
1. Elija **Abrir**.
1. Seleccione **Save**.
**Carga de un archivo .zip desde un bucket de Amazon S3 (consola)**
1. En la [página Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda, elija la función para la que desea cargar un nuevo archivo .zip.
1. Seleccione la pestaña **Código**.
1. En el panel **Código fuente**, elija **Cargar desde**.
1. Elija la **ubicación de Amazon S3**.
1. Pegue la URL del enlace de Amazon S3 de su archivo .zip y seleccione **Guardar**.
### Actualización de las funciones del archivo .zip mediante el editor de código de la consola
Para algunas funciones con paquetes de despliegue en formato .zip, puede utilizar el editor de código integrado en la consola de Lambda para actualizar el código de la función de forma directa. Para utilizar esta característica, la función debe cumplir los siguientes criterios:
+ La función debe utilizar uno de los tiempos de ejecución del lenguaje interpretado (Python, Node.js o Ruby)
+ El paquete de implementación de la función debe tener un tamaño inferior a 50 MB (sin comprimir).
El código de función de las funciones con paquetes de despliegue de imágenes de contenedores no se puede editar directamente en la consola.
**Para actualizar el código de función mediante el editor de código de la consola**
1. Abra la [página Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda y seleccione su función.
1. Seleccione la pestaña **Código**.
1. En el panel **Código fuente**, seleccione su archivo de código fuente y edítelo en el editor de código integrado.
1. En la sección **IMPLEMENTAR** elija **Implementar** para actualizar el código de la función:
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
### Creación y actualización de funciones con archivos .zip mediante la AWS CLI
Puede utilizar la [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) para crear una nueva función o actualizar una existente con un archivo .zip. Utilice los comandos [create-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) y [update-function-code](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) para implementar su paquete .zip. Si el archivo .zip tiene un tamaño inferior a 50 MB, puede cargarlo desde una ubicación de archivo en su equipo de compilación local. Para archivos más grandes, debe cargar su paquete .zip desde un bucket de Amazon S3. Para obtener instrucciones sobre cómo cargar un archivo en un bucket de Amazon S3 con la AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) en la *Guía del usuario de la AWS CLI*.
**nota**
Si carga su archivo .zip desde un bucket de Amazon S3 con la AWS CLI, el bucket debe estar ubicado en la misma Región de AWS que su función.
Para crear una nueva función mediante un archivo .zip con la AWS CLI, debe especificar lo siguiente:
+ El nombre de la función (`--function-name`).
+ El tiempo de ejecución de la función (`--runtime`).
+ El nombre de recurso de Amazon (ARN) del [rol de ejecución](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) de la función (`--role`).
+ El nombre del método de controlador en el código de la función (`--handler`).
También debe especificar la ubicación del archivo .zip. Si el archivo .zip se encuentra en una carpeta de su equipo de compilación local, utilice la opción `--zip-file` para especificar la ruta del archivo, como se muestra en el siguiente comando de ejemplo.
```
aws lambda create-function --function-name myFunction \
--runtime python3.14 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--zip-file fileb://myFunction.zip
```
Para especificar la ubicación del archivo .zip en un bucket de Amazon S3, utilice la opción `--code`, como se muestra en el siguiente comando de ejemplo. Solo necesita utilizar el parámetro `S3ObjectVersion` para los objetos con versiones.
```
aws lambda create-function --function-name myFunction \
--runtime python3.14 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion
```
Para actualizar una función existente mediante la CLI, especifique el nombre de la función mediante el parámetro `--function-name`. También debe especificar la ubicación del archivo .zip que desea utilizar para actualizar el código de la función. Si el archivo .zip se encuentra en una carpeta de su equipo de compilación local, utilice la opción `--zip-file` para especificar la ruta del archivo, como se muestra en el siguiente comando de ejemplo.
```
aws lambda update-function-code --function-name myFunction \
--zip-file fileb://myFunction.zip
```
Para especificar la ubicación del archivo .zip en un bucket de Amazon S3, utilice las opciones `--s3-bucket` y `--s3-key` tal como se muestra en el siguiente comando de ejemplo. Solo necesita utilizar el parámetro `--s3-object-version` para los objetos con versiones.
```
aws lambda update-function-code --function-name myFunction \
--s3-bucket amzn-s3-demo-bucket --s3-key myFileName.zip --s3-object-version myObject Version
```
### Creación y actualización de funciones con archivos .zip mediante la API de Lambda
Para crear y actualizar funciones con un archivo de archivos .zip, utilice las siguientes operaciones de la API:
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)
### Creación y actualización de funciones con archivos .zip mediante AWS SAM
AWS Serverless Application Model (AWS SAM) es un conjunto de herramientas que ayuda a agilizar el proceso de creación y ejecución de aplicaciones sin servidor en AWS. Defina los recursos de su aplicación en una plantilla YAML o JSON y utilice la interfaz de la línea de comandos de AWS SAM (AWS SAM CLI) para crear, empaquetar e implementar sus aplicaciones. Al crear una función de Lambda a partir de una plantilla de AWS SAM, AWS SAM crea automáticamente un paquete de despliegue .zip o una imagen de contenedor con el código de la función y las dependencias que especifique. Para obtener más información sobre el uso de AWS SAM para crear e implementar funciones de Lambda, consulte [Introducción a AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) en la *Guía para desarrolladores de AWS Serverless Application Model*.
También puede utilizar AWS SAM para crear una función de Lambda con un archivo de archivos .zip existente. Para crear una función de Lambda mediante AWS SAM, puede guardar el archivo .zip en un bucket de Amazon S3 o en una carpeta local de su equipo de compilación. Para obtener instrucciones sobre cómo cargar un archivo en un bucket de Amazon S3 con la AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) en la *Guía del usuario de la AWS CLI*.
En la plantilla de AWS SAM, el recurso `AWS::Serverless::Function` especifica la función de Lambda. En este recurso, establezca las siguientes propiedades para crear una función mediante un archivo de archivos .zip:
+ `PackageType`: se establece como `Zip`.
+ `CodeUri`: se establece como el URI de Amazon S3, la ruta a la carpeta local o el objeto [FunctionCode](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html) del código de la función.
+ `Runtime`: se establece como el entorno de ejecución elegido
Con AWS SAM, si su archivo .zip tiene más de 50 MB, no es necesario cargarlo primero en un bucket de Amazon S3. AWS SAM puede cargar paquetes .zip hasta el tamaño máximo permitido de 250 MB (descomprimidos) desde una ubicación de su equipo de compilación local.
Para obtener más información sobre la implementación de funciones mediante un archivo .zip en AWS SAM, consulte [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html) en la *Guía para desarrolladores de AWS SAM*.
### Creación y actualización de funciones con archivos .zip mediante CloudFormation
Puede utilizar CloudFormation para crear una función de Lambda con un archivo de archivos .zip. Para crear una función de Lambda a partir de un archivo .zip, primero debe cargar el archivo a un bucket de Amazon S3. Para obtener instrucciones sobre cómo cargar un archivo en un bucket de Amazon S3 con la AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) en la *Guía del usuario de la AWS CLI.*
Para los tiempos de ejecución de Node.js y Python, también puede proporcionar código fuente en línea en la plantilla de CloudFormation. A continuación, CloudFormation crea un archivo .zip que contiene el código de la función creada.
**Uso de un archivo .zip existente**
En la plantilla de CloudFormation, el recurso `AWS::Lambda::Function` especifica la función de Lambda. En este recurso, establezca las siguientes propiedades para crear una función mediante un archivo de archivos .zip:
+ `PackageType`: se establece como `Zip`.
+ `Code`: ingrese el nombre del bucket de Amazon S3 y el nombre del archivo .zip en los campos `S3Bucket` y `S3Key`.
+ `Runtime`: se establece como el entorno de ejecución elegido
**Creación de un archivo .zip a partir de código en línea**
Puede declarar funciones simples escritas en Python o Node.js en línea en una plantilla de CloudFormation. Como el código está incrustado en YAML o JSON, no puede agregar ninguna dependencia externa a su paquete de despliegue. Esto significa que la función debe usar la versión del AWS SDK que se incluye en el tiempo de ejecución. Los requisitos de la plantilla, como tener que usar caracteres de escape para ciertos caracteres, también dificultan el uso de las características de comprobación de sintaxis y finalización de código del IDE. Esto significa que la plantilla puede requerir pruebas adicionales. Debido a estas limitaciones, declarar funciones en línea es más adecuado para códigos muy simples que no cambian con frecuencia.
Para crear un archivo .zip a partir de código en línea para los tiempos de ejecución de Node.js y Python, establezca las siguientes propiedades en el recurso `AWS::Lambda::Function` de la plantilla:
+ `PackageType`: se establece como `Zip`.
+ `Code`: se ingresa el código de la función en el campo `ZipFile`.
+ `Runtime`: se establece como el tiempo de ejecución elegido.
El archivo .zip que genera CloudFormation no puede superar los 4 MB. Para obtener más información sobre la implementación de funciones mediante un archivo .zip en CloudFormation, consulte [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html) en la *Guía del usuario de CloudFormation*.
# Implementar funciones de Python Lambda con imágenes de contenedor
Hay tres formas de crear una imagen de contenedor para una función de Lambda en Python:
+ [Uso de una imagen base de AWS para Python](#python-image-instructions)
Las [imágenes base de AWS](images-create.md#runtimes-images-lp) vienen precargadas con un tiempo de ejecución de lenguaje, un cliente de interfaz de tiempo de ejecución para administrar la interacción entre Lambda y el código de la función y un emulador de interfaz de tiempo de ejecución para realizar pruebas a nivel local.
+ [Uso de una imagen base exclusiva del sistema operativo de AWS](images-create.md#runtimes-images-provided)
[Las imágenes base exclusivas del sistema operativo de AWS](https://gallery.ecr.aws/lambda/provided)contienen una distribución de Amazon Linux y el [emulador de interfaz de tiempo de ejecución](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Por lo general, estas imágenes se utilizan para crear imágenes contenedoras para lenguajes compilados, como [Go](go-image.md#go-image-provided) y [Rust](lambda-rust.md), y para un lenguaje o versión de un lenguaje para los que Lambda no proporciona una imagen base, como Node.js 19. También puede usar imágenes base exclusivas del sistema operativo para implementar un [tiempo de ejecución personalizado](runtimes-custom.md). Para que la imagen sea compatible con Lambda, debe incluir el [cliente de interfaz de tiempo de ejecución para Python](#python-image-clients) en la imagen.
+ [Uso de una imagen base que no sea de AWS](#python-image-clients)
Puede utilizar una imagen base alternativa de otro registro de contenedores, como Alpine Linux o Debian. También puede utilizar una imagen personalizada creada por su organización. Para que la imagen sea compatible con Lambda, debe incluir el [cliente de interfaz de tiempo de ejecución para Python](#python-image-clients) en la imagen.
**sugerencia**
Para reducir el tiempo que tardan las funciones de contenedor de Lambda en activarse, consulte [Uso de compilaciones de varias fases](https://docs.docker.com/build/building/multi-stage/) en la documentación de Docker. Para compilar imágenes de contenedores eficientes, siga [Prácticas recomendadas para escribir Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
En esta página, se explica cómo compilar, probar e implementar imágenes de contenedor para Lambda.
**Topics**
+ [AWS imágenes base para Python](#python-image-base)
+ [Uso de una imagen base de AWS para Python](#python-image-instructions)
+ [Uso de una imagen base alternativa con el cliente de interfaz de tiempo de ejecución](#python-image-clients)
## AWS imágenes base para Python
AWS proporciona las siguientes imágenes base para Python:
| Etiquetas | Tiempo de ejecución | Sistema operativo | Dockerfile | Obsolescencia |
| --- | --- | --- | --- | --- |
| 3.14 | Python 3.14 | Amazon Linux 2023 | [Dockerfile para Python 3.14 en GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.14/Dockerfile.python3.14) | 30 de junio de 2029 |
| 3.13 | Python 3.13 | Amazon Linux 2023 | [Dockerfile para Python 3.13 en GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.13/Dockerfile.python3.13) | 30 de junio de 2029 |
| 3.12 | Python 3.12 | Amazon Linux 2023 | [Dockerfile para Python 3.12 en GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.12/Dockerfile.python3.12) | 31 de octubre de 2028 |
| 3.11 | Python 3.11 | Amazon Linux 2 | [Dockerfile para Python 3.11 en GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.11/Dockerfile.python3.11) | 30 de junio de 2027 |
| 3.10 | Python 3.10 | Amazon Linux 2 | [Dockerfile para Python 3.10 en GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.10/Dockerfile.python3.10) | 31 de octubre de 2026 |
Repositorio de Amazon ECR: [gallery.ecr.aws/lambda/python](https://gallery.ecr.aws/lambda/python)
Las imágenes base de Python 3.12 y versiones posteriores se basan en la [imagen de contenedor mínima de Amazon Linux 2023](https://docs.aws.amazon.com/linux/al2023/ug/minimal-container.html). Las imágenes de Python 3.8-3.11 se basan en la imagen de Amazon Linux 2. (). Las imágenes basadas en AL2023 ofrecen varias ventajas con respecto a Amazon Linux 2, incluida una huella de implementación más reducida y versiones actualizadas de bibliotecas como `glibc`.
Las imágenes basadas en AL2023 utilizan `microdnf` (enlazadas simbólicamente como `dnf`) como administrador de paquetes en lugar de `yum`, que es el administrador de paquetes predeterminado en Amazon Linux 2. `microdnf` es una implementación independiente de `dnf`. Para obtener una lista de los paquetes que se incluyen en las imágenes basadas en AL2023, consulte las columnas de **Minimal Container** de [Comparing packages installed on Amazon Linux 2023 Container Images](https://docs.aws.amazon.com/linux/al2023/ug/al2023-container-image-types.html). Para obtener más información sobre las diferencias entre AL2023 y Amazon Linux 2, consulte [Introducing the Amazon Linux 2023 runtime for AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/) en el Blog de informática de AWS.
**nota**
Para ejecutar imágenes basadas en AL2023 de forma local, incluso con AWS Serverless Application Model (AWS SAM), debe usar Docker en la versión 20.10.10 o posterior.
### Ruta de búsqueda de dependencias en las imágenes base
Cuando utilice una instrucción `import` en su código, el tiempo de ejecución de Python buscará en los directorios de su ruta de búsqueda hasta que encuentre el módulo o el paquete. De forma predeterminada, el tiempo de ejecución busca en el directorio `{LAMBDA_TASK_ROOT}` primero. Si incluye una versión de una biblioteca incluida en el tiempo de ejecución de su imagen, esta versión tendrá prioridad sobre la versión incluida en el tiempo de ejecución.
Los demás pasos de la ruta de búsqueda dependen de la versión de la imagen base de Lambda para Python que utilice:
+ **Python 3.11 y posteriores**: las bibliotecas incluidas en el tiempo de ejecución y las bibliotecas instaladas con pip se instalan en el directorio `/var/lang/lib/python3.11/site-packages`. Este directorio tiene prioridad sobre `/var/runtime` en la ruta de búsqueda. Puede anular el SDK mediante pip para instalar una versión más reciente. Puede usar pip para comprobar que el SDK incluido en el tiempo de ejecución y sus dependencias son compatibles con los paquetes que instale.
+ **Python 3.8-3.10**: las bibliotecas incluidas en el tiempo de ejecución se instalan en el directorio `/var/runtime`. Las bibliotecas instaladas con pip se instalan en el directorio `/var/lang/lib/python3.x/site-packages`. El directorio `/var/runtime` tiene prioridad sobre `/var/lang/lib/python3.x/site-packages` en la ruta de búsqueda.
Para ver la ruta de búsqueda completa de la función de Lambda, agregue el siguiente fragmento de código.
```
import sys
search_path = sys.path
print(search_path)
```
## Uso de una imagen base de AWS para Python
### Requisitos previos
Para completar los pasos de esta sección, debe disponer de lo siguiente:
+ [AWS CLI versión 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versión mínima 25.0.0)
+ El [complemento buildx](https://github.com/docker/buildx/blob/master/README.md) de Docker.
+ Python
### Creación de una imagen a partir de una imagen base
**Para crear una imagen de contenedor a partir de una imagen base de AWS para Python**
1. Cree un directorio para el proyecto y, a continuación, cambie a ese directorio.
```
mkdir example
cd example
```
1. Cree un nuevo archivo denominado `lambda_function.py`. Puede agregar el siguiente código de función de muestra al archivo para realizar pruebas o utilizar su propio código.
**Example Función de Python**
```
import sys
def handler(event, context):
return 'Hello from AWS Lambda using Python' + sys.version + '!'
```
1. Cree un nuevo archivo denominado `requirements.txt`. Si utiliza el código de función de ejemplo del paso anterior, puede dejar el archivo vacío porque no hay dependencias. De lo contrario, enumere cada biblioteca requerida. Por ejemplo, este es el aspecto que `requirements.txt` debería tener si la función usa AWS SDK para Python (Boto3):
**Example requirements.txt**
```
boto3
```
1. Cree un nuevo archivo Dockerfile con la siguiente configuración:
+ Establezca la propiedad `FROM` en el [URI de la imagen base](https://gallery.ecr.aws/lambda/python/).
+ Utilice el comando COPY para copiar el código de la función y las dependencias del tiempo de ejecución a `{LAMBDA_TASK_ROOT}`, una [variable de entorno definido de Lambda](configuration-envvars.md#configuration-envvars-runtime).
+ Establezca el argumento `CMD` para el controlador de la función de Lambda.
Tenga en cuenta que el Dockerfile de ejemplo no incluye una [instrucción USER](https://docs.docker.com/reference/dockerfile/#user). Al implementar una imagen de contenedor en Lambda, Lambda define automáticamente un usuario predeterminado de Linux con permisos de privilegio mínimo. Esto es diferente del comportamiento estándar de Docker, que utiliza de forma predeterminada el usuario `root` cuando no se proporciona ninguna instrucción `USER`.
**Example Dockerfile**
```
FROM public.ecr.aws/lambda/python:3.12
# Copy requirements.txt
COPY requirements.txt ${LAMBDA_TASK_ROOT}
# Install the specified packages
RUN pip install -r requirements.txt
# Copy function code
COPY lambda_function.py ${LAMBDA_TASK_ROOT}
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "lambda_function.handler" ]
```
1. Cree la imagen de Docker con el comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). En el siguiente ejemplo se asigna un nombre a la imagen `docker-image` y se le asigna la [etiqueta](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Para que la imagen sea compatible con Lambda, debe usar la opción `--provenance=false`.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**nota**
El comando especifica la opción `--platform linux/amd64` para garantizar que el contenedor sea compatible con el entorno de ejecución de Lambda, independientemente de la arquitectura de la máquina de compilación. Si tiene intención de crear una función de Lambda con la arquitectura del conjunto de instrucciones ARM64, asegúrese de cambiar el comando para utilizar la opción `--platform linux/arm64` en su lugar.
### (Opcional) Prueba de la imagen de forma local
1. Inicie la imagen de Docker con el comando **docker run**. En este ejemplo, `docker-image` es el nombre de la imagen y `test` es la etiqueta.
```
docker run --platform linux/amd64 -p 9000:8080 docker-image:test
```
Este comando ejecuta la imagen como un contenedor y crea un punto de conexión local en `localhost:9000/2015-03-31/functions/function/invocations`.
**nota**
Si creó la imagen de Docker para la arquitectura del conjunto de instrucciones ARM64, asegúrese de utilizar la opción `--platform linux/arm64` en lugar de `--platform linux/amd64`.
1. Desde una nueva ventana de terminal, publique un evento en el punto de conexión local.
------
#### [ Linux/macOS ]
En Linux y macOS, ejecute el siguiente comando `curl`:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Este comando invoca la función con un evento vacío y devuelve una respuesta. Si utiliza su propio código de función en lugar del código de función de ejemplo, quizás quiera invocar la función con una carga JSON. Ejemplo:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
En PowerShell, ejecute el siguiente comando `Invoke-WebRequest`:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Este comando invoca la función con un evento vacío y devuelve una respuesta. Si utiliza su propio código de función en lugar del código de función de ejemplo, quizás quiera invocar la función con una carga JSON. Ejemplo:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Obtenga el ID del contenedor.
```
docker ps
```
1. Use el comando [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) para detener el contenedor. En este comando, reemplace `3766c4ab331c` por el ID del contenedor del paso anterior.
```
docker kill 3766c4ab331c
```
### Implementación de la imagen
**Para cargar la imagen en Amazon ECR y crear la función de Lambda**
1. Para autenticar la CLI de Docker en su registro de Amazon ECR, ejecute el comando [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html).
+ Establezca el valor de `--region` en la Región de AWS en la que desee crear el repositorio de Amazon ECR.
+ Reemplace `111122223333` por el ID de su Cuenta de AWS.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. Cree un repositorio en Amazon ECR con el comando [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**nota**
El repositorio de Amazon ECR debe estar en la misma Región de AWS que la función de Lambda.
Si se realiza de la forma correcta, verá una respuesta como la siguiente:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Copie el valor de `repositoryUri` de la salida del paso anterior.
1. Ejecute el comando [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) para etiquetar la imagen local en su repositorio de Amazon ECR como la versión más reciente. En este comando:
+ `docker-image:test` es el nombre y la [etiqueta](https://docs.docker.com/engine/reference/commandline/build/#tag) de su imagen de Docker. Son el nombre y la etiqueta de la imagen que especificó en el comando `docker build`.
+ Reemplace `` por el `repositoryUri` que ha copiado. Asegúrese de incluir `:latest` al final del URI.
```
docker tag docker-image:test :latest
```
Ejemplo:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Ejecute el comando [docker push](https://docs.docker.com/engine/reference/commandline/push/) para implementar la imagen local en el repositorio de Amazon ECR. Asegúrese de incluir `:latest` al final del URI del repositorio.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Cree un rol de ejecución](lambda-intro-execution-role.md#permissions-executionrole-api) para la función si aún no tiene uno. Necesitará el nombre de recurso de Amazon (ARN) del rol en el paso siguiente.
1. Cree la función de Lambda. En `ImageUri`, especifique el URI del repositorio anterior. Asegúrese de incluir `:latest` al final del URI.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**nota**
Puede crear una función con una imagen de una cuenta AWS diferente, siempre que la imagen esté en la misma región que la función de Lambda. Para obtener más información, consulte [Permisos entre cuentas de Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Invoque la función.
```
aws lambda invoke --function-name hello-world response.json
```
Debería ver una respuesta como la siguiente:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Para ver la salida de la función, compruebe el archivo `response.json`.
Para actualizar el código de la función, debe volver a compilar la imagen, cargar la nueva imagen en el repositorio de Amazon ECR y, a continuación, utilizar el comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) para implementar la imagen en la función de Lambda.
Lambda resuelve la etiqueta de la imagen en un resumen de imagen específico. Esto significa que si apunta la etiqueta de imagen que se utilizó para implementar la función a una nueva imagen en Amazon ECR, Lambda no actualiza automáticamente la función para usar la nueva imagen.
Para implementar la nueva imagen en la misma función de Lambda, debe usar el comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html), incluso si la etiqueta de la imagen en Amazon ECR sigue siendo la misma. En el siguiente ejemplo, la opción `--publish` crea una nueva versión de la función con la imagen del contenedor actualizada.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
## Uso de una imagen base alternativa con el cliente de interfaz de tiempo de ejecución
Si usa una [imagen base exclusiva del sistema operativo](images-create.md#runtimes-images-provided) o una imagen base alternativa, debe incluir el cliente de interfaz de tiempo de ejecución en su imagen. El cliente de interfaz de tiempo de ejecución extiende el [API de tiempo de ejecución](runtimes-api.md), que administra la interacción entre Lambda y el código de la función.
Instale el [cliente de interfaz de tiempo de ejecución para Python](https://pypi.org/project/awslambdaric) mediante el administrador de paquetes pip:
```
pip install awslambdaric
```
También puede descargar el [cliente de interfaz de tiempo de ejecución de Python](https://github.com/aws/aws-lambda-python-runtime-interface-client/) desde GitHub.
En el siguiente ejemplo, se muestra cómo crear una imagen de contenedor para Python mediante una imagen base que no es de AWS. El Dockerfile de ejemplo usa una imagen base oficial de Python. El Dockerfile incluye el cliente de interfaz de tiempo de ejecución para Python.
### Requisitos previos
Para completar los pasos de esta sección, debe disponer de lo siguiente:
+ [AWS CLI versión 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versión mínima 25.0.0)
+ El [complemento buildx](https://github.com/docker/buildx/blob/master/README.md) de Docker.
+ Python
### Creación de imágenes a partir de una imagen base alternativa
**Para crear una imagen de contenedor a partir de una imagen base que no es de AWS**
1. Cree un directorio para el proyecto y, a continuación, cambie a ese directorio.
```
mkdir example
cd example
```
1. Cree un nuevo archivo denominado `lambda_function.py`. Puede agregar el siguiente código de función de muestra al archivo para realizar pruebas o utilizar su propio código.
**Example Función de Python**
```
import sys
def handler(event, context):
return 'Hello from AWS Lambda using Python' + sys.version + '!'
```
1. Cree un nuevo archivo denominado `requirements.txt`. Si utiliza el código de función de ejemplo del paso anterior, puede dejar el archivo vacío porque no hay dependencias. De lo contrario, enumere cada biblioteca requerida. Por ejemplo, este es el aspecto que `requirements.txt` debería tener si la función usa AWS SDK para Python (Boto3):
**Example requirements.txt**
```
boto3
```
1. Cree un nuevo Dockerfile. El siguiente Dockerfile usa una imagen base oficial de Python en lugar de una [imagen base de AWS](images-create.md#runtimes-images-lp). El Dockerfile incluye el [cliente de interfaz de tiempo de ejecución](https://pypi.org/project/awslambdaric), que hace que la imagen sea compatible con Lambda. El siguiente Dockerfile de ejemplo utiliza una [compilación de varias etapas](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds).
+ Establezca la propiedad `FROM` como la imagen base.
+ Configure `ENTRYPOINT` como el módulo que desea que el contenedor de Docker ejecute cuando se inicie. En este caso, el módulo es el cliente de interfaz de tiempo de ejecución.
+ Establezca el `CMD` como el controlador de la función de Lambda.
Tenga en cuenta que el Dockerfile de ejemplo no incluye una [instrucción USER](https://docs.docker.com/reference/dockerfile/#user). Al implementar una imagen de contenedor en Lambda, Lambda define automáticamente un usuario predeterminado de Linux con permisos de privilegio mínimo. Esto es diferente del comportamiento estándar de Docker, que utiliza de forma predeterminada el usuario `root` cuando no se proporciona ninguna instrucción `USER`.
**Example Dockerfile**
```
# Define custom function directory
ARG FUNCTION_DIR="/function"
FROM python:3.12 AS build-image
# Include global arg in this stage of the build
ARG FUNCTION_DIR
# Copy function code
RUN mkdir -p ${FUNCTION_DIR}
COPY . ${FUNCTION_DIR}
# Install the function's dependencies
RUN pip install \
--target ${FUNCTION_DIR} \
awslambdaric
# Use a slim version of the base Python image to reduce the final image size
FROM python:3.12-slim
# Include global arg in this stage of the build
ARG FUNCTION_DIR
# Set working directory to function root directory
WORKDIR ${FUNCTION_DIR}
# Copy in the built dependencies
COPY --from=build-image ${FUNCTION_DIR} ${FUNCTION_DIR}
# Set runtime interface client as default command for the container runtime
ENTRYPOINT [ "/usr/local/bin/python", "-m", "awslambdaric" ]
# Pass the name of the function handler as an argument to the runtime
CMD [ "lambda_function.handler" ]
```
1. Cree la imagen de Docker con el comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). En el siguiente ejemplo se asigna un nombre a la imagen `docker-image` y se le asigna la [etiqueta](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Para que la imagen sea compatible con Lambda, debe usar la opción `--provenance=false`.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**nota**
El comando especifica la opción `--platform linux/amd64` para garantizar que el contenedor sea compatible con el entorno de ejecución de Lambda, independientemente de la arquitectura de la máquina de compilación. Si tiene intención de crear una función de Lambda con la arquitectura del conjunto de instrucciones ARM64, asegúrese de cambiar el comando para utilizar la opción `--platform linux/arm64` en su lugar.
### (Opcional) Prueba de la imagen de forma local
Utilice el [emulador de interfaz de tiempo de ejecución](https://github.com/aws/aws-lambda-runtime-interface-emulator/) para probar la imagen localmente. Puede [crear el emulador en su imagen](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image) o usar el procedimiento siguiente para instalarlo en su equipo local.
**Para instalar y ejecutar el emulador de interfaz de tiempo de ejecución en su equipo local**
1. Desde el directorio del proyecto, ejecute el siguiente comando para descargar el emulador de interfaz de tiempo de ejecución (arquitectura x86-64) de GitHub e instalarlo en su equipo local.
------
#### [ Linux/macOS ]
```
mkdir -p ~/.aws-lambda-rie && \
curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
chmod +x ~/.aws-lambda-rie/aws-lambda-rie
```
Para instalar el emulador arm64, reemplace la URL del repositorio de GitHub en el comando anterior por lo siguiente:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
#### [ PowerShell ]
```
$dirPath = "$HOME\.aws-lambda-rie"
if (-not (Test-Path $dirPath)) {
New-Item -Path $dirPath -ItemType Directory
}
$downloadLink = "https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie"
$destinationPath = "$HOME\.aws-lambda-rie\aws-lambda-rie"
Invoke-WebRequest -Uri $downloadLink -OutFile $destinationPath
```
Para instalar el emulador arm64, reemplace el `$downloadLink` con lo siguiente:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
1. Inicie la imagen de Docker con el comando **docker run**. Tenga en cuenta lo siguiente:
+ `docker-image` es el nombre de la imagen y `test` es la etiqueta.
+ `/usr/local/bin/python -m awslambdaric lambda_function.handler` es el `ENTRYPOINT` seguido del `CMD` de su Dockerfile.
------
#### [ Linux/macOS ]
```
docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
--entrypoint /aws-lambda/aws-lambda-rie \
docker-image:test \
/usr/local/bin/python -m awslambdaric lambda_function.handler
```
------
#### [ PowerShell ]
```
docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
--entrypoint /aws-lambda/aws-lambda-rie `
docker-image:test `
/usr/local/bin/python -m awslambdaric lambda_function.handler
```
------
Este comando ejecuta la imagen como un contenedor y crea un punto de conexión local en `localhost:9000/2015-03-31/functions/function/invocations`.
**nota**
Si creó la imagen de Docker para la arquitectura del conjunto de instrucciones ARM64, asegúrese de utilizar la opción `--platform linux/arm64` en lugar de `--platform linux/amd64`.
1. Publique un evento en el punto de conexión local.
------
#### [ Linux/macOS ]
En Linux y macOS, ejecute el siguiente comando `curl`:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Este comando invoca la función con un evento vacío y devuelve una respuesta. Si utiliza su propio código de función en lugar del código de función de ejemplo, quizás quiera invocar la función con una carga JSON. Ejemplo:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
En PowerShell, ejecute el siguiente comando `Invoke-WebRequest`:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Este comando invoca la función con un evento vacío y devuelve una respuesta. Si utiliza su propio código de función en lugar del código de función de ejemplo, quizás quiera invocar la función con una carga JSON. Ejemplo:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Obtenga el ID del contenedor.
```
docker ps
```
1. Use el comando [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) para detener el contenedor. En este comando, reemplace `3766c4ab331c` por el ID del contenedor del paso anterior.
```
docker kill 3766c4ab331c
```
### Implementación de la imagen
**Para cargar la imagen en Amazon ECR y crear la función de Lambda**
1. Para autenticar la CLI de Docker en su registro de Amazon ECR, ejecute el comando [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html).
+ Establezca el valor de `--region` en la Región de AWS en la que desee crear el repositorio de Amazon ECR.
+ Reemplace `111122223333` por el ID de su Cuenta de AWS.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. Cree un repositorio en Amazon ECR con el comando [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**nota**
El repositorio de Amazon ECR debe estar en la misma Región de AWS que la función de Lambda.
Si se realiza de la forma correcta, verá una respuesta como la siguiente:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Copie el valor de `repositoryUri` de la salida del paso anterior.
1. Ejecute el comando [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) para etiquetar la imagen local en su repositorio de Amazon ECR como la versión más reciente. En este comando:
+ `docker-image:test` es el nombre y la [etiqueta](https://docs.docker.com/engine/reference/commandline/build/#tag) de su imagen de Docker. Son el nombre y la etiqueta de la imagen que especificó en el comando `docker build`.
+ Reemplace `` por el `repositoryUri` que ha copiado. Asegúrese de incluir `:latest` al final del URI.
```
docker tag docker-image:test :latest
```
Ejemplo:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Ejecute el comando [docker push](https://docs.docker.com/engine/reference/commandline/push/) para implementar la imagen local en el repositorio de Amazon ECR. Asegúrese de incluir `:latest` al final del URI del repositorio.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Cree un rol de ejecución](lambda-intro-execution-role.md#permissions-executionrole-api) para la función si aún no tiene uno. Necesitará el nombre de recurso de Amazon (ARN) del rol en el paso siguiente.
1. Cree la función de Lambda. En `ImageUri`, especifique el URI del repositorio anterior. Asegúrese de incluir `:latest` al final del URI.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**nota**
Puede crear una función con una imagen de una cuenta AWS diferente, siempre que la imagen esté en la misma región que la función de Lambda. Para obtener más información, consulte [Permisos entre cuentas de Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Invoque la función.
```
aws lambda invoke --function-name hello-world response.json
```
Debería ver una respuesta como la siguiente:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Para ver la salida de la función, compruebe el archivo `response.json`.
Para actualizar el código de la función, debe volver a compilar la imagen, cargar la nueva imagen en el repositorio de Amazon ECR y, a continuación, utilizar el comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) para implementar la imagen en la función de Lambda.
Lambda resuelve la etiqueta de la imagen en un resumen de imagen específico. Esto significa que si apunta la etiqueta de imagen que se utilizó para implementar la función a una nueva imagen en Amazon ECR, Lambda no actualiza automáticamente la función para usar la nueva imagen.
Para implementar la nueva imagen en la misma función de Lambda, debe usar el comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html), incluso si la etiqueta de la imagen en Amazon ECR sigue siendo la misma. En el siguiente ejemplo, la opción `--publish` crea una nueva versión de la función con la imagen del contenedor actualizada.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
Para obtener un ejemplo de cómo crear una imagen de Python a partir de una imagen base Alpine, consulte [Soporte de imágenes de contenedor para Lambda](https://aws.amazon.com/blogs/aws/new-for-aws-lambda-container-image-support/) en el Blog AWS.
# Uso de capas para funciones de Lambda en Python
Utilice [capas de Lambda](chapter-layers.md) para empaquetar el código y las dependencias que desee reutilizar en varias funciones. Las capas suelen contener dependencias de biblioteca, un [tiempo de ejecución personalizado](runtimes-custom.md) o archivos de configuración. La creación de una capa implica tres pasos generales:
1. Empaquete el contenido de su capa. Esto significa crear un archivo de archivo. zip que contenga las dependencias que desea usar en sus funciones.
1. Cree la capa en Lambda.
1. Agregue la capa a sus funciones.
**Topics**
+ [Empaquete el contenido de su capa.](#python-layers-package)
+ [Creación de la capa en Lambda](#publishing-layer)
+ [Adición de la capa a la función](#python-layer-adding)
+ [Aplicación de ejemplo](#python-layer-sample-app)
## Empaquete el contenido de su capa.
Para crear una capa, agrupe sus paquetes en un archivo .zip que cumpla con los siguientes requisitos:
+ Cree la capa con la misma versión de Python que tiene previsto usar para la función de Lambda. Por ejemplo, si crea una capa con Python 3.14, use el tiempo de ejecución de Python 3.14 para su función.
+ Su archivo .zip debe incluir un directorio `python` en el nivel raíz.
+ Los paquetes de la capa deben ser compatibles con Linux. Las funciones de Lambda se ejecutan en Amazon Linux.
Puede crear capas que contengan bibliotecas de Python de terceros instaladas con `pip` (como `requests` o `pandas`) o sus propios módulos y paquetes de Python.
### Dependencias de terceros
**Creación de una capa con paquetes pip**
1. Elija uno de los siguientes métodos para instalar los paquetes `pip` en el directorio de nivel superior requerido (`python/`):
------
#### [ pip install ]
Para paquetes de Python puros (como solicitudes o boto3):
```
pip install requests -t python/
```
Algunos paquetes de Python, como NumPy y Pandas, incluyen componentes C compilados. Si crea una capa con estos paquetes en macOS o Windows, puede que necesite usar este comando para instalar una rueda compatible con Linux:
```
pip install numpy --platform manylinux2014_x86_64 --only-binary=:all: -t python/
```
Para obtener más información sobre cómo trabajar con paquetes de Python que contienen componentes compilados, consulte [Creación de paquetes de despliegue .zip con bibliotecas nativas](python-package.md#python-package-native-libraries).
------
#### [ requirements.txt ]
El uso de un archivo `requirements.txt` le ayuda a gestionar las versiones de los paquetes y a garantizar instalaciones coherentes.
**Example requirements.txt**
```
requests==2.31.0
boto3==1.37.34
numpy==1.26.4
```
Si el archivo `requirements.txt` solo incluye paquetes de Python puros (como solicitudes o boto3):
```
pip install -r requirements.txt -t python/
```
Algunos paquetes de Python, como NumPy y Pandas, incluyen componentes C compilados. Si crea una capa con estos paquetes en macOS o Windows, puede que necesite usar este comando para instalar una rueda compatible con Linux:
```
pip install -r requirements.txt --platform manylinux2014_x86_64 --only-binary=:all: -t python/
```
Para obtener más información sobre cómo trabajar con paquetes de Python que contienen componentes compilados, consulte [Creación de paquetes de despliegue .zip con bibliotecas nativas](python-package.md#python-package-native-libraries).
------
1. Comprima en zip el contenido del directorio `python`.
------
#### [ Linux/macOS ]
```
zip -r layer.zip python/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\python -DestinationPath .\layer.zip
```
------
La estructura de directorios del archivo .zip debería ser similar a la siguiente:
```
python/ # Required top-level directory
└── requests/
└── boto3/
└── numpy/
└── (dependencies of the other packages)
```
**nota**
Si usa un entorno virtual de Python (venv) para instalar paquetes, la estructura de directorios será diferente (por ejemplo, `python/lib/python3.x/site-packages`). Siempre que el archivo .zip incluya el directorio `python` en el nivel raíz, Lambda podrá localizar e importar los paquetes.
### Módulos de Python personalizados
**Creación de una capa con su propio código**
1. Cree el directorio de nivel superior necesario para su capa:
```
mkdir python
```
1. Cree sus módulos de Python en el directorio `python`. El siguiente módulo de ejemplo valida los pedidos mediante la confirmación de que contienen la información requerida.
**Example módulo personalizado: validator.py**
```
import json
def validate_order(order_data):
"""Validates an order and returns formatted data."""
required_fields = ['product_id', 'quantity']
# Check required fields
missing_fields = [field for field in required_fields if field not in order_data]
if missing_fields:
raise ValueError(f"Missing required fields: {', '.join(missing_fields)}")
# Validate quantity
quantity = order_data['quantity']
if not isinstance(quantity, int) or quantity < 1:
raise ValueError("Quantity must be a positive integer")
# Format and return the validated data
return {
'product_id': str(order_data['product_id']),
'quantity': quantity,
'shipping_priority': order_data.get('priority', 'standard')
}
def format_response(status_code, body):
"""Formats the API response."""
return {
'statusCode': status_code,
'body': json.dumps(body)
}
```
1. Comprima en zip el contenido del directorio `python`.
------
#### [ Linux/macOS ]
```
zip -r layer.zip python/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\python -DestinationPath .\layer.zip
```
------
La estructura de directorios del archivo .zip debería ser similar a la siguiente:
```
python/ # Required top-level directory
└── validator.py
```
1. En su función, importe y use los módulos como lo haría con cualquier paquete de Python. Ejemplo:
```
from validator import validate_order, format_response
import json
def lambda_handler(event, context):
try:
# Parse the order data from the event body
order_data = json.loads(event.get('body', '{}'))
# Validate and format the order
validated_order = validate_order(order_data)
return format_response(200, {
'message': 'Order validated successfully',
'order': validated_order
})
except ValueError as e:
return format_response(400, {
'error': str(e)
})
except Exception as e:
return format_response(500, {
'error': 'Internal server error'
})
```
Puede usar el siguiente [evento de prueba](testing-functions.md#invoke-with-event) para invocar la función:
```
{
"body": "{\"product_id\": \"ABC123\", \"quantity\": 2, \"priority\": \"express\"}"
}
```
Respuesta esperada:
```
{
"statusCode": 200,
"body": "{\"message\": \"Order validated successfully\", \"order\": {\"product_id\": \"ABC123\", \"quantity\": 2, \"shipping_priority\": \"express\"}}"
}
```
## Creación de la capa en Lambda
También puede publicar la capa con la AWS CLI o la consola de Lambda.
------
#### [ AWS CLI ]
Ejecute el comando [publish-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) de la AWS CLI para crear la capa de Lambda:
```
aws lambda publish-layer-version --layer-name my-layer --zip-file fileb://layer.zip --compatible-runtimes python3.14
```
El parámetro [Tiempos de ejecución compatibles](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) es opcional. Cuando se especifica, Lambda usa este parámetro para filtrar las capas en la consola de Lambda.
------
#### [ Console ]
**Para crear una capa (consola)**
1. Abra la página de [Capas](https://console.aws.amazon.com/lambda/home#/layers) de la consola de Lambda.
1. Elija **Crear capa**.
1. Elija **Cargar un archivo .zip** y, a continuación, cargue el archivo .zip que creó anteriormente.
1. (Opcional) En **Tiempos de ejecución compatibles**, elija el tiempo de ejecución de Python que corresponda a la versión de Python que utilizó para crear la capa.
1. Seleccione **Crear**.
------
## Adición de la capa a la función
------
#### [ AWS CLI ]
Para adjuntar la capa a la función, ejecute el comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) de la AWS CLI. Para el parámetro `--layers`, use el ARN de la capa. El ARN debe especificar la versión (por ejemplo, `arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1`). Para obtener más información, consulte [Capas y versiones de capas](chapter-layers.md#lambda-layer-versions).
```
aws lambda update-function-configuration --function-name my-function --cli-binary-format raw-in-base64-out --layers "arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1"
```
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*.
------
#### [ Console ]
**Adición de una capa a una función**
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija la función.
1. Desplácese hacia abajo hasta la sección **Capas** y, a continuación, elija **Agregar una capa**.
1. En **Elija una capa**, seleccione **Capas personalizadas** y, a continuación, elija su capa.
**nota**
Si no agregó un [tiempo de ejecución compatible](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) al crear la capa, su capa no aparecerá aquí. Puede especificar el ARN de la capa en su lugar.
1. Elija **Añadir**.
------
## Aplicación de ejemplo
Para ver más ejemplos de cómo usar las capas de Lambda, consulte la aplicación de ejemplo [layer-python](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-python) en el repositorio de GitHub de la Guía para desarrolladores de AWS Lambda. Esta aplicación incluye dos capas que contienen bibliotecas de Python. Después de crear las capas, puede implementar e invocar las funciones correspondientes para confirmar que las capas funcionan como se espera.
# Uso del objeto de contexto Lambda para recuperar información de funciones de Python
Cuando Lambda ejecuta su función, pasa un objeto context al [controlador](python-handler.md). Este objeto proporciona métodos y propiedades que facilitan información acerca de la invocación, la función y el entorno de ejecución. Para obtener más información sobre cómo se pasa el objeto de contexto al controlador de funciones, consulte [Definir el controlador de funciones de Lambda en Python](python-handler.md).
**Métodos de context**
+ `get_remaining_time_in_millis`: devuelve el número de milisegundos que quedan antes del tiempo de espera de la ejecución.
**Propiedades de context**
+ `function_name`: el nombre de la función de Lambda.
+ `function_version`: la [versión](configuration-versions.md) de la función.
+ `invoked_function_arn`: el nombre de recurso de Amazon (ARN) que se utiliza para invocar esta función. Indica si el invocador especificó un número de versión o alias.
+ `memory_limit_in_mb`: cantidad de memoria asignada a la función.
+ `aws_request_id`: el identificador de la solicitud de invocación.
+ `log_group_name`: grupo de registros de para la función.
+ `log_stream_name`: el flujo de registro de la instancia de la función.
+ `identity`: (aplicaciones móviles) Información acerca de la identidad de Amazon Cognito que autorizó la solicitud.
+ `cognito_identity_id`: la identidad autenticada de Amazon Cognito.
+ `cognito_identity_pool_id`: el grupo de identidad de Amazon Cognito que ha autorizado la invocación.
+ `client_context`: (aplicaciones móviles) Contexto de cliente proporcionado a Lambda por la aplicación cliente.
+ `client.installation_id`
+ `client.app_title`
+ `client.app_version_name`
+ `client.app_version_code`
+ `client.app_package_name`
+ `custom`: un elemento `dict` de valores personalizados establecidos por la aplicación cliente para móviles.
+ `env`: un elemento `dict` de información de entorno proporcionado por el AWS SDK.
Powertools para Lambda (Python) proporciona una definición de interfaz para el objeto de contexto de Lambda. Puede utilizar la definición de la interfaz para obtener sugerencias de tipo o para inspeccionar más a fondo la estructura del objeto de contexto de Lambda. Para ver la definición de la interfaz, consulte [lambda\$1context.py](https://github.com/aws-powertools/powertools-lambda-python/blob/develop/aws_lambda_powertools/utilities/typing/lambda_context.py) en el repositorio *powertools-lambda-python* en GitHub.
En el siguiente ejemplo se muestra una función de controlador que registra información de context.
**Example handler.py**
```
import time
def lambda_handler(event, context):
print("Lambda function ARN:", context.invoked_function_arn)
print("CloudWatch log stream name:", context.log_stream_name)
print("CloudWatch log group name:", context.log_group_name)
print("Lambda Request ID:", context.aws_request_id)
print("Lambda function memory limits in MB:", context.memory_limit_in_mb)
# We have added a 1 second delay so you can see the time remaining in get_remaining_time_in_millis.
time.sleep(1)
print("Lambda time remaining in MS:", context.get_remaining_time_in_millis())
```
Además de las opciones que se enumeran anteriormente, también puede utilizar el SDK de X-Ray AWS para [Instrumentación del código Python en AWS Lambda](python-tracing.md) a fin de identificar las rutas de código críticas, rastrear su rendimiento y capturar los datos para su análisis.
# 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
```
# Prueba de funciones de AWS Lambda en Python
**nota**
Consulte el capítulo [Prueba de funciones](testing-guide.md) para obtener una introducción completa a las técnicas y prácticas recomendadas para probar soluciones sin servidor.
Para probar las funciones sin servidor, se utilizan tipos y técnicas de prueba tradicionales, pero también se debe considerar la posibilidad de probar las aplicaciones sin servidor en conjunto. Las pruebas basadas en la nube proporcionan la medida **más precisa** de la calidad tanto de las funciones como de las aplicaciones sin servidor.
Una arquitectura de aplicaciones sin servidor incluye servicios administrados que proporcionan las funcionalidades críticas de las aplicaciones mediante llamadas a la API. Por este motivo, el ciclo de desarrollo debe incluir pruebas automatizadas que verifiquen las funcionalidades cuando la función y los servicios interactúen.
Si no crea pruebas basadas en la nube, pueden surgir problemas debido a las diferencias entre su entorno local y el entorno implementado. El proceso de integración continua debe ejecutar pruebas con un conjunto de recursos aprovisionados en la nube antes de promover el código al siguiente entorno de implementación, como el control de calidad, el ensayo o la producción.
Siga leyendo esta breve guía para obtener información sobre las estrategias de prueba para aplicaciones sin servidor, o visite el [repositorio de ejemplos de pruebas sin servidor](https://github.com/aws-samples/serverless-test-samples) a fin de profundizar en ejemplos prácticos y específicos para el lenguaje y el tiempo de ejecución de su elección.
![\[illustration showing the relationship between types of tests\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/test-type-illustration2.png)
Para las pruebas sin servidor, seguirá escribiendo pruebas *unitarias*, *de integración* e *integrales*.
+ **Pruebas unitarias**: pruebas que se ejecutan en un bloque de código aislado. Por ejemplo, verificar la lógica empresarial para calcular los gastos de envío en función de un elemento y un destino determinados.
+ **Pruebas de integración**: pruebas en las que participan dos o más componentes o servicios que interactúan, normalmente en un entorno de nube. Por ejemplo, verificar si una función procesa los eventos de una cola.
+ **Pruebas integrales**: pruebas que verifican el comportamiento de toda una aplicación. Por ejemplo, garantizar que la infraestructura esté configurada correctamente y que los eventos fluyan entre los servicios tal como se espera para registrar el pedido de un cliente.
## Pruebas de aplicaciones sin servidor
Por lo general, utilizará una combinación de métodos para probar el código de sus aplicaciones sin servidor, como las pruebas en la nube, las pruebas con simulaciones y, en ocasiones, las pruebas con emuladores.
### Pruebas en la nube
Las pruebas en la nube son valiosas para todas las fases de las pruebas, incluidas las pruebas unitarias, las pruebas de integración y las pruebas integrales. Las pruebas se ejecutan con el código implementado en la nube y se interactúa con los servicios basados en la nube. Este enfoque proporciona la medida **más precisa** de la calidad del código.
Una forma práctica de depurar la función de Lambda en la nube es a través de la consola con un evento de prueba. Un *evento de prueba* es una entrada JSON a su función. Si la función no requiere una entrada, el evento puede ser un documento JSON vacío `({})`. La consola proporciona ejemplos de eventos para una variedad de integraciones de servicios. Tras crear un evento en la consola, puede compartirlo con su equipo para que las pruebas sean más sencillas y coherentes.
**nota**
[Probar una función en la consola](testing-functions.md) es una forma rápida de empezar, pero la automatización de los ciclos de prueba garantiza la calidad de la aplicación y la velocidad de desarrollo.
### Herramientas para pruebas
Existen herramientas y técnicas para acelerar los ciclos de retroalimentación del desarrollo. Por ejemplo, tanto [AWS SAM Accelerate](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/accelerate.html) como el [modo de vigilancia de AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy-watch) reducen el tiempo necesario para actualizar los entornos de nube.
[Moto](https://pypi.org/project/moto/) es una biblioteca de Python que se utiliza para simular servicios y recursos de AWS, de modo que puede probar sus funciones con poca o ninguna modificación mediante el uso de decoradores para interceptar y simular las respuestas.
La característica de validación de [Powertools para AWS Lambda (Python)](https://docs.powertools.aws.dev/lambda-python/latest/utilities/validation/) proporciona decoradores para que pueda validar los eventos de entrada y las respuestas de salida de sus funciones de Python.
Para obtener más información, lea la publicación de blog [Prueba unitaria de Lambda con Python y servicios de AWS simulados](https://aws.amazon.com/blogs/devops/unit-testing-aws-lambda-with-python-and-mock-aws-services/).
Para reducir la latencia relacionada con las iteraciones de implementación en la nube, consulte [AWS Serverless Application Model (AWS SAM) Accelerate](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/using-sam-cli-sync.html) y el [modo de vigilancia de AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy-watch). Estas herramientas supervisan la infraestructura y el código para detectar cambios. Reaccionan ante estos cambios al crear e implementar automáticamente actualizaciones progresivas en el entorno de nube.
Los ejemplos que utilizan estas herramientas están disponibles en el repositorio de código [Python Test Samples](https://github.com/aws-samples/serverless-test-samples/tree/main/python-test-samples).
# Instrumentación del código Python en AWS Lambda
Lambda se integra con AWS X-Ray para permitirle seguir, depurar y optimizar aplicaciones de Lambda. Puede utilizar X-Ray para seguir una solicitud mientras atraviesa los recursos de la aplicación, que pueden incluir funciones de Lambda y otros servicios de AWS.
Para enviar datos de seguimiento a X-Ray, puede utilizar una de estas tres bibliotecas de SDK:
+ [AWS Distro for OpenTelemetry (ADOT)](https://aws.amazon.com/otel): una distribución segura, lista para producción y con soporte de AWS del OpenTelemetry (OTel) SDK.
+ [AWS X-Ray SDK para Python](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html) – un SDK para generar y enviar datos de seguimiento a X-Ray.
+ [Powertools para AWS Lambda (Python)](https://docs.aws.amazon.com/powertools/python/latest/): un kit de herramientas para desarrolladores destinado a implementar prácticas recomendadas sin servidor y aumentar la velocidad de los desarrolladores.
Cada uno de los SDK ofrecen formas de enviar los datos de telemetría al servicio X-Ray. Tras ello, se puede utilizar X-Ray para consultar, filtrar y obtener información sobre las métricas de rendimiento de la aplicación con el fin de identificar problemas y oportunidades de optimización.
**importante**
Los SDK de X-Ray y Powertools para AWS Lambda son parte de una solución de instrumentación completamente integrada que ofrece AWS. Las capas Lambda de ADOT forman parte de un estándar que abarca todo el sector para la instrumentación de seguimiento que recopila más datos en general, pero es posible que no sean adecuadas para todos los casos de uso. Puede implementar el seguimiento integral en X-Ray con cualquiera de las soluciones. Para obtener más información sobre cuál elegir, consulte [Elegir entre SDK de AWS Distro para OpenTelemetry y X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/xray-instrumenting-your-app.html#xray-instrumenting-choosing).
**Topics**
+ [Uso de Powertools para AWS Lambda (Python) y AWS SAM para el seguimiento](#python-tracing-sam)
+ [Uso de Powertools para AWS Lambda (Python) y el AWS CDK para el seguimiento](#python-logging-cdk)
+ [Uso de ADOT para instrumentar las funciones de Python](#python-adot)
+ [Uso del X-Ray SDK para instrumentar las funciones de Python](#python-xray-sdk)
+ [Activación del seguimiento con la consola de Lambda](#python-tracing-console)
+ [Activación del seguimiento con la API de Lambda](#python-tracing-api)
+ [Activación del seguimiento con CloudFormation](#python-tracing-cloudformation)
+ [Interpretación de un seguimiento de X-Ray](#python-tracing-interpretation)
+ [Almacenamiento de dependencias de tiempo de ejecución en una capa (X-Ray SDK)](#python-tracing-layers)
## Uso de Powertools para AWS Lambda (Python) y AWS SAM para el seguimiento
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.powertools.aws.dev/lambda-python) mediante 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.11
+ [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.11 --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 -X GET
```
Si se realiza de forma correcta, verá el siguiente resultado:
```
{"message":"hello world"}
```
1. Para obtener el seguimiento de la función, ejecute [sam traces](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html).
```
sam traces
```
El resultado del seguimiento tendrá este aspecto:
```
New XRay Service Graph
Start time: 2023-02-03 14:59:50+00:00
End time: 2023-02-03 14:59:50+00:00
Reference Id: 0 - (Root) AWS::Lambda - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [1]
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.924
Reference Id: 1 - AWS::Lambda::Function - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: []
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.016
Reference Id: 2 - client - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [0]
Summary_statistics:
- total requests: 0
- ok count(2XX): 0
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0
XRay Event [revision 1] at (2023-02-03T14:59:50.204000) with id (1-63dd2166-434a12c22e1307ff2114f299) and duration (0.924s)
- 0.924s - sam-app-HelloWorldFunction-YBg8yfYtOc9j [HTTP: 200]
- 0.016s - sam-app-HelloWorldFunction-YBg8yfYtOc9j
- 0.739s - Initialization
- 0.016s - Invocation
- 0.013s - ## lambda_handler
- 0.000s - ## app.hello
- 0.000s - Overhead
```
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
```
X-Ray no sigue todas las solicitudes realizadas a la aplicación. X-Ray aplica un algoritmo de muestreo para garantizar que el seguimiento sea eficiente, a la vez que proporciona una muestra representativa de todas las solicitudes. La tasa de muestreo es 1 solicitud por segundo y un 5 por ciento de las solicitudes adicionales. La frecuencia de muestreo de X-Ray no se puede configurar para las funciones.
## Uso de Powertools para AWS Lambda (Python) y el AWS CDK para el seguimiento
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.powertools.aws.dev/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. 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.11
+ [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)
+ [Versión 1.75 o posterior de la CLI de AWS SAM](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.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)
```
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",
# 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_11,
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 -X GET
```
Si se realiza de forma correcta, verá el siguiente resultado:
```
{"message":"hello world"}
```
1. Para obtener el seguimiento de la función, ejecute [sam traces](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html).
```
sam traces
```
El resultado del seguimiento se verá de la siguiente manera:
```
New XRay Service Graph
Start time: 2023-02-03 14:59:50+00:00
End time: 2023-02-03 14:59:50+00:00
Reference Id: 0 - (Root) AWS::Lambda - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [1]
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.924
Reference Id: 1 - AWS::Lambda::Function - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: []
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.016
Reference Id: 2 - client - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [0]
Summary_statistics:
- total requests: 0
- ok count(2XX): 0
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0
XRay Event [revision 1] at (2023-02-03T14:59:50.204000) with id (1-63dd2166-434a12c22e1307ff2114f299) and duration (0.924s)
- 0.924s - sam-app-HelloWorldFunction-YBg8yfYtOc9j [HTTP: 200]
- 0.016s - sam-app-HelloWorldFunction-YBg8yfYtOc9j
- 0.739s - Initialization
- 0.016s - Invocation
- 0.013s - ## lambda_handler
- 0.000s - ## app.hello
- 0.000s - Overhead
```
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
```
## Uso de ADOT para instrumentar las funciones de Python
ADOT proporciona [capas](chapter-layers.md) de Lambda completamente administradas que empaquetan todo lo necesario para recopilar datos de telemetría mediante el OTel SDK. Utilizando esta capa, se pueden instrumentar las funciones de Lambda sin tener que modificar el código de ninguna función. También se puede configurar la capa para que realice una inicialización personalizada de OTel. Para obtener más información, consulte [Configuración personalizada del recopilador de ADOT en Lambda](https://aws-otel.github.io/docs/getting-started/lambda#custom-configuration-for-the-adot-collector-on-lambda) en la documentación de ADOT.
Para los tiempos de ejecución de Python, puede agregar la ** capa Lambda administrada por AWS para ADOT Python** para instrumentar automáticamente sus funciones. Esta capa funciona para arquitecturas arm64 y x86\$164. Para obtener instrucciones detalladas sobre cómo agregar esta capa, consulte [Soporte de Lambda de AWS Distro for OpenTelemetry para Python](https://aws-otel.github.io/docs/getting-started/lambda/lambda-python) en la documentación de ADOT.
## Uso del X-Ray SDK para instrumentar las funciones de Python
Para registrar detalles sobre las llamadas que realiza la función Lambda a otros recursos de la aplicación, también se puede utilizar el AWS X-Ray SDK para Python. Para obtener el SDK, agregue el paquete `aws-xray-sdk` a las dependencias de la aplicación.
**Example [requirements.txt](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-python/function/requirements.txt)**
```
jsonpickle==1.3
aws-xray-sdk==2.4.3
```
En el código de función, puede instrumentar los clientes del SDK de AWS mediante la aplicación de parches a la biblioteca `boto3` con el módulo de `aws_xray_sdk.core`.
**Example [función: rastreo de un cliente del SDK de AWS](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-python/function/lambda_function.py)**
```
import boto3
from aws_xray_sdk.core import xray_recorder
from aws_xray_sdk.core import patch_all
logger = logging.getLogger()
logger.setLevel(logging.INFO)
patch_all()
client = boto3.client('lambda')
client.get_account_settings()
def lambda_handler(event, context):
logger.info('## ENVIRONMENT VARIABLES\r' + jsonpickle.encode(dict(**os.environ)))
...
```
Una vez agregadas las dependencias correctas y realizados los cambios de código necesarios, active el seguimiento en la configuración de la función mediante la consola de Lambda o la API.
## Activación del seguimiento con la consola de Lambda
Para activar el seguimiento activo de la función Lambda mediante la consola, siga estos pasos:
**Cómo activar el seguimiento activo**
1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija una función.
1. Elija **Configuration** (Configuración), y luego **Monitoring and operations tools** (Herramientas de supervisión y operaciones).
1. En **Herramientas de monitorización adicionales**, elija **Editar**.
1. En **CloudWatch Application Signals y AWS X-Ray**, seleccione **Habilitar** para **Seguimientos de servicios de Lambda**.
1. Seleccione **Save**.
## Activación del seguimiento con la API de Lambda
Configure el rastreo en la función Lambda con AWS CLI o SDK de AWS, utilice las siguientes operaciones de API:
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
El siguiente comando de ejemplo de la AWS CLI habilita el seguimiento activo en una función llamada **my-function**.
```
aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active
```
El modo de seguimiento forma parte de la configuración específica de la versión, cuando se publica una versión de la función. No se puede cambiar el modo de seguimiento de una versión publicada.
## Activación del seguimiento con CloudFormation
Para activar el seguimiento en un recurso de `AWS::Lambda::Function` de una plantilla de CloudFormation, utilice la propiedad `TracingConfig`.
**Example [función-inline.yml](https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/templates/function-inline.yml): configuración de rastreo**
```
Resources:
function:
Type: [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
Properties:
TracingConfig:
Mode: Active
...
```
Para un recurso AWS Serverless Application Model de AWS SAM (`AWS::Serverless::Function`) , utilice la propiedad `Tracing`.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml): configuración de rastreo**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
Tracing: Active
...
```
## Interpretación de un seguimiento de X-Ray
La función necesita permiso para cargar datos de rastreo en X-Ray. Cuando activa el rastreo activo en la consola de Lambda, Lambda agrega los permisos necesarios al [rol de ejecución](lambda-intro-execution-role.md) de la función. De lo contrario, agregue la política [AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess) al rol de ejecución.
Después de configurar el seguimiento activo, se pueden observar solicitudes específicas a través de la aplicación. El [gráfico de servicios de X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html#xray-concepts-servicegraph) muestra información sobre la aplicación y todos sus componentes. En el siguiente ejemplo, se muestra una aplicación con dos funciones. La función principal procesa eventos y, a veces, devuelve errores. La segunda función de la cadena procesa los errores que aparecen en el primer grupo de registros y utiliza el SDK de AWS para llamar a X-Ray, Amazon Simple Storage Service (Amazon S3) y Registros de Amazon CloudWatch.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/sample-errorprocessor-servicemap.png)
X-Ray no sigue todas las solicitudes realizadas a la aplicación. X-Ray aplica un algoritmo de muestreo para garantizar que el seguimiento sea eficiente, a la vez que proporciona una muestra representativa de todas las solicitudes. La tasa de muestreo es 1 solicitud por segundo y un 5 por ciento de las solicitudes adicionales. La frecuencia de muestreo de X-Ray no se puede configurar para las funciones.
En X-Ray, un *seguimiento* registra información sobre una solicitud procesada por uno o varios *servicios*. Lambda registra 2 segmentos por seguimiento, lo que crea dos nodos en el gráfico de servicios. La siguiente imagen resalta estos dos nodos:
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/xray-servicemap-function.png)
El primer nodo, situado a la izquierda, representa el servicio de Lambda, que recibe la solicitud de invocación. El segundo nodo representa la función Lambda específica. En el siguiente ejemplo, se muestra un seguimiento con estos dos segmentos. Ambos se denominan **my-function**, pero uno tiene un origen de `AWS::Lambda` y el otro tiene origen de `AWS::Lambda::Function`. Si el segmento `AWS::Lambda` muestra un error, el servicio Lambda tuvo un problema. Si el segmento `AWS::Lambda::Function` muestra un error, la función tuvo un problema.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)
En este ejemplo, el segmento `AWS::Lambda::Function` aparece ampliado para mostrar los tres subsegmentos.
**nota**
AWS está implementando cambios en el servicio Lambda. Debido a estos cambios, es posible que vea pequeñas diferencias entre la estructura y el contenido de los mensajes de registro del sistema y los segmentos de rastro emitidos por diferentes funciones de Lambda en su Cuenta de AWS.
El rastro de ejemplo que se muestra aquí ilustra el segmento de función de estilo antiguo. Las diferencias entre los segmentos de estilo antiguo y nuevo se describen en los párrafos siguientes.
Estos cambios se implementarán en las próximas semanas y todas las funciones de todas las Regiones de AWS, excepto en las regiones de China y GovCloud, pasarán a utilizar el nuevo formato de mensajes de registro y segmentos de rastro.
El segmento de función de estilo antiguo contiene los siguientes subsegmentos:
+ **Inicialización**: representa el tiempo dedicado a cargar la función y ejecutar el [código de inicialización](foundation-progmodel.md). Este subsegmento aparece únicamente para el primer evento que procesa cada instancia de la función.
+ **Invocación**: representa el tiempo dedicado a ejecutar el código del controlador.
+ **Sobrecarga**: representa el tiempo que el tiempo de ejecución de Lambda dedica a prepararse para gestionar el siguiente evento.
El segmento de función de estilo nuevo no contiene ningún subsegmento de `Invocation`. En cambio, los subsegmentos de clientes se adjuntan directamente al segmento de la función. Para obtener más información sobre la estructura de los segmentos de funciones de estilo antiguo y nuevo, consulte [Comprensión de los rastros](services-xray.md#services-xray-traces).
También puede instrumentar clientes HTTP, registrar consultas SQL y crear subsegmentos personalizados con anotaciones y metadatos. Para obtener más información, consulte [AWS X-Ray SDK para Python](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html) en la *Guía para desarrolladores de AWS X-Ray*.
**Precios**
Puede utilizar el seguimiento de X-Ray de manera gratuita cada mes hasta un límite determinado como parte del nivel Gratuito de AWS. A partir de ese umbral, X-Ray realiza cargos por almacenamiento y recuperación del seguimiento. Para más información, consulte [Precios de AWS X-Ray](https://aws.amazon.com/xray/pricing/).
## Almacenamiento de dependencias de tiempo de ejecución en una capa (X-Ray SDK)
Si utiliza el X-Ray SDK para instrumentar el código de las funciones de los clientes del SDK de AWS, el paquete de implementación puede llegar a ser bastante grande. Para evitar que se carguen dependencias en tiempo de ejecución cada vez que se actualice el código de las funciones, empaquete el X-Ray SDK en una [capa de Lambda](chapter-layers.md).
El siguiente ejemplo muestra un recurso `AWS::Serverless::LayerVersion` que almacena el AWS X-Ray SDK para Python.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-python/template.yml): capa de dependencias.**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
CodeUri: function/.
Tracing: Active
Layers:
- !Ref libs
...
libs:
Type: [AWS::Serverless::LayerVersion](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-layerversion.html)
Properties:
LayerName: blank-python-lib
Description: Dependencies for the blank-python sample app.
ContentUri: package/.
CompatibleRuntimes:
- python3.11
```
Con esta configuración, solo se actualiza la capa de la biblioteca si se modifican las dependencias del tiempo de ejecución. Dado que el paquete de implementación de la función contiene únicamente el código, esto puede ayudar a reducir los tiempos de carga.
Para crear una capa de dependencias, es necesario realizar cambios en la compilación para generar el archivo de capas antes de la implementación. Para ver un ejemplo de trabajo, consulte la aplicación de ejemplo [blank-python](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-python).