Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Cet article répertorie des méthodes supplémentaires que les applications peuvent utiliser pour s'authentifier auprès des ressources Azure. Ces méthodes sont moins couramment utilisées. Si possible, utilisez l’une des méthodes décrites dans la vue d’ensemble de l’authentification des applications Rust auprès d’Azure à l’aide de l’Kit de développement logiciel (SDK) Azure.
Authentification par certificat client
ClientCertificateCredential authentifie un principal de service à l’aide d’un certificat au lieu d’une clé secrète client. Cette méthode est plus sécurisée que les secrets client, car vous pouvez gérer et renouveler plus facilement les certificats.
Note
ClientCertificateCredential nécessite le flag de fonctionnalité client_certificate. Ajoutez-le à votre Cargo.toml:
[dependencies]
azure_identity = { version = "0.32", features = ["client_certificate"] }
Exemple utilisant 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(())
}
Authentification par identité de charge de travail
WorkloadIdentityCredentialprend en charge Microsoft Entra Workload Identity sur Kubernetes. Ces informations d’identification authentifient les pods dans les clusters Azure Kubernetes Service (AKS) configurés avec l’identité de charge de travail.
Lorsque vous le configurez, le cluster AKS fournit les variables d’environnement nécessaires (AZURE_TENANT_ID, AZURE_CLIENT_ID et AZURE_FEDERATED_TOKEN_FILE) que les informations d’identification utilisent automatiquement.
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(())
}
Pour plus d’informations, consultez Utiliser l’identité de charge de travail Microsoft Entra avec AKS.
Authentification des Azure Pipelines
AzurePipelinesCredential authentifie une connexion de service Azure Pipelines. Utilisez ces informations d’identification dans les tâches de pipeline Azure DevOps qui doivent accéder aux ressources Azure.
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(())
}
Authentification par assertion client (identité fédérée)
ClientAssertionCredential authentifie un principal de service avec une assertion cliente, ce qui est utile pour les scénarios de justificatif d’identité fédérée. Par exemple, vous pouvez configurer une application pour approuver des jetons à partir d’une identité managée :
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(())
}
Pour plus d’informations, voir Configurer une application pour faire confiance à une identité gérée.