Uso de capas para funciones de Lambda en Node.js - AWS Lambda
Empaquete el contenido de su capa.Creación de la capa en LambdaAdición de la capa a la funciónAplicación de ejemplo

Uso de capas para funciones de Lambda en Node.js

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:

  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.

  2. Cree la capa en Lambda.

  3. 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 Node.js que tiene previsto usar para la función de Lambda. Por ejemplo, si crea una capa con Node.js 22, use el tiempo de ejecución de Node.js 22 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.

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

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 o bcrypt), asegúrese de que sean compatibles con el entorno Lambda Linux y la arquitectura 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.

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

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

  2. Cree un archivo package.json para su módulo personalizado para definir cómo debe importarse:

    ejemplo nodejs/node_modules/validator/package.json
    {
  "name": "validator",
  "version": "1.0.0",
  "type": "module",
  "main": "index.mjs"
}

  3. Cree su archivo de módulo JavaScript:

    ejemplo nodejs/node_modules/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)
  };
}

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

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

También puede publicar la capa con la AWS CLI o la consola de Lambda.

AWS CLI

Ejecute el comando publish-layer-version 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 nodejs22.x

El parámetro Tiempos de ejecución compatibles 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 de la consola de Lambda.

  2. Elija Crear capa.

  3. Elija Cargar un archivo .zip y, a continuación, cargue el archivo .zip que creó anteriormente.

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

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

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 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 en la consola de Lambda.

  2. Elija la función.

  3. Desplácese hacia abajo hasta la sección Capas y, a continuación, elija Agregar una capa.

  4. En Elija una capa, seleccione Capas personalizadas y, a continuación, elija su capa.

    nota

    Si no agregó un tiempo de ejecución compatible al crear la capa, su capa no aparecerá aquí. Puede especificar el ARN de la capa en su lugar.

  5. Elija Agregar.

Aplicación de ejemplo

Para ver más ejemplos de cómo usar las capas de Lambda, consulte la aplicación de ejemplo 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. Después de crear la capa, puede implementar e invocar las funciones correspondientes para confirmar que la capa funciona como se espera.