Aggiorna una risorsa utilizzando una maschera dei campi

Scopri come aggiornare selettivamente le risorse utilizzando le maschere di campo. Quando aggiorni una risorsa in Google Cloud, potresti voler modificare solo campi specifici anziché sostituire l'intera risorsa. Le librerie client Rust supportano le maschere di campo, consentendoti di controllare con precisione quali campi di una risorsa vengono aggiornati lasciando invariati gli altri campi.

Prerequisiti

Questa guida utilizza l'API Secret Manager, ma i concetti si applicano ad altri Google Cloud servizi e risorse.

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.

Per istruzioni di configurazione complete per le librerie Rust, vedi Configurazione dell'ambiente di sviluppo.

Dipendenze

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

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

Installare tipi noti

Il crate google_cloud_wkt contiene tipi noti per le API Google Cloud . Questi tipi in genere hanno una codifica JSON personalizzata e potrebbero fornire funzioni di conversione da e verso i tipi Rust di uso comune. La cassa google_cloud_wkt contiene il tipo di maschera del campo, FieldMask.

Aggiungi la crate come dipendenza:

cargo add google-cloud-wkt

Maschere dei campi

Una FieldMask rappresenta un insieme di percorsi di campi simbolici. Le maschere di campo specificano un sottoinsieme di campi che un'operazione di aggiornamento modifica o un'operazione di recupero restituisce.

In un'operazione di aggiornamento, una maschera di campo specifica quali campi della risorsa di destinazione aggiornare. L'API modifica solo i valori dei campi specificati nella maschera e lascia invariati gli altri. Se passi una risorsa per descrivere i valori aggiornati, l'API ignora i valori di tutti i campi non coperti dalla maschera. Se non fornisci una maschera di campo durante l'aggiornamento, l'operazione viene applicata a tutti i campi.

Per reimpostare un campo sul valore predefinito, includilo nella maschera e imposta il valore predefinito nella risorsa fornita. Per reimpostare tutti i campi di una risorsa, fornisci un'istanza predefinita della risorsa e imposta tutti i campi nella maschera oppure non fornire una maschera.

Aggiornare i campi di una risorsa

Innanzitutto, inizializza un client Secret Manager e crea un 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:?}");

L'output dell'operazione di creazione mostra che i campi labels e annotations sono vuoti.

Il seguente codice aggiorna i campi 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:?}");

Il metodo set_etag consente di impostare un ETag sul secret, il che impedisce la sovrascrittura degli aggiornamenti simultanei.

Dopo aver impostato etichette e annotazioni sul secret aggiornato, trasmetti una maschera di campo a set_update_mask per specificare i percorsi dei campi da aggiornare:

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

L'output dell'operazione di aggiornamento mostra che i campi sono aggiornati:

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

Aggiorna un campo: codice completo

Questo codice campione inizializza e crea un secret, quindi applica una maschera di 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(())
}