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

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

Retrizzatore standard

Retry.Standard retryer è l'aws.Retryerimplementazione 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:

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 per i dettagli su quali errori sono considerati riutilizzabili dall'implementazione standard di retryer.

NopRetryer

Le leggi. NopRetryerè un'aws.Retryerimplementazione 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

L'SDK fornisce una serie di utilità di supporto che completano un'aws.Retryerimplementazione 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.

Limitazione del numero massimo di tentativi

Si usa retry. AddWithMaxAttemptsper completare un'aws.Retryerimplementazione per impostare il numero massimo di tentativi sul valore desiderato.

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

Si usa retry. AddWithMaxBackoffDelayper completare un'aws.Retryerimplementazione 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

Si utilizza retry. AddWithErrorCodesper completare un'aws.Retryerimplementazione 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

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

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

L'implementazione predefinita è parametrizzata come segue (come modificare ogni impostazione):

Se ritieni che il comportamento predefinito non soddisfi le esigenze dell'applicazione, puoi disabilitarlo con RateLimit.None.

Esempio: limitatore di velocità modificato

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

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

Si utilizza il pacchetto context per impostare timeout o scadenze quando si richiama un'operazione del client di servizio. Usa il contesto. WithDeadlineper 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. 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

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
}