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.

# Instrumentierung von Java-Code in AWS Lambda
<a name="java-tracing"></a>

Lambda lässt sich integrieren AWS X-Ray , um Ihnen zu helfen, Lambda-Anwendungen zu verfolgen, zu debuggen und zu optimieren. Sie können mit X-Ray eine Anforderung verfolgen, während sie Ressourcen in Ihrer Anwendung durchläuft, die Lambda-Funktionen und andere AWS -Services enthalten können.

Um Protokollierungsdaten an X-Ray zu senden, können Sie eine von zwei SDK-Bibliotheken verwenden:
+ [AWS Distro for OpenTelemetry (ADOT)](https://aws.amazon.com/otel) — Eine sichere, produktionsbereite und AWS unterstützte Distribution des () SDK. OpenTelemetry OTel
+ [AWS X-Ray SDK für Java](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java.html) – Ein SDK zum Generieren und Senden von Nachverfolgungsdaten an X-Ray.
+ [Powertools for AWS Lambda (Java)](https://docs.aws.amazon.com/powertools/java/latest/) — Ein Entwickler-Toolkit zur Implementierung von Best Practices für Serverless und zur Steigerung der Entwicklergeschwindigkeit.

Jedes SDKs bietet Möglichkeiten, Ihre Telemetriedaten an den X-Ray-Dienst zu senden. Sie können dann mit X-Ray die Leistungsmetriken Ihrer Anwendung anzeigen, filtern und erhalten, um Probleme und Möglichkeiten zur Optimierung zu identifizieren.

**Wichtig**  
X-Ray und Powertools für AWS Lambda SDKs sind Teil einer eng integrierten Instrumentierungslösung, die von AWS angeboten wird. Die ADOT Lambda Layers sind Teil eines branchenweiten Standards für die Verfolgung von Instrumenten, die im Allgemeinen mehr Daten erfassen, aber möglicherweise nicht für alle Anwendungsfälle geeignet sind. Sie können die end-to-end Ablaufverfolgung in X-Ray mit beiden Lösungen implementieren. Weitere Informationen zur Auswahl zwischen beiden finden Sie unter [Wählen zwischen der AWS Distribution für Open Telemetry und](https://docs.aws.amazon.com/xray/latest/devguide/xray-instrumenting-your-app.html#xray-instrumenting-choosing) X-Ray. SDKs

**Topics**
+ [

## Verwendung von Powertools für AWS Lambda (Java) und für die Nachverfolgung AWS SAM
](#java-tracing-sam)
+ [

## Verwendung von Powertools für AWS Lambda (Java) und AWS CDK für die Ablaufverfolgung
](#java-tracing-cdk)
+ [

## Verwenden von ADOT zur Instrumentierung Ihrer Java-Funktionen
](#java-adot)
+ [

## Instrumentieren Sie mit dem X-Ray-SDK Ihre Java-Funktionen
](#java-xray-sdk)
+ [

## Aktivieren der Nachverfolgung mit der Lambda-Konsole
](#java-tracing-console)
+ [

## Aktivieren der Nachverfolgung mit der Lambda-API
](#java-tracing-api)
+ [

## Die Ablaufverfolgung wird aktiviert mit CloudFormation
](#java-tracing-cloudformation)
+ [

## Interpretieren einer X-Ray-Nachverfolgung
](#java-tracing-interpretation)
+ [

## Laufzeitabhängigkeiten in einer Ebene speichern (X-Ray-SDK)
](#java-tracing-layers)
+ [

## X-Ray-Nachverfolgung in Beispielanwendungen (X-Ray-SDK)
](#java-tracing-samples)

## Verwendung von Powertools für AWS Lambda (Java) und für die Nachverfolgung AWS SAM
<a name="java-tracing-sam"></a>

Gehen Sie wie folgt vor, um eine Hello World Java-Beispielanwendung mit integrierten [Powertools für AWS Lambda (Java)](https://docs.powertools.aws.dev/lambda-java) -Modulen herunterzuladen, zu erstellen und bereitzustellen. Verwenden Sie dazu den. AWS SAM Diese Anwendung implementiert ein grundlegendes API-Backend und verwendet Powertools zum Ausgeben von Protokollen, Metriken und Traces. Es besteht aus einem Amazon-API-Gateway-Endpunkt und einer Lambda-Funktion. Wenn Sie eine GET-Anfrage an den API-Gateway-Endpunkt senden, ruft die Lambda-Funktion Logs und Metriken auf, sendet sie im Embedded Metric Format an CloudWatch und sendet Traces an. AWS X-Ray Die Funktion gibt eine `hello world`-Nachricht zurück.

**Voraussetzungen**

Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ Java 11 oder höher
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS SAM CLI Version 1.75 oder höher](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Wenn Sie eine ältere Version der AWS SAM CLI haben, finden Sie weitere Informationen unter [Upgrade der AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade).

**Stellen Sie eine AWS SAM Beispielanwendung bereit**

1. Initialisieren Sie die Anwendung mit der Hello World Java-Vorlage.

   ```
   sam init --app-template hello-world-powertools-java --name sam-app --package-type Zip --runtime java11 --no-tracing
   ```

1. Entwickeln Sie die App.

   ```
   cd sam-app && sam build
   ```

1. Stellen Sie die Anwendung bereit.

   ```
   sam deploy --guided
   ```

1. Folgen Sie den Anweisungen auf dem Bildschirm. Um die im interaktiven Erlebnis bereitgestellten Standardoptionen zu akzeptieren, drücken Sie `Enter`.
**Anmerkung**  
Für ist **HelloWorldFunction möglicherweise keine Autorisierung definiert. Ist das in Ordnung?** , stellen Sie sicher, dass Sie eintreten`y`.

1. Rufen Sie die URL der bereitgestellten Anwendung ab:

   ```
   aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text
   ```

1. Rufen Sie den API-Endpunkt auf:

   ```
   curl -X GET <URL_FROM_PREVIOUS_STEP>
   ```

   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
<a name="java-tracing-cdk"></a>

Gehen Sie wie folgt vor, um eine Hello World Java-Beispielanwendung mit integrierten [Powertools for AWS Lambda (Java)](https://docs.powertools.aws.dev/lambda-java) -Modulen herunterzuladen, zu erstellen und bereitzustellen. Verwenden Sie dazu den. AWS CDK Diese Anwendung implementiert ein grundlegendes API-Backend und verwendet Powertools zum Ausgeben von Protokollen, Metriken und Traces. Es besteht aus einem Amazon-API-Gateway-Endpunkt und einer Lambda-Funktion. Wenn Sie eine GET-Anfrage an den API-Gateway-Endpunkt senden, ruft die Lambda-Funktion Logs und Metriken auf, sendet sie im Embedded Metric Format an CloudWatch und sendet Traces an. AWS X-Ray Die Funktion gibt eine Hello-World-Nachricht zurück.

**Voraussetzungen**

Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ Java 11 oder höher
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS CDK Ausführung 2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_prerequisites)
+ [AWS SAM CLI Version 1.75 oder höher](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Wenn Sie eine ältere Version der AWS SAM CLI haben, finden Sie weitere Informationen unter [Upgrade der AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade).

**Stellen Sie eine AWS CDK Beispielanwendung bereit**

1. Erstellen Sie ein Projektverzeichnis für Ihre neue Anwendung.

   ```
   mkdir hello-world
   cd hello-world
   ```

1. Initialisieren Sie die App.

   ```
   cdk init app --language java
   ```

1. Erstellen Sie ein Maven-Projekt mit dem folgenden Befehl:

   ```
   mkdir app
   cd app
   mvn archetype:generate -DgroupId=helloworld -DartifactId=Function -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
   ```

1. Öffnen Sie `pom.xml` im `hello-world\app\Function`-Verzeichnis und ersetzen Sie den vorhandenen Code durch den folgenden Code, der Abhängigkeiten und Maven-Plugins für Powertools enthält.

   ```
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>helloworld</groupId>
     <artifactId>Function</artifactId>
     <packaging>jar</packaging>
     <version>1.0-SNAPSHOT</version>
     <name>Function</name>
     <url>http://maven.apache.org</url>
   <properties>
       <maven.compiler.source>11</maven.compiler.source>
       <maven.compiler.target>11</maven.compiler.target>
       <log4j.version>2.17.2</log4j.version>
   </properties>
       <dependencies>
           <dependency>
               <groupId>junit</groupId>
               <artifactId>junit</artifactId>
               <version>3.8.1</version>
               <scope>test</scope>
           </dependency>
           <dependency>
               <groupId>software.amazon.lambda</groupId>
               <artifactId>powertools-tracing</artifactId>
               <version>1.3.0</version>
           </dependency>
           <dependency>
               <groupId>software.amazon.lambda</groupId>
               <artifactId>powertools-metrics</artifactId>
               <version>1.3.0</version>
           </dependency>
           <dependency>
               <groupId>software.amazon.lambda</groupId>
               <artifactId>powertools-logging</artifactId>
               <version>1.3.0</version>
           </dependency>
           <dependency>
               <groupId>com.amazonaws</groupId>
               <artifactId>aws-lambda-java-core</artifactId>
               <version>1.2.2</version>
           </dependency>
           <dependency>
               <groupId>com.amazonaws</groupId>
               <artifactId>aws-lambda-java-events</artifactId>
               <version>3.11.1</version>
           </dependency>
     </dependencies>
   <build>
       <plugins>
           <plugin>
               <groupId>org.codehaus.mojo</groupId>
               <artifactId>aspectj-maven-plugin</artifactId>
               <version>1.14.0</version>
               <configuration>
                   <source>${maven.compiler.source}</source>
                   <target>${maven.compiler.target}</target>
                   <complianceLevel>${maven.compiler.target}</complianceLevel>
                   <aspectLibraries>
                       <aspectLibrary>
                           <groupId>software.amazon.lambda</groupId>
                           <artifactId>powertools-tracing</artifactId>
                       </aspectLibrary>
                       <aspectLibrary>
                           <groupId>software.amazon.lambda</groupId>
                           <artifactId>powertools-metrics</artifactId>
                       </aspectLibrary>
                       <aspectLibrary>
                           <groupId>software.amazon.lambda</groupId>
                           <artifactId>powertools-logging</artifactId>
                       </aspectLibrary>
                   </aspectLibraries>
               </configuration>
               <executions>
                   <execution>
                       <goals>
                           <goal>compile</goal>
                       </goals>
                   </execution>
               </executions>
           </plugin>
           <plugin>
                   <groupId>org.apache.maven.plugins</groupId>
                   <artifactId>maven-shade-plugin</artifactId>
                   <version>3.4.1</version>
                   <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>
                               <createDependencyReducedPom>false</createDependencyReducedPom>
                               <finalName>function</finalName>
   
                           </configuration>
                       </execution>
                   </executions>
                   <dependencies>
                       <dependency>
                           <groupId>com.github.edwgiz</groupId>
                           <artifactId>maven-shade-plugin.log4j2-cachefile-transformer</artifactId>
                           <version>2.15</version>
                       </dependency>
                   </dependencies>
           </plugin>
       </plugins>
   </build>
   </project>
   ```

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.

   ```
   <?xml version="1.0" encoding="UTF-8"?>
   <Configuration>
       <Appenders>
           <Console name="JsonAppender" target="SYSTEM_OUT">
               <JsonTemplateLayout eventTemplateUri="classpath:LambdaJsonLayout.json" />
           </Console>
       </Appenders>
       <Loggers>
           <Logger name="JsonLogger" level="INFO" additivity="false">
               <AppenderRef ref="JsonAppender"/>
           </Logger>
           <Root level="info">
               <AppenderRef ref="JsonAppender"/>
           </Root>
       </Loggers>
   </Configuration>
   ```

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<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
       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<String, String> 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<String> 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.

   ```
   <?xml version="1.0" encoding="UTF-8"?>
   <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
            xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
       <modelVersion>4.0.0</modelVersion>
   
       <groupId>com.myorg</groupId>
       <artifactId>hello-world</artifactId>
       <version>0.1</version>
   
       <properties>
           <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
           <cdk.version>2.70.0</cdk.version>
           <constructs.version>[10.0.0,11.0.0)</constructs.version>
           <junit.version>5.7.1</junit.version>
       </properties>
   
       <build>
           <plugins>
               <plugin>
                   <groupId>org.apache.maven.plugins</groupId>
                   <artifactId>maven-compiler-plugin</artifactId>
                   <version>3.8.1</version>
                   <configuration>
                       <source>1.8</source>
                       <target>1.8</target>
                   </configuration>
               </plugin>
   
               <plugin>
                   <groupId>org.codehaus.mojo</groupId>
                   <artifactId>exec-maven-plugin</artifactId>
                   <version>3.0.0</version>
                   <configuration>
                       <mainClass>com.myorg.HelloWorldApp</mainClass>
                   </configuration>
               </plugin>
           </plugins>
       </build>
   
       <dependencies>
           <!-- AWS Cloud Development Kit -->
           <dependency>
               <groupId>software.amazon.awscdk</groupId>
               <artifactId>aws-cdk-lib</artifactId>
               <version>${cdk.version}</version>
           </dependency>
           <dependency>
               <groupId>software.constructs</groupId>
               <artifactId>constructs</artifactId>
               <version>${constructs.version}</version>
           </dependency>
           <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter</artifactId>
             <version>${junit.version}</version>
             <scope>test</scope>
           </dependency>
           <dependency>
               <groupId>software.amazon.awscdk</groupId>
               <artifactId>apigatewayv2-alpha</artifactId>
               <version>${cdk.version}-alpha.0</version>
           </dependency>
           <dependency>
               <groupId>software.amazon.awscdk</groupId>
               <artifactId>apigatewayv2-integrations-alpha</artifactId>
               <version>${cdk.version}-alpha.0</version>
           </dependency>
       </dependencies>
   </project>
   ```

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

   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
<a name="java-adot"></a>

ADOT bietet vollständig verwaltete [Lambda-Schichten](chapter-layers.md), die alles zusammenfassen, was Sie für die Erfassung von Telemetriedaten mithilfe des SDK benötigen. OTel Indem Sie diese Ebene verwenden, können Sie Ihre Lambda-Funktionen instrumentieren, ohne einen Funktionscode ändern zu müssen. Sie können Ihren Layer auch so konfigurieren, dass er eine benutzerdefinierte Initialisierung von durchführt. OTel Weitere Informationen finden Sie unter [Benutzerdefinierte Konfiguration für den ADOT Collector auf Lambda](https://aws-otel.github.io/docs/getting-started/lambda#custom-configuration-for-the-adot-collector-on-lambda) in der ADOT-Dokumentation.

Für Java-Laufzeiten können Sie zwischen zwei Ebenen wählen, die verbraucht werden sollen:
+ **AWS verwaltete Lambda-Schicht für ADOT Java (Auto-Instrumentation Agent)** — Diese Schicht transformiert Ihren Funktionscode beim Start automatisch, um Tracing-Daten zu sammeln. Detaillierte Anweisungen, wie Sie diese Ebene zusammen mit dem ADOT-Java-Agenten verwenden können, finden Sie in der ADOT-Dokumentation unter [AWS Distro for OpenTelemetry Lambda Support for Java (Auto-Instrumentation Agent)](https://aws-otel.github.io/docs/getting-started/lambda/lambda-java-auto-instr).
+ **AWS verwaltete Lambda-Schicht für ADOT Java** — Diese Schicht bietet auch eine integrierte Instrumentierung für Lambda-Funktionen, erfordert jedoch einige manuelle Codeänderungen, um das SDK zu initialisieren. OTel Eine ausführliche Anleitung zur Nutzung dieser Ebene finden Sie unter [AWS Distro for OpenTelemetry Lambda Support for Java](https://aws-otel.github.io/docs/getting-started/lambda/lambda-java) in der ADOT-Dokumentation.

## Instrumentieren Sie mit dem X-Ray-SDK Ihre Java-Funktionen
<a name="java-xray-sdk"></a>

Um Daten über Aufrufe Ihrer Funktion an andere Ressourcen und Services in Ihrer Anwendung aufzuzeichnen, können Sie Ihrer Build-Konfiguration das X-Ray-SDK für Java hinzufügen. Das folgende Beispiel zeigt eine Gradle-Build-Konfiguration, die die Bibliotheken enthält, die die automatische Instrumentierung von Clients aktivieren. AWS SDK for Java 2.x 

**Example [build.gradle](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/s3-java/build.gradle) – Ablaufverfolgung von Abhängigkeiten**  

```
dependencies {
    implementation platform('software.amazon.awssdk:bom:2.16.1')
    implementation platform('com.amazonaws:aws-xray-recorder-sdk-bom:2.11.0')
    ...
    implementation 'com.amazonaws:aws-xray-recorder-sdk-core'
    implementation 'com.amazonaws:aws-xray-recorder-sdk-aws-sdk'
    implementation 'com.amazonaws:aws-xray-recorder-sdk-aws-sdk-v2-instrumentor'
    ...
}
```

Aktivieren Sie nach Hinzufügen der richtigen Abhängigkeiten die Nachverfolgung in der Konfiguration Ihrer Funktion über die Lambda-Konsole oder die API.

## Aktivieren der Nachverfolgung mit der Lambda-Konsole
<a name="java-tracing-console"></a>

Gehen Sie folgendermaßen vor, um die aktive Nachverfolgung Ihrer Lambda-Funktion mit der Konsole umzuschalten:

**So aktivieren Sie die aktive Nachverfolgung**

1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.

1. Wählen Sie eine Funktion aus.

1. Wählen Sie **Configuration** (Konfiguration) und dann **Monitoring and operations tools** (Überwachungs- und Produktionstools).

1. Wählen Sie unter **Zusätzliche Überwachungstools** die Option **Bearbeiten** aus.

1. Wählen Sie unter **CloudWatch Anwendungssignale und AWS X-Ray** die Option **Enable** for **Lambda Service Traces** aus.

1. Wählen Sie **Speichern**.

## Aktivieren der Nachverfolgung mit der Lambda-API
<a name="java-tracing-api"></a>

Konfigurieren Sie die Ablaufverfolgung für Ihre Lambda-Funktion mit dem AWS CLI oder AWS SDK und verwenden Sie die folgenden API-Operationen:
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)

**Der folgende AWS CLI Beispielbefehl aktiviert die aktive Ablaufverfolgung für eine Funktion namens my-function.**

```
aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active
```

Der Ablaufverfolgungsmodus ist Teil der versionsspezifischen Konfiguration, wenn Sie eine Version Ihrer Funktion veröffentlichen. Sie können den Ablaufverfolgungsmodus für eine veröffentlichte Version nicht ändern.

## Die Ablaufverfolgung wird aktiviert mit CloudFormation
<a name="java-tracing-cloudformation"></a>

Um die Ablaufverfolgung für eine `AWS::Lambda::Function` Ressource in einer CloudFormation Vorlage zu aktivieren, verwenden Sie die `TracingConfig` Eigenschaft.

**Example [function-inline.yml](https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/templates/function-inline.yml) – Ablaufverfolgungskonfiguration**  

```
Resources:
  function:
    Type: [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
    Properties:
      TracingConfig:
        Mode: Active
      ...
```

Verwenden Sie für eine `AWS::Serverless::Function` Ressource AWS Serverless Application Model (AWS SAM) die `Tracing` Eigenschaft.

**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml) – Ablaufverfolgungskonfiguration**  

```
Resources:
  function:
    Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
    Properties:
      Tracing: Active
      ...
```

## Interpretieren einer X-Ray-Nachverfolgung
<a name="java-tracing-interpretation"></a>

Ihre Funktion benötigt die Berechtigung zum Hochladen von Trace-Daten zu X-Ray. Wenn Sie die aktive Nachverfolgung in der Lambda-Konsole aktivieren, fügt Lambda der [Ausführungsrolle](lambda-intro-execution-role.md) Ihrer Funktion die erforderlichen Berechtigungen hinzu. Andernfalls fügen Sie die [AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess)Richtlinie der Ausführungsrolle hinzu.

Nachdem Sie die aktive Nachverfolgung konfiguriert haben, können Sie bestimmte Anfragen über Ihre Anwendung beobachten. Das [X-Ray-Service-Diagramm](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html#xray-concepts-servicegraph) zeigt Informationen über Ihre Anwendung und alle ihre Komponenten an. Das folgende Beispiel zeigt eine Anwendung mit zwei Funktionen. Die primäre Funktion verarbeitet Ereignisse und gibt manchmal Fehler zurück. Die zweite Funktion an oberster Stelle verarbeitet Fehler, die in der Protokollgruppe der ersten auftreten, und verwendet das AWS SDK, um X-Ray, Amazon Simple Storage Service (Amazon S3) und Amazon CloudWatch Logs aufzurufen.

![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/sample-errorprocessor-servicemap.png)


X-Ray verfolgt nicht alle Anfragen an Ihre Anwendung nach. X-Ray wendet einen Sampling-Algorithmus an, um sicherzustellen, dass die Nachverfolgung effizient ist, und stellt dennoch ein repräsentatives Beispiel aller Anfragen bereit. Die Samplingrate beträgt 1 Anforderung pro Sekunde und 5 Prozent aller weiteren Anforderungen. Sie können die X-Ray-Samplingrate nicht für Ihre Funktionen konfigurieren.

In X-Ray, zeichnet eine *Ablaufverfolgung* Informationen zu einer Anforderung auf, die von einem oder mehreren *Services* verarbeitet wird. Lambda zeichnet 2 Segmente pro Trace auf, wodurch zwei Knoten im Dienstgraphen entstehen. In der folgenden Abbildung werden diese beiden Knoten hervorgehoben:

![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/xray-servicemap-function.png)


Der erste Knoten auf der linken Seite stellt den Lambda-Service dar, der die Aufrufanforderung empfängt. Der zweite Knoten stellt Ihre spezifische Lambda-Funktion dar. Das folgende Beispiel zeigt eine Nachverfolgung mit diesen zwei Segmenten. Beide heißen **my-function**, aber einer hat einen Ursprung von `AWS::Lambda` und der andere hat einen Ursprung von `AWS::Lambda::Function`. Wenn das `AWS::Lambda`-Segment einen Fehler anzeigt, hatte der Lambda-Service ein Problem. Wenn das `AWS::Lambda::Function`-Segment einen Fehler anzeigt, ist bei Ihrer Funktion ein Problem aufgetreten.

![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)


Dieses Beispiel erweitert das `AWS::Lambda::Function`-Segment, um seine drei Untersegmente anzuzeigen.

**Anmerkung**  
AWS implementiert derzeit Änderungen am Lambda-Service. Aufgrund dieser Änderungen können geringfügige Unterschiede in Struktur und Inhalt der Systemprotokollmeldungen und Trace-Segmente auftreten, die von verschiedenen Lambda-Funktionen in Ihrem AWS-Konto.  
Der hier gezeigte Beispiel-Trace veranschaulicht das Funktionssegment im alten Stil. Die Unterschiede zwischen den Segmenten im alten und im neuen Stil werden in den folgenden Abschnitten beschrieben.  
Diese Änderungen werden in den kommenden Wochen umgesetzt, und alle Funktionen AWS-Regionen außer China und den GovCloud Regionen werden auf die Verwendung der Protokollnachrichten und Trace-Segmente im neuen Format umgestellt.

Das Funktionssegment im alten Stil enthält die folgenden Untersegmente:
+ **Initialisierung** – Stellt die Zeit dar, die für das Laden Ihrer Funktion und das Ausführen des [Initialisierungscodes](foundation-progmodel.md) aufgewendet wurde. Dieses Untersegment erscheint nur für das erste Ereignis, das jede Instance Ihrer Funktion verarbeitet.
+ **Invocation** (Aufruf) – Stellt die Zeit dar, die beim Ausführen Ihres Handler-Codes vergeht.
+ **Overhead** (Aufwand) – Stellt die Zeit dar, die von der Lambda-Laufzeitumgebung bei der Verarbeitung des nächsten Ereignisses verbraucht wird.

Das Funktionssegment im neuen Stil enthält kein `Invocation`-Untersegment. Stattdessen werden Kundenuntersegmente direkt an das Funktionssegment angehängt. Weitere Informationen über die Struktur der alten und neuen Funktionssegmente finden Sie unter [Grundlegendes zu X-Ray-Ablaufverfolgungen](services-xray.md#services-xray-traces).

**Anmerkung**  
Zu den [Lambda SnapStart](snapstart.md)-Funktionen gehört auch ein `Restore`-Teilsegment. Das Teilsegment `Restore` zeigt die Zeit an, die Lambda benötigt, um einen Snapshot wiederherzustellen, die Laufzeit zu laden und vorhandene [Laufzeit-Hooks](snapstart-runtime-hooks.md) nach der Wiederherstellung auszuführen. Der Prozess der Wiederherstellung von Snapshots kann Zeit beinhalten, die für Aktivitäten außerhalb der MicroVM aufgewendet wird. Diese Zeit wird im `Restore`-Untersegment erfasst. Die Zeit, die Sie außerhalb der microVM für die Wiederherstellung eines Snapshots aufwenden, wird Ihnen nicht in Rechnung gestellt.

Sie können auch HTTP-Clients instrumentieren, SQL-Abfragen aufzeichnen und benutzerdefinierte Untersegmente mit Anmerkungen und Metadaten erstellen. Weitere Informationen finden Sie unter [AWS X-Ray SDK für Java](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java.html) im *AWS X-Ray -Entwicklerhandbuch*.

**Preisgestaltung**  
Im Rahmen des kostenlosen Kontingents können Sie X-Ray Tracing jeden Monat bis zu einem bestimmten Limit AWS kostenlos nutzen. Über den Schwellenwert hinaus berechnet X-Ray Gebühren für die Speicherung und den Abruf der Nachverfolgung. Weitere Informationen finden Sie unter [AWS X-Ray Preise](https://aws.amazon.com/xray/pricing/).

## Laufzeitabhängigkeiten in einer Ebene speichern (X-Ray-SDK)
<a name="java-tracing-layers"></a>

Wenn Sie das X-Ray-SDK verwenden, um AWS SDK-Clients Ihren Funktionscode zu instrumentieren, kann Ihr Bereitstellungspaket ziemlich umfangreich werden. Um Laufzeitabhängigkeiten bei jeder Aktualisierung des Funktionscodes zu vermeiden, verpacken Sie das X-Ray-SDK in einer [Lambda-Ebene](chapter-layers.md).

Das folgende Beispiel zeigt eine `AWS::Serverless::LayerVersion`-Ressource, die AWS SDK für Java und das X-Ray-SDK für Java speichert.

**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-java/template.yml) – Abhängigkeitenebene**  

```
Resources:
  function:
    Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
    Properties:
      CodeUri: build/distributions/blank-java.zip
      Tracing: Active
      Layers:
        - !Ref libs
      ...
  libs:
    Type: [AWS::Serverless::LayerVersion](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-layerversion.html)
    Properties:
      LayerName: blank-java-lib
      Description: Dependencies for the blank-java sample app.
      ContentUri: build/blank-java-lib.zip
      CompatibleRuntimes:
        - java25
```

Bei dieser Konfiguration aktualisieren Sie die Bibliotheksebene nur, wenn Sie Ihre Laufzeitabhängigkeiten ändern. Da das Funktionsbereitstellungspaket nur Ihren Code enthält, kann dies dazu beitragen, die Upload-Zeiten zu reduzieren.

Das Erstellen einer Ebene für Abhängigkeiten erfordert Build-Konfigurationsänderungen, um das Layer-Archiv vor der Bereitstellung zu generieren. Ein funktionierendes Beispiel finden Sie in der [Java-Basic-Beispielanwendung](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/java-basic) unter. GitHub

## X-Ray-Nachverfolgung in Beispielanwendungen (X-Ray-SDK)
<a name="java-tracing-samples"></a>

Das GitHub Repository für dieses Handbuch enthält Beispielanwendungen, die die Verwendung von X-Ray Tracing demonstrieren. Jede Beispielanwendung enthält Skripts für die einfache Bereitstellung und Bereinigung, eine AWS SAM Vorlage und unterstützende Ressourcen.

**Lambda-Beispielanwendungen in Java**
+ [example-java](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/example-java) – Eine Java-Funktion, die zeigt, wie Sie Lambda zur Bearbeitung von Aufträgen verwenden können. Diese Funktion veranschaulicht, wie Sie ein benutzerdefiniertes Eingabeereignisobjekt definieren und deserialisieren, das AWS SDK verwenden und die Ausgabeprotokollierung durchführen.
+ [Java-Basis](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/java-basic) – Eine Sammlung minimaler Java-Funktionen mit Einheitentests und variabler Protokollierungskonfiguration.
+ [Java-Ereignisse](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/java-events) – 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-events](java-package.md)Bibliothek (3.0.0 und neuer). Für diese Beispiele ist das AWS SDK nicht als Abhängigkeit erforderlich.
+ [s3-java](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/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.
+ [layer-java](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-java) – Eine Java-Funktion, die veranschaulicht, wie Sie mit einer Lambda-Ebene Abhängigkeiten getrennt von Ihrem Kernfunktionscode packen können.

Für alle Beispielanwendungen ist die aktive Ablaufverfolgung für Lambda-Funktionen aktiviert. Die `s3-java` Anwendung zeigt beispielsweise die automatische Instrumentierung von AWS SDK for Java 2.x Clients, Segmentmanagement für Tests, benutzerdefinierte Untersegmente und die Verwendung von Lambda-Schichten zum Speichern von Laufzeitabhängigkeiten.