Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Konfigurasikan klien HTTP berbasis Netty
<a name="http-configuration-netty"></a>

Klien HTTP default untuk operasi asinkron dalam AWS SDK for Java 2.x adalah berbasis Netty. [NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html) [Klien berbasis Netty didasarkan pada kerangka kerja jaringan berbasis peristiwa asinkron dari proyek Netty.](https://netty.io/)

Sebagai klien HTTP alternatif, Anda dapat menggunakan klien [HTTP AWS berbasis CRT](http-configuration-crt.md) baru. Topik ini menunjukkan kepada Anda cara mengkonfigurasi file`NettyNioAsyncHttpClient`.

## Akses `NettyNioAsyncHttpClient`
<a name="http-config-netty-access"></a>

Dalam kebanyakan situasi, Anda menggunakan `NettyNioAsyncHttpClient` tanpa konfigurasi eksplisit dalam program asinkron. Anda mendeklarasikan klien layanan asinkron Anda dan SDK akan mengkonfigurasi dengan nilai standar untuk `NettyNioAsyncHttpClient` Anda.

Jika Anda ingin mengkonfigurasi `NettyNioAsyncHttpClient` atau menggunakannya secara eksplisit dengan beberapa klien layanan, Anda harus membuatnya tersedia untuk konfigurasi.

### Tidak ada konfigurasi yang diperlukan
<a name="http-config-netty-no-config"></a>

*Saat Anda mendeklarasikan dependensi pada klien layanan di Maven, SDK menambahkan dependensi runtime pada artefak.* `netty-nio-client` Ini membuat `NettyNioAsyncHttpClient` kelas tersedia untuk kode Anda saat runtime, tetapi tidak pada waktu kompilasi. Jika Anda tidak mengonfigurasi klien HTTP berbasis Netty, Anda tidak perlu menentukan ketergantungan untuk itu.

Dalam cuplikan XHTML berikut dari `pom.xml` file Maven, dependensi yang dideklarasikan dengan `<artifactId>dynamodb-enhanced</artifactId>` transitif membawa klien HTTP berbasis Netty. Anda tidak perlu mendeklarasikan dependensi khusus untuk itu.

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

Dengan dependensi ini, Anda tidak dapat membuat perubahan konfigurasi HTTP apa pun, karena `NettyNioAsyncHttpClient` pustaka hanya ada di classpath runtime. 

### Konfigurasi diperlukan
<a name="http-config-netty-yes-config"></a>

Untuk mengkonfigurasi`NettyNioAsyncHttpClient`, Anda perlu menambahkan ketergantungan pada `netty-nio-client` artefak pada waktu *kompilasi*. 

Lihat contoh berikut dari file Maven untuk mengkonfigurasi `pom.xml` file. `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>
```

## Gunakan dan konfigurasikan `NettyNioAsyncHttpClient`
<a name="http-netty-config"></a>

Anda dapat mengonfigurasi instance `NettyNioAsyncHttpClient` bersama dengan membangun klien layanan, atau Anda dapat mengonfigurasi satu instance untuk dibagikan di beberapa klien layanan. 

Dengan salah satu pendekatan, Anda menggunakan [NettyNioAsyncHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.Builder.html) untuk mengonfigurasi properti untuk instance klien HTTP berbasis Netty.

### Praktik terbaik: mendedikasikan `NettyNioAsyncHttpClient` instance untuk klien layanan
<a name="http-config-netty-one-client"></a>

Jika Anda perlu mengonfigurasi instance`NettyNioAsyncHttpClient`, kami sarankan Anda membuat `NettyNioAsyncHttpClient` instance khusus. Anda dapat melakukannya dengan menggunakan `httpClientBuilder` metode pembangun klien layanan. Dengan cara ini, siklus hidup klien HTTP dikelola oleh SDK, yang membantu menghindari potensi kebocoran memori jika `NettyNioAsyncHttpClient` instance tidak ditutup saat tidak lagi diperlukan.

Contoh berikut menciptakan sebuah `DynamoDbAsyncClient` instance yang digunakan oleh sebuah `DynamoDbEnhancedAsyncClient` instance. `DynamoDbAsyncClient`Instance berisi `NettyNioAsyncHttpClient` instance dengan `connectionTimeout` dan `maxConcurrency` nilai-nilai. Contoh HTTP dibuat menggunakan `httpClientBuilder` metode`DynamoDbAsyncClient.Builder`.

 **Impor** 

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

 **Kode** 

```
// 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();
```

### Pendekatan alternatif: bagikan `NettyNioAsyncHttpClient` contoh
<a name="http-config-netty-multi-clients"></a>

Untuk membantu menjaga penggunaan sumber daya dan memori lebih rendah untuk aplikasi Anda, Anda dapat mengonfigurasi `NettyNioAsyncHttpClient` dan membagikannya di beberapa klien layanan. Kumpulan koneksi HTTP akan dibagikan, yang menurunkan penggunaan sumber daya.

**catatan**  
Ketika sebuah `NettyNioAsyncHttpClient` instance dibagikan, Anda harus menutupnya ketika sudah siap untuk dibuang. SDK tidak akan menutup instance saat klien layanan ditutup.

Contoh berikut mengkonfigurasi klien HTTP berbasis Netty yang digunakan oleh dua klien layanan. `NettyNioAsyncHttpClient`Instance yang dikonfigurasi diteruskan ke `httpClient` metode masing-masing builder. Ketika klien layanan dan klien HTTP tidak lagi diperlukan, kode secara eksplisit menutupnya. Kode menutup klien HTTP terakhir.

**Impor**

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

 **Kode** 

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

## Konfigurasikan negosiasi protokol ALPN
<a name="http-netty-config-alpn"></a>

ALPN (Application-Layer Protocol Negotiation) adalah ekstensi TLS yang memungkinkan lapisan aplikasi untuk menegosiasikan protokol mana yang harus dilakukan melalui koneksi aman dengan cara yang menghindari perjalanan pulang pergi tambahan dan memberikan kinerja yang lebih baik.

Untuk mengaktifkan klien HTTP berbasis Netty menggunakan ALPN, panggil metode pembangun seperti yang ditunjukkan pada cuplikan berikut:

```
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();
```

Negosiasi protokol ALPN saat ini hanya berfungsi dengan protokol HTTP/2 seperti yang ditunjukkan pada cuplikan sebelumnya.

## Contoh konfigurasi proxy
<a name="http-config-netty-proxy-ex"></a>

Cuplikan kode berikut menggunakan [pembangun konfigurasi proxy untuk klien Netty HTTP](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/ProxyConfiguration.Builder.html).

```
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();
```

Properti sistem Java yang setara untuk konfigurasi proxy ditampilkan dalam cuplikan baris perintah berikut.

```
$ java -Dhttps.proxyHost=myproxy -Dhttps.proxyPort=1234 -Dhttps.proxyUser=username \
-Dhttps.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```

**penting**  
Untuk menggunakan salah satu properti sistem proxy HTTPS, `scheme` properti harus disetel dalam kode`https`. Jika properti skema tidak disetel dalam kode, skema default ke HTTP dan SDK hanya mencari properti sistem. `http.*`

Pengaturan setara yang menggunakan variabel lingkungan adalah:

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