Aggiorna una risorsa utilizzando una maschera dei campi

Quando aggiorni una risorsa in Google Cloud, spesso vuoi modificare campi specifici senza sostituire l'intera risorsa. Le librerie client di Cloud per Rust supportano le maschere di campo in modo da poter specificare quali campi vengono modificati da un'operazione di aggiornamento e lasciare invariati tutti gli altri campi.

Prima di iniziare

Questo documento utilizza l'API Secret Manager, anche se gli stessi concetti si applicano ad altri servizi Google Cloud .

Prima di eseguire il codice in questo documento, completa i seguenti prerequisiti:

Dipendenze

Il crate google-cloud-wkt fornisce tipi noti per le API Google Cloud, tra cui FieldMask. Aggiungi google-cloud-secretmanager-v1, google-cloud-wkt, anyhow e tokio al file Cargo.toml:

cargo add google-cloud-secretmanager-v1 google-cloud-wkt anyhow
cargo add tokio --features macros,rt-multi-thread

Come funzionano le maschere di campo

Un FieldMask contiene un insieme di percorsi di campi simbolici che identificano i campi modificati da un'operazione di aggiornamento o restituiti da un'operazione di lettura.

In un'operazione di aggiornamento, il servizio modifica solo i campi elencati nella maschera e ignora i valori di tutti i campi non elencati nel messaggio di richiesta. Se ometti la maschera di campo in una richiesta di aggiornamento, l'operazione viene applicata a tutti i campi modificabili.

Per reimpostare un campo specifico sul valore predefinito, includi il percorso del campo nella maschera e lascia il campo sul valore predefinito nella struttura della risorsa.

Aggiorna i campi di una risorsa

Per creare un secret e aggiornare in modo selettivo i campi labels e annotations utilizzando un FieldMask, completa i seguenti passaggi:

  1. Inizializza un client SecretManagerService e crea un secret con labels e annotations vuoti:

    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:?}");

  2. Invia una richiesta update_secret che imposta labels, annotations, il valore etag corrente per impedire la sovrascrittura degli aggiornamenti simultanei e una maschera di aggiornamento che copre "annotations" e "labels":

    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:?}");

    La chiamata set_update_mask specifica i percorsi esatti dei campi da modificare:

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

L'output conferma che l'operazione ha aggiornato entrambi i campi:

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

Completamento codice

La seguente funzione combina la creazione del secret e l'aggiornamento della 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(())
}

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi e per prevenire errori ALREADY_EXISTS nelle esecuzioni successive, elimina il secret your-secret al termine.