Configurazione dei criteri di ripetizione dei tentativi

Le librerie client di Cloud per Rust possono riprovare automaticamente le operazioni che non vanno a buon fine a causa di errori temporanei. Questo documento mostra come configurare una policy di ripetizione dei tentativi predefinita su un client, impostare i limiti di tempo e di tentativi ed eseguire l'override della policy di ripetizione dei tentativi per le singole richieste.

Prima di iniziare

Gli esempi in questo documento utilizzano Secret Manager, anche se gli stessi concetti si applicano ad altri servizi Google Cloud .

Prima di eseguire il codice in questo documento, segui Crea e accedi a un secret utilizzando Secret Manager per abilitare l'API Secret Manager e configurare l'autenticazione.

Dipendenze

Aggiungi i crate richiesti al file Cargo.toml:

cargo add google-cloud-secretmanager-v1 google-cloud-gax anyhow

Configura una policy di ripetizione dei tentativi predefinita

Questo esempio utilizza la policy Aip194Strict, che implementa le linee guida in AIP-194 per i nuovi tentativi di richieste API di Google.

Per configurare Aip194Strict come policy di ripetizione predefinita per un client, completa i seguenti passaggi:

  1. Imposta la policy di ripetizione durante l'inizializzazione del client:

    let client = SecretManagerService::builder()
        .with_retry_policy(Aip194Strict)
        .build()
        .await?;

  2. Invia richieste utilizzando il client configurato:

    let mut list = client
        .list_secrets()
        .set_parent(format!("projects/{project_id}"))
        .by_item();
    while let Some(secret) = list.next().await {
        let secret = secret?;
        println!("  secret={}", secret.name);
    }

Codice completo per una policy di ripetizione predefinita

L'esempio seguente applica Aip194Strict a un client Secret Manager:

use google_cloud_gax::paginator::ItemPaginator as _;
use google_cloud_gax::retry_policy::Aip194Strict;
use google_cloud_secretmanager_v1::client::SecretManagerService;

pub async fn sample(project_id: &str) -> anyhow::Result<()> {
    let client = SecretManagerService::builder()
        .with_retry_policy(Aip194Strict)
        .build()
        .await?;

    let mut list = client
        .list_secrets()
        .set_parent(format!("projects/{project_id}"))
        .by_item();
    while let Some(secret) = list.next().await {
        let secret = secret?;
        println!("  secret={}", secret.name);
    }

    Ok(())
}

Configura una policy di ripetizione predefinita con limiti

Per impostazione predefinita, Aip194Strict non limita il numero di tentativi o il tempo totale impiegato per i nuovi tentativi. Per configurare i limiti di tentativi e di tempo su un client, porta il tratto RetryPolicyExt nell'ambito e completa i seguenti passaggi:

  1. Configura la policy di ripetizione con with_attempt_limit e with_time_limit sul generatore di client:

    let client = SecretManagerService::builder()
        .with_retry_policy(
            Aip194Strict
                .with_attempt_limit(5)
                .with_time_limit(Duration::from_secs(15)),
        )
        .build()
        .await?;

  2. Invia richieste utilizzando il client configurato:

    let mut list = client
        .list_secrets()
        .set_parent(format!("projects/{project_id}"))
        .by_item();
    while let Some(secret) = list.next().await {
        let secret = secret?;
        println!("  secret={}", secret.name);
    }

Codice completo per una policy di ripetizione con limiti

L'esempio seguente applica Aip194Strict con limiti di tempo e tentativi personalizzati:

use google_cloud_gax::paginator::ItemPaginator as _;
use google_cloud_gax::retry_policy::Aip194Strict;
use google_cloud_gax::retry_policy::RetryPolicyExt;
use google_cloud_secretmanager_v1::client::SecretManagerService;
use std::time::Duration;

pub async fn sample(project_id: &str) -> anyhow::Result<()> {
    let client = SecretManagerService::builder()
        .with_retry_policy(
            Aip194Strict
                .with_attempt_limit(5)
                .with_time_limit(Duration::from_secs(15)),
        )
        .build()
        .await?;

    let mut list = client
        .list_secrets()
        .set_parent(format!("projects/{project_id}"))
        .by_item();
    while let Some(secret) = list.next().await {
        let secret = secret?;
        println!("  secret={}", secret.name);
    }

    Ok(())
}

Esegui l'override della policy di ripetizione per una singola richiesta

Puoi eseguire l'override della policy di ripetizione su una singola richiesta quando sai che la ripetizione di un'operazione specifica è sicura per la tua applicazione. Ad esempio, l'eliminazione di un secret può riuscire al massimo una volta, anche se la libreria client tratta le operazioni di eliminazione come non idempotenti per impostazione predefinita.

Inserisci RequestOptionsBuilder, RetryPolicyExt e AlwaysRetry nell'ambito, quindi chiama with_retry_policy sul generatore di richieste:

client
    .delete_secret()
    .set_name(format!("projects/{project_id}/secrets/{secret_id}"))
    .with_retry_policy(
        AlwaysRetry
            .with_attempt_limit(5)
            .with_time_limit(Duration::from_secs(15)),
    )
    .send()
    .await?;

Codice completo per una policy di ripetizione per richiesta

L'esempio seguente esegue l'override della policy per i nuovi tentativi, del limite di tentativi e del limite di tempo per una singola richiesta delete_secret:

use google_cloud_gax::options::RequestOptionsBuilder;
use google_cloud_gax::retry_policy::AlwaysRetry;
use google_cloud_gax::retry_policy::RetryPolicyExt;
use google_cloud_secretmanager_v1::client::SecretManagerService;
use std::time::Duration;

pub async fn sample(
    client: &SecretManagerService,
    project_id: &str,
    secret_id: &str,
) -> anyhow::Result<()> {
    client
        .delete_secret()
        .set_name(format!("projects/{project_id}/secrets/{secret_id}"))
        .with_retry_policy(
            AlwaysRetry
                .with_attempt_limit(5)
                .with_time_limit(Duration::from_secs(15)),
        )
        .send()
        .await?;

    Ok(())
}