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à.
# Configura i timeout in AWS SDK for Java 2.x
AWS SDK for Java 2.x Fornisce più livelli di configurazione del timeout per aiutarti a creare applicazioni resilienti. L'SDK offre diversi tipi di timeout che interagiscono per ottimizzare le prestazioni e l'affidabilità dell'applicazione.
Esistono due categorie principali di timeout nell'SDK:
+ **Service Client Timeout: timeout** di alto livello che controllano le operazioni delle API
+ **Timeout del client HTTP: timeout di basso livello che controllano le comunicazioni di rete**
## Timeout del client di servizio
I timeout dei client di servizio operano a livello di API e controllano il comportamento generale delle operazioni di servizio, inclusi nuovi tentativi e tentativi multipli.
### Timeout delle chiamate API
Il timeout della chiamata API imposta la quantità di tempo massima per un'intera operazione API, inclusi tutti i tentativi di nuovo tentativo. Questo timeout fornisce un limite rigido al tempo di attesa dell'applicazione per il completamento di un'operazione.
```
S3Client s3Client = S3Client.builder()
.overrideConfiguration(ClientOverrideConfiguration.builder()
.apiCallTimeout(Duration.ofMinutes(2)) // Total time for entire operation, such as when you call the getObject method.
.build())
.build();
```
Caratteristiche principali:
+ Include tutti i tentativi di riprova.
+ Include il tempo di attesa tra un tentativo e l'altro.
+ Fornisce il tempo di attesa massimo assoluto.
+ Impedisce l'esecuzione indefinita delle operazioni.
### Timeout del tentativo di chiamata API
Il timeout del tentativo di chiamata API imposta il tempo massimo per un singolo tentativo di operazione API. Se questo timeout viene superato, l'SDK riprova l'operazione (se i tentativi sono configurati) anziché fallire l'intera chiamata.
```
S3Client s3Client = S3Client.builder()
.overrideConfiguration(ClientOverrideConfiguration.builder()
.apiCallAttemptTimeout(Duration.ofSeconds(30)) // Time for single attempt.
.build())
.build();
```
Caratteristiche principali:
+ Si applica solo ai tentativi individuali.
+ Consente errori e ritentativi rapidi in caso di richieste lente.
+ Deve essere inferiore al timeout della chiamata API.
+ Aiuta a identificare e risolvere problemi transitori.
### Configura i timeout dei client di servizio
Puoi configurare i timeout dei client di servizio a livello globale per tutte le operazioni o per richiesta:
**Configurazione globale:**
```
S3Client s3Client = S3Client.builder()
.overrideConfiguration(b -> b
.apiCallTimeout(Duration.ofSeconds(105L))
.apiCallAttemptTimeout(Duration.ofSeconds(25L)))
.build();
// When you use the s3Client for an API operation, the SDK uses the configured timeout values.
```
**Configurazione per richiesta:**
```
S3Client basicS3Client = S3Client.create();
// The following configuration uses the same settings as shown before, but these settings
// apply to only the `putObject` call. When you use `basicS3Client` in another API call without
// supplying the override configuration, there are no API timeout limits. No timeout limits is the default for the SDK.
AwsRequestOverrideConfiguration overrideConfiguration = AwsRequestOverrideConfiguration.builder()
.apiCallTimeout(Duration.ofSeconds(105L))
.apiCallAttemptTimeout(Duration.ofSeconds(25L))
.build();
basicS3Client.putObject(b -> b
.bucket("amzn-s3-demo-bucket")
.key("example-key")
.overrideConfiguration(overrideConfiguration),
RequestBody.fromString("test"));
```
### Migliori pratiche per i timeout delle API
Per impostazione predefinita, l'SDK for Java 2.x non imposta i timeout delle chiamate API o i timeout dei singoli tentativi di chiamata API. Imposta i timeout sia per i singoli tentativi che per l'intera richiesta. Questo aiuta l'applicazione a fallire rapidamente quando problemi temporanei fanno sì che i tentativi di richiesta richiedano più tempo o quando si verificano problemi irreversibili di rete.
## Timeout del client HTTP
I timeout dei client HTTP operano a livello di rete e controllano vari aspetti della comunicazione HTTP. Questi timeout variano a seconda dell'implementazione del client HTTP utilizzata.
### Timeout di connessione
Il timeout della connessione controlla il tempo di attesa quando si stabilisce una nuova connessione all'endpoint. Servizio AWS
```
// Available with all HTTP clients.
ApacheHttpClient.builder()
.connectionTimeout(Duration.ofSeconds(5L))
.build();
```
Scopo:
+ Evita il blocco dei problemi di connettività di rete.
+ Si guasta rapidamente quando i servizi non sono raggiungibili.
+ Essenziale per le applicazioni che richiedono una gestione tempestiva degli errori.
### Socket Timeout (Apache e client) URLConnection
Il timeout del socket controlla per quanto tempo attendere i dati su una connessione stabilita.
```
ApacheHttpClient.builder()
.socketTimeout(Duration.ofSeconds(30L)) // Time to wait for response data.
.build();
```
### Timeout di lettura e scrittura (client Netty)
Il client Netty fornisce timeout separati per le operazioni di lettura e scrittura:
```
NettyNioAsyncHttpClient.builder()
.readTimeout(Duration.ofSeconds(30L)) // Reading response data.
.writeTimeout(Duration.ofSeconds(30L)) // Writing request data.
.build();
```
### Timeout di negoziazione TLS (client Netty)
Controlla il tempo consentito per la stretta di mano: TLS/SSL
```
NettyNioAsyncHttpClient.builder()
.tlsNegotiationTimeout(Duration.ofSeconds(3L))
.build();
```
### Timeout del pool di connessioni
Alcuni client HTTP forniscono timeout per le operazioni del pool di connessioni:
```
ApacheHttpClient.builder()
.connectionAcquisitionTimeout(Duration.ofSeconds(10L)) // Wait for pool connection.
.connectionTimeToLive(Duration.ofMinutes(5L)) // Maximum connection age.
.connectionMaxIdleTime(Duration.ofSeconds(60L)) // Maximum idle time.
.build()
```
[Configurare i client HTTP](http-configuration.md)contiene ulteriori informazioni sui client HTTP nel AWS SDK for Java 2.x
## Interazioni e gerarchia di timeout
Comprendere come interagiscono i diversi timeout è fondamentale per una corretta configurazione:
### Gerarchia dei timeout
```
API Call Timeout (2 minutes)
├── Retry Attempt 1
│ ├── API Call Attempt Timeout (45 seconds)
│ └── HTTP Client Timeouts
│ ├── Connection Timeout (5 seconds)
│ ├── TLS Negotiation Timeout (3 seconds)
│ └── Read/Write Timeout (30 seconds)
├── Retry Attempt 2
│ └── [Same structure as Attempt 1]
└── Retry Attempt 3
└── [Same structure as Attempt 1]
```
### Regole di configurazione
Timeout della chiamata API ≥ timeout del tentativo di chiamata API
```
// Correct configuration.
.apiCallTimeout(Duration.ofMinutes(2)) // 120 seconds.
.apiCallAttemptTimeout(Duration.ofSeconds(30)) // 30 seconds.
```
Timeout del tentativo di chiamata API ≥ timeout del client HTTP
```
// HTTP client timeouts must be less than attempt timeout.
.apiCallAttemptTimeout(Duration.ofSeconds(30L)) // 30 seconds.
// HTTP client configuration.
.connectionTimeout(Duration.ofSeconds(5L)) // 5 seconds.
.readTimeout(Duration.ofSeconds(25L)) // 25 seconds (< 30).
```
Tieni conto di più tentativi
```
// If you have 3 retry attempts, each taking up to 30 seconds
// API call timeout must be at least 90 seconds plus overhead.
.apiCallTimeout(Duration.ofMinutes(2L)) // 120 seconds.
.apiCallAttemptTimeout(Duration.ofSeconds(30)) // 30 seconds per attempt.
```
## Usa impostazioni di configurazione intelligenti predefinite
L'SDK fornisce impostazioni predefinite intelligenti che configurano automaticamente i valori di timeout appropriati:
```
// Enable smart defaults.
S3Client client = S3Client.builder()
.defaultsMode(DefaultsMode.AUTO) // Automatically choose appropriate defaults.
.build();
// Available modes:
// - STANDARD: Balanced defaults
// - IN_REGION: Optimized for same-region calls
// - CROSS_REGION: Optimized for cross-region calls
// - MOBILE: Optimized for mobile applications
// - AUTO: Automatically detect and choose appropriate mode
// - LEGACY: Provides settings that were used before smart defaults existed.
```
Le impostazioni predefinite intelligenti configurano automaticamente:
+ Valori di timeout della connessione.
+ Valori di timeout della negoziazione TLS.
+ Altre impostazioni del client.
## Riepilogo
Una configurazione efficace del timeout AWS SDK for Java 2.x richiede la comprensione dell'interazione tra i timeout del client di servizio e i timeout del client HTTP:
1. I **timeout dei client di servizio controllano** il comportamento delle API di alto livello.
1. I **timeout dei client HTTP controllano il comportamento di rete di basso livello**.
1. **Una gerarchia adeguata** garantisce che i timeout funzionino insieme in modo efficace.
1. Le **impostazioni predefinite intelligenti** forniscono buoni punti di partenza per la maggior parte delle applicazioni.
Configura i timeout in modo appropriato per il tuo caso d'uso per creare applicazioni che siano resilienti ai problemi di rete e reattive agli utenti.