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

Package de déploiement AWS Lambda en Java

Pour créer une image de conteneur afin de déployer votre code de fonction, veuillez consulter .

Un package de déploiement est une archive .zip qui contient le code compilé de la fonction et les dépendances. Vous pouvez charger le package directement dans Lambda, ou vous pouvez utiliser un compartiment Amazon Simple Storage Service (Amazon S3) puis le charger dans Lambda. Si le package de déploiement est supérieur à 50 Mo, vous devez utiliser Amazon S3.

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

com.amazonaws:aws-lambda-java-core (obligatoire) – Définit les interfaces de méthode de gestion 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 des services qui appellent des fonctions Lambda.
com.amazonaws:aws-lambda-java-log4j2 – Une bibliothèque appender pour Log4j 2 que vous pouvez utiliser afin d'ajouter l'ID de requête pour l'appel en cours à vos journaux de fonctions.

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 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 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, peuvent être utilisées par plusieurs fonctions et être partagées avec d'autres comptes. Pour plus d'informations, consultez Couches AWS Lambda.

Vous pouvez télécharger votre package de déploiement à l'aide de la console Lambda, de l'API Lambda ou de l'AWS SAM.

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

Ouvrez la page des fonctions sur la console Lambda.
Choisissez une fonction.
Sous Code de fonction, choisissez Charger.
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

Utilisez le type de build Zip pour créer un package de déploiement avec le code et les dépendances de votre fonction.

Exemple build.gradle – Tâche de build


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

Cette configuration de build produit un package de déploiement dans le dossier build/distributions. La tâche compileJava compile les classes de votre fonction. Les tâches processResources copient les bibliothèques du chemin de classe de la 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.1.0'
    implementation 'com.google.code.gson:gson:2.8.6'
    implementation 'org.apache.logging.log4j:log4j-api:2.13.0'
    implementation 'org.apache.logging.log4j:log4j-core:2.13.0'
    runtimeOnly 'org.apache.logging.log4j:log4j-slf4j18-impl:2.13.0'
    runtimeOnly 'com.amazonaws:aws-lambda-java-log4j2:1.2.0'
    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 dans le dossierlib contiennent la même classe, le premier fichier est utilisé. Vous pouvez utiliser le script shell ci-après pour 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 plug-in


      <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.1.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 dossier 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 plug-in 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

Pour mettre à jour le code d'une fonction avec le AWS CLI ou le kit AWS SDK, utilisez l'opération d'API UpdateFunctionCode. Pour l'interface de ligne de commande AWS, utilisez la commande update-function-code. La commande suivante charge un package de déploiement nommé my-function.zip dans le répertoire courant.


~/my-function$ aws lambda update-function-code --function-name my-function --zip-file fileb://my-function.zip
{
    "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 plus grand que 50 MB, vous ne pouvez pas le charger directement. Chargez-le dans un compartiment Amazon S3 et pointez Lambda sur l'objet. Les exemples de commandes suivants téléchargent un package de déploiement dans un compartiment nommé my-bucket et l'utilisent pour mettre à jour le code d'une fonction.


~/my-function$ aws s3 cp my-function.zip s3://my-bucket
 upload: my-function.zip to s3://my-bucket/my-function
 ~/my-function$ aws lambda update-function-code --function-name my-function \
 --s3-bucket my-bucket --s3-key my-function.zip
{
    "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 MB (décompressé).

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

Vous pouvez utiliser le Modèle d'application sans serveur AWS 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: java8
      Description: Java function
      MemorySize: 512
      Timeout: 10
      # Function's execution role
      Policies:
        - AWSLambdaBasicExecutionRole
        - AWSLambdaReadOnlyAccess
        - AWSXrayWriteOnlyAccess
        - AWSLambdaVPCAccessExecutionRole
      Tracing: Active

Pour créer la fonction, utilisez les commandes package et deploy. Ces commandes sont des personnalisations de l'interface de ligne de commande AWS. Elles encapsulent d'autres commandes pour télécharger le package de déploiement 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

Pour obtenir un exemple complet de travail, consultez les exemples d'applications suivants.

Exemples d'applications Lambda en Java

blank-java – Fonction Java qui montre l'utilisation des bibliothèques Java de Lambda, la journalisation, les variables d'environnement, les couches, le suivi AWS X-Ray, les tests unitaires et le kit SDK AWS.
java-basic – Fonction Java minimale avec des tests unitaires et une configuration de journalisation variable.
java-events – Fonction Java minimale qui utilise la bibliothèque aws-lambda-java-events avec des types d'événements qui n'ont pas besoin du kit SDK AWS en tant que dépendance, par exemple Amazon API Gateway.
java-events-v1sdk – Fonction Java qui utilise la bibliothèque aws-lambda-java-events avec des types d'événements nécessitant le kit SDK AWS en tant que dépendance (Amazon Simple Storage Service, Amazon DynamoDB et Amazon Kinesis).
s3-java – Fonction Java qui traite les événements de notification de Amazon S3 et utilise la bibliothèque de classes Java (JCL) pour créer des miniatures à partir de fichiers image téléchargés.

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

Exemples d'application

Gestionnaire