Reintentar estrategia

C++

De forma predeterminada, las operaciones admiten reintentos para los siguientes códigos de error HTTP, así como para cualquier error de socket que indique que la conexión se ha perdido o que nunca se ha establecido correctamente.

• 408 Request Timeout
• 429 Too Many Requests
• 500 Internal Server Error
• 502 Bad Gateway
• 503 Service Unavailable
• 504 Gateway Timeout

Todos los ajustes de retroceso exponencial y reintento de la biblioteca de C++ se pueden configurar. Si los algoritmos implementados en la biblioteca no se ajustan a tus necesidades, puedes proporcionar código personalizado para implementar tus propias estrategias.

De forma predeterminada, la biblioteca de C++ vuelve a intentar todas las operaciones con errores que se pueden volver a intentar, incluso las que nunca son idempotentes y pueden eliminar o crear varios recursos cuando se realizan correctamente varias veces. Para volver a intentar solo las operaciones idempotentes, usa la clase google::cloud::storage::StrictIdempotencyPolicy.

C#

La biblioteca de cliente de C# usa el retroceso exponencial de forma predeterminada.

Go

De forma predeterminada, las operaciones admiten reintentos en caso de que se produzcan los siguientes errores:

• Errores de conexión:
  • io.ErrUnexpectedEOF: esto puede ocurrir debido a problemas de red transitorios.
  • url.Error que contiene connection refused: esto puede ocurrir debido a problemas de red temporales.
  • url.Error que contiene connection reset by peer: Esto significa que Google Cloud ha restablecido la conexión.
  • net.ErrClosed: esto significa que Google Cloud ha cerrado la conexión.
• Códigos HTTP:
  • 408 Request Timeout
  • 429 Too Many Requests
  • 500 Internal Server Error
  • 502 Bad Gateway
  • 503 Service Unavailable
  • 504 Gateway Timeout
• Errores que implementan la interfaz Temporary() y dan un valor de err.Temporary() == true
• Cualquiera de los errores anteriores que se haya envuelto con envoltura de errores de Go 1.13

Todos los ajustes de retroceso exponencial de la biblioteca de Go se pueden configurar. De forma predeterminada, las operaciones de Go usan los siguientes ajustes para la retirada exponencial (los valores predeterminados se toman de gax):

Por lo general, los reintentos continúan indefinidamente a menos que se cancele el contexto de control, se cierre el cliente o se reciba un error no transitorio. Para evitar que se sigan reintentando las operaciones, usa los tiempos de espera de contexto o la cancelación. La única excepción a este comportamiento se da cuando se realizan subidas reanudables con Writer, donde los datos son lo suficientemente grandes como para requerir varias solicitudes. En este caso, cada fragmento agota el tiempo de espera y deja de reintentarse después de 32 segundos de forma predeterminada. Puedes ajustar el tiempo de espera predeterminado cambiando Writer.ChunkRetryDeadline.

Hay un subconjunto de operaciones de Go que son condicionalmente idempotentes (se pueden reintentar de forma segura en determinadas condiciones). Estas operaciones solo se vuelven a intentar si cumplen condiciones específicas:

• GenerationMatch o Generation

  • Se puede volver a intentar si se ha aplicado una condición previa GenerationMatch a la llamada o si se ha definido ObjectHandle.Generation.

• MetagenerationMatch

  • Se puede volver a intentar si se ha aplicado una condición previa MetagenerationMatch a la llamada.

• Etag

  • Se puede volver a intentar si el método inserta un etag en el cuerpo de la solicitud JSON. Solo se usa en HMACKeyHandle.Update cuando se ha definido HmacKeyMetadata.Etag.

RetryPolicy tiene el valor RetryPolicy.RetryIdempotent de forma predeterminada. Consulta Personalizar reintentos para ver ejemplos de cómo modificar el comportamiento predeterminado de los reintentos.

Java

De forma predeterminada, las operaciones admiten reintentos en caso de que se produzcan los siguientes errores:

• Errores de conexión:
  • Connection reset by peer: esto significa que Google Cloud ha restablecido la conexión.
  • Unexpected connection closure: esto significa que Google Cloud ha cerrado la conexión.
• Códigos HTTP:
  • 408 Request Timeout
  • 429 Too Many Requests
  • 500 Internal Server Error
  • 502 Bad Gateway
  • 503 Service Unavailable
  • 504 Gateway Timeout

Todos los ajustes de retroceso exponencial de la biblioteca de Java se pueden configurar. De forma predeterminada, las operaciones a través de Java usan los siguientes ajustes para el tiempo de espera exponencial:

Para obtener más información sobre los ajustes, consulta la documentación de referencia de Java sobre RetrySettings.Builder y HttpTransportOptions.Builder.

Hay un subconjunto de operaciones de Java que son condicionalmente idempotentes (se pueden reintentar de forma condicional). Estas operaciones solo se reintentan si incluyen argumentos específicos:

• ifGenerationMatch o generation

  • Es seguro volver a intentarlo si se ha introducido ifGenerationMatch o generation como opción del método.

• ifMetagenerationMatch

  • Es seguro volver a intentarlo si se ha pasado ifMetagenerationMatch como opción.

StorageOptions.setStorageRetryStrategy tiene el valor StorageRetryStrategy#getDefaultStorageRetryStrategy de forma predeterminada. Consulta Personalizar reintentos para ver ejemplos de cómo modificar el comportamiento de reintento predeterminado.

Node.js

De forma predeterminada, las operaciones admiten reintentos para los siguientes códigos de error:

• Errores de conexión:
  • EAI_again: se trata de un error de petición de DNS. Para obtener más información, consulta la documentación de getaddrinfo.
  • Connection reset by peer: esto significa que Google Cloud ha restablecido la conexión.
  • Unexpected connection closure: esto significa que Google Cloud ha cerrado la conexión.
• Códigos HTTP:
  • 408 Request Timeout
  • 429 Too Many Requests
  • 500 Internal Server Error
  • 502 Bad Gateway
  • 503 Service Unavailable
  • 504 Gateway Timeout

Todos los ajustes de retroceso exponencial de la biblioteca Node.js se pueden configurar. De forma predeterminada, las operaciones a través de Node.js utilizan los siguientes ajustes para el tiempo de espera exponencial:

Hay un subconjunto de operaciones de Node.js que son condicionalmente idempotentes (es decir, se pueden reintentar de forma segura en determinadas condiciones). Estas operaciones solo se vuelven a intentar si incluyen argumentos específicos:

• ifGenerationMatch o generation

  • Es seguro volver a intentarlo si se ha introducido ifGenerationMatch o generation como opción del método. A menudo, los métodos solo aceptan uno de estos dos parámetros.

• ifMetagenerationMatch

  • Es seguro volver a intentarlo si se ha pasado ifMetagenerationMatch como opción.

retryOptions.idempotencyStrategy tiene el valor IdempotencyStrategy.RetryConditional de forma predeterminada. Consulta Personalizar reintentos para ver ejemplos de cómo modificar el comportamiento predeterminado de los reintentos.

PHP

La biblioteca de cliente de PHP usa el retroceso exponencial de forma predeterminada.

De forma predeterminada, las operaciones admiten reintentos para los siguientes códigos de error:

• Errores de conexión:
  • connetion-refused: puede deberse a problemas de red temporales.
  • connection-reset: esto significa que Google Cloud ha restablecido la conexión.
• Códigos HTTP:
  • 200: para casos de descarga parcial
  • 408 Request Timeout
  • 429 Too Many Requests
  • 500 Internal Server Error
  • 502 Bad Gateway
  • 503 Service Unavailable
  • 504 Gateway Timeout

Algunos ajustes de retroceso exponencial de la biblioteca PHP se pueden configurar. De forma predeterminada, las operaciones a través de PHP usan los siguientes ajustes para el tiempo de espera exponencial:

Hay un subconjunto de operaciones de PHP que son condicionalmente idempotentes (se pueden reintentar de forma segura en determinadas condiciones). Estas operaciones solo se vuelven a intentar si incluyen argumentos específicos:

• ifGenerationMatch o generation

  • Es seguro volver a intentarlo si se ha introducido ifGenerationMatch o generation como opción del método. A menudo, los métodos solo aceptan uno de estos dos parámetros.

• ifMetagenerationMatch

  • Es seguro volver a intentarlo si se ha pasado ifMetagenerationMatch como opción.

Al crear StorageClient, se usa la estrategia StorageClient::RETRY_IDEMPOTENT de forma predeterminada. Consulta Personalizar reintentos para ver ejemplos de cómo modificar el comportamiento predeterminado de los reintentos.

Python

De forma predeterminada, las operaciones admiten reintentos para los siguientes códigos de error:

• Errores de conexión:
  • requests.exceptions.ConnectionError
  • requests.exceptions.ChunkedEncodingError (solo para operaciones que obtienen o envían datos de carga útil a objetos, como las subidas y descargas)
  • ConnectionError
  • http.client.ResponseNotReady
  • urllib3.exceptions.TimeoutError
• Códigos HTTP:
  • 408 Request Timeout
  • 429 Too Many Requests
  • 500 Internal Server Error
  • 502 Bad Gateway
  • 503 Service Unavailable
  • 504 Gateway Timeout

Las operaciones a través de Python usan los siguientes ajustes predeterminados para la retirada exponencial:

Además de las operaciones de Cloud Storage que son siempre idempotentes, la biblioteca de cliente de Python vuelve a intentar automáticamente las operaciones Objects: insert, Objects: delete y Objects: patch de forma predeterminada.

Hay un subconjunto de operaciones de Python que son condicionalmente idempotentes (se pueden volver a intentar de forma segura) cuando incluyen argumentos específicos. Estas operaciones solo se vuelven a intentar si se cumple un caso de condición:

• DEFAULT_RETRY_IF_GENERATION_SPECIFIED

  • Se puede volver a intentar si se ha pasado generation o if_generation_match como argumento al método. A menudo, los métodos solo aceptan uno de estos dos parámetros.

• DEFAULT_RETRY_IF_METAGENERATION_SPECIFIED

  • Se puede volver a intentar si if_metageneration_match se ha enviado como argumento al método.

• DEFAULT_RETRY_IF_ETAG_IN_JSON

  • Se puede volver a intentar si el método inserta un etag en el cuerpo de la solicitud JSON. En el caso de HMACKeyMetadata.update(), esto significa que el etag debe definirse en el propio objeto HMACKeyMetadata. En el caso del método set_iam_policy() de otras clases, esto significa que el etag debe definirse en el argumento "policy" que se pasa al método.

Ruby

De forma predeterminada, las operaciones admiten reintentos para los siguientes códigos de error:

• Errores de conexión:
  • SocketError
  • HTTPClient::TimeoutError
  • Errno::ECONNREFUSED
  • HTTPClient::KeepAliveDisconnected
• Códigos HTTP:
  • 408 Request Timeout
  • 429 Too Many Requests
  • 5xx Server Error

Todos los ajustes de retroceso exponencial de la biblioteca de cliente de Ruby se pueden configurar. De forma predeterminada, las operaciones a través de la biblioteca de cliente de Ruby usan los siguientes ajustes para la retención exponencial:

Hay un subconjunto de operaciones de Ruby que son condicionalmente idempotentes (es decir, se pueden volver a intentar de forma segura) cuando incluyen argumentos específicos:

• if_generation_match o generation

  • Se puede volver a intentar si se pasa el parámetro generation o if_generation_match como argumento al método. A menudo, los métodos solo aceptan uno de estos dos parámetros.

• if_metageneration_match

  • Se puede volver a intentar si el parámetro if_metageneration_match se pasa como una opción.

De forma predeterminada, se vuelve a intentar realizar todas las operaciones idempotentes y las operaciones idempotentes condicionales solo si se cumple la condición. Las operaciones no idempotentes no se vuelven a intentar. Consulta Personalizar reintentos para ver ejemplos de cómo modificar el comportamiento predeterminado de los reintentos.

C++

Para personalizar el comportamiento de reintento, proporciona valores para las siguientes opciones cuando inicialices el objeto google::cloud::storage::Client:

• google::cloud::storage::RetryPolicyOption: la biblioteca proporciona las clases google::cloud::storage::LimitedErrorCountRetryPolicy y google::cloud::storage::LimitedTimeRetryPolicy. Puedes proporcionar tu propia clase, que debe implementar la interfaz google::cloud::RetryPolicy.

• google::cloud::storage::BackoffPolicyOption: la biblioteca proporciona la clase google::cloud::storage::ExponentialBackoffPolicy. Puedes proporcionar tu propia clase, que debe implementar la interfaz google::cloud::storage::BackoffPolicy.

• google::cloud::storage::IdempotencyPolicyOption: la biblioteca proporciona las clases google::cloud::storage::StrictIdempotencyPolicy y google::cloud::storage::AlwaysRetryIdempotencyPolicy. Puedes proporcionar tu propia clase, que debe implementar la interfaz google::cloud::storage::IdempotencyPolicy.

Para obtener más información, consulta la documentación de referencia de la biblioteca de cliente de C++.

namespace gcs = ::google::cloud::storage;
// Create the client configuration:
auto options = google::cloud::Options{};
// Retries only idempotent operations.
options.set<gcs::IdempotencyPolicyOption>(
    gcs::StrictIdempotencyPolicy().clone());
// On error, it backs off for a random delay between [1, 3] seconds, then [3,
// 9] seconds, then [9, 27] seconds, etc. The backoff time never grows larger
// than 1 minute.
options.set<gcs::BackoffPolicyOption>(
    gcs::ExponentialBackoffPolicy(
        /*initial_delay=*/std::chrono::seconds(1),
        /*maximum_delay=*/std::chrono::minutes(1),
        /*scaling=*/3.0)
        .clone());
// Retries all operations for up to 5 minutes, including any backoff time.
options.set<gcs::RetryPolicyOption>(
    gcs::LimitedTimeRetryPolicy(std::chrono::minutes(5)).clone());
return gcs::Client(std::move(options));

C#

No puedes personalizar la estrategia de reintento predeterminada que usa la biblioteca de cliente de C#.

Go

Cuando inicializas un cliente de almacenamiento, se establece una configuración de reintentos predeterminada. A menos que se anulen, las opciones de la configuración se definen con los valores predeterminados. Los usuarios pueden configurar un comportamiento de reintento no predeterminado para una sola llamada de biblioteca (con BucketHandle.Retryer y ObjectHandle.Retryer) o para todas las llamadas realizadas por un cliente (con Client.SetRetry). Para modificar el comportamiento de reintento, pasa las RetryOptions pertinentes a uno de estos métodos.

Consulta el siguiente código de ejemplo para saber cómo personalizar el comportamiento de los reintentos.

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
	"github.com/googleapis/gax-go/v2"
)

// configureRetries configures a custom retry strategy for a single API call.
func configureRetries(w io.Writer, bucket, object string) error {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	// Configure retries for all operations using this ObjectHandle. Retries may
	// also be configured on the BucketHandle or Client types.
	o := client.Bucket(bucket).Object(object).Retryer(
		// Use WithBackoff to control the timing of the exponential backoff.
		storage.WithBackoff(gax.Backoff{
			// Set the initial retry delay to a maximum of 2 seconds. The length of
			// pauses between retries is subject to random jitter.
			Initial: 2 * time.Second,
			// Set the maximum retry delay to 60 seconds.
			Max: 60 * time.Second,
			// Set the backoff multiplier to 3.0.
			Multiplier: 3,
		}),
		// Use WithPolicy to customize retry so that all requests are retried even
		// if they are non-idempotent.
		storage.WithPolicy(storage.RetryAlways),
	)

	// Use context timeouts to set an overall deadline on the call, including all
	// potential retries.
	ctx, cancel := context.WithTimeout(ctx, 500*time.Second)
	defer cancel()

	// Delete an object using the specified retry policy.
	if err := o.Delete(ctx); err != nil {
		return fmt.Errorf("Object(%q).Delete: %w", object, err)
	}
	fmt.Fprintf(w, "Blob %v deleted with a customized retry strategy.\n", object)
	return nil
}

Java

Cuando inicializas Storage, también se inicializa una instancia de RetrySettings. Si no se anulan, las opciones de RetrySettings se definen con los valores predeterminados. Para modificar el comportamiento predeterminado de reintento automático, pasa el StorageRetryStrategy personalizado al StorageOptions usado para crear la instancia Storage. Para modificar cualquiera de los otros parámetros escalares, pasa un RetrySettings personalizado al StorageOptions usado para crear la instancia Storage.

Consulta el siguiente ejemplo para saber cómo personalizar el comportamiento de reintento:

import com.google.api.gax.retrying.RetrySettings;
import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import com.google.cloud.storage.StorageRetryStrategy;
import org.threeten.bp.Duration;

public final class ConfigureRetries {
  public static void main(String[] args) {
    String bucketName = "my-bucket";
    String blobName = "blob/to/delete";
    deleteBlob(bucketName, blobName);
  }

  static void deleteBlob(String bucketName, String blobName) {
    // Customize retry behavior
    RetrySettings retrySettings =
        StorageOptions.getDefaultRetrySettings().toBuilder()
            // Set the max number of attempts to 10 (initial attempt plus 9 retries)
            .setMaxAttempts(10)
            // Set the backoff multiplier to 3.0
            .setRetryDelayMultiplier(3.0)
            // Set the max duration of all attempts to 5 minutes
            .setTotalTimeout(Duration.ofMinutes(5))
            .build();

    StorageOptions alwaysRetryStorageOptions =
        StorageOptions.newBuilder()
            // Customize retry so all requests are retried even if they are non-idempotent.
            .setStorageRetryStrategy(StorageRetryStrategy.getUniformStorageRetryStrategy())
            // provide the previously configured retrySettings
            .setRetrySettings(retrySettings)
            .build();

    // Instantiate a client
    Storage storage = alwaysRetryStorageOptions.getService();

    // Delete the blob
    BlobId blobId = BlobId.of(bucketName, blobName);
    boolean success = storage.delete(blobId);

    System.out.printf(
        "Deletion of Blob %s completed %s.%n", blobId, success ? "successfully" : "unsuccessfully");
  }
}

Node.js

Cuando inicializas Cloud Storage, también se inicializa un archivo de configuración retryOptions. A menos que se anulen, las opciones de la configuración se definen con los valores predeterminados. Para modificar el comportamiento predeterminado de los reintentos, pasa la configuración de reintento personalizada retryOptions al constructor de almacenamiento al inicializarlo. La biblioteca de cliente de Node.js puede usar automáticamente estrategias de retardo exponencial para volver a intentar enviar solicitudes con el parámetro autoRetry.

Consulta el siguiente código de ejemplo para saber cómo personalizar el comportamiento de los reintentos.

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The ID of your GCS file
// const fileName = 'your-file-name';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage({
  retryOptions: {
    // If this is false, requests will not retry and the parameters
    // below will not affect retry behavior.
    autoRetry: true,
    // The multiplier by which to increase the delay time between the
    // completion of failed requests, and the initiation of the subsequent
    // retrying request.
    retryDelayMultiplier: 3,
    // The total time between an initial request getting sent and its timeout.
    // After timeout, an error will be returned regardless of any retry attempts
    // made during this time period.
    totalTimeout: 500,
    // The maximum delay time between requests. When this value is reached,
    // retryDelayMultiplier will no longer be used to increase delay time.
    maxRetryDelay: 60,
    // The maximum number of automatic retries attempted before returning
    // the error.
    maxRetries: 5,
    // Will respect other retry settings and attempt to always retry
    // conditionally idempotent operations, regardless of precondition
    idempotencyStrategy: IdempotencyStrategy.RetryAlways,
  },
});
console.log(
  'Functions are customized to be retried according to the following parameters:'
);
console.log(`Auto Retry: ${storage.retryOptions.autoRetry}`);
console.log(
  `Retry delay multiplier: ${storage.retryOptions.retryDelayMultiplier}`
);
console.log(`Total timeout: ${storage.retryOptions.totalTimeout}`);
console.log(`Maximum retry delay: ${storage.retryOptions.maxRetryDelay}`);
console.log(`Maximum retries: ${storage.retryOptions.maxRetries}`);
console.log(
  `Idempotency strategy: ${storage.retryOptions.idempotencyStrategy}`
);

async function deleteFileWithCustomizedRetrySetting() {
  await storage.bucket(bucketName).file(fileName).delete();
  console.log(`File ${fileName} deleted with a customized retry strategy.`);
}

deleteFileWithCustomizedRetrySetting();

PHP

Cuando inicializas un cliente de almacenamiento, se establece una configuración de reintentos predeterminada. A menos que se anulen, las opciones de la configuración se definen con los valores predeterminados. Los usuarios pueden configurar un comportamiento de reintento no predeterminado para un cliente o una sola llamada de operación pasando opciones de anulación en una matriz.

Consulta el siguiente código de ejemplo para saber cómo personalizar el comportamiento de los reintentos.

use Google\Cloud\Storage\StorageClient;

/**
 * Configures retries with customizations.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 */
function configure_retries(string $bucketName): void
{
    $storage = new StorageClient([
        // The maximum number of automatic retries attempted before returning
        // the error.
        // Default: 3
        'retries' => 10,

        // Exponential backoff settings
        // Retry strategy to signify that we never want to retry an operation
        // even if the error is retryable.
        // Default: StorageClient::RETRY_IDEMPOTENT
        'retryStrategy' => StorageClient::RETRY_ALWAYS,

        // Executes a delay
        // Defaults to utilizing `usleep`.
        // Function signature should match: `function (int $delay) : void`.
        // This function is mostly used internally, so the tests don't wait
        // the time of the delay to run.
        'restDelayFunction' => function ($delay) {
            usleep($delay);
        },

        // Sets the conditions for determining how long to wait between attempts to retry.
        // Function signature should match: `function (int $attempt) : int`.
        // Allows to change the initial retry delay, retry delay multiplier and maximum retry delay.
        'restCalcDelayFunction' => fn ($attempt) => ($attempt + 1) * 100,

        // Sets the conditions for whether or not a request should attempt to retry.
        // Function signature should match: `function (\Exception $ex) : bool`.
        'restRetryFunction' => function (\Exception $e) {
            // Custom logic: ex. only retry if the error code is 404.
            return $e->getCode() === 404;
        },

        // Runs after the restRetryFunction. This might be used to simply consume the
        // exception and $arguments b/w retries. This returns the new $arguments thus allowing
        // modification on demand for $arguments. For ex: changing the headers in b/w retries.
        'restRetryListener' => function (\Exception $e, $retryAttempt, &$arguments) {
            // logic
        },
    ]);
    $bucket = $storage->bucket($bucketName);
    $operationRetriesOverrides = [
        // The maximum number of automatic retries attempted before returning
        // the error.
        // Default: 3
        'retries' => 10,

        // Exponential backoff settings
        // Retry strategy to signify that we never want to retry an operation
        // even if the error is retryable.
        // Default: StorageClient::RETRY_IDEMPOTENT
        'retryStrategy' => StorageClient::RETRY_ALWAYS,

        // Executes a delay
        // Defaults to utilizing `usleep`.
        // Function signature should match: `function (int $delay) : void`.
        // This function is mostly used internally, so the tests don't wait
        // the time of the delay to run.
        'restDelayFunction' => function ($delay) {
            usleep($delay);
        },

        // Sets the conditions for determining how long to wait between attempts to retry.
        // Function signature should match: `function (int $attempt) : int`.
        // Allows to change the initial retry delay, retry delay multiplier and maximum retry delay.
        'restCalcDelayFunction' => fn ($attempt) => ($attempt + 1) * 100,

        // Sets the conditions for whether or not a request should attempt to retry.
        // Function signature should match: `function (\Exception $ex) : bool`.
        'restRetryFunction' => function (\Exception $e) {
            // Custom logic: ex. only retry if the error code is 404.
            return $e->getCode() === 404;
        },

        // Runs after the restRetryFunction. This might be used to simply consume the
        // exception and $arguments b/w retries. This returns the new $arguments thus allowing
        // modification on demand for $arguments. For ex: changing the headers in b/w retries.
        'restRetryListener' => function (\Exception $e, $retryAttempt, &$arguments) {
            // logic
        },
    ];
    foreach ($bucket->objects($operationRetriesOverrides) as $object) {
        printf('Object: %s' . PHP_EOL, $object->name());
    }
}

Python

Para modificar el comportamiento predeterminado de los reintentos, crea una copia del objeto google.cloud.storage.retry.DEFAULT_RETRY llamándolo con un método with_BEHAVIOR. La biblioteca de cliente de Python usa automáticamente estrategias de retardo para reintentar las solicitudes si incluyes el parámetro DEFAULT_RETRY.

Ten en cuenta que with_predicate no se admite en operaciones que obtienen o envían datos de carga útil a objetos, como las subidas y las descargas. Te recomendamos que modifiques los atributos uno a uno. Para obtener más información, consulta la referencia de reintentos de google-api-core.

Para configurar tu propio reintento condicional, crea un objeto ConditionalRetryPolicy y encapsula tu objeto Retry personalizado con DEFAULT_RETRY_IF_GENERATION_SPECIFIED, DEFAULT_RETRY_IF_METAGENERATION_SPECIFIED o DEFAULT_RETRY_IF_ETAG_IN_JSON.

Consulta el siguiente código de ejemplo para saber cómo personalizar el comportamiento de los reintentos.

from google.cloud import storage
from google.cloud.storage.retry import DEFAULT_RETRY


def configure_retries(bucket_name, blob_name):
    """Configures retries with customizations."""
    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"
    # The ID of your GCS object
    # blob_name = "your-object-name"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(blob_name)

    # Customize retry with a timeout of 500 seconds (default=120 seconds).
    modified_retry = DEFAULT_RETRY.with_timeout(500.0)
    # Customize retry with an initial wait time of 1.5 (default=1.0).
    # Customize retry with a wait time multiplier per iteration of 1.2 (default=2.0).
    # Customize retry with a maximum wait time of 45.0 (default=60.0).
    modified_retry = modified_retry.with_delay(initial=1.5, multiplier=1.2, maximum=45.0)

    # blob.delete() uses DEFAULT_RETRY by default.
    # Pass in modified_retry to override the default retry behavior.
    print(
        f"The following library method is customized to be retried according to the following configurations: {modified_retry}"
    )

    blob.delete(retry=modified_retry)
    print(f"Blob {blob_name} deleted with a customized retry strategy.")

Ruby

Cuando inicializas el cliente de almacenamiento, todas las configuraciones de reintentos se definen con los valores que se muestran en la tabla anterior. Para modificar el comportamiento predeterminado de reintento, pasa las configuraciones de reintento al inicializar el cliente de almacenamiento.

Para anular el número de reintentos de una operación concreta, envía retries en el parámetro options de la operación.

def configure_retries bucket_name: nil, file_name: nil
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The ID of your GCS object
  # file_name = "your-file-name"

  require "google/cloud/storage"

  # Creates a client
  storage = Google::Cloud::Storage.new(

    # The maximum number of automatic retries attempted before returning
    # the error.
    #
    # Customize retry configuration with the maximum retry attempt of 5.
    retries: 5,

    # The total time in seconds that requests are allowed to keep being retried.
    # After max_elapsed_time, an error will be returned regardless of any
    # retry attempts made during this time period.
    #
    # Customize retry configuration with maximum elapsed time of 500 seconds.
    max_elapsed_time: 500,

    # The initial interval between the completion of failed requests, and the
    # initiation of the subsequent retrying request.
    #
    # Customize retry configuration with an initial interval of 1.5 seconds.
    base_interval: 1.5,

    # The maximum interval between requests. When this value is reached,
    # multiplier will no longer be used to increase the interval.
    #
    # Customize retry configuration with maximum interval of 45.0 seconds.
    max_interval: 45,

    # The multiplier by which to increase the interval between the completion
    # of failed requests, and the initiation of the subsequent retrying request.
    #
    # Customize retry configuration with an interval multiplier per iteration of 1.2.
    multiplier: 1.2
  )

  # Uses the retry configuration set during the client initialization above with 5 retries
  file = storage.service.get_file bucket_name, file_name

  # Maximum retry attempt can be overridden for each operation using options parameter.
  storage.service.delete_file bucket_name, file_name, options: { retries: 4 }
  puts "File #{file.name} deleted with a customized retry strategy."
end