Wiederholungsrichtlinien konfigurieren

Die Google Cloud Clientbibliotheken für Rust können automatisch Vorgänge wiederholen, die aufgrund von vorübergehenden Fehlern fehlschlagen. Hier erfahren Sie, wie Sie Wiederholungsschleifen erstellen und anpassen, eine gemeinsame Wiederholungsrichtlinie für alle Anfragen implementieren und Standardrichtlinien für bestimmte Anfragen überschreiben.

Vorbereitung

In den Beispielen in diesem Leitfaden wird der Secret Manager-Dienst verwendet. Dieselben Konzepte können jedoch auf andere Google Cloud Dienste angewendet werden.

Bevor Sie fortfahren, folgen Sie der Anleitung unter Secret mit Secret Manager erstellen und darauf zugreifen, um die Secret Manager API zu aktivieren und zu authentifizieren.

Abhängigkeiten

Nachdem Sie Secret Manager aktiviert haben, deklarieren Sie Ihre Abhängigkeiten in der Datei Cargo.toml:

cargo add google-cloud-secretmanager-v1

Standard-Wiederholungsrichtlinie konfigurieren

In diesem Beispiel wird die Richtlinie Aip194Strict verwendet. Diese Richtlinie basiert auf den Richtlinien in AIP-194, in dem die Bedingungen dokumentiert sind, unter denen ein Google API-Client eine Anfrage automatisch wiederholen sollte.

Hinweis :Die AIP-194-Richtlinie ist relativ streng. Bei Fehlern, die darauf hindeuten, dass die Anfrage den Dienst möglicherweise erreicht hat, wird kein neuer Versuch unternommen, es sei denn, die Anfrage ist idempotent. Daher kann die Richtlinie bedenkenlos als Standard verwendet werden. Der einzige Nachteil sind möglicherweise zusätzliche Anfragen an den Dienst, die Kontingente und Abrechnung belasten.

Wenn Sie die Aip194Strict-Richtlinie zur Standardrichtlinie für einen Dienst machen möchten, legen Sie die Richtlinie während der Client-Initialisierung fest:

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

Nachdem Sie die Richtlinie festgelegt haben, können Sie den Dienst wie gewohnt verwenden:

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

Standard-Wiederholungsrichtlinie konfigurieren: vollständiger Code

In diesem Codebeispiel wird die Aip194Strict-Richtlinie auf den Secret Manager-Dienst angewendet.

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

Standardmäßige Wiederholungsrichtlinie mit Limits konfigurieren

Standardmäßig werden durch die Aip194Strict-Richtlinie weder die Anzahl der Wiederholungsversuche noch die für das Wiederholen von Anfragen aufgewendete Zeit begrenzt. Sie können der Richtlinie jedoch Limits hinzufügen.

Sie können beispielsweise sowohl die Anzahl der Versuche als auch die Zeit, die in der Wiederholungsschleife verbracht wird, begrenzen:

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

Bei dieser Konfiguration funktionieren Anfragen wie gewohnt:

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

Standardwiederholungsrichtlinie mit Limits konfigurieren: vollständiger Code

In diesem Codebeispiel wird die Richtlinie Aip194Strict auf den Secret Manager-Dienst mit einem benutzerdefinierten Limit für Versuche und einem benutzerdefinierten Zeitlimit angewendet.

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

Wiederholungsrichtlinie für eine Anfrage überschreiben

Manchmal müssen Anwendungen die Richtlinie für Wiederholungsversuche für eine bestimmte Anfrage überschreiben. So kann der Anwendungsentwickler beispielsweise bestimmte Details des Dienstes oder der Anwendung kennen und feststellen, dass es sicher ist, mehr Fehler zu tolerieren.

Das Löschen eines Secrets ist beispielsweise idempotent, da es nur einmal erfolgreich ausgeführt werden kann. Die Clientbibliothek geht jedoch davon aus, dass alle Löschvorgänge unsicher sind. Sie können die Richtlinie für eine Anfrage überschreiben:

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

Wiederholungsrichtlinie für eine Anfrage überschreiben: vollständiger Code

In diesem Codebeispiel werden das Limit für Versuche und das Zeitlimit für eine bestimmte Anfrage an den Secret Manager-Dienst überschrieben.

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