Déployez des fonctions Java Lambda avec des archives .zip ou de fichiers 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).

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 :

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

Pour créer un package de déploiement, compilez le code de votre fonction et ses dépendances dans un seul fichier .zip ou un fichier 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, le Lambda ou API (). AWS Serverless Application Model 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 dans Gradle, utilisez le type de build Zip. Voici un exemple tiré d’un fichier exemple build.gradle complet :

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.

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 JAR les fichiers dans l'ordre alphabétique Unicode. Si plusieurs JAR fichiers du lib répertoire contiennent la même classe, la première est utilisée. Vous pouvez utiliser le script shell suivant afin d’identifier les classes en double :

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

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 :

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 plugin crée un JAR fichier qui contient le code de fonction compilé et toutes ses dépendances.

      <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 JAR fichier dans le target répertoire.

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.

      <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 télécharger votre fichier .zip ou JAR fichier. Pour mettre à jour une fonction existante, ouvrez la page correspondante, puis suivez la même procédure pour ajouter votre fichier .zip ou JAR fichier 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 JAR fichiers .zip ou supérieurs à 50 Mo, vous devez d'abord télé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.

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

Vous pouvez utiliser le AWS CLIpour créer une nouvelle fonction ou pour mettre à jour une fonction existante à l'aide d'un fichier .zip ou d'un JAR fichier. Utilisez la fonction de création et update-function-codeles commandes pour déployer votre fichier .zip ou votre package. 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 télécharger votre fichier .zip ou votre JAR package depuis 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.

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

Vous devez également spécifier l'emplacement de votre fichier .zip ou JAR fichier. Si votre fichier .zip ou JAR fichier se trouve dans un dossier de votre machine de génération locale, utilisez l'--zip-fileoption pour spécifier le chemin du fichier, comme illustré dans 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=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion

Pour mettre à jour une fonction existante à l'aide duCLI, vous devez spécifier le nom de votre fonction à l'aide du --function-name paramètre. 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 amzn-s3-demo-bucket --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 :

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. Ils encapsulent d'autres commandes pour télécharger le package de déploiement sur Amazon S3, réécrivent le modèle avec l'objet URI 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.

#!/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 :