Trabalho com camadas para funções do Lambda com Node.js - AWS Lambda
Empacotar o conteúdo da sua camadaCriar a camada no LambdaAdicionar a camada à funçãoAplicação de amostra

Trabalho com camadas para funções do Lambda com Node.js

Use camadas do Lambda para empacotar o código e as dependências que você quiser reutilizar em várias funções. As camadas geralmente contêm dependências de biblioteca, um runtime personalizado ou arquivos de configuração. A criação de uma camada envolve três etapas gerais:

  1. Empacotar o conteúdo da sua camada. Isso significa criar um arquivo .zip contendo as dependências que você deseja usar em suas funções.

  2. Criar a camada no Lambda.

  3. Adicionar a camada às suas funções.

Empacotar o conteúdo da sua camada

Para criar uma camada, reúna os pacotes em um arquivo .zip que atenda aos seguintes requisitos:

  • Crie a camada usando a mesma versão do Node.js que você planeja usar para a função do Lambda. Por exemplo, se você compilar a camada usando o Node.js 22, use o runtime do Node.js 22 para a função.

  • O arquivo .zip da camada deve usar uma destas estruturas de diretório:

    • nodejs/node_modules

    • nodejs/nodeX/node_modules (em que X é a versão do Node.js, como node22)

    Para obter mais informações, consulte Caminhos da camada para cada runtime do Lambda.

  • Os pacotes da camada devem ser compatíveis com o Linux. As funções do Lambda são executadas no Amazon Linux.

Você pode criar camadas que contenham bibliotecas Node.js de terceiros instaladas com npm (como axios ou lodash) ou seus próprios módulos JavaScript.

Para criar uma camada usando pacotes npm

  1. Crie a estrutura de diretório necessária e instale pacotes nela diretamente:

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

    Esse comando instala pacotes diretamente no diretório nodejs/node_modules, que é a estrutura exigida pelo Lambda.

    nota

    Para pacotes com dependências nativas ou componentes binários (como sharp ou bcrypt), certifique-se de que sejam compatíveis com o ambiente Linux do Lambda e com a arquitetura da função. Talvez seja necessário usar o sinalizador --platform:

    npm install --prefix nodejs --platform=linux --arch=x64 sharp

    No caso de dependências nativas mais complexas, talvez seja necessário compilá-las em um ambiente Linux que corresponda ao runtime do Lambda. É possível usar o Docker para essa finalidade.

  2. Crie um arquivo .zip do conteúdo da camada:

    Linux/macOS
    zip -r layer.zip nodejs/
    PowerShell
    Compress-Archive -Path .\nodejs -DestinationPath .\layer.zip

    A estrutura de diretórios do arquivo zip deve ser assim:

    nodejs/
├── package.json
├── package-lock.json
└── node_modules/
    ├── lodash/
    ├── axios/
    └── (dependencies of the other packages)
    nota

    • Garanta que o arquivo .zip inclua o diretório nodejs no nível raiz com node_modules dentro dele. Essa estrutura garante que o Lambda consiga localizar e importar seus pacotes.

    • Os arquivos package.json e package-lock.json no diretório nodejs/ são usados pelo npm para gerenciamento de dependências, mas não são exigidos pelo Lambda para a funcionalidade da camada. Cada pacote instalado já contém seu próprio arquivo package.json que define como o Lambda importa o pacote.

Para criar uma camada usando seu próprio código

  1. Crie a estrutura de diretório necessária para sua camada:

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

  2. Crie um arquivo package.json para seu módulo personalizado a fim de definir como ele deve ser importado:

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

  3. Crie o arquivo do módulo JavaScript:

    exemplo 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. Crie um arquivo .zip do conteúdo da camada:

    Linux/macOS
    zip -r layer.zip nodejs/
    PowerShell
    Compress-Archive -Path .\nodejs -DestinationPath .\layer.zip

    A estrutura de diretórios do arquivo zip deve ser assim:

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

  5. Na função, importe e use os módulos. Exemplo:

    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'
    });
  }
};

    Você pode usar os seguinte evento de testepara invocar a função:

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

    Resposta esperada:

    {
  "statusCode": 200,
  "body": "{\"message\":\"Order validated successfully\",\"order\":{\"productId\":\"ABC123\",\"quantity\":2,\"shippingPriority\":\"express\"}}"
}

Criar a camada no Lambda

Você pode publicar a camada usando a AWS CLI ou o console do Lambda.

AWS CLI

Execute o comando da AWS CLI publish-layer-version para criar a camada do Lambda:

aws lambda publish-layer-version --layer-name my-layer --zip-file fileb://layer.zip --compatible-runtimes nodejs22.x

O parâmetro runtimes compatíveis é opcional. Quando especificado, o Lambda usa esse parâmetro para filtrar camadas no console do Lambda.

Console
Para criar uma camada (console)

  1. Abra a página Layers (Camadas) do console do Lambda.

  2. Escolha Criar camada.

  3. Escolha Carregar um arquivo .zip e depois carregue o arquivo .zip que você criou anteriormente.

  4. (Opcional) Para ver quais são os runtimes compatíveis, escolha o runtime do Node.js que corresponde à versão do Node.js que você usou para criar a camada.

  5. Escolha Criar.

Adicionar a camada à função

AWS CLI

Para anexar a camada à função, execute o comando da AWS CLI update-function-configuration . Para o parâmetro --layers use o ARN da camada. O ARN deve especificar a versão (por exemplo, arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1). Para obter mais informações, consulte Camadas e versões da camada.

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"

A opção cli-binary-format será necessária se você estiver usando a AWS CLI versão 2. Para que essa seja a configuração padrão, execute aws configure set cli-binary-format raw-in-base64-out. Para obter mais informações, consulte A AWS CLI comporta opções de linha de comando globais no Guia do usuário da AWS Command Line Interface versão 2.

Console
Para adicionar uma camada a uma função

  1. Abra a página Funções do console do Lambda.

  2. Escolha a função.

  3. Role a tela para baixo até a seção Camadas e depois escolha Adicionar uma camada.

  4. Em Escolher uma camada, selecione Camadas personalizadas e depois escolha a camada.

    nota

    Se você não adicionou um runtime compatível ao criar a camada, ela não estará listada aqui. Em vez disso, você pode especificar o ARN da camada.

  5. Escolha Adicionar.

Aplicação de amostra

Para obter mais exemplos de como usar camadas do Lambda, consulte a aplicação de amostra layer-nodejs no repositório AWS Lambda Developer Guide do GitHub. Essa aplicação inclui uma camada que contém a biblioteca lodash. Após criar a camada, você pode implantar e invocar as funções correspondentes para confirmar que ela funciona conforme o esperado.