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](chapter-layers.md), um Code und Abhängigkeiten zu bündeln, die Sie für mehrere Funktionen wiederverwenden möchten. Ebenen enthalten üblicherweise Bibliotheksabhängigkeiten, eine [benutzerdefinierte Laufzeit](runtimes-custom.md) 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.
1. Erstellen Sie die Ebene in Lambda.
1. Fügen Sie die Ebene zu Ihren Funktionen hinzu.
**Topics**
+ [Verpacken Ihres Ebeneninhalts](#java-layers-package)
+ [Erstellen Sie die Ebene in Lambda](#publishing-layer)
+ [Fügen Sie die Ebene zu Ihrer Funktion hinzu](#java-layer-adding)
## 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. Für eine Java 25-Funktion sollte der `mvn -v` Befehl beispielsweise Java 25 in der Ausgabe auflisten.
+ Ihre Abhängigkeiten müssen im Verzeichnis `java/lib` im Stammverzeichnis der ZIP-Datei gespeichert werden. Weitere Informationen finden Sie unter [Ebenenpfade für jede Lambda-Laufzeit](packaging-layers.md#packaging-layers-paths).
+ Die Pakete in Ihrer Ebene müssen mit Linux kompatibel sein. Lambda-Funktionen werden auf Amazon Linux ausgeführt.
Sie können Ebenen erstellen, die entweder Java-Bibliotheken von Drittanbietern oder Ihre eigenen Java-Module und -Pakete enthalten. Im Folgenden wird Maven verwendet. Sie können auch Gradle verwenden, um den Inhalt Ihrer Ebenen zu verpacken.
**Erstellen einer Ebene mit Maven-Abhängigkeiten**
1. Erstellen Sie ein Apache-Maven-Projekt mit einer `pom.xml`-Datei, die Ihre Abhängigkeiten definiert.
Das folgende Beispiel enthält [Jackson Databind](https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind) für die JSON-Verarbeitung. ``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](https://mvnrepository.com/artifact/org.apache.maven.plugins/maven-dependency-plugin) Wenn Sie ein Uber-Jar erstellen möchten, verwenden Sie das. [maven-shade-plugin](https://maven.apache.org/plugins/maven-shade-plugin/)
**Example pom.xml**
```
com.fasterxml.jackson.corejackson-databind2.17.0org.apache.maven.pluginsmaven-compiler-plugin3.13.0212121org.apache.maven.pluginsmaven-dependency-plugin3.6.1copy-dependenciespackagecopy-dependencies${project.build.directory}/lib
```
1. Erstellen Sie das Projekt. Dieser Befehl erstellt alle JAR-Abhängigkeitsdateien im `target/lib/`-Verzeichnis.
```
mvn clean package
```
1. Erstellen Sie die erforderliche Verzeichnisstruktur für Ihre Ebene:
```
mkdir -p java/lib
```
1. Kopieren Sie die JAR-Abhängigkeitsdateien in das `java/lib`-Verzeichnis:
```
cp target/lib/*.jar java/lib/
```
1. Verpacken Sie den Ebeneninhalt:
------
#### [ 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 enthält und sich `lib` darin befindet. Diese Struktur stellt sicher, dass Lambda Ihre Bibliotheken finden und importieren kann. Jede Abhängigkeit wird als separate JAR-Datei gespeichert und nicht in einem Uber-JAR 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](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) 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 java25
```
Der Parameter [Kompatible Laufzeiten](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) ist optional. Wenn angegeben, verwendet Lambda diesen Parameter zum Filtern von Ebenen in der Lambda-Konsole.
------
#### [ Console ]
**So erstellen Sie eine Ebene (Konsole)**
1. Öffnen Sie die Seite [Ebenen](https://console.aws.amazon.com/lambda/home#/layers) der Lambda-Konsole.
1. Wählen Sie **Create Layer (Ebene erstellen)** aus.
1. Wählen Sie **ZIP-Datei hochladen** und laden Sie dann das zuvor erstellte ZIP-Archiv hoch.
1. (Optional) Wählen Sie für **Kompatible Laufzeiten** die Java-Laufzeit aus, die der Java-Version entspricht, mit der Sie die Ebene erstellt haben.
1. Wählen Sie **Erstellen** aus.
------
## Fügen Sie die Ebene zu Ihrer Funktion hinzu
------
#### [ AWS CLI ]
Führen Sie den [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) AWS CLI Befehl aus, um die Ebene an Ihre Funktion anzuhängen. Verwenden Sie den ARN der Ebene für den `--layers`-Parameter. 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](chapter-layers.md#lambda-layer-versions).
```
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](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) im *AWS Command Line Interface -Benutzerhandbuch für Version 2*.
------
#### [ Console ]
**So fügen Sie eine Ebene zu einer Funktion hinzu**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie die Funktion aus.
1. Blättern Sie nach unten bis zum Abschnitt **Ebenen** und wählen Sie dann **Eine Ebene hinzufügen**.
1. Wählen Sie unter **Ebene auswählen** die Option **Benutzerdefinierte Ebenen** und dann Ihre Ebene aus.
**Anmerkung**
Wenn Sie bei der Erstellung der Ebene keine [kompatible Laufzeit](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) hinzugefügt haben, wird die Ebene hier nicht aufgeführt. Sie können stattdessen den ARN der Ebene angeben.
1. Wählen Sie **Hinzufügen** aus.
------