Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Konfigurasikan perilaku coba lagi di AWS SDK for Java 2.x
Panggilan ke Layanan AWS terkadang gagal karena alasan yang tidak terduga. Kesalahan tertentu, seperti pelambatan (laju terlampaui) atau kesalahan sementara, mungkin berhasil jika panggilan dicoba ulang. Ini AWS SDK for Java 2.x memiliki mekanisme bawaan untuk mendeteksi kesalahan tersebut dan secara otomatis mencoba kembali panggilan yang diaktifkan secara default untuk semua klien.
Halaman ini menjelaskan cara kerjanya, cara mengonfigurasi mode yang berbeda, dan menyesuaikan perilaku coba lagi.
## Coba lagi strategi
Strategi coba lagi adalah mekanisme yang digunakan dalam SDK untuk mengimplementasikan percobaan ulang. Setiap klien SDK memiliki strategi coba ulang yang dibuat pada waktu pembuatan yang tidak dapat dimodifikasi setelah klien dibuat.
Strategi coba lagi memiliki tanggung jawab sebagai berikut.
+ Klasifikasi pengecualian sebagai dapat dicoba kembali atau tidak.
+ Hitung penundaan yang disarankan untuk menunggu sebelum upaya berikutnya.
+ Pertahankan [bucket token](https://en.wikipedia.org/wiki/Token_bucket) yang menyediakan mekanisme untuk menghentikan percobaan ulang ketika sebagian besar permintaan gagal dan percobaan ulang tidak berhasil.
**catatan**
Sebelum rilis *strategi* coba lagi dengan SDK versi 2.26.0, *kebijakan* coba lagi menyediakan mekanisme coba lagi di SDK. API *kebijakan* coba lagi terdiri dari [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/retry/RetryPolicy.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/retry/RetryPolicy.html)kelas inti dalam `software.amazon.awssdk.core.retry` paket, sedangkan `[software.amazon.awssdk.retries](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/package-summary.html)` paket berisi elemen API *strategi* coba lagi.
API strategi coba lagi diperkenalkan sebagai bagian dari upaya AWS luas untuk menyatukan antarmuka dan perilaku komponen inti dari. SDKs
SDK for Java 2.x memiliki tiga strategi coba ulang bawaan: standar, warisan, dan adaptif. Ketiga strategi coba lagi telah dikonfigurasi sebelumnya untuk mencoba lagi pada serangkaian pengecualian yang dapat dicoba ulang. Contoh kesalahan yang dapat dicoba ulang adalah batas waktu soket, pelambatan sisi layanan, kegagalan kunci konkurensi atau optimis, dan kesalahan layanan sementara.
### Strategi coba lagi standar
[Strategi coba lagi standar](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/StandardRetryStrategy.html) adalah `RetryStrategy` implementasi yang direkomendasikan untuk kasus penggunaan normal. Berbeda dengan`AdaptiveRetryStrategy`, strategi standar umumnya berguna di semua kasus penggunaan coba lagi.
Secara default, strategi coba lagi standar melakukan hal berikut.
+ Mencoba lagi pada kondisi yang dikonfigurasi pada waktu pembuatan. Anda dapat menyesuaikan ini dengan`[StandardRetryStrategy.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/StandardRetryStrategy.Builder.html)#retryOnException`.
+ Mencoba lagi 2 kali untuk total 3 upaya. Anda dapat menyesuaikan ini dengan`StandardRetryStrategy.Builder#maxAttempts(int)`.
+ Untuk pengecualian non-throttling, ia menggunakan strategi `[BackoffStrategy](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/api/BackoffStrategy.html)#exponentialDelay` backoff, dengan penundaan dasar 100 milidetik dan penundaan maksimal 20 detik. Anda dapat menyesuaikan ini dengan`StandardRetryStrategy.Builder#backoffStrategy`.
+ Untuk pengecualian throttling, ia menggunakan strategi `BackoffStrategy#exponentialDelay` backoff, dengan penundaan dasar 1 detik dan penundaan maksimal 20 detik. Anda dapat menyesuaikan ini dengan`StandardRetryStrategy.Builder#throttlingBackoffStrategy`.
+ Melakukan pemutusan sirkuit (menonaktifkan percobaan ulang) jika terjadi kegagalan hilir yang tinggi. Upaya pertama selalu dijalankan, hanya percobaan ulang yang dinonaktifkan. Sesuaikan dengan`StandardRetryStrategy.Builder#circuitBreakerEnabled`.
### Strategi coba lagi warisan
[Strategi coba lagi warisan](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/LegacyRetryStrategy.html) adalah `RetryStrategy` untuk kasus penggunaan normal, namun tidak digunakan lagi untuk mendukung. `StandardRetryStrategy` Ini adalah strategi coba ulang default yang digunakan oleh klien ketika Anda tidak menentukan strategi lain.
Hal ini ditandai dengan memperlakukan pengecualian throttling dan non-throttling secara berbeda, untuk pengecualian throttling, penundaan dasar untuk backoff lebih besar (500 ms) daripada penundaan dasar untuk pengecualian non-throttling (100 md), dan pengecualian throttling tidak memengaruhi status bucket token.
Pengalaman menggunakan strategi ini dalam skala di dalam AWS telah menunjukkan bahwa tidak terlalu baik daripada strategi coba ulang standar. Selain itu, gagal melindungi layanan hilir dari badai coba lagi dan dapat menyebabkan kelaparan sumber daya di sisi klien.
Secara default, strategi coba lagi lawas melakukan hal berikut.
+ Mencoba lagi pada kondisi yang dikonfigurasi pada waktu pembuatan. Anda dapat menyesuaikan ini dengan`[LegacyRetryStrategy.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/LegacyRetryStrategy.Builder.html)#retryOnException`.
+ Mencoba lagi 3 kali untuk total 4 upaya. Anda dapat menyesuaikan ini dengan`LegacyRetryStrategy.Builder#maxAttempts(int)`.
+ Untuk pengecualian non-throttling, ia menggunakan strategi `BackoffStrategy#exponentialDelay` backoff, dengan penundaan dasar 100 milidetik dan penundaan maksimal 20 detik. Anda dapat menyesuaikan ini dengan `LegacyRetryStrategy.Builder#backoffStrategy.`
+ Untuk pengecualian throttling, ia menggunakan strategi `BackoffStrategy#exponentialDelay` backoff, dengan penundaan dasar 500 milidetik dan penundaan maksimal 20 detik. Anda dapat menyesuaikan ini dengan`LegacyRetryStrategy.Builder#throttlingBackoffStrategy`.
+ Melakukan pemutusan sirkuit (menonaktifkan percobaan ulang) jika terjadi kegagalan hilir yang tinggi. Pemutusan sirkuit tidak pernah mencegah upaya pertama yang berhasil. Anda dapat menyesuaikan perilaku ini dengan`LegacyRetryStrategy.Builder#circuitBreakerEnabled`.
+ Keadaan pemutus sirkuit tidak terpengaruh oleh pengecualian pelambatan.
### Strategi coba lagi adaptif
[Strategi coba lagi adaptif](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/AdaptiveRetryStrategy.html) adalah `RetryStrategy` untuk kasus penggunaan dengan tingkat kendala sumber daya yang tinggi.
Strategi coba ulang adaptif mencakup semua fitur strategi standar dan menambahkan pembatas tingkat sisi klien yang mengukur tingkat permintaan yang dibatasi dibandingkan dengan permintaan yang tidak dibatasi. Strategi ini menggunakan pengukuran ini untuk memperlambat permintaan dalam upaya untuk tetap berada dalam bandwidth yang aman, idealnya menyebabkan kesalahan pelambatan nol.
Secara default, strategi coba ulang adaptif melakukan hal berikut.
+ Mencoba lagi pada kondisi yang dikonfigurasi pada waktu pembuatan. Anda dapat menyesuaikan ini dengan`[AdaptiveRetryStrategy.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/AdaptiveRetryStrategy.Builder.html)#retryOnException`.
+ Mencoba lagi 2 kali untuk total 3 upaya. Anda dapat menyesuaikan ini dengan`AdaptiveRetryStrategy.Builder#maxAttempts(int)`.
+ Menggunakan penundaan backoff dinamis yang didasarkan pada beban saat ini terhadap sumber daya hilir.
+ Melakukan pemutusan sirkuit (menonaktifkan percobaan ulang) ketika ada banyak kegagalan hilir. Pemutusan sirkuit dapat mencegah upaya kedua dalam skenario pemadaman untuk melindungi layanan hilir.
**Awas**
Strategi coba ulang adaptif mengasumsikan bahwa klien bekerja melawan satu sumber daya (misalnya, satu tabel DynamoDB atau satu bucket Amazon S3).
Jika Anda menggunakan satu klien untuk beberapa sumber daya, pembatasan atau pemadaman yang terkait dengan satu sumber daya menghasilkan peningkatan latensi dan kegagalan saat klien mengakses semua sumber daya lainnya. Saat Anda menggunakan strategi coba ulang adaptif, kami sarankan Anda menggunakan satu klien untuk setiap sumber daya.
Kami juga menyarankan Anda menggunakan strategi ini dalam situasi di mana semua klien menggunakan strategi coba ulang adaptif terhadap sumber daya.
**penting**
Rilis strategi coba lagi dengan 2.26.0 dari Java SDK mencakup nilai enumerasi baru. [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/retry/RetryMode.html#ADAPTIVE_V2](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/retry/RetryMode.html#ADAPTIVE_V2) `ADAPTIVE_V2`Mode mengoreksi kesalahan yang gagal menunda upaya pertama saat kesalahan pelambatan terdeteksi sebelumnya.
Dengan rilis 2.26.0, pengguna secara otomatis mendapatkan perilaku `ADAPTIVE_V2` mode dengan mengatur mode seperti `adaptive` variabel lingkungan, properti sistem, atau pengaturan profil. Tidak ada `adaptive_v2` nilai untuk pengaturan ini. Lihat [Tentukan strategi](#retry-strategies-specify) bagian berikut untuk cara mengatur mode.
Pengguna bisa mendapatkan perilaku sebelumnya dengan mengatur mode dalam kode menggunakan`RetryMode.ADAPTIVE`.
### Ringkasan: Perbandingan nilai default strategi coba lagi
Tabel berikut menunjukkan nilai default untuk properti dari setiap strategi coba lagi.
| Strategi | Upaya maksimal | Penundaan dasar untuk kesalahan non-throttling | Penundaan dasar untuk kesalahan pelambatan | Ukuran ember token | Biaya token per percobaan ulang non-throttling | Biaya token per throttling coba lagi |
| --- | --- | --- | --- | --- | --- | --- |
| Standar | 3 | 100 ms | 1000 ms | 500 | 5 | 5 |
| Warisan | 4 | 100 ms | 500 ms | 500 | 5 | 0 |
| Adaptif | 3 | 100 ms | 100 ms | 500 | 5 | 5 |
**catatan**
Klien DynamoDB menggunakan hitungan coba ulang maksimum default 8 untuk semua strategi coba lagi, yang lebih tinggi dari nilai yang ditunjukkan pada tabel di atas untuk klien lain. Layanan AWS
## Tentukan strategi
Anda memiliki empat cara untuk menentukan strategi untuk klien layanan Anda.
### Dalam kode
Saat membangun klien, Anda dapat mengonfigurasi ekspresi lambda dengan strategi coba lagi. Cuplikan berikut mengonfigurasi strategi coba ulang standar yang menggunakan nilai default pada klien layanan DynamoDB.
```
DynamoDbClient client = DynamoDbClient.builder()
.overrideConfiguration(o -> o.retryStrategy(RetryMode.STANDARD))
.build();
```
Anda dapat menentukan `RetryMode.LEGACY` atau `RetryMode.ADAPTIVE` menggantikan`RetryMode.STANDARD`.
### Sebagai pengaturan profil
Sertakan `retry_mode` sebagai pengaturan profil dalam [file AWS konfigurasi bersama](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html). Tentukan `standard``legacy`,, atau `adaptive` sebagai nilai. Saat ditetapkan sebagai pengaturan profil, semua klien layanan yang dibuat saat profil aktif menggunakan strategi coba lagi yang ditentukan dengan nilai default. Anda dapat mengganti pengaturan ini dengan mengonfigurasi strategi coba lagi dalam kode seperti yang ditunjukkan sebelumnya.
Dengan profil berikut, semua klien layanan menggunakan strategi coba ulang standar.
```
[profile dev]
region = us-east-2
retry_mode = standard
```
### Sebagai properti sistem JVM
Anda dapat mengonfigurasi status coba lagi untuk semua klien layanan, kecuali diganti dalam kode, dengan menggunakan properti sistem. `aws.retryMode` Tentukan `standard``legacy`,, atau `adaptive` sebagai nilai.
Gunakan `-D` sakelar saat Anda memanggil Java seperti yang ditunjukkan pada perintah berikut.
```
java -Daws.retryMode=standard ...
```
Atau, atur properti sistem dalam kode *sebelum* membuat klien apa pun seperti yang ditunjukkan pada cuplikan berikut.
```
public void main(String[] args) {
// Set the property BEFORE any AWS service clients are created.
System.setProperty("aws.retryMode", "standard");
...
}
```
### Dengan variabel lingkungan
Anda juga dapat menggunakan variabel `AWS_RETRY_MODE` lingkungan dengan nilai`standard`,`legacy`, atau`adaptive`. Seperti pengaturan profil atau properti sistem JVM, variabel lingkungan mengonfigurasi semua klien layanan dengan mode coba lagi yang ditentukan kecuali Anda mengonfigurasi klien dalam kode.
Perintah berikut menetapkan mode coba lagi `standard` untuk sesi shell saat ini.
```
export AWS_RETRY_MODE=standard
```
## Sesuaikan strategi
Anda dapat menyesuaikan strategi coba lagi dengan menetapkan upaya maksimum, strategi backoff, dan pengecualian yang dapat dicoba ulang. Anda dapat menyesuaikan ketika Anda membangun strategi coba lagi atau ketika Anda membangun klien dengan menggunakan pembangun override yang memungkinkan penyempurnaan lebih lanjut dari strategi yang dikonfigurasi.
### Sesuaikan upaya maksimum
Anda dapat mengkonfigurasi jumlah maksimum upaya selama konstruksi klien seperti yang ditunjukkan dalam pernyataan berikut. Pernyataan berikut menyesuaikan strategi coba ulang default untuk klien hingga maksimal 5 percobaan - percobaan pertama ditambah 4 percobaan ulang.
```
DynamoDbClient client = DynamoDbClient.builder()
.overrideConfiguration(o -> o.retryStrategy(b -> b.maxAttempts(5)))
.build();
```
Atau, Anda dapat membangun strategi dan memberikannya kepada klien seperti pada contoh kode berikut. Kode berikut menggantikan upaya maksimum 3 standar dengan 10 dan mengkonfigurasi klien DynamoDB dengan strategi yang disesuaikan.
```
StandardRetryStrategy strategy = AwsRetryStrategy.standardRetryStrategy()
.toBuilder()
.maxAttempts(10)
.build();
DynamoDbClient client = DynamoDbClient.builder()
.overrideConfiguration(o -> o.retryStrategy(strategy))
.build();
```
**Awas**
Kami menyarankan Anda mengonfigurasi setiap klien dengan `RetryStrategy` instance unik. Jika sebuah `RetryStrategy` instance dibagikan, kegagalan di satu klien dapat memengaruhi perilaku coba lagi di klien lainnya.
Anda juga dapat mengatur jumlah upaya maksimum untuk semua klien dengan menggunakan [pengaturan eksternal](https://docs.aws.amazon.com/sdkref/latest/guide/feature-retry-behavior.html) alih-alih kode. Anda mengonfigurasi pengaturan ini seperti yang dijelaskan di [Tentukan strategi](#retry-strategies-specify) bagian.
### Sesuaikan pengecualian yang dapat dicoba ulang
Anda dapat mengonfigurasi pengecualian tambahan yang memicu percobaan ulang selama konstruksi klien. Kustomisasi ini disediakan untuk kasus tepi di mana pengecualian dilemparkan yang tidak termasuk dalam kumpulan default pengecualian yang dapat dicoba ulang.
`retryOnExceptionOrCause`Metode `retryOnException` dan **menambahkan** jenis pengecualian baru ke kumpulan pengecualian yang dapat dicoba ulang; mereka tidak menggantikan set default. Ini memungkinkan Anda untuk memperluas perilaku coba lagi sambil mempertahankan kemampuan coba ulang default SDK.
`retryOnExceptionOrCause`Metode ini menambahkan pengecualian yang dapat dicoba ulang jika SDK melempar pengecualian langsung atau jika pengecualian dibungkus sebagai penyebab dalam pengecualian lain.
Cuplikan kode berikut menunjukkan metode yang Anda gunakan untuk menyesuaikan pengecualian coba lagi-- dan. `retryOnException` `retryOnExceptionOrCause` `retryOnExceptionOrCause`Metode menambahkan pengecualian yang dapat dicoba ulang jika SDK melempar pengecualian langsung atau jika pengecualian dibungkus.
```
DynamoDbClient client = DynamoDbClient.builder()
.overrideConfiguration(o -> o.retryStrategy(
b -> b.retryOnException(EdgeCaseException.class)
.retryOnExceptionOrCause(WrappedEdgeCaseException.class)))
.build();
```
**penting**
Percobaan ulang dinonaktifkan untuk klien asinkron Kinesis saat Anda memanggil metode, terlepas dari [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/kinesis/KinesisAsyncClient.html#subscribeToShard(software.amazon.awssdk.services.kinesis.model.SubscribeToShardRequest,software.amazon.awssdk.services.kinesis.model.SubscribeToShardResponseHandler)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/kinesis/KinesisAsyncClient.html#subscribeToShard(software.amazon.awssdk.services.kinesis.model.SubscribeToShardRequest,software.amazon.awssdk.services.kinesis.model.SubscribeToShardResponseHandler))konfigurasi strategi coba ulang.
### Sesuaikan strategi backoff
Anda dapat membangun strategi backoff dan menyediakannya kepada klien.
Kode berikut membangun sebuah `BackoffStrategy` yang menggantikan strategi backoff penundaan eksponensial strategi standar default.
```
BackoffStrategy backoffStrategy =
BackoffStrategy.exponentialDelay(Duration.ofMillis(150), // The base delay.
Duration.ofSeconds(15)); // The maximum delay.
DynamoDbClient client = DynamoDbClient.builder()
.overrideConfiguration(o -> o.retryStrategy(
b -> b.backoffStrategy(backoffStrategy)))
.build();
```
## Migrasi dari ke `RetryPolicy` `RetryStrategy`
`RetryPolicy`(API kebijakan coba lagi) akan didukung untuk masa mendatang. Jika saat ini Anda menggunakan instance `RetryPolicy` untuk mengkonfigurasi klien Anda, semuanya akan berfungsi seperti sebelumnya. Di belakang layar, Java SDK menyesuaikannya dengan file. `RetryStrategy` Antarmuka strategi coba lagi yang baru menyediakan fungsionalitas yang sama seperti `RetryPolicy` tetapi dibuat dan dikonfigurasi secara berbeda.