Bibliothèque Azure Key Vault Certificates pour Rust

Gérez les certificats X.509 pour TLS/SSL, la signature de code et l'authentification.

Utilisez ce skill quand :

• Une app doit créer ou gérer des certificats X.509 dans Key Vault depuis Rust
• Vous avez besoin de certificats auto-signés ou émis par une CA
• Vous avez besoin d'opérations longue durée (LRO) pour l'émission de certificats
• Vous devez signer des données avec la clé d'un certificat

IMPORTANT : Utilisez uniquement le crate officiel azure_security_keyvault_certificates publié par l'utilisateur azure-sdk sur crates.io. N'utilisez PAS de crates non officiels ou communautaires. Les crates officiels utilisent des underscores dans les noms et aucun n'a la version 0.21.0.

Installation

cargo add azure_security_keyvault_certificates azure_identity tokio futures

Ne pas ajouter azure_core directement à Cargo.toml. Il est réexporté par azure_security_keyvault_certificates.

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_certificates::CertificateClient;

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

    let cert = client
        .get_certificate("cert-name", None)
        .await?
        .into_model()?;
    println!("Certificate: {:?}", cert.id);
    Ok(())
}

Flux de travail principal

Créer un certificat auto-signé (LRO)

Créer un certificat est une opération longue durée. Poller<T> implémente IntoFuture — il suffit de .await :

use azure_security_keyvault_certificates::{
    models::{
        CertificateCreateParameters, IssuerParameters, SecretProperties,
        SubjectAlternativeNames, X509CertificateProperties,
    },
    ResourceExt,
};

let body = CertificateCreateParameters {
    certificate_policy: Some(Box::new(
        azure_security_keyvault_certificates::models::CertificatePolicy {
            issuer_parameters: Some(IssuerParameters {
                name: Some("Self".into()),
                ..Default::default()
            }),
            secret_properties: Some(SecretProperties {
                content_type: Some("application/x-pkcs12".into()),
                ..Default::default()
            }),
            x509_certificate_properties: Some(X509CertificateProperties {
                subject: Some("CN=example.com".into()),
                subject_alternative_names: Some(SubjectAlternativeNames {
                    dns_names: Some(vec!["example.com".into()]),
                    ..Default::default()
                }),
                ..Default::default()
            }),
            ..Default::default()
        },
    )),
    ..Default::default()
};

// Poller implémente IntoFuture — attendez directement la fin
let cert = client
    .create_certificate("cert-name", body.try_into()?, None)?
    .await?
    .into_model()?;

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

Mettre à jour les propriétés du certificat

use azure_security_keyvault_certificates::models::CertificateUpdateParameters;
use std::collections::HashMap;

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

client
    .update_certificate("cert-name", params.try_into()?, None)
    .await?
    .into_model()?;

Supprimer un certificat

client.delete_certificate("cert-name", None).await?;

Lister les certificats (pagination)

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

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

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

Signature avec la clé d'un certificat

Les certificats dans Key Vault ont une clé associée. Utilisez le SDK Key Vault Keys pour les opérations cryptographiques :

use azure_security_keyvault_keys::{
    models::{KeySignParameters, SignatureAlgorithm},
    KeyClient,
};

let key_client = KeyClient::new(
    "https://<vault-name>.vault.azure.net/",
    credential.clone(),
    None,
)?;

// Signer avec la clé EC du certificat
let digest = vec![0u8; 32]; // Condensé SHA-256
let sign_params = KeySignParameters {
    algorithm: Some(SignatureAlgorithm::Es256),
    value: Some(digest),
    ..Default::default()
};

let result = key_client
    .sign("cert-name", "", sign_params.try_into()?, None)
    .await?
    .into_model()?;
println!("Signature: {:?}", result.result);

Formats de certificat

Rôles RBAC

Pour l'auth Entra ID, assignez 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 des variables d'environnement ou l'identité managée
3. Utilisez ..Default::default() avec #[allow(clippy::needless_update)] pour les mises à jour de struct modèle
4. Utilisez ResourceExt pour extraire le nom/version du certificat des IDs
5. LROs — create_certificate retourne un Poller ; il suffit de .await pour l'achèvement (les clients ne doivent que rarement interroger le statut)
6. Réutilisez les clients — CertificateClient est thread-safe ; créez une fois, partagez entre les tâches

Liens de référence