Bibliothèque Azure Key Vault Certificates pour Rust

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

Utilisez cette compétence lorsque :

• Une application doit créer ou gérer des certificats X.509 dans Key Vault à partir de Rust
• Vous avez besoin de certificats auto-signés ou émis par une autorité de certification (CA)
• Vous avez besoin d'opérations de longue durée (LRO) pour l'émission de certificats
• Vous devez signer des données à l'aide de 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 leurs noms et aucun n'a la version 0.21.0.

Installation

cargo add azure_security_keyvault_certificates azure_identity tokio futures

Si votre code utilise directement les types azure_core, ajoutez azure_core à Cargo.toml. Si vous n'utilisez que les réexports de azure_security_keyvault_certificates, la dépendance directe vers azure_core est facultative.

Variables d'environnement

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

Authentification

use azure_identity::DeveloperToolsCredential;
use azure_security_keyvault_certificates::CertificateClient;

#[tokio::main]
async fn main() -> Result> {
    // Développement 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(())
}
</vault-name>

Flux de travail principal

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

La création d'un certificat est une opération de longue durée. Poller<t></t> implémente IntoFuture — il suffit d'utiliser .await :

use azure_security_keyvault_certificates::{
    models::{
        CertificatePolicy, CreateCertificateParameters, IssuerParameters,
        X509CertificateProperties,
    },
    ResourceExt,
};

let policy = CertificatePolicy {
    x509_certificate_properties: Some(X509CertificateProperties {
        subject: Some("CN=example.com".into()),
        ..Default::default()
    }),
    issuer_parameters: Some(IssuerParameters {
        name: Some("Self".into()),
        ..Default::default()
    }),
    ..Default::default()
};
let body = CreateCertificateParameters {
    certificate_policy: Some(policy),
    ..Default::default()
};

// Poller implémente IntoFuture — attendez directement la complétion
let cert = client
    .begin_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::UpdateCertificatePropertiesParameters;
use std::collections::HashMap;

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

client
    .update_certificate_properties("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></t> — itérez directement sur les éléments :

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 possèdent une clé associée. Utilisez le SDK Key Vault Keys pour les opérations cryptographiques :

use azure_security_keyvault_keys::{
    models::{KeyClientSignOptions, SignParameters, 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]; // Digest SHA-256
let body = SignParameters {
    algorithm: Some(SignatureAlgorithm::Es256),
    value: Some(digest),
};

let result = key_client
    .sign(
        "cert-name",
        body.try_into()?,
        Some(KeyClientSignOptions {
            key_version: Some("<certificate-version>".to_string()),
            ..Default::default()
        }),
    )
    .await?
    .into_model()?;
println!("Signature: {:?}", result.result);
</certificate-version></vault-name>

Formats de certificat
-------------------

<table><thead><tr><th>Format</th><th>Type de contenu</th><th>Cas d'utilisation</th></tr></thead><tbody><tr><td>PKCS#12</td><td>`application/x-pkcs12`</td><td>Certificat + clé privée groupés</td></tr><tr><td>PEM</td><td>`application/x-pem-file`</td><td>Encodé en Base64, courant sous Linux/web</td></tr></tbody></table>

Rôles RBAC
----------

Pour l'authentification Entra ID, attribuez l'un des rôles suivants :

<table><thead><tr><th>Rôle</th><th>Accès</th></tr></thead><tbody><tr><td>`Key Vault Certificate User`</td><td>Utiliser les certificats</td></tr><tr><td>`Key Vault Certificates Officer`</td><td>Gestion complète des certificats</td></tr></tbody></table>

Bonnes pratiques
--------------

1. **Utilisez `cargo add` pour gérer les dépendances, ne modifiez jamais `Cargo.toml` directement.** Ajoutez et supprimez les dépendances du SDK Rust à l'aide des commandes cargo au lieu des modifications manuelles du manifeste.
2. **Ajoutez `azure_core` uniquement lorsque vous importez directement des types `azure_core`.** Si votre code importe `azure_core::http::Url`, `azure_core::http::RequestContent` ou `azure_core::error::ErrorKind`, incluez `azure_core`; sinon, une dépendance directe est facultative.
3. **Utilisez `DeveloperToolsCredential`** pour le développement local, **`ManagedIdentityCredential`** pour la production — Rust ne fournit pas de type unique `DefaultAzureCredential`
4. **Ne mettez jamais les identifiants en dur** — utilisez des variables d'environnement ou une identité managée
5. **Utilisez `..Default::default()`** avec `#[allow(clippy::needless_update)]` pour les mises à jour des structures de modèle
6. **Utilisez `ResourceExt`** pour extraire le nom/la version du certificat à partir des identifiants
7. **LRO** — `begin_create_certificate` retourne un `Poller`; utilisez simplement `.await` pour la complétion (les clients doivent rarement interroger l'état)
8. **Réutilisez les clients** — `CertificateClient` est thread-safe ; créez-le une fois, partagez-le entre les tâches

Liens de référence
---------------

<table><thead><tr><th>Ressource</th><th>Lien</th></tr></thead><tbody><tr><td>Référence de l'API</td><td>https://docs.rs/azure\_security\_keyvault\_certificates/latest/azure\_security\_keyvault\_certificates</td></tr><tr><td>crates.io</td><td>https://crates.io/crates/azure\_security\_keyvault\_certificates</td></tr><tr><td>Code source</td><td>https://github.com/Azure/azure-sdk-for-rust/tree/main/sdk/keyvault/azure\_security\_keyvault\_certificates</td></tr></tbody></table>