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.

# Den Netty-basierten HTTP-Client konfigurieren
<a name="http-configuration-netty"></a>

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`
<a name="http-config-netty-access"></a>

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
<a name="http-config-netty-no-config"></a>

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 `<artifactId>dynamodb-enhanced</artifactId>` transitiv deklarierte Abhängigkeit den Netty-basierten HTTP-Client mit ein. Sie müssen keine spezielle Abhängigkeit dafür deklarieren.

```
<dependencyManagement>
   <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>bom</artifactId>
            <version>2.27.21</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
    <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>dynamodb-enhanced</artifactId>
    </dependency>
</dependencies>
```

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
<a name="http-config-netty-yes-config"></a>

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

```
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>software.amazon.awssdk</groupId>
                <artifactId>bom</artifactId>
                <version>2.27.21</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>dynamodb-enhanced</artifactId>
        </dependency>
        <!-- By adding the netty-nio-client dependency, NettyNioAsyncHttpClient will be 
             added to the compile classpath so you can configure it. -->
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>netty-nio-client</artifactId>
        </dependency>
    </dependencies>
```

## Verwenden und konfigurieren Sie den `NettyNioAsyncHttpClient`
<a name="http-netty-config"></a>

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
<a name="http-config-netty-one-client"></a>

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
<a name="http-config-netty-multi-clients"></a>

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
<a name="http-netty-config-alpn"></a>

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
<a name="http-config-netty-proxy-ex"></a>

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