Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Utilisation de couches pour les fonctions Lambda Java
<a name="java-layers"></a>

Utilisez les [couches Lambda](chapter-layers.md) pour empaqueter le code et les dépendances que vous souhaitez réutiliser dans plusieurs fonctions. Les couches contiennent généralement des dépendances de bibliothèque, une [exécution personnalisée](runtimes-custom.md), ou des fichiers de configuration. La création d’une couche implique trois étapes générales :

1. Empaquetez le contenu de votre couche. Cela signifie créer une archive de fichiers .zip contenant les dépendances que vous souhaitez utiliser dans vos fonctions.

1. Créez la couche dans Lambda.

1. Ajoutez la couche à vos fonctions.

**Topics**
+ [Empaqueter le contenu de votre couche](#java-layers-package)
+ [Créer la couche dans Lambda](#publishing-layer)
+ [Ajouter la couche à votre fonction](#java-layer-adding)

## Empaqueter le contenu de votre couche
<a name="java-layers-package"></a>

Pour créer une couche, regroupez vos packages dans une archive (fichier .zip) répondant aux exigences suivantes :
+ Assurez-vous que la version Java à laquelle Maven ou Gradle fait référence est identique à la version Java de la fonction que vous souhaitez déployer. Par exemple, pour une fonction Java 25, la `mvn -v` commande doit répertorier Java 25 dans la sortie.
+ Vos dépendances doivent être stockées dans le répertoire `java/lib`, à la racine du fichier .zip. Pour de plus amples informations, veuillez consulter [Chemins d’accès de couche pour chaque exécution Lambda](packaging-layers.md#packaging-layers-paths).
+ Les packages de votre couche doivent être compatibles avec Linux. Les fonctions Lambda s’exécutent sur Amazon Linux.

Vous pouvez créer des couches contenant des bibliothèques Java tierces ou vos propres modules et packages Java. La procédure suivante utilise Maven. Vous pouvez également utiliser Gradle pour empaqueter le contenu de votre couche.

**Créer une couche à l’aide de dépendances Maven**

1. Créez un projet Apache Maven avec un fichier `pom.xml` qui définit vos dépendances.

   L’exemple suivant inclut [Jackson Databind](https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind) pour le traitement JSON. La `<build>` section utilise le [maven-dependency-plugin](https://mvnrepository.com/artifact/org.apache.maven.plugins/maven-dependency-plugin)pour créer des fichiers JAR distincts pour chaque dépendance au lieu de les regrouper dans un seul uber-jar. Si vous souhaitez créer un uber-jar, utilisez le. [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. Générez le projet. Cette commande crée tous les fichiers JAR de dépendance dans le répertoire `target/lib/`.

   ```
   mvn clean package
   ```

1. Créez la structure de répertoires requise pour votre couche :

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

1. Copiez les fichiers JAR de dépendance dans le répertoire `java/lib` :

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

1. Compressez le contenu de la couche :

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

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

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

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

------

   La structure de répertoire de votre fichier .zip devrait se présenter comme suit :

   ```
   java/              
   └── lib/
       ├── jackson-databind-2.17.0.jar
       ├── jackson-core-2.17.0.jar
       └── jackson-annotations-2.17.0.jar
   ```
**Note**  
Assurez-vous que votre fichier .zip inclut le répertoire `java` au niveau racine avec `lib` à l’intérieur. Cette structure garantit que Lambda peut localiser et importer vos bibliothèques. Chaque dépendance est conservée dans un fichier JAR distinct plutôt que regroupée dans un fichier uber-jar.

## Créer la couche dans Lambda
<a name="publishing-layer"></a>

Vous pouvez publier votre couche à l'aide de la console Lambda AWS CLI ou de la console Lambda.

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

Exécutez la [publish-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) AWS CLI commande pour créer la couche Lambda :

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

Le paramètre [compatible runtimes](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) est facultatif. Lorsqu’il est spécifié, Lambda utilise ce paramètre pour filtrer les couches dans la console Lambda.

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

**Pour créer une couche (console)**

1. Ouvrez la [page Couches](https://console.aws.amazon.com/lambda/home#/layers) de la console Lambda.

1. Sélectionnez **Créer un calque**.

1. Choisissez **Charger un fichier .zip**, puis chargez l’archive .zip que vous avez créée précédemment.

1. (Facultatif) Pour **Environnements d’exécution compatibles**, choisissez l’environnement d’exécution Java qui correspond à la version de Java que vous avez utilisée pour créer votre couche.

1. Choisissez **Créer**.

------

## Ajouter la couche à votre fonction
<a name="java-layer-adding"></a>

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

Pour associer la couche à votre fonction, exécutez la [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) AWS CLI commande. Utilisez l’ARN de la couche pour le paramètre `--layers`. L’ARN doit spécifier la version (par exemple, `arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1`). Pour de plus amples informations, veuillez consulter [Couches et versions de couches](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**option est obligatoire si vous utilisez AWS CLI la version 2. Pour faire de ce paramètre le paramètre par défaut, exécutez `aws configure set cli-binary-format raw-in-base64-out`. Pour plus d’informations, consultez les [options de ligne de commande globales AWS CLI prises en charge](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) dans le *Guide de l’utilisateur AWS Command Line Interface version 2*.

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

**Ajouter une couche à une fonction**

1. Ouvrez la [page Functions](https://console.aws.amazon.com/lambda/home#/functions) (Fonctions) de la console Lambda.

1. Choisissez la fonction.

1. Faites défiler jusqu’à la section **Couches**, puis choisissez **Ajouter une couche**.

1. Sous **Choisir une couche**, sélectionnez **Couches personnalisées**, puis choisissez votre couche.
**Note**  
Si vous n’avez pas ajouté d’[environnement d’exécution compatible](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) lors de la création de la couche, celle-ci ne sera pas répertoriée ici. Vous pouvez spécifier l’ARN de la couche à la place.

1. Choisissez **Ajouter**.

------