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.
# Erstellen von Lambda-Funktionen mit Java
com.amazonaws
aws-lambda-java-core
1.2.2
com.amazonaws
aws-lambda-java-events
3.11.1
com.amazonaws
aws-lambda-java-log4j2
1.5.1
software.amazon.lambda.durable
aws-durable-execution-sdk-java
1.0.1
```
------
**Wichtig**
Verwenden Sie keine privaten Komponenten der JDK API, wie private Felder, Methoden oder Klassen. Nicht öffentliche API-Komponenten können sich bei jedem Update ändern oder entfernt werden, was dazu führen kann, dass Ihre Anwendung nicht mehr funktioniert.
**So erstellen Sie eine Java-Funktion**
1. Öffnen Sie die [Lambda-Konsole](https://console.aws.amazon.com/lambda).
1. Wählen Sie **Funktion erstellen**.
1. Konfigurieren Sie die folgenden Einstellungen:
+ **Funktionsname**: Geben Sie einen Namen für die Funktion ein.
+ **Runtime**: Wählen Sie **Java 25.**
1. Wählen Sie **Funktion erstellen**.
Die Konsole erstellt eine Lambda-Funktion mit einer Handler-Klasse namens `Hello`. Da es sich bei Java um eine kompilierte Sprache handelt, können Sie den Quellcode in der Lambda-Konsole nicht anzeigen oder bearbeiten, aber Sie können seine Konfiguration ändern, ihn aufrufen und Auslöser konfigurieren.
**Anmerkung**
Um mit der Anwendungsentwicklung in Ihrer lokalen Umgebung zu beginnen, stellen Sie eine der [Beispielanwendungen](java-samples.md) bereit, die im GitHub Repository dieses Handbuchs verfügbar sind.
Die `Hello`-Klasse hat eine Funktion mit dem Namen `handleRequest`, die ein Ereignisobjekt und ein Kontext-Objekt übernimmt. Dies ist die [Handler-Funktion](java-handler.md), die bei einem Aufruf der Funktion von Lambda aufgerufen wird. Die Java-Funktionslaufzeit ruft Aufrufereignisse von Lambda ab und leitet sie an den Handler weiter. In der Konfiguration der Funktion lautet der Wert für den Handler `example.Hello::handleRequest`.
Um den Funktionscode zu aktualisieren, erstellen Sie ein Bereitstellungspaket, d. h. ein ZIP-Datei-Archiv handelt, das Ihren Funktionscode enthält. Mit fortschreitender Funktionserstellung sollten Sie Ihren Funktionscode in der Versionskontrolle speichern, Bibliotheken hinzufügen und Bereitstellungen automatisieren. Beginnen Sie mit der [Erstellung eines Bereitstellungspakets](java-package.md) und der Aktualisierung Ihres Codes in der Befehlszeile.
Die Funktionslaufzeit übergibt neben dem Aufrufereignis ein Context-Objekt an den Handler. Das [Context-Objekt](java-context.md) enthält zusätzliche Informationen zum Aufruf, zur Funktion und zur Ausführungsumgebung. Weitere Informationen erhalten Sie über die Umgebungsvariablen.
Ihre Lambda-Funktion wird mit einer CloudWatch Logs-Protokollgruppe geliefert. Die Funktionslaufzeit sendet Details zu jedem Aufruf an CloudWatch Logs. Es leitet alle [Protokolle weiter, die Ihre Funktion während des Aufrufs ausgibt](java-logging.md). Wenn Ihre Funktion einen Fehler zurückgibt, formatiert Lambda den Fehler und gibt ihn an den Aufrufer zurück.
**Topics**
+ [Definieren des Lambda-Funktions-Handlers in Java](java-handler.md)
+ [Bereitstellen von Java-Lambda-Funktionen mit ZIP- oder JAR-Dateiarchiven](java-package.md)
+ [Bereitstellen von Java-Lambda-Funktionen mit Container-Images](java-image.md)
+ [Arbeiten mit Ebenen für Java Lambda-Funktionen](java-layers.md)
+ [Passen Sie die Serialisierung für Lambda-Java-Funktionen an](java-custom-serialization.md)
+ [Passen Sie das Startverhalten der Java-Laufzeit für Lambda-Funktionen an](java-customization.md)
+ [Verwenden des Lambda-Kontextobjekts zum Abrufen von Java-Funktionsinformationen](java-context.md)
+ [Java-Lambda-Funktionen protokollieren und überwachen](java-logging.md)
+ [Instrumentierung von Java-Code in AWS Lambda](java-tracing.md)
+ [Java-Beispielanwendungen für AWS Lambda](java-samples.md)
# Definieren des Lambda-Funktions-Handlers in Java
└ build.gradle OR pom.xml
```
Sie können entweder Maven oder Gradle verwenden, um Ihr Projekt zu erstellen und Abhängigkeiten zu verwalten.
Die Haupthandler-Logik für Ihre Funktion befindet sich in einer Java-Datei im Verzeichnis `src/main/java/example`. Im Beispiel auf dieser Seite nennen wir diese Datei `OrderHandler.java`. Neben dieser Datei können Sie bei Bedarf weitere Java-Klassen hinzufügen. Achten Sie beim Bereitstellen Ihrer Funktion in Lambda darauf, die Java-Klasse anzugeben, die die Haupthandler-Methode enthält, die Lambda bei einem Aufruf ausführen soll.
## Beispiel für Java-Lambda-Funktionscode
{
private static final S3Client S3_CLIENT = S3Client.builder().build();
/**
* Record to model the input event.
*/
public record Order(String orderId, double amount, String item) {}
@Override
public String handleRequest(Order event, Context context) {
try {
// Access environment variables
String bucketName = System.getenv("RECEIPT_BUCKET");
if (bucketName == null || bucketName.isEmpty()) {
throw new IllegalArgumentException("RECEIPT_BUCKET environment variable is not set");
}
// Create the receipt content and key destination
String receiptContent = String.format("OrderID: %s\nAmount: $%.2f\nItem: %s",
event.orderId(), event.amount(), event.item());
String key = "receipts/" + event.orderId() + ".txt";
// Upload the receipt to S3
uploadReceiptToS3(bucketName, key, receiptContent);
context.getLogger().log("Successfully processed order " + event.orderId() +
" and stored receipt in S3 bucket " + bucketName);
return "Success";
} catch (Exception e) {
context.getLogger().log("Failed to process order: " + e.getMessage());
throw new RuntimeException(e);
}
}
private void uploadReceiptToS3(String bucketName, String key, String receiptContent) {
try {
PutObjectRequest putObjectRequest = PutObjectRequest.builder()
.bucket(bucketName)
.key(key)
.build();
// Convert the receipt content to bytes and upload to S3
S3_CLIENT.putObject(putObjectRequest, RequestBody.fromBytes(receiptContent.getBytes(StandardCharsets.UTF_8)));
} catch (S3Exception e) {
throw new RuntimeException("Failed to upload receipt to S3: " + e.awsErrorDetails().errorMessage(), e);
}
}
}
```
Diese `OrderHandler.java`-Datei enthält die folgenden Abschnitte des Codes:
+ `package example`: In Java kann dies beliebig sein, muss jedoch mit der Verzeichnisstruktur Ihres Projekts übereinstimmen. Hier verwenden wir `package example`, da die Verzeichnisstruktur `src/main/java/example` lautet.
+ `import`-Anweisungen: Damit können Sie Java-Klassen importieren, die für Ihre Lambda-Funktion erforderlich sind.
+ `public class OrderHandler ...`: Dies definiert Ihre Java-Klasse und muss eine [gültige Klassendefinition](#java-handler-signatures) sein.
+ `private static final S3Client S3_CLIENT ...`: Dadurch wird ein S3-Client außerhalb einer der Methoden der Klasse initialisiert. Dies veranlasst Lambda, diesen Code während der [Initialisierungsphase](lambda-runtime-environment.md#runtimes-lifecycle-ib) auszuführen.
+ `public record Order ...`: Definieren Sie die Form des erwarteten Eingabeereignisses in diesem benutzerdefinierten Java-[Datensatz](https://openjdk.org/jeps/395).
+ `public String handleRequest(Order event, Context context)`: Dies ist die **Haupthandler-Methode**, die Ihre Hauptanwendungslogik enthält.
+ `private void uploadReceiptToS3(...) {}`: Dies ist eine Hilfsmethode, auf die von der `handleRequest`-Haupthandler-Methode verwiesen wird.
### Beispieldateien „build.gradle“ und „pom.xml“
4.0.0
com.example
example-java
jar
1.0-SNAPSHOT
example-java-function
UTF-8
21
21
com.amazonaws
aws-lambda-java-core
1.2.3
software.amazon.awssdk
s3
2.28.29
org.slf4j
slf4j-nop
2.0.16
maven-surefire-plugin
3.5.2
org.apache.maven.plugins
maven-shade-plugin
3.4.1
false
*:*
META-INF/*
META-INF/versions/**
package
shade
org.apache.maven.plugins
maven-compiler-plugin
3.13.0
21
```
------
Damit diese Funktion ordnungsgemäß funktioniert, muss ihre [Ausführungsrolle](lambda-intro-execution-role.md) die `s3:PutObject`-Aktion zulassen. Stellen Sie außerdem sicher, dass Sie die `RECEIPT_BUCKET`-Umgebungsvariable definieren. Nach einem erfolgreichen Aufruf sollte der Amazon-S3-Bucket eine Empfangsdatei enthalten.
**Anmerkung**
Diese Funktion erfordert möglicherweise zusätzliche Konfigurationseinstellungen, um ohne Zeitüberschreitung erfolgreich ausgeführt zu werden. Wir empfehlen, 256 MB Arbeitsspeicher und eine Zeitüberschreitung von 10 Sekunden zu konfigurieren. Der erste Aufruf kann aufgrund eines [Kaltstarts](lambda-runtime-environment.md#cold-start-latency) zusätzliche Zeit in Anspruch nehmen. Nachfolgende Aufrufe sollten aufgrund der Wiederverwendung der Ausführungsumgebung wesentlich schneller ausgeführt werden.
## Gültige Klassendefinitionen für Java-Handler
`. Der Eingabetyp ist der `Order`-Datensatz, den wir innerhalb der Klasse definieren, und der Ausgabetyp ist `String`.
```
public class OrderHandler implements RequestHandler {
...
}
```
Wenn Sie diese Schnittstelle verwenden, deserialisiert die Java-Laufzeit das Ereignis in das Objekt mit dem Eingabetyp und serialisiert die Ausgabe in Text. Verwenden Sie diese Schnittstelle, wenn die integrierte Serialisierung mit Ihren Ein- und Ausgabetypen funktioniert.
Um Ihre eigene Serialisierung zu verwenden, können Sie die `RequestStreamHandler`-Schnittstelle implementieren. Mit dieser Schnittstelle übergibt Lamda Ihrem Handler einen Eingabestream und einen Ausgabestream. Der Handler liest Bytes aus dem Eingabestream, schreibt in den Ausgabestream und gibt „void“ zurück. Ein Beispiel für die Verwendung der Java 21-Laufzeit finden Sie unter [HandlerStream.java](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/java-basic/src/main/java/example/HandlerStream.java).
Wenn Sie in Ihrer Java-Funktion nur mit grundlegenden und generischen Typen (d. h. `String`, `Integer`, `List` oder `Map`) arbeiten, müssen Sie keine Schnittstelle implementieren. Wenn Ihre Funktion beispielsweise eine `Map`-Eingabe akzeptiert und eine `String` zurückgibt, könnten Ihre Klassendefinition und Ihre Handler-Signatur wie folgt aussehen:
```
public class ExampleHandler {
public String handleRequest(Map input, Context context) {
...
}
}
```
Wenn Sie keine Schnittstelle implementieren, ist das [Kontextobjekt](java-context.md) außerdem optional. Ihre Klassendefinition und Ihre Handler-Signatur könnten beispielsweise wie folgt aussehen:
```
public class NoContextHandler {
public String handleRequest(Map input) {
...
}
}
```
## Namenskonventionen für Handler
*.** – Beispiel: `example.OrderHandler`.
Für Lambda-Funktionen in Java, die nicht die `RequestHandler`- oder `RequestStreamHandler`-Schnittstelle implementieren, können Sie einen beliebigen Namen für den Handler verwenden. Wenn Sie Ihre Funktion in Lambda bereitstellen, geben Sie den Haupthandler in der Konfiguration Ihrer Funktion im folgenden Format an:
+ **.**::** – Beispiel: `example.Handler::mainHandler`.
## Definieren Sie das Eingabeereignisobjekt und greifen Sie darauf zu
`, `List`, `List`, usw. – Das Ereignis ist ein JSON-Array. Die Laufzeitumgebung deserialisiert sie in ein Objekt des angegebenen Typs oder der angegebenen Schnittstelle.
+ `InputStream` – Das Ereignis ist ein beliebiger JSON-Typ. Die Laufzeit übergibt einen Bytestream des Dokuments ohne Änderung an den Handler. Sie deserialisieren die Eingabe und schreiben Ausgabe in einen Ausgabestream.
+ Bibliothekstyp – Bei Ereignissen, die von anderen AWS-Services gesendet werden, müssen Sie die Typen in der Bibliothek [aws-lambda-java-events](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-events) verwenden. Wenn Ihre Lambda-Funktion beispielsweise von Amazon Simple Queue Service (SQS) aufgerufen wird, verwenden Sie das `SQSEvent`-Objekt als Eingabe.
## Zugreifen auf und Verwenden des Lambda-Kontextobjekts
`-Abschnitt von `pom.xml` hinzu:
```
software.amazon.awssdk
s3
2.28.29
```
**Anmerkung**
Dies ist möglicherweise nicht die neueste Version des SDK. Wählen Sie die geeignete SDK-Version für Ihre Anwendung.
Importieren Sie dann die Abhängigkeiten direkt in Ihree Java-Klasse:
```
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import software.amazon.awssdk.services.s3.model.S3Exception;
```
Der Beispielcode initialisiert dann einen Amazon-S3-Client wie folgt:
```
private static final S3Client S3_CLIENT = S3Client.builder().build();
```
In diesem Beispiel haben wir unseren Amazon-S3-Client außerhalb der Haupt-Handler-Funktion initialisiert, um zu vermeiden, dass wir ihn bei jedem Aufruf unserer Funktion initialisieren müssen. Nachdem Sie Ihren SDK-Client initialisiert haben, können Sie ihn für die Interaktion mit anderen AWS-Services verwenden. Der Beispielcode ruft die Amazon S3 `PutObject`-API wie folgt auf:
```
PutObjectRequest putObjectRequest = PutObjectRequest.builder()
.bucket(bucketName)
.key(key)
.build();
// Convert the receipt content to bytes and upload to S3
S3_CLIENT.putObject(putObjectRequest, RequestBody.fromBytes(receiptContent.getBytes(StandardCharsets.UTF_8)));
```
## Zugriff auf Umgebungsvariablen
com.amazonaws
aws-lambda-java-core
1.2.2
com.amazonaws
aws-lambda-java-events
3.11.1
com.amazonaws
aws-lambda-java-log4j2
1.5.1
software.amazon.lambda.durable
aws-durable-execution-sdk-java
1.0.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](#java-package-gradle). Verwenden Sie für Apache Maven [das Maven Shade Plugin](#java-package-maven). 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 [Verwaltung von Lambda-Abhängigkeiten mit Ebenen](chapter-layers.md).
## Erstellen eines Bereitstellungspakets mit Gradle
org.apache.maven.plugins
maven-shade-plugin
3.2.2
false
package
shade
```
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)](https://openjdk.org/jeps/238) 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 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.
**Example pom.xml – Plugin-Konfiguration mit Log4j-2-Appender**
```
org.apache.maven.plugins
maven-shade-plugin
3.2.2
false
package
shade
com.github.edwgiz
maven-shade-plugin.log4j2-cachefile-transformer
2.13.0
```
## Hochladen eines Bereitstellungspakets mit der Lambda-Konsole
{
public String handleRequest(Object input, Context context) {
return "Hello world!";
}
}
```
1. Öffnen Sie die `build.gradle` Datei. Wenn Sie den Beispiel-Funktionscode aus dem vorherigen Schritt verwenden, ersetzen Sie den Inhalt von `build.gradle` durch den folgenden. Wenn Sie Ihren eigenen Funktionscode verwenden, ändern Sie Ihre `build.gradle`-Datei nach Bedarf.
**Example build.gradle (Groovy DSL)**
```
plugins {
id 'java'
}
group 'com.example'
version '1.0-SNAPSHOT'
sourceCompatibility = 1.8
repositories {
mavenCentral()
}
dependencies {
implementation 'com.amazonaws:aws-lambda-java-core:1.2.1'
}
jar {
manifest {
attributes 'Main-Class': 'com.example.App'
}
}
```
1. Der `gradle init`-Befehl aus Schritt 2 generierte auch einen Dummy-Testfall im `app/test`-Verzeichnis. Überspringen Sie in diesem Tutorial das Ausführen von Tests, indem Sie das `/test`-Verzeichnis löschen.
1. Erstellen Sie das Projekt.
```
gradle build
```
1. Erstellen Sie im Stammverzeichnis (`/example`) des Projekts eine Docker-Datei mit der folgenden Konfiguration:
+ Setzen Sie die `FROM`-Eigenschaft auf den [URI des Basis-Images](https://gallery.ecr.aws/lambda/java).
+ Verwenden Sie den Befehl COPY, um den Funktionscode und die Laufzeitabhängigkeiten in `{LAMBDA_TASK_ROOT}`, eine von [Lambda definierte Umgebungsvariable](configuration-envvars.md#configuration-envvars-runtime) zu kopieren.
+ Legen Sie das `CMD`-Argument auf den Lambda-Funktionshandler fest.
Beachten Sie, dass das Dockerfile-Beispiel keine [USER-Anweisung](https://docs.docker.com/reference/dockerfile/#user) enthält. Wenn Sie ein Container-Image für Lambda bereitstellen, definiert Lambda automatisch einen Standard-Linux-Benutzer mit Berechtigungen mit geringsten Rechten. Dies unterscheidet sich vom Standardverhalten von Docker, bei dem standardmäßig der `root`-Benutzer verwendet wird, wenn keine `USER`-Anweisung bereitgestellt wird.
**Example Dockerfile**
```
FROM public.ecr.aws/lambda/java:21
# Copy function code and runtime dependencies from Gradle layout
COPY app/build/classes/java/main ${LAMBDA_TASK_ROOT}
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "com.example.App::handleRequest" ]
```
1. Erstellen Sie Ihr Docker-Image mit dem [docker build](https://docs.docker.com/engine/reference/commandline/build/)-Befehl. Das folgende Beispiel benennt das Bild in `docker-image` und gibt ihm den `test` [Tag](https://docs.docker.com/engine/reference/commandline/build/#tag). Um Ihr Image mit Lambda kompatibel zu machen, müssen Sie die Option `--provenance=false` verwenden.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**Anmerkung**
Der Befehl gibt die `--platform linux/amd64`-Option an, um sicherzustellen, dass Ihr Container mit der Lambda-Ausführungsumgebung kompatibel ist, unabhängig von der Architektur des Entwicklungsrechners. Wenn Sie beabsichtigen, eine Lambda-Funktion mithilfe der ARM64 Befehlssatzarchitektur zu erstellen, müssen Sie den Befehl so ändern, dass er stattdessen die `--platform linux/arm64` Option verwendet.
------
### (Optional) Testen Sie das Image lokal
` durch den `repositoryUri`, den Sie kopiert haben. Stellen Sie sicher, dass Sie `:latest` am Ende der URI angeben.
```
docker tag docker-image:test :latest
```
Beispiel:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Führen Sie den Befehl [docker push](https://docs.docker.com/engine/reference/commandline/push/) aus, um Ihr lokales Image im Amazon-ECR-Repository bereitzustellen. Stellen Sie sicher, dass Sie `:latest` am Ende der Repository-URI angeben.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Erstellen Sie eine Ausführungsrolle](lambda-intro-execution-role.md#permissions-executionrole-api) für die Funktion, wenn Sie noch keine haben. Sie benötigen den Amazon-Ressourcennamen (ARN) der Rolle im nächsten Schritt.
1. So erstellen Sie die Lambda-Funktion: Geben Sie für `ImageUri` die Repository-URI von zuvor an. Stellen Sie sicher, dass Sie `:latest` am Ende der URI angeben.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**Anmerkung**
Sie können eine Funktion mit einem Bild in einem anderen AWS Konto erstellen, sofern sich das Bild in derselben Region wie die Lambda-Funktion befindet. Weitere Informationen finden Sie unter [Kontoübergreifende Berechtigungen von Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Die Funktion aufrufen.
```
aws lambda invoke --function-name hello-world response.json
```
Das Ergebnis sollte ungefähr wie folgt aussehen:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Um die Ausgabe der Funktion zu sehen, überprüfen Sie die `response.json`-Datei.
Um den Funktionscode zu aktualisieren, müssen Sie das Image erneut erstellen, das neue Image in das Amazon ECR-Repository hochladen und dann den [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Befehl verwenden, um das Image für die Lambda-Funktion bereitzustellen.
Lambda löst das Image-Tag in einen bestimmten Image-Digest auf. Das heißt, wenn Sie das Image-Tag, das zur Bereitstellung der Funktion verwendet wurde, auf ein neues Image in Amazon ECR verweisen, aktualisiert Lambda die Funktion nicht automatisch, um das neue Image zu verwenden.
Um das neue Image für dieselbe Lambda-Funktion bereitzustellen, müssen Sie den [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Befehl verwenden, auch wenn das Image-Tag in Amazon ECR gleich bleibt. Im folgenden Beispiel erstellt die `--publish`-Option eine neue Version der Funktion unter Verwendung des aktualisierten Container-Images.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
## Verwenden eines alternativen Basis-Images mit dem Laufzeitschnittstellen-Client
com.amazonaws
aws-lambda-java-runtime-interface-client
2.3.2
```
Einzelheiten zum Paket finden Sie unter [AWS Lambda Java Runtime Interface Client](https://mvnrepository.com/artifact/com.amazonaws/aws-lambda-java-runtime-interface-client) im Maven-Central-Repository. Sie können den Quellcode des Runtime-Interface-Clients auch im GitHub Repository der [AWS Lambda Java Support Libraries](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-runtime-interface-client) überprüfen.
Das folgende Beispiel zeigt, wie Sie mithilfe eines [Amazon-Corretto-Images](https://gallery.ecr.aws/amazoncorretto/amazoncorretto) ein Container-Image für Java erstellen. Amazon Corretto ist eine kostenlose, plattformübergreifende und produktionsbereite Distribution des Open Java Development Kit (OpenJDK). Das Maven-Projekt beinhaltet den Laufzeitschnittstellen-Client als Abhängigkeit.
### Voraussetzungen
4.0.0
example
hello-lambda
jar
1.0-SNAPSHOT
hello-lambda
http://maven.apache.org
1.8
1.8
com.amazonaws
aws-lambda-java-runtime-interface-client
2.3.2
org.apache.maven.plugins
maven-dependency-plugin
3.1.2
copy-dependencies
package
copy-dependencies
```
1. Öffnen Sie das `myapp/src/main/java/com/example/myapp`-Verzeichnis, und suchen Sie die `App.java`-Datei. Dies ist der Code für die Lambda-Funktion. Ersetzen Sie den Code durch Folgendes:
**Example Funktions-Handler**
```
package example;
public class App {
public static String sayHello() {
return "Hello world!";
}
}
```
1. Der `mvn -B archetype:generate`-Befehl aus Schritt 1 generierte auch einen Dummy-Testfall im `src/test`-Verzeichnis. Überspringen Sie in diesem Tutorial das Ausführen von Tests, indem Sie das gesamte generierte Verzeichnis `/test` löschen.
1. Navigieren Sie zurück zum Stammverzeichnis des Projekts und erstellen Sie dann ein neues Dockerfile. Das folgende Beispiel-Dockerfile verwendet ein [Amazon-Corretto-Image](https://gallery.ecr.aws/amazoncorretto/amazoncorretto). Amazon Corretto ist eine kostenlose, plattformübergreifende und produktionsbereite Distribution des OpenJDK.
+ Setzen Sie die `FROM`-Eigenschaft auf den URI des Basis-Images.
+ Legen Sie `ENTRYPOINT` auf das Modul fest, das der Docker-Container beim Start ausführen soll. In diesem Fall ist das Modul der Laufzeitschnittstellen-Client.
+ Legen Sie das `CMD`-Argument auf den Lambda-Funktionshandler fest.
Beachten Sie, dass das Dockerfile-Beispiel keine [USER-Anweisung](https://docs.docker.com/reference/dockerfile/#user) enthält. Wenn Sie ein Container-Image für Lambda bereitstellen, definiert Lambda automatisch einen Standard-Linux-Benutzer mit Berechtigungen mit geringsten Rechten. Dies unterscheidet sich vom Standardverhalten von Docker, bei dem standardmäßig der `root`-Benutzer verwendet wird, wenn keine `USER`-Anweisung bereitgestellt wird.
**Example Dockerfile**
```
FROM public.ecr.aws/amazoncorretto/amazoncorretto:21 as base
# Configure the build environment
FROM base as build
RUN yum install -y maven
WORKDIR /src
# Cache and copy dependencies
ADD pom.xml .
RUN mvn dependency:go-offline dependency:copy-dependencies
# Compile the function
ADD . .
RUN mvn package
# Copy the function artifact and dependencies onto a clean base
FROM base
WORKDIR /function
COPY --from=build /src/target/dependency/*.jar ./
COPY --from=build /src/target/*.jar ./
# Set runtime interface client as default command for the container runtime
ENTRYPOINT [ "/usr/bin/java", "-cp", "./*", "com.amazonaws.services.lambda.runtime.api.client.AWSLambda" ]
# Pass the name of the function handler as an argument to the runtime
CMD [ "example.App::sayHello" ]
```
1. Erstellen Sie Ihr Docker-Image mit dem [docker build](https://docs.docker.com/engine/reference/commandline/build/)-Befehl. Das folgende Beispiel benennt das Bild in `docker-image` und gibt ihm den `test` [Tag](https://docs.docker.com/engine/reference/commandline/build/#tag). Um Ihr Image mit Lambda kompatibel zu machen, müssen Sie die Option `--provenance=false` verwenden.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**Anmerkung**
Der Befehl gibt die `--platform linux/amd64`-Option an, um sicherzustellen, dass Ihr Container mit der Lambda-Ausführungsumgebung kompatibel ist, unabhängig von der Architektur des Entwicklungsrechners. Wenn Sie beabsichtigen, eine Lambda-Funktion mithilfe der ARM64 Befehlssatzarchitektur zu erstellen, müssen Sie den Befehl so ändern, dass er stattdessen die `--platform linux/arm64` Option verwendet.
### (Optional) Testen Sie das Image lokal
` durch den `repositoryUri`, den Sie kopiert haben. Stellen Sie sicher, dass Sie `:latest` am Ende der URI angeben.
```
docker tag docker-image:test :latest
```
Beispiel:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Führen Sie den Befehl [docker push](https://docs.docker.com/engine/reference/commandline/push/) aus, um Ihr lokales Image im Amazon-ECR-Repository bereitzustellen. Stellen Sie sicher, dass Sie `:latest` am Ende der Repository-URI angeben.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Erstellen Sie eine Ausführungsrolle](lambda-intro-execution-role.md#permissions-executionrole-api) für die Funktion, wenn Sie noch keine haben. Sie benötigen den Amazon-Ressourcennamen (ARN) der Rolle im nächsten Schritt.
1. So erstellen Sie die Lambda-Funktion: Geben Sie für `ImageUri` die Repository-URI von zuvor an. Stellen Sie sicher, dass Sie `:latest` am Ende der URI angeben.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**Anmerkung**
Sie können eine Funktion mit einem Bild in einem anderen AWS Konto erstellen, sofern sich das Bild in derselben Region wie die Lambda-Funktion befindet. Weitere Informationen finden Sie unter [Kontoübergreifende Berechtigungen von Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Die Funktion aufrufen.
```
aws lambda invoke --function-name hello-world response.json
```
Das Ergebnis sollte ungefähr wie folgt aussehen:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Um die Ausgabe der Funktion zu sehen, überprüfen Sie die `response.json`-Datei.
Um den Funktionscode zu aktualisieren, müssen Sie das Image erneut erstellen, das neue Image in das Amazon ECR-Repository hochladen und dann den [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Befehl verwenden, um das Image für die Lambda-Funktion bereitzustellen.
Lambda löst das Image-Tag in einen bestimmten Image-Digest auf. Das heißt, wenn Sie das Image-Tag, das zur Bereitstellung der Funktion verwendet wurde, auf ein neues Image in Amazon ECR verweisen, aktualisiert Lambda die Funktion nicht automatisch, um das neue Image zu verwenden.
Um das neue Image für dieselbe Lambda-Funktion bereitzustellen, müssen Sie den [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Befehl verwenden, auch wenn das Image-Tag in Amazon ECR gleich bleibt. Im folgenden Beispiel erstellt die `--publish`-Option eine neue Version der Funktion unter Verwendung des aktualisierten Container-Images.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
# Arbeiten mit Ebenen für Java Lambda-Funktionen
`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.core
jackson-databind
2.17.0
org.apache.maven.plugins
maven-compiler-plugin
3.13.0
21
21
21
org.apache.maven.plugins
maven-dependency-plugin
3.6.1
copy-dependencies
package
copy-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
, Void>{
@Override
public Void handleRequest(Map event, Context context)
{
LambdaLogger logger = context.getLogger();
logger.log("EVENT TYPE: " + event.getClass());
return null;
}
}
```
Die Funktion protokolliert den Klassentyp des eingehenden Ereignisses, bevor sie `null` zurückgibt.
**Example Protokollausgabe**
```
EVENT TYPE: class java.util.LinkedHashMap
```
Die Schnittstelle für das Kontextobjekt ist in der [aws-lambda-java-core](https://github.com/aws/aws-lambda-java-libs/tree/master/aws-lambda-java-core)-Bibliothek verfügbar. Sie können diese Schnittstelle implementieren, um eine Kontextklasse zum Testen zu erstellen. Das folgende Beispiel zeigt eine Kontextklasse, die Dummy-Werte für die meisten Eigenschaften und einen funktionierenden Testlogger zurückgibt.
**Example [src/test/java/example/TestContext.java](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/java-basic/src/test/java/example/TestContext.java)**
```
package example;
import [com.amazonaws.services.lambda.runtime.Context](https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/Context.java);
import [com.amazonaws.services.lambda.runtime.CognitoIdentity](https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/CognitoIdentity.java);
import [com.amazonaws.services.lambda.runtime.ClientContext](https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/ClientContext.java);
import [com.amazonaws.services.lambda.runtime.LambdaLogger](https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/LambdaLogger.java);
public class TestContext implements Context{
public TestContext() {}
public String getAwsRequestId(){
return new String("495b12a8-xmpl-4eca-8168-160484189f99");
}
public String getLogGroupName(){
return new String("/aws/lambda/my-function");
}
public String getLogStreamName(){
return new String("2020/02/26/[$LATEST]704f8dxmpla04097b9134246b8438f1a");
}
public String getFunctionName(){
return new String("my-function");
}
public String getFunctionVersion(){
return new String("$LATEST");
}
public String getInvokedFunctionArn(){
return new String("arn:aws:lambda:us-east-2:123456789012:function:my-function");
}
public CognitoIdentity getIdentity(){
return null;
}
public ClientContext getClientContext(){
return null;
}
public int getRemainingTimeInMillis(){
return 300000;
}
public int getMemoryLimitInMB(){
return 512;
}
public LambdaLogger getLogger(){
return new TestLogger();
}
}
```
Weitere Informationen zu Protokollierung finden Sie unter [Java-Lambda-Funktionen protokollieren und überwachen](java-logging.md).
## Kontext in Beispielanwendungen
{
Gson gson = new GsonBuilder().setPrettyPrinting().create();
@Override
public String handleRequest(Object event, Context context)
{
LambdaLogger logger = context.getLogger();
String response = new String("SUCCESS");
// log execution details
logger.log("ENVIRONMENT VARIABLES: " + gson.toJson(System.getenv()));
logger.log("CONTEXT: " + gson.toJson(context));
// process event
logger.log("EVENT: " + gson.toJson(event));
return response;
}
}
```
**Example Protokollformat**
```
START RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Version: $LATEST
ENVIRONMENT VARIABLES:
{
"_HANDLER": "example.Handler",
"AWS_EXECUTION_ENV": "AWS_Lambda_java8",
"AWS_LAMBDA_FUNCTION_MEMORY_SIZE": "512",
...
}
CONTEXT:
{
"memoryLimit": 512,
"awsRequestId": "6bc28136-xmpl-4365-b021-0ce6b2e64ab0",
"functionName": "java-console",
...
}
EVENT:
{
"records": [
{
"messageId": "19dd0b57-xmpl-4ac1-bd88-01bbb068cb78",
"receiptHandle": "MessageReceiptHandle",
"body": "Hello from SQS!",
...
}
]
}
END RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0
REPORT RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Duration: 198.50 ms Billed Duration: 724 ms Memory Size: 512 MB Max Memory Used: 90 MB Init Duration: 524.75 ms
```
Die Java-Laufzeit protokolliert die Zeilen `START`, `END` und `REPORT` für jeden Aufruf. Die Berichtszeile enthält die folgenden Details:
**Datenfelder für REPORT-Zeilen**
+ **RequestId**— Die eindeutige Anforderungs-ID für den Aufruf.
+ **Dauer** – Die Zeit, die die Handler-Methode Ihrer Funktion mit der Verarbeitung des Ereignisses verbracht hat.
+ **Fakturierte Dauer** – Die für den Aufruf fakturierte Zeit.
+ **Speichergröße** – Die der Funktion zugewiesene Speichermenge.
+ **Max. verwendeter Speicher** – Die Speichermenge, die von der Funktion verwendet wird. Wenn Aufrufe eine Ausführungsumgebung gemeinsam nutzen, meldet Lambda den maximalen Speicherverbrauch für alle Aufrufe. Dieses Verhalten kann zu einem höheren als erwarteten gemeldeten Wert führen.
+ **Initialisierungsdauer** – Für die erste Anfrage die Zeit, die zur Laufzeit zum Laden der Funktion und Ausführen von Code außerhalb der Handler-Methode benötigt wurde.
+ **XRAY TraceId** [— Für verfolgte Anfragen die AWS X-Ray Trace-ID.](services-xray.md)
+ **SegmentId**— Für verfolgte Anfragen die X-Ray-Segment-ID.
+ **Stichprobe** – Bei verfolgten Anforderungen das Stichprobenergebnis.
## Verwenden von Lambda-Optionen für die erweiterte Protokollierung mit Java
%d{yyyy-MM-dd HH:mm:ss} %X{AWSRequestId} %-5p %c{1} - %m%n
```
Sie können entscheiden, wie Ihre Log4j2-Protokolle entweder für Klartext- oder JSON-Ausgaben konfiguriert werden sollen, indem Sie unter den Tags `` und `` ein Layout angeben.
In diesem Beispiel wird im Textmodus jeder Zeile das Datum, die Uhrzeit, die Anforderungs-ID, die Protokollstufe und der Klassenname vorangestellt. Im JSON-Modus wird das `` mit einer Konfiguration verwendet, die zusammen mit der `aws-lambda-java-log4j2`-Bibliothek geliefert wird.
SLF4J ist eine Fassadenbibliothek zum Einloggen in Java-Code. In Ihrem Funktionscode verwenden Sie die SLF4 J Logger Factory, um einen Logger mit Methoden für Log-Levels wie `info()` und abzurufen`warn()`. In Ihrer Build-Konfiguration nehmen Sie die Logging-Bibliothek und den SLF4 J-Adapter in den Klassenpfad auf. Indem Sie die Bibliotheken in der Build-Konfiguration ändern, können Sie den Logger-Typ ändern, ohne Ihren Funktionscode zu ändern. SLF4J ist erforderlich, um Protokolle aus dem SDK for Java zu erfassen.
Im folgenden Beispielcode verwendet die Handler-Klasse SLF4 J, um einen Logger abzurufen.
**Example [src/main/java/example/HandlerS3.java](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/java-events/src/main/java/example/HandlerS3.java) — Protokollierung mit SLF4 J**
```
package example;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.S3Event;
import static org.apache.logging.log4j.CloseableThreadContext.put;
public class HandlerS3 implements RequestHandler{
private static final Logger logger = LoggerFactory.getLogger(HandlerS3.class);
@Override
public String handleRequest(S3Event event, Context context) {
for(var record : event.getRecords()) {
try (var loggingCtx = put("awsRegion", record.getAwsRegion())) {
loggingCtx.put("eventName", record.getEventName());
loggingCtx.put("bucket", record.getS3().getBucket().getName());
loggingCtx.put("key", record.getS3().getObject().getKey());
logger.info("Handling s3 event");
}
}
return "Ok";
}
}
```
Es wird eine ähnliche Protokollausgabe wie die folgende erstellt:
**Example Protokollformat**
```
{
"timestamp": "2023-11-15T16:56:00.815Z",
"level": "INFO",
"message": "Handling s3 event",
"logger": "example.HandlerS3",
"AWSRequestId": "0bced576-3936-4e5a-9dcd-db9477b77f97",
"awsRegion": "eu-south-1",
"bucket": "java-logging-test-input-bucket",
"eventName": "ObjectCreated:Put",
"key": "test-folder/"
}
```
Die Build-Konfiguration verwendet Laufzeitabhängigkeiten vom Lambda-Appender und SLF4 J-Adapter sowie Implementierungsabhängigkeiten von Log4j2.
**Example build.gradle – Protokollierungsabhängigkeiten**
```
dependencies {
...
'com.amazonaws:aws-lambda-java-log4j2:[1.6.0,)',
'com.amazonaws:aws-lambda-java-events:[3.11.3,)',
'org.apache.logging.log4j:log4j-layout-template-json:[2.17.1,)',
'org.apache.logging.log4j:log4j-slf4j2-impl:[2.19.0,)',
...
}
```
Wenn Sie Ihren Code vor Ort für Tests ausführen, ist das Kontextobjekt mit dem Lambda-Logger nicht verfügbar, und es gibt keine Anforderungs-ID, die der Lambda-Appender verwenden kann. Beispiele für Testkonfigurationen finden Sie in den Beispielanwendungen im nächsten Abschnitt.
## Andere Tools und Bibliotheken für die Protokollierung verwenden
```
Wenn der Link erfolgreich ausgeführt wurde, sehen Sie die folgende Antwort:
```
{"message":"hello world"}
```
1. Führen Sie [sam logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html) aus, um die Protokolle für die Funktion abzurufen. Weitere Informationen finden Sie unter [Arbeiten mit Protokollen](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) im *AWS Serverless Application Model -Entwicklerhandbuch*.
```
sam logs --stack-name sam-app
```
Das Ergebnis sieht folgendermaßen aus:
```
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:34.095000 INIT_START Runtime Version: java:11.v15 Runtime Version ARN: arn:aws:lambda:eu-central-1::runtime:0a25e3e7a1cc9ce404bc435eeb2ad358d8fa64338e618d0c224fe509403583ca
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:34.114000 Picked up JAVA_TOOL_OPTIONS: -XX:+TieredCompilation -XX:TieredStopAtLevel=1
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:34.793000 Transforming org/apache/logging/log4j/core/lookup/JndiLookup (lambdainternal.CustomerClassLoader@1a6c5a9e)
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:35.252000 START RequestId: 7fcf1548-d2d4-41cd-a9a8-6ae47c51f765 Version: $LATEST
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.531000 {
"_aws": {
"Timestamp": 1675416276051,
"CloudWatchMetrics": [
{
"Namespace": "sam-app-powerools-java",
"Metrics": [
{
"Name": "ColdStart",
"Unit": "Count"
}
],
"Dimensions": [
[
"Service",
"FunctionName"
]
]
}
]
},
"function_request_id": "7fcf1548-d2d4-41cd-a9a8-6ae47c51f765",
"traceId": "Root=1-63dcd2d1-25f90b9d1c753a783547f4dd;Parent=e29684c1be352ce4;Sampled=1",
"FunctionName": "sam-app-HelloWorldFunction-y9Iu1FLJJBGD",
"functionVersion": "$LATEST",
"ColdStart": 1.0,
"Service": "service_undefined",
"logStreamId": "2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81",
"executionEnvironment": "AWS_Lambda_java11"
}
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.974000 Feb 03, 2023 9:24:36 AM com.amazonaws.xray.AWSXRayRecorder
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.993000 Feb 03, 2023 9:24:36 AM com.amazonaws.xray.config.DaemonConfiguration
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.993000 INFO: Environment variable AWS_XRAY_DAEMON_ADDRESS is set. Emitting to daemon on address XXXX.XXXX.XXXX.XXXX:2000.
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:37.331000 09:24:37.294 [main] INFO helloworld.App - {"version":null,"resource":"/hello","path":"/hello/","httpMethod":"GET","headers":{"Accept":"*/*","CloudFront-Forwarded-Proto":"https","CloudFront-Is-Desktop-Viewer":"true","CloudFront-Is-Mobile-Viewer":"false","CloudFront-Is-SmartTV-Viewer":"false","CloudFront-Is-Tablet-Viewer":"false","CloudFront-Viewer-ASN":"16509","CloudFront-Viewer-Country":"IE","Host":"XXXX.execute-api.eu-central-1.amazonaws.com","User-Agent":"curl/7.86.0","Via":"2.0 f0300a9921a99446a44423d996042050.cloudfront.net (CloudFront)","X-Amz-Cf-Id":"t9W5ByT11HaY33NM8YioKECn_4eMpNsOMPfEVRczD7T1RdhbtiwV1Q==","X-Amzn-Trace-Id":"Root=1-63dcd2d1-25f90b9d1c753a783547f4dd","X-Forwarded-For":"XX.XXX.XXX.XX, XX.XXX.XXX.XX","X-Forwarded-Port":"443","X-Forwarded-Proto":"https"},"multiValueHeaders":{"Accept":["*/*"],"CloudFront-Forwarded-Proto":["https"],"CloudFront-Is-Desktop-Viewer":["true"],"CloudFront-Is-Mobile-Viewer":["false"],"CloudFront-Is-SmartTV-Viewer":["false"],"CloudFront-Is-Tablet-Viewer":["false"],"CloudFront-Viewer-ASN":["16509"],"CloudFront-Viewer-Country":["IE"],"Host":["XXXX.execute-api.eu-central-1.amazonaws.com"],"User-Agent":["curl/7.86.0"],"Via":["2.0 f0300a9921a99446a44423d996042050.cloudfront.net (CloudFront)"],"X-Amz-Cf-Id":["t9W5ByT11HaY33NM8YioKECn_4eMpNsOMPfEVRczD7T1RdhbtiwV1Q=="],"X-Amzn-Trace-Id":["Root=1-63dcd2d1-25f90b9d1c753a783547f4dd"],"X-Forwarded-For":["XXX, XXX"],"X-Forwarded-Port":["443"],"X-Forwarded-Proto":["https"]},"queryStringParameters":null,"multiValueQueryStringParameters":null,"pathParameters":null,"stageVariables":null,"requestContext":{"accountId":"XXX","stage":"Prod","resourceId":"at73a1","requestId":"ba09ecd2-acf3-40f6-89af-fad32df67597","operationName":null,"identity":{"cognitoIdentityPoolId":null,"accountId":null,"cognitoIdentityId":null,"caller":null,"apiKey":null,"principalOrgId":null,"sourceIp":"54.240.197.236","cognitoAuthenticationType":null,"cognitoAuthenticationProvider":null,"userArn":null,"userAgent":"curl/7.86.0","user":null,"accessKey":null},"resourcePath":"/hello","httpMethod":"GET","apiId":"XXX","path":"/Prod/hello/","authorizer":null},"body":null,"isBase64Encoded":false}
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:37.351000 09:24:37.351 [main] INFO helloworld.App - Retrieving https://checkip.amazonaws.com
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:39.313000 {
"function_request_id": "7fcf1548-d2d4-41cd-a9a8-6ae47c51f765",
"traceId": "Root=1-63dcd2d1-25f90b9d1c753a783547f4dd;Parent=e29684c1be352ce4;Sampled=1",
"xray_trace_id": "1-63dcd2d1-25f90b9d1c753a783547f4dd",
"functionVersion": "$LATEST",
"Service": "service_undefined",
"logStreamId": "2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81",
"executionEnvironment": "AWS_Lambda_java11"
}
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:39.371000 END RequestId: 7fcf1548-d2d4-41cd-a9a8-6ae47c51f765
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:39.371000 REPORT RequestId: 7fcf1548-d2d4-41cd-a9a8-6ae47c51f765 Duration: 4118.98 ms Billed Duration: 5275 ms Memory Size: 512 MB Max Memory Used: 152 MB Init Duration: 1155.47 ms
XRAY TraceId: 1-63dcd2d1-25f90b9d1c753a783547f4dd SegmentId: 3a028fee19b895cb Sampled: true
```
1. Dies ist ein öffentlicher API-Endpunkt, der über das Internet zugänglich ist. Es wird empfohlen, dass Sie den Endpunkt nach dem Testen löschen.
```
sam delete
```
### Verwalten der Protokollaufbewahrung
```
Wenn der Link erfolgreich ausgeführt wurde, sehen Sie die folgende Antwort:
```
{"message":"hello world"}
```
1. Führen Sie [sam traces](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html) aus, um die Traces für die Funktion zu erhalten.
```
sam traces
```
Das Nachverfolgungsergebnis sieht folgendermaßen aus:
```
New XRay Service Graph
Start time: 2025-02-03 14:31:48+01:00
End time: 2025-02-03 14:31:48+01:00
Reference Id: 0 - (Root) AWS::Lambda - sam-app-HelloWorldFunction-y9Iu1FLJJBGD - Edges: []
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 5.587
Reference Id: 1 - client - sam-app-HelloWorldFunction-y9Iu1FLJJBGD - Edges: [0]
Summary_statistics:
- total requests: 0
- ok count(2XX): 0
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0
XRay Event [revision 3] at (2025-02-03T14:31:48.500000) with id (1-63dd0cc4-3c869dec72a586875da39777) and duration (5.603s)
- 5.587s - sam-app-HelloWorldFunction-y9Iu1FLJJBGD [HTTP: 200]
- 4.053s - sam-app-HelloWorldFunction-y9Iu1FLJJBGD
- 1.181s - Initialization
- 4.037s - Invocation
- 1.981s - ## handleRequest
- 1.840s - ## getPageContents
- 0.000s - Overhead
```
1. Dies ist ein öffentlicher API-Endpunkt, der über das Internet zugänglich ist. Es wird empfohlen, dass Sie den Endpunkt nach dem Testen löschen.
```
sam delete
```
## Verwendung von Powertools für AWS Lambda (Java) und AWS CDK für die Ablaufverfolgung
4.0.0
helloworld
Function
jar
1.0-SNAPSHOT
Function
http://maven.apache.org
11
11
2.17.2
junit
junit
3.8.1
test
software.amazon.lambda
powertools-tracing
1.3.0
software.amazon.lambda
powertools-metrics
1.3.0
software.amazon.lambda
powertools-logging
1.3.0
com.amazonaws
aws-lambda-java-core
1.2.2
com.amazonaws
aws-lambda-java-events
3.11.1
org.codehaus.mojo
aspectj-maven-plugin
1.14.0
${maven.compiler.source}
${maven.compiler.target}
${maven.compiler.target}
software.amazon.lambda
powertools-tracing
software.amazon.lambda
powertools-metrics
software.amazon.lambda
powertools-logging
compile
org.apache.maven.plugins
maven-shade-plugin
3.4.1
package
shade
false
function
com.github.edwgiz
maven-shade-plugin.log4j2-cachefile-transformer
2.15
```
1. Erstellen Sie das `hello-world\app\src\main\resource`-Verzeichnis und erstellen Sie `log4j.xml` für die Protokollkonfiguration.
```
mkdir -p src/main/resource
cd src/main/resource
touch log4j.xml
```
1. Öffnen Sie `log4j.xml` und fügen Sie den folgenden Code hinzu.
```
```
1. Öffnen Sie `App.java` aus dem `hello-world\app\Function\src\main\java\helloworld`-Verzeichnis und ersetzen Sie den vorhandenen Code durch den folgenden Code. Dies ist der Code für die Lambda-Funktion.
```
package helloworld;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import software.amazon.lambda.powertools.logging.Logging;
import software.amazon.lambda.powertools.metrics.Metrics;
import software.amazon.lambda.powertools.tracing.CaptureMode;
import software.amazon.lambda.powertools.tracing.Tracing;
import static software.amazon.lambda.powertools.tracing.CaptureMode.*;
/**
* Handler for requests to Lambda function.
*/
public class App implements RequestHandler {
Logger log = LogManager.getLogger(App.class);
@Logging(logEvent = true)
@Tracing(captureMode = DISABLED)
@Metrics(captureColdStart = true)
public APIGatewayProxyResponseEvent handleRequest(final APIGatewayProxyRequestEvent input, final Context context) {
Map headers = new HashMap<>();
headers.put("Content-Type", "application/json");
headers.put("X-Custom-Header", "application/json");
APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent()
.withHeaders(headers);
try {
final String pageContents = this.getPageContents("https://checkip.amazonaws.com");
String output = String.format("{ \"message\": \"hello world\", \"location\": \"%s\" }", pageContents);
return response
.withStatusCode(200)
.withBody(output);
} catch (IOException e) {
return response
.withBody("{}")
.withStatusCode(500);
}
}
@Tracing(namespace = "getPageContents")
private String getPageContents(String address) throws IOException {
log.info("Retrieving {}", address);
URL url = new URL(address);
try (BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream()))) {
return br.lines().collect(Collectors.joining(System.lineSeparator()));
}
}
}
```
1. Öffnen Sie `HelloWorldStack.java` aus dem `hello-world\src\main\java\com\myorg`-Verzeichnis und ersetzen Sie den vorhandenen Code durch den folgenden Code. Dieser Code verwendet [Lambda Constructor](https://docs.aws.amazon.com/cdk/api/v1/java/aws_cdk.aws_lambda.html) und den [ApiGatewayv2 Constructor](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigatewayv2-readme.html), um eine REST-API und eine Lambda-Funktion zu erstellen.
```
package com.myorg;
import software.amazon.awscdk.*;
import software.amazon.awscdk.services.apigatewayv2.alpha.*;
import software.amazon.awscdk.services.apigatewayv2.integrations.alpha.HttpLambdaIntegration;
import software.amazon.awscdk.services.apigatewayv2.integrations.alpha.HttpLambdaIntegrationProps;
import software.amazon.awscdk.services.lambda.Code;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.FunctionProps;
import software.amazon.awscdk.services.lambda.Runtime;
import software.amazon.awscdk.services.lambda.Tracing;
import software.amazon.awscdk.services.logs.RetentionDays;
import software.amazon.awscdk.services.s3.assets.AssetOptions;
import software.constructs.Construct;
import java.util.Arrays;
import java.util.List;
import static java.util.Collections.singletonList;
import static software.amazon.awscdk.BundlingOutput.ARCHIVED;
public class HelloWorldStack extends Stack {
public HelloWorldStack(final Construct scope, final String id) {
this(scope, id, null);
}
public HelloWorldStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
List functionPackagingInstructions = Arrays.asList(
"/bin/sh",
"-c",
"cd Function " +
"&& mvn clean install " +
"&& cp /asset-input/Function/target/function.jar /asset-output/"
);
BundlingOptions.Builder builderOptions = BundlingOptions.builder()
.command(functionPackagingInstructions)
.image(Runtime.JAVA_11.getBundlingImage())
.volumes(singletonList(
// Mount local .m2 repo to avoid download all the dependencies again inside the container
DockerVolume.builder()
.hostPath(System.getProperty("user.home") + "/.m2/")
.containerPath("/root/.m2/")
.build()
))
.user("root")
.outputType(ARCHIVED);
Function function = new Function(this, "Function", FunctionProps.builder()
.runtime(Runtime.JAVA_11)
.code(Code.fromAsset("app", AssetOptions.builder()
.bundling(builderOptions
.command(functionPackagingInstructions)
.build())
.build()))
.handler("helloworld.App::handleRequest")
.memorySize(1024)
.tracing(Tracing.ACTIVE)
.timeout(Duration.seconds(10))
.logRetention(RetentionDays.ONE_WEEK)
.build());
HttpApi httpApi = new HttpApi(this, "sample-api", HttpApiProps.builder()
.apiName("sample-api")
.build());
httpApi.addRoutes(AddRoutesOptions.builder()
.path("/")
.methods(singletonList(HttpMethod.GET))
.integration(new HttpLambdaIntegration("function", function, HttpLambdaIntegrationProps.builder()
.payloadFormatVersion(PayloadFormatVersion.VERSION_2_0)
.build()))
.build());
new CfnOutput(this, "HttpApi", CfnOutputProps.builder()
.description("Url for Http Api")
.value(httpApi.getApiEndpoint())
.build());
}
}
```
1. Öffnen Sie `pom.xml` aus dem `hello-world`-Verzeichnis und ersetzen Sie den vorhandenen Code durch den folgenden Code.
```
4.0.0
com.myorg
hello-world
0.1
UTF-8
2.70.0
[10.0.0,11.0.0)
5.7.1
org.apache.maven.plugins
maven-compiler-plugin
3.8.1
1.8
1.8
org.codehaus.mojo
exec-maven-plugin
3.0.0
com.myorg.HelloWorldApp
software.amazon.awscdk
aws-cdk-lib
${cdk.version}
software.constructs
constructs
${constructs.version}
org.junit.jupiter
junit-jupiter
${junit.version}
test
software.amazon.awscdk
apigatewayv2-alpha
${cdk.version}-alpha.0
software.amazon.awscdk
apigatewayv2-integrations-alpha
${cdk.version}-alpha.0
```
1. Stellen Sie sicher, dass Sie sich im `hello-world`-Verzeichnis befinden, und stellen Sie Ihre Anwendung bereit.
```
cdk deploy
```
1. Rufen Sie die URL der bereitgestellten Anwendung ab:
```
aws cloudformation describe-stacks --stack-name HelloWorldStack --query 'Stacks[0].Outputs[?OutputKey==`HttpApi`].OutputValue' --output text
```
1. Rufen Sie den API-Endpunkt auf:
```
curl -X GET
```
Wenn der Link erfolgreich ausgeführt wurde, sehen Sie die folgende Antwort:
```
{"message":"hello world"}
```
1. Führen Sie [sam traces](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html) aus, um die Traces für die Funktion zu erhalten.
```
sam traces
```
Das Nachverfolgungsergebnis sieht folgendermaßen aus:
```
New XRay Service Graph
Start time: 2025-02-03 14:59:50+00:00
End time: 2025-02-03 14:59:50+00:00
Reference Id: 0 - (Root) AWS::Lambda - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [1]
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.924
Reference Id: 1 - AWS::Lambda::Function - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: []
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.016
Reference Id: 2 - client - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [0]
Summary_statistics:
- total requests: 0
- ok count(2XX): 0
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0
XRay Event [revision 1] at (2025-02-03T14:59:50.204000) with id (1-63dd2166-434a12c22e1307ff2114f299) and duration (0.924s)
- 0.924s - sam-app-HelloWorldFunction-YBg8yfYtOc9j [HTTP: 200]
- 0.016s - sam-app-HelloWorldFunction-YBg8yfYtOc9j
- 0.739s - Initialization
- 0.016s - Invocation
- 0.013s - ## lambda_handler
- 0.000s - ## app.hello
- 0.000s - Overhead
```
1. Dies ist ein öffentlicher API-Endpunkt, der über das Internet zugänglich ist. Es wird empfohlen, dass Sie den Endpunkt nach dem Testen löschen.
```
cdk destroy
```
## Verwenden von ADOT zur Instrumentierung Ihrer Java-Funktionen