Dela via

Autentisera Rust-appar till Azure-tjänster

Rust-program måste autentiseras mot Azure-tjänster som Storage, Key Vault eller Cosmos DB. Den här artikeln beskriver hur du använder Azure Identity-lådan för att autentisera Rust-appar på ett säkert sätt i lokala utvecklings- och servermiljöer, vilket förbättrar säkerheten och förenklar autentiseringshanteringen.

Den rekommenderade metoden är att låta dina appar använda tokenbaserad autentisering i stället för anslutningssträngar eller nycklar när de autentiserar till Azure-resurser. Den azure_identity-lådan ger tokenbaserad autentisering och gör det möjligt för appar att smidigt autentisera till Azure-resurser oavsett om appen är i lokal utveckling, distribueras till Azure eller distribueras till en lokal server.

Den specifika typen av tokenbaserad autentisering som en app ska använda för att autentisera till Azure-resurser beror på var appen körs.

Miljö Authentication
Lokal När en utvecklare kör en app under lokal utveckling – Appen kan autentisera till Azure med hjälp av utvecklarens lokala autentiseringsuppgifter. De här alternativen finns mer i detalj i crates.io: Autentisera med utvecklingsverktyg.
Azure När en app finns i Azure – Appen bör autentiseras mot Azure-resurser med hjälp av en hanterad identitet. Det här alternativet beskrivs mer detaljerat i dokumentationen för crates.io : Autentisera Azure-värdbaserade program.
Lokalt När en app hanteras och distribueras lokalt – Appen bör autentiseras mot Azure-resurser med hjälp av ett huvudnamn för programtjänsten. Det här alternativet beskrivs i dokumentationen för crates.io : Autentisera tjänstens huvudnamn.

Fördelar med tokenbaserad autentisering

När du skapar appar för Azure rekommenderar vi starkt att du använder tokenbaserad autentisering i stället för hemligheter som anslutningssträngar eller nycklar.

Tokenbaserad autentisering Hemligheter (anslutningssträngar och nycklar)
Principen om minsta behörighet upprättar de specifika behörigheter som krävs av appen på Azure-resursen. En anslutningssträng eller nyckel ger azure-resursen fullständiga rättigheter.
Det finns ingen programhemlighet att lagra. Måste lagra och rotera hemligheter i appinställningen eller miljövariabeln.
Azure Identity-biblioteket hanterar token åt dig i bakgrunden. Detta gör det enkelt att använda tokenbaserad autentisering som en anslutningssträng. Hemligheter hanteras inte.

Användning av anslutningssträngar bör begränsas till inledande konceptbevisappar eller utvecklingsprototyper som inte har åtkomst till produktionsdata eller känsliga data. Annars bör de tokenbaserade autentiseringsklasserna som är tillgängliga i Azure Identity-biblioteket alltid föredras när du autentiserar till Azure-resurser.

Autentisera under lokal utveckling

När ett program körs på en utvecklares arbetsstation under lokal utveckling måste den lokala miljön fortfarande autentiseras mot alla Azure-tjänster som används av appen.

Autentisera med Azure CLI-autentiseringsuppgifter

Azure CLI-autentiseringsuppgifterna använder autentiseringstillståndet för Azure CLI för att autentisera ditt Rust-program. Den här autentiseringsuppgiften är perfekt för lokal utveckling när du redan är inloggad med az login.

use azure_identity::AzureCliCredential;
use azure_security_keyvault_secrets::SecretClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {

    dotazure::load()?;

    let vault_url = std::env::var("AZURE_KEYVAULT_URL")
        .map_err(|_| "AZURE_KEYVAULT_URL environment variable is required")?;

    let credential = AzureCliCredential::new(None)?;

    let client = SecretClient::new(&vault_url, credential.clone(), None)?;

    Ok(())
}

Autentisera med CLI-autentiseringsuppgifter för Azure Developer

Azure Developer CLI-autentiseringsuppgifterna använder autentiseringstillståndet för Azure Developer CLI (azd) för att autentisera ditt program. Den här autentiseringsuppgiften är användbar när du arbetar med azd-mallar och arbetsflöden.

use azure_identity::AzureDeveloperCliCredential;
use azure_security_keyvault_secrets::SecretClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {

    dotazure::load()?;

    let vault_url = std::env::var("AZURE_KEYVAULT_URL")
        .map_err(|_| "AZURE_KEYVAULT_URL environment variable is required")?;

    let credential = AzureDeveloperCliCredential::new(None)?;

    let client = SecretClient::new(&vault_url, credential.clone(), None)?;

    Ok(())
}

Autentisera i servermiljöer

I servermiljöer använder du hanterade identiteter för säker, lösenordsfri autentisering. Hanterade identiteter skapas och hanteras automatiskt av Azure, så att ditt program kan autentiseras utan att behöva lagra autentiseringsuppgifter.

När du är värd för en servermiljö tilldelar du en unik programidentitet till varje program för varje miljö. I Azure representeras en appidentitet av ett huvudnamn för tjänsten, en särskild typ av säkerhetsobjekt som identifierar och autentiserar appar till Azure. Vilken typ av tjänsthuvudnamn du använder för din app beror på var appen körs.

use azure_identity::{ManagedIdentityCredential, ManagedIdentityCredentialOptions, UserAssignedId};
use azure_security_keyvault_secrets::SecretClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {

    dotazure::load()?;

    let vault_url = std::env::var("AZURE_KEYVAULT_URL")
        .map_err(|_| "AZURE_KEYVAULT_URL environment variable is required")?;

    let user_assigned_id: Option<UserAssignedId> = std::env::var("AZURE_USER_ASSIGNED_IDENTITY")
        .ok()
        .map(|id| UserAssignedId::ClientId(id.clone()));

    let credential_options = ManagedIdentityCredentialOptions {
        user_assigned_id,
        ..Default::default()
    };

    let credential = ManagedIdentityCredential::new(Some(credential_options))?;

    let client = SecretClient::new(vault_url.as_str(), credential.clone(), None)?;

    Ok(())
}

Exempelkod

Koden som visas i den här artikeln är tillgänglig på https://github.com/azure-samples/azure-sdk-for-rust-docs/.

Ytterligare resurser