Weitere Methoden zum Authentifizieren von Rust-Apps aus bei Azure-Ressourcen

In diesem Artikel werden zusätzliche Methoden aufgeführt, mit denen Apps sich bei Azure-Ressourcen authentifizieren können. Diese Methoden werden weniger häufig verwendet. Verwenden Sie nach Möglichkeit eine der Methoden, die in der Übersicht zur Authentifizierung von Rust-Apps bei Azure mit dem Azure SDK beschrieben werden.

Clientzertifikatsauthentifizierung

ClientCertificateCredential authentifiziert einen Dienstprinzipal mithilfe eines Zertifikats anstelle eines geheimen Clientschlüssels. Diese Methode ist sicherer als Clientgeheimnisse, da Sie Zertifikate einfacher verwalten und erneuern können.

Notiz

ClientCertificateCredential erfordert die client_certificate Featurekennzeichnung. Fügen Sie es zu Ihrem Cargo.toml:

[dependencies]
azure_identity = { version = "0.32", features = ["client_certificate"] }

Beispiel für ClientCertificateCredential

use azure_identity::ClientCertificateCredential;
use azure_core::credentials::SecretBytes;
use azure_security_keyvault_secrets::SecretClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let tenant_id = std::env::var("AZURE_TENANT_ID")?;
    let client_id = std::env::var("AZURE_CLIENT_ID")?;
    let cert_path = std::env::var("AZURE_CLIENT_CERTIFICATE_PATH")?;

    // Read the certificate file
    let cert_bytes = std::fs::read(&cert_path)?;

    let credential = ClientCertificateCredential::new(
        tenant_id,
        client_id,
        SecretBytes::from(cert_bytes.as_slice()),
        None,
    )?;

    let client = SecretClient::new(
        "https://<your-key-vault-name>.vault.azure.net/",
        credential.clone(),
        None,
    )?;

    // Use the client to interact with Azure Key Vault
    // let secret = client.get("secret-name", None).await?;

    Ok(())
}

Workload-Identitätsauthentifizierung

WorkloadIdentityCredentialunterstützt Microsoft Entra Workload Identity auf Kubernetes. Diese Anmeldeinformationen authentifizieren Pods in Azure Kubernetes Service (AKS) Clustern, die mit Workloadidentität konfiguriert sind.

Beim Konfigurieren stellt der AKS-Cluster die erforderlichen Umgebungsvariablen (AZURE_TENANT_ID, AZURE_FEDERATED_TOKEN_FILE und AZURE_CLIENT_ID) bereit, die von den Anmeldeinformationen automatisch verwendet werden.

use azure_identity::WorkloadIdentityCredential;
use azure_security_keyvault_secrets::SecretClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // WorkloadIdentityCredential reads configuration from environment variables
    // set by the AKS workload identity webhook
    let credential = WorkloadIdentityCredential::new(None)?;

    let client = SecretClient::new(
        "https://<your-key-vault-name>.vault.azure.net/",
        credential.clone(),
        None,
    )?;

    // Use the client to interact with Azure Key Vault
    // let secret = client.get("secret-name", None).await?;

    Ok(())
}

Weitere Informationen finden Sie unter Microsoft Entra Workload Identity mit AKS verwenden.

Azure Pipelines-Authentifizierung

AzurePipelinesCredentialauthentifiziert eine Azure Pipelines Dienstverbindung. Verwenden Sie diese Anmeldeinformationen in Azure DevOps-Pipelineaufgaben, die auf Azure-Ressourcen zugreifen müssen.

use azure_identity::AzurePipelinesCredential;
use azure_core::credentials::Secret;
use azure_security_keyvault_secrets::SecretClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let system_access_token = std::env::var("SYSTEM_ACCESSTOKEN")?;

    let credential = AzurePipelinesCredential::new(
        String::from("<tenant-id>"),
        String::from("<client-id>"),
        "<service-connection-id>",
        Secret::new(system_access_token),
        None,
    )?;

    let client = SecretClient::new(
        "https://<your-key-vault-name>.vault.azure.net/",
        credential.clone(),
        None,
    )?;

    // Use the client in your pipeline task
    // let secret = client.get("secret-name", None).await?;

    Ok(())
}

Client assertion authentication (Föderierte Identität)

ClientAssertionCredential authentifiziert einen Dienstprinzipal mit einer Clientassertion, die für Verbundidentitätsanmeldeinformationsszenarien nützlich ist. Sie können beispielsweise eine Anwendung so konfigurieren, dass Token einer verwalteten Identität vertraut wird:

use azure_core::credentials::TokenCredential;
use azure_core::http::ClientMethodOptions;
use azure_identity::{ClientAssertion, ClientAssertionCredential, ManagedIdentityCredential};
use azure_security_keyvault_secrets::SecretClient;
use std::sync::Arc;

#[derive(Debug)]
struct AccessTokenAssertion {
    credential: Arc<dyn TokenCredential>,
}

#[cfg_attr(target_arch = "wasm32", async_trait::async_trait(?Send))]
#[cfg_attr(not(target_arch = "wasm32"), async_trait::async_trait)]
impl ClientAssertion for AccessTokenAssertion {
    async fn secret(&self, _: Option<ClientMethodOptions<'_>>) -> azure_core::Result<String> {
        Ok(self
            .credential
            .get_token(&[&"api://AzureADTokenExchange/.default"], None)
            .await?
            .token
            .secret()
            .to_string())
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let assertion = AccessTokenAssertion {
        credential: ManagedIdentityCredential::new(None)?,
    };

    let credential = ClientAssertionCredential::new(
        String::from("tenant ID"),
        String::from("client ID"),
        assertion,
        None,
    )?;

    let client = SecretClient::new(
        "https://<your-key-vault-name>.vault.azure.net/",
        credential.clone(),
        None,
    )?;

    // Use the client to interact with Azure Key Vault
    // let secret = client.get("secret-name", None).await?;

    Ok(())
}

Weitere Informationen finden Sie unter Konfigurieren einer Anwendung, damit sie einer verwalteten Identität vertraut.