# Trabalho com camadas para funções do Lambda com Node.js
<a name="nodejs-layers"></a>

Use [camadas do Lambda](chapter-layers.md) 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](runtimes-custom.md) 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.

1. Criar a camada no Lambda.

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

**Topics**
+ [

## Empacotar o conteúdo da sua camada
](#nodejs-layers-package)
+ [

## Criar a camada no Lambda
](#publishing-layer)
+ [

## Adicionar a camada à função
](#nodejs-layer-adding)
+ [

## Aplicação de amostra
](#nodejs-layer-sample-app)

## Empacotar o conteúdo da sua camada
<a name="nodejs-layers-package"></a>

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 24, use o runtime do Node.js 24 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](packaging-layers.md#packaging-layers-paths).
+ 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.

### Dependências de terceiros
<a name="nodejs-layers-third-party-dependencies"></a>

**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](https://www.npmjs.com/package/sharp) ou [bcrypt](https://www.npmjs.com/package/bcrypt)), certifique-se de que sejam compatíveis com o ambiente Linux do Lambda e com a [arquitetura](foundation-arch.md) 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.

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

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

**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
   ```

1. Crie um arquivo `package.json` para seu módulo personalizado a fim de definir como ele deve ser importado:  
**Example nodejs/node\$1modules/validator/package.json**  

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

1. Crie o arquivo do 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. 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
   ```

1. 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 teste](testing-functions.md#invoke-with-event)para 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
<a name="publishing-layer"></a>

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](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) para criar a camada do Lambda:

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

O parâmetro [runtimes compatíveis](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) é 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](https://console.aws.amazon.com/lambda/home#/layers) (Camadas) do console do Lambda.

1. Escolha **Criar camada**.

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

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

1. Escolha **Criar**.

------

## Adicionar a camada à função
<a name="nodejs-layer-adding"></a>

------
#### [ AWS CLI ]

Para anexar a camada à função, execute o comando da AWS CLI [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) . 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](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"
```

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](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) 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](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda.

1. Escolha a função.

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

1. Em **Escolher uma camada**, selecione **Camadas personalizadas** e depois escolha a camada.
**nota**  
Se você não adicionou um [runtime compatível](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) ao criar a camada, ela não estará listada aqui. Em vez disso, você pode especificar o ARN da camada.

1. Escolha **Adicionar**.

------

## Aplicação de amostra
<a name="nodejs-layer-sample-app"></a>

Para obter mais exemplos de como usar camadas do Lambda, consulte a aplicação de amostra [layer-nodejs](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-nodejs) no repositório AWS Lambda Developer Guide do GitHub. Essa aplicação inclui uma camada que contém a biblioteca [lodash](https://www.npmjs.com/package/lodash). Após criar a camada, você pode implantar e invocar as funções correspondentes para confirmar que ela funciona conforme o esperado.