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 in Python
<a name="python-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
](#python-layers-package)
+ [

## Crea il layer in Lambda
](#publishing-layer)
+ [

## Aggiungi il layer alla tua funzione
](#python-layer-adding)
+ [

## App di esempio
](#python-layer-sample-app)

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

Per creare un layer, raggruppa i pacchetti in un archivio di file.zip che soddisfi i seguenti requisiti:
+ Costruite il layer utilizzando la stessa versione di Python che intendete utilizzare per la funzione Lambda. Ad esempio, se crei il tuo layer usando Python 3.14, usa il runtime Python 3.14 per la tua funzione.
+ Il file.zip deve includere una `python` directory a livello root.
+ I pacchetti del livello devono essere compatibili con Linux. Le funzioni Lambda vengono eseguite su Amazon Linux.

È possibile creare livelli che contengono librerie Python di terze parti installate con `pip` (come `requests` o`pandas`) o moduli e pacchetti Python personalizzati.

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

**Per creare un livello utilizzando pacchetti pip**

1. Scegliete uno dei seguenti metodi per installare `pip` i pacchetti nella directory di primo livello richiesta ()`python/`:

------
#### [ pip install ]

   Per pacchetti Python puri (come requests o boto3):

   ```
   pip install requests -t python/
   ```

   Alcuni pacchetti Python, come NumPy e Pandas, includono componenti C compilati. Se state creando un layer con questi pacchetti su macOS o Windows, potreste aver bisogno di usare questo comando per installare una ruota compatibile con Linux:

   ```
   pip install numpy --platform manylinux2014_x86_64 --only-binary=:all: -t python/
   ```

   Per ulteriori informazioni sull'utilizzo dei pacchetti Python che contengono componenti compilati, vedere. [Creazione di un pacchetto di implementazione .zip con librerie native](python-package.md#python-package-native-libraries)

------
#### [ requirements.txt ]

   L'utilizzo di un `requirements.txt` file consente di gestire le versioni dei pacchetti e garantire installazioni coerenti.

**Example requirements.txt**  

   ```
   requests==2.31.0
   boto3==1.37.34
   numpy==1.26.4
   ```

   Se il tuo `requirements.txt` file include solo pacchetti Python puri (come requests o boto3):

   ```
   pip install -r requirements.txt -t python/
   ```

   Alcuni pacchetti Python, come NumPy e Pandas, includono componenti C compilati. Se state creando un layer con questi pacchetti su macOS o Windows, potreste aver bisogno di usare questo comando per installare una ruota compatibile con Linux:

   ```
   pip install -r requirements.txt --platform manylinux2014_x86_64 --only-binary=:all: -t python/
   ```

   Per ulteriori informazioni sull'utilizzo dei pacchetti Python che contengono componenti compilati, vedere. [Creazione di un pacchetto di implementazione .zip con librerie native](python-package.md#python-package-native-libraries)

------

1. Comprimi il contenuto della `python` directory.

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

   ```
   zip -r layer.zip python/
   ```

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

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

------

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

   ```
   python/              # Required top-level directory
   └── requests/
   └── boto3/
   └── numpy/
   └── (dependencies of the other packages)
   ```
**Nota**  
Se usi un ambiente virtuale Python (venv) per installare i pacchetti, la struttura delle cartelle sarà diversa (ad esempio,). `python/lib/python3.x/site-packages` Finché il file.zip include la `python` directory a livello principale, Lambda può localizzare e importare i pacchetti.

### Moduli Python personalizzati
<a name="custom-python-modules"></a>

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

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

   ```
   mkdir python
   ```

1. Crea i tuoi moduli Python nella `python` directory. Il seguente modulo di esempio convalida gli ordini confermando che contengono le informazioni richieste.  
**Example modulo personalizzato: validator.py**  

   ```
   import json
   
   def validate_order(order_data):
       """Validates an order and returns formatted data."""
       required_fields = ['product_id', 'quantity']
       
       # Check required fields
       missing_fields = [field for field in required_fields if field not in order_data]
       if missing_fields:
           raise ValueError(f"Missing required fields: {', '.join(missing_fields)}")
       
       # Validate quantity
       quantity = order_data['quantity']
       if not isinstance(quantity, int) or quantity < 1:
           raise ValueError("Quantity must be a positive integer")
       
       # Format and return the validated data
       return {
           'product_id': str(order_data['product_id']),
           'quantity': quantity,
           'shipping_priority': order_data.get('priority', 'standard')
       }
   
   def format_response(status_code, body):
       """Formats the API response."""
       return {
           'statusCode': status_code,
           'body': json.dumps(body)
       }
   ```

1. Comprimi il contenuto della `python` directory.

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

   ```
   zip -r layer.zip python/
   ```

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

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

------

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

   ```
   python/     # Required top-level directory
   └── validator.py
   ```

1. Nella tua funzione, importa e usa i moduli come faresti con qualsiasi pacchetto Python. Esempio:

   ```
   from validator import validate_order, format_response
   import json
   
   def lambda_handler(event, context):
       try:
           # Parse the order data from the event body
           order_data = json.loads(event.get('body', '{}'))
           
           # Validate and format the order
           validated_order = validate_order(order_data)
           
           return format_response(200, {
               'message': 'Order validated successfully',
               'order': validated_order
           })
       except ValueError as e:
           return format_response(400, {
               'error': str(e)
           })
       except Exception as e:
           return format_response(500, {
               'error': 'Internal server error'
           })
   ```

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

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

   Risposta prevista:

   ```
   {
     "statusCode": 200,
     "body": "{\"message\": \"Order validated successfully\", \"order\": {\"product_id\": \"ABC123\", \"quantity\": 2, \"shipping_priority\": \"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 python3.14
```

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 Python che corrisponde alla versione di Python che avete usato per creare il layer.

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

------

## Aggiungi il layer alla tua funzione
<a name="python-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="python-layer-sample-app"></a>

Per altri esempi di utilizzo dei layer Lambda, consultate l'applicazione di esempio [layer-python](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-python) nel repository Developer Guide. AWS Lambda GitHub Questa applicazione include due livelli che contengono librerie Python. Dopo aver creato i livelli, è possibile distribuire e richiamare le funzioni corrispondenti per confermare che i livelli funzionino come previsto.