Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Wiederholversuche und Zeitüberschreitungen

AWS SDK für Go Damit können Sie das Wiederholungsverhalten von Anfragen an HTTP-Dienste konfigurieren. Standardmäßig verwenden Service-Clients Retry.STANDARD als Standard-Wiederholungsversuch. Wenn die Standardkonfiguration oder das Standardverhalten nicht Ihren Anwendungsanforderungen entspricht, können Sie die Retryer-Konfiguration anpassen oder Ihre eigene Retryer-Implementierung bereitstellen.

Das AWS SDK für Go stellt eine AWS.Retryer-Schnittstelle bereit, die den Methodensatz definiert, der für die Implementierung einer Retry-Implementierung erforderlich ist. Das SDK bietet zwei Implementierungen für Wiederholungen: retry.STANDARD und aws. NoOpRetryer.

Standardtrockner

Der Retry.Standard Retryer ist die Standardimplementierung, die von SDK-Clients verwendet wird. aws.Retryer Der Standard-Retryer ist ein Retryer mit begrenzter Geschwindigkeit, einer konfigurierbaren Anzahl von Maximalversuchen und der Möglichkeit, die Rücknahme von Anfragen zu deaktivieren.

In der folgenden Tabelle sind die Standardwerte für diesen Wiederholungsversuch definiert:

Wenn beim Aufrufen Ihrer Anfrage ein Fehler auftritt, der wiederholt werden kann, verwendet der Standard-Wiederholungsversuch die bereitgestellte Konfiguration, um die Anfrage zu verzögern und anschließend erneut zu versuchen. Wiederholungen erhöhen die Gesamtlatenz Ihrer Anfrage, und Sie müssen den Wiederholungsversuch konfigurieren, falls die Standardkonfiguration nicht Ihren Anwendungsanforderungen entspricht.

In der Dokumentation zum Retry-Paket finden Sie Einzelheiten dazu, welche Fehler bei der Standardimplementierung von Retryern als wiederholbar angesehen werden.

NopRetryer

Das war. NopRetryerist eine aws.Retryer Implementierung, die bereitgestellt wird, wenn Sie alle Wiederholungsversuche deaktivieren möchten. Beim Aufrufen eines Service-Client-Vorgangs erlaubt dieser Wiederholungsversuch nur, dass die Anfrage einmal versucht wird, und alle daraus resultierenden Fehler werden an die aufrufende Anwendung zurückgegeben.

Verhalten anpassen

Das SDK stellt eine Reihe von Hilfsprogrammen bereit, die eine aws.Retryer Implementierung umschließen, und gibt den bereitgestellten Wiederholungsversuch mit dem gewünschten Wiederholungsverhalten zurück. Sie können den Standard-Retryer für alle Clients, pro Client oder pro Vorgang überschreiben, je nach den Anforderungen Ihrer Anwendung. Weitere Beispiele zur Vorgehensweise finden Sie in den Dokumentationsbeispielen zum Retry-Paket.

Begrenzung der maximalen Anzahl von Versuchen

Sie verwenden Wiederholungsversuch. AddWithMaxAttemptsum eine aws.Retryer Implementierung zu beenden und die maximale Anzahl der Versuche auf den gewünschten Wert zu setzen.

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)

Beachten Sie, dass die Instanziierung eines Wiederholungsversuchs mithilfe von Funktionsoptionen, die direkt festgelegt werden, ein leicht anderes Verhalten haben wird. MaxAttempts Genauer gesagt führt das Setzen eines Werts kleiner oder gleich Null dazu, dass der Wiederholungsversuch das standardmäßige Maximum von 3 Versuchen verwendet, anstatt es unendlich zu wiederholen:

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)

Begrenzung der maximalen Back-Off-Verzögerung

Sie verwenden Retry. AddWithMaxBackoffDelayum eine aws.Retryer Implementierung abzuschließen und die maximale Back-Off-Verzögerung zu begrenzen, die zwischen erneuten Versuchen einer fehlgeschlagenen Anfrage auftreten kann.

Sie können beispielsweise den folgenden Code verwenden, um den standardmäßigen Client-Wiederholungsversuch mit einer gewünschten maximalen Verzögerung von fünf Sekunden zu beenden:

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)

Versuchen Sie es erneut mit weiteren API-Fehlercodes

Sie verwenden Retry. AddWithErrorCodesum eine aws.Retryer Implementierung zu verpacken und zusätzliche API-Fehlercodes einzufügen, die als wiederholbar erachtet werden sollten.

Sie können beispielsweise den folgenden Code verwenden, um den Standard-Client-Wiederholungsversuch so zu umschließen, dass die Amazon S3 NoSuchBucketException S3-Ausnahme als wiederholbar gilt.

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)

Clientseitige Ratenbegrenzung

Damit AWS SDK für Go wird ein neuer Mechanismus zur kundenseitigen Ratenbegrenzung in die Standardrichtlinie für Wiederholungsversuche aufgenommen, der dem heutigen Verhalten entspricht. SDKs Dieses Verhalten wird durch das RateLimiterFeld in den Optionen eines Wiederholungsversuchs gesteuert.

A RateLimiter arbeitet als Token-Bucket mit einer festgelegten Kapazität, in dem fehlgeschlagene Betriebsversuche Tokens verbrauchen. Ein erneuter Versuch, mehr Token zu verbrauchen, als verfügbar sind, führt zu einem Betriebsfehler mit einer QuotaExceededError.

Die Standardimplementierung ist wie folgt parametrisiert (wie man die einzelnen Einstellungen ändert):

Wenn Sie feststellen, dass das Standardverhalten nicht den Anforderungen Ihrer Anwendung entspricht, können Sie es mit RateLimit.NONE deaktivieren.

Beispiel: modifizierter Ratenbegrenzer

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
    })
}))

Beispiel: Keine Ratenbegrenzung mit 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
    })
}))

Timeouts

Sie verwenden das Kontextpaket, um beim Aufrufen eines Service-Client-Vorgangs Timeouts oder Deadlines festzulegen. Verwenden Sie den Kontext. WithDeadlineum den Kontext Ihrer Anwendungen zu verschließen und eine Frist bis zu einem bestimmten Zeitpunkt festzulegen, bis zu dem der aufgerufene Vorgang abgeschlossen sein muss. Um ein Timeout nach einem bestimmten time.Duration Nutzungskontext festzulegen. WithTimeout. Das SDK übergibt die bereitgestellten Daten context.Context an den HTTP-Transportclient, wenn eine Service-API aufgerufen wird. Wenn der an das SDK übergebene Kontext beim Aufrufen des Vorgangs storniert wird oder abgebrochen wird, wiederholt das SDK die Anfrage nicht weiter und kehrt zur aufrufenden Anwendung zurück. In Fällen, in denen der dem SDK bereitgestellte Kontext storniert wurde, müssen Sie die Kontextstornierung in Ihrer Anwendung entsprechend handhaben.

Ein Timeout festlegen

Das folgende Beispiel zeigt, wie ein Timeout für einen Service-Client-Vorgang festgelegt wird.

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
}