Bibliothèque Azure Key Vault Secrets pour Rust

Stockage sécurisé pour les mots de passe, les clés API et les chaînes de connexion.

Utilisez cette skill quand :

• Une application doit stocker ou récupérer des secrets depuis Azure Key Vault en Rust
• Vous devez définir, obtenir, mettre à jour ou supprimer des secrets
• Vous devez lister les propriétés des secrets avec pagination
• Vous devez gérer les erreurs pour les secrets manquants

IMPORTANT : Utilisez uniquement la crate officielle azure_security_keyvault_secrets publiée par l'utilisateur azure-sdk sur crates.io. N'utilisez PAS de crates non officielles ou communautaires. Les crates officielles utilisent des underscores dans leurs noms et aucune n'a la version 0.21.0.

Installation

cargo add azure_security_keyvault_secrets azure_identity tokio futures

Ne pas ajouter azure_core directement à Cargo.toml. Elle est réexportée par azure_security_keyvault_secrets.

Variables d'environnement

AZURE_KEYVAULT_URL=https://<vault-name>.vault.azure.net/ # Requis pour toutes les opérations

Authentification

use azure_identity::DeveloperToolsCredential;
use azure_security_keyvault_secrets::SecretClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Dev local : DeveloperToolsCredential. Production : utilisez ManagedIdentityCredential.
    let credential = DeveloperToolsCredential::new(None)?;
    let client = SecretClient::new(
        "https://<vault-name>.vault.azure.net/",
        credential.clone(),
        None,
    )?;

    let secret = client
        .get_secret("secret-name", None)
        .await?
        .into_model()?;
    println!("Secret: {:?}", secret.value);
    Ok(())
}

Workflow principal

Définir un secret

use azure_security_keyvault_secrets::{models::SetSecretParameters, ResourceExt};

let params = SetSecretParameters {
    value: Some("secret-value".into()),
    ..Default::default()
};

let secret = client
    .set_secret("secret-name", params.try_into()?, None)
    .await?
    .into_model()?;

println!(
    "Name: {:?}, Version: {:?}",
    secret.resource_id()?.name,
    secret.resource_id()?.version
);

Mettre à jour les propriétés d'un secret

use azure_security_keyvault_secrets::models::UpdateSecretPropertiesParameters;
use std::collections::HashMap;

#[allow(clippy::needless_update)]
let params = UpdateSecretPropertiesParameters {
    content_type: Some("text/plain".into()),
    tags: Some(HashMap::from_iter(vec![(
        "env".into(),
        "prod".into(),
    )])),
    ..Default::default()
};

client
    .update_secret_properties("secret-name", params.try_into()?, None)
    .await?
    .into_model()?;

Supprimer un secret

client.delete_secret("secret-name", None).await?;

Lister les secrets (Pagination)

list_secret_properties retourne un Pager<T> — itérez directement les éléments :

use azure_security_keyvault_secrets::ResourceExt;
use futures::TryStreamExt as _;

let mut pager = client.list_secret_properties(None)?;
while let Some(secret) = pager.try_next().await? {
    println!("Found: {}", secret.resource_id()?.name);
}

Gestion des erreurs

use azure_core::{error::ErrorKind, http::StatusCode};

match client.get_secret("secret-name", None).await {
    Ok(response) => println!("Secret: {:?}", response.into_model()?.value),
    Err(e) => match e.kind() {
        ErrorKind::HttpResponse { status, error_code, .. }
            if *status == StatusCode::NotFound =>
        {
            println!("Secret not found");
            if let Some(code) = error_code {
                println!("ErrorCode: {code}");
            }
        }
        _ => println!("Error: {e:?}"),
    },
}

Rôles RBAC

Pour l'authentification Entra ID, attribuez l'un de ces rôles :

Bonnes pratiques

1. Utilisez DeveloperToolsCredential pour le dev local, ManagedIdentityCredential pour la production — le SDK Rust n'a pas de DefaultAzureCredential
2. Ne codez jamais les credentials en dur — utilisez les variables d'environnement ou l'identité managée
3. Utilisez ..Default::default() avec #[allow(clippy::needless_update)] pour les mises à jour de structs de modèles
4. Utilisez ResourceExt pour extraire le nom et la version de la ressource depuis les IDs de secrets
5. Réutilisez les clients — SecretClient est thread-safe ; créez une fois, partagez entre les tâches

Liens de référence