Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Nouvelles tentatives et délais d'expiration
Vous AWS SDK pour Go permet de configurer le comportement des nouvelles tentatives des demandes adressées aux services HTTP. Par défaut, les clients du service utilisent [Retry.standard](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#Standard) comme rétryer par défaut. Si la configuration ou le comportement par défaut ne répond pas aux exigences de votre application, vous pouvez ajuster la configuration du rétryer ou fournir votre propre implémentation de rétryer.
AWS SDK pour Go Fournit une interface [AWS.Retryer](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#Retryer) qui définit l'ensemble des méthodes requises pour implémenter une nouvelle tentative. [Le SDK fournit deux implémentations pour les nouvelles tentatives : [Retry.standard](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#Standard) et aws. NoOpRetryer](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#NoOpRetryer).
## Rétracteur standard
Le [retryer Retry.standard](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#Standard) est l'`aws.Retryer`implémentation par défaut utilisée par les clients du SDK. Le réessayeur standard est un réessayeur à débit limité avec un nombre maximum de tentatives configurable et la possibilité d'ajuster la politique de rétrogradation des demandes.
Le tableau suivant définit les valeurs par défaut pour ce rétryer :
| Propriété | Par défaut |
| --- | --- |
| Nombre maximum de tentatives | 3 |
| Délai de retour maximal | 20 secondes |
Lorsqu'une erreur réessayable se produit lors de l'appel de votre demande, le réessayeur standard utilise la configuration fournie pour retarder puis réessayer la demande. Les nouvelles tentatives augmentent la latence globale de votre demande, et vous devez configurer une nouvelle tentative si la configuration par défaut ne répond pas aux exigences de votre application.
Consultez la documentation du package [Retry](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry) pour plus de détails sur les erreurs considérées comme réessayables par l'implémentation standard du retryer.
## NopRetryer
Les [lois. NopRetryer](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#NopRetryer)est une `aws.Retryer` implémentation qui est fournie si vous souhaitez désactiver toutes les tentatives de nouvelle tentative. Lors de l'appel d'une opération client de service, ce réessayeur n'autorisera la demande qu'une seule fois, et toute erreur qui en résultera sera renvoyée à l'application appelante.
## Personnalisation du comportement
Le SDK fournit un ensemble d'utilitaires d'assistance qui encapsulent une `aws.Retryer` implémentation et renvoie le rétryer fourni avec le comportement de nouvelle tentative souhaité. Vous pouvez remplacer le rétryer par défaut pour tous les clients, par client ou par opération en fonction des exigences de vos applications. Pour voir des exemples supplémentaires montrant comment procéder, consultez les exemples de documentation du package [retry](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry).
**Avertissement**
Si vous spécifiez une `aws.Retryer` implémentation globale en utilisant`config.WithRetryer`, vous devez vous assurer de renvoyer une nouvelle instance de `aws.Retryer` chaque appel. Cela vous évitera de créer un bucket global de jetons de réessai pour tous les clients du service.
### Limiter le nombre maximum de tentatives
Vous utilisez [Retry. AddWithMaxAttempts](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#AddWithMaxAttempts)pour encapsuler une `aws.Retryer` implémentation afin de définir le nombre maximum de tentatives à la valeur souhaitée.
**Avertissement**
L'utilisation `retry.AddWithMaxAttempts` d'une valeur de zéro permettra au SDK de réessayer toutes les erreurs réessayables jusqu'à ce que la demande aboutisse ou qu'une erreur non réessayable soit renvoyée. **Permettre au SDK de réessayer à l'infini peut entraîner une charge de travail galopante et des cycles de facturation excessifs.**
```
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)
```
Notez que l'instanciation d'un rétryer à l'aide d'options fonctionnelles à définir MaxAttempts directement aura un comportement légèrement différent. Plus précisément, si vous définissez une valeur inférieure ou égale à zéro, le réessayeur utilisera le maximum de 3 tentatives par défaut, plutôt que de réessayer à l'infini :
```
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)
```
### Limiter le délai maximal d'arrêt
Vous utilisez [Retry. AddWithMaxBackoffDelay](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#AddWithMaxBackoffDelay)pour encapsuler une `aws.Retryer` implémentation et limiter le délai d'attente maximal autorisé entre deux nouvelles tentatives d'une demande ayant échoué.
Par exemple, vous pouvez utiliser le code suivant pour encapsuler le rétryer client standard avec le délai maximum souhaité de cinq secondes :
```
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)
```
### Réessayez d'autres codes d'erreur d'API
Vous utilisez [Retry. AddWithErrorCodes](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#AddWithErrorCodes)pour encapsuler une `aws.Retryer` implémentation et inclure des codes d'erreur d'API supplémentaires qui doivent être considérés comme réessayables.
Par exemple, vous pouvez utiliser le code suivant pour encapsuler le rétryer client standard afin d'inclure l'`NoSuchBucketException`exception Amazon S3 comme réessayable.
```
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)
```
### Limitation du débit côté client
Le AWS SDK pour Go introduit un nouveau mécanisme de limitation du débit côté client dans la politique de réessai standard afin de s'aligner sur le comportement moderne. SDKs [Ce comportement est contrôlé par le [RateLimiter](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#RateLimiter)champ des options d'un réessayeur.](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#StandardOptions)
A RateLimiter fonctionne comme un bucket de jetons d'une capacité définie, où les échecs de tentative d'opération consomment des jetons. Une nouvelle tentative qui tente de consommer plus de jetons que ce qui est disponible entraîne un échec de l'opération avec un [QuotaExceededError](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/ratelimit#QuotaExceededError).
L'implémentation par défaut est paramétrée comme suit (comment modifier chaque paramètre) :
+ une capacité de 500 (définissez la valeur de RateLimiter lors de StandardOptions l'utilisation [NewTokenRateLimit](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/ratelimit#NewTokenRateLimit))
+ une nouvelle tentative provoquée par un délai d'attente coûte 10 jetons (activé RetryTimeoutCost ) StandardOptions
+ une nouvelle tentative provoquée par d'autres erreurs coûte 5 jetons ( RetryCostactivé StandardOptions)
+ une opération réussie à la première tentative ajoute 1 jeton ( NoRetryIncrement activé StandardOptions)
+ les opérations réussies lors de la deuxième tentative ou d'une tentative ultérieure n'ajoutent aucun jeton
Si vous trouvez que le comportement par défaut ne correspond pas aux besoins de votre application, vous pouvez le désactiver avec [RateLimit.NONE](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/ratelimit#pkg-variables).
#### Exemple : limiteur de débit modifié
```
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
})
}))
```
#### Exemple : aucune limite de débit avec 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
})
}))
```
## Délais
Vous utilisez le package de [contexte](https://golang.org/pkg/context/) pour définir des délais ou des délais lorsque vous invoquez une opération client de service. Utilisez le [contexte. WithDeadline](https://golang.org/pkg/context/#WithDeadline)pour encapsuler le contexte de vos applications et définir une date limite à laquelle l'opération invoquée doit être terminée. Pour définir un délai d'expiration après un certain [contexte `time.Duration` d'utilisation. WithTimeout](https://golang.org/pkg/context/#WithTimeout). Le SDK transmet le contenu fourni `context.Context` au client de transport HTTP lors de l'appel d'une API de service. Si le contexte transmis au SDK est annulé ou devient annulé lors de l'appel de l'opération, le SDK ne réessaiera pas la demande et retournera à l'application appelante. Vous devez gérer l'annulation du contexte de manière appropriée dans votre application dans les cas où le contexte fourni au SDK est annulé.
### Définition d'un délai d'attente
L'exemple suivant montre comment définir un délai d'expiration pour une opération client de service.
```
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
}
```