Arbeiten mit Ebenen für Java Lambda-Funktionen - AWS Lambda
Verpacken Ihres EbeneninhaltsErstellen Sie die Ebene in LambdaFügen Sie den Layer zu Ihrer Funktion hinzu

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Arbeiten mit Ebenen für Java Lambda-Funktionen

Verwenden Sie Lambda-Ebenen, um Code und Abhängigkeiten zu verpacken, die Sie für mehrere Funktionen wiederverwenden möchten. Ebenen enthalten üblicherweise Bibliotheksabhängigkeiten, eine benutzerdefinierte Laufzeit oder Konfigurationsdateien. Das Erstellen einer Ebene umfasst drei allgemeine Schritte:

  1. Verpacken Ihres Ebeneninhalts. Dies bedeutet, dass Sie ein .zip-Dateiarchiv erstellen, das die Abhängigkeiten enthält, die Sie in Ihren Funktionen verwenden möchten.

  2. Erstellen Sie die Ebene in Lambda.

  3. Fügen Sie die Ebene zu Ihren Funktionen hinzu.

Verpacken Ihres Ebeneninhalts

Um eine Ebene zu erstellen, bündeln Sie Ihre Pakete in einem ZIP-Dateiarchiv, das die folgenden Anforderungen erfüllt:

  • Stellen Sie sicher, dass die Java-Version, auf die sich Maven oder Gradle bezieht, mit der Java-Version der Funktion übereinstimmt, die Sie bereitstellen möchten. Bei einer Java 21-Funktion sollte der mvn -v Befehl beispielsweise Java 21 in der Ausgabe auflisten.

  • Ihre Abhängigkeiten müssen im java/lib Verzeichnis im Stammverzeichnis der ZIP-Datei gespeichert werden. Weitere Informationen finden Sie unter Ebenenpfade für jede Lambda-Laufzeit.

  • Die Pakete in Ihrem Layer müssen mit Linux kompatibel sein. Lambda-Funktionen laufen auf Amazon Linux.

  • Wenn Ihre Ebene native Binärdateien oder ausführbare Dateien enthält, müssen diese auf dieselbe Architektur (x86_64 oder arm64) abzielen wie Ihre Funktion.

Sie können Ebenen erstellen, die entweder Java-Bibliotheken von Drittanbietern oder Ihre eigenen Java-Module und -Pakete enthalten. Das folgende Verfahren verwendet Maven. Sie können Gradle auch verwenden, um Ihren Layer-Inhalt zu verpacken.

Um eine Ebene mithilfe von Maven-Abhängigkeiten zu erstellen

  1. Erstellen Sie ein Apache Maven-Projekt mit einer pom.xml Datei, die Ihre Abhängigkeiten definiert.

    Das folgende Beispiel beinhaltet Jackson Databind für die JSON-Verarbeitung. <build>In diesem Abschnitt werden separate JAR-Dateien für jede Abhängigkeit erstellt, anstatt sie in einer einzigen Uber-Jar-Datei zu bündeln. maven-dependency-plugin Wenn Sie ein Uber-Jar erstellen möchten, verwenden Sie das. maven-shade-plugin

    Beispiel pom.xml
    <dependencies>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.17.0</version>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.13.0</version>
            <configuration>
                <source>21</source>
                <target>21</target>
                <release>21</release>
            </configuration>
        </plugin>
        
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <version>3.6.1</version>
            <executions>
                <execution>
                    <id>copy-dependencies</id>
                    <phase>package</phase>
                    <goals>
                        <goal>copy-dependencies</goal>
                    </goals>
                    <configuration>
                        <outputDirectory>${project.build.directory}/lib</outputDirectory>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

  2. Erstellen Sie das Projekt. Dieser Befehl erstellt alle JAR-Abhängigkeitsdateien im target/lib/ Verzeichnis.

    mvn clean package

  3. Erstellen Sie die erforderliche Verzeichnisstruktur für Ihre Ebene:

    mkdir -p java/lib

  4. Kopieren Sie die JAR-Abhängigkeitsdateien in das java/lib Verzeichnis:

    cp target/lib/*.jar java/lib/

  5. Den Inhalt der Ebene komprimieren:

    Linux/macOS
    zip -r layer.zip java/
    PowerShell
    Compress-Archive -Path .\java -DestinationPath .\layer.zip

    Die Verzeichnisstruktur Ihrer ZIP-Datei sollte wie folgt aussehen:

    java/              
└── lib/
    ├── jackson-databind-2.17.0.jar
    ├── jackson-core-2.17.0.jar
    └── jackson-annotations-2.17.0.jar
    Anmerkung

    Stellen Sie sicher, dass Ihre ZIP-Datei das java Verzeichnis auf der Stammebene mit lib darin enthaltenen Verzeichnis enthält. Diese Struktur stellt sicher, dass Lambda Ihre Bibliotheken finden und importieren kann. Jede Abhängigkeit wird als separate JAR-Datei gespeichert und nicht in einer Uber-JAR-Datei gebündelt.

Erstellen Sie die Ebene in Lambda

Sie können Ihren Layer entweder mit der AWS CLI oder der Lambda-Konsole veröffentlichen.

AWS CLI

Führen Sie den publish-layer-version AWS CLI Befehl aus, um die Lambda-Schicht zu erstellen:

aws lambda publish-layer-version --layer-name my-layer --zip-file fileb://layer.zip --compatible-runtimes java21

Der Parameter compatible runtimes ist optional. Wenn angegeben, verwendet Lambda diesen Parameter, um Ebenen in der Lambda-Konsole zu filtern.

Console
So erstellen Sie eine Ebene (Konsole)

  1. Öffnen Sie die Seite Ebenen der Lambda-Konsole.

  2. Wählen Sie Create Layer (Ebene erstellen) aus.

  3. Wählen Sie „.zip-Datei hochladen“ und laden Sie dann das zuvor erstellte ZIP-Archiv hoch.

  4. (Optional) Wählen Sie unter Kompatible Laufzeiten die Java-Laufzeit aus, die der Java-Version entspricht, mit der Sie den Layer erstellt haben.

  5. Wählen Sie Erstellen aus.

Fügen Sie den Layer zu Ihrer Funktion hinzu

AWS CLI

Führen Sie den update-function-configuration AWS CLI Befehl aus, um die Ebene an Ihre Funktion anzuhängen. Verwenden Sie für den --layers Parameter den Layer-ARN. Der ARN muss die Version angeben (z. B.arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1). Weitere Informationen finden Sie unter Ebenen und Ebenenversionen.

aws lambda update-function-configuration --function-name my-function --cli-binary-format raw-in-base64-out --layers "arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1"

Die cli-binary-format Option ist erforderlich, wenn Sie AWS CLI Version 2 verwenden. Um dies zur Standardeinstellung zu machen, führen Sie aws configure set cli-binary-format raw-in-base64-out aus. Weitere Informationen finden Sie unter Von AWS CLI unterstützte globale Befehlszeilenoptionen im AWS Command Line Interface -Benutzerhandbuch für Version 2.

Console
Um einer Funktion eine Ebene hinzuzufügen

  1. Öffnen Sie die Seite Funktionen der Lambda-Konsole.

  2. Wählen Sie die Funktion aus.

  3. Blättern Sie nach unten bis zum Abschnitt Ebenen und wählen Sie dann Eine Ebene hinzufügen.

  4. Wählen Sie unter Ebene auswählen die Option Benutzerdefinierte Ebenen und dann Ihre Ebene aus.

    Anmerkung

    Wenn Sie bei der Erstellung des Layers keine kompatible Runtime hinzugefügt haben, wird Ihr Layer hier nicht aufgeführt. Sie können stattdessen den Layer-ARN angeben.

  5. Wählen Sie Hinzufügen aus.