Voraussetzungen Tools und Bibliotheken Erstellen eines Bereitstellungspakets mit Gradle Erstellen einer Java-Ebene für Ihre Abhängigkeiten Erstellen eines Bereitstellungspakets mit Maven Hochladen eines Bereitstellungspakets mit der Lambda-Konsole Hochladen eines Bereitstellungspakets mit AWS CLI Hochladen eines Bereitstellungspakets mit AWS SAM

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.

Sections

Voraussetzungen
Tools und Bibliotheken
Erstellen eines Bereitstellungspakets mit Gradle
Erstellen einer Java-Ebene für Ihre Abhängigkeiten
Erstellen eines Bereitstellungspakets mit Maven
Hochladen eines Bereitstellungspakets mit der Lambda-Konsole
Hochladen eines Bereitstellungspakets mit AWS CLI
Hochladen eines Bereitstellungspakets mit AWS SAM

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

Tools und Bibliotheken

Lambda stellt die folgenden Bibliotheken für Java-Funktionen bereit:

com.amazonaws: aws-lambda-java-core (erforderlich) — Definiert Handler-Methodenschnittstellen und das Kontextobjekt, das die Runtime an den Handler übergibt. Wenn Sie eigene Eingabetypen definieren, benötigen Sie nur diese eine Bibliothek.
com.amazonaws: aws-lambda-java-events — Eingabetypen für Ereignisse von Diensten, die Lambda-Funktionen aufrufen.
com.amazonaws: aws-lambda-java-log 4j2 — Eine Appender-Bibliothek für Apache Log4j 2, mit der Sie die Anforderungs-ID für den aktuellen Aufruf zu Ihren Funktionsprotokollen hinzufügen können.
AWS SDK for Java 2.0 — Das offizielle AWS SDK für die Programmiersprache Java.

Diese Bibliotheken sind über Maven Central Repositoryverfügbar. Fügen Sie sie wie folgt der Build-Definition hinzu.

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.

Anmerkung

Um den Umfang des Bereitstellungspakets gering zu halten, verpacken Sie die Abhängigkeiten Ihrer Funktion in Ebenen. Ebenen ermöglichen Ihnen, Ihre Abhängigkeiten unabhängig zu verwalten, können von mehreren Funktionen genutzt werden und können für andere Konten zur gemeinsamen Nutzung freigegeben werden. Weitere Informationen finden Sie unter Arbeiten mit Lambda-Ebenen.

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:

Beispiel build.gradle – Entwicklungs-Aufgabe


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

Beispiel build.gradle – Abhängigkeiten


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.

Beispiel 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

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

Anmerkung

Die Verwendung von Ebenen mit Funktionen in einer kompilierten Sprache wie Java bietet möglicherweise nicht den gleichen Nutzen wie in einer interpretierten Sprache wie Python. Da es sich bei Java um eine kompilierte Sprache handelt, müssen Ihre Funktionen während der Initialisierungsphase alle freigegebenen Baugruppen manuell in den Speicher laden, was die Kaltstartzeiten erhöhen kann. Stattdessen empfehlen wir, den freigegebenen Code bei der Kompilierung einzuschließen, um die Vorteile der integrierten Compiler-Optimierungen zu nutzen.

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 die PATH Variable Ihren Layer-Inhalt aufnimmt, sollte Ihre Layer-.zip-Datei ihre Abhängigkeiten in den folgenden Ordnerpfaden haben:

java/lib (CLASSPATH)

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.

Beispiel pom.xml – Plugin-Konfiguration


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

Anmerkung

Wenn Sie mit einem Multi-Release-JAR (MRJAR) arbeiten, müssen Sie das MRJAR (d.h. das vom Maven Shade-Plugin erzeugte shaded JAR) in das lib-Verzeichnis aufnehmen und es zippen, bevor Sie Ihr Bereitstellungspaket zu Lambda hochladen. Andernfalls entpackt Lambda Ihre JAR-Datei möglicherweise nicht richtig, sodass Ihre MANIFEST.MF-Datei ignoriert wird.

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

Beispiel pom.xml – Plugin-Konfiguration mit Log4j-2-Appender


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

Anmerkung

Sie können den Bereitstellungspakettyp (.zip oder Container-Image) für eine bestehende Funktion nicht ändern. Sie können beispielsweise eine Container-Image-Funktion nicht so konvertieren, dass sie ein ZIP-Dateiarchiv verwendet. Sie müssen eine neue Funktion erstellen.

So erstellen Sie eine neue Funktion (Konsole)

Öffnen Sie die Funktionsseite der Lambda-Konsole und wählen Sie Funktion erstellen aus.
Wählen Sie Author from scratch aus.
Führen Sie unter Basic information (Grundlegende Informationen) die folgenden Schritte aus:
1. Geben Sie als Funktionsname den Namen Ihrer Funktion ein.
2. Wählen Sie für Laufzeit die Laufzeit aus, die Sie verwenden möchten.
3. (Optional) Für Architektur wählen Sie die Befehlssatz-Architektur für Ihre Funktion aus. Die Standardarchitektur ist x86_64. Stellen Sie sicher, dass das ZIP-Bereitstellungspaket für Ihre Funktion mit der von Ihnen gewählten Befehlssatzarchitektur kompatibel ist.
(Optional) Erweitern Sie unter Berechtigungen die Option Standardausführungsrolle ändern. Sie können eine neue Ausführungsrolle erstellen oder eine vorhandene Rolle verwenden.
Wählen Sie Funktion erstellen. Lambda erstellt eine grundlegende „Hello World“-Funktion mit der von Ihnen gewählten Laufzeit.

So laden Sie ein ZIP- oder JAR-Archiv von Ihrem lokalen Computer (Konsole) hoch

Wählen Sie auf der Funktionsseite der Lambda-Konsole die Funktion aus, für die Sie die ZIP- oder JAR-Datei hochladen möchten.
Wählen Sie die Registerkarte Code aus.
Wählen Sie im Bereich Codequelle die Option Hochladen von aus.
Wählen Sie ZIP- oder JAR-Datei aus.
Laden Sie die ZIP- oder JAR-Datei wie folgt hoch:
1. Wählen Sie Hochladen und dann Ihre ZIP- oder JAR-Datei in der Dateiauswahl aus.
2. Klicken Sie auf Open.
3. Wählen Sie Speichern.

So laden Sie ein ZIP-Archiv aus einem Amazon-S3-Bucket hoch (Konsole)

Wählen Sie auf der Funktionsseite der Lambda-Konsole die Funktion aus, für die Sie die neue ZIP- oder JAR-Datei hochladen möchten.
Wählen Sie die Registerkarte Code aus.
Wählen Sie im Bereich Codequelle die Option Hochladen von aus.
Wählen Sie den Amazon-S3-Speicherort aus.
Fügen Sie die Amazon-S3-Link-URL Ihrer ZIP-Datei ein und wählen Sie Speichern aus.

Hochladen eines Bereitstellungspakets mit 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

Anmerkung

Wenn Sie Ihre .zip- oder JAR-Datei mithilfe von aus einem Amazon S3 S3-Bucket hochladen AWS CLI, muss sich der Bucket im selben Verzeichnis befinden AWS-Region wie Ihre Funktion.

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

Den Namen Ihrer Funktion (--function-name)
Die Laufzeit Ihrer Funktion (--runtime)
Den Amazon-Ressourcennamen (ARN) der Ausführungsrolle der Funktion (--role).
Den Namen der Handler-Methode in Ihrem Funktionscode (--handler)

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=myBucketName,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 myBucketName --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.

Beispiel 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

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.

Beispiel 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

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

Lambda-Beispielanwendungen in Java

java17-examples – Eine Java-Funktion, die demonstriert, wie ein Java-Datensatz verwendet wird, um ein Eingabeereignis-Datenobjekt darzustellen.
Java-Basis – Eine Sammlung minimaler Java-Funktionen mit Einheitentests und variabler Protokollierungskonfiguration.
Java-Ereignisse – Eine Sammlung von Java-Funktionen, die Grundcode für den Umgang mit Ereignissen aus verschiedenen Services wie Amazon API Gateway, Amazon SQS und Amazon Kinesis enthalten. Diese Funktionen verwenden die neueste Version der aws-lambda-java-eventsBibliothek (3.0.0 und neuer). Für diese Beispiele ist das AWS SDK nicht als Abhängigkeit erforderlich.
s3-java – Eine Java-Funktion die Benachrichtigungsereignisse aus Amazon S3 verarbeitet und die Java Class Library (JCL) verwendet, um Miniaturansichten aus hochgeladenen Image-Dateien zu erstellen.
Verwenden von API Gateway zum Aufrufen einer Lambda-Funktion – Eine Java-Funktion, die eine Amazon-DynamoDB-Tabelle durchsucht, die Mitarbeiterinformationen enthält. Anschließend verwendet es Amazon Simple Notification Service, um eine Textnachricht an Mitarbeiter zu senden, die ihr Betriebsjubiläum feiern. In diesem Beispiel wird API Gateway verwendet, um die Funktion aufzurufen.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Handler

Bereitstellen von Container-Images