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
<a name="configure-retries-timeouts"></a>

 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](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#Standard). 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](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#Retryer) 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.](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). 

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

 Der [Retry.Standard Retryer](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#Standard) 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: 


| Eigenschaft | Standard | 
| --- | --- | 
| Max. Anzahl der Versuche | 3 | 
| Maximale Back-Off-Verzögerung | 20 Sekunden | 

 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](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry) finden Sie Einzelheiten dazu, welche Fehler bei der Standardimplementierung von Retryern als wiederholbar angesehen werden. 

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

 [Das war. NopRetryer](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#NopRetryer)ist 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
<a name="customizing-behavior"></a>

 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](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry). 

**Warnung**  
 Wenn Sie eine globale `aws.Retryer` Implementierung mit angeben`config.WithRetryer`, müssen Sie sicherstellen, dass Sie für `aws.Retryer` jeden Aufruf eine neue Instanz zurückgeben. Dadurch wird sichergestellt, dass Sie nicht für alle Service-Clients einen globalen Token-Bucket für Wiederholungsversuche erstellen. 

### Begrenzung der maximalen Anzahl von Versuchen
<a name="limiting-the-max-number-of-attempts"></a>

 Sie verwenden [Wiederholungsversuch. AddWithMaxAttempts](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#AddWithMaxAttempts)um eine `aws.Retryer` Implementierung zu beenden und die maximale Anzahl der Versuche auf den gewünschten Wert zu setzen. 

**Warnung**  
 Wenn Sie `retry.AddWithMaxAttempts` den Wert Null angeben, kann das SDK alle wiederholbaren Fehler erneut versuchen, bis die Anfrage erfolgreich ist oder ein Fehler zurückgegeben wird, der nicht erneut versucht werden kann. **Wenn Sie dem SDK erlauben, es unendlich oft zu wiederholen, kann dies zu unkontrollierten Arbeitslasten und überhöhten Abrechnungszyklen führen.** 

```
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
<a name="limiting-the-max-back-off-delay"></a>

 Sie verwenden [Retry. AddWithMaxBackoffDelay](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#AddWithMaxBackoffDelay)um 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
<a name="retry-additional-api-error-codes"></a>

 Sie verwenden [Retry. AddWithErrorCodes](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#AddWithErrorCodes)um 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
<a name="client-side-rate-limiting"></a>

 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 [RateLimiter](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#RateLimiter)Feld in den Optionen eines Wiederholungsversuchs gesteuert.](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#StandardOptions) 

 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](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/ratelimit#QuotaExceededError). 

 Die Standardimplementierung ist wie folgt parametrisiert (wie man die einzelnen Einstellungen ändert): 
+  eine Kapazität von 500 (stellen Sie den Wert RateLimiter on StandardOptions using ein) [NewTokenRateLimit](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/ratelimit#NewTokenRateLimit) 
+  Ein durch einen Timeout verursachter Wiederholungsversuch kostet 10 Token (aktiviert) RetryTimeoutCost StandardOptions 
+  Ein durch andere Fehler verursachter Wiederholungsversuch kostet 5 Token (aktiviert) RetryCost StandardOptions 
+  Ein Vorgang, der beim ersten Versuch erfolgreich ist, fügt 1 Token hinzu (aktiviert) NoRetryIncrement StandardOptions 
  +  Operationen, die beim zweiten oder späteren Versuch erfolgreich sind, fügen keine Tokens zurück 

 Wenn Sie feststellen, dass das Standardverhalten nicht den Anforderungen Ihrer Anwendung entspricht, können Sie es mit [RateLimit.NONE](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/ratelimit#pkg-variables) deaktivieren. 

#### Beispiel: modifizierter Ratenbegrenzer
<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
    })
}))
```

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

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

 Sie verwenden das [Kontextpaket](https://golang.org/pkg/context/), um beim Aufrufen eines Service-Client-Vorgangs Timeouts oder Deadlines festzulegen. [Verwenden Sie den Kontext. WithDeadline](https://golang.org/pkg/context/#WithDeadline)um 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](https://golang.org/pkg/context/#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
<a name="setting-a-timeout"></a>

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