Aanvullende methoden voor authenticatie bij Azure-resources vanuit Rust-apps

Dit artikel bevat aanvullende methoden die apps kunnen gebruiken om te verifiëren bij Azure-resources. Deze methoden worden minder vaak gebruikt. Gebruik indien mogelijk een van de methoden die worden beschreven in het overzicht van Rust-apps verifiëren bij Azure met behulp van Azure SDK.

Verificatie van clientcertificaten

ClientCertificateCredential authenticeert een service-principal met behulp van een certificaat in plaats van een clientgeheim. Deze methode is veiliger dan clientgeheimen, omdat u certificaten eenvoudiger kunt beheren en roteren.

Note

ClientCertificateCredential vereist de client_certificate functievlag. Voeg het toe aan uw Cargo.toml:

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

Voorbeeld van 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(())
}

Verificatie van workload identiteit

WorkloadIdentityCredential ondersteunt Microsoft Entra workloadidentiteit in Kubernetes. Met dit aanmeldingsgegeven worden pods geauthenticeerd in Azure Kubernetes Service (AKS)-clusters die zijn geconfigureerd met workloadidentiteit.

Wanneer u dit configureert, stelt het AKS-cluster de benodigde omgevingsvariabelen (AZURE_TENANT_ID, AZURE_CLIENT_ID en AZURE_FEDERATED_TOKEN_FILE) beschikbaar die automatisch door de aanmeldingsgegevens worden gebruikt.

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(())
}

Zie Use Microsoft Entra Workload Identity with AKS (Workloadidentiteit gebruiken met AKS) voor meer informatie.

Verificatie van Azure-pipelines

AzurePipelinesCredential authenticeert een Azure-pipelines-serviceverbinding. Gebruik deze referentie in Azure DevOps-pijplijntaken die toegang nodig hebben tot Azure-resources.

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(())
}

Clientassertion-authenticatie (federatieve identiteit)

ClientAssertionCredential authenticeert een service-principal met een clientverklaring, wat handig is voor scenario's met federatieve identiteitsreferenties. U kunt bijvoorbeeld een toepassing configureren om tokens van een beheerde identiteit te vertrouwen:

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(())
}

Voor meer informatie, zie Configureer een applicatie om een beheerde identiteit te vertrouwen.