Atualizar um recurso usando uma máscara de campo

Saiba como atualizar recursos seletivamente usando máscaras de campo. Ao atualizar um recurso em Google Cloud, talvez você queira modificar apenas campos específicos em vez de substituir o recurso inteiro. As bibliotecas de cliente Rust aceitam máscaras de campo, permitindo controlar com precisão quais campos de um recurso são atualizados, deixando outros campos inalterados.

Pré-requisitos

Este guia usa a API Secret Manager, mas os conceitos se aplicam a outros recursos e serviços do Google Cloud .

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

Para instruções completas de configuração das bibliotecas Rust, consulte Como configurar seu ambiente de desenvolvimento.

Dependências

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

cargo add google-cloud-secretmanager-v1
cargo add tokio

Instalar tipos conhecidos

O crate google_cloud_wkt contém tipos conhecidos para APIs Google Cloud . Esses tipos geralmente têm codificação JSON personalizada e podem fornecer funções de conversão para e de tipos Rust usados com frequência. O crate google_cloud_wkt contém o tipo de máscara de campo, FieldMask.

Adicione a caixa como uma dependência:

cargo add google-cloud-wkt

Máscaras de campo

Um FieldMask representa um conjunto de caminhos de campo simbólicos. As máscaras de campo especificam um subconjunto de campos que uma operação de atualização modifica ou uma operação de leitura retorna.

Em uma operação de atualização, uma máscara de campo especifica quais campos do recurso de destino serão atualizados. A API muda apenas os valores dos campos especificados na máscara e deixa os outros inalterados. Se você transmitir um recurso para descrever os valores atualizados, a API vai ignorar os valores de todos os campos não cobertos pela máscara. Se você não fornecer uma máscara de campo na atualização, a operação será aplicada a todos os campos.

Para redefinir um campo para o valor padrão, inclua o campo na máscara e defina o valor padrão no recurso fornecido. Para redefinir todos os campos de um recurso, forneça uma instância padrão do recurso e defina todos os campos na máscara ou não forneça uma máscara.

Atualizar campos em um recurso

Primeiro, inicialize um cliente do Secret Manager e crie um secret:

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

    let secret = client
        .create_secret()
        .set_parent(format!("projects/{project_id}"))
        .set_secret_id("your-secret")
        .set_secret(
            Secret::new().set_replication(Replication::new().set_automatic(Automatic::new())),
        )
        .send()
        .await?;
    println!("CREATE = {secret:?}");

A saída da operação de criação mostra que os campos labels e annotations estão vazios.

O código a seguir atualiza os campos labels e annotations:

    let tag = |mut labels: HashMap<_, _>, msg: &str| {
        labels.insert("updated".to_string(), msg.to_string());
        labels
    };

    let update = client
        .update_secret()
        .set_secret(
            Secret::new()
                .set_name(&secret.name)
                .set_etag(secret.etag)
                .set_labels(tag(secret.labels, "your-label"))
                .set_annotations(tag(secret.annotations, "your-annotations")),
        )
        .set_update_mask(FieldMask::default().set_paths(["annotations", "labels"]))
        .send()
        .await?;
    println!("UPDATE = {update:?}");

O método set_etag permite definir uma ETag no secret, o que evita a substituição de atualizações simultâneas.

Depois de definir rótulos e anotações no secret atualizado, transmita uma máscara de campo para set_update_mask e especifique os caminhos de campo a serem atualizados:

        .set_update_mask(FieldMask::default().set_paths(["annotations", "labels"]))

A saída da operação de atualização mostra que os campos foram atualizados:

labels: {"updated": "your-label"},
...
annotations: {"updated": "your-annotations"},

Atualizar um campo: código completo

Este exemplo de código inicializa e cria uma chave secreta e, em seguida, aplica uma máscara de campo:

use google_cloud_secretmanager_v1::client::SecretManagerService;
use google_cloud_secretmanager_v1::model::replication::Automatic;
use google_cloud_secretmanager_v1::model::{Replication, Secret};
use google_cloud_wkt::FieldMask;
use std::collections::HashMap;

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

    let secret = client
        .create_secret()
        .set_parent(format!("projects/{project_id}"))
        .set_secret_id("your-secret")
        .set_secret(
            Secret::new().set_replication(Replication::new().set_automatic(Automatic::new())),
        )
        .send()
        .await?;
    println!("CREATE = {secret:?}");

    let tag = |mut labels: HashMap<_, _>, msg: &str| {
        labels.insert("updated".to_string(), msg.to_string());
        labels
    };

    let update = client
        .update_secret()
        .set_secret(
            Secret::new()
                .set_name(&secret.name)
                .set_etag(secret.etag)
                .set_labels(tag(secret.labels, "your-label"))
                .set_annotations(tag(secret.annotations, "your-annotations")),
        )
        .set_update_mask(FieldMask::default().set_paths(["annotations", "labels"]))
        .send()
        .await?;
    println!("UPDATE = {update:?}");

    Ok(())
}