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à.

# Tentativi e timeout
<a name="configure-retries-timeouts"></a>

 AWS SDK per Go Consente di configurare il comportamento di ripetizione delle richieste ai servizi HTTP. Per impostazione predefinita, i client di servizio utilizzano [Retry.Standard come retryer](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#Standard) predefinito. Se la configurazione o il comportamento predefiniti non soddisfano i requisiti dell'applicazione, è possibile modificare la configurazione di retryer o fornire un'implementazione retryer personalizzata. 

 AWS SDK per Go Fornisce un'interfaccia [AWS.Retryer](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#Retryer) che definisce l'insieme di metodi richiesti da un'implementazione Retry per l'implementazione. [L'SDK fornisce due implementazioni per i tentativi: retry.standard e aws.](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#Standard) [ NoOpRetryer](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#NoOpRetryer). 

## Retrizzatore standard
<a name="standard-retryer"></a>

 [Retry.Standard retryer](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#Standard) è l'`aws.Retryer`implementazione predefinita utilizzata dai client SDK. Il retryer standard è un retryer a velocità limitata con un numero massimo di tentativi configurabile e la possibilità di ottimizzare la politica di annullamento della richiesta. 

 La tabella seguente definisce i valori predefiniti per questo retryer: 


| Proprietà | Predefinita | 
| --- | --- | 
| Numero massimo di tentativi | 3 | 
| Ritardo massimo di back off | 20 secondi | 

 Quando si verifica un errore riutilizzabile durante l'invocazione della richiesta, il sistema standard utilizzerà la configurazione fornita per ritardare e successivamente riprovare la richiesta. I nuovi tentativi aumentano la latenza complessiva della richiesta ed è necessario configurare retryer se la configurazione predefinita non soddisfa i requisiti dell'applicazione. 

 Consultate la documentazione del pacchetto [retry](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry) per i dettagli su quali errori sono considerati riutilizzabili dall'implementazione standard di retryer. 

## NopRetryer
<a name="nopretryer"></a>

 [Le leggi. NopRetryer](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#NopRetryer)è un'`aws.Retryer`implementazione che viene fornita se si desidera disabilitare tutti i tentativi di nuovo tentativo. Quando si richiama l'operazione di un client di servizio, questo retryer consente di tentare la richiesta una sola volta e qualsiasi errore risultante verrà restituito all'applicazione chiamante. 

## Personalizzazione del comportamento
<a name="customizing-behavior"></a>

 L'SDK fornisce una serie di utilità di supporto che completano un'`aws.Retryer`implementazione e restituisce il retryer fornito con il comportamento di riprova desiderato. È possibile sostituire il retryer predefinito per tutti i client, per client o per operazione, a seconda dei requisiti delle applicazioni. Per vedere altri esempi che mostrano come eseguire questa operazione, consulta gli esempi di documentazione del pacchetto [retry](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry). 

**avvertimento**  
 Se si specifica un'`aws.Retryer`implementazione globale utilizzando`config.WithRetryer`, è necessario assicurarsi di restituire una nuova istanza di `aws.Retryer` ogni chiamata. In questo modo non creerai un bucket di token di riprova globale su tutti i client di servizio. 

### Limitazione del numero massimo di tentativi
<a name="limiting-the-max-number-of-attempts"></a>

 Si usa [retry. AddWithMaxAttempts](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#AddWithMaxAttempts)per completare un'`aws.Retryer`implementazione per impostare il numero massimo di tentativi sul valore desiderato. 

**avvertimento**  
 L'utilizzo `retry.AddWithMaxAttempts` con un valore pari a zero consentirà all'SDK di riprovare tutti gli errori riproducibili finché la richiesta non avrà esito positivo o non verrà restituito un errore non riproducibile. **Consentire all'SDK di riprovare all'infinito può comportare carichi di lavoro inutili e cicli di fatturazione gonfiati.** 

```
import "context"
import "github.com/aws/aws-sdk-go-v2/aws/retry"
import "github.com/aws/aws-sdk-go-v2/config"
import "github.com/aws/aws-sdk-go-v2/service/s3"

// ...

// MaxAttempts will be infinite (will retry indefinitely)
cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRetryer(func() aws.Retryer {
    return retry.AddWithMaxAttempts(retry.NewStandard(), 0)
}))
if err != nil {
    return err
}

client := s3.NewFromConfig(cfg)
```

 Tieni presente che l'istanziazione di un retryer utilizzando opzioni funzionali per l'impostazione diretta avrà un comportamento leggermente diverso. MaxAttempts Più specificamente, l'impostazione di un valore inferiore o uguale a zero farà sì che il retryer utilizzi il massimo predefinito di 3 tentativi, anziché riprovare all'infinito: 

```
import "context"
import "github.com/aws/aws-sdk-go-v2/aws/retry"
import "github.com/aws/aws-sdk-go-v2/config"
import "github.com/aws/aws-sdk-go-v2/service/s3"

// ...

// MaxAttempts will default to 3
cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRetryer(func() aws.Retryer {
    return retry.NewStandard(func(o *retry.StandardOptions) {
        o.MaxAttempts = 0
    })
}))
if err != nil {
    return err
}

client := s3.NewFromConfig(cfg)
```

### Limitazione del ritardo massimo di backoff
<a name="limiting-the-max-back-off-delay"></a>

 Si usa [retry. AddWithMaxBackoffDelay](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#AddWithMaxBackoffDelay)per completare un'`aws.Retryer`implementazione e limitare il ritardo massimo consentito tra un tentativo e l'altro di una richiesta fallita. 

 Ad esempio, è possibile utilizzare il codice seguente per eseguire il wrapping del client retryer standard con un ritardo massimo desiderato di cinque secondi: 

```
import "context"
import "time"
import "github.com/aws/aws-sdk-go-v2/aws/retry"
import "github.com/aws/aws-sdk-go-v2/config"
import "github.com/aws/aws-sdk-go-v2/service/s3"

// ...

cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRetryer(func() aws.Retryer {
    return retry.AddWithMaxBackoffDelay(retry.NewStandard(), time.Second*5)
}))
if err != nil {
    return err
}

client := s3.NewFromConfig(cfg)
```

### Riprova i codici di errore API aggiuntivi
<a name="retry-additional-api-error-codes"></a>

 Si utilizza [retry. AddWithErrorCodes](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#AddWithErrorCodes)per completare un'`aws.Retryer`implementazione e includere codici di errore API aggiuntivi che dovrebbero essere considerati riutilizzabili. 

 Ad esempio, puoi utilizzare il codice seguente per inserire il client retryer standard in modo da includere l'eccezione Amazon `NoSuchBucketException` S3 come riutilizzabile. 

```
import "context"
import "time"
import "github.com/aws/aws-sdk-go-v2/aws/retry"
import "github.com/aws/aws-sdk-go-v2/config"
import "github.com/aws/aws-sdk-go-v2/service/s3"
import "github.com/aws/aws-sdk-go-v2/service/s3/types"

// ...

cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRetryer(func() aws.Retryer {
    return retry.AddWithErrorCodes(retry.NewStandard(), (*types.NoSuchBucketException)(nil).ErrorCode())
}))
if err != nil {
    return err
}

client := s3.NewFromConfig(cfg)
```

### Limitazione della tariffa lato client
<a name="client-side-rate-limiting"></a>

 AWS SDK per Go Introduce un nuovo meccanismo di limitazione della velocità lato client nella politica di ripetizione dei tentativi standard per allinearsi al comportamento moderno. SDKs [Questo comportamento è controllato dal campo delle opzioni di un retryer. [RateLimiter](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#RateLimiter)](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#StandardOptions) 

 A RateLimiter funziona come un token bucket con una capacità prestabilita, laddove i tentativi di operazione falliti consumano i token. Un nuovo tentativo che tenta di consumare più token di quelli disponibili comporta un fallimento dell'operazione con a. [QuotaExceededError](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/ratelimit#QuotaExceededError) 

 L'implementazione predefinita è parametrizzata come segue (come modificare ogni impostazione): 
+  una capacità di 500 (imposta il valore di RateLimiter on StandardOptions using) [NewTokenRateLimit](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/ratelimit#NewTokenRateLimit) 
+  un nuovo tentativo causato da un timeout costa 10 token (impostato su) RetryTimeoutCost StandardOptions 
+  un nuovo tentativo causato da altri errori costa 5 token (impostato su) RetryCost StandardOptions 
+  un'operazione che riesce al primo tentativo aggiunge 1 token (impostato su) NoRetryIncrement StandardOptions 
  +  le operazioni che hanno esito positivo al secondo o successivo tentativo non aggiungono nuovamente alcun token 

 Se ritieni che il comportamento predefinito non soddisfi le esigenze dell'applicazione, puoi disabilitarlo con [RateLimit.None](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/ratelimit#pkg-variables). 

#### Esempio: limitatore di velocità modificato
<a name="example-modified-rate-limiter"></a>

```
import (
    "context"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/aws/ratelimit"
    "github.com/aws/aws-sdk-go-v2/aws/retry"
    "github.com/aws/aws-sdk-go-v2/config"
)

// ...

cfg, err := config.LoadDefaultConfig(context.Background(), config.WithRetryer(func() aws.Retryer {
    return retry.NewStandard(func(o *retry.StandardOptions) {
        // Makes the rate limiter more permissive in general. These values are
        // arbitrary for demonstration and may not suit your specific
        // application's needs.
        o.RateLimiter = ratelimit.NewTokenRateLimit(1000)
        o.RetryCost = 1
        o.RetryTimeoutCost = 3
        o.NoRetryIncrement = 10
    })
}))
```

#### Esempio: nessun limite di velocità utilizzando RateLimit.None
<a name="example-no-rate-limit-using-ratelimitnone"></a>

```
import (
    "context"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/aws/ratelimit"
    "github.com/aws/aws-sdk-go-v2/aws/retry"
    "github.com/aws/aws-sdk-go-v2/config"
)

// ...

cfg, err := config.LoadDefaultConfig(context.Background(), config.WithRetryer(func() aws.Retryer {
    return retry.NewStandard(func(o *retry.StandardOptions) {
        o.RateLimiter = ratelimit.None
    })
}))
```

## Timeout
<a name="timeouts"></a>

 Si utilizza il pacchetto [context](https://golang.org/pkg/context/) per impostare timeout o scadenze quando si richiama un'operazione del client di servizio. [Usa il contesto. WithDeadline](https://golang.org/pkg/context/#WithDeadline)per riassumere il contesto dell'applicazione e fissare una scadenza a un'ora specifica entro la quale l'operazione richiamata deve essere completata. [Per impostare un timeout dopo un determinato `time.Duration` contesto di utilizzo. WithTimeout](https://golang.org/pkg/context/#WithTimeout). L'SDK passa il fornito `context.Context` al client di trasporto HTTP quando richiama un'API di servizio. Se il contesto passato all'SDK viene annullato o viene annullato durante l'invocazione dell'operazione, l'SDK non ritenterà ulteriormente la richiesta e tornerà all'applicazione chiamante. È necessario gestire l'annullamento del contesto in modo appropriato nell'applicazione nei casi in cui il contesto fornito all'SDK sia stato annullato. 

### Impostazione di un timeout
<a name="setting-a-timeout"></a>

 L'esempio seguente mostra come impostare un timeout per l'operazione di un client di servizio. 

```
import "context"
import "time"

// ...

ctx := context.TODO() // or appropriate context.Context value for your application

client := s3.NewFromConfig(cfg)

// create a new context from the previous ctx with a timeout, e.g. 5 seconds
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()

resp, err := client.GetObject(ctx, &s3.GetObjectInput{
    // input parameters
})
if err != nil {
    // handle error
}
```