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.
# Konfigurieren Sie HTTP-Clients in der AWS SDK for Java 2.x
Sie können den HTTP-Client ändern, der für Ihren Service-Client verwendet werden soll, sowie die Standardkonfiguration für HTTP-Clients mit dem ändern AWS SDK for Java 2.x. In diesem Abschnitt werden HTTP-Clients und Einstellungen für das SDK beschrieben.
## HTTP-Clients sind im SDK for Java verfügbar
### Synchrone Clients
Synchrone HTTP-Clients im SDK for Java implementieren die [SdkHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/SdkHttpClient.html)Schnittstelle. Ein synchroner Dienstclient, wie der `S3Client` oder der`DynamoDbClient`, erfordert die Verwendung eines synchronen HTTP-Clients. Der AWS SDK für Java bietet drei synchrone HTTP-Clients.
**ApacheHttpClient (Standard)**
[ApacheHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html)ist der Standard-HTTP-Client für synchrone Service-Clients. Hinweise zur Konfiguration von finden Sie `ApacheHttpClient` unter[Den Apache-basierten HTTP-Client konfigurieren](http-configuration-apache.md).
**AwsCrtHttpClient**
[AwsCrtHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.html)bietet hohen Durchsatz und blockierungsfreie I/O. Es basiert auf dem AWS Common Runtime (CRT) Http Client. Hinweise zur Konfiguration `AwsCrtHttpClient` und Verwendung mit Service-Clients finden Sie unter[AWS CRT-basierte HTTP-Clients konfigurieren](http-configuration-crt.md).
**UrlConnectionHttpClient**
Um die Anzahl der von Ihrer Anwendung verwendeten JAR-Dateien und Bibliotheken von Drittanbietern zu minimieren, können Sie die verwenden [UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html). Hinweise zur Konfiguration von finden `UrlConnectionHttpClient` Sie unter[Den URLConnection basierten HTTP-Client konfigurieren](http-configuration-url.md).
**Apache 5 HttpClient**
[Apache5 HttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache5/Apache5HttpClient.html) *ist eine aktualisierte Version davon, die auf dem Apache `ApacheHttpClient` 5.x basiert. HttpClient Version 5.x* ist die Version, die aktiv von Apache betreut wird. Sie verbessert die vorherige Version, `ApacheHttpClient` indem sie die Kompatibilität mit dem modernen Java-Ökosystem bietet, einschließlich virtueller Thread-Unterstützung für Java 21 und verbesserter Logging-Flexibilität durch SLF4 J., der in einer future Version des AWS SDK for Java 2.x `ApacheHttpClient` als standardmäßigen synchronen Client ersetzt `Apache5HttpClient` wird. Sie verfügt über eine identische API und identische Funktionen, sodass sie sich ideal als Drop-In-Ersatz eignet. Informationen zur Konfiguration von finden Sie `Apache5HttpClient` unter[Konfigurieren Sie den Apache 5.x-basierten HTTP-Client](http-configuration-apache5.md).
### Asynchrone Clients
Asynchrone HTTP-Clients im SDK for Java implementieren die [SdkAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/async/SdkAsyncHttpClient.html)Schnittstelle. Ein asynchroner Dienstclient, wie der `S3AsyncClient` oder der`DynamoDbAsyncClient`, erfordert die Verwendung eines asynchronen HTTP-Clients. Der AWS SDK für Java bietet zwei asynchrone HTTP-Clients.
**NettyNioAsyncHttpClient (Standard)**
[NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html)ist der Standard-HTTP-Client, der von asynchronen Clients verwendet wird. Hinweise zur Konfiguration von finden Sie `NettyNioAsyncHttpClient` unter[Den Netty-basierten HTTP-Client konfigurieren](http-configuration-netty.md).
**AwsCrtAsyncHttpClient**
Der [AwsCrtAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.html)basiert auf dem AWS Common Runtime (CRT) -HTTP-Client. Hinweise zur Konfiguration von finden Sie `AwsCrtAsyncHttpClient` unter[AWS CRT-basierte HTTP-Clients konfigurieren](http-configuration-crt.md).
## Empfehlungen für HTTP-Clients
Bei der Auswahl einer HTTP-Client-Implementierung spielen mehrere Faktoren eine Rolle. Verwenden Sie die folgenden Informationen als Entscheidungshilfe.
### Flussdiagramm für Empfehlungen
Das folgende Flussdiagramm enthält allgemeine Hinweise, anhand derer Sie bestimmen können, welcher HTTP-Client verwendet werden soll.
![\[Flussdiagramm der HTTP-Client-Empfehlungen.\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/images/JavaDevGuide-HTTPflowchart-DI.png)
### Vergleich von HTTP-Clients
Die folgende Tabelle enthält detaillierte Informationen für jeden HTTP-Client.
| HTTP-Client | Synchronisieren oder asynchron | Wann sollte dies verwendet werden? | Einschränkung/Nachteil |
| --- | --- | --- | --- |
| Apache-basierter HTTP-Client *(Standard-Synchronisierungs-HTTP-Client)* | Synchronisierung | Verwenden Sie ihn, wenn Sie eine niedrige Latenz einem hohen Durchsatz vorziehen | Langsamere Startzeit im Vergleich zu anderen HTTP-Clients |
| URLConnection-basierter HTTP-Client | Synchronisierung | Verwenden Sie es, wenn Sie unbedingt die Abhängigkeiten von Drittanbietern einschränken möchten | Unterstützt nicht die HTTP-PATCH-Methode, die für einige APIS wie Amazon APIGateway Update-Operationen erforderlich ist |
| AWS CRT-basierter Sync-HTTP-Client 1 | Synchronisierung | • Verwenden Sie es, wenn Ihre Anwendung in läuft AWS Lambda • Verwenden Sie es, wenn Sie einen hohen Durchsatz einer niedrigen Latenz vorziehen • Verwenden Sie es, wenn Sie SDK-Clients synchronisieren möchten | Die folgenden Java-Systemeigenschaften werden nicht unterstützt: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/http-configuration.html) |
| Netty-basierter HTTP-Client *(standardmäßiger asynchroner HTTP-Client)* | Asynchron | • Verwenden Sie es, wenn Ihre Anwendung Aufrufe aufruft APIs , für die HTTP/2-Unterstützung erforderlich ist, z. B. die Kinesis-API [SubscribeToShard](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_SubscribeToShard.html) | Langsamere Startzeit im Vergleich zu anderen HTTP-Clients |
| AWS CRT-basierter asynchroner HTTP-Client 1 | Asynchron | • Verwenden Sie es, wenn Ihre Anwendung in läuft AWS Lambda• Verwenden Sie es, wenn Sie einen hohen Durchsatz einer niedrigen Latenz vorziehen• Verwenden Sie es, wenn Sie asynchrone SDK-Clients bevorzugen | • Unterstützt keine Service-Clients, die HTTP/2-Unterstützung benötigen, wie und `KinesisAsynClient` `TranscribeStreamingAsyncClient` Die folgenden Java-Systemeigenschaften werden nicht unterstützt: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/http-configuration.html) |
1 Aufgrund ihrer zusätzlichen Vorteile empfehlen wir, wenn möglich die AWS CRT-basierten HTTP-Clients zu verwenden.
## Standardeinstellungen für die intelligente Konfiguration
Die AWS SDK for Java 2.x (Version 2.17.102 oder höher) bietet eine Funktion für intelligente Standardeinstellungen für Konfigurationen. Diese Funktion optimiert zwei HTTP-Client-Eigenschaften zusammen mit anderen Eigenschaften, die den HTTP-Client nicht beeinflussen.
Die Standardeinstellungen der intelligenten Konfiguration legen sinnvolle Werte für die `tlsNegotiationTimeoutInMillis` Eigenschaften `connectTimeoutInMillis` und fest, die auf einem von Ihnen angegebenen Standardmoduswert basieren. Sie wählen den Standardmoduswert auf der Grundlage der Eigenschaften Ihrer Anwendung.
Weitere Informationen zu den Standardeinstellungen für intelligente Konfigurationen und zur Auswahl des Standardmoduswerts, der für Ihre Anwendungen am besten geeignet ist, finden Sie im Referenzhandbuch [AWS SDKs und im Tools-Referenzhandbuch](https://docs.aws.amazon.com/sdkref/latest/guide/feature-smart-config-defaults.html).
Im Folgenden finden Sie vier Möglichkeiten, den Standardmodus für Ihre Anwendung festzulegen.
------
#### [ Service client ]
Verwenden Sie den Service Client Builder, um den Standardmodus direkt auf dem Service Client zu konfigurieren. Im folgenden Beispiel wird der Standardmodus `auto` für den auf festgelegt. `DynamoDbClient`
```
DynamoDbClient ddbClient = DynamoDbClient.builder()
.defaultsMode(DefaultsMode.AUTO)
.build();
```
------
#### [ System property ]
Sie können die `aws.defaultsMode` Systemeigenschaft verwenden, um den Standardmodus anzugeben. Wenn Sie die Systemeigenschaft in Java festlegen, müssen Sie die Eigenschaft festlegen, bevor Sie einen Service-Client initialisieren.
Das folgende Beispiel zeigt Ihnen, wie Sie den Standardmodus so einstellen, dass er eine in `auto` Java festgelegte Systemeigenschaft verwendet.
```
System.setProperty("aws.defaultsMode", "auto");
```
Das folgende Beispiel zeigt, wie Sie den Standardmodus `auto` mithilfe einer `-D` Option des Befehls auf „Standardmodus“ festlegen. `java`
```
java -Daws.defaultsMode=auto
```
------
#### [ Environment variable ]
Geben Sie einen Wert für die Umgebungsvariable ein`AWS_DEFAULTS_MODE`, um den Standardmodus für Ihre Anwendung auszuwählen.
Die folgenden Informationen zeigen den Befehl, der ausgeführt werden muss, um den Wert für den Standardmodus auf die `auto` Verwendung einer Umgebungsvariablen festzulegen.
| Betriebssystem | Befehl zum Setzen von Umgebungsvariablen |
| --- | --- |
| Linux, macOS oder Unix | export AWS\$1DEFAULTS\$1MODE=auto |
| Windows | set AWS\$1DEFAULTS\$1MODE=auto |
------
#### [ AWS config file ]
Sie können der gemeinsam genutzten AWS `config` Datei eine `defaults_mode` Konfigurationseigenschaft hinzufügen, wie das folgende Beispiel zeigt.
```
[default]
defaults_mode = auto
```
------
Wenn Sie den Standardmodus global mit der Systemeigenschaft, der Umgebungsvariablen oder der AWS Konfigurationsdatei festlegen, können Sie die Einstellungen beim Erstellen eines HTTP-Clients überschreiben.
Wenn Sie mit `httpClientBuilder()` dieser Methode einen HTTP-Client erstellen, gelten die Einstellungen nur für die Instanz, die Sie gerade erstellen. Ein Beispiel dafür wird [hier](http-configuration-netty.md#http-config-netty-one-client) gezeigt. Der Netty-basierte HTTP-Client in diesem Beispiel überschreibt alle global für und festgelegten Standardmoduswerte. `connectTimeoutInMillis` `tlsNegotiationTimeoutInMillis`
# Den Apache-basierten HTTP-Client konfigurieren
Synchrone Service-Clients AWS SDK for Java 2.x verwenden standardmäßig einen Apache-basierten HTTP-Client. [ApacheHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html) Die SDKs basieren auf dem `ApacheHttpClient` Apache. [HttpClient](https://hc.apache.org/httpcomponents-client-4.5.x/index.html)
Das SDK bietet auch das [UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html), das schneller geladen wird, aber weniger Funktionen hat. Hinweise zur Konfiguration von finden `UrlConnectionHttpClient` Sie unter[Den URLConnection basierten HTTP-Client konfigurieren](http-configuration-url.md).
Alle verfügbaren Konfigurationsoptionen für finden Sie unter [ApacheHttpClient.Builder und [ProxyConfiguration.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ProxyConfiguration.Builder.html)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.Builder.html). `ApacheHttpClient`
## Greifen Sie auf `ApacheHttpClient`
In den meisten Situationen verwenden Sie die `ApacheHttpClient` ohne explizite Konfiguration. Sie deklarieren Ihre Service-Clients und das SDK konfiguriert sie `ApacheHttpClient` mit Standardwerten für Sie.
Wenn Sie den explizit konfigurieren `ApacheHttpClient` oder ihn mit mehreren Service-Clients verwenden möchten, müssen Sie ihn für die Konfiguration verfügbar machen.
### Keine Konfiguration erforderlich
Wenn Sie in Maven eine Abhängigkeit von einem Service-Client deklarieren, fügt das SDK eine *Laufzeitabhängigkeit* von dem `apache-client` Artefakt hinzu. Dadurch steht die `ApacheHttpClient` Klasse Ihrem Code zur Laufzeit zur Verfügung, aber nicht zur Kompilierzeit. Wenn Sie den Apache-basierten HTTP-Client nicht konfigurieren, müssen Sie dafür keine Abhängigkeit angeben.
Im folgenden XML-Snippet einer `pom.xml` Maven-Datei wird durch die mit deklarierte Abhängigkeit `s3` automatisch der Apache-basierte HTTP-Client eingebunden. Sie müssen keine spezielle Abhängigkeit dafür deklarieren.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
s3
```
Mit diesen Abhängigkeiten können Sie keine expliziten Änderungen an der HTTP-Konfiguration vornehmen, da sich die `ApacheHttpClient` Bibliothek nur im Laufzeit-Klassenpfad befindet.
### Konfiguration erforderlich
*Um das zu konfigurieren`ApacheHttpClient`, müssen Sie bei der Kompilierung eine Abhängigkeit von der `apache-client` Bibliothek hinzufügen.*
Sehen Sie sich das folgende Beispiel für eine `pom.xml` Maven-Datei an, um die `ApacheHttpClient` zu konfigurieren.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
s3
software.amazon.awssdk
apache-client
```
## Verwenden und konfigurieren Sie den `ApacheHttpClient`
Sie können eine Instanz von `ApacheHttpClient` konfigurieren und gleichzeitig einen Service Client erstellen, oder Sie können eine einzelne Instanz so konfigurieren, dass sie von mehreren Service Clients gemeinsam genutzt wird.
Bei beiden Ansätzen verwenden Sie den, `[ApacheHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.Builder.html)` um die Eigenschaften für den Apache-basierten HTTP-Client zu konfigurieren.
### Bewährtes Verfahren: Weisen Sie einem Service-Client eine `ApacheHttpClient` Instanz zu
Wenn Sie eine Instanz von konfigurieren müssen, empfehlen wir Ihnen`ApacheHttpClient`, die dedizierte `ApacheHttpClient` Instanz zu erstellen. Sie können dies tun, indem Sie die `httpClientBuilder` Methode des Builders des Service-Clients verwenden. Auf diese Weise wird der Lebenszyklus des HTTP-Clients vom SDK verwaltet, wodurch potenzielle Speicherlecks vermieden werden, wenn die `ApacheHttpClient` Instanz nicht geschlossen wird, wenn sie nicht mehr benötigt wird.
Im folgenden Beispiel wird eine `S3Client` eingebettete Instanz von `ApacheHttpClient` with `maxConnections` and `connectionTimeout` values erstellt und konfiguriert. Die HTTP-Instanz wird mit der `httpClientBuilder` Methode von `S3Client.Builder` erstellt.
**Importe**
```
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Code**
```
S3Client s3Client = S3Client // Singleton: Use the s3Client for all requests.
.builder()
.httpClientBuilder(ApacheHttpClient.builder()
.maxConnections(100)
.connectionTimeout(Duration.ofSeconds(5))
).build();
// Perform work with the s3Client.
s3Client.close(); // Requests completed: Close all service clients.
```
### Alternativer Ansatz: Eine `ApacheHttpClient` Instanz teilen
Um den Ressourcen- und Speicherverbrauch für Ihre Anwendung zu senken, können Sie eine konfigurieren `ApacheHttpClient` und sie von mehreren Service-Clients gemeinsam nutzen. Der HTTP-Verbindungspool wird gemeinsam genutzt, was die Ressourcennutzung senkt.
**Anmerkung**
Wenn eine `ApacheHttpClient` Instanz gemeinsam genutzt wird, müssen Sie sie schließen, wenn sie bereit ist, gelöscht zu werden. Das SDK schließt die Instanz nicht, wenn der Service-Client geschlossen wird.
Im folgenden Beispiel wird ein Apache-basierter HTTP-Client konfiguriert, der von zwei Service-Clients verwendet wird. Die konfigurierte `ApacheHttpClient` Instanz wird an die `httpClient` Methode jedes Builders übergeben. Wenn die Service-Clients und der HTTP-Client nicht mehr benötigt werden, werden sie durch den Code explizit geschlossen. Der Code schließt den HTTP-Client zuletzt.
**Importe**
```
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.s3.S3Client;
```
**Code**
```
SdkHttpClient apacheHttpClient = ApacheHttpClient.builder()
.maxConnections(100).build();
// Singletons: Use the s3Client and dynamoDbClient for all requests.
S3Client s3Client =
S3Client.builder()
.httpClient(apacheHttpClient).build();
DynamoDbClient dynamoDbClient =
DynamoDbClient.builder()
.httpClient(apacheHttpClient).build();
// Perform work with the s3Client and dynamoDbClient.
// Requests completed: Close all service clients.
s3Client.close();
dynamoDbClient.close();
apacheHttpClient.close(); // Explicitly close apacheHttpClient.
```
## Beispiel für eine Proxykonfiguration
Der folgende Codeausschnitt verwendet den [Proxykonfigurationsgenerator für den Apache HTTP-Client](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ProxyConfiguration.Builder.html).
```
SdkHttpClient apacheHttpClient = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.endpoint(URI.create("http://example.com:1234"))
.username("username")
.password("password")
.addNonProxyHost("localhost")
.addNonProxyHost("host.example.com")
.build())
.build();
```
Die entsprechenden Java-Systemeigenschaften für die Proxykonfiguration werden im folgenden Befehlszeilenausschnitt angezeigt.
```
$ java -Dhttp.proxyHost=example.com -Dhttp.proxyPort=1234 -Dhttp.proxyUser=username \
-Dhttp.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
Das äquivalente Setup, das Umgebungsvariablen verwendet, ist:
```
// Set the following environment variables.
// $ export HTTP_PROXY="http://username:password@example.com:1234"
// $ export NO_PROXY="localhost|host.example.com"
// Set the 'useSystemPropertyValues' to false on the proxy configuration.
SdkHttpClient apacheHttpClient = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.useSystemPropertyValues(Boolean.FALSE)
.build())
.build();
// Run the application.
// $ java -cp ... App
```
**Anmerkung**
Der Apache HTTP-Client unterstützt derzeit keine HTTPS-Proxy-Systemeigenschaften oder die Umgebungsvariable HTTPS\$1PROXY.
# Den URLConnection basierten HTTP-Client konfigurieren
Der AWS SDK for Java 2.x bietet im Vergleich zum Standard einen leichteren `[UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html)` HTTP-Client. `ApacheHttpClient` Der `UrlConnectionHttpClient` basiert auf dem von Java. `[URLConnection](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/net/URLConnection.html)`
Der `UrlConnectionHttpClient` wird schneller geladen als der Apache-basierte HTTP-Client, hat aber weniger Funktionen. Da er schneller geladen wird, ist er eine [gute Lösung](lambda-optimize-starttime.md) für Java-Funktionen. AWS Lambda
Das `UrlConnectionHttpClient` hat mehrere [konfigurierbare Optionen](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.Builder.html), auf die Sie zugreifen können.
**Anmerkung**
Der `UrlConnectionHttpClient` unterstützt die HTTP-PATCH-Methode nicht.
Für eine Handvoll AWS API-Operationen sind PATCH-Anfragen erforderlich. Diese Operationsnamen beginnen normalerweise mit`Update*`. Im Folgenden finden Sie einige Beispiele.
[Verschiedene `Update*` Operationen](https://docs.aws.amazon.com/securityhub/1.0/APIReference/API_Operations.html) in der AWS Security Hub CSPM API und auch die [BatchUpdateFindings](https://docs.aws.amazon.com/securityhub/1.0/APIReference/API_BatchUpdateFindings.html)Operation
Alle [`Update*`API-Operationen](https://docs.aws.amazon.com/apigateway/latest/api/API_UpdateAccount.html) von Amazon API Gateway
Wenn Sie die verwenden könnten`UrlConnectionHttpClient`, lesen Sie zunächst in der API-Referenz nach AWS-Service , die Sie verwenden. Prüfen Sie, ob die Operationen, die Sie benötigen, den PATCH-Vorgang verwenden.
## Greifen Sie auf `UrlConnectionHttpClient`
Um das zu konfigurieren und zu verwenden`UrlConnectionHttpClient`, deklarieren Sie eine Abhängigkeit vom `url-connection-client` Maven-Artefakt in Ihrer `pom.xml` Datei.
Im Gegensatz zu `UrlConnectionHttpClient` wird das nicht automatisch zu Ihrem Projekt hinzugefügt, daher muss es von use ausdrücklich deklariert werden. `ApacheHttpClient`
Das folgende Beispiel einer `pom.xml` Datei zeigt die Abhängigkeiten, die für die Verwendung und Konfiguration des HTTP-Clients erforderlich sind.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
url-connection-client
```
## Verwenden und konfigurieren Sie `UrlConnectionHttpClient`
Sie können eine Instanz von `UrlConnectionHttpClient` konfigurieren und gleichzeitig einen Service Client erstellen, oder Sie können eine einzelne Instanz so konfigurieren, dass sie von mehreren Service Clients gemeinsam genutzt wird.
Bei beiden Ansätzen verwenden Sie den [UrlConnectionHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.Builder.html), um die Eigenschaften für den URLConnection basierten HTTP-Client zu konfigurieren.
### Bewährtes Verfahren: Dedizieren Sie eine `UrlConnectionHttpClient` Instanz einem Service-Client
Wenn Sie eine Instanz von konfigurieren müssen, empfehlen wir Ihnen`UrlConnectionHttpClient`, die dedizierte `UrlConnectionHttpClient` Instanz zu erstellen. Sie können dies tun, indem Sie die `httpClientBuilder` Methode des Builders des Service-Clients verwenden. Auf diese Weise wird der Lebenszyklus des HTTP-Clients vom SDK verwaltet, wodurch potenzielle Speicherlecks vermieden werden, wenn die `UrlConnectionHttpClient` Instanz nicht geschlossen wird, wenn sie nicht mehr benötigt wird.
Im folgenden Beispiel wird eine `S3Client` eingebettete Instanz von `UrlConnectionHttpClient` with `socketTimeout` and `proxyConfiguration` values erstellt und konfiguriert. Die `proxyConfiguration` Methode verwendet einen Java-Lambda-Ausdruck vom Typ. ` Consumer<[ProxyConfiguration.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/ProxyConfiguration.Builder.html)>`
**Importe**
```
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.urlconnection.UrlConnectionHttpClient;
import java.net.URI;
import java.time.Duration;
```
**Code**
```
// Singleton: Use the s3Client for all requests.
S3Client s3Client =
S3Client.builder()
.httpClientBuilder(UrlConnectionHttpClient.builder()
.socketTimeout(Duration.ofMinutes(5))
.proxyConfiguration(proxy -> proxy.endpoint(URI.create("http://proxy.mydomain.net:8888"))))
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.build();
// Perform work with the s3Client.
s3Client.close(); // Requests completed: Close the s3client.
```
### Alternativer Ansatz: Eine `UrlConnectionHttpClient` Instanz teilen
Um den Ressourcen- und Speicherverbrauch für Ihre Anwendung zu senken, können Sie eine konfigurieren `UrlConnectionHttpClient` und sie von mehreren Service-Clients gemeinsam nutzen. Der HTTP-Verbindungspool wird gemeinsam genutzt, was die Ressourcennutzung senkt.
**Anmerkung**
Wenn eine `UrlConnectionHttpClient` Instanz gemeinsam genutzt wird, müssen Sie sie schließen, wenn sie bereit ist, gelöscht zu werden. Das SDK schließt die Instanz nicht, wenn der Service-Client geschlossen wird.
Im folgenden Beispiel wird ein URLConnection basierter HTTP-Client konfiguriert, der von zwei Dienstclients verwendet wird. Die konfigurierte `UrlConnectionHttpClient` Instanz wird an die `httpClient` Methode jedes Builders übergeben. Wenn die Service-Clients und der HTTP-Client nicht mehr benötigt werden, werden sie durch den Code explizit geschlossen. Der Code schließt den HTTP-Client zuletzt.
**Importe**
```
import software.amazon.awssdk.auth.credentials.EnvironmentVariableCredentialsProvider;
import software.amazon.awssdk.awscore.defaultsmode.DefaultsMode;
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.urlconnection.ProxyConfiguration;
import software.amazon.awssdk.http.urlconnection.UrlConnectionHttpClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.net.URI;
import java.time.Duration;
```
**Code**
```
SdkHttpClient urlHttpClient = UrlConnectionHttpClient.create();
// Singletons: Use the s3Client and dynamoDbClient for all requests.
S3Client s3Client =
S3Client.builder()
.httpClient(urlHttpClient)
.defaultsMode(DefaultsMode.IN_REGION)
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.build();
DynamoDbClient dynamoDbClient =
DynamoDbClient.builder()
.httpClient(urlHttpClient)
.defaultsMode(DefaultsMode.IN_REGION)
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.build();
// Perform work with the s3Client and dynamoDbClient.
// Requests completed: Close all service clients.
s3Client.close();
dynamoDbClient.close();
urlHttpClient.close();
```
#### Verwenden Sie `URLConnectionHttpClient` und `ApacheHttpClient` zusammen
Wenn Sie das `UrlConnectionHttpClient` in Ihrer Anwendung verwenden, müssen Sie jedem Service-Client entweder eine `URLConnectionHttpClient` Instanz oder eine `ApacheHttpClient` Instanz mithilfe der `httpClientBuilder` Methode des Service Client Builders zur Verfügung stellen.
Eine Ausnahme tritt auf, wenn Ihr Programm mehrere Service-Clients verwendet und beide der folgenden Bedingungen zutreffen:
+ Ein Dienstclient ist für die Verwendung einer `UrlConnectionHttpClient` Instanz konfiguriert
+ Ein anderer Dienstclient verwendet den Standard, `ApacheHttpClient` ohne ihn explizit mit den `httpClientBuilder()` Methoden `httpClient()` oder zu erstellen
Die Ausnahme besagt, dass im Klassenpfad mehrere HTTP-Implementierungen gefunden wurden.
Der folgende Beispielcodeausschnitt führt zu einer Ausnahme.
```
// The dynamoDbClient uses the UrlConnectionHttpClient
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.httpClient(UrlConnectionHttpClient.create())
.build();
// The s3Client below uses the ApacheHttpClient at runtime, without specifying it.
// An SdkClientException is thrown with the message that multiple HTTP implementations were found on the classpath.
S3Client s3Client = S3Client.create();
// Perform work with the s3Client and dynamoDbClient.
dynamoDbClient.close();
s3Client.close();
```
Vermeiden Sie die Ausnahme, indem Sie das explizit `S3Client` mit einem konfigurieren. `ApacheHttpClient`
```
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.httpClient(UrlConnectionHttpClient.create())
.build();
S3Client s3Client = S3Client.builder()
.httpClient(ApacheHttpClient.create()) // Explicitly build the ApacheHttpClient.
.build();
// Perform work with the s3Client and dynamoDbClient.
dynamoDbClient.close();
s3Client.close();
```
**Anmerkung**
Um das explizit zu erstellen`ApacheHttpClient`, müssen Sie Ihrer Maven-Projektdatei [eine Abhängigkeit vom `apache-client` Artefakt hinzufügen](http-configuration-apache.md#http-apache-dependency).
## Beispiel für eine Proxy-Konfiguration
Der folgende Codeausschnitt verwendet den [Proxykonfigurationsgenerator für den URL-Verbindungs-HTTP-Client](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/ProxyConfiguration.Builder.html).
```
SdkHttpClient urlHttpClient = UrlConnectionHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.endpoint(URI.create("http://example.com:1234"))
.username("username")
.password("password")
.addNonProxyHost("localhost")
.addNonProxyHost("host.example.com")
.build())
.build();
```
Die entsprechenden Java-Systemeigenschaften für die Proxykonfiguration werden im folgenden Befehlszeilenausschnitt angezeigt.
```
$ java -Dhttp.proxyHost=example.com -Dhttp.proxyPort=1234 -Dhttp.proxyUser=username \
-Dhttp.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
Das äquivalente Setup, das Umgebungsvariablen verwendet, ist:
```
// Set the following environment variables.
// $ export HTTP_PROXY="http://username:password@example.com:1234"
// $ export NO_PROXY="localhost|host.example.com"
// Set the 'useSystemPropertyValues' to false on the proxy configuration.
SdkHttpClient apacheHttpClient = UrlConnectionHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.useSystemPropertyValues(Boolean.FALSE)
.build())
.build();
// Run the application.
// $ java -cp ... App
```
**Anmerkung**
Der URLConnection basierte HTTP-Client unterstützt derzeit weder die HTTPS-Proxy-Systemeigenschaften noch die Umgebungsvariable HTTPS\$1PROXY.
# Den Netty-basierten HTTP-Client konfigurieren
Der Standard-HTTP-Client für asynchrone Operationen in der AWS SDK for Java 2.x ist der [NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html)Netty-basierte. [Der Netty-basierte Client basiert auf dem asynchronen, ereignisgesteuerten Netzwerk-Framework des Netty-Projekts.](https://netty.io/)
[Als alternativen HTTP-Client können Sie den neuen CRT-basierten HTTP-Client verwenden.AWS](http-configuration-crt.md) In diesem Thema erfahren Sie, wie Sie den konfigurieren. `NettyNioAsyncHttpClient`
## Greifen Sie auf `NettyNioAsyncHttpClient`
In den meisten Situationen verwenden Sie die `NettyNioAsyncHttpClient` ohne explizite Konfiguration in asynchronen Programmen. Sie deklarieren Ihre asynchronen Service-Clients und das SDK konfiguriert sie `NettyNioAsyncHttpClient` mit Standardwerten für Sie.
Wenn Sie den explizit konfigurieren `NettyNioAsyncHttpClient` oder ihn mit mehreren Service-Clients verwenden möchten, müssen Sie ihn für die Konfiguration verfügbar machen.
### Keine Konfiguration erforderlich
Wenn Sie in Maven eine Abhängigkeit von einem Service-Client deklarieren, fügt das SDK eine *Laufzeitabhängigkeit* von dem `netty-nio-client` Artefakt hinzu. Dadurch steht die `NettyNioAsyncHttpClient` Klasse Ihrem Code zur Laufzeit zur Verfügung, aber nicht zur Kompilierzeit. Wenn Sie den Netty-basierten HTTP-Client nicht konfigurieren, müssen Sie dafür keine Abhängigkeit angeben.
Im folgenden XML-Snippet einer `pom.xml` Maven-Datei bezieht die mit `dynamodb-enhanced` transitiv deklarierte Abhängigkeit den Netty-basierten HTTP-Client mit ein. Sie müssen keine spezielle Abhängigkeit dafür deklarieren.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
dynamodb-enhanced
```
Mit diesen Abhängigkeiten können Sie keine Änderungen an der HTTP-Konfiguration vornehmen, da sich die `NettyNioAsyncHttpClient` Bibliothek nur im Laufzeit-Klassenpfad befindet.
### Konfiguration erforderlich
*Um das zu konfigurieren`NettyNioAsyncHttpClient`, müssen Sie bei der Kompilierung eine Abhängigkeit vom `netty-nio-client` Artefakt hinzufügen.*
Sehen Sie sich das folgende Beispiel für eine `pom.xml` Maven-Datei an, um die zu konfigurieren. `NettyNioAsyncHttpClient`
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
dynamodb-enhanced
software.amazon.awssdk
netty-nio-client
```
## Verwenden und konfigurieren Sie den `NettyNioAsyncHttpClient`
Sie können eine Instanz von `NettyNioAsyncHttpClient` konfigurieren und gleichzeitig einen Service Client erstellen, oder Sie können eine einzelne Instanz so konfigurieren, dass sie von mehreren Service Clients gemeinsam genutzt wird.
Bei beiden Ansätzen verwenden Sie den [NettyNioAsyncHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.Builder.html), um die Eigenschaften für die Netty-basierte HTTP-Client-Instanz zu konfigurieren.
### Bewährtes Verfahren: Dedizieren Sie eine `NettyNioAsyncHttpClient` Instanz einem Service-Client
Wenn Sie eine Instanz von konfigurieren müssen, empfehlen wir Ihnen`NettyNioAsyncHttpClient`, eine dedizierte `NettyNioAsyncHttpClient` Instanz zu erstellen. Sie können dies tun, indem Sie die `httpClientBuilder` Methode des Builders des Service-Clients verwenden. Auf diese Weise wird der Lebenszyklus des HTTP-Clients vom SDK verwaltet, wodurch potenzielle Speicherlecks vermieden werden, wenn die `NettyNioAsyncHttpClient` Instanz nicht geschlossen wird, wenn sie nicht mehr benötigt wird.
Im folgenden Beispiel wird eine `DynamoDbAsyncClient` Instanz erstellt, die von einer `DynamoDbEnhancedAsyncClient` Instanz verwendet wird. Die `DynamoDbAsyncClient` Instanz enthält die `NettyNioAsyncHttpClient` Instanz mit den `maxConcurrency` Werten `connectionTimeout` und. Die HTTP-Instanz wird mit der `httpClientBuilder` Methode von erstellt`DynamoDbAsyncClient.Builder`.
**Importe**
```
import software.amazon.awssdk.auth.credentials.EnvironmentVariableCredentialsProvider;
import software.amazon.awssdk.awscore.defaultsmode.DefaultsMode;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedAsyncClient;
import software.amazon.awssdk.enhanced.dynamodb.extensions.AutoGeneratedTimestampRecordExtension;
import software.amazon.awssdk.http.nio.netty.NettyNioAsyncHttpClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;
import java.time.Duration;
```
**Code**
```
// DynamoDbAsyncClient is the lower-level client used by the enhanced client.
DynamoDbAsyncClient dynamoDbAsyncClient =
DynamoDbAsyncClient
.builder()
.httpClientBuilder(NettyNioAsyncHttpClient.builder()
.connectionTimeout(Duration.ofMillis(5_000))
.maxConcurrency(100)
.tlsNegotiationTimeout(Duration.ofMillis(3_500)))
.defaultsMode(DefaultsMode.IN_REGION)
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.build();
// Singleton: Use dynamoDbAsyncClient and enhancedClient for all requests.
DynamoDbEnhancedAsyncClient enhancedClient =
DynamoDbEnhancedAsyncClient
.builder()
.dynamoDbClient(dynamoDbAsyncClient)
.extensions(AutoGeneratedTimestampRecordExtension.create())
.build();
// Perform work with the dynamoDbAsyncClient and enhancedClient.
// Requests completed: Close dynamoDbAsyncClient.
dynamoDbAsyncClient.close();
```
### Alternativer Ansatz: Eine `NettyNioAsyncHttpClient` Instanz teilen
Um den Ressourcen- und Speicherverbrauch für Ihre Anwendung zu senken, können Sie eine konfigurieren `NettyNioAsyncHttpClient` und sie von mehreren Service-Clients gemeinsam nutzen. Der HTTP-Verbindungspool wird gemeinsam genutzt, was die Ressourcennutzung senkt.
**Anmerkung**
Wenn eine `NettyNioAsyncHttpClient` Instanz gemeinsam genutzt wird, müssen Sie sie schließen, wenn sie bereit ist, gelöscht zu werden. Das SDK schließt die Instanz nicht, wenn der Service-Client geschlossen wird.
Im folgenden Beispiel wird ein Netty-basierter HTTP-Client konfiguriert, der von zwei Dienstclients verwendet wird. Die konfigurierte `NettyNioAsyncHttpClient` Instanz wird an die `httpClient` Methode jedes Builders übergeben. Wenn die Service-Clients und der HTTP-Client nicht mehr benötigt werden, werden sie durch den Code explizit geschlossen. Der Code schließt den HTTP-Client zuletzt.
**Importe**
```
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.s3.S3Client;
```
**Code**
```
// Create a NettyNioAsyncHttpClient shared instance.
SdkAsyncHttpClient nettyHttpClient = NettyNioAsyncHttpClient.builder().maxConcurrency(100).build();
// Singletons: Use the s3AsyncClient, dbAsyncClient, and enhancedAsyncClient for all requests.
S3AsyncClient s3AsyncClient =
S3AsyncClient.builder()
.httpClient(nettyHttpClient)
.build();
DynamoDbAsyncClient dbAsyncClient =
DynamoDbAsyncClient.builder()
.httpClient(nettyHttpClient)
.defaultsMode(DefaultsMode.IN_REGION)
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.build();
DynamoDbEnhancedAsyncClient enhancedAsyncClient =
DynamoDbEnhancedAsyncClient.builder()
.dynamoDbClient(dbAsyncClient)
.extensions(AutoGeneratedTimestampRecordExtension.create())
.build();
// Perform work with s3AsyncClient, dbAsyncClient, and enhancedAsyncClient.
// Requests completed: Close all service clients.
s3AsyncClient.close();
dbAsyncClient.close()
nettyHttpClient.close(); // Explicitly close nettyHttpClient.
```
## Konfigurieren Sie die ALPN-Protokollaushandlung
ALPN (Application-Layer Protocol Negotiation) ist eine TLS-Erweiterung, mit der die Anwendungsebene aushandeln kann, welches Protokoll über eine sichere Verbindung ausgeführt werden soll, sodass zusätzliche Roundtrips vermieden werden und eine bessere Leistung erzielt wird.
Um dem Netty-basierten HTTP-Client die Verwendung von ALPN zu ermöglichen, rufen Sie die Builder-Methoden auf, wie im folgenden Codeausschnitt gezeigt:
```
import software.amazon.awssdk.http.Protocol;
import software.amazon.awssdk.http.ProtocolNegotiation;
import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
import software.amazon.awssdk.http.nio.netty.NettyNioAsyncHttpClient;
import software.amazon.awssdk.services.transcribestreaming.TranscribeStreamingAsyncClient;
// Configure the Netty-based HTTP client to use the ALPN protocol.
SdkAsyncHttpClient nettyClient = NettyNioAsyncHttpClient.builder()
.protocol(Protocol.HTTP2)
.protocolNegotiation(ProtocolNegotiation.ALPN)
.build();
// Use the Netty-based HTTP client with a service client.
TranscribeStreamingAsyncClient transcribeClient = TranscribeStreamingAsyncClient.builder()
.httpClient(nettyClient)
.build();
```
Die ALPN-Protokollaushandlung funktioniert derzeit nur mit dem HTTP/2-Protokoll, wie im vorherigen Codeausschnitt gezeigt.
## Beispiel für eine Proxykonfiguration
Der folgende Codeausschnitt verwendet den [Proxykonfigurationsgenerator für den Netty](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/ProxyConfiguration.Builder.html) HTTP-Client.
```
SdkAsyncHttpClient nettyHttpClient = NettyNioAsyncHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.scheme("https")
.host("myproxy")
.port(1234)
.username("username")
.password("password")
.nonProxyHosts(Set.of("localhost", "host.example.com"))
.build())
.build();
```
Die entsprechenden Java-Systemeigenschaften für die Proxykonfiguration werden im folgenden Befehlszeilenausschnitt angezeigt.
```
$ java -Dhttps.proxyHost=myproxy -Dhttps.proxyPort=1234 -Dhttps.proxyUser=username \
-Dhttps.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
**Wichtig**
Um eine der HTTPS-Proxy-Systemeigenschaften verwenden zu können, muss die `scheme` Eigenschaft im Code auf gesetzt werden. `https` Wenn die Schemaeigenschaft nicht im Code festgelegt ist, verwendet das Schema standardmäßig HTTP und das SDK sucht nur nach `http.*` Systemeigenschaften.
Das äquivalente Setup, das Umgebungsvariablen verwendet, ist:
```
// Set the following environment variables.
// $ export HTTPS_PROXY="https://username:password@myproxy:1234"
// $ export NO_PROXY="localhost|host.example.com"
// Set the 'useSystemPropertyValues' to false on the proxy configuration.
SdkAsyncHttpClient nettyHttpClient = NettyNioAsyncHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.useSystemPropertyValues(Boolean.FALSE)
.build())
.build();
// Run the application.
// $ java -cp ... App
```
# AWS CRT-basierte HTTP-Clients konfigurieren
Zu den AWS CRT-basierten HTTP-Clients gehören synchrone und asynchrone [AwsCrtHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.html)Clients. [AwsCrtAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.html) Die AWS CRT-basierten HTTP-Clients bieten die folgenden Vorteile für HTTP-Clients:
+ Schnellere SDK-Startup-Zeiten
+ Geringeren Speicherbedarf
+ Reduzierte Latenzzeit
+ Verbindungsgesundheitsverwaltung
+ DNS-Load Balancing
**AWS CRT-basierte Komponenten im SDK**
Die in diesem Thema beschriebenen AWS CRT-basierten *HTTP-Clients* und der AWS CRT-basierte *S3-Client* sind unterschiedliche Komponenten im SDK.
Die synchronen und asynchronen **AWS CRT-basierten HTTP-Clients sind SDK-HTTP-Client-Schnittstellen** für Implementierungen und werden für die allgemeine HTTP-Kommunikation verwendet. Sie sind Alternativen zu den anderen synchronen oder asynchronen HTTP-Clients im SDK mit zusätzlichen Vorteilen.
Der **[AWS CRT-basierte S3-Client](crt-based-s3-client.md)** ist eine Implementierung der [AsyncClientS3-Schnittstelle](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html) und wird für die Arbeit mit dem Amazon S3 S3-Service verwendet. Es ist eine Alternative zur Java-basierten Implementierung der `S3AsyncClient` Schnittstelle und bietet mehrere Vorteile.
Obwohl beide Komponenten Bibliotheken aus der [AWS Common Runtime](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html) verwenden, verwenden die AWS CRT-basierten HTTP-Clients die [aws-c-s3-Bibliothek](https://github.com/awslabs/aws-c-s3) nicht und unterstützen auch nicht die API-Funktionen für [mehrteilige Uploads von S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html). Der AWS CRT-basierte S3-Client wurde dagegen speziell für die Unterstützung der API-Funktionen für mehrteilige S3-Uploads entwickelt.
## Greifen Sie auf die CRT-basierten HTTP-Clients zu AWS
Bevor Sie die AWS CRT-basierten HTTP-Clients verwenden können, fügen Sie das `aws-crt-client` Artefakt mit einer Mindestversion von 2.22.0 zu den Abhängigkeiten Ihres Projekts hinzu.
Verwenden Sie eine der folgenden Optionen, um Ihre Maven-Datei einzurichten. `pom.xml`
**Anmerkung**
Sie können die *plattformspezifische JAR-Option* verwenden, wenn Sie die Größe der Laufzeitabhängigkeiten verringern müssen, z. B. wenn Ihre Anwendung in einer Funktion ausgeführt wird. AWS Lambda
------
#### [ Uber-jar option ]
Standardmäßig `aws-crt-client` verwendet der ein Uber-Jar mit AWS CRT-Artefakten, das Binärdateien für verschiedene Plattformen enthält, darunter Linux, Windows und macOS.
```
2.29.10*
software.amazon.awssdk
bom
${aws.sdk.version}
pom
import
software.amazon.awssdk
aws-crt-client
```
\$1Ersetzen Sie die rot dargestellte Version durch die Version des Java-SDK, die Sie verwenden möchten. Finden Sie die neuesten Informationen auf [Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).
------
#### [ Platform-specific jar option ]
*Um die Java-Laufzeit auf eine plattformspezifische Version der AWS CRT-Bibliothek zu beschränken, nehmen Sie die folgenden Änderungen an der Uber-JAR-Option vor.*
+ Fügen Sie dem Artefakt `exclusions` des SDK ein Element hinzu. `aws-crt-client` Dieser Ausschluss verhindert, dass das SDK das AWS CRT-Uber-JAR transitiv verwendet.
+ Fügen Sie ein Abhängigkeitselement für die spezifische AWS CRT-Plattformversion hinzu, die Sie benötigen. In den **folgenden Schritten zur Bestimmung der AWS CRT-Artefaktversion** erfahren Sie, wie Sie die richtige Version ermitteln können.
```
2.29.101
software.amazon.awssdk
bom
${aws.sdk.java.version}
pom
import
software.amazon.awssdk
aws-crt-client
software.amazon.awssdk.crt
aws-crt
software.amazon.awssdk.crt
aws-crt
0.31.32
linux-x86_643
```
1 Ersetzen Sie die rot dargestellte Version durch die Version des Java-SDK, die Sie verwenden möchten. Finden Sie die neuesten Informationen auf [Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).
2 Ersetzen Sie die Version`software.amazon.awssdk.crt:aws-crt`, die durch die *Uber-JAR-Option* bereitgestellt würde. Sehen Sie sich die folgenden **Schritte an, um die Version des AWS CRT-Artefakts zu ermitteln**.
3 Ersetzen Sie den `classifier` Wert durch einen Wert für Ihre Plattform. Eine [Liste der verfügbaren Werte finden Sie auf der GitHub ](https://github.com/awslabs/aws-crt-java?tab=readme-ov-file#platform-specific-jars) Seite AWS CRT for Java.
**Schritte zur Bestimmung der Version des AWS CRT-Artefakts**
Verwenden Sie die folgenden Schritte, um die AWS CRT-Artefaktversion zu ermitteln, die mit der Version des SDK for Java kompatibel ist, die Sie verwenden.
1. Richten Sie Ihre `pom.xml` Datei wie in der *Uber-JAR-Option* gezeigt ein. Mit diesem Setup können Sie sehen, welche Version `software.amazon.awssdk.crt:aws-crt` des SDK standardmäßig enthalten ist.
1. Führen Sie im Stammverzeichnis des Projekts (im selben Verzeichnis wie die `pom.xml` Datei) den folgenden Maven-Befehl aus:
```
mvn dependency:tree -Dincludes=software.amazon.awssdk.crt:aws-crt
```
Maven führt möglicherweise andere Aktionen aus, aber am Ende sollten Sie die Konsolenausgabe der `software.amazon.awssdk.crt:aws-crt` Abhängigkeit sehen, die das SDK transitiv verwendet. Der folgende Ausschnitt zeigt eine Beispielausgabe, die auf einer SDK-Version von basiert: `2.29.10`
```
[INFO] org.example:yourProject:jar:1.0-SNAPSHOT
[INFO] \- software.amazon.awssdk:aws-crt-client:jar:2.29.10:compile
[INFO] \- software.amazon.awssdk.crt:aws-crt:jar:0.31.3:compile
```
1. Verwenden Sie die Version, die auf der Konsole für das `software.amazon.awssdk.crt:aws-crt` Artefakt angezeigt wird. In diesem Fall fügen Sie es `0.31.3` zu Ihrer `pom.xml` Datei hinzu.
------
## Verwenden und konfigurieren Sie einen AWS CRT-basierten HTTP-Client
Sie können einen AWS CRT-basierten HTTP-Client zusammen mit der Erstellung eines Service-Clients konfigurieren, oder Sie können eine einzelne Instanz so konfigurieren, dass sie von mehreren Service-Clients gemeinsam genutzt wird.
Bei beiden Ansätzen verwenden Sie einen Builder, um [die Eigenschaften für die AWS CRT-basierte HTTP-Clientinstanz zu konfigurieren](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.Builder.html).
### Bewährtes Verfahren: Dedizieren Sie eine Instanz einem Service-Client
Wenn Sie eine Instanz eines AWS CRT-basierten HTTP-Clients konfigurieren müssen, empfehlen wir, dass Sie die Instanz dedizieren, indem Sie sie zusammen mit dem Service-Client erstellen. Sie können dies tun, indem Sie die `httpClientBuilder` Methode des Builders des Service-Clients verwenden. Auf diese Weise wird der Lebenszyklus des HTTP-Clients vom SDK verwaltet, wodurch potenzielle Speicherlecks vermieden werden, wenn die AWS CRT-basierte HTTP-Client-Instanz nicht geschlossen wird, wenn sie nicht mehr benötigt wird.
Im folgenden Beispiel wird ein S3-Serviceclient erstellt und ein AWS CRT-basierter HTTP-Client mit Werten und konfiguriert. `connectionTimeout` `maxConcurrency`
------
#### [ Synchronous client ]
**Importe**
```
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Code**
```
// Singleton: Use s3Client for all requests.
S3Client s3Client = S3Client.builder()
.httpClientBuilder(AwsCrtHttpClient
.builder()
.connectionTimeout(Duration.ofSeconds(3))
.maxConcurrency(100))
.build();
// Perform work with the s3Client.
// Requests completed: Close the s3Client.
s3Client.close();
```
------
#### [ Asynchronous client ]
**Importe**
```
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import java.time.Duration;
```
**Code**
```
// Singleton: Use s3AsyncClient for all requests.
S3AsyncClient s3AsyncClient = S3AsyncClient.builder()
.httpClientBuilder(AwsCrtAsyncHttpClient
.builder()
.connectionTimeout(Duration.ofSeconds(3))
.maxConcurrency(100))
.build();
// Perform work with the s3AsyncClient.
// Requests completed: Close the s3AsyncClient.
s3AsyncClient.close();
```
------
### Alternativer Ansatz: Eine Instanz teilen
Um die Ressourcen- und Speicherauslastung für Ihre Anwendung gering zu halten, können Sie einen AWS CRT-basierten HTTP-Client konfigurieren und ihn von mehreren Service-Clients gemeinsam nutzen. Der HTTP-Verbindungspool wird gemeinsam genutzt, was die Ressourcennutzung senkt.
**Anmerkung**
Wenn eine AWS CRT-basierte HTTP-Client-Instanz gemeinsam genutzt wird, müssen Sie sie schließen, wenn sie bereit ist, gelöscht zu werden. Das SDK schließt die Instanz nicht, wenn der Service-Client geschlossen wird.
Im folgenden Beispiel wird eine AWS CRT-basierte HTTP-Clientinstanz mit `connectionTimeout` Werten und konfiguriert. `maxConcurrency` Die konfigurierte Instanz wird an die `httpClient` Methode des Builders jedes Service-Clients übergeben. Wenn die Service-Clients und der HTTP-Client nicht mehr benötigt werden, werden sie explizit geschlossen. Der HTTP-Client wird zuletzt geschlossen.
------
#### [ Synchronous client ]
**Importe**
```
import software.amazon.awssdk.auth.credentials.EnvironmentVariableCredentialsProvider;
import software.amazon.awssdk.awscore.defaultsmode.DefaultsMode;
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Code**
```
// Create an AwsCrtHttpClient shared instance.
SdkHttpClient crtHttpClient = AwsCrtHttpClient.builder()
.connectionTimeout(Duration.ofSeconds(3))
.maxConcurrency(100)
.build();
// Singletons: Use the s3Client and dynamoDbClient for all requests.
S3Client s3Client = S3Client.builder()
.httpClient(crtHttpClient)
.credentialsProvider(EnvironmentVariableCredentialsProvider.crea
.defaultsMode(DefaultsMode.IN_REGION)
.region(Region.US_EAST_1)
.build();
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.httpClient(crtHttpClient)
.credentialsProvider(EnvironmentVariableCredentialsProvider.crea
.defaultsMode(DefaultsMode.IN_REGION)
.region(Region.US_EAST_1)
.build();
// Requests completed: Close all service clients.
s3Client.close();
dynamoDbClient.close();
crtHttpClient.close(); // Explicitly close crtHttpClient.
```
------
#### [ Asynchronous client ]
**Importe**
```
import software.amazon.awssdk.auth.credentials.EnvironmentVariableCredentialsProvider;
import software.amazon.awssdk.awscore.defaultsmode.DefaultsMode;
import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import java.time.Duration;
```
**Code**
```
// Create an AwsCrtAsyncHttpClient shared instance.
SdkAsyncHttpClient crtAsyncHttpClient = AwsCrtAsyncHttpClient.builder()
.connectionTimeout(Duration.ofSeconds(3))
.maxConcurrency(100)
.build();
// Singletons: Use the s3AsyncClient and dynamoDbAsyncClient for all requests.
S3AsyncClient s3AsyncClient = S3AsyncClient.builder()
.httpClient(crtAsyncHttpClient)
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.defaultsMode(DefaultsMode.IN_REGION)
.region(Region.US_EAST_1)
.build();
DynamoDbAsyncClient dynamoDbAsyncClient = DynamoDbAsyncClient.builder()
.httpClient(crtAsyncHttpClient)
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.defaultsMode(DefaultsMode.IN_REGION)
.region(Region.US_EAST_1)
.build();
// Requests completed: Close all service clients.
s3AsyncClient.close();
dynamoDbAsyncClient.close();
crtAsyncHttpClient.close(); // Explicitly close crtAsyncHttpClient.
```
------
## Stellen Sie einen AWS CRT-basierten HTTP-Client als Standard ein
Sie können Ihre Maven-Build-Datei so einrichten, dass das SDK einen AWS CRT-basierten HTTP-Client als Standard-HTTP-Client für Service-Clients verwendet.
Dazu fügen Sie jedem Service-Client-Artefakt ein `exclusions` Element mit den standardmäßigen HTTP-Client-Abhängigkeiten hinzu.
Im folgenden `pom.xml` Beispiel verwendet das SDK einen AWS CRT-basierten HTTP-Client für S3-Dienste. Wenn der Service-Client in Ihrem Code ein ist`S3AsyncClient`, verwendet das SDK. `AwsCrtAsyncHttpClient` Wenn der Service-Client ein S3Client ist, verwendet das SDK. `AwsCrtHttpClient` Bei diesem Setup sind der standardmäßige asynchrone HTTP-Client auf Netty-Basis und der standardmäßige asynchrone HTTP-Client auf Apache-Basis nicht verfügbar.
```
VERSION
software.amazon.awssdk
s3
${aws.sdk.version}
software.amazon.awssdk
netty-nio-client
software.amazon.awssdk
apache-client
software.amazon.awssdk
aws-crt-client
```
Den neuesten Wert finden Sie im zentralen Maven-Repository. [https://central.sonatype.com/artifact/software.amazon.awssdk/bom](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)
**Anmerkung**
Wenn mehrere Service-Clients in einer `pom.xml` Datei deklariert sind, benötigen alle das `exclusions` XML-Element.
### Verwenden Sie eine Java-Systemeigenschaft
Um die AWS CRT-basierten HTTP-Clients als Standard-HTTP für Ihre Anwendung zu verwenden, können Sie die Java-Systemeigenschaft `software.amazon.awssdk.http.async.service.impl` auf den Wert von setzen. `software.amazon.awssdk.http.crt.AwsCrtSdkHttpService`
Um den Wert beim Start der Anwendung festzulegen, führen Sie einen Befehl aus, der dem folgenden ähnelt.
```
java app.jar -Dsoftware.amazon.awssdk.http.async.service.impl=\
software.amazon.awssdk.http.crt.AwsCrtSdkHttpService
```
Verwenden Sie den folgenden Codeausschnitt, um die Systemeigenschaft in Ihrem Anwendungscode festzulegen.
```
System.setProperty("software.amazon.awssdk.http.async.service.impl",
"software.amazon.awssdk.http.crt.AwsCrtSdkHttpService");
```
**Anmerkung**
Sie müssen eine Abhängigkeit von dem `aws-crt-client` Artefakt in Ihrer `poml.xml` Datei hinzufügen, wenn Sie eine Systemeigenschaft verwenden, um die Verwendung der AWS CRT-basierten HTTP-Clients zu konfigurieren.
## Erweiterte Konfiguration von CRT-basierten HTTP-Clients AWS
Sie können verschiedene Konfigurationseinstellungen der AWS CRT-basierten HTTP-Clients verwenden, einschließlich der Konfiguration des Verbindungsstatus und der maximalen Leerlaufzeit. Sie können die [verfügbaren Konfigurationsoptionen](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.Builder.html) für überprüfen. `AwsCrtAsyncHttpClient` Sie können dieselben Optionen für den konfigurieren`AwsCrtHttpClient`.
### Konfiguration des Verbindungsstatus
Sie können die Verbindungsintegritätskonfiguration für die AWS CRT-basierten HTTP-Clients konfigurieren, indem Sie die `connectionHealthConfiguration` Methode im HTTP-Client-Builder verwenden.
Im folgenden Beispiel wird ein S3-Dienstclient erstellt, der eine AWS CRT-basierte HTTP-Clientinstanz verwendet, die mit einer Verbindungsintegritätskonfiguration und einer maximalen Leerlaufzeit für Verbindungen konfiguriert ist.
------
#### [ Synchronous client ]
**Importe**
```
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Code**
```
// Singleton: Use the s3Client for all requests.
S3Client s3Client = S3Client.builder()
.httpClientBuilder(AwsCrtHttpClient
.builder()
.connectionHealthConfiguration(builder -> builder
.minimumThroughputInBps(32000L)
.minimumThroughputTimeout(Duration.ofSeconds(3)))
.connectionMaxIdleTime(Duration.ofSeconds(5)))
.build();
// Perform work with s3Client.
// Requests complete: Close the service client.
s3Client.close();
```
------
#### [ Asynchronous client ]
**Importe**
```
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import java.time.Duration;
```
**Code**
```
// Singleton: Use the s3AsyncClient for all requests.
S3AsyncClient s3AsyncClient = S3AsyncClient.builder()
.httpClientBuilder(AwsCrtAsyncHttpClient
.builder()
.connectionHealthConfiguration(builder -> builder
.minimumThroughputInBps(32000L)
.minimumThroughputTimeout(Duration.ofSeconds(3)))
.connectionMaxIdleTime(Duration.ofSeconds(5)))
.build();
// Perform work with s3AsyncClient.
// Requests complete: Close the service client.
s3AsyncClient.close();
```
------
## HTTP/2-Support
Das HTTP/2-Protokoll wird in den AWS CRT-basierten HTTP-Clients noch nicht unterstützt, ist aber für eine future Version geplant.
Wenn Sie in der Zwischenzeit Service-Clients verwenden, die HTTP/2-Unterstützung benötigen, wie z. B. der [KinesisAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/kinesis/KinesisAsyncClient.html)oder der, sollten Sie in Erwägung ziehen [TranscribeStreamingAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/transcribestreaming/TranscribeStreamingAsyncClient.html), stattdessen den zu verwenden. [NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html)
## Beispiel für eine Proxykonfiguration
Der folgende Codeausschnitt zeigt die Verwendung der Einstellung [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/ProxyConfiguration.Builder.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/ProxyConfiguration.Builder.html), die Sie zur Konfiguration der Proxyeinstellungen verwenden, im Code.
------
#### [ Synchronous client ]
**Importe**
```
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.http.crt.ProxyConfiguration;
```
**Code**
```
SdkHttpClient crtHttpClient = AwsCrtHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.scheme("https")
.host("myproxy")
.port(1234)
.username("username")
.password("password")
.nonProxyHosts(Set.of("localhost", "host.example.com"))
.build())
.build();
```
------
#### [ Asynchronous client ]
**Importe**
```
import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.http.crt.ProxyConfiguration;
```
**Code**
```
SdkAsyncHttpClient crtAsyncHttpClient = AwsCrtAsyncHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.scheme("https")
.host("myproxy")
.port(1234)
.username("username")
.password("password")
.nonProxyHosts(Set.of("localhost", "host.example.com"))
.build())
.build();
```
------
Die entsprechenden Java-Systemeigenschaften für die Proxykonfiguration werden im folgenden Befehlszeilenausschnitt angezeigt.
```
$ java -Dhttps.proxyHost=myproxy -Dhttps.proxyPort=1234 -Dhttps.proxyUser=username \
-Dhttps.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
**Wichtig**
Um eine der HTTPS-Proxy-Systemeigenschaften verwenden zu können, muss die `scheme` Eigenschaft im Code auf gesetzt werden. `https` Wenn die Schemaeigenschaft nicht im Code festgelegt ist, verwendet das Schema standardmäßig HTTP und das SDK sucht nur nach `http.*` Systemeigenschaften.
Das äquivalente Setup, das Umgebungsvariablen verwendet, ist:
```
// Set the following environment variables.
// $ export HTTPS_PROXY="https://username:password@myproxy:1234"
// $ export NO_PROXY="localhost|host.example.com"
// Set the 'useSystemPropertyValues' to false on the proxy configuration.
SdkAsyncHttpClient crtAsyncHttpClient = AwsCrtAsyncHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.scheme("https")
.useSystemPropertyValues(Boolean.FALSE)
.build())
.build();
// Run the application.
// $ java -cp ... App
```
# HTTP-Proxys konfigurieren
Sie können HTTP-Proxys konfigurieren, indem Sie Code verwenden, Java-Systemeigenschaften festlegen oder Umgebungsvariablen festlegen.
## Im Code konfigurieren
Sie konfigurieren Proxys im Code mit einem kundenspezifischen `ProxyConfiguration` Builder, wenn Sie den Service-Client erstellen. Der folgende Code zeigt ein Beispiel für eine Proxykonfiguration für einen Apache-basierten HTTP-Client, der von einem Amazon S3-Serviceclient verwendet wird.
```
SdkHttpClient httpClient1 = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.endpoint(URI.create("http://proxy.example.com"))
.username("username")
.password("password")
.addNonProxyHost("localhost")
.build())
.build();
S3Client s3Client = S3Client.builder()
.httpClient(httpClient)
.build();
```
Der Abschnitt für jeden HTTP-Client in diesem Thema zeigt ein Beispiel für eine Proxykonfiguration.
+ [Apache HTTP-Client](http-configuration-apache.md#http-configuration-apache-proxy-conf-ex)
+ [URLConnectionbasierter HTTP-Client](http-configuration-url.md#http-configuration-url-proxy-conf-ex)
+ [Netty-basierter HTTP-Client](http-configuration-netty.md#http-config-netty-proxy-ex)
+ [AWS CRT-basierter HTTP-Client](http-configuration-crt.md#http-config-crt-proxy-ex)
## Konfigurieren Sie HTTP-Proxys mit externen Einstellungen
Auch wenn Sie nicht explizit einen `ProxyConfiguration` Builder im Code verwenden, sucht das SDK nach externen Einstellungen, um eine Standard-Proxykonfiguration zu konfigurieren.
Standardmäßig sucht das SDK zuerst nach JVM-Systemeigenschaften. Wenn auch nur eine Eigenschaft gefunden wird, verwendet das SDK den Wert und alle anderen Systemeigenschaftswerte. Wenn keine Systemeigenschaften verfügbar sind, sucht das SDK nach Proxy-Umgebungsvariablen.
Das SDK kann die folgenden Java-Systemeigenschaften und Umgebungsvariablen verwenden.
**Java-Systemeigenschaften**
| Systemeigenschaft | Description | Unterstützung für HTTP-Clients |
| --- | --- | --- |
| http.ProxyHost | Hostname des HTTP-Proxyservers | Alle |
| http.ProxyPort | Portnummer des HTTP-Proxyservers | Alle |
| http.ProxyUser | Benutzername für die HTTP-Proxyauthentifizierung | Alle |
| http.ProxyPassword | Passwort für die HTTP-Proxyauthentifizierung | Alle |
| http. nonProxyHosts | Liste der Hosts, die unter Umgehung des Proxys direkt erreicht werden sollen. [Diese Liste ist auch gültig, wenn HTTPS verwendet wird](https://docs.oracle.com/javase/8/docs/technotes/guides/net/proxies.html). | Alle |
| https.proxyHost | Hostname des HTTPS-Proxyservers | Netty, CRT |
| HTTPS.Proxy-Port | Portnummer des HTTPS-Proxyservers | Netty, CRT |
| https.proxyBenutzer | Benutzername für die HTTPS-Proxyauthentifizierung | Netty, CRT |
| https.proxyPasswort | Passwort für die HTTPS-Proxyauthentifizierung | Netty, CRT |
**Umgebungsvariablen**
| Umgebungsvariable | Description | HTTP-Client-Unterstützung |
| --- | --- | --- |
| HTTP\$1PROXY 1 | Eine gültige URL mit dem Schema HTTP | Alle |
| HTTPS\$1PROXY 1 | Eine gültige URL mit dem Schema HTTPS | Netty, CRT |
| KEIN PROXY 2 | Liste der Hosts, die unter Umgehung des Proxys direkt erreicht werden sollen. Die Liste gilt sowohl für HTTP als auch für HTTPS. | Alle |
### Schlüssel und Fußnoten anzeigen
**Alle** — Alle vom SDK angebotenen HTTP-Clients—`UrlConnectionHttpClient`,, `ApacheHttpClient``NettyNioAsyncHttpClient`,`AwsCrtAsyncHttpClient`.
**Netty** — Der Netty-basierte HTTP-Client (). `NettyNioAsyncHttpClient`
**CRT** — Die AWS CRT-basierten HTTP-Clients (und). `AwsCrtHttpClient` `AwsCrtAsyncHttpClient`
1 Die abgefragte Umgebungsvariable, ob `HTTP_PROXY` oder`HTTPS_PROXY`, hängt von der Schemaeinstellung im Client ab. `ProxyConfiguration` Das Standardschema ist HTTP. Der folgende Ausschnitt zeigt, wie Sie das Schema auf HTTPS ändern, das für die Auflösung von Umgebungsvariablen verwendet wird.
```
SdkHttpClient httpClient = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.scheme("https")
.build())
.build();
```
2 Die `NO_PROXY` Umgebungsvariable unterstützt eine Mischung aus „\$1“ und „,“ -Trennzeichen zwischen Hostnamen. Hostnamen können den Platzhalter „\$1“ enthalten.
## Verwenden Sie eine Kombination von Einstellungen
Sie können eine Kombination von HTTP-Proxyeinstellungen in Code, Systemeigenschaften und Umgebungsvariablen verwenden.
**Example — Konfiguration, die durch eine Systemeigenschaft und durch Code bereitgestellt wird**
```
// Command line with the proxy password set as a system property.
$ java -Dhttp.proxyPassword=SYS_PROP_password -cp ... App
// Since the 'useSystemPropertyValues' setting is 'true' (the default), the SDK will supplement
// the proxy configuration in code with the 'http.proxyPassword' value from the system property.
SdkHttpClient apacheHttpClient = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.endpoint(URI.create("http://localhost:1234"))
.username("username")
.build())
.build();
// Use the apache HTTP client with proxy configuration.
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.httpClient(apacheHttpClient)
.build();
```
Das SDK löst die folgenden Proxyeinstellungen auf.
```
Host = localhost
Port = 1234
Password = SYS_PROP_password
UserName = username
Non ProxyHost = null
```
**Example — Sowohl Systemeigenschaften als auch Umgebungsvariablen sind verfügbar**
Der `ProxyConfiguration` Builder jedes HTTP-Clients bietet Einstellungen mit dem Namen `useSystemPropertyValues` und`useEnvironmentVariablesValues`. Standardmäßig sind beide Einstellungen`true`. Wann `true` verwendet das SDK automatisch Werte aus Systemeigenschaften oder Umgebungsvariablen für Optionen, die nicht vom `ProxyConfiguration` Builder bereitgestellt werden.
Systemeigenschaften haben Vorrang vor Umgebungsvariablen. Wenn eine HTTP-Proxy-Systemeigenschaft gefunden wird, ruft das SDK ***alle*** Werte aus den Systemeigenschaften und keine aus Umgebungsvariablen ab. Wenn Sie Umgebungsvariablen Vorrang vor Systemeigenschaften einräumen möchten, legen Sie den Wert auf fest`useSystemPropertyValues`. `false`
Für dieses Beispiel sind die folgenden Einstellungen zur Laufzeit verfügbar:
```
// System properties
http.proxyHost=SYS_PROP_HOST.com
http.proxyPort=2222
http.password=SYS_PROP_PASSWORD
http.user=SYS_PROP_USER
// Environment variables
HTTP_PROXY="http://EnvironmentUser:EnvironmentPassword@ENV_VAR_HOST:3333"
NO_PROXY="environmentnonproxy.host,environmentnonproxy2.host:1234"
```
Der Service-Client wird mit einer der folgenden Anweisungen erstellt. Keine der Anweisungen legt explizit eine Proxyeinstellung fest.
```
DynamoDbClient client = DynamoDbClient.create();
DynamoDbClient client = DynamoDbClient.builder().build();
DynamoDbClient client = DynamoDbClient.builder()
.httpClient(ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.build())
.build())
.build();
```
Die folgenden Proxyeinstellungen werden vom SDK aufgelöst:
```
Host = SYS_PROP_HOST.com
Port = 2222
Password = SYS_PROP_PASSWORD
UserName = SYS_PROP_USER
Non ProxyHost = null
```
Da der Service Client über Standard-Proxyeinstellungen verfügt, sucht das SDK nach Systemeigenschaften und dann nach Umgebungsvariablen. Da Einstellungen für Systemeigenschaften Vorrang vor Umgebungsvariablen haben, verwendet das SDK nur Systemeigenschaften.
Wenn die Verwendung von Systemeigenschaften `false` wie im folgenden Code gezeigt geändert wird, löst das SDK nur die Umgebungsvariablen auf.
```
DynamoDbClient client = DynamoDbClient.builder()
.httpClient(ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.useSystemPropertyValues(Boolean.FALSE)
.build())
.build())
.build();
```
Die mithilfe von HTTP aufgelösten Proxyeinstellungen sind:
```
Host = ENV_VAR_HOST
Port = 3333
Password = EnvironmentPassword
UserName = EnvironmentUser
Non ProxyHost = environmentnonproxy.host, environmentnonproxy2.host:1234
```
# Konfigurieren Sie den Apache 5.x-basierten HTTP-Client
## Greifen Sie auf den Apache5 zu HttpClient
Um das verwenden zu können, müssen `Apache5HttpClient` Sie eine Abhängigkeit von Ihren Service-Clients hinzufügen **apache5-client** und diese explizit konfigurieren`Apache5HttpClient`.
```
software.amazon.awssdk
bom
2.41.0*
pom
import
software.amazon.awssdk
s3
software.amazon.awssdk
apache5-client
```
\$1Ersetzen Sie die rot dargestellte Version durch die Version des Java-SDK, die Sie verwenden möchten. Finden Sie die neuesten Informationen auf [Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).
### Verwenden und konfigurieren Sie den `Apache5HttpClient`
Sie können eine Instanz von `Apache5HttpClient` konfigurieren und gleichzeitig einen Service Client erstellen, oder Sie können eine einzelne Instanz so konfigurieren, dass sie von mehreren Service Clients gemeinsam genutzt wird.
Bei beiden Ansätzen verwenden Sie den [Apache5 HttpClient .Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache5/Apache5HttpClient.Builder.html), um die Eigenschaften für den Apache 5-basierten HTTP-Client zu konfigurieren.
#### Bewährtes Verfahren: Dedizieren Sie eine Apache5-Instanz einem Service-Client HttpClient
Wenn Sie eine Instanz von konfigurieren müssen, empfehlen wir Ihnen`Apache5HttpClient`, die dedizierte Instanz zu erstellen. `Apache5HttpClient` Sie können dies tun, indem Sie die httpClientBuilder Methode des Builders des Service-Clients verwenden. Auf diese Weise wird der Lebenszyklus des HTTP-Clients vom SDK verwaltet, wodurch potenzielle Speicherlecks vermieden werden, wenn die `Apache5HttpClient` Instanz nicht geschlossen wird, wenn sie nicht mehr benötigt wird.
Im folgenden Beispiel wird ein S3Client erstellt und die eingebettete Instanz von `Apache5HttpClient` mit den Werten MaxConnections und ConnectionTimeout konfiguriert. Die HTTP-Instanz wird mit der Methode von erstellt. `httpClientBuilder` `S3Client.Builder`
**Importe**
```
import software.amazon.awssdk.http.apache5.Apache5HttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Code**
```
S3Client s3Client = S3Client // Singleton: Use the s3Client for all requests.
.builder()
.httpClientBuilder(Apache5HttpClient.builder()
.maxConnections(100)
.connectionTimeout(Duration.ofSeconds(5))
)
.build();
// Perform work with the s3Client.
s3Client.close(); // Requests completed: Close all service clients.
```
#### Alternativer Ansatz: Eine `Apache5HttpClient` Instanz teilen
Um den Ressourcen- und Speicherverbrauch für Ihre Anwendung zu senken, können Sie eine konfigurieren `Apache5HttpClient` und sie von mehreren Service-Clients gemeinsam nutzen. Der HTTP-Verbindungspool wird gemeinsam genutzt, was die Ressourcennutzung senkt.
**Anmerkung**
Wenn eine `Apache5HttpClient` Instanz gemeinsam genutzt wird, müssen Sie sie schließen, wenn sie bereit ist, gelöscht zu werden. Das SDK schließt die Instanz nicht, wenn der Service-Client geschlossen wird.
Im folgenden Beispiel wird ein Apache-basierter HTTP-Client konfiguriert, der von zwei Service-Clients verwendet wird. Die konfigurierte `ApacheHttpClient` Instanz wird an die HttpClient-Methode jedes Builders übergeben. Wenn die Service-Clients und der HTTP-Client nicht mehr benötigt werden, werden sie durch den Code explizit geschlossen. Der Code schließt den HTTP-Client zuletzt.
**Importe**
```
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.apache5.Apache5HttpClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.s3.S3Client;
```
**Code**
```
SdkHttpClient apache5HttpClient = Apache5HttpClient.builder()
.maxConnections(100).build();
// Singletons: Use the s3Client and dynamoDbClient for all requests.
S3Client s3Client =
S3Client.builder()
.httpClient(apache5HttpClient).build();
DynamoDbClient dynamoDbClient =
DynamoDbClient.builder()
.httpClient(apache5HttpClient).build();
// Perform work with the s3Client and dynamoDbClient.
// Requests completed: Close all service clients.
s3Client.close();
dynamoDbClient.close();
apache5HttpClient.close(); // Explicitly close apache5HttpClient.
```