Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Konfigurasikan klien HTTP di AWS SDK for Java 2.x
Anda dapat mengubah klien HTTP untuk digunakan untuk klien layanan Anda serta mengubah konfigurasi default untuk klien HTTP dengan AWS SDK for Java 2.x. Bagian ini membahas klien HTTP dan pengaturan untuk SDK.
## Klien HTTP tersedia di SDK for Java
### Klien sinkron
Klien HTTP sinkron di SDK for Java mengimplementasikan [SdkHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/SdkHttpClient.html)antarmuka. Klien layanan sinkron, seperti `S3Client` atau`DynamoDbClient`, memerlukan penggunaan klien HTTP sinkron. Ini AWS SDK untuk Java menawarkan tiga klien HTTP sinkron.
**ApacheHttpClient (default)**
[ApacheHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html)adalah klien HTTP default untuk klien layanan sinkron. Untuk informasi tentang mengonfigurasi`ApacheHttpClient`, lihat[Konfigurasikan klien HTTP berbasis Apache](http-configuration-apache.md).
**AwsCrtHttpClient**
[AwsCrtHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.html)menyediakan throughput tinggi dan IO non-pemblokiran. Ini dibangun di atas AWS Common Runtime (CRT) Http Client. Untuk informasi tentang mengkonfigurasi `AwsCrtHttpClient` dan menggunakannya dengan klien layanan, lihat[Konfigurasikan AWS klien HTTP berbasis CRT](http-configuration-crt.md).
**UrlConnectionHttpClient**
Untuk meminimalkan jumlah toples dan pustaka pihak ketiga yang Anda gunakan aplikasi, Anda dapat menggunakan. [UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html) Untuk informasi tentang mengonfigurasi`UrlConnectionHttpClient`, lihat[Konfigurasikan klien HTTP URLConnection berbasis](http-configuration-url.md).
**Apache5 HttpClient**
[Apache5 HttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache5/Apache5HttpClient.html) *adalah versi terbaru yang dibangun di atas Apache 5.x. `ApacheHttpClient` HttpClient Versi 5.x* adalah versi yang dikelola secara aktif oleh Apache, dan meningkatkan versi sebelumnya yang digunakan dengan `ApacheHttpClient` menghadirkan kompatibilitas ekosistem Java modern termasuk dukungan thread virtual untuk Java 21, dan peningkatan fleksibilitas logging melalui SLF4 J. `Apache5HttpClient` akan menggantikan `ApacheHttpClient` sebagai klien sinkron default dalam versi masa depan SDK for AWS Java 2.x. Ini memiliki API dan fitur yang identik, membuatnya ideal sebagai pengganti drop-in. Untuk informasi tentang mengonfigurasi`Apache5HttpClient`, lihat[Konfigurasikan klien HTTP berbasis Apache 5.x](http-configuration-apache5.md).
### Klien asinkron
Klien HTTP asinkron di SDK for Java mengimplementasikan antarmuka. [SdkAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/async/SdkAsyncHttpClient.html) Klien layanan asinkron, seperti `S3AsyncClient` atau`DynamoDbAsyncClient`, memerlukan penggunaan klien HTTP asinkron. Ini AWS SDK untuk Java menawarkan dua klien HTTP asinkron.
**NettyNioAsyncHttpClient (default)**
[NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html)adalah klien HTTP default yang digunakan oleh klien asinkron. Untuk informasi tentang mengonfigurasi`NettyNioAsyncHttpClient`, lihat[Konfigurasikan klien HTTP berbasis Netty](http-configuration-netty.md).
**AwsCrtAsyncHttpClient**
[AwsCrtAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.html)Ini didasarkan pada AWS Common Runtime (CRT) HTTP Client. Untuk informasi tentang mengonfigurasi`AwsCrtAsyncHttpClient`, lihat[Konfigurasikan AWS klien HTTP berbasis CRT](http-configuration-crt.md).
## Rekomendasi klien HTTP
Beberapa faktor ikut bermain ketika Anda memilih implementasi klien HTTP. Gunakan informasi berikut untuk membantu Anda memutuskan.
### Diagram alur rekomendasi
Diagram alur berikut memberikan panduan umum untuk membantu Anda menentukan klien HTTP mana yang akan digunakan.
![\[Diagram alir rekomendasi klien HTTP.\]](http://docs.aws.amazon.com/id_id/sdk-for-java/latest/developer-guide/images/JavaDevGuide-HTTPflowchart-DI.png)
### Perbandingan klien HTTP
Tabel berikut memberikan informasi rinci untuk setiap klien HTTP.
| Klien HTTP | Sinkronisasi atau asinkron | Kapan harus digunakan | Batasan/kelemahan |
| --- | --- | --- | --- |
| Klien HTTP berbasis Apache *(klien HTTP sinkronisasi default)* | Sinkronkan | Gunakan jika Anda lebih suka latensi rendah daripada throughput tinggi | Waktu startup lebih lambat dibandingkan dengan klien HTTP lainnya |
| URLConnectionberbasis HTTP klien | Sinkronkan | Gunakan jika Anda memiliki persyaratan sulit untuk membatasi dependensi pihak ketiga | Tidak mendukung metode HTTP PATCH, yang diperlukan oleh beberapa API seperti operasi APIGateway Pembaruan Amazon |
| AWS Klien HTTP sinkronisasi berbasis CRT 1 | Sinkronkan | • Gunakan jika aplikasi Anda berjalan di AWS Lambda • Gunakan jika Anda lebih suka throughput tinggi daripada latensi rendah • Gunakan jika Anda lebih suka menyinkronkan klien SDK | Properti sistem Java berikut tidak didukung: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sdk-for-java/latest/developer-guide/http-configuration.html) |
| Klien HTTP berbasis Netty *(klien HTTP asinkron default)* | Asinkron | • Gunakan jika aplikasi Anda memanggil APIs yang memerlukan dukungan HTTP/2 seperti Kinesis API [SubscribeToShard](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_SubscribeToShard.html) | Waktu startup lebih lambat dibandingkan dengan klien HTTP lainnya |
| AWS Klien HTTP async berbasis CRT 1 | Asinkron | • Gunakan jika aplikasi Anda berjalan di AWS Lambda• Gunakan jika Anda lebih suka throughput tinggi daripada latensi rendah• Gunakan jika Anda lebih suka klien SDK async | • Tidak mendukung klien layanan yang memerlukan dukungan HTTP/2 seperti dan `KinesisAsynClient` `TranscribeStreamingAsyncClient` Properti sistem Java berikut tidak didukung: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sdk-for-java/latest/developer-guide/http-configuration.html) |
1 Karena manfaat tambahannya, kami sarankan Anda menggunakan klien HTTP AWS berbasis CRT jika memungkinkan.
## Default konfigurasi cerdas
AWS SDK for Java 2.x (versi 2.17.102 atau yang lebih baru) menawarkan fitur default konfigurasi cerdas. Fitur ini mengoptimalkan dua properti klien HTTP bersama dengan properti lain yang tidak mempengaruhi klien HTTP.
Default konfigurasi cerdas menetapkan nilai yang masuk akal untuk `tlsNegotiationTimeoutInMillis` properti `connectTimeoutInMillis` dan berdasarkan nilai mode default yang Anda berikan. Anda memilih nilai mode default berdasarkan karakteristik aplikasi Anda.
[Untuk informasi selengkapnya tentang default konfigurasi cerdas dan cara memilih nilai mode default yang paling cocok untuk aplikasi Anda, lihat Panduan Referensi Alat dan Alat.AWS SDKs ](https://docs.aws.amazon.com/sdkref/latest/guide/feature-smart-config-defaults.html)
Berikut adalah empat cara untuk mengatur mode default untuk aplikasi Anda.
------
#### [ Service client ]
Gunakan pembuat klien layanan untuk mengonfigurasi mode default langsung pada klien layanan. Contoh berikut menetapkan modus default untuk untuk`auto`. `DynamoDbClient`
```
DynamoDbClient ddbClient = DynamoDbClient.builder()
.defaultsMode(DefaultsMode.AUTO)
.build();
```
------
#### [ System property ]
Anda dapat menggunakan properti `aws.defaultsMode` sistem untuk menentukan mode default. Jika Anda mengatur properti sistem di Java, Anda perlu mengatur properti sebelum menginisialisasi klien layanan apa pun.
Contoh berikut menunjukkan kepada Anda cara mengatur mode default untuk `auto` menggunakan properti sistem yang disetel di Java.
```
System.setProperty("aws.defaultsMode", "auto");
```
Contoh berikut menunjukkan bagaimana Anda mengatur mode default untuk `auto` menggunakan `-D` opsi perintah. `java`
```
java -Daws.defaultsMode=auto
```
------
#### [ Environment variable ]
Tetapkan nilai untuk variabel lingkungan `AWS_DEFAULTS_MODE` untuk memilih mode default untuk aplikasi Anda.
Informasi berikut menunjukkan perintah untuk menjalankan untuk mengatur nilai untuk modus default untuk `auto` menggunakan variabel lingkungan.
| Sistem operasi | Perintah untuk mengatur variabel lingkungan |
| --- | --- |
| Linux, macOS, atau Unix | export AWS\$1DEFAULTS\$1MODE=auto |
| Windows | set AWS\$1DEFAULTS\$1MODE=auto |
------
#### [ AWS config file ]
Anda dapat menambahkan properti `defaults_mode` konfigurasi ke AWS `config` file bersama seperti yang ditunjukkan contoh berikut.
```
[default]
defaults_mode = auto
```
------
Jika Anda menyetel mode default secara global dengan properti sistem, variabel lingkungan, atau file AWS konfigurasi, Anda dapat mengganti pengaturan saat membuat klien HTTP.
Saat Anda membangun klien HTTP dengan `httpClientBuilder()` metode ini, pengaturan hanya berlaku untuk instance yang sedang Anda bangun. Contohnya ditunjukkan [di sini](http-configuration-netty.md#http-config-netty-one-client). Klien HTTP berbasis Netty dalam contoh ini mengganti nilai mode default apa pun yang ditetapkan secara global untuk dan. `connectTimeoutInMillis` `tlsNegotiationTimeoutInMillis`
# Konfigurasikan klien HTTP berbasis Apache
Klien layanan sinkron dalam AWS SDK for Java 2.x menggunakan klien HTTP berbasis Apache, secara default. [ApacheHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html) SDK `ApacheHttpClient` didasarkan pada [HttpClient](https://hc.apache.org/httpcomponents-client-4.5.x/index.html)Apache.
SDK juga menawarkan [UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html), yang memuat lebih cepat, tetapi memiliki lebih sedikit fitur. Untuk informasi tentang mengonfigurasi`UrlConnectionHttpClient`, lihat[Konfigurasikan klien HTTP URLConnection berbasis](http-configuration-url.md).
Untuk melihat set lengkap opsi konfigurasi yang tersedia untuk Anda`ApacheHttpClient`, lihat [ApacheHttpClient.Builder dan [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).
## Akses `ApacheHttpClient`
Dalam kebanyakan situasi, Anda menggunakan `ApacheHttpClient` tanpa konfigurasi eksplisit. Anda mendeklarasikan klien layanan Anda dan SDK akan mengkonfigurasi `ApacheHttpClient` dengan nilai standar untuk Anda.
Jika Anda ingin mengkonfigurasi `ApacheHttpClient` atau menggunakannya secara eksplisit dengan beberapa klien layanan, Anda harus membuatnya tersedia untuk konfigurasi.
### Tidak diperlukan konfigurasi
*Saat Anda mendeklarasikan dependensi pada klien layanan di Maven, SDK menambahkan dependensi runtime pada artefak.* `apache-client` Ini membuat `ApacheHttpClient` kelas tersedia untuk kode Anda saat runtime, tetapi tidak pada waktu kompilasi. Jika Anda tidak mengonfigurasi klien HTTP berbasis Apache, Anda tidak perlu menentukan ketergantungan untuk itu.
Dalam cuplikan XHTML berikut dari `pom.xml` file Maven, dependensi yang dideklarasikan dengan `s3` secara otomatis membawa klien HTTP berbasis Apache. Anda tidak perlu mendeklarasikan ketergantungan khusus untuk itu.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
s3
```
Dengan dependensi ini, Anda tidak dapat membuat perubahan konfigurasi HTTP eksplisit, karena `ApacheHttpClient` pustaka hanya ada di classpath runtime.
### Konfigurasi diperlukan
Untuk mengkonfigurasi`ApacheHttpClient`, Anda perlu menambahkan ketergantungan pada `apache-client` perpustakaan pada waktu *kompilasi*.
Lihat contoh berikut dari file Maven untuk mengkonfigurasi `pom.xml` file. `ApacheHttpClient`
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
s3
software.amazon.awssdk
apache-client
```
## Gunakan dan konfigurasikan `ApacheHttpClient`
Anda dapat mengonfigurasi instance `ApacheHttpClient` bersama dengan membangun klien layanan, atau Anda dapat mengonfigurasi satu instance untuk dibagikan di beberapa klien layanan.
Dengan salah satu pendekatan, Anda menggunakan `[ApacheHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.Builder.html)` untuk mengkonfigurasi properti untuk klien HTTP berbasis Apache.
### Praktik terbaik: mendedikasikan sebuah `ApacheHttpClient` instance untuk klien layanan
Jika Anda perlu mengonfigurasi instance`ApacheHttpClient`, kami sarankan Anda membuat `ApacheHttpClient` 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 `ApacheHttpClient` instance tidak ditutup saat tidak lagi diperlukan.
Contoh berikut membuat `S3Client` dan mengkonfigurasi instance tertanam `ApacheHttpClient` dengan `maxConnections` dan `connectionTimeout` nilai-nilai. Contoh HTTP dibuat menggunakan `httpClientBuilder` metode`S3Client.Builder`.
**Impor**
```
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Kode**
```
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.
```
### Pendekatan alternatif: bagikan `ApacheHttpClient` contoh
Untuk membantu menjaga penggunaan sumber daya dan memori lebih rendah untuk aplikasi Anda, Anda dapat mengonfigurasi `ApacheHttpClient` dan membagikannya di beberapa klien layanan. Kumpulan koneksi HTTP akan dibagikan, yang menurunkan penggunaan sumber daya.
**catatan**
Ketika sebuah `ApacheHttpClient` 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 Apache yang digunakan oleh dua klien layanan. `ApacheHttpClient`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**
```
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.
```
## Contoh konfigurasi proxy
Cuplikan kode berikut menggunakan [pembangun konfigurasi proxy untuk klien HTTP Apache](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();
```
Properti sistem Java yang setara untuk konfigurasi proxy ditampilkan dalam cuplikan baris perintah berikut.
```
$ java -Dhttp.proxyHost=example.com -Dhttp.proxyPort=1234 -Dhttp.proxyUser=username \
-Dhttp.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
Pengaturan setara yang menggunakan variabel lingkungan adalah:
```
// 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
```
**catatan**
Klien HTTP Apache saat ini tidak mendukung properti sistem proxy HTTPS atau variabel lingkungan HTTPS\$1PROXY.
# Konfigurasikan klien HTTP URLConnection berbasis
Ini AWS SDK for Java 2.x menawarkan klien `[UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html)` HTTP yang lebih ringan dibandingkan dengan default. `ApacheHttpClient` `UrlConnectionHttpClient`Ini didasarkan pada Java`[URLConnection](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/net/URLConnection.html)`.
`UrlConnectionHttpClient`Beban lebih cepat daripada klien HTTP berbasis Apache, tetapi memiliki lebih sedikit fitur. Karena memuat lebih cepat, ini adalah [solusi yang baik](lambda-optimize-starttime.md) untuk AWS Lambda fungsi Java.
Ini `UrlConnectionHttpClient` memiliki beberapa [opsi yang dapat dikonfigurasi](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.Builder.html) yang dapat Anda akses.
**catatan**
`UrlConnectionHttpClient`Tidak mendukung metode HTTP PATCH.
Beberapa operasi AWS API memerlukan permintaan PATCH. Nama-nama operasi itu biasanya dimulai dengan`Update*`. Berikut ini adalah beberapa contoh.
[Beberapa `Update*` operasi](https://docs.aws.amazon.com/securityhub/1.0/APIReference/API_Operations.html) di AWS Security Hub CSPM API dan juga [BatchUpdateFindings](https://docs.aws.amazon.com/securityhub/1.0/APIReference/API_BatchUpdateFindings.html)operasi
Semua [`Update*`operasi](https://docs.aws.amazon.com/apigateway/latest/api/API_UpdateAccount.html) API Amazon API Gateway
Jika Anda mungkin menggunakan`UrlConnectionHttpClient`, pertama-tama lihat Referensi API untuk Layanan AWS yang Anda gunakan. Periksa untuk melihat apakah operasi yang Anda butuhkan menggunakan operasi PATCH.
## Akses `UrlConnectionHttpClient`
Untuk mengkonfigurasi dan menggunakan`UrlConnectionHttpClient`, Anda mendeklarasikan ketergantungan pada artefak `url-connection-client` Maven dalam file Anda. `pom.xml`
Berbeda dengan`ApacheHttpClient`, tidak `UrlConnectionHttpClient` secara otomatis ditambahkan ke proyek Anda, jadi penggunaan harus secara khusus mendeklarasikannya.
Contoh berikut dari `pom.xml` file menunjukkan dependensi yang diperlukan untuk menggunakan dan mengkonfigurasi klien HTTP.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
url-connection-client
```
## Gunakan dan konfigurasikan `UrlConnectionHttpClient`
Anda dapat mengonfigurasi instance `UrlConnectionHttpClient` bersama dengan membangun klien layanan, atau Anda dapat mengonfigurasi satu instance untuk dibagikan di beberapa klien layanan.
Dengan salah satu pendekatan, Anda menggunakan [UrlConnectionHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.Builder.html) untuk mengonfigurasi properti untuk klien HTTP URLConnection berbasis.
### Praktik terbaik: mendedikasikan sebuah `UrlConnectionHttpClient` instance untuk klien layanan
Jika Anda perlu mengonfigurasi instance`UrlConnectionHttpClient`, kami sarankan Anda membuat `UrlConnectionHttpClient` 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 `UrlConnectionHttpClient` instance tidak ditutup saat tidak lagi diperlukan.
Contoh berikut membuat `S3Client` dan mengkonfigurasi instance tertanam `UrlConnectionHttpClient` dengan `socketTimeout` dan `proxyConfiguration` nilai-nilai. `proxyConfiguration`Metode ini mengambil ekspresi Java lambda tipe` Consumer<[ProxyConfiguration.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/ProxyConfiguration.Builder.html)>`.
**Impor**
```
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.urlconnection.UrlConnectionHttpClient;
import java.net.URI;
import java.time.Duration;
```
**Kode**
```
// 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.
```
### Pendekatan alternatif: bagikan `UrlConnectionHttpClient` contoh
Untuk membantu menjaga penggunaan sumber daya dan memori lebih rendah untuk aplikasi Anda, Anda dapat mengonfigurasi `UrlConnectionHttpClient` dan membagikannya di beberapa klien layanan. Kumpulan koneksi HTTP akan dibagikan, yang menurunkan penggunaan sumber daya.
**catatan**
Ketika sebuah `UrlConnectionHttpClient` instance dibagikan, Anda harus menutupnya ketika sudah siap untuk dibuang. SDK tidak akan menutup instance saat klien layanan ditutup.
Contoh berikut mengkonfigurasi klien HTTP URLConnection berbasis yang digunakan oleh dua klien layanan. `UrlConnectionHttpClient`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.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;
```
**Kode**
```
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();
```
#### Gunakan `URLConnectionHttpClient` dan `ApacheHttpClient` bersama-sama
Ketika Anda menggunakan `UrlConnectionHttpClient` dalam aplikasi Anda, Anda harus menyediakan setiap klien layanan dengan `URLConnectionHttpClient` instance atau `ApacheHttpClient` instance menggunakan `httpClientBuilder` metode pembuat klien layanan.
Pengecualian terjadi jika program Anda menggunakan beberapa klien layanan dan kedua hal berikut ini benar:
+ Satu klien layanan dikonfigurasi untuk menggunakan `UrlConnectionHttpClient` instance
+ Klien layanan lain menggunakan default `ApacheHttpClient` tanpa secara eksplisit membangunnya dengan metode or `httpClient()` `httpClientBuilder()`
Pengecualian akan menyatakan bahwa beberapa implementasi HTTP ditemukan di classpath.
Contoh cuplikan kode berikut mengarah ke pengecualian.
```
// 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();
```
Hindari pengecualian dengan secara eksplisit mengonfigurasi dengan file. `S3Client` `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();
```
**catatan**
Untuk secara eksplisit membuat`ApacheHttpClient`, Anda harus [menambahkan ketergantungan](http-configuration-apache.md#http-apache-dependency) pada `apache-client` artefak dalam file proyek Maven Anda.
## Contoh konfigurasi proxy
Cuplikan kode berikut menggunakan [pembangun konfigurasi proxy untuk klien HTTP koneksi URL](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();
```
Properti sistem Java yang setara untuk konfigurasi proxy ditampilkan dalam cuplikan baris perintah berikut.
```
$ java -Dhttp.proxyHost=example.com -Dhttp.proxyPort=1234 -Dhttp.proxyUser=username \
-Dhttp.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
Pengaturan setara yang menggunakan variabel lingkungan adalah:
```
// 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
```
**catatan**
Klien HTTP URLConnection berbasis saat ini tidak mendukung properti sistem proxy HTTPS atau variabel lingkungan HTTPS\$1PROXY.
# Konfigurasikan klien HTTP berbasis Netty
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`
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
*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 `dynamodb-enhanced` transitif membawa klien HTTP berbasis Netty. Anda tidak perlu mendeklarasikan dependensi khusus untuk itu.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
dynamodb-enhanced
```
Dengan dependensi ini, Anda tidak dapat membuat perubahan konfigurasi HTTP apa pun, karena `NettyNioAsyncHttpClient` pustaka hanya ada di classpath runtime.
### Konfigurasi diperlukan
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`
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
dynamodb-enhanced
software.amazon.awssdk
netty-nio-client
```
## Gunakan dan konfigurasikan `NettyNioAsyncHttpClient`
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
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
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
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
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
```
# Konfigurasikan AWS klien HTTP berbasis CRT
Klien HTTP AWS berbasis CRT termasuk sinkron dan asinkron. [AwsCrtHttpClient[AwsCrtAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.html)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.html) Klien HTTP AWS berbasis CRT memberikan manfaat klien HTTP berikut:
+ Waktu startup SDK lebih cepat
+ Jejak memori yang lebih kecil
+ Mengurangi waktu latensi
+ Manajemen kesehatan koneksi
+ Penyeimbangan beban DNS
**AWS Komponen berbasis CRT di SDK**
Klien *HTTP AWS * berbasis CRT, dijelaskan dalam topik ini, dan klien *S3 AWS * berbasis CRT adalah komponen yang berbeda dalam SDK.
**Klien HTTP AWS berbasis CRT sinkron dan asinkron adalah implementasi antarmuka klien HTTP** SDK dan digunakan untuk komunikasi HTTP umum. Mereka adalah alternatif untuk klien HTTP sinkron atau asinkron lainnya di SDK dengan manfaat tambahan.
**[Klien S3 AWS berbasis CRT](crt-based-s3-client.md)** adalah implementasi AsyncClient antarmuka [S3](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html) dan digunakan untuk bekerja dengan layanan Amazon S3. Ini adalah alternatif untuk implementasi `S3AsyncClient` antarmuka berbasis Java dan menawarkan beberapa keuntungan.
Meskipun kedua komponen menggunakan pustaka dari [AWS Common Runtime](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html), klien HTTP AWS berbasis CRT tidak menggunakan [pustaka aws-c-s 3](https://github.com/awslabs/aws-c-s3) dan tidak mendukung fitur API unggahan multipart [S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html). Klien S3 AWS berbasis CRT, sebaliknya, dibuat khusus untuk mendukung fitur API unggahan multibagian S3.
## Akses klien HTTP AWS berbasis CRT
Sebelum Anda dapat menggunakan klien HTTP AWS berbasis CRT, tambahkan `aws-crt-client` artefak dengan versi minimum 2.22.0 ke dependensi proyek Anda.
Gunakan salah satu opsi berikut untuk mengatur file Maven `pom.xml` Anda.
**catatan**
Anda dapat memilih untuk menggunakan *opsi jar khusus Platform* jika Anda perlu menjaga ukuran dependensi runtime lebih kecil, misalnya jika aplikasi Anda berjalan dalam suatu fungsi. AWS Lambda
------
#### [ Uber-jar option ]
Secara default, `aws-crt-client` menggunakan uber-jar artefak AWS CRT yang berisi binari untuk beberapa platform, termasuk Linux, Windows, dan macOS.
```
2.29.10*
software.amazon.awssdk
bom
${aws.sdk.version}
pom
import
software.amazon.awssdk
aws-crt-client
```
\$1 Ganti versi yang ditampilkan dalam warna merah dengan versi Java SDK yang ingin Anda gunakan. Temukan yang terbaru di [Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).
------
#### [ Platform-specific jar option ]
*Untuk membatasi runtime Java ke versi khusus platform dari pustaka AWS CRT, buat perubahan berikut pada opsi Uber-jar.*
+ Tambahkan `exclusions` elemen ke `aws-crt-client` artefak SDK. Pengecualian ini mencegah SDK secara transitif menggunakan uber-jar CRT. AWS
+ Tambahkan elemen ketergantungan untuk versi platform AWS CRT tertentu yang Anda butuhkan. Lihat **Langkah-langkah untuk menentukan versi artefak AWS CRT di bawah ini untuk mengetahui bagaimana Anda dapat menentukan versi** yang benar.
```
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 Ganti versi yang ditampilkan dalam warna merah dengan versi Java SDK yang ingin Anda gunakan. Temukan yang terbaru di [Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).
2 Ganti versi `software.amazon.awssdk.crt:aws-crt` yang akan disediakan oleh opsi *Uber-jar*. Lihat **Langkah-langkah berikut untuk menentukan versi artefak AWS CRT**.
3 Ganti `classifier` nilainya dengan satu untuk platform Anda. Lihat GitHub halaman AWS CRT untuk Java untuk [daftar nilai yang tersedia](https://github.com/awslabs/aws-crt-java?tab=readme-ov-file#platform-specific-jars).
**Langkah-langkah untuk menentukan versi artefak AWS CRT**
Gunakan langkah-langkah berikut untuk menentukan versi artefak AWS CRT yang kompatibel dengan versi SDK for Java yang Anda gunakan.
1. Siapkan `pom.xml` file Anda seperti yang ditunjukkan pada opsi *Uber-jar*. Pengaturan ini memungkinkan Anda untuk melihat versi SDK apa `software.amazon.awssdk.crt:aws-crt` yang dibawa secara default.
1. Di root proyek (dalam direktori yang sama dengan `pom.xml` file), jalankan perintah Maven berikut:
```
mvn dependency:tree -Dincludes=software.amazon.awssdk.crt:aws-crt
```
Maven mungkin melakukan tindakan lain, tetapi pada akhirnya Anda akan melihat keluaran konsol dari `software.amazon.awssdk.crt:aws-crt` ketergantungan yang digunakan SDK secara transitif. Cuplikan berikut menunjukkan output sampel berdasarkan versi SDK: `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. Gunakan versi yang ditampilkan konsol untuk `software.amazon.awssdk.crt:aws-crt` artefak. Dalam hal ini, tambahkan `0.31.3` ke `pom.xml` file Anda.
------
## Gunakan dan konfigurasikan klien AWS HTTP berbasis CRT
Anda dapat mengonfigurasi klien HTTP AWS berbasis CRT bersama dengan membangun klien layanan, atau Anda dapat mengonfigurasi satu instance untuk dibagikan di beberapa klien layanan.
Dengan salah satu pendekatan, Anda menggunakan pembangun untuk [mengonfigurasi properti](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.Builder.html) untuk instance klien HTTP AWS berbasis CRT.
### Praktik terbaik: mendedikasikan sebuah instance untuk klien layanan
Jika Anda perlu mengonfigurasi instance klien HTTP AWS berbasis CRT, kami sarankan Anda mendedikasikan instance dengan membangunnya bersama dengan klien layanan. 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 instance klien HTTP AWS berbasis CRT tidak ditutup ketika tidak lagi diperlukan.
Contoh berikut membuat klien layanan S3 dan mengkonfigurasi klien HTTP AWS berbasis CRT dengan dan nilai-nilai. `connectionTimeout` `maxConcurrency`
------
#### [ Synchronous client ]
**Impor**
```
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Kode**
```
// 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 ]
**Impor**
```
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import java.time.Duration;
```
**Kode**
```
// 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();
```
------
### Pendekatan alternatif: bagikan contoh
Untuk membantu menjaga penggunaan sumber daya dan memori lebih rendah untuk aplikasi Anda, Anda dapat mengonfigurasi klien HTTP AWS berbasis CRT dan membagikannya di beberapa klien layanan. Kumpulan koneksi HTTP akan dibagikan, yang menurunkan penggunaan sumber daya.
**catatan**
Ketika instance klien HTTP AWS berbasis CRT dibagikan, Anda harus menutupnya ketika sudah siap untuk dibuang. SDK tidak akan menutup instance saat klien layanan ditutup.
Contoh berikut mengkonfigurasi instance klien HTTP AWS berbasis CRT dengan `connectionTimeout` dan nilai-nilai. `maxConcurrency` Instance yang dikonfigurasi diteruskan ke `httpClient` metode setiap pembuat klien layanan. Ketika klien layanan dan klien HTTP tidak lagi diperlukan, mereka secara eksplisit ditutup. Klien HTTP ditutup terakhir.
------
#### [ Synchronous client ]
**Impor**
```
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;
```
**Kode**
```
// 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 ]
**Impor**
```
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;
```
**Kode**
```
// 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.
```
------
## Tetapkan klien HTTP AWS berbasis CRT sebagai default
Anda dapat mengatur file build Maven agar SDK menggunakan klien HTTP AWS berbasis CRT sebagai klien HTTP default untuk klien layanan.
Anda melakukan ini dengan menambahkan `exclusions` elemen dengan dependensi klien HTTP default ke setiap artefak klien layanan.
Dalam `pom.xml` contoh berikut, SDK menggunakan klien HTTP AWS berbasis CRT untuk layanan S3. Jika klien layanan dalam kode Anda adalah`S3AsyncClient`, SDK akan menggunakan`AwsCrtAsyncHttpClient`. Jika klien layanan adalah S3Client, SDK menggunakan. `AwsCrtHttpClient` Dengan pengaturan ini, klien HTTP asinkron berbasis Netty default dan HTTP sinkron berbasis Apache default tidak tersedia.
```
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
```
Kunjungi repositori pusat Maven untuk nilai terbaru. [https://central.sonatype.com/artifact/software.amazon.awssdk/bom](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)
**catatan**
Jika beberapa klien layanan dideklarasikan dalam sebuah `pom.xml` file, semua memerlukan elemen `exclusions` XHTML.
### Menggunakan properti sistem Java
Untuk menggunakan klien HTTP AWS berbasis CRT sebagai HTTP default untuk aplikasi Anda, Anda dapat mengatur properti sistem Java `software.amazon.awssdk.http.async.service.impl` ke nilai. `software.amazon.awssdk.http.crt.AwsCrtSdkHttpService`
Untuk mengatur selama startup aplikasi, jalankan perintah yang mirip dengan berikut ini.
```
java app.jar -Dsoftware.amazon.awssdk.http.async.service.impl=\
software.amazon.awssdk.http.crt.AwsCrtSdkHttpService
```
Gunakan cuplikan kode berikut untuk mengatur properti sistem dalam kode aplikasi Anda.
```
System.setProperty("software.amazon.awssdk.http.async.service.impl",
"software.amazon.awssdk.http.crt.AwsCrtSdkHttpService");
```
**catatan**
Anda perlu menambahkan ketergantungan pada `aws-crt-client` artefak dalam `poml.xml` file Anda ketika Anda menggunakan properti sistem untuk mengkonfigurasi penggunaan klien HTTP berbasis AWS CRT.
## Konfigurasi lanjutan dari klien AWS HTTP berbasis CRT
Anda dapat menggunakan berbagai pengaturan konfigurasi klien HTTP AWS berbasis CRT, termasuk konfigurasi kesehatan koneksi dan waktu idle maksimum. Anda dapat meninjau [opsi konfigurasi yang tersedia](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.Builder.html) untuk`AwsCrtAsyncHttpClient`. Anda dapat mengonfigurasi opsi yang sama untuk file`AwsCrtHttpClient`.
### Konfigurasi kesehatan koneksi
Anda dapat mengonfigurasi konfigurasi kesehatan koneksi untuk klien HTTP AWS berbasis CRT dengan menggunakan `connectionHealthConfiguration` metode pada pembuat klien HTTP.
Contoh berikut membuat klien layanan S3 yang menggunakan instance klien HTTP AWS berbasis CRT yang dikonfigurasi dengan konfigurasi kesehatan koneksi dan waktu idle maksimum untuk koneksi.
------
#### [ Synchronous client ]
**Impor**
```
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Kode**
```
// 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 ]
**Impor**
```
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import java.time.Duration;
```
**Kode**
```
// 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();
```
------
## Dukungan HTTP/2
Protokol HTTP/2 belum didukung di klien HTTP AWS berbasis CRT, tetapi direncanakan untuk rilis future.
Sementara itu, jika Anda menggunakan klien layanan yang memerlukan dukungan HTTP/2 seperti [KinesisAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/kinesis/KinesisAsyncClient.html)atau [TranscribeStreamingAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/transcribestreaming/TranscribeStreamingAsyncClient.html), pertimbangkan untuk menggunakan sebagai gantinya. [NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html)
## Contoh konfigurasi proxy
Cuplikan kode berikut menunjukkan penggunaan [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)yang Anda gunakan untuk mengkonfigurasi pengaturan proxy dalam kode.
------
#### [ Synchronous client ]
**Impor**
```
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.http.crt.ProxyConfiguration;
```
**Kode**
```
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 ]
**Impor**
```
import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.http.crt.ProxyConfiguration;
```
**Kode**
```
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();
```
------
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 crtAsyncHttpClient = AwsCrtAsyncHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.scheme("https")
.useSystemPropertyValues(Boolean.FALSE)
.build())
.build();
// Run the application.
// $ java -cp ... App
```
# Konfigurasikan proxy HTTP
Anda dapat mengkonfigurasi proxy HTTP dengan menggunakan kode, dengan mengatur properti sistem Java, atau dengan mengatur variabel lingkungan.
## Konfigurasikan dalam kode
Anda mengonfigurasi proxy dalam kode dengan `ProxyConfiguration` pembuat khusus klien saat Anda membangun klien layanan. Kode berikut menunjukkan contoh konfigurasi proxy untuk klien HTTP berbasis Apache yang digunakan oleh klien layanan Amazon S3.
```
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();
```
Bagian untuk setiap klien HTTP dalam topik ini menunjukkan contoh konfigurasi proxy.
+ [Apache HTTP klien](http-configuration-apache.md#http-configuration-apache-proxy-conf-ex)
+ [URLConnectionberbasis HTTP klien](http-configuration-url.md#http-configuration-url-proxy-conf-ex)
+ [Klien HTTP berbasis Netty](http-configuration-netty.md#http-config-netty-proxy-ex)
+ [AWS Klien HTTP berbasis CRT](http-configuration-crt.md#http-config-crt-proxy-ex)
## Konfigurasikan proxy HTTP dengan pengaturan eksternal
Bahkan jika Anda tidak secara eksplisit menggunakan `ProxyConfiguration` pembuat dalam kode, SDK mencari pengaturan eksternal untuk mengonfigurasi konfigurasi proxy default.
Secara default, SDK pertama-tama mencari properti sistem JVM. Jika satu properti ditemukan, SDK menggunakan nilai dan nilai properti sistem lainnya. Jika tidak ada properti sistem yang tersedia, SDK mencari variabel lingkungan proxy.
SDK dapat menggunakan properti sistem Java berikut dan variabel lingkungan.
**Properti sistem Java**
| Properti sistem | Deskripsi | Dukungan klien HTTP |
| --- | --- | --- |
| http.ProxyHost | Nama host dari server proxy HTTP | Semua |
| http.Proxyport | Nomor port server proxy HTTP | Semua |
| http.ProxyUser | Nama pengguna untuk otentikasi proxy HTTP | Semua |
| http.ProxyPassword | Kata sandi untuk otentikasi proxy HTTP | Semua |
| http. nonProxyHosts | Daftar host yang harus dijangkau secara langsung, melewati proxy. [Daftar ini juga valid ketika HTTPS digunakan](https://docs.oracle.com/javase/8/docs/technotes/guides/net/proxies.html). | Semua |
| https.proxyhost | Nama host dari server proxy HTTPS | Netty, CRT |
| https.proxyport | Nomor port server proxy HTTPS | Netty, CRT |
| https.proxyuser | Nama pengguna untuk otentikasi proxy HTTPS | Netty, CRT |
| https.proxyPassword | Kata sandi untuk otentikasi proxy HTTPS | Netty, CRT |
**Variabel-variabel lingkungan**
| Variabel lingkungan | Deskripsi | Dukungan klien HTTP |
| --- | --- | --- |
| HTTP\$1PROXY 1 | URL yang valid dengan skema HTTP | Semua |
| HTTPS\$1PROXY 1 | URL yang valid dengan skema HTTPS | Netty, CRT |
| TIDAK\$1PROXY 2 | Daftar host yang harus dijangkau secara langsung, melewati proxy. Daftar ini valid untuk HTTP dan HTTPS. | Semua |
### Lihat kunci dan catatan kaki
**Semua** - Semua klien HTTP yang ditawarkan oleh SDK—`UrlConnectionHttpClient`,, `ApacheHttpClient``NettyNioAsyncHttpClient`,`AwsCrtAsyncHttpClient`.
**Netty** - Klien HTTP berbasis Netty (). `NettyNioAsyncHttpClient`
**CRT** - Klien HTTP AWS berbasis CRT, (`AwsCrtHttpClient`dan). `AwsCrtAsyncHttpClient`
1 Variabel lingkungan yang ditanyakan, apakah `HTTP_PROXY` atau`HTTPS_PROXY`, tergantung pada pengaturan skema di klien. `ProxyConfiguration` Skema default adalah HTTP. Cuplikan berikut menunjukkan cara mengubah skema ke HTTPS yang digunakan untuk resolusi variabel lingkungan.
```
SdkHttpClient httpClient = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.scheme("https")
.build())
.build();
```
2 Variabel `NO_PROXY` lingkungan mendukung campuran pemisah “\$1” dan “,” antara nama host. Nama host mungkin termasuk wildcard “\$1”.
## Gunakan kombinasi pengaturan
Anda dapat menggunakan kombinasi pengaturan proxy HTTP dalam kode, properti sistem, dan variabel lingkungan.
**Example — konfigurasi yang disediakan oleh properti sistem dan oleh kode**
```
// 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();
```
SDK menyelesaikan pengaturan proxy berikut.
```
Host = localhost
Port = 1234
Password = SYS_PROP_password
UserName = username
Non ProxyHost = null
```
**Example — properti sistem dan variabel lingkungan tersedia**
Setiap `ProxyConfiguration` pembangun klien HTTP menawarkan pengaturan bernama `useSystemPropertyValues` dan`useEnvironmentVariablesValues`. Secara default, kedua pengaturan adalah`true`. Saat`true`, SDK secara otomatis menggunakan nilai dari properti sistem atau variabel lingkungan untuk opsi yang tidak disediakan oleh `ProxyConfiguration` pembuat.
Properti sistem lebih diutamakan daripada variabel lingkungan. Jika properti sistem proxy HTTP ditemukan, SDK mengambil ***semua*** nilai dari properti sistem dan tidak ada dari variabel lingkungan. Jika Anda ingin memprioritaskan variabel lingkungan di atas properti sistem, setel `useSystemPropertyValues` ke. `false`
Untuk contoh ini, pengaturan berikut tersedia runtime:
```
// 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"
```
Klien layanan dibuat dengan salah satu pernyataan berikut. Tak satu pun dari pernyataan secara eksplisit menetapkan pengaturan proxy.
```
DynamoDbClient client = DynamoDbClient.create();
DynamoDbClient client = DynamoDbClient.builder().build();
DynamoDbClient client = DynamoDbClient.builder()
.httpClient(ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.build())
.build())
.build();
```
Pengaturan proxy berikut diselesaikan oleh SDK:
```
Host = SYS_PROP_HOST.com
Port = 2222
Password = SYS_PROP_PASSWORD
UserName = SYS_PROP_USER
Non ProxyHost = null
```
Karena klien layanan memiliki pengaturan proxy default, SDK mencari properti sistem dan kemudian variabel lingkungan. Karena pengaturan properti sistem lebih diutamakan daripada variabel lingkungan, SDK hanya menggunakan properti sistem.
Jika penggunaan properti sistem diubah menjadi `false` seperti yang ditunjukkan dalam kode berikut, SDK hanya menyelesaikan variabel lingkungan.
```
DynamoDbClient client = DynamoDbClient.builder()
.httpClient(ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.useSystemPropertyValues(Boolean.FALSE)
.build())
.build())
.build();
```
Pengaturan proxy yang diselesaikan menggunakan HTTP adalah:
```
Host = ENV_VAR_HOST
Port = 3333
Password = EnvironmentPassword
UserName = EnvironmentUser
Non ProxyHost = environmentnonproxy.host, environmentnonproxy2.host:1234
```
# Konfigurasikan klien HTTP berbasis Apache 5.x
## Akses Apache5 HttpClient
Untuk menggunakan `Apache5HttpClient` Anda harus menambahkan ketergantungan pada **apache5-client** dan secara eksplisit mengkonfigurasi `Apache5HttpClient` pada klien layanan Anda.
```
software.amazon.awssdk
bom
2.41.0*
pom
import
software.amazon.awssdk
s3
software.amazon.awssdk
apache5-client
```
\$1 Ganti versi yang ditampilkan dalam warna merah dengan versi Java SDK yang ingin Anda gunakan. Temukan yang terbaru di [Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).
### Gunakan dan konfigurasikan `Apache5HttpClient`
Anda dapat mengonfigurasi instance `Apache5HttpClient` bersama dengan membangun klien layanan, atau Anda dapat mengonfigurasi satu instance untuk dibagikan di beberapa klien layanan.
Dengan salah satu pendekatan, Anda menggunakan [Apache5 HttpClient .Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache5/Apache5HttpClient.Builder.html) untuk mengkonfigurasi properti untuk klien HTTP berbasis Apache 5.
#### Praktik terbaik: dedikasikan HttpClient instance Apache5 ke klien layanan
Jika Anda perlu mengonfigurasi instance`Apache5HttpClient`, kami sarankan Anda membuat `Apache5HttpClient` 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 `Apache5HttpClient` instance tidak ditutup saat tidak lagi diperlukan.
Contoh berikut membuat S3Client dan mengkonfigurasi instance tertanam `Apache5HttpClient` dengan nilai MaxConnections dan ConnectionTimeout. Contoh HTTP dibuat menggunakan `httpClientBuilder` metode`S3Client.Builder`.
**Impor**
```
import software.amazon.awssdk.http.apache5.Apache5HttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Kode**
```
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.
```
#### Pendekatan alternatif: bagikan `Apache5HttpClient` contoh
Untuk membantu menjaga penggunaan sumber daya dan memori lebih rendah untuk aplikasi Anda, Anda dapat mengonfigurasi `Apache5HttpClient` dan membagikannya di beberapa klien layanan. Kumpulan koneksi HTTP akan dibagikan, yang menurunkan penggunaan sumber daya.
**catatan**
Ketika sebuah `Apache5HttpClient` 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 Apache yang digunakan oleh dua klien layanan. `ApacheHttpClient`Instance yang dikonfigurasi diteruskan ke metode HttpClient dari setiap pembangun. 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.apache5.Apache5HttpClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.s3.S3Client;
```
**Kode**
```
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.
```