Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Configura las políticas de sondeo

Aprende a configurar políticas de sondeo para operaciones de larga duración. Las bibliotecas cliente deGoogle Cloud para Rust proporcionan funciones auxiliares para simplificar la supervisión del progreso de las operaciones de larga duración (LRO). Estos asistentes usan políticas para configurar la frecuencia de sondeo y determinar qué errores de sondeo son transitorios (y se pueden reintentar de forma segura) y cuáles son irrecuperables.

Dos políticas controlan el comportamiento de los bucles de LRO:

La política de retirada de sondeo controla cuánto tiempo esperan los bucles antes de sondear el estado de una LRO que aún está en curso.
La política de errores de sondeo controla qué hacer en caso de un error de sondeo. Algunos errores de sondeo son irrecuperables y señalan que se anuló la operación o que el llamador no tiene permisos para verificar el estado del LRO. Otros errores de sondeo son transitorios y señalan un problema temporal en la red del cliente o en el servicio.

Puedes establecer cada una de estas políticas de forma independiente. Además, puedes aplicar una política a todas las LRO iniciadas en un cliente o cambiar la política para una sola solicitud.

Requisitos previos

En esta guía, se usa el servicio de Cloud Storage para mantener los fragmentos de código concretos, pero los mismos conceptos se aplican a cualquier otro servicio que use LRO.

Antes de usar esta guía, sigue los pasos de Cómo usar Cloud Storage con Rust para habilitar y autenticar la API de Cloud Storage.

Para obtener instrucciones completas sobre la configuración de las bibliotecas de Rust, consulta Cómo configurar tu entorno de desarrollo.

Dependencias

Agrega las siguientes dependencias a tu archivo Cargo.toml:

cargo add google-cloud-storage google-cloud-lro

Configura la frecuencia de sondeo para todas las solicitudes en un cliente

Si planeas usar la misma política de retirada de sondeo para la mayoría de las solicitudes con el mismo cliente, considera establecer la política como una opción del cliente. En esta muestra de código, se configura la frecuencia de sondeo para todas las solicitudes al servicio de Cloud Storage.

pub async fn client_backoff(bucket: &str, folder: &str, dest: &str) -> Result<()> {
    // Use a type that implements the `PollingBackoffPolicy` trait, in this case
    // `ExponentialBackoffBuilder`.
    use google_cloud_gax::exponential_backoff::ExponentialBackoffBuilder;
    use google_cloud_lro::Poller;
    use std::time::Duration;

    let client = StorageControl::builder()
        // Initialize the policy with a chosen delay duration.
        .with_polling_backoff_policy(
            ExponentialBackoffBuilder::new()
                .with_initial_delay(Duration::from_millis(250))
                .with_maximum_delay(Duration::from_secs(10))
                .build()?,
        )
        .build()
        .await?;

    // Initiate an LRO using polling.
    let response = client
        .rename_folder()
        .set_name(format!("projects/_/buckets/{bucket}/folders/{folder}"))
        .set_destination_folder_id(dest)
        .poller()
        .until_done()
        .await?;

    println!("LRO completed, response={response:?}");

    Ok(())
}

A menos que anules la política con un parámetro de configuración por solicitud, la política seguirá vigente para cualquier operación de larga duración que inicie el cliente.

Por ejemplo, la siguiente llamada usará esta política:

    let mut operation = client
        .rename_folder()
        /* more stuff */
        .send()
        .await?;

En esta llamada de ejemplo, la biblioteca cliente espera 250 ms después del primer intento de sondeo y, luego, 500 ms para el segundo intento. Los intentos posteriores esperan 1 s, 2 s, 4 s y 8 s, y todos los intentos posteriores esperan 10 s.

Configura la frecuencia de sondeo para una solicitud específica

Puedes configurar la frecuencia de sondeo para una solicitud individual, lo que anula cualquier política establecida a nivel del cliente. Por ejemplo:

pub async fn rpc_backoff(bucket: &str, folder: &str, dest: &str) -> Result<()> {
    // Use a type that implements the `PollingBackoffPolicy` trait, in this case
    // `ExponentialBackoffBuilder`.
    use google_cloud_gax::exponential_backoff::ExponentialBackoffBuilder;
    use std::time::Duration;

    // To configure the request, bring the RequestOptionsBuilder trait into
    // scope.
    use google_cloud_gax::options::RequestOptionsBuilder;
    use google_cloud_lro::Poller;

    let client = StorageControl::builder().build().await?;
    // Create the request builder.
    let response = client
        .rename_folder()
        // Configure the polling backoff policy.
        .with_polling_backoff_policy(
            ExponentialBackoffBuilder::new()
                .with_initial_delay(Duration::from_millis(250))
                .with_maximum_delay(Duration::from_secs(10))
                .build()?,
        )
        .set_name(format!("projects/_/buckets/{bucket}/folders/{folder}"))
        .set_destination_folder_id(dest)
        // Issue the polling request as normal.
        .poller()
        .until_done()
        .await?;

    println!("LRO completed, response={response:?}");

    Ok(())
}

Configura errores de sondeo reintentables para todas las solicitudes de un cliente

Para configurar errores reintentables, usa un tipo que implemente el rasgo PollingErrorPolicy. Las bibliotecas cliente proporcionan varias políticas. Una opción conservadora es Aip194Strict. Si planeas usar la misma política de sondeo para la mayoría de las solicitudes con el mismo cliente, considera establecer la política como una opción del cliente.

En esta muestra de código, se configuran los errores de sondeo reintentables para todas las solicitudes al servicio de Cloud Storage:

pub async fn client_error_policy(bucket: &str, folder: &str, dest: &str) -> Result<()> {
    // Use a type that implements the `PollingErrorPolicy` trait, in this case
    // `Aip194Strict`.
    use google_cloud_gax::polling_error_policy::Aip194Strict;
    use google_cloud_gax::polling_error_policy::PollingErrorPolicyExt;
    use google_cloud_lro::Poller;
    use std::time::Duration;

    // Add the polling policy that you want to use for all long-running
    // operations.
    let client = StorageControl::builder()
        .with_polling_error_policy(
            Aip194Strict
                .with_attempt_limit(100)
                .with_time_limit(Duration::from_secs(300)),
        )
        .build()
        .await?;

    // Initiate an LRO using polling.
    let response = client
        .rename_folder()
        .set_name(format!("projects/_/buckets/{bucket}/folders/{folder}"))
        .set_destination_folder_id(dest)
        .poller()
        .until_done()
        .await?;

    println!("LRO completed, response={response:?}");

    Ok(())
}

Si bien la política de errores de sondeo controla los errores durante el bucle de espera del LRO, también puedes agregar una política de reintentos estándar para controlar los errores transitorios que podrían ocurrir cuando se envía inicialmente la solicitud para iniciar el LRO:

    let client = StorageControl::builder()
        .with_retry_policy(
            retry_policy::Aip194Strict
                .with_attempt_limit(100)
                .with_time_limit(Duration::from_secs(300)),
        )
        .build()
        .await?;

A menos que anules la política con un parámetro de configuración por solicitud, esta política seguirá vigente para cualquier operación de larga duración que inicie el cliente. Por ejemplo, si realizas la siguiente llamada:

    let mut operation = client
        .rename_folder()
        /* more stuff */
        .send()
        .await?;

Nota: La biblioteca cliente solo trata UNAVAILABLE (consulta AIP-194) como un error que se puede reintentar y detiene el sondeo después de 100 intentos o 300 segundos, lo que ocurra primero.

Configura errores de sondeo reintentables para una solicitud específica

Puedes configurar errores de sondeo reintentables para una solicitud específica usando un tipo que implemente el rasgo PollingErrorPolicy y que incorpore el rasgo RequestOptionsBuilder al alcance.

En esta muestra de código, se configuran errores de sondeo reintentables para una solicitud específica al servicio de Cloud Storage.

pub async fn rpc_error_policy(bucket: &str, folder: &str, dest: &str) -> Result<()> {
    // Use a type that implements the `PollingErrorPolicy` trait, in this case
    // `Aip194Strict`.
    use google_cloud_gax::polling_error_policy::Aip194Strict;
    use google_cloud_gax::polling_error_policy::PollingErrorPolicyExt;
    // Bring `RequestOptionsBuilder` into scope.
    use google_cloud_gax::options::RequestOptionsBuilder;
    use std::time::Duration;
    use google_cloud_lro::Poller;

    let client = StorageControl::builder().build().await?;

    // Create the request builder.
    let response = client
        .rename_folder()
        // Configure the polling error policy.
        .with_polling_error_policy(
            Aip194Strict
                .with_attempt_limit(100)
                .with_time_limit(Duration::from_secs(300)),
        )
        .set_name(format!("projects/_/buckets/{bucket}/folders/{folder}"))
        .set_destination_folder_id(dest)
        // Initialize the request.
        .poller()
        .until_done()
        .await?;

    println!("LRO completed, response={response:?}");

    Ok(())
}

También puedes considerar agregar una política de reintentos en caso de que falle la solicitud inicial para iniciar el LRO:

    let client = StorageControl::builder()
        .with_retry_policy(
            retry_policy::Aip194Strict
                .with_attempt_limit(100)
                .with_time_limit(Duration::from_secs(300)),
        )
        .build()
        .await?;

Configura las políticas de sondeo Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.