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. # Veröffentlichen Sie SDK-Metriken aus dem AWS SDK for Java 2.x Mit dem können AWS SDK for Java 2.x Sie Metriken über die Service-Clients und Anfragen in Ihrer Anwendung sammeln, die Ausgabe in Amazon CloudWatch Logs analysieren und dann darauf reagieren. Standardmäßig ist die Erfassung von Metriken im SDK deaktiviert. Dieses Thema hilft Ihnen dabei, es zu aktivieren und zu konfigurieren. ## Erste Schritte mit SDK-Metriken Um die Erfassung von Metriken in Ihrer Anwendung zu aktivieren, wählen Sie die für Ihren Anwendungsfall geeignete Implementierung der `[MetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/MetricPublisher.html)` Schnittstelle aus und folgen Sie den detaillierten Anweisungen zur Einrichtung: **Für Anwendungen mit langer Laufzeit:** + Verwenden von `[CloudWatchMetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/publishers/cloudwatch/CloudWatchMetricPublisher.html)` + Vollständige Anweisungen zur Einrichtung, Codebeispiele und Konfigurationsoptionen finden Sie unter [Veröffentlichen von SDK-Metriken von Anwendungen mit langer Laufzeit](metric-pub-impl-cwmp.md). **Für AWS Lambda Funktionen:** + Verwenden von `[EmfMetricLoggingPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/publishers/emf/EmfMetricLoggingPublisher.html)` + Vollständige Setup-Anweisungen, Abhängigkeiten und Lambda-spezifische Konfigurationen finden Sie unter [SDK-Metriken für AWS Lambda Funktionen veröffentlichen](metric-pub-impl-emf.md). **Zur Fehlerbehebung und zur Konsolenausgabe:** + Verwenden von `[LoggingMetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/LoggingMetricPublisher.html)` + Anweisungen [zur Einrichtung, Formatierungsoptionen und Beispiele für lokale Entwicklung und Problembehebung finden Sie unter SDK-Metriken für Entwicklung und Debugging an die Konsole ausgeben](metric-pub-impl-logging.md). ## Schnelle Implementierungsvorschau So sehen die Aktivierungsmetriken für jeden Anwendungsfall aus: **Anwendungen mit langer Laufzeit:** ``` MetricPublisher metricsPub = CloudWatchMetricPublisher.create(); DynamoDbClient ddb = DynamoDbClient.builder() .overrideConfiguration(c -> c.addMetricPublisher(metricsPub)) .build(); ``` **Lambda-Funktionen:** ``` EmfMetricLoggingPublisher emfPublisher = EmfMetricLoggingPublisher.builder() .namespace("MyApp") .build(); DynamoDbClient dynamoDb = DynamoDbClient.builder() .overrideConfiguration(c -> c.addMetricPublisher(emfPublisher)) .build(); ``` **Entwicklung und Debugging:** ``` MetricPublisher loggingPublisher = LoggingMetricPublisher.create(); S3Client s3 = S3Client.builder() .overrideConfiguration(c -> c.addMetricPublisher(loggingPublisher)) .build(); ``` ## Beschränkung der Metriken des AWS CRT-basierten S3-Clients Der [AWS CRT-basierte S3-Client unterstützt derzeit keine Erfassung](crt-based-s3-client.md) von SDK-Metriken. Der Builder für eine AWS CRT-basierte S3-Client-Instanz bietet keine Methoden zur Konfiguration von [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3CrtAsyncClientBuilder.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3CrtAsyncClientBuilder.html)Metrik-Publishern. ## Wann sind Metriken verfügbar? Metriken sind in der Regel innerhalb von 5-10 Minuten verfügbar, nachdem sie vom SDK for Java ausgegeben wurden. Genaue up-to-date Metriken finden Sie mindestens 10 Minuten nach der Ausgabe der Metriken aus Ihren Java-Anwendungen in Cloudwatch. ## Welche Informationen werden gesammelt? Die Erfassung von Metriken umfasst Folgendes: + Anzahl der API-Anfragen, einschließlich der Frage, ob sie erfolgreich waren oder nicht + Informationen über die von AWS-Services Ihnen aufgerufenen API-Anfragen, einschließlich der zurückgegebenen Ausnahmen + Die Dauer verschiedener Operationen wie Marshalling, Signierung und HTTP-Anfragen + HTTP-Client-Metriken, wie die Anzahl der offenen Verbindungen, die Anzahl der ausstehenden Anfragen und der Name des verwendeten HTTP-Clients **Anmerkung** Die verfügbaren Metriken variieren je nach HTTP-Client. Eine vollständige Liste finden Sie unter [Service-Client-Metriken](metrics-list.md). ## Wie kann ich diese Informationen verwenden? Sie können die vom SDK gesammelten Metriken verwenden, um die Service-Clients in Ihrer Anwendung zu überwachen. Sie können sich allgemeine Nutzungstrends ansehen, Anomalien identifizieren, zurückgegebene Service-Client-Ausnahmen überprüfen oder sich ein bestimmtes Problem genauer ansehen. Mithilfe von Amazon CloudWatch Logs können Sie auch Alarme erstellen, die Sie benachrichtigen, sobald Ihre Anwendung einen von Ihnen definierten Zustand erreicht. Weitere Informationen finden Sie unter [Verwenden von Amazon CloudWatch Logs-Metriken](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) und [Verwenden von Amazon CloudWatch Logs-Alarmen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) im [Amazon CloudWatch Logs-Benutzerhandbuch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/). # Veröffentlichen Sie SDK-Metriken von Anwendungen mit langer Laufzeit mithilfe der AWS SDK for Java 2.x Da die `[CloudWatchMetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/publishers/cloudwatch/CloudWatchMetricPublisher.html)` Implementierung Metriken aggregiert und regelmäßig verzögert auf Amazon hochlädt, eignet sich ihre Verwendung am besten für Anwendungen CloudWatch mit langer Laufzeit. Die Standardeinstellungen des Metrik-Publishers sollen den Speicherverbrauch und die CloudWatch Kosten minimieren und gleichzeitig einen nützlichen Einblick in die Metrikdaten bieten. ## Einrichtung Führen Sie die folgenden Schritte aus`CloudWatchMetricPublisher`, bevor Sie Metriken mithilfe von aktivieren und verwenden können. ### Schritt 1: Fügen Sie die erforderliche Abhängigkeit hinzu Konfigurieren Sie Ihre Projektabhängigkeiten (z. B. in Ihrer `pom.xml` `build.gradle` OR-Datei) so, dass die Version `2.14.0` oder eine neuere Version von verwendet wird AWS SDK für Java. Fügen Sie die artifactId `cloudwatch-metric-publisher` mit der Versionsnummer `2.14.0` oder später in die Abhängigkeiten Ihres Projekts ein. Beispiel: ``` software.amazon.awssdk bom [2.30.11](https://central.sonatype.com/artifact/software.amazon.awssdk/bom) pom import software.amazon.awssdk cloudwatch-metric-publisher ``` ### Schritt 2: Konfigurieren Sie die erforderlichen Berechtigungen Aktivieren Sie die `cloudwatch:PutMetricData` Berechtigungen für die IAM-Identität, die vom Herausgeber der Metriken verwendet wird, damit das SDK for Java Metriken schreiben kann. ## Aktivieren Sie Metriken für eine bestimmte Anfrage Die folgende Klasse zeigt, wie Sie den CloudWatch Metrik-Publisher für eine Anfrage an Amazon DynamoDB aktivieren. Es verwendet die Standardkonfiguration für den Metrik-Publisher. ``` import software.amazon.awssdk.metrics.MetricPublisher; import software.amazon.awssdk.metrics.publishers.cloudwatch.CloudWatchMetricPublisher; import software.amazon.awssdk.services.dynamodb.DynamoDbClient; import software.amazon.awssdk.services.dynamodb.model.ListTablesRequest; public class DefaultConfigForRequest { // Use one MetricPublisher for your application. It can be used with requests or service clients. static MetricPublisher metricsPub = CloudWatchMetricPublisher.create(); public static void main(String[] args) { DynamoDbClient ddb = DynamoDbClient.create(); // Publish metrics the for ListTables operation. ddb.listTables(ListTablesRequest.builder() .overrideConfiguration(c -> c.addMetricPublisher(metricsPub)) .build()); // Perform more work in your application. // A MetricsPublisher has its own lifecycle independent of any service client or request that uses it. // If you no longer need the publisher, close it to free up resources. metricsPub.close(); // All metrics stored in memory are flushed to CloudWatch. // Perform more work with the DynamoDbClient instance without publishing metrics. // Close the service client when you no longer need it. ddb.close(); } } ``` **Wichtig** Stellen Sie sicher, dass Ihre Anwendung die `[MetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/MetricPublisher.html)` Instanz `close` aufruft, wenn der Service Client nicht mehr verwendet wird. Wenn Sie dies nicht tun, können Thread- oder Dateideskriptorlecks auftreten. ## Aktivieren Sie Übersichtsmetriken für einen bestimmten Service-Client Der folgende Codeausschnitt zeigt, wie Sie einen CloudWatch Metrik-Publisher mit Standardeinstellungen für einen Service Client aktivieren. ``` MetricPublisher metricsPub = CloudWatchMetricPublisher.create(); DynamoDbClient ddb = DynamoDbClient.builder() .overrideConfiguration(c -> c.addMetricPublisher(metricsPub)) .build(); ``` ## Passen Sie einen Herausgeber für Metriken an CloudWatch In der folgenden Klasse wird gezeigt, wie Sie eine benutzerdefinierte Konfiguration für den Metrik-Publisher für einen bestimmten Service-Client einrichten. Zu den Anpassungen gehören das Laden eines bestimmten Profils, die Angabe einer AWS Region, in die der Herausgeber der Metriken Anfragen sendet, und die Anpassung, wie oft der Herausgeber Metriken sendet. CloudWatch ``` import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider; import software.amazon.awssdk.core.metrics.CoreMetric; import software.amazon.awssdk.metrics.MetricPublisher; import software.amazon.awssdk.metrics.publishers.cloudwatch.CloudWatchMetricPublisher; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.cloudwatch.CloudWatchAsyncClient; import software.amazon.awssdk.services.dynamodb.DynamoDbClient; import java.time.Duration; public class CustomConfigForDDBClient { // Use one MetricPublisher for your application. It can be used with requests or service clients. static MetricPublisher metricsPub = CloudWatchMetricPublisher.builder() .cloudWatchClient(CloudWatchAsyncClient.builder() .region(Region.US_WEST_2) .credentialsProvider(ProfileCredentialsProvider.create("cloudwatch")) .build()) .uploadFrequency(Duration.ofMinutes(5)) .maximumCallsPerUpload(100) .namespace("ExampleSDKV2Metrics") .detailedMetrics(CoreMetric.API_CALL_DURATION) .build(); public static void main(String[] args) { DynamoDbClient ddb = DynamoDbClient.builder() .overrideConfiguration(c -> c.addMetricPublisher(metricsPub)) .build(); // Publish metrics for DynamoDB operations. ddb.listTables(); ddb.describeEndpoints(); ddb.describeLimits(); // Perform more work in your application. // A MetricsPublisher has its own lifecycle independent of any service client or request that uses it. // If you no longer need the publisher, close it to free up resources. metricsPub.close(); // All metrics stored in memory are flushed to CloudWatch. // Perform more work with the DynamoDbClient instance without publishing metrics. // Close the service client when you no longer need it. ddb.close(); } } ``` Die im vorherigen Snippet gezeigten Anpassungen haben die folgenden Auswirkungen. + Mit `cloudWatchClient` dieser Methode können Sie den CloudWatch Client anpassen, der zum Senden von Metriken verwendet wird. In diesem Beispiel verwenden wir eine andere Region als die Standardregion *us-east-1*, in die der Client Metriken sendet. Wir verwenden auch ein anderes benanntes Profil, *cloudwatch*, dessen Anmeldeinformationen zur Authentifizierung von Anfragen verwendet werden. CloudWatch Diese Anmeldeinformationen müssen über die erforderlichen Berechtigungen verfügen. `cloudwatch:PutMetricData` + Mit `uploadFrequency` dieser Methode können Sie angeben, wie oft der Herausgeber Metriken hochlädt. CloudWatch Die Standardeinstellung ist einmal pro Minute. + Die `maximumCallsPerUpload` Methode begrenzt die Anzahl der Aufrufe pro Upload. Der Standardwert lautet „unbegrenzt“. + Standardmäßig veröffentlicht das SDK for Java 2.x Metriken unter dem `AwsSdk/JavaSdk2` Namespace. Sie können die `namespace` Methode verwenden, um einen anderen Wert anzugeben. + Standardmäßig veröffentlicht das SDK zusammenfassende Metriken. Übersichtsmetriken bestehen aus Durchschnitt, Minimum, Maximum, Summe und Stichprobenanzahl. Durch die Angabe einer oder mehrerer SDK-Metriken in der `detailedMetrics` Methode veröffentlicht das SDK zusätzliche Daten für jede Metrik. Diese zusätzlichen Daten ermöglichen Perzentilstatistiken wie p90 und p99, die Sie abfragen können. CloudWatch Die detaillierten Metriken sind besonders nützlich für Latenzmetriken wie`APICallDuration`, mit denen die Latenz für SDK-Client-Anfragen gemessen end-to-end wird. Sie können Felder der `[CoreMetric](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/metrics/CoreMetric.html)` Klasse verwenden, um andere gängige SDK-Metriken anzugeben. **Nächste Schritte:** Wenn Sie auch mit Lambda-Funktionen arbeiten, finden Sie unter [SDK-Metriken veröffentlichen Informationen zu AWS Lambda Funktionen für die](metric-pub-impl-emf.md) Veröffentlichung von EMF-basierten Metriken. # Veröffentlichen Sie SDK-Metriken für AWS Lambda Funktionen mit dem AWS SDK for Java 2.x Da Lambda-Funktionen in der Regel Millisekunden bis Minuten lang ausgeführt werden, besteht bei jeder Verzögerung beim Senden der Metriken die Gefahr eines `CloudWatchMetricPublisher` Datenverlusts. `[EmfMetricLoggingPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/publishers/emf/EmfMetricLoggingPublisher.html)`bietet einen geeigneteren Ansatz, indem Metriken sofort als strukturierte Protokolleinträge im [CloudWatch Embedded Metric Format](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format.html) (EMF) geschrieben werden. `EmfMetricLoggingPublisher`funktioniert in Ausführungsumgebungen mit integrierter Integration mit Amazon CloudWatch Logs wie AWS Lambda Amazon Elastic Container Service. ## Einrichtung Führen Sie die folgenden Schritte aus`EmfMetricLoggingPublisher`, bevor Sie Metriken mithilfe von aktivieren und verwenden können. ### Schritt 1: Fügen Sie die erforderliche Abhängigkeit hinzu Konfigurieren Sie Ihre Projektabhängigkeiten (z. B. in Ihrer `pom.xml` `build.gradle` OR-Datei) so, dass die Version `2.30.3` oder eine neuere Version von verwendet wird AWS SDK für Java. Fügen Sie die artifactId `emf-metric-logging-publisher` mit der Versionsnummer `2.30.3` oder später in die Abhängigkeiten Ihres Projekts ein. Beispiel: ``` software.amazon.awssdk bom [2.30.11](https://central.sonatype.com/artifact/software.amazon.awssdk/bom) pom import software.amazon.awssdk emf-metric-logging-publisher ``` ### Schritt 2: Konfigurieren Sie die erforderlichen Berechtigungen Aktivieren Sie die `logs:PutLogEvents` Berechtigungen für die IAM-Identität, die vom Herausgeber der Metriken verwendet wird, damit das SDK for Java Protokolle im EMF-Format schreiben kann. ### Schritt 3: Protokollierung einrichten Um eine korrekte Erfassung der Messwerte zu gewährleisten, konfigurieren Sie Ihre Protokollierung so, dass sie auf der Konsole oder `INFO` niedriger ausgegeben wird (z. B.`DEBUG`). In Ihrer `log4j2.xml` Datei: ``` ``` Weitere Informationen zum Einrichten einer `log4j2.xml` Datei finden Sie im [Thema Protokollierung](logging-slf4j.md) in diesem Handbuch. ## Konfigurieren und verwenden `EmfMetricLoggingPublisher` Die folgende Lambda-Funktionsklasse erstellt und konfiguriert zunächst eine `EmfMetricLoggingPublisher` Instance und verwendet sie dann mit einem Amazon DynamoDB-Serviceclient: ``` public class GameIdHandler implements RequestHandler, String> { private final EmfMetricLoggingPublisher emfPublisher; private final DynamoDbClient dynamoDb; public GameIdHandler() { // Build the publisher. this.emfPublisher = EmfMetricLoggingPublisher.builder() .namespace("namespace") .dimensions(CoreMetric.SERVICE_ID, CoreMetric.OPERATION_NAME) .build(); // Add the publisher to the client. this.dynamoDb = DynamoDbClient.builder() .overrideConfiguration(c -> c.addMetricPublisher(emfPublisher)) .region(Region.of(System.getenv("AWS_REGION"))) .build(); } @Override public String handleRequest(Map event, Context context) { Map gameItem = new HashMap<>(); gameItem.put("gameId", AttributeValue.builder().s(event.get("id")).build()); PutItemRequest putItemRequest = PutItemRequest.builder() .tableName("games") .item(gameItem) .build(); dynamoDb.putItem(putItemRequest); return "Request handled"; } } ``` Wenn der DynamoDB-Client die `putItem` Methode ausführt, veröffentlicht er automatisch Metriken in einem CloudWatch Log-Stream im EMF-Format. ### Beispiel für ein EMF-Protokollereignis Wenn Sie beispielsweise das folgende Ereignis an die GameHandler Lambda-Funktion senden, wobei die Protokollierung wie oben gezeigt konfiguriert ist: ``` { "id": "23456" } ``` Nachdem die Funktion das Ereignis verarbeitet hat, finden Sie zwei Protokollereignisse, die dem folgenden Beispiel ähneln. Das JSON-Objekt im zweiten Ereignis enthält die Java SDK-Metrikdaten für den `PutItem` Vorgang mit DynamoDB. Wenn ein Protokollereignis im EMF-Format CloudWatch empfangen wird, analysiert es automatisch das strukturierte JSON, um Metrikdaten zu extrahieren. CloudWatch erstellt dann entsprechende Metriken und speichert gleichzeitig den ursprünglichen Protokolleintrag in CloudWatch Logs. ``` 2025-07-11 15:58:30 [main] INFO org.example.GameIdHandler:39 - Received map: {id=23456} 2025-07-11 15:58:34 [main] INFO software.amazon.awssdk.metrics.publishers.emf.EmfMetricLoggingPublisher:43 - { "_aws": { "Timestamp": 1752249513975, "LogGroupName": "/aws/lambda/GameId", "CloudWatchMetrics": [ { "Namespace": "namespace", "Dimensions": [ [ "OperationName", "ServiceId" ] ], "Metrics": [ { "Name": "AvailableConcurrency" }, { "Name": "PendingConcurrencyAcquires" }, { "Name": "ServiceCallDuration", "Unit": "Milliseconds" }, { "Name": "EndpointResolveDuration", "Unit": "Milliseconds" }, { "Name": "MaxConcurrency" }, { "Name": "BackoffDelayDuration", "Unit": "Milliseconds" }, { "Name": "MarshallingDuration", "Unit": "Milliseconds" }, { "Name": "LeasedConcurrency" }, { "Name": "SigningDuration", "Unit": "Milliseconds" }, { "Name": "ConcurrencyAcquireDuration", "Unit": "Milliseconds" }, { "Name": "ApiCallSuccessful" }, { "Name": "RetryCount" }, { "Name": "UnmarshallingDuration", "Unit": "Milliseconds" }, { "Name": "ApiCallDuration", "Unit": "Milliseconds" }, { "Name": "CredentialsFetchDuration", "Unit": "Milliseconds" } ] } ] }, "AvailableConcurrency": 0, "PendingConcurrencyAcquires": 0, "OperationName": "PutItem", "ServiceCallDuration": 1339, "EndpointResolveDuration": 81, "MaxConcurrency": 50, "BackoffDelayDuration": 0, "ServiceId": "DynamoDB", "MarshallingDuration": 181, "LeasedConcurrency": 1, "SigningDuration": 184, "ConcurrencyAcquireDuration": 83, "ApiCallSuccessful": 1, "RetryCount": 0, "UnmarshallingDuration": 85, "ApiCallDuration": 1880, "CredentialsFetchDuration": 138 } ``` Die [API-Dokumentation](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/publishers/emf/EmfMetricLoggingPublisher.Builder.html) für `EmfMetricLoggingPublisher.Builder` zeigt die Konfigurationsoptionen, die Sie verwenden können. Sie können die EMF-Metrikprotokollierung auch für eine einzelne Anfrage aktivieren, wie [für gezeigt](metric-pub-impl-cwmp.md#enable-metrics-for-a-specific-request). CloudWatchMetricPublisher **Nächste Schritte:** Informationen zu Anwendungen mit langer Laufzeit finden Sie unter [Veröffentlichen von SDK-Metriken aus Anwendungen mit langer Laufzeit](metric-pub-impl-cwmp.md) für die Veröffentlichung von CloudWatch basierten Metriken. # Geben Sie SDK-Metriken auf der Konsole aus, indem Sie AWS SDK for Java 2.x Die `[LoggingMetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/LoggingMetricPublisher.html)` Implementierung gibt Metriken direkt an die Konsole oder in die Protokolldateien Ihrer Anwendung aus. Dieser Ansatz ist ideal für die Entwicklung, das Debuggen und um zu verstehen, welche Metriken das SDK sammelt, ohne externe Dienste wie Amazon CloudWatch zu benötigen. Im Gegensatz zu `CloudWatchMetricPublisher` und `EmfMetricLoggingPublisher` `LoggingMetricPublisher` bietet sofortige Ausgabe ohne Verzögerungen oder externe Abhängigkeiten. Dadurch eignet es sich perfekt für lokale Entwicklungs- und Problemlösungsszenarien. ## Wann sollte es verwendet werden LoggingMetricPublisher Verwenden Sie `LoggingMetricPublisher`, wenn Sie Folgendes benötigen: + Erfassung von Metriken während der Entwicklung debuggen + Verstehen Sie, welche Metriken das SDK für Ihren Betrieb sammelt + Beheben Sie Leistungsprobleme lokal + Testen Sie die Erfassung von Metriken ohne Abhängigkeiten von externen Diensten + Sehen Sie sich Metriken sofort in Ihrer Konsole oder in Ihren Protokolldateien an **Anmerkung** `LoggingMetricPublisher`wird nicht für Produktionsumgebungen empfohlen, in denen Sie persistente Speicher- und Analysefunktionen für Metriken benötigen. ## Richten Sie die Konsolenprotokollierung für Metriken ein Um die `LoggingMetricPublisher` Ausgabe zu sehen, konfigurieren Sie Ihr Logging-Framework so, dass `INFO` Level-Meldungen angezeigt werden. Die folgende `log4j2.xml` Konfiguration stellt sicher, dass Metriken in Ihrer Konsole angezeigt werden: ``` ``` Diese Konfiguration weist das SDK an, Metriken auf der entsprechenden `INFO` Ebene an Ihre Konsole auszugeben. Die `LoggingMetricPublisher` Logger-Konfiguration stellt sicher, dass die Metrikausgabe auch dann angezeigt wird, wenn Ihr Root-Logger eine höhere Ebene wie `WARN` oder verwendet`ERROR`. ## Aktivieren Sie Konsolenmetriken für einen Service-Client Das folgende Beispiel zeigt, wie Sie einen erstellen `LoggingMetricPublisher` und ihn mit einem Amazon Simple Storage Service-Client verwenden: ``` import software.amazon.awssdk.metrics.LoggingMetricPublisher; import software.amazon.awssdk.metrics.MetricPublisher; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3Client; // Create a LoggingMetricPublisher with default settings. MetricPublisher metricPublisher = LoggingMetricPublisher.create(); // Add the publisher to your service client. S3Client s3Client = S3Client.builder() .region(Region.US_EAST_1) .overrideConfiguration(config -> config.addMetricPublisher(metricPublisher)) .build(); // Make requests - metrics will appear in your console. s3Client.listBuckets(); // Clean up resources. metricPublisher.close(); s3Client.close(); ``` ## Wählen Sie das metrische Ausgabeformat `LoggingMetricPublisher`unterstützt zwei Ausgabeformate: + **PLAIN-Format (Standard):** Gibt Metriken als kompakte, einzeilige Einträge aus + **PRETTY-Format:** Gibt Metriken in einem mehrzeiligen, für Menschen lesbaren Format aus Das folgende Beispiel zeigt, wie das PRETTY-Format verwendet wird, um das Lesen während der Entwicklung zu erleichtern: ``` import org.slf4j.event.Level; import software.amazon.awssdk.metrics.LoggingMetricPublisher; // Create a LoggingMetricPublisher with PRETTY format. MetricPublisher prettyMetricPublisher = LoggingMetricPublisher.create( Level.INFO, LoggingMetricPublisher.Format.PRETTY ); // Use with your service client. S3Client s3Client = S3Client.builder() .region(Region.US_EAST_1) .overrideConfiguration(config -> config.addMetricPublisher(prettyMetricPublisher)) .build(); ``` ## Vollständiges Beispiel Das folgende Beispiel zeigt die Verwendung `LoggingMetricPublisher` auf zwei Arten: + Auf der Ebene des Serviceclients + Für eine einzige Anfrage ``` import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.slf4j.event.Level; import software.amazon.awssdk.metrics.LoggingMetricPublisher; import software.amazon.awssdk.metrics.MetricPublisher; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.ListBucketsRequest; import software.amazon.awssdk.services.s3.model.ListBucketsResponse; /** * Demonstrates how to use LoggingMetricPublisher with AWS S3 SDK for Java 2.x. *

* This demo focuses on the S3 listBuckets operation to show how metrics are collected * and logged to the console for development and debugging purposes. *

* LoggingMetricPublisher is ideal for: * - Development and debugging * - Console output for troubleshooting * - Understanding what metrics are being collected * - Testing metric collection without external dependencies */ public class S3LoggingMetricPublisherDemo { private static final Logger logger = LoggerFactory.getLogger(S3LoggingMetricPublisherDemo.class); public static void main(String[] args) { S3LoggingMetricPublisherDemo demo = new S3LoggingMetricPublisherDemo(); demo.demonstrateUsage(); } /** * Demonstrates basic usage with S3Client and metrics enabled at the client level. */ private void demonstrateUsage() { // Create a LoggingMetricPublisher with default settings. The SDK logs metrics as text in a single line. // The default settings are equivalent to using `LoggingMetricPublisher.Format.PLAIN`. MetricPublisher metricPublisher = LoggingMetricPublisher.create(); // Create an S3 client with metrics enabled. try (S3Client s3Client = S3Client.builder() .region(Region.US_EAST_1) .overrideConfiguration(config -> config.addMetricPublisher(metricPublisher)) .build()) { // Make the listBuckets request - metrics will be logged to console. ListBucketsResponse response = s3Client.listBuckets(ListBucketsRequest.builder().build()); // The next block shows the using a different LoggingMetricPublisher with a `PRETTY` format. // Since the metric publisher is added to the request using the `overrideConfiguration`, this formatting // applies only to the one request. try { s3Client.listBuckets(ListBucketsRequest.builder() .overrideConfiguration(config -> config .addMetricPublisher(LoggingMetricPublisher.create( Level.INFO, LoggingMetricPublisher.Format.PRETTY))) .build()); } catch (Exception e) { logger.info("Request failed with metrics logged: {}", e.getMessage()); } logger.info("Found {} buckets in your AWS account.", response.buckets().size()); } catch (Exception e) { logger.error("Error during S3 operation: {}", e.getMessage()); logger.info("Note: This is expected if AWS credentials are not configured."); } // Close the metric publisher to flush any remaining metrics. metricPublisher.close(); } } ``` Der Code protokolliert Folgendes auf der Konsole: ``` INFO LoggingMetricPublisher - Metrics published: MetricCollection(name=ApiCall, metrics=[MetricRecord(metric=MarshallingDuration, value=PT0.005409792S), MetricRecord(metric=RetryCount, value=0), MetricRecord(metric=ApiCallSuccessful, value=true), MetricRecord(metric=OperationName, value=ListBuckets), MetricRecord(metric=EndpointResolveDuration, value=PT0.000068S), MetricRecord(metric=ApiCallDuration, value=PT0.163802958S), MetricRecord(metric=CredentialsFetchDuration, value=PT0.145686542S), MetricRecord(metric=ServiceEndpoint, value=https://s3.amazonaws.com), MetricRecord(metric=ServiceId, value=S3)], children=[MetricCollection(name=ApiCallAttempt, metrics=[MetricRecord(metric=TimeToFirstByte, value=PT0.138816S), MetricRecord(metric=SigningDuration, value=PT0.007803459S), MetricRecord(metric=ReadThroughput, value=165153.96002660287), MetricRecord(metric=ServiceCallDuration, value=PT0.138816S), MetricRecord(metric=AwsExtendedRequestId, value=e13Swj3uwn0qP1Oz+m7II5OGq7jf8xxT8H18iDfRBCQmDg+gU4ek91Xrsl8XxRLROlIzCAPQtsQF0DAAWOb8ntuKCzX2AJdj), MetricRecord(metric=HttpStatusCode, value=200), MetricRecord(metric=BackoffDelayDuration, value=PT0S), MetricRecord(metric=TimeToLastByte, value=PT0.148915667S), MetricRecord(metric=AwsRequestId, value=78AW9BM7SWR6YMGB)], children=[MetricCollection(name=HttpClient, metrics=[MetricRecord(metric=MaxConcurrency, value=50), MetricRecord(metric=AvailableConcurrency, value=0), MetricRecord(metric=LeasedConcurrency, value=1), MetricRecord(metric=ConcurrencyAcquireDuration, value=PT0.002623S), MetricRecord(metric=PendingConcurrencyAcquires, value=0), MetricRecord(metric=HttpClientName, value=Apache)], children=[])])]) INFO LoggingMetricPublisher - [4e6f2bb5] ApiCall INFO LoggingMetricPublisher - [4e6f2bb5] ┌──────────────────────────────────────────┐ INFO LoggingMetricPublisher - [4e6f2bb5] │ MarshallingDuration=PT0.000063S │ INFO LoggingMetricPublisher - [4e6f2bb5] │ RetryCount=0 │ INFO LoggingMetricPublisher - [4e6f2bb5] │ ApiCallSuccessful=true │ INFO LoggingMetricPublisher - [4e6f2bb5] │ OperationName=ListBuckets │ INFO LoggingMetricPublisher - [4e6f2bb5] │ EndpointResolveDuration=PT0.000024375S │ INFO LoggingMetricPublisher - [4e6f2bb5] │ ApiCallDuration=PT0.018463083S │ INFO LoggingMetricPublisher - [4e6f2bb5] │ CredentialsFetchDuration=PT0.000022334S │ INFO LoggingMetricPublisher - [4e6f2bb5] │ ServiceEndpoint=https://s3.amazonaws.com │ INFO LoggingMetricPublisher - [4e6f2bb5] │ ServiceId=S3 │ INFO LoggingMetricPublisher - [4e6f2bb5] └──────────────────────────────────────────┘ INFO LoggingMetricPublisher - [4e6f2bb5] ApiCallAttempt INFO LoggingMetricPublisher - [4e6f2bb5] ┌───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ INFO LoggingMetricPublisher - [4e6f2bb5] │ TimeToFirstByte=PT0.0165575S │ INFO LoggingMetricPublisher - [4e6f2bb5] │ SigningDuration=PT0.000301125S │ INFO LoggingMetricPublisher - [4e6f2bb5] │ ReadThroughput=1195591.792850103 │ INFO LoggingMetricPublisher - [4e6f2bb5] │ ServiceCallDuration=PT0.0165575S │ INFO LoggingMetricPublisher - [4e6f2bb5] │ AwsExtendedRequestId=3QI1eenRuokdszWqZBmBMDUmko6FlSmHkM+CUMNMeLor7gJml4D4lv6QXUZ1zWoTgG+tHbr6yo2vHdz4h1P8PDovvtMFRCeB │ INFO LoggingMetricPublisher - [4e6f2bb5] │ HttpStatusCode=200 │ INFO LoggingMetricPublisher - [4e6f2bb5] │ BackoffDelayDuration=PT0S │ INFO LoggingMetricPublisher - [4e6f2bb5] │ TimeToLastByte=PT0.017952625S │ INFO LoggingMetricPublisher - [4e6f2bb5] │ AwsRequestId=78AVFAF795AAWAXH │ INFO LoggingMetricPublisher - [4e6f2bb5] └───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ INFO LoggingMetricPublisher - [4e6f2bb5] HttpClient INFO LoggingMetricPublisher - [4e6f2bb5] ┌───────────────────────────────────────┐ INFO LoggingMetricPublisher - [4e6f2bb5] │ MaxConcurrency=50 │ INFO LoggingMetricPublisher - [4e6f2bb5] │ AvailableConcurrency=0 │ INFO LoggingMetricPublisher - [4e6f2bb5] │ LeasedConcurrency=1 │ INFO LoggingMetricPublisher - [4e6f2bb5] │ ConcurrencyAcquireDuration=PT0.00004S │ INFO LoggingMetricPublisher - [4e6f2bb5] │ PendingConcurrencyAcquires=0 │ INFO LoggingMetricPublisher - [4e6f2bb5] │ HttpClientName=Apache │ INFO LoggingMetricPublisher - [4e6f2bb5] └───────────────────────────────────────┘ INFO S3LoggingMetricPublisherDemo - Found 6 buckets in your AWS account. ``` ### Zusätzliche Artefakte für das Beispiel Maven-Datei `pom.xml` ``` 4.0.0 com.example s3-logging-metric-publisher-demo 1.0.0 jar AWS S3 LoggingMetricPublisher Demo Demonstrates how to use LoggingMetricPublisher with AWS S3 SDK for Java 2.x 17 17 UTF-8 2.31.66 2.24.3 software.amazon.awssdk bom ${aws.java.sdk.version} pom import org.apache.logging.log4j log4j-bom ${log4j.version} pom import software.amazon.awssdk s3 org.apache.logging.log4j log4j-slf4j2-impl org.apache.logging.log4j log4j-core org.apache.maven.plugins maven-compiler-plugin 3.13.0 17 17 ``` `Log4j2.xml` Konfigurationsdatei ``` ``` Die Metriken umfassen Zeitinformationen, Servicedetails, Vorgangsnamen und HTTP-Statuscodes, die Ihnen helfen, die AWS API-Nutzungsmuster Ihrer Anwendung zu verstehen. ## Nächste Schritte Nach der Verwendung `LoggingMetricPublisher` für die Entwicklung und das Debuggen sollten Sie die folgenden Optionen für Produktionsumgebungen in Betracht ziehen: + Verwenden Sie für Anwendungen mit langer Laufzeit, [CloudWatchMetricPublisher](metric-pub-impl-cwmp.md)um Metriken CloudWatch zur Analyse und Benachrichtigung an Amazon zu senden + Verwenden Sie [EmfMetricLoggingPublisher](metric-pub-impl-emf.md)für AWS Lambda Funktionen die Veröffentlichung von Metriken im CloudWatch eingebetteten metrischen Format # AWS SDK for Java 2.x: Umfassende Metrik-Referenz Mit dem AWS SDK for Java 2.x können Sie Metriken von den Service-Clients in Ihrer Anwendung sammeln und diese Metriken dann auf [Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) veröffentlichen (ausgeben) CloudWatch. In diesen Tabellen sind die Metriken, die Sie sammeln können, sowie alle Anforderungen für die Nutzung des HTTP-Clients aufgeführt. Weitere Informationen zur Aktivierung und Konfiguration von Metriken für das SDK finden Sie unter [SDK-Metriken aktivieren](metrics.md). ## Bei jeder Anfrage gesammelte Metriken | Metrikname | Description | Typ | | --- | --- | --- | | ApiCallDuration | Die Dauer des API-Aufrufs. Dies schließt alle unternommenen Anrufversuche ein. | Dauer\$1 | | ApiCallSuccessful | Wahr, wenn der API-Aufruf erfolgreich war, andernfalls falsch. | Boolesch | | CredentialsFetchDuration | Die Zeitdauer, die benötigt wird, um die Signaturdaten für den API-Aufruf abzurufen. | Dauer\$1 | | EndpointResolveDuration | Die Dauer der Auflösung des Endpunkts, der für den API-Aufruf verwendet wurde. | Dauer\$1 | | MarshallingDuration | Die Zeitdauer, die benötigt wird, um die SDK-Anfrage in eine HTTP-Anfrage umzuwandeln. | Dauer\$1 | | OperationName | Der Name des aufgerufenen Dienstvorgangs. | Zeichenfolge | | RetryCount | Die Anzahl der Wiederholungen, die das SDK bei der Ausführung der Anforderung ausgeführt hat. 0 bedeutet, dass die Anfrage beim ersten Mal funktioniert hat und dass keine Wiederholungsversuche unternommen wurden. Weitere Hinweise zur Konfiguration des Wiederholungsverhaltens finden Sie unter. [Strategien für Wiederholungsversuche](retry-strategy.md#retry-strategies) | Ganzzahl | | ServiceId | Die eindeutige ID für den Dienst. | Zeichenfolge | | ServiceEndpoint | Der Endpunkt für den Dienst. | URI | | TokenFetchDuration | Die Dauer des Abrufs der Signaturdaten für den API-Aufruf. | Dauer\$1 | [\$1 java.time.Duration.](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/time/Duration.html) ## Für jeden Anforderungsversuch gesammelte Metriken Für jeden API-Aufruf sind möglicherweise mehrere Versuche erforderlich, bevor eine Antwort eingeht. Diese Metriken werden für jeden Versuch gesammelt. ### Kernmetriken | Metrikname | Description | Typ | | --- | --- | --- | | AwsExtendedRequestId | Die erweiterte Anfrage-ID der Serviceanfrage. | Zeichenfolge | | AwsRequestId | Die Anforderungs-ID der Serviceanfrage. | Zeichenfolge | | BackoffDelayDuration | Die Dauer, während der das SDK auf diesen API-Aufrufversuch gewartet hat. Der Wert basiert auf dem auf dem Client `[https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/api/BackoffStrategy.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/api/BackoffStrategy.html)` eingestellten Wert. Weitere Informationen finden Sie im [Strategien für Wiederholungsversuche](retry-strategy.md#retry-strategies) Abschnitt dieses Handbuchs. | Dauer\$1 | | ErrorType | Die Art des Fehlers, der bei einem Anrufversuch aufgetreten ist. Folgende Werte sind möglich: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/metrics-list.html) | Zeichenfolge | | ReadThroughput | Der Lesedurchsatz des Clients, definiert als. `NumberOfResponseBytesRead / (TTLB - TTFB)` Dieser Wert wird in Byte pro Sekunde angegeben. Beachten Sie, dass diese Metrik nur die Byte misst, die innerhalb von `ResponseTransformer` oder gelesen `AsyncResponseTransformer` werden. Daten, die außerhalb des Transformators gelesen werden — beispielsweise wenn der Antwortstream als Ergebnis des Transformators zurückgegeben wird — sind nicht in der Berechnung enthalten. | Double | | WriteThroughput | Der Schreibdurchsatz des Clients, definiert als. `RequestBytesWritten / (LastByteWrittenTime - FirstByteWrittenTime)` Dieser Wert wird in Byte pro Sekunde angegeben. Diese Metrik misst die Geschwindigkeit, mit der das SDK den Anforderungstext für den HTTP-Client bereitstellt. Sie schließt den Verbindungsaufbau, die TLS-Handshake-Zeit und die Serververarbeitungszeit aus. Diese Metrik wird nur für Anfragen gemeldet, die einen Streaming-Hauptteil wie S3 haben. PutObject Beachten Sie, dass diese Metrik die Pufferung auf der HTTP-Client-Ebene nicht berücksichtigt. Die tatsächliche Netzwerkübertragungsrate kann niedriger sein, wenn der HTTP-Client Daten vor dem Senden zwischenspeichert. Diese Metrik stellt eine Obergrenze des Netzwerkdurchsatzes dar. | Double | | ServiceCallDuration | Die Dauer, die benötigt wird, um eine Verbindung mit dem Dienst herzustellen (oder eine Verbindung vom Verbindungspool herzustellen), die serialisierte Anfrage zu senden und die erste Antwort zu empfangen (z. B. HTTP-Statuscode und Header). Dies beinhaltet NICHT die Zeit, die zum Lesen der gesamten Antwort vom Dienst benötigt wird. | Dauer\$1 | | SigningDuration | Die Zeitdauer für das Signieren der HTTP-Anfrage. | Dauer\$1 | | TimeToFirstByte | Die Zeitspanne zwischen dem Senden der HTTP-Anfrage (einschließlich des Aufbaus einer Verbindung) an den Dienst und dem Empfangen des ersten Bytes der Header in der Antwort. | Dauer\$1 | | TimeToLastByte | Die Zeitspanne zwischen dem Senden der HTTP-Anfrage (einschließlich des Aufbaus einer Verbindung) an den Dienst und dem Empfangen des letzten Bytes der Antwort. Beachten Sie, dass APIs sich diese Metrik bei zurückgesendeten Streaming-Antworten über die Zeit erstreckt, bis das `ResponseTransformer` Oder `AsyncResponseTransformer` abgeschlossen ist. | Dauer\$1 | | UnmarshallingDuration | Die Zeitdauer für das Unmarshalling der HTTP-Antwort auf eine SDK-Antwort. Hinweis: Bei Streaming-Vorgängen beinhaltet dies nicht die Zeit zum Lesen der Antwortnutzdaten. | Dauer\$1 | [\$1 java.time.Duration.](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/time/Duration.html) ### HTTP-Metriken | Metrikname | Description | Typ | HTTP-Client erforderlich\$1 | | --- | --- | --- | --- | | AvailableConcurrency | Die Anzahl zusätzlicher gleichzeitiger Anfragen, die der HTTP-Client unterstützt, ohne dass neue Verbindungen zum Zielserver hergestellt werden. Bei HTTP/1-Vorgängen entspricht dies der Anzahl der inaktiven TCP-Verbindungen, die mit dem Dienst eingerichtet wurden. Bei HTTP/2-Vorgängen entspricht dies der Anzahl der inaktiven Streams. Hinweis: Dieser Wert variiert je nach Implementierung des HTTP-Clients: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/metrics-list.html) Der Wert ist auf eine einzelne HTTP-Clientinstanz beschränkt und schließt die Parallelität anderer HTTP-Clients in derselben JVM aus. | Ganzzahl | Apache, Netty, CRT | | ConcurrencyAcquireDuration | Die Zeitdauer, die benötigt wird, um einen Kanal aus dem Verbindungspool zu beziehen. Bei HTTP/1-Vorgängen entspricht ein Kanal einer TCP-Verbindung. Bei HTTP/2-Operationen entspricht ein Kanal einem HTTP/2-Stream-Kanal. Der Erwerb eines neuen Kanals kann Zeit beinhalten für: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/metrics-list.html) | Dauer\$1 | Apache, Netty, CRT | | HttpClientName | Der Name des für die Anfrage verwendeten HTTPs. | Zeichenfolge | Apache, Netty, CRT | | HttpStatusCode | Der Statuscode der HTTP-Antwort. | Ganzzahl | Beliebig | | LeasedConcurrency | Die Anzahl der Anfragen, die der HTTP-Client derzeit ausführt. Bei HTTP/1-Vorgängen entspricht dies der Anzahl der aktiven TCP-Verbindungen mit dem Dienst (ohne inaktive Verbindungen). Bei HTTP/2-Vorgängen entspricht dies der Anzahl der aktiven HTTP-Streams mit dem Dienst (ohne Stream-Kapazität im Leerlauf). Hinweis: Dieser Wert variiert je nach Implementierung des HTTP-Clients: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/metrics-list.html) Der Wert ist auf eine einzelne HTTP-Clientinstanz beschränkt und schließt die Parallelität anderer HTTP-Clients in derselben JVM aus. | Ganzzahl | Apache, Netty, CRT | | LocalStreamWindowSize | Die lokale HTTP/2-Fenstergröße in Byte für den Stream, der diese Anforderung ausführt. | Ganzzahl | Netty | | MaxConcurrency | Die maximale Anzahl gleichzeitiger Anfragen, die der HTTP-Client unterstützt. Bei HTTP/1-Vorgängen entspricht dies der maximalen Anzahl von TCP-Verbindungen, die der HTTP-Client bündeln kann. Bei HTTP/2-Vorgängen entspricht dies der maximalen Anzahl von Streams, die der HTTP-Client bündeln kann. Hinweis: Dieser Wert variiert je nach Implementierung des HTTP-Clients: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/metrics-list.html) Der Wert ist auf eine einzelne HTTP-Clientinstanz beschränkt und schließt die Parallelität anderer HTTP-Clients in derselben JVM aus. | Ganzzahl | Apache, Netty, CRT | | PendingConcurrencyAcquires | Die Anzahl der Anfragen, die auf Parallelität vom HTTP-Client warten. Bei HTTP/1-Vorgängen entspricht dies der Anzahl der Anfragen, die darauf warten, dass eine TCP-Verbindung hergestellt wird oder aus dem Verbindungspool zurückkehrt. Bei HTTP/2-Operationen entspricht dies der Anzahl der Anfragen, die auf einen neuen Stream (und möglicherweise eine neue HTTP/2-Verbindung) aus dem Verbindungspool warten. Hinweis: Dieser Wert variiert je nach Implementierung des HTTP-Clients: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/metrics-list.html) Der Wert ist auf eine einzelne HTTP-Clientinstanz beschränkt und schließt die Parallelität anderer HTTP-Clients in derselben JVM aus. | Ganzzahl | Apache, Netty, CRT | | RemoteStreamWindowSize | Die Größe des Remote-HTTP/2-Fensters in Byte für den Stream, der diese Anforderung ausführt. | Ganzzahl | Netty | \$1 [java.time.Duration](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/time/Duration.html). Die in der Spalte verwendeten Begriffe bedeuten: + Apache: der Apache-basierte HTTP-Client () `[ApacheHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html)` + Netty: der Netty-basierte HTTP-Client () `[NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html)` + CRT: der AWS CRT-basierte HTTP-Client () `[AwsCrtAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.html)` + Beliebig: Die Erfassung von Metrikdaten hängt nicht vom HTTP-Client ab. Dazu gehört auch der URLConnection basierte HTTP-Client () `[UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html)`