Actualiza un recurso con una máscara de campo

Obtén información para actualizar recursos de forma selectiva con máscaras de campo. Cuando actualizas un recurso en Google Cloud, es posible que desees modificar solo campos específicos en lugar de reemplazar todo el recurso. Las bibliotecas cliente de Rust admiten máscaras de campo, lo que te permite controlar con precisión qué campos de un recurso se actualizan y cuáles no.

Requisitos previos

En esta guía, se usa la API de Secret Manager, pero los conceptos se aplican a otros recursos y servicios de Google Cloud .

Antes de continuar, sigue los pasos en Crea un secreto y accede a él con Secret Manager para habilitar y autenticar la API de Secret Manager.

Para obtener instrucciones completas sobre la configuración de las bibliotecas de Rust, consulta Cómo configurar tu entorno de desarrollo.

Dependencias

Después de habilitar Secret Manager, declara tus dependencias en el archivo Cargo.toml:

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

Instala tipos conocidos

El crate google_cloud_wkt contiene tipos conocidos para las APIs de Google Cloud . Estos tipos suelen tener una codificación JSON personalizada y pueden proporcionar funciones de conversión hacia y desde tipos de Rust de uso común. El crate google_cloud_wkt contiene el tipo de máscara de campo, FieldMask.

Agrega el crate como una dependencia:

cargo add google-cloud-wkt

Máscaras de campo

Un FieldMask representa un conjunto de rutas de campos simbólicos. Las máscaras de campo especifican un subconjunto de campos que una operación de actualización modifica o que una operación de obtención devuelve.

En una operación de actualización, una máscara de campo especifica qué campos del recurso objetivo se deben actualizar. La API solo cambia los valores de los campos especificados en la máscara y deja los demás sin modificar. Si pasas un recurso para describir los valores actualizados, la API ignora los valores de todos los campos no incluidos en la máscara. Si no proporcionas una máscara de campo en la actualización, la operación se aplica a todos los campos.

Para restablecer un campo al valor predeterminado, incluye el campo en la máscara y establece el valor predeterminado en el recurso proporcionado. Para restablecer todos los campos de un recurso, proporciona una instancia predeterminada del recurso y establece todos los campos en la máscara, o bien no proporciones una máscara.

Actualiza campos en un recurso

Primero, inicializa un cliente de Secret Manager y crea un secreto:

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

El resultado de la operación de creación muestra que los campos labels y annotations están vacíos.

En el siguiente código, se actualizan los campos labels y 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:?}");

El método set_etag te permite establecer un ETag en el secreto, lo que evita que se sobrescriban las actualizaciones simultáneas.

Después de establecer etiquetas y anotaciones en el secreto actualizado, pasa una máscara de campo a set_update_mask para especificar las rutas de acceso de los campos que se actualizarán:

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

El resultado de la operación de actualización muestra que los campos se actualizaron:

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

Actualiza un campo: código completo

En este ejemplo de código, se inicializa y crea un secreto, y, luego, se aplica una 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(())
}