Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Configurare il comportamento dei tentativi in AWS SDK for Java 2.x
Le chiamate a Servizi AWS possono fallire occasionalmente per motivi imprevisti. Alcuni errori, come la limitazione (frequenza superata) o gli errori transitori, potrebbero avere esito positivo se la chiamata viene ritentata. AWS SDK for Java 2.x Dispone di un meccanismo integrato per rilevare tali errori e riprovare automaticamente la chiamata, abilitato di default per tutti i client.
Questa pagina descrive come funziona, come configurare le diverse modalità e personalizzare il comportamento dei tentativi.
## Strategie di nuovo tentativo
Una strategia di ripetizione dei tentativi è un meccanismo utilizzato nell'SDK per implementare nuovi tentativi. Ogni client SDK dispone di una strategia di riprova creata in fase di compilazione che non può essere modificata dopo la creazione del client.
La strategia di riprova ha le seguenti responsabilità.
+ Classificate le eccezioni come riprovabili o meno.
+ Calcola il ritardo suggerito per attendere prima del tentativo successivo.
+ Mantieni un [token bucket](https://en.wikipedia.org/wiki/Token_bucket) che fornisca un meccanismo per bloccare i nuovi tentativi quando una grande percentuale di richieste ha esito negativo e i nuovi tentativi non hanno esito positivo.
**Nota**
*Prima del rilascio delle *strategie* di riprova con la versione 2.26.0 dell'SDK, le politiche di riprova fornivano il meccanismo di riprova dell'SDK.* *L'API retry *policy* è costituita dalla [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)classe principale del `software.amazon.awssdk.core.retry` pacchetto, mentre il pacchetto contiene gli elementi dell'API retry strategy. `[software.amazon.awssdk.retries](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/package-summary.html)`*
L'API retry strategy è stata introdotta come parte dell' AWS ampio sforzo volto a unificare le interfacce e il comportamento dei componenti principali di. SDKs
L'SDK for Java 2.x include tre strategie di riprova integrate: standard, legacy e adattiva. Tutte e tre le strategie di riprova sono preconfigurate per riprovare una serie di eccezioni riprovabili. Esempi di errori riutilizzabili sono i timeout dei socket, la limitazione sul lato del servizio, gli errori di blocco simultanei o ottimistici e gli errori temporanei del servizio.
### Strategia di riprova standard
La [strategia di riprova standard](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/StandardRetryStrategy.html) è l'`RetryStrategy`implementazione consigliata per i normali casi d'uso. A differenza della`AdaptiveRetryStrategy`, la strategia standard è generalmente utile in tutti i casi d'uso con nuovi tentativi.
Per impostazione predefinita, la strategia di ripetizione standard esegue le seguenti operazioni.
+ Riprova in base alle condizioni configurate in fase di compilazione. Puoi regolarlo con`[StandardRetryStrategy.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/StandardRetryStrategy.Builder.html)#retryOnException`.
+ Riprova 2 volte per un totale di 3 tentativi. Puoi regolarlo con`StandardRetryStrategy.Builder#maxAttempts(int)`.
+ Per le eccezioni che non prevedono il throttling, utilizza la strategia di `[BackoffStrategy](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/api/BackoffStrategy.html)#exponentialDelay` backoff, con un ritardo base di 100 millisecondi e un ritardo massimo di 20 secondi. Puoi `StandardRetryStrategy.Builder#backoffStrategy` regolarlo con.
+ Per le eccezioni relative al throttling, utilizza la strategia di `BackoffStrategy#exponentialDelay` backoff, con un ritardo base di 1 secondo e un ritardo massimo di 20 secondi. Puoi regolarlo con. `StandardRetryStrategy.Builder#throttlingBackoffStrategy`
+ Interrompe il circuito (disabilita i nuovi tentativi) in caso di gravi guasti a valle. Il primo tentativo viene sempre eseguito, solo i nuovi tentativi sono disabilitati. Regola con`StandardRetryStrategy.Builder#circuitBreakerEnabled`.
### Strategia preesistente di nuovi tentativi
La [precedente strategia di ripetizione](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/LegacyRetryStrategy.html) dei tentativi è `RetryStrategy` destinata ai casi d'uso normali, tuttavia è obsoleta a favore di. `StandardRetryStrategy` Questa è la strategia di riprova predefinita utilizzata dai clienti quando non si specifica un'altra strategia.
È caratterizzata dal fatto che le eccezioni di throttling e non throttling vengono trattate in modo diverso, per le eccezioni di throttling il ritardo di base per il backoff è maggiore (500 ms) rispetto al ritardo di base per le eccezioni senza limitazione (100 ms) e le eccezioni di throttling non influiscono sullo stato del token bucket.
L'esperienza nell'uso di questa strategia su larga scala ha dimostrato che non è particolarmente migliore della strategia di riprova standard. AWS Inoltre, non riesce a proteggere i servizi a valle dalle tempeste di tentativi ripetuti e può portare alla carenza di risorse da parte del client.
Per impostazione predefinita, la strategia di ripetizione dei tentativi precedente esegue le seguenti operazioni.
+ Riprova in base alle condizioni configurate in fase di compilazione. Puoi regolarlo con`[LegacyRetryStrategy.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/LegacyRetryStrategy.Builder.html)#retryOnException`.
+ Riprova 3 volte per un totale di 4 tentativi. Puoi regolarlo con`LegacyRetryStrategy.Builder#maxAttempts(int)`.
+ Per le eccezioni che non prevedono il throttling, utilizza la strategia di `BackoffStrategy#exponentialDelay` backoff, con un ritardo base di 100 millisecondi e un ritardo massimo di 20 secondi. Puoi regolarlo con `LegacyRetryStrategy.Builder#backoffStrategy.`
+ Per le eccezioni di limitazione, utilizza la strategia di `BackoffStrategy#exponentialDelay` backoff, con un ritardo base di 500 millisecondi e un ritardo massimo di 20 secondi. Puoi regolarlo `LegacyRetryStrategy.Builder#throttlingBackoffStrategy` con.
+ Interrompe il circuito (disabilita i nuovi tentativi) in caso di gravi guasti a valle. L'interruzione del circuito non impedisce mai il successo del primo tentativo. È possibile modificare questo comportamento con`LegacyRetryStrategy.Builder#circuitBreakerEnabled`.
+ Lo stato dell'interruttore automatico non è influenzato dalle eccezioni di limitazione.
### Strategia adattiva di nuovi tentativi
La [strategia adattiva di riprova](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/AdaptiveRetryStrategy.html) è `RetryStrategy` adatta ai casi d'uso con un elevato livello di vincoli di risorse.
La strategia adattiva di riprova include tutte le funzionalità della strategia standard e aggiunge un limitatore di velocità sul lato client che misura la frequenza delle richieste limitate rispetto alle richieste non limitate. La strategia utilizza questa misurazione per rallentare le richieste nel tentativo di rimanere entro una larghezza di banda sicura, causando idealmente zero errori di limitazione.
Per impostazione predefinita, la strategia di ripetizione adattiva esegue le seguenti operazioni.
+ Riprova in base alle condizioni configurate in fase di compilazione. Puoi regolarlo con`[AdaptiveRetryStrategy.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/AdaptiveRetryStrategy.Builder.html)#retryOnException`.
+ Riprova 2 volte per un totale di 3 tentativi. Puoi regolarlo con`AdaptiveRetryStrategy.Builder#maxAttempts(int)`.
+ Utilizza un ritardo di backoff dinamico basato sul carico corrente rispetto alla risorsa a valle.
+ Effettua l'interruzione del circuito (disabilitando i nuovi tentativi) in caso di un numero elevato di guasti a valle. L'interruzione del circuito può impedire un secondo tentativo in scenari di interruzione per proteggere il servizio a valle.
**avvertimento**
La strategia di ripetizione adattiva presuppone che il client lavori su una singola risorsa (ad esempio, una tabella DynamoDB o un bucket Amazon S3).
Se si utilizza un singolo client per più risorse, le limitazioni o le interruzioni associate a una risorsa determinano un aumento della latenza e degli errori quando il client accede a tutte le altre risorse. Quando utilizzi la strategia di ripetizione adattiva, ti consigliamo di utilizzare un singolo client per ogni risorsa.
Si consiglia inoltre di utilizzare questa strategia in situazioni in cui tutti i client utilizzano la strategia adattiva di ripetizione dei tentativi rispetto alla risorsa.
**Importante**
Il rilascio delle strategie di ripetizione con la versione 2.26.0 di Java SDK include il nuovo valore di enumerazione. [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) La `ADAPTIVE_V2` modalità corregge un errore che non è riuscito a ritardare il primo tentativo quando in precedenza erano stati rilevati errori di limitazione.
Con la versione 2.26.0, gli utenti ottengono automaticamente il comportamento della `ADAPTIVE_V2` modalità impostando la modalità come `adaptive` con una variabile di ambiente, una proprietà di sistema o un'impostazione del profilo. Non esiste alcun `adaptive_v2` valore per queste impostazioni. Per informazioni su come impostare la modalità, vedere la [Specificare una strategia](#retry-strategies-specify) sezione seguente.
Gli utenti possono ottenere il comportamento precedente impostando la modalità nel codice utilizzando`RetryMode.ADAPTIVE`.
### Riepilogo: confronto dei valori predefiniti della strategia Retry
La tabella seguente mostra i valori predefiniti per le proprietà di ogni strategia di nuovo tentativo.
| Strategia | Numero massimo di tentativi | Ritardo di base per errori che non riguardano la limitazione | Ritardo di base per errori di limitazione | Dimensioni del bucket token | Costo del token per ogni nuovo tentativo senza limitazione | Costo del token per ogni nuovo tentativo di limitazione |
| --- | --- | --- | --- | --- | --- | --- |
| Standard | 3 | 100 ms | 1000 ms | 500 | 5 | 5 |
| Legacy | 4 | 100 ms | 500 ms | 500 | 5 | 0 |
| Adattabile | 3 | 100 ms | 100 ms | 500 | 5 | 5 |
**Nota**
I client DynamoDB utilizzano un numero massimo di tentativi predefinito di 8 per tutte le strategie di ripetizione, che è superiore ai valori mostrati nella tabella precedente per gli altri client. Servizio AWS
## Specificare una strategia
Avete quattro modi per specificare una strategia per il vostro cliente di assistenza.
### In codice
Quando crei un client, puoi configurare un'espressione lambda con una strategia di riprova. Il seguente frammento configura una strategia di riprova standard che utilizza valori predefiniti su un client di servizio DynamoDB.
```
DynamoDbClient client = DynamoDbClient.builder()
.overrideConfiguration(o -> o.retryStrategy(RetryMode.STANDARD))
.build();
```
È possibile specificare o al posto di. `RetryMode.LEGACY` `RetryMode.ADAPTIVE` `RetryMode.STANDARD`
### Come impostazione del profilo
Includi `retry_mode` come impostazione del profilo nel [file di AWS configurazione condiviso](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html). `legacy`Specificare `standard` o `adaptive` come valore. Se impostata come impostazione del profilo, tutti i client di servizio creati mentre il profilo è attivo utilizzano la strategia di ripetizione dei tentativi specificata con valori predefiniti. È possibile ignorare questa impostazione configurando una strategia di nuovo tentativo nel codice, come mostrato in precedenza.
Con il seguente profilo, tutti i client di servizio utilizzano la strategia di riprova standard.
```
[profile dev]
region = us-east-2
retry_mode = standard
```
### Come proprietà del sistema JVM
È possibile configurare una strategia di riprova per tutti i client di servizio, a meno che non sia sovrascritta nel codice, utilizzando la proprietà di sistema. `aws.retryMode` Specificare `standard` o come `legacy` valore. `adaptive`
Utilizzate lo `-D` switch quando richiamate Java, come illustrato nel comando seguente.
```
java -Daws.retryMode=standard ...
```
In alternativa, impostate la proprietà di sistema nel codice *prima di* creare qualsiasi client, come mostrato nel frammento seguente.
```
public void main(String[] args) {
// Set the property BEFORE any AWS service clients are created.
System.setProperty("aws.retryMode", "standard");
...
}
```
### Con una variabile di ambiente
È inoltre possibile utilizzare la variabile di `AWS_RETRY_MODE` ambiente con un valore di `standard``legacy`, o`adaptive`. Analogamente all'impostazione del profilo o alla proprietà del sistema JVM, la variabile di ambiente configura tutti i client di servizio con la modalità di riprova specificata, a meno che non si configuri un client nel codice.
Il comando seguente imposta la modalità retry `standard` per la sessione di shell corrente.
```
export AWS_RETRY_MODE=standard
```
## Personalizza una strategia
Puoi personalizzare qualsiasi strategia di nuovo tentativo impostando il numero massimo di tentativi, la strategia di backoff e le eccezioni che possono essere riprovate. È possibile personalizzare quando si crea una strategia di ripetizione dei tentativi o quando si crea un client utilizzando un generatore di override che consente ulteriori perfezionamenti della strategia configurata.
### Personalizza il numero massimo di tentativi
È possibile configurare il numero massimo di tentativi durante la costruzione del client, come illustrato nella seguente dichiarazione. L'istruzione seguente personalizza la strategia di ripetizione dei tentativi predefinita per il client fino a un massimo di 5 tentativi, un primo tentativo più 4 tentativi.
```
DynamoDbClient client = DynamoDbClient.builder()
.overrideConfiguration(o -> o.retryStrategy(b -> b.maxAttempts(5)))
.build();
```
In alternativa, è possibile creare la strategia e fornirla al client come illustrato nel seguente esempio di codice. Il codice seguente sostituisce i 3 tentativi massimi standard con 10 e configura un client DynamoDB con la strategia personalizzata.
```
StandardRetryStrategy strategy = AwsRetryStrategy.standardRetryStrategy()
.toBuilder()
.maxAttempts(10)
.build();
DynamoDbClient client = DynamoDbClient.builder()
.overrideConfiguration(o -> o.retryStrategy(strategy))
.build();
```
**avvertimento**
Si consiglia di configurare ogni client con un'istanza unica. `RetryStrategy` Se un'`RetryStrategy`istanza è condivisa, gli errori in un client potrebbero influire sul comportamento dei tentativi nell'altro.
È inoltre possibile impostare il numero massimo di tentativi per tutti i client utilizzando [impostazioni esterne](https://docs.aws.amazon.com/sdkref/latest/guide/feature-retry-behavior.html) anziché codice. È possibile configurare questa impostazione come descritto nella [Specificare una strategia](#retry-strategies-specify) sezione.
### Personalizza le eccezioni riprovabili
È possibile configurare eccezioni aggiuntive che attivano nuovi tentativi durante la creazione del client. Questa personalizzazione viene fornita per i casi limite in cui vengono generate eccezioni che non sono incluse nel set predefinito di eccezioni riutilizzabili.
I `retryOnExceptionOrCause` metodi `retryOnException` and **aggiungono** nuovi tipi di eccezione al set esistente di eccezioni riutilizzabili; non sostituiscono il set predefinito. Ciò consente di estendere il comportamento dei tentativi mantenendo le funzionalità di ripetizione predefinite dell'SDK.
Il `retryOnExceptionOrCause` metodo aggiunge un'eccezione riutilizzabile se l'SDK genera l'eccezione diretta o se l'eccezione viene inserita come causa in un'altra eccezione.
Il seguente frammento di codice mostra i metodi utilizzati per personalizzare le eccezioni relative ai tentativi: e. `retryOnException` `retryOnExceptionOrCause` I `retryOnExceptionOrCause` metodi aggiungono un'eccezione riutilizzabile se l'SDK genera l'eccezione diretta o se l'eccezione è inclusa.
```
DynamoDbClient client = DynamoDbClient.builder()
.overrideConfiguration(o -> o.retryStrategy(
b -> b.retryOnException(EdgeCaseException.class)
.retryOnExceptionOrCause(WrappedEdgeCaseException.class)))
.build();
```
**Importante**
I nuovi tentativi sono disabilitati per il client asincrono Kinesis quando si chiama [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))un metodo, indipendentemente dalla configurazione della strategia di ripetizione.
### Personalizza la strategia di backoff
È possibile creare la strategia di backoff e fornirla al cliente.
Il codice seguente ne crea una `BackoffStrategy` che sostituisce la strategia di backoff esponenziale con ritardo esponenziale predefinita della strategia standard.
```
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();
```
## Migrazione da `RetryPolicy` a `RetryStrategy`
`RetryPolicy`(l'API retry policy) sarà supportata per il prossimo futuro. Se attualmente utilizzi un'istanza di `RetryPolicy` per configurare il tuo client, tutto funzionerà come prima. Dietro le quinte, Java SDK lo adatta a un. `RetryStrategy` Le nuove interfacce retry strategy offrono le stesse funzionalità di un `RetryPolicy` ma vengono create e configurate in modo diverso.