Configurazione dei criteri di ripetizione dei tentativi

Le librerie client Google Cloud per Rust possono riprovare automaticamente le operazioni non riuscite a causa di errori temporanei. Scopri come creare e personalizzare cicli di nuovi tentativi, implementare una politica di nuovi tentativi comune per tutte le richieste ed eseguire l'override delle politiche predefinite per richieste specifiche.

Prerequisiti

Gli esempi in questa guida utilizzano il servizio Secret Manager. Tuttavia, gli stessi concetti funzionano per altri servizi Google Cloud .

Prima di continuare, segui la procedura descritta in Creare e accedere a un secret utilizzando Secret Manager per abilitare e autenticare l'API Secret Manager.

Dipendenze

Dopo aver attivato Secret Manager, dichiara le dipendenze nel file Cargo.toml:

cargo add google-cloud-secretmanager-v1

Configura la policy di ripetizione dei tentativi predefinita

Questo esempio utilizza il criterio Aip194Strict. Queste norme si basano sulle linee guida riportate in AIP-194, che documenta le condizioni in base alle quali un client API di Google deve riprovare automaticamente una richiesta.

Nota: le norme AIP-194 sono piuttosto rigide e non riproveranno alcun errore che indica che la richiesta potrebbe aver raggiunto il servizio, a meno che non sia idempotente. Pertanto, la norma può essere utilizzata in sicurezza come predefinita. L'unico svantaggio potrebbero essere le richieste aggiuntive al servizio, che consumano parte della quota e della fatturazione.

Per impostare il criterio Aip194Strict come criterio predefinito per un servizio, imposta il criterio durante l'inizializzazione del client:

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

Una volta impostato il criterio, puoi utilizzare il servizio come di consueto:

   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);
   }

Configurazione della policy di ripetizione dei tentativi predefinita: codice completo

Questo esempio di codice applica le norme Aip194Strict al servizio 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 la policy di ripetizione dei tentativi predefinita con limiti

Per impostazione predefinita, la policy Aip194Strict non limita il numero di tentativi di ripetizione o il tempo dedicato ai tentativi di ripetizione delle richieste. Tuttavia, puoi aggiungere limiti alla policy.

Ad esempio, puoi limitare sia il numero di tentativi sia il tempo trascorso nel ciclo di nuovi tentativi:

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

Con questa configurazione, le richieste funzioneranno come di consueto:

   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);
   }

Configura la policy di ripetizione dei tentativi predefinita con limiti: codice completo

Questo esempio di codice applica il criterio Aip194Strict al servizio Secret Manager con un limite di tentativi e un limite di tempo 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(())
}

Ignorare la policy di ripetizione dei tentativi per una richiesta

A volte le applicazioni devono ignorare i criteri di ripetizione per una richiesta specifica. Ad esempio, lo sviluppatore dell'applicazione potrebbe conoscere dettagli specifici del servizio o dell'applicazione e determinare che è sicuro tollerare più errori.

Ad esempio, l'eliminazione di un secret è idempotente, perché può avere esito positivo una sola volta. Tuttavia, la libreria client presuppone che tutte le operazioni di eliminazione non siano sicure. Puoi ignorare le norme per una richiesta:

   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?;

Eseguire l'override della policy di ripetizione dei tentativi per una richiesta: codice completo

Questo esempio di codice esegue l'override del limite di tentativi e del limite di tempo per una richiesta specifica al servizio Secret Manager.

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(())
}