Empaquete el contenido de su capa.Creación de la capa en Lambda Adición de la capa a la función Aplicación de ejemplo

Uso de capas para funciones de Lambda en Python

Utilice capas de Lambda 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 o archivos de configuración. La creación de una capa implica tres pasos generales:

Empaquete el contenido de su capa. Esto significa crear un archivo de archivo. zip que contenga las dependencias que desea usar en sus funciones.
Cree la capa en Lambda.
Agregue la capa a sus funciones.

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.13, use el tiempo de ejecución de Python 3.13 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.
Si tu capa incluye archivos ejecutables o binarios nativos, deben estar orientados a la misma arquitectura (x86_64 o arm64) que tu función.

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.

Creación de una capa con paquetes pip

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.
requirements.txt
El uso de un archivo requirements.txt le ayuda a gestionar las versiones de los paquetes y a garantizar instalaciones coherentes.
ejemplo 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.
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.

Creación de una capa con su propio código

Cree el directorio de nivel superior necesario para su capa:
```
mkdir python
```

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.

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

Comprima en zip el contenido del directorio python.

La estructura de directorios del archivo .zip debería ser similar a la siguiente:

python/     # Required top-level directory
└── validator.py

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

Adición de la capa a la función

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

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

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

Convenciones del documento

Implementación de imágenes de contenedor

Context