Como configurar políticas de nova tentativa

As Google Cloud bibliotecas de cliente do Rust podem repetir automaticamente as operações que falham devido a erros temporários. Saiba como criar e personalizar loops de repetição, implementar uma política comum para todas as solicitações e substituir as políticas padrão para solicitações específicas.

Pré-requisitos

Os exemplos neste guia usam o serviço do Secret Manager. No entanto, os mesmos conceitos funcionam para outros Google Cloud serviços.

Antes de continuar, siga as etapas em Criar e acessar um secret usando o Secret Manager para ativar e autenticar a API Secret Manager.

Dependências

Depois de ativar o Secret Manager, declare suas dependências no arquivo Cargo.toml:

cargo add google-cloud-secretmanager-v1

Configurar a política de repetição padrão

Este exemplo usa a política Aip194Strict. Essa política é baseada nas diretrizes do AIP-194, que documenta as condições em que um cliente da API Google deve repetir automaticamente uma solicitação.

Para definir a política Aip194Strict como a política padrão de um serviço, defina a política durante a inicialização do cliente:

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

Depois de definir a política, você pode usar o serviço normalmente:

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

Como configurar a política de repetição padrão: código completo

Este exemplo de código aplica a política Aip194Strict ao serviço do 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(())
}

Configurar a política de repetição padrão com limites

Por padrão, a política Aip194Strict não limita o número de tentativas de repetição nem o tempo gasto repetindo solicitações. No entanto, é possível adicionar limites à política.

Por exemplo, é possível limitar o número de tentativas e o tempo gasto no loop de repetição:

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

Com essa configuração, as solicitações funcionarão normalmente:

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

Configurar a política de repetição padrão com limites: código completo

Este exemplo de código aplica a política Aip194Strict ao serviço do Secret Manager com um limite de tentativas e um limite de tempo personalizados.

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

Substituir a política de repetição de uma solicitação

Às vezes, os aplicativos precisam substituir a política de repetição de uma solicitação específica. Por exemplo, o desenvolvedor do aplicativo pode conhecer detalhes específicos do serviço ou aplicativo e determinar que é seguro tolerar mais erros.

Por exemplo, excluir um secret é idempotente, porque só pode ser bem-sucedido uma vez. Mas a biblioteca de cliente pressupõe que todas as operações de exclusão não são seguras. É possível substituir a política de uma solicitação:

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

Substituir a política de repetição de uma solicitação: código completo

Este exemplo de código substitui o limite de tentativas e o limite de tempo de uma solicitação específica ao serviço do 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(())
}