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 Java
<a name="java-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](#java-layers-package)
+ [Crea il layer in Lambda](#publishing-layer)
+ [Aggiungete il layer alla vostra funzione](#java-layer-adding)

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

Per creare un layer, raggruppa i pacchetti in un archivio di file.zip che soddisfi i seguenti requisiti:
+ Assicurati che la versione Java a cui fanno riferimento Maven o Gradle sia la stessa della versione Java della funzione che intendi distribuire. Ad esempio, per una funzione Java 25, il `mvn -v` comando dovrebbe elencare Java 25 nell'output.
+ Le dipendenze devono essere archiviate nella `java/lib` directory, alla radice del file.zip. 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 Java di terze parti o moduli e pacchetti Java personalizzati. La procedura seguente utilizza Maven. Puoi anche usare Gradle per impacchettare il contenuto del tuo layer.

**Per creare un livello utilizzando le dipendenze di Maven**

1. Crea un progetto Apache Maven con un `pom.xml` file che definisce le tue dipendenze.

   L'esempio seguente include [Jackson Databind](https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind) per l'elaborazione JSON. La `<build>` sezione utilizza il [maven-dependency-plugin](https://mvnrepository.com/artifact/org.apache.maven.plugins/maven-dependency-plugin)per creare file JAR separati per ogni dipendenza invece di raggrupparli in un unico uber-jar. Se vuoi creare un uber-jar, usa il. [maven-shade-plugin](https://maven.apache.org/plugins/maven-shade-plugin/)  
**Example pom.xml**  

   ```
   <dependencies>
       <dependency>
           <groupId>com.fasterxml.jackson.core</groupId>
           <artifactId>jackson-databind</artifactId>
           <version>2.17.0</version>
       </dependency>
   </dependencies>
   
   <build>
       <plugins>
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-compiler-plugin</artifactId>
               <version>3.13.0</version>
               <configuration>
                   <source>21</source>
                   <target>21</target>
                   <release>21</release>
               </configuration>
           </plugin>
           
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-dependency-plugin</artifactId>
               <version>3.6.1</version>
               <executions>
                   <execution>
                       <id>copy-dependencies</id>
                       <phase>package</phase>
                       <goals>
                           <goal>copy-dependencies</goal>
                       </goals>
                       <configuration>
                           <outputDirectory>${project.build.directory}/lib</outputDirectory>
                       </configuration>
                   </execution>
               </executions>
           </plugin>
       </plugins>
   </build>
   ```

1. Compilare il progetto. Questo comando crea tutti i file JAR di dipendenza nella directory. `target/lib/`

   ```
   mvn clean package
   ```

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

   ```
   mkdir -p java/lib
   ```

1. Copia i file JAR delle dipendenze nella `java/lib` directory:

   ```
   cp target/lib/*.jar java/lib/
   ```

1. Comprimi il contenuto del livello:

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

   ```
   zip -r layer.zip java/
   ```

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

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

------

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

   ```
   java/              
   └── lib/
       ├── jackson-databind-2.17.0.jar
       ├── jackson-core-2.17.0.jar
       └── jackson-annotations-2.17.0.jar
   ```
**Nota**  
Assicurati che il tuo file.zip includa la `java` directory a livello principale al `lib` suo interno. Questa struttura assicura che Lambda possa localizzare e importare le tue librerie. Ogni dipendenza viene conservata come file JAR separato anziché raggruppata in un uber-jar.

## 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 java25
```

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 Java che corrisponde alla versione Java utilizzata per creare il layer.

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

------

## Aggiungete il layer alla vostra funzione
<a name="java-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**.

------