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

Le code de votre fonction AWS Lambda se compose de scripts ou de programmes compilés et 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 la forme d'un fichier .zip ou Jar avant d'utiliser le package de déploiement pour déployer votre code de fonction sur AWS Lambda à l'aide de l'AWS Command Line Interface (AWS CLI).

Sections

Prérequis
Outils et bibliothèques

Prérequis

La AWS CLI est un outil à code open source qui vous permet d’interagir avec les services AWS à l’aide des commandes du terminal 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 de méthode du gestionnaire et l’objet contexte que l’environnement 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ées pour les événements des services qui appellent des fonctions Lambda.
com.amazonaws:aws-lambda-java-log4j2 – Bibliothèque Appender pour Apache Log4j 2 que vous pouvez utiliser afin d’ajouter l’ID de demande pour l’appel en cours aux journaux de fonctions.
Kit SDK AWS pour Java 2.0 : le kit 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.

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 de plus amples informations, veuillez consulter Création et partage de couches Lambda.

Vous pouvez charger votre package de déploiement à l'aide de la console Lambda, de l'API Lambda ou de AWS Serverless Application Model (AWS SAM).

Pour charger un package de déploiement avec la console Lambda

Ouvrez la page Functions (Fonctions) de la console Lambda.
Choisissez une fonction.
Sous Code source (Source du code), sélectionnez Upload from (Charger depuis).
Charger un package de déploiement
Choisissez Enregistrer.

Sections

Création d'un package de déploiement avec Gradle
Création d'un package de déploiement avec Maven
Chargement d'un package de déploiement avec l'API Lambda
Chargement d'un package de déploiement avec AWS SAM

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, utilisez le type de build Zip.

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


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

Cette configuration de build donne lieu à un package de déploiement dans le répertoire build/distributions. La tâche compileJava compile les classes de votre fonction. La tâche processResources copie les ressources du projet Java dans leur répertoire cible, ces ressources pouvant être potentiellement traitées. L'instruction into('lib') copie ensuite les bibliothèques de dépendances du chemin de classe de build dans un dossier nommé lib.

Exemple build.gradle – Dépendances


dependencies {
    implementation platform('software.amazon.awssdk:bom:2.10.73')
    implementation 'software.amazon.awssdk:lambda'
    implementation 'com.amazonaws:aws-lambda-java-core:1.2.1'
    implementation 'com.amazonaws:aws-lambda-java-events:3.11.0'
    implementation 'com.google.code.gson:gson:2.8.6'
    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'
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.0'
}

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'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.1 in the shaded jar.
[INFO] Including com.amazonaws:aws-lambda-java-events:jar:3.11.0 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.

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 l'API Lambda

Afin de mettre à jour le code d'une fonction avec l'AWS Command Line Interface (AWS CLI) ou le kit SDK AWS, utilisez l'opération d'API UpdateFunctionCode. Pour AWS CLI, utilisez la commande update-function-code. La commande suivante charge un package de déploiement nommé my-function.zip dans le répertoire actuel :


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

Vous devriez voir la sortie suivante:


{
    "FunctionName": "my-function",
    "FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
    "Runtime": "java8",
    "Role": "arn:aws:iam::123456789012:role/lambda-role",
    "Handler": "example.Handler",
    "CodeSha256": "Qf0hMc1I2di6YFMi9aXm3JtGTmcDbjniEuiYonYptAk=",
    "Version": "$LATEST",
    "TracingConfig": {
        "Mode": "Active"
    },
    "RevisionId": "983ed1e3-ca8e-434b-8dc1-7d72ebadd83d",
    ...
}

Si votre package de déploiement est d'une taille supérieure à 50 Mo, vous ne pouvez pas le charger directement. Chargez-le vers un compartiment Amazon Simple Storage Service (Amazon S3) et pointez Lambda vers l'objet. Les exemples de commandes suivants chargent un package de déploiement dans un compartiment S3 nommé my-bucket et l'utilisent afin de mettre à jour le code d'une fonction :


aws s3 cp my-function.zip s3://my-bucket

Vous devriez voir la sortie suivante:


upload: my-function.zip to s3://my-bucket/my-function


aws lambda update-function-code --function-name my-function \
 --s3-bucket my-bucket --s3-key my-function.zip

Vous devriez voir la sortie suivante:


{
    "FunctionName": "my-function",
    "FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
    "Runtime": "java8",
    "Role": "arn:aws:iam::123456789012:role/lambda-role",
    "Handler": "example.Handler",
    "CodeSha256": "Qf0hMc1I2di6YFMi9aXm3JtGTmcDbjniEuiYonYptAk=",
    "Version": "$LATEST",
    "TracingConfig": {
        "Mode": "Active"
    },
    "RevisionId": "983ed1e3-ca8e-434b-8dc1-7d72ebadd83d",
    ...
}

Vous pouvez utiliser cette méthode pour charger des packages de fonctions jusqu'à 250 Mo (décompressé).

Chargement d'un package de déploiement avec AWS SAM

Vous pouvez utiliser AWS SAM afin d'automatiser les déploiements de votre code de fonction, de votre configuration et de vos dépendances. AWS SAM est une extension d'AWS CloudFormation qui fournit une syntaxe simplifiée afin de définir des applications serverless. 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: java8
      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 pile AWS CloudFormation 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

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 (3.0.0 et ultérieure) de la bibliothèque aws-lambda-java-events. Ces exemples ne nécessitent pas le kit SDK AWS 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 appeler 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 appeler 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