Bereitstellen von Java-Lambda-Funktionen mit ZIP- oder JAR-Dateiarchiven

Der Code Ihrer AWS Lambda Funktion besteht aus Skripten oder kompilierten Programmen und deren Abhängigkeiten. Sie verwenden ein Bereitstellungspaket, um Ihren Funktionscode in Lambda bereitzustellen. Lambda unterstützt zwei Arten von Bereitstellungspaketen: Container-Images und ZIP-Dateiarchiven.

Auf dieser Seite wird beschrieben, wie Sie Ihr Bereitstellungspaket als ZIP-Datei oder Jar-Datei erstellen und dann das Bereitstellungspaket verwenden, um Ihren Funktionscode AWS Lambda mithilfe von AWS Command Line Interface (AWS CLI) bereitzustellen.

Voraussetzungen

Das AWS CLI ist ein Open-Source-Tool, mit dem Sie mithilfe von Befehlen in Ihrer Befehlszeilen-Shell mit AWS Diensten interagieren können. Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie AWS CLI Version 2.

Tools und Bibliotheken

AWS stellt die folgenden Bibliotheken für Java-Funktionen bereit. Diese Bibliotheken sind über Maven Central Repositoryverfügbar.

Fügen Sie diese Bibliotheken wie folgt zu Ihrer Build-Definition hinzu:

dependencies {
    implementation 'com.amazonaws:aws-lambda-java-core:1.2.2'
    implementation 'com.amazonaws:aws-lambda-java-events:3.11.1'
    runtimeOnly 'com.amazonaws:aws-lambda-java-log4j2:1.5.1'
}

Um ein Bereitstellungspaket zu erstellen, kompilieren Sie den Funktionscode und die Abhängigkeiten in einer einzelnen ZIP- oder Java-Archivdatei (JAR). Verwenden Sie für Gradle den Zip-Build-Typ. Verwenden Sie für Apache Maven das Maven Shade Plugin. Verwenden Sie zum Hochladen Ihres Bereitstellungspakets die Lambda-Konsole, die Lambda-API oder AWS Serverless Application Model ()AWS SAM.

Erstellen eines Bereitstellungspakets mit Gradle

Um in Gradle ein Bereitstellungspaket mit dem Code Ihrer Funktion und deren Abhängigkeiten zu erstellen, verwenden Sie den Build-Typ Zip. Hier ist ein Beispiel aus einer vollständigen build.gradle Datei:

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

Diese Build-Konfiguration erzeugt ein Bereitstellungspaket im build/distributions-Ordner. Innerhalb der into('lib')-Anweisung stellt die jar-Aufgabe ein JAR-Archiv mit Ihren Hauptklassen in einem Ordner mit dem Namen „lib“ zusammen. Die configurations.runtimeClassPath-Aufgabe kopiert außerdem Abhängigkeitsbibliotheken aus dem Klassenpfad des Builds in denselben Ordner mit dem Namen „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 lädt JAR-Dateien in alphabetischer Reihenfolge (Unicode). Wenn mehrere JAR-Dateien im lib-Verzeichnis die gleiche Klasse enthalten, wird die erste verwendet. Sie können das folgende Shell-Skript zum Identifizieren von doppelten Klassen verwenden.

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

Erstellen einer Java-Ebene für Ihre Abhängigkeiten

Die Anweisungen in diesem Abschnitt zeigen Ihnen, wie Sie Ihre Abhängigkeiten in eine Ebene einschließen. Anweisungen zum Einschließen Ihrer Abhängigkeiten in Ihr Bereitstellungspaket finden Sie unter Erstellen eines Bereitstellungspakets mit Gradle oder Erstellen eines Bereitstellungspakets mit Maven.

Wenn Sie einer Funktion eine Ebene hinzufügen, lädt Lambda den Ebeneninhalt in das Verzeichnis /opt der Ausführungsumgebung. Für jede Lambda-Laufzeit enthält die Variable PATH bereits spezifische Ordnerpfade innerhalb des Verzeichnisses /opt. Um sicherzustellen, dass Lambda Ihren Layer-Inhalt aufnimmt, sollte Ihre Layer-.zip-Datei ihre Abhängigkeiten in den folgenden Ordnerpfaden haben:

Die Struktur Ihrer Ebene-ZIP-Datei könnte beispielsweise wie folgt aussehen:

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

Darüber hinaus erkennt Lambda automatisch alle Bibliotheken im /opt/lib-Verzeichnis und alle Binärdateien im /opt/bin-Verzeichnis. Um sicherzustellen, dass Lambda Ihren Ebeneninhalt korrekt findet, können Sie auch eine Ebene mit der folgenden Struktur erstellen:

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

Nachdem Sie Ihre Ebene gebündelt haben, sehen Sie sich Erstellen und Löschen von Ebenen in Lambda und Hinzufügen von Ebenen zu Funktionen an, um die Einrichtung Ihrer Ebene abzuschließen.

Erstellen eines Bereitstellungspakets mit Maven

Verwenden Sie das Maven Shade-Plugin, um ein Bereitstellungspaket mit Maven zu erstellen. Das Plugin erstellt eine JAR-Datei mit dem kompilierten Funktionscode und allen seinen Abhängigkeiten.

      <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>

Verwenden Sie den mvn package-Befehl, um das Bereitstellungspaket zu erstellen.

[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] ------------------------------------------------------------------------

Mit diesem Befehl wird eine JAR-Datei im target-Verzeichnis generiert.

Wenn Sie die Appender-Bibliothek (aws-lambda-java-log4j2) verwenden, müssen Sie auch einen Transformer für das Maven Shade-Plugin konfigurieren. Die Transformer-Bibliothek kombiniert Versionen einer Cache-Datei, die sowohl in der Appender-Bibliothek als auch in Log4j angezeigt wird.

      <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>

Hochladen eines Bereitstellungspakets mit der Lambda-Konsole

Eine neue Funktion müssen Sie zuerst in der Konsole erstellen und dann Ihre ZIP- oder JAR-Datei hochladen. Zum Aktualisieren einer bestehenden Funktion öffnen Sie die Seite für Ihre Funktion und gehen dann genauso vor, um Ihre aktualisierte ZIP- oder JAR-Datei hinzuzufügen.

Bei einer Bereitstellungspaketdatei unter 50 MB können Sie eine Funktion erstellen oder aktualisieren, indem Sie die Datei direkt von Ihrem lokalen Computer hochladen. Bei ZIP-oder JAR-Dateien mit einer Größe von mehr als 50 MB müssen Sie Ihr Paket zuerst in einen Amazon-S3-Bucket hochladen. Anweisungen zum Hochladen einer Datei in einen Amazon S3-Bucket mithilfe von finden Sie unter Erste Schritte mit Amazon S3. AWS Management Console Informationen zum Hochladen von Dateien mit dem AWS CLI finden Sie unter Objekte verschieben im AWS CLI Benutzerhandbuch.

Hochladen eines Bereitstellungspakets mit dem AWS CLI

Sie können die AWS CLI verwenden, um eine neue Funktion zu erstellen oder eine vorhandene unter Verwendung einer ZIP- oder JAR-Datei zu aktualisieren. Verwenden Sie die Create-Funktion und die update-function-codeBefehle, um Ihr .zip- oder JAR-Paket bereitzustellen. Wenn Ihre Datei kleiner als 50 MB ist, können Sie das Paket von einem Dateispeicherort auf Ihrem lokalen Build-Computer hochladen. Bei größeren Dateien müssen Sie Ihr ZIP-oder JAR-Paket aus einem Amazon-S3-Bucket hochladen. Anweisungen zum Hochladen einer Datei in einen Amazon S3 S3-Bucket mithilfe von finden Sie unter Objekte verschieben im AWS CLI Benutzerhandbuch. AWS CLI

Um eine neue Funktion mithilfe einer .zip- oder JAR-Datei mit der zu erstellen AWS CLI, müssen Sie Folgendes angeben:

Sie müssen auch den Speicherort Ihrer ZIP- oder JAR-Datei angeben. Befindet sich Ihre ZIP- oder JAR-Datei in einem Ordner auf Ihrem lokalen Build-Computer, verwenden Sie die --zip-file-Option, um den Dateipfad anzugeben, wie im folgenden Beispielbefehl gezeigt.

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

Zur Angabe des Speicherorts der ZIP-Datei in einem Amazon-S3-Bucket verwenden Sie die im folgenden Beispielbefehl gezeigte --code-Option. Sie müssen den S3ObjectVersion-Parameter nur für versionierte Objekte verwenden.

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

Um eine vorhandene Funktion mit der CLI zu aktualisieren, geben Sie den Namen Ihrer Funktion unter Verwendung des --function-name-Parameters an. Sie müssen auch den Speicherort der ZIP-Datei angeben, die Sie zum Aktualisieren Ihres Funktionscodes verwenden möchten. Befindet sich Ihre ZIP-Datei in einem Ordner auf Ihrem lokalen Build-Computer, verwenden Sie die --zip-file-Option, um den Dateipfad anzugeben, wie im folgenden Beispielbefehl gezeigt.

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

Zur Angabe des Speicherorts der ZIP-Datei in einem Amazon-S3-Bucket verwenden Sie die im folgenden Beispielbefehl gezeigten --s3-bucket- und --s3-key-Optionen. Sie müssen den --s3-object-version-Parameter nur für versionierte Objekte verwenden.

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

Hochladen eines Bereitstellungspakets mit AWS SAM

Sie können AWS SAM es verwenden, um die Bereitstellung Ihres Funktionscodes, Ihrer Konfiguration und Ihrer Abhängigkeiten zu automatisieren. AWS SAM ist eine Erweiterung von AWS CloudFormation , die eine vereinfachte Syntax für die Definition serverloser Anwendungen bietet. Die folgende Beispielvorlage definiert eine Funktion mit einem Bereitstellungspaket in dem build/distributions-Verzeichnis, das Gradle verwendet.

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

Um die Funktion zu erstellen, verwenden Sie die Befehle „package“ und „deploy“. Bei diesen Befehlen handelt es sich um Anpassungen an der AWS CLI. Sie umschließen andere Befehle, um das Bereitstellungspaket zu Amazon S3 hochzuladen, die Vorlage mit dem Objekt-URI neu zu schreiben und den Code der Funktion zu aktualisieren.

Im folgenden Beispielskript wird ein Gradle-Build ausgeführt und das von ihm erstellte Bereitstellungspaket wird hochgeladen. Es erstellt einen AWS CloudFormation Stack, wenn Sie es zum ersten Mal ausführen. Wenn der Stack bereits vorhanden ist, wird der vom Skript aktualisiert.

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

Ein vollständiges funktionierendes Beispiel finden Sie in den folgenden Beispielanwendungen.