Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Reintentos y tiempos de espera
<a name="configure-retries-timeouts"></a>

 AWS SDK para Go Le permite configurar el comportamiento de reintento de las solicitudes a los servicios HTTP. De forma predeterminada, los clientes de servicio utilizan [retry.Standard](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#Standard) como elemento de reintento predeterminado. Si la configuración o el comportamiento predeterminado no cumple con los requisitos de la aplicación, puede ajustar la configuración del elemento de reintento o proporcionar su propia implementación del mismo. 

 AWS SDK para Go Proporciona una interfaz [AWS.Retryer](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#Retryer) que define el conjunto de métodos que debe implementar una implementación de reintento. [El SDK proporciona dos implementaciones para los reintentos: retry.standard y 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). 

## Elemento de reintento estándar
<a name="standard-retryer"></a>

 El elemento de reintento [retry.Standard](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#Standard) es la implementación de `aws.Retryer` predeterminada que utilizan los clientes del SDK. El elemento de reintento estándar tiene ciertas limitaciones, con un número máximo de intentos configurable y la posibilidad de ajustar la política de retroceso de las solicitudes. 

 En la tabla siguiente se definen los valores predeterminados de este elemento de reintento: 


| Propiedad | Predeterminado | 
| --- | --- | 
|  Número máximo de intentos  |  3  | 
|  Retardo de retroceso máximo  |  20 segundos  | 

 Cuando se produzca un error reintentable al invocar la solicitud, el elemento de reintento estándar utilizará la configuración proporcionada a fin de retrasar la solicitud y reintentarla más adelante. Los reintentos se agregan a la latencia general de la solicitud y debe configurar el elemento de reintento si la configuración predeterminada no cumple los requisitos de la aplicación. 

 Consulte la documentación del paquete [retry](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry) para obtener más información sobre los errores que la implementación del elemento de reintento estándar considera reintentables. 

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

 Las [leyes. NopRetryer](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#NopRetryer)es una `aws.Retryer` implementación que se proporciona si desea deshabilitar todos los reintentos. Al invocar una operación de cliente de servicio, este elemento de reintento solo permite que la solicitud se intente una vez y cualquier error resultante se devolverá a la aplicación que realiza la llamada. 

## Personalización del comportamiento
<a name="customizing-behavior"></a>

 El SDK proporciona un conjunto de utilidades auxiliares que encapsulan una implementación de `aws.Retryer` y devuelve el elemento de reintento que se proporciona, encapsulado con el comportamiento de reintento deseado. Puede reemplazar el elemento de reintento predeterminado para todos los clientes, por cliente o por operación, en función de los requisitos de las aplicaciones. Para ver más ejemplos en los que se muestra cómo realizar esta acción, consulte los ejemplos de la documentación del paquete [retry](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry). 

**aviso**  
 Si especifica una implementación de `aws.Retryer` global mediante `config.WithRetryer`, debe asegurarse de que se devuelva una nueva instancia de `aws.Retryer` en cada invocación. De esta forma, se garantiza que no se cree un bucket de tokens de reintentos global en todos los clientes de servicio. 

### Limitación del número máximo de intentos
<a name="limiting-the-max-number-of-attempts"></a>

 Usas [retry. AddWithMaxAttempts](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#AddWithMaxAttempts)para ajustar una `aws.Retryer` implementación a fin de establecer el número máximo de intentos en el valor deseado. 

**aviso**  
 Si se usa `retry.AddWithMaxAttempts` con un valor de cero, el SDK podrá volver a intentar todos los errores reintentables hasta que la solicitud se realice correctamente o se devuelva un error que no sea reintentable. **Permitir que el SDK realice reintentos de forma infinita puede provocar cargas de trabajo fuera de control y ciclos de facturación desorbitados.** 

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

 Tenga en cuenta que crear una instancia de un retryer utilizando opciones funcionales para configurarlo MaxAttempts directamente tendrá un comportamiento ligeramente diferente. En concreto, si se establece un valor menor que cero o cero, el elemento de reintento utilizará el máximo predeterminado de tres intentos, en lugar de hacer reintentos de forma infinita: 

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

### Limitación del retardo de retroceso máximo
<a name="limiting-the-max-back-off-delay"></a>

 [Usas retry. AddWithMaxBackoffDelay](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#AddWithMaxBackoffDelay)para completar una `aws.Retryer` implementación y limitar el tiempo máximo de espera que se puede producir entre el reintento de una solicitud fallida. 

 Por ejemplo, puede usar el código siguiente para encapsular el elemento de reintento del cliente estándar con un retraso máximo deseado de cinco segundos: 

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

### Reintento de códigos de error adicionales de la API
<a name="retry-additional-api-error-codes"></a>

 Se usa [reintentar. AddWithErrorCodes](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#AddWithErrorCodes)para empaquetar una `aws.Retryer` implementación e incluir códigos de error de API adicionales que deberían considerarse reintentables. 

 Por ejemplo, puede usar el código siguiente para encapsular el elemento de reintento del cliente estándar e incluir la excepción `NoSuchBucketException` de Amazon S3 como reintentable. 

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

### Limitación de la tasa del cliente
<a name="client-side-rate-limiting"></a>

 AWS SDK para Go Introduce un nuevo mecanismo de limitación de la velocidad por parte del cliente en la política de reintentos estándar para adaptarlo al comportamiento de la tecnología moderna. SDKs [Este comportamiento lo controla el [RateLimiter](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#RateLimiter)campo de las opciones de un retryer.](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#StandardOptions) 

 A RateLimiter funciona como un depósito de fichas con una capacidad determinada, en el que los intentos fallidos de operación consumen fichas. Si se vuelve a intentar consumir más fichas de las disponibles, se produce un error en la operación con un [QuotaExceededError](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/ratelimit#QuotaExceededError). 

 La implementación predeterminada está parametrizada de la siguiente forma (cómo modificar cada configuración): 
+  una capacidad de 500 (establece el valor de RateLimiter al StandardOptions usarla [NewTokenRateLimit](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/ratelimit#NewTokenRateLimit)) 
+  un reintento provocado por un tiempo de espera cuesta 10 fichas (un número fijo RetryTimeoutCost ) StandardOptions 
+  un reintento provocado por otros errores cuesta 5 fichas (activado) RetryCost StandardOptions 
+  una operación que se realiza correctamente en el primer intento añade 1 ficha (activada NoRetryIncrement ) StandardOptions 
  +  Las operaciones que se realizan correctamente en el segundo intento o en un intento posterior no agregan tokens 

 Si considera que el comportamiento predeterminado no se ajusta a las necesidades de su aplicación, puede deshabilitarlo con [ratelimit.None](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/ratelimit#pkg-variables). 

#### Ejemplo: Limitador de tasa modificado
<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
    })
}))
```

#### Ejemplo: Sin límite de tasa con 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
    })
}))
```

## Tiempos de espera
<a name="timeouts"></a>

 El paquete [context](https://golang.org/pkg/context/) se utiliza para establecer tiempos de espera o plazos al invocar una operación de cliente de servicio. Usa el [contexto. WithDeadline](https://golang.org/pkg/context/#WithDeadline)para resumir el contexto de su solicitud y establecer una fecha límite en un momento específico para completar la operación invocada. Para establecer un tiempo de espera después de un determinado [contexto de `time.Duration` uso. WithTimeout](https://golang.org/pkg/context/#WithTimeout). El SDK pasa el elemento `context.Context` proporcionado al cliente de transporte HTTP al invocar una API de servicio. Si el contexto que se pasa al SDK se cancela, o se produce su cancelación durante la invocación de la operación, el SDK no reintentará realizar la solicitud y volverá a la aplicación que realiza la llamada. La cancelación del contexto debe gestionarse de forma adecuada en la aplicación en los casos en los que se haya cancelado el contexto proporcionado al SDK. 

### Establecimiento de un tiempo de espera
<a name="setting-a-timeout"></a>

 En el ejemplo siguiente se muestra cómo establecer un tiempo de espera para una operación de cliente de servicio. 

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