Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Arbeiten Sie mit Amazon EC2 EC2-Instance-Metadaten
Ein Java-SDK-Client für den Amazon EC2 Instance Metadata Service (Metadaten-Client) ermöglicht Ihren Anwendungen den Zugriff auf Metadaten auf ihrer lokalen EC2-Instance. Der Metadaten-Client arbeitet mit der lokalen Instanz von [IMDSv2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html)(Instance Metadata Service v2) und verwendet sitzungsorientierte Anfragen.
Zwei Clientklassen sind im SDK verfügbar. Die synchrone Variante `[Ec2MetadataClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/imds/Ec2MetadataClient.html)` dient zum Blockieren von Vorgängen und die [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/imds/Ec2MetadataAsyncClient.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/imds/Ec2MetadataAsyncClient.html)für asynchrone, nicht blockierende Anwendungsfälle.
## Erste Schritte
Um den Metadaten-Client zu verwenden, fügen Sie das `imds` Maven-Artefakt zu Ihrem Projekt hinzu. Sie benötigen auch Klassen für eine `[SdkHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/SdkHttpClient.html)` (oder eine `[SdkAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/async/SdkAsyncHttpClient.html)` für die asynchrone Variante) im Klassenpfad.
Das folgende Maven-XML zeigt Abhängigkeits-Snippets für die Verwendung der synchronen [UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html)Version zusammen mit der Abhängigkeit für Metadaten-Clients.
```
software.amazon.awssdk
bom
VERSION
pom
import
software.amazon.awssdk
imds
software.amazon.awssdk
url-connection-client
```
Suchen Sie im [zentralen Maven-Repository](https://central.sonatype.com/artifact/software.amazon.awssdk/bom) nach der neuesten Version des Artefakts. `bom`
Um einen asynchronen HTTP-Client zu verwenden, ersetzen Sie das Abhängigkeits-Snippet für das Artefakt. `url-connection-client` Das folgende Snippet bringt beispielsweise die Implementierung mit ein. [NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html)
```
software.amazon.awssdk
netty-nio-client
```
## Verwenden Sie den Metadaten-Client
### Instanziieren Sie einen Metadaten-Client
Sie können eine Instanz eines synchronen Systems instanziieren, `Ec2MetadataClient` wenn nur eine Implementierung der `SdkHttpClient` Schnittstelle im Klassenpfad vorhanden ist. Rufen Sie dazu die statische `Ec2MetadataClient#create()` Methode auf, wie im folgenden Codeausschnitt gezeigt.
```
Ec2MetadataClient client = Ec2MetadataClient.create(); // 'Ec2MetadataAsyncClient#create' is the asynchronous version.
```
Wenn Ihre Anwendung über mehrere Implementierungen der `SdkHttpClient` `SdkHttpAsyncClient` OR-Schnittstelle verfügt, müssen Sie eine Implementierung angeben, die der Metadaten-Client verwenden soll, wie im Abschnitt gezeigt. [Konfigurierbarer HTTP-Client](#examples-ec2-IMDS-features-http)
**Anmerkung**
Für die meisten Service-Clients, wie Amazon S3, fügt das SDK for Java automatisch Implementierungen der `SdkHttpClient` `SdkHttpAsyncClient` OR-Schnittstelle hinzu. Wenn Ihr Metadaten-Client dieselbe Implementierung verwendet, `Ec2MetadataClient#create()` funktioniert das. Wenn Sie eine andere Implementierung benötigen, müssen Sie diese angeben, wenn Sie den Metadaten-Client erstellen.
### Anfragen senden
Um Instanzmetadaten abzurufen, instanziieren Sie die `EC2MetadataClient` Klasse und rufen Sie die `get` Methode mit einem Pfadparameter auf, der die [Metadatenkategorie der Instanz](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-categories.html) angibt.
Im folgenden Beispiel wird der mit dem `ami-id` Schlüssel verknüpfte Wert in die Konsole gedruckt.
```
Ec2MetadataClient client = Ec2MetadataClient.create();
Ec2MetadataResponse response = client.get("/latest/meta-data/ami-id");
System.out.println(response.asString());
client.close(); // Closes the internal resources used by the Ec2MetadataClient class.
```
Wenn der Pfad nicht gültig ist, löst die `get` Methode eine Ausnahme aus.
Verwenden Sie dieselbe Client-Instanz für mehrere Anfragen, rufen Sie jedoch den Client `close` auf, wenn er nicht mehr benötigt wird, um Ressourcen freizugeben. Nach dem Aufruf der Methode close kann die Client-Instanz nicht mehr verwendet werden.
### Antworten analysieren
EC2-Instanz-Metadaten können in verschiedenen Formaten ausgegeben werden. Klartext und JSON sind die am häufigsten verwendeten Formate. Die Metadaten-Clients bieten Möglichkeiten, mit diesen Formaten zu arbeiten.
Wie das folgende Beispiel zeigt, verwenden Sie die `asString` Methode, um die Daten als Java-String abzurufen. Sie können die `asList` Methode auch verwenden, um eine Klartext-Antwort zu trennen, die mehrere Zeilen zurückgibt.
```
Ec2MetadataClient client = Ec2MetadataClient.create();
Ec2MetadataResponse response = client.get("/latest/meta-data/");
String fullResponse = response.asString();
List splits = response.asList();
```
Wenn die Antwort in JSON ist, verwenden Sie die `Ec2MetadataResponse#asDocument` Methode, um die JSON-Antwort in eine [Dokumentinstanz](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/document/Document.html) zu parsen, wie im folgenden Codeausschnitt gezeigt.
```
Document fullResponse = response.asDocument();
```
Eine Ausnahme wird ausgelöst, wenn das Format der Metadaten nicht in JSON ist. Wenn die Antwort erfolgreich analysiert wurde, können Sie die [Dokument-API](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/document/package-summary.html) verwenden, um die Antwort genauer zu untersuchen. In der [Tabelle mit den Kategorien der Instanz-Metadaten](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-categories.html) erfahren Sie, welche Metadatenkategorien Antworten im JSON-Format liefern.
## Konfigurieren Sie einen Metadaten-Client
### Erneute Versuche
Sie können einen Metadaten-Client mit einem Wiederholungsmechanismus konfigurieren. Wenn Sie dies tun, kann der Client Anfragen, die aus unerwarteten Gründen fehlschlagen, automatisch wiederholen. Standardmäßig versucht der Client bei einer fehlgeschlagenen Anfrage dreimal, wobei zwischen den Versuchen eine exponentielle Backoff-Zeit liegt.
Wenn Ihr Anwendungsfall einen anderen Wiederholungsmechanismus erfordert, können Sie den Client mithilfe der `retryPolicy` Methode in seinem Builder anpassen. Das folgende Beispiel zeigt beispielsweise einen synchronen Client, der mit einer festen Verzögerung von zwei Sekunden zwischen Versuchen und fünf Wiederholungsversuchen konfiguriert ist.
```
BackoffStrategy fixedBackoffStrategy = FixedDelayBackoffStrategy.create(Duration.ofSeconds(2));
Ec2MetadataClient client =
Ec2MetadataClient.builder()
.retryPolicy(retryPolicyBuilder -> retryPolicyBuilder.numRetries(5)
.backoffStrategy(fixedBackoffStrategy))
.build();
```
Es gibt mehrere [BackoffStrategies](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/retry/backoff/package-summary.html), die Sie mit einem Metadaten-Client verwenden können.
Sie können den Wiederholungsmechanismus auch vollständig deaktivieren, wie der folgende Ausschnitt zeigt.
```
Ec2MetadataClient client =
Ec2MetadataClient.builder()
.retryPolicy(Ec2MetadataRetryPolicy.none())
.build();
```
Durch die Verwendung `Ec2MetadataRetryPolicy#none()` wird die standardmäßige Wiederholungsrichtlinie deaktiviert, sodass der Metadaten-Client keine Wiederholungen versucht.
### IP-Version
Standardmäßig verwendet ein Metadaten-Client den IPV4 Endpunkt unter. `http://169.254.169.254` Um den Client so zu ändern, dass er die IPV6 Version verwendet, verwenden Sie entweder die `endpointMode` oder die `endpoint` Methode des Builders. Eine Ausnahme ergibt sich, wenn beide Methoden im Builder aufgerufen werden.
Die folgenden Beispiele zeigen beide IPV6 Optionen.
```
Ec2MetadataClient client =
Ec2MetadataClient.builder()
.endpointMode(EndpointMode.IPV6)
.build();
```
```
Ec2MetadataClient client =
Ec2MetadataClient.builder()
.endpoint(URI.create("http://[fd00:ec2::254]"))
.build();
```
## Schlüssel-Features
### Asynchroner Client
Um die nicht blockierende Version des Clients zu verwenden, instanziieren Sie eine Instanz der Klasse. `Ec2MetadataAsyncClient` Der Code im folgenden Beispiel erstellt einen asynchronen Client mit Standardeinstellungen und verwendet die `get` Methode, um den Wert für den Schlüssel abzurufen. `ami-id`
```
Ec2MetadataAsyncClient asyncClient = Ec2MetadataAsyncClient.create();
CompletableFuture response = asyncClient.get("/latest/meta-data/ami-id");
```
Der von der `get` Methode `java.util.concurrent.CompletableFuture` zurückgegebene Vorgang wird abgeschlossen, wenn die Antwort zurückgegeben wird. Im folgenden Beispiel werden die `ami-id` Metadaten auf die Konsole gedruckt.
```
response.thenAccept(metadata -> System.out.println(metadata.asString()));
```
### Konfigurierbarer HTTP-Client
Der Builder für jeden Metadaten-Client verfügt über eine `httpClient` Methode, mit der Sie einen benutzerdefinierten HTTP-Client bereitstellen können.
Das folgende Beispiel zeigt Code für eine benutzerdefinierte `UrlConnectionHttpClient` Instanz.
```
SdkHttpClient httpClient =
UrlConnectionHttpClient.builder()
.socketTimeout(Duration.ofMinutes(5))
.proxyConfiguration(proxy -> proxy.endpoint(URI.create("http://proxy.example.net:8888"))))
.build();
Ec2MetadataClient metaDataClient =
Ec2MetadataClient.builder()
.httpClient(httpClient)
.build();
// Use the metaDataClient instance.
metaDataClient.close(); // Close the instance when no longer needed.
```
Das folgende Beispiel zeigt Code für eine benutzerdefinierte `NettyNioAsyncHttpClient` Instanz mit einem asynchronen Metadaten-Client.
```
SdkAsyncHttpClient httpAsyncClient =
NettyNioAsyncHttpClient.builder()
.connectionTimeout(Duration.ofMinutes(5))
.maxConcurrency(100)
.build();
Ec2MetadataAsyncClient asyncMetaDataClient =
Ec2MetadataAsyncClient.builder()
.httpClient(httpAsyncClient)
.build();
// Use the asyncMetaDataClient instance.
asyncMetaDataClient.close(); // Close the instance when no longer needed.
```
Das [Konfigurieren Sie HTTP-Clients in der AWS SDK for Java 2.x](http-configuration.md) Thema in diesem Handbuch enthält Einzelheiten zur Konfiguration der HTTP-Clients, die im SDK for Java verfügbar sind.
### Zwischenspeichern von Token
Da die Clients die Metadaten verwenden IMDSv2, sind alle Anfragen mit einer Sitzung verknüpft. Eine Sitzung wird durch ein Token mit Ablauf definiert, das der Metadaten-Client für Sie verwaltet. Bei jeder Metadatenanforderung wird das Token automatisch wiederverwendet, bis es abläuft.
Standardmäßig ist ein Token sechs Stunden (21.600 Sekunden) gültig. Wir empfehlen, den time-to-live Standardwert beizubehalten, es sei denn, Ihr spezieller Anwendungsfall erfordert eine erweiterte Konfiguration.
Falls erforderlich, konfigurieren Sie die Dauer mithilfe der `tokenTtl` Builder-Methode. Mit dem Code im folgenden Codeausschnitt wird beispielsweise ein Client mit einer Sitzungsdauer von fünf Minuten erstellt.
```
Ec2MetadataClient client =
Ec2MetadataClient.builder()
.tokenTtl(Duration.ofMinutes(5))
.build();
```
Wenn Sie den Aufruf der `tokenTtl` Methode im Builder weglassen, wird stattdessen die Standarddauer von 21.600 verwendet.