# Uso de capas para funciones de Lambda en Node.js
<a name="nodejs-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.
](#nodejs-layers-package)
+ [

## Creación de la capa en Lambda
](#publishing-layer)
+ [

## Adición de la capa a la función
](#nodejs-layer-adding)
+ [

## Aplicación de ejemplo
](#nodejs-layer-sample-app)

## Empaquete el contenido de su capa.
<a name="nodejs-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 Node.js que tiene previsto usar para la función de Lambda. Por ejemplo, si crea una capa con Node.js 24, use el tiempo de ejecución de Node.js 24 para su función.
+ El archivo .zip de su capa debe usar una de estas estructuras de directorios:
  + `nodejs/node_modules`
  + `nodejs/nodeX/node_modules`(donde *X* es su versión de Node.js, por ejemplo `node22`)

  Para obtener más información, consulte [Rutas de capa para cada tiempo de ejecución de Lambda](packaging-layers.md#packaging-layers-paths).
+ 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 Node.js de terceros instaladas con `npm` (como `axios` o `lodash`) o sus propios módulos y paquetes de JavaScript.

### Dependencias de terceros
<a name="nodejs-layers-third-party-dependencies"></a>

**Creación de una capa con paquetes npm**

1. Cree la estructura de directorios necesaria e instale los paquetes directamente allí:

   ```
   mkdir -p nodejs
   npm install --prefix nodejs lodash axios
   ```

   Este comando instala los paquetes directamente en el directorio `nodejs/node_modules`, que es la estructura que Lambda requiere.
**nota**  
Para los paquetes con dependencias nativas o componentes binarios (como [sharp](https://www.npmjs.com/package/sharp) o [bcrypt](https://www.npmjs.com/package/bcrypt)), asegúrese de que sean compatibles con el entorno Lambda Linux y la [arquitectura](foundation-arch.md) de su función. Es posible que necesite usar la bandera `--platform`:  

   ```
   npm install --prefix nodejs --platform=linux --arch=x64 sharp
   ```
En el caso de dependencias nativas más complejas, es posible que deba compilarlas en un entorno Linux que coincida con el tiempo de ejecución de Lambda. Puede utilizar Docker para hacerlo.

1. Comprima en formato zip el contenido de la capa:

------
#### [ Linux/macOS ]

   ```
   zip -r layer.zip nodejs/
   ```

------
#### [ PowerShell ]

   ```
   Compress-Archive -Path .\nodejs -DestinationPath .\layer.zip
   ```

------

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

   ```
   nodejs/
   ├── package.json
   ├── package-lock.json
   └── node_modules/
       ├── lodash/
       ├── axios/
       └── (dependencies of the other packages)
   ```
**nota**  
Asegúrese de que su archivo .zip incluya el directorio `nodejs` en el nivel raíz con `node_modules` en su interior. Esta estructura garantiza que Lambda pueda localizar e importar sus paquetes.
npm utiliza los archivos `package.json` y `package-lock.json` del directorio `nodejs/` para la administración de dependencias, pero Lambda no los requiere para la funcionalidad de las capas. Cada paquete instalado ya contiene su propio archivo `package.json` que define cómo Lambda importa el paquete.

### Módulos personalizados de JavaScript
<a name="custom-nodejs-modules"></a>

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

1. Cree la estructura del directorio necesario para su capa:

   ```
   mkdir -p nodejs/node_modules/validator
   cd nodejs/node_modules/validator
   ```

1. Cree un archivo `package.json` para su módulo personalizado para definir cómo debe importarse:  
**Example nodejs/node\$1modules/validator/package.json**  

   ```
   {
     "name": "validator",
     "version": "1.0.0",
     "type": "module",
     "main": "index.mjs"
   }
   ```

1. Cree su archivo de módulo JavaScript:  
**Example nodejs/node\$1modules/validator/index.mjs**  

   ```
   export function validateOrder(orderData) {
     // Validates an order and returns formatted data
     const requiredFields = ['productId', 'quantity'];
     
     // Check required fields
     const missingFields = requiredFields.filter(field => !(field in orderData));
     if (missingFields.length > 0) {
       throw new Error(`Missing required fields: ${missingFields.join(', ')}`);
     }
     
     // Validate quantity
     const quantity = orderData.quantity;
     if (!Number.isInteger(quantity) || quantity < 1) {
       throw new Error('Quantity must be a positive integer');
     }
     
     // Format and return the validated data
     return {
       productId: String(orderData.productId),
       quantity: quantity,
       shippingPriority: orderData.priority || 'standard'
     };
   }
   
   export function formatResponse(statusCode, body) {
     // Formats the API response
     return {
       statusCode: statusCode,
       body: JSON.stringify(body)
     };
   }
   ```

1. Comprima en formato zip el contenido de la capa:

------
#### [ Linux/macOS ]

   ```
   zip -r layer.zip nodejs/
   ```

------
#### [ PowerShell ]

   ```
   Compress-Archive -Path .\nodejs -DestinationPath .\layer.zip
   ```

------

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

   ```
   nodejs/              
   └── node_modules/
       └── validator/
           ├── package.json
           └── index.mjs
   ```

1. En su función, importe y utilice los módulos. Ejemplo:

   ```
   import { validateOrder, formatResponse } from 'validator';
   
   export const handler = async (event) => {
     try {
       // Parse the order data from the event body
       const orderData = JSON.parse(event.body || '{}');
       
       // Validate and format the order
       const validatedOrder = validateOrder(orderData);
       
       return formatResponse(200, {
         message: 'Order validated successfully',
         order: validatedOrder
       });
     } catch (error) {
       if (error instanceof Error && error.message.includes('Missing required fields')) {
         return formatResponse(400, {
           error: error.message
         });
       }
       
       return formatResponse(500, {
         error: 'Internal server error'
       });
     }
   };
   ```

   Puede usar el siguiente [evento de prueba](testing-functions.md#invoke-with-event) para invocar la función:

   ```
   {
       "body": "{\"productId\": \"ABC123\", \"quantity\": 2, \"priority\": \"express\"}"
   }
   ```

   Respuesta esperada:

   ```
   {
     "statusCode": 200,
     "body": "{\"message\":\"Order validated successfully\",\"order\":{\"productId\":\"ABC123\",\"quantity\":2,\"shippingPriority\":\"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 nodejs24.x
```

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 Node.js que corresponda a la versión de Node.js que utilizó para crear la capa.

1. Seleccione **Crear**.

------

## Adición de la capa a la función
<a name="nodejs-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 **Agregar**.

------

## Aplicación de ejemplo
<a name="nodejs-layer-sample-app"></a>

Para ver más ejemplos de cómo usar las capas de Lambda, consulte la aplicación de ejemplo [layer-nodejs](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-nodejs) en el repositorio de GitHub de la Guía para desarrolladores de AWS Lambda. Esta aplicación incluye una capa que contiene la biblioteca [lodash](https://www.npmjs.com/package/lodash). Después de crear la capa, puede implementar e invocar las funciones correspondientes para confirmar que la capa funciona como se espera.