Azure Key Vault-Zertifikatsbibliothek für Rust

Verwalten Sie X.509-Zertifikate für TLS/SSL, Codesignierung und Authentifizierung.

Verwenden Sie diese Funktion, wenn:

• Eine Anwendung X.509-Zertifikate in Key Vault aus Rust heraus erstellen oder verwalten muss
• Sie selbstsignierte oder von einer CA ausgestellte Zertifikate benötigen
• Sie langandauernde Vorgänge (LRO) für die Zertifikatsausstellung benötigen
• Sie Daten mithilfe des Schlüssels eines Zertifikats signieren müssen

WICHTIG: Verwenden Sie ausschließlich das offizielle azure_security_keyvault_certificates-Crate, das vom azure-sdk-Benutzer auf crates.io veröffentlicht wurde. Verwenden Sie KEINE inoffiziellen oder Community-Crates. Offizielle Crates verwenden Unterstriche in den Namen, und keines hat die Version 0.21.0.

Installation

cargo add azure_security_keyvault_certificates azure_identity tokio futures

Wenn Ihr Code azure_core-Typen direkt verwendet, fügen Sie azure_core zu Cargo.toml hinzu. Wenn Sie nur von azure_security_keyvault_certificates neu exportierte Typen verwenden, ist die direkte Abhängigkeit von azure_core optional.

Umgebungsvariablen

AZURE_KEYVAULT_URL=https://<vault-name>.vault.azure.net/ # Erforderlich für alle Vorgänge
</vault-name>

Authentifizierung

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

#[tokio::main]
async fn main() -> Result> {
    // Lokale Entwicklung: DeveloperToolsCredential. Produktion: Verwenden Sie 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!("Zertifikat: {:?}", cert.id);
    Ok(())
}
</vault-name>

Hauptarbeitsablauf

Selbstsigniertes Zertifikat erstellen (LRO)

Das Erstellen eines Zertifikats ist ein langandauernder Vorgang. Poller<t></t> implementiert IntoFuture — einfach .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 implementiert IntoFuture — direkt .await für Abschluss
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,
);

Zertifikateigenschaften aktualisieren

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()?;

Zertifikat löschen

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

Zertifikate auflisten (Paginierung)

list_certificate_properties gibt einen Pager<t></t> zurück — iterieren Sie direkt über die Elemente:

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!("Gefunden: {}", cert.resource_id()?.name);
}

Signieren mit dem Schlüssel eines Zertifikats

Zertifikate in Key Vault verfügen über einen zugehörigen Schlüssel. Verwenden Sie das Key Vault Keys SDK für kryptografische Vorgänge:

use azure_security_keyvault_keys::{
    models::{KeyClientSignOptions, SignParameters, SignatureAlgorithm},
    KeyClient,
};

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

// Signieren mit dem EC-Schlüssel des Zertifikats
let digest = vec![0u8; 32]; // SHA-256-Hashwert
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!("Signatur: {:?}", result.result);
</certificate-version></vault-name>

Zertifikatsformate
-------------------

<table><thead><tr><th>Format</th><th>Inhaltstyp</th><th>Anwendungsfall</th></tr></thead><tbody><tr><td>PKCS#12</td><td>`application/x-pkcs12`</td><td>Gebündeltes Zertifikat + privater Schlüssel</td></tr><tr><td>PEM</td><td>`application/x-pem-file`</td><td>Base64-codiert, häufig in Linux/Web</td></tr></tbody></table>

RBAC-Rollen
----------

Weisen Sie für Entra ID-Authentifizierung eine der folgenden Rollen zu:

<table><thead><tr><th>Rolle</th><th>Zugriff</th></tr></thead><tbody><tr><td>`Key Vault Certificate User`</td><td>Zertifikate verwenden</td></tr><tr><td>`Key Vault Certificates Officer`</td><td>Vollständige Zertifikatsverwaltung</td></tr></tbody></table>

Best Practices
--------------

1. **Verwenden Sie `cargo add`, um Abhängigkeiten zu verwalten, bearbeiten Sie `Cargo.toml` niemals direkt.** Fügen Sie Rust-SDK-Abhängigkeiten über cargo-Befehle hinzu und entfernen Sie diese, anstatt Manifestdateien manuell zu bearbeiten.
2. **Fügen Sie `azure_core` nur hinzu, wenn Sie `azure_core`-Typen direkt importieren.** Wenn Ihr Code `azure_core::http::Url`, `azure_core::http::RequestContent` oder `azure_core::error::ErrorKind` importiert, fügen Sie `azure_core` hinzu; andernfalls ist eine direkte Abhängigkeit optional.
3. **Verwenden Sie `DeveloperToolsCredential`** für die lokale Entwicklung, **`ManagedIdentityCredential`** für die Produktion — Rust stellt keinen einzelnen `DefaultAzureCredential`-Typ bereit
4. **Speichern Sie Anmeldeinformationen niemals hartkodiert** — verwenden Sie Umgebungsvariablen oder verwaltete Identität
5. **Verwenden Sie `..Default::default()`** in Kombination mit `#[allow(clippy::needless_update)]` für Aktualisierungen von Modellstrukturen
6. **Verwenden Sie `ResourceExt`**, um Zertifikatsname und -version aus IDs zu extrahieren
7. **LROs** — `begin_create_certificate` gibt einen `Poller` zurück; verwenden Sie einfach `.await` für den Abschluss (Clients sollten selten nach dem Status pollen)
8. **Wiederverwenden Sie Clients** — `CertificateClient` ist threadsicher; erstellen Sie ihn einmal und teilen Sie ihn über Aufgaben hinweg

Referenzlinks
---------------

<table><thead><tr><th>Ressource</th><th>Link</th></tr></thead><tbody><tr><td>API-Referenz</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>Quellcode</td><td>https://github.com/Azure/azure-sdk-for-rust/tree/main/sdk/keyvault/azure\_security\_keyvault\_certificates</td></tr></tbody></table>