Prérequis Outils et bibliothèques Création d’un package de déploiement avec Gradle Création d’une couche Java pour vos dépendances Création d’un package de déploiement avec Maven Chargement d’un package de déploiement avec la console Lambda Téléchargement d'un package de déploiement à l'aide du AWS CLI Téléchargement d'un package de déploiement avec AWS SAM

Déployer des fonctions Lambda en Java avec des archives de fichiers .zip ou JAR

Le code de votre AWS Lambda fonction se compose de scripts ou de programmes compilés et de leurs dépendances. Pour déployer votre code de fonction vers Lambda, vous utilisez un package de déploiement. Lambda prend en charge deux types de packages de déploiement : les images conteneurs et les archives de fichiers .zip.

Cette page explique comment créer votre package de déploiement sous forme de fichier .zip ou Jar, puis utiliser le package de déploiement pour déployer votre code de fonction à AWS Lambda l'aide de AWS Command Line Interface (AWS CLI).

Sections

Prérequis
Outils et bibliothèques
Création d’un package de déploiement avec Gradle
Création d’une couche Java pour vos dépendances
Création d’un package de déploiement avec Maven
Chargement d’un package de déploiement avec la console Lambda
Téléchargement d'un package de déploiement à l'aide du AWS CLI
Téléchargement d'un package de déploiement avec AWS SAM

Prérequis

AWS CLI Il s'agit d'un outil open source qui vous permet d'interagir avec les AWS services à l'aide de commandes dans votre interface de ligne de commande. Pour exécuter la procédure indiquée dans cette section, vous devez satisfaire aux exigences suivantes :

Outils et bibliothèques

Lambda fournit les bibliothèques suivantes pour les fonctions Java :

com.amazonaws : aws-lambda-java-core (obligatoire) — Définit les interfaces des méthodes du gestionnaire et l'objet de contexte que le moteur d'exécution transmet au gestionnaire. Si vous définissez vos propres types d’entrée, c’est la seule bibliothèque dont vous avez besoin.
com.amazonaws : aws-lambda-java-events — Types d'entrée pour les événements provenant de services qui invoquent des fonctions Lambda.
com.amazonaws : aws-lambda-java-log 4j2 — Une bibliothèque d'ajout pour Apache Log4j 2 que vous pouvez utiliser pour ajouter l'ID de demande pour l'appel en cours dans vos journaux de fonctions.
AWS SDK pour Java 2.0 — Le SDK AWS officiel pour le langage de programmation Java.

Ces bibliothèques sont disponibles via le Référentiel central Maven. Ajoutez-les à votre définition de build comme suit :

Afin de créer un package de déploiement, compilez votre code de fonction et vos dépendances dans un seul fichier .zip ou Java Archive (JAR). Pour Gradle, utilisez le type de build Zip. Pour Apache Maven, utilisez le plug-in Maven Shade. Pour télécharger votre package de déploiement, utilisez la console Lambda, l'API Lambda ou (). AWS Serverless Application Model AWS SAM

Note

Pour que la taille de votre package de déploiement reste petite, empaquetez les dépendances de votre fonction en couches. Les couches vous permettent de gérer vos dépendances de manière indépendante. Elles peuvent être utilisées par plusieurs fonctions et partagées avec d’autres comptes. Pour plus d’informations, consultez Utilisation de couches Lambda.

Création d’un package de déploiement avec Gradle

Afin de créer un package de déploiement avec le code et les dépendances de votre fonction dans Gradle, utilisez le type de build Zip. Voici un exemple tiré d’un fichier exemple build.gradle complet :

Exemple build.gradle – Tâche de génération


task buildZip(type: Zip) {
    into('lib') {
        from(jar)
        from(configurations.runtimeClasspath)
    }
}

Cette configuration de build donne lieu à un package de déploiement dans le répertoire build/distributions. Dans l’instruction into('lib'), la tâche jar assemble une archive jar contenant vos classes principales dans un dossier nommé lib. De plus, la tâche configurations.runtimeClassPath copie les bibliothèques de dépendances du chemin de classe de génération dans le même dossier lib.

Exemple build.gradle – Dépendances


dependencies {
    ...
    implementation 'com.amazonaws:aws-lambda-java-core:1.2.2'
    implementation 'com.amazonaws:aws-lambda-java-events:3.11.1'
    implementation 'org.apache.logging.log4j:log4j-api:2.17.1'
    implementation 'org.apache.logging.log4j:log4j-core:2.17.1'
    runtimeOnly 'org.apache.logging.log4j:log4j-slf4j18-impl:2.17.1'
    runtimeOnly 'com.amazonaws:aws-lambda-java-log4j2:1.5.1'
    ...
}

Lambda charge les fichiers JAR dans l’ordre alphabétique Unicode. Si plusieurs fichiers JAR du répertoire lib contiennent la même classe, le premier fichier est utilisé. Vous pouvez utiliser le script shell suivant afin d’identifier les classes en double :

Exemple test-zip.sh


mkdir -p expanded
unzip path/to/my/function.zip -d expanded
find ./expanded/lib -name '*.jar' | xargs -n1 zipinfo -1 | grep '.*.class' | sort | uniq -c | sort

Création d’une couche Java pour vos dépendances

Note

Il se peut que l’utilisation de couches avec des fonctions dans un langage compilé tel que Java ne procure pas les mêmes avantages qu’avec un langage interprété tel que Python. Java étant un langage compilé, vos fonctions doivent toujours charger manuellement les assemblages partagés dans la mémoire pendant la phase d’initialisation, ce qui peut augmenter les temps de démarrage à froid. Nous recommandons plutôt d’inclure tout le code partagé au moment de la compilation afin de tirer parti des optimisations intégrées du compilateur.

Les instructions de cette section vous indiquent comment inclure les dépendances dans une couche. Pour obtenir des instructions sur la façon d’inclure vos dépendances dans votre package de déploiement, voir Création d’un package de déploiement avec Gradle ou Création d’un package de déploiement avec Maven.

Lorsque vous ajoutez une couche à une fonction, Lambda charge le contenu de la couche dans le répertoire /opt de cet environnement d’exécution. Pour chaque exécution Lambda, la variable PATH inclut déjà des chemins de dossiers spécifiques dans le répertoire /opt. Pour garantir que la PATH variable capte le contenu de votre couche, le fichier .zip de votre couche doit avoir ses dépendances dans les chemins de dossier suivants :

java/lib (CLASSPATH)

Par exemple, la structure du fichier .zip de votre couche peut ressembler à ce qui suit :


jackson.zip
└ java/lib/jackson-core-2.2.3.jar

En outre, Lambda détecte automatiquement toutes les bibliothèques dans le répertoire /opt/lib et tous les fichiers binaires dans le répertoire /opt/bin. Pour que Lambda trouve correctement le contenu de votre couche, vous pouvez aussi créer une couche avec la structure suivante :


custom-layer.zip
└ lib
    | lib_1
    | lib_2
└ bin
    | bin_1
    | bin_2

Après avoir empaqueté votre couche, reportez-vous à Création et suppression de couches dans Lambda et à Ajout de couches aux fonctions pour terminer la configuration de votre couche.

Création d’un package de déploiement avec Maven

Pour créer un package de déploiement avec Maven, utilisez le plug-in Maven Shade. Le plug-in crée un fichier JAR qui contient le code de fonction compilé et toutes ses dépendances.

Exemple pom.xml – Configuration du plugin


      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-shade-plugin</artifactId>
        <version>3.2.2</version>
        <configuration>
          <createDependencyReducedPom>false</createDependencyReducedPom>
        </configuration>
        <executions>
          <execution>
            <phase>package</phase>
            <goals>
              <goal>shade</goal>
            </goals>
          </execution>
        </executions>
      </plugin>

Pour créer le package de déploiement, utilisez la commande mvn package.


[INFO] Scanning for projects...
[INFO] -----------------------< com.example:java-maven >-----------------------
[INFO] Building java-maven-function 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
...
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ java-maven ---
[INFO] Building jar: target/java-maven-1.0-SNAPSHOT.jar
[INFO]
[INFO] --- maven-shade-plugin:3.2.2:shade (default) @ java-maven ---
[INFO] Including com.amazonaws:aws-lambda-java-core:jar:1.2.2 in the shaded jar.
[INFO] Including com.amazonaws:aws-lambda-java-events:jar:3.11.1 in the shaded jar.
[INFO] Including joda-time:joda-time:jar:2.6 in the shaded jar.
[INFO] Including com.google.code.gson:gson:jar:2.8.6 in the shaded jar.
[INFO] Replacing original artifact with shaded artifact.
[INFO] Replacing target/java-maven-1.0-SNAPSHOT.jar with target/java-maven-1.0-SNAPSHOT-shaded.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  8.321 s
[INFO] Finished at: 2020-03-03T09:07:19Z
[INFO] ------------------------------------------------------------------------

Cette commande génère un fichier JAR dans le répertoire target.

Note

Si vous travaillez avec un JAR multi-version (MRJAR), vous devez inclure le MRJAR (c’est-à-dire le JAR ombré produit par le plugin Maven Shade) dans le répertoire lib et le zipper avant de charger votre package de déploiement sur Lambda. Sinon, Lambda pourrait ne pas décompresser correctement votre fichier JAR, ce qui ferait que votre fichier MANIFEST.MF serait ignoré.

Si vous utilisez la bibliothèque appender (aws-lambda-java-log4j2), vous devez également configurer un transformateur pour le plug-in Maven Shade. La bibliothèque de transformateurs combine les versions d’un fichier cache qui apparaissent à la fois dans la bibliothèque appender et dans Log4j.

Exemple pom.xml – Configuration du plugin avec l’appender Log4j 2


      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-shade-plugin</artifactId>
        <version>3.2.2</version>
        <configuration>
          <createDependencyReducedPom>false</createDependencyReducedPom>
        </configuration>
        <executions>
          <execution>
            <phase>package</phase>
            <goals>
              <goal>shade</goal>
            </goals>
            <configuration>
              <transformers>
                <transformer implementation="com.github.edwgiz.maven_shade_plugin.log4j2_cache_transformer.PluginsCacheFileTransformer">
                </transformer>
              </transformers>
            </configuration>
          </execution>
        </executions>
        <dependencies>
          <dependency>
            <groupId>com.github.edwgiz</groupId>
            <artifactId>maven-shade-plugin.log4j2-cachefile-transformer</artifactId>
            <version>2.13.0</version>
          </dependency>
        </dependencies>
      </plugin>

Chargement d’un package de déploiement avec la console Lambda

Pour créer une nouvelle fonction, vous devez d’abord créer la fonction dans la console, puis charger votre fichier .zip ou JAR. Pour mettre à jour une fonction existante, ouvrez la page de votre fonction, puis suivez la même procédure pour ajouter votre fichier .zip ou JAR mis à jour.

Si votre fichier package de déploiement fait moins de 50 Mo, vous pouvez créer ou mettre à jour une fonction en chargeant le fichier directement à partir de votre ordinateur local. Pour les fichiers .zip ou JAR de plus de 50 Mo, vous devez d’abord charger votre package dans un compartiment Amazon S3. Pour savoir comment charger un fichier dans un compartiment Amazon S3 à l'aide du AWS Management Console, consultez Getting started with Amazon S3. Pour télécharger des fichiers à l'aide de AWS CLI, voir Déplacer des objets dans le guide de AWS CLI l'utilisateur.

Note

Vous ne pouvez pas modifier le type de package de déploiement (.zip ou image de conteneur) pour une fonction existante. Par exemple, vous ne pouvez pas convertir une fonction d'image de conteneur pour utiliser une archive de fichier .zip. Vous devez créer une nouvelle fonction.

Pour créer une nouvelle fonction (console)

Ouvrez la page Fonctions de la console Lambda et choisissez Créer une fonction.
Choisissez Créer à partir de zéro.
Sous Informations de base, procédez comme suit :
1. Pour Nom de la fonction, saisissez le nom de la fonction.
2. Pour Exécution, sélectionnez l’exécution que vous souhaitez utiliser.
3. (Facultatif) Pour Architecture, choisissez l’architecture de l’ensemble des instructions pour votre fonction. L’architecture par défaut est x86_64. Assurez-vous que le package de déploiement .zip pour votre fonction est compatible avec l’architecture de l’ensemble d’instructions que vous sélectionnez.
(Facultatif) Sous Permissions (Autorisations), développez Change default execution role (Modifier le rôle d’exécution par défaut). Vous pouvez créer un rôle d’exécution ou en utiliser un existant.
Choisissez Créer une fonction. Lambda crée une fonction de base « Hello world » à l’aide de l’exécution de votre choix.

Pour charger une archive .zip ou JAR à partir de votre ordinateur local (console)

Sur la page Fonctions de la console Lambda, choisissez la fonction pour laquelle vous souhaitez charger le fichier .zip ou JAR.
Sélectionnez l’onglet Code.
Dans le volet Source du code, choisissez Charger à partir de.
Choisissez un fichier .zip ou .jar.
Pour charger un fichier .zip ou JAR, procédez comme suit :
1. Sélectionnez Charger, puis choisissez votre fichier .zip ou JAR dans le sélecteur de fichiers.
2. Choisissez Ouvrir.
3. Choisissez Enregistrer.

Pour charger une archive .zip ou JAR depuis un compartiment Amazon S3 (console)

Sur la page Fonctions de la console Lambda, choisissez la fonction pour laquelle vous souhaitez charger un nouveau fichier .zip ou JAR.
Sélectionnez l’onglet Code.
Dans le volet Source du code, choisissez Charger à partir de.
Choisissez l’emplacement Amazon S3.
Collez l’URL du lien Amazon S3 de votre fichier .zip et choisissez Enregistrer.

Téléchargement d'un package de déploiement à l'aide du AWS CLI

Vous pouvez utiliser la AWS CLI pour créer une nouvelle fonction ou pour mettre à jour une fonction existante à l’aide d’un fichier .zip ou JAR. Utilisez la fonction de création et update-function-codeles commandes pour déployer votre package .zip ou JAR. Si votre fichier est inférieur à 50 Mo, vous pouvez charger le package à partir d’un emplacement de fichier sur votre machine de génération locale. Pour les fichiers plus volumineux, vous devez charger votre package .zip ou JAR à partir d’un compartiment Amazon S3. Pour savoir comment charger un fichier dans un compartiment Amazon S3 à l'aide du AWS CLI, consultez la section Déplacer des objets dans le guide de AWS CLI l'utilisateur.

Note

Si vous chargez votre fichier .zip ou JAR depuis un compartiment Amazon S3 à l'aide de AWS CLI, le compartiment doit se trouver dans le même emplacement Région AWS que votre fonction.

Pour créer une nouvelle fonction à l'aide d'un fichier .zip ou JAR avec le AWS CLI, vous devez spécifier les éléments suivants :

Le nom de votre fonction (--function-name)
L’exécution de votre fonction (--runtime)
L’Amazon Resource Name (ARN) du rôle d’exécution de votre fonction (--role)
Le nom de la méthode du gestionnaire dans votre code de fonction (--handler)

Vous devez également indiquer l’emplacement de votre fichier .zip ou JAR. Si votre fichier .zip ou JAR se trouve dans un dossier sur votre machine de génération locale, utilisez l’option --zip-file pour spécifier le chemin d’accès du fichier, comme le montre l’exemple de commande suivant.


aws lambda create-function --function-name myFunction \
--runtime java21 --handler example.handler \
--role arn:aws:iam::123456789012:role/service-role/my-lambda-role \
--zip-file fileb://myFunction.zip

Pour spécifier l’emplacement du fichier .zip dans un compartiment Amazon S3, utilisez l’option --code comme le montre l’exemple de commande suivant. Vous devez uniquement utiliser le paramètre S3ObjectVersion pour les objets soumis à la gestion des versions.


aws lambda create-function --function-name myFunction \
--runtime java21 --handler example.handler \
--role arn:aws:iam::123456789012:role/service-role/my-lambda-role \
--code S3Bucket=myBucketName,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion

Pour mettre à jour une fonction existante à l’aide de l’interface de ligne de commande, vous devez spécifier le nom de votre fonction à l’aide du paramètre --function-name. Vous devez également spécifier l’emplacement du fichier .zip que vous souhaitez utiliser pour mettre à jour votre code de fonction. Si votre fichier .zip se trouve dans un dossier sur votre machine de génération locale, utilisez l’option --zip-file pour spécifier le chemin d’accès du fichier, comme le montre l’exemple de commande suivant.


aws lambda update-function-code --function-name myFunction \
--zip-file fileb://myFunction.zip

Pour spécifier l’emplacement du fichier .zip dans un compartiment Amazon S3, utilisez les options --s3-bucket et --s3-key comme le montre l’exemple de commande suivant. Vous devez uniquement utiliser le paramètre --s3-object-version pour les objets soumis à la gestion des versions.


aws lambda update-function-code --function-name myFunction \
--s3-bucket myBucketName --s3-key myFileName.zip --s3-object-version myObject Version

Téléchargement d'un package de déploiement avec AWS SAM

Vous pouvez l'utiliser AWS SAM pour automatiser les déploiements de votre code de fonction, de votre configuration et de vos dépendances. AWS SAM est une extension de AWS CloudFormation qui fournit une syntaxe simplifiée pour définir des applications sans serveur. L’exemple de modèle suivant définit une fonction avec un package de déploiement dans le répertoire build/distributions utilisé par Gradle :

Exemple template.yml


AWSTemplateFormatVersion: '2010-09-09'
Transform: 'AWS::Serverless-2016-10-31'
Description: An AWS Lambda application that calls the Lambda API.
Resources:
  function:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: build/distributions/java-basic.zip
      Handler: example.Handler
      Runtime: java21
      Description: Java function
      MemorySize: 512
      Timeout: 10
      # Function's execution role
      Policies:
        - AWSLambdaBasicExecutionRole
        - AWSLambda_ReadOnlyAccess
        - AWSXrayWriteOnlyAccess
        - AWSLambdaVPCAccessExecutionRole
      Tracing: Active

Pour créer la fonction, utilisez les commandes package et deploy. Ces commandes sont des personnalisations de l AWS CLI. Elles encapsulent d’autres commandes pour charger le package de déploiement sur Amazon S3, réécrivent le modèle avec l’URI de l’objet, et mettent à jour le code de la fonction.

L’exemple de script suivant exécute une build Gradle et télécharge le package de déploiement qu’il crée. Il crée une AWS CloudFormation pile la première fois que vous l'exécutez. Si la pile existe déjà, le script la met à jour.

Exemple deploy.sh


#!/bin/bash
set -eo pipefail
aws cloudformation package --template-file template.yml --s3-bucket MY_BUCKET --output-template-file out.yml
aws cloudformation deploy --template-file out.yml --stack-name java-basic --capabilities CAPABILITY_NAMED_IAM

Afin d’obtenir un exemple de travail complet, consultez les exemples d’applications suivants :

Exemples d’applications Lambda en Java

java17-examples : fonction Java qui montre comment utiliser un enregistrement Java pour représenter un objet de données d’événement en entrée.
java-basic – Ensemble de fonctions Java minimales avec des tests unitaires et une configuration de journalisation variable.
java events – Ensemble de fonctions Java contenant du code squelette permettant de gérer les événements de divers services tels qu’Amazon API Gateway, Amazon SQS et Amazon Kinesis. Ces fonctions utilisent la dernière version de la aws-lambda-java-eventsbibliothèque (3.0.0 et versions ultérieures). Ces exemples ne nécessitent pas le AWS SDK comme dépendance.
s3-java – Fonction Java qui traite les événements de notification d’Amazon S3 et utilise la bibliothèque de classes Java (JCL) pour créer des miniatures à partir de fichiers d’image chargés.
Utiliser API Gateway pour invoquer une fonction Lambda : Fonction Java qui analyse une table Amazon DynamoDB contenant les informations relatives aux employés. Il utilise ensuite Amazon Simple Notification Service pour envoyer un message texte aux employés qui fêtent leur anniversaire professionnel. Cet exemple utilise API Gateway pour invoquer la fonction.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Handler (Gestionnaire)

Déploiement d’images de conteneur