Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Utilizzo dei livelli per le funzioni Lambda Node.js
<a name="nodejs-layers"></a>

Usa i [livelli Lambda](chapter-layers.md) per impacchettare codice e dipendenze che desideri riutilizzare in più funzioni. I livelli di solito contengono dipendenze dalla libreria, un [runtime personalizzato](runtimes-custom.md) o file di configurazione. La creazione di un livello prevede tre passaggi generali:

1. Crea un pacchetto per il contenuto del livello. Ciò significa creare un archivio di file con estensione .zip che contiene le dipendenze che desideri utilizzare nelle funzioni.

1. Crea il livello in Lambda.

1. Aggiungi il livello alle tue funzioni.

**Topics**
+ [Crea un pacchetto per il contenuto del livello](#nodejs-layers-package)
+ [Crea il layer in Lambda](#publishing-layer)
+ [Aggiungete il layer alla vostra funzione](#nodejs-layer-adding)
+ [App di esempio](#nodejs-layer-sample-app)

## Crea un pacchetto per il contenuto del livello
<a name="nodejs-layers-package"></a>

Per creare un layer, raggruppa i pacchetti in un archivio di file.zip che soddisfi i seguenti requisiti:
+ Create il layer utilizzando la stessa versione di Node.js che intendete utilizzare per la funzione Lambda. Ad esempio, se create il layer utilizzando Node.js 24, utilizzate il runtime Node.js 24 per la funzione.
+ Il file.zip del livello deve utilizzare una di queste strutture di directory:
  + `nodejs/node_modules`
  + `nodejs/nodeX/node_modules`(*X*dov'è la versione di Node.js, ad esempio`node22`)

  Per ulteriori informazioni, consulta [Percorsi dei livelli per ciascun runtime Lambda](packaging-layers.md#packaging-layers-paths).
+ I pacchetti del livello devono essere compatibili con Linux. Le funzioni Lambda vengono eseguite su Amazon Linux.

Puoi creare livelli che contengono librerie Node.js di terze parti installate con `npm` (come `axios` or`lodash`) o JavaScript moduli personalizzati.

### Dipendenze da terze parti
<a name="nodejs-layers-third-party-dependencies"></a>

**Per creare un livello utilizzando i pacchetti npm**

1. Crea la struttura di directory richiesta e installa i pacchetti direttamente al suo interno:

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

   Questo comando installa i pacchetti direttamente nella `nodejs/node_modules` directory, che è la struttura richiesta da Lambda.
**Nota**  
[Per i pacchetti con dipendenze native o componenti binari (come [sharp](https://www.npmjs.com/package/sharp) o [bcrypt](https://www.npmjs.com/package/bcrypt)), assicurati che siano compatibili con l'ambiente Lambda Linux e l'architettura della tua funzione.](foundation-arch.md) Potrebbe essere necessario utilizzare il flag: `--platform`  

   ```
   npm install --prefix nodejs --platform=linux --arch=x64 sharp
   ```
Per dipendenze native più complesse, potrebbe essere necessario compilarle in un ambiente Linux che corrisponda al runtime Lambda. Puoi usare Docker per questo scopo.

1. Comprimi il contenuto del livello:

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

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

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

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

------

   La struttura delle cartelle del file.zip dovrebbe essere simile alla seguente:

   ```
   nodejs/
   ├── package.json
   ├── package-lock.json
   └── node_modules/
       ├── lodash/
       ├── axios/
       └── (dependencies of the other packages)
   ```
**Nota**  
Assicurati che il tuo file.zip includa la `nodejs` directory a livello principale al `node_modules` suo interno. Questa struttura assicura che Lambda possa localizzare e importare i tuoi pacchetti.
I file `package.json` e `package-lock.json` nella directory `nodejs/` vengono utilizzati da npm per la gestione delle dipendenze ma non sono richiesti da Lambda per la funzionalità dei livelli. Ogni pacchetto installato contiene già il proprio `package.json` file che definisce il modo in cui Lambda importa il pacchetto.

### Moduli personalizzati JavaScript
<a name="custom-nodejs-modules"></a>

**Per creare un livello utilizzando il proprio codice**

1. Crea la struttura di directory richiesta per il tuo livello:

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

1. Crea un `package.json` file per il tuo modulo personalizzato per definire come deve essere importato:  
**Example nodejs/node\$1modules/validator/package.json**  

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

1. Crea il tuo file del JavaScript modulo:  
**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. Comprimi il contenuto del livello:

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

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

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

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

------

   La struttura delle cartelle del file.zip dovrebbe essere simile alla seguente:

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

1. Nella tua funzione, importa e usa i moduli. Esempio:

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

   È possibile utilizzare il seguente [evento di test](testing-functions.md#invoke-with-event) per richiamare la funzione:

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

   Risposta prevista:

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

## Crea il layer in Lambda
<a name="publishing-layer"></a>

È possibile pubblicare il layer utilizzando la console AWS CLI o la console Lambda.

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

Esegui il [publish-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) AWS CLI comando per creare il livello Lambda:

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

Il parametro di [runtime compatibile](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) è facoltativo. Quando specificato, Lambda utilizza questo parametro per filtrare i livelli nella console Lambda.

------
#### [ Console ]

**Creazione di un livello (console)**

1. Apri la [pagina Layers](https://console.aws.amazon.com/lambda/home#/layers) (Livelli) nella console Lambda.

1. Scegli **Create layer** (Crea livello).

1. Scegli **Carica un file.zip**, quindi carica l'archivio.zip che hai creato in precedenza.

1. (Facoltativo) Per i **runtime compatibili**, scegliete il runtime Node.js che corrisponde alla versione Node.js utilizzata per creare il layer.

1. Scegli **Create** (Crea).

------

## Aggiungete il layer alla vostra funzione
<a name="nodejs-layer-adding"></a>

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

Per collegare il layer alla tua funzione, esegui il [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) AWS CLI comando. Per il `--layers` parametro, utilizzate il livello ARN. L'ARN deve specificare la versione (ad esempio,`arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1`). Per ulteriori informazioni, consulta [Livelli e versioni di livelli](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"
```

L'**cli-binary-format**opzione è obbligatoria se si utilizza la AWS CLI versione 2. Per rendere questa impostazione come predefinita, esegui `aws configure set cli-binary-format raw-in-base64-out`. Per ulteriori informazioni, consulta la pagina [AWS CLI supported global command line options](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) nella *Guida per l'utente di AWS Command Line Interface versione 2*.

------
#### [ Console ]

**Aggiunta di un livello a una funzione**

1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.

1. Scegli la funzione.

1. Scorri verso il basso fino alla sezione **Livelli**, quindi scegli **Aggiungi un livello**.

1. In **Scegli un livello**, seleziona **Livelli personalizzati**, quindi scegli il tuo livello.
**Nota**  
Se non hai aggiunto un [runtime compatibile](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) quando hai creato il layer, il tuo layer non verrà elencato qui. È possibile specificare invece il livello ARN.

1. Scegliere **Aggiungi**.

------

## App di esempio
<a name="nodejs-layer-sample-app"></a>

Per altri esempi di utilizzo dei layer Lambda, consulta l'applicazione di esempio [layer-nodejs](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-nodejs) nel repository Developer Guide. AWS Lambda GitHub [Questa applicazione include un livello che contiene la libreria lodash.](https://www.npmjs.com/package/lodash) Dopo aver creato il layer, è possibile implementare e richiamare la funzione corrispondente per confermare che il layer funzioni come previsto.