如何使用Rust最优且安全地编辑Kubernetes Secret？

我需要更新Kubernetes Secret的data字段值，目前用Rust的kube库只能调用创建和删除API，没找到直接的更新/编辑接口，现在只能先删除再重建，但想找更优、更安全的实现方式。现有创建和删除Secret的代码如下：

async fn create_k8s_secret(secrets: &Api<Secret>, secret: &Secret) -> bool {
    let secret_name = secret.metadata.name.as_ref().unwrap().clone();
    match secrets.create(&PostParams::default(), &secret).await {
        Ok(_) => {
            debug!("Successfully created secret: {}", secret_name);
            true
        }
        Err(kube::Error::Api(ErrorResponse { code, reason, .. }))
            if code == 409 && reason == "AlreadyExists" =>
        {
            debug!("Secret {} already exists. Ignoring...", secret_name);
            true
        }
        Err(e) => {
            error!("Error creating secret {}: {}", secret_name, e);
            false
        }
    }
}

async fn delete_k8s_secret(secrets: &Api<Secret>, secret: &Secret) -> bool {
    let secret_name = secret.metadata.name.as_ref().unwrap().clone();
    let delete_options = kube::api::DeleteParams::default();
    match secrets.delete(&secret_name, &delete_options).await {
        Ok(_) => {
            debug!("Successfully deleted the secret: {}", secret_name);
            true
        }
        Err(kube::Error::Api(ErrorResponse { code, reason, .. }))
            if code == 404 && reason == "NotFound" =>
        {
            debug!("Secret {} does not exist. Ignoring...", secret_name);
            true
        }
        Err(e) => {
            error!("Error deleting secret {}: {}", secret_name, e);
            false
        }
    }
}

推荐两种比“删了重建”更安全的方式，都基于kube库原生支持的API，不会出现Secret短暂缺失的窗口：

1. 替换整个Secret（Replace） #

先获取现有Secret的最新版本，修改目标字段后调用replace接口，通过resourceVersion实现乐观锁，避免并发更新冲突：

use kube::api::{Api, ReplaceParams};
use k8s_openapi::api::core::v1::Secret;

async fn replace_k8s_secret(secrets: &Api<Secret>, updated_secret: &Secret) -> bool {
    let secret_name = updated_secret.metadata.name.as_ref().unwrap().clone();
    
    // 获取现有Secret确保拿到最新版本
    match secrets.get(&secret_name).await {
        Ok(mut existing_secret) => {
            // 替换data字段，保留原Secret的其他属性（如annotations、labels等）
            existing_secret.data = updated_secret.data.clone();
            // 传递resourceVersion做乐观锁，防止覆盖并发更新
            existing_secret.metadata.resource_version = updated_secret.metadata.resource_version.clone();
            
            let replace_params = ReplaceParams::default();
            match secrets.replace(&secret_name, &replace_params, &existing_secret).await {
                Ok(_) => {
                    debug!("Successfully replaced secret: {}", secret_name);
                    true
                }
                Err(e) => {
                    error!("Error replacing secret {}: {}", secret_name, e);
                    false
                }
            }
        }
        Err(e) => {
            error!("Failed to fetch existing secret {}: {}", secret_name, e);
            false
        }
    }
}

2. 局部更新（Patch，推荐） #

只修改需要更新的data字段，用Merge Patch方式提交变更，操作更轻量，冲突概率更低：

use kube::api::{Api, Patch, PatchParams};
use k8s_openapi::api::core::v1::Secret;
use std::collections::BTreeMap;

async fn patch_k8s_secret(secrets: &Api<Secret>, secret_name: &str, new_data: BTreeMap<String, String>) -> bool {
    let patch_params = PatchParams::default();
    // 构造Merge Patch，仅包含要更新的data字段
    let patch_payload = serde_json::json!({
        "data": new_data
    });

    match secrets.patch(secret_name, &patch_params, &Patch::Merge(&patch_payload)).await {
        Ok(_) => {
            debug!("Successfully patched secret: {}", secret_name);
            true
        }
        Err(e) => {
            error!("Error patching secret {}: {}", secret_name, e);
            false
        }
    }
}

为什么这两种方式更优？ #

• 没有Secret不存在的时间窗口，依赖该Secret的Pod不会因短暂缺失而报错
• 支持乐观锁机制，避免并发场景下的更新覆盖问题
• Patch方式仅修改目标字段，减少不必要的资源操作，效率更高

内容的提问来源于stack exchange，提问作者Aviral Srivastava