# Uso de capas para funciones de Lambda en Python
<a name="python-layers"></a>

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.
<a name="python-layers-package"></a>

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
<a name="python-layers-third-party-dependencies"></a>

**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
<a name="custom-python-modules"></a>

**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
<a name="publishing-layer"></a>

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
<a name="python-layer-adding"></a>

------
#### [ 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
<a name="python-layer-sample-app"></a>

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.