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.
Les applications hébergées en dehors d’Azure, telles que les serveurs on-premises ou les centres de données, doivent utiliser un principal de service d’application pour s’authentifier auprès des ressources Azure. Inscrivez votre application dans Azure pour créer le service principal. Lorsque vous en créez un, Azure génère un ID client et une clé secrète client. Stockez l’ID client, la clé secrète client et l’ID de locataire dans les variables d’environnement afin que votre application puisse les ClientSecretCredential transmettre au moment de l’exécution.
Créez une inscription d’application différente pour chaque environnement dans lequel vous hébergez l’application. Cette configuration vous permet de configurer des autorisations de ressources spécifiques à l’environnement pour chaque principal de service et de s’assurer qu’une application déployée dans un environnement n’accède pas aux ressources Azure dans un autre environnement.
Inscrire l’application dans Azure
Les objets principaux du service d’application sont créés via une inscription d’application dans Azure à l’aide du portail Azure ou de Azure CLI.
Dans le portail Azure, utilisez la barre de recherche pour accéder à la page inscriptions d'applications.
Dans la page Inscriptions d’applications, sélectionnez + Nouvelle inscription.
Dans la page Inscrire une application :
- Pour le champ Nom, entrez une valeur descriptive qui inclut le nom de l’application et l’environnement cible.
- Pour Types de comptes pris en charge, sélectionnez Comptes qui se trouvent uniquement dans cet annuaire organisationnel (géré par le client uniquement - locataire unique), ou l’option qui correspond le mieux à vos besoins.
Sélectionnez Inscrire pour inscrire votre application et créer le principal du service.
Dans la page d'inscription de l'application , copiez l'ID d'application (client) et l'ID de répertoire (locataire) et collez-les dans un emplacement temporaire pour une utilisation ultérieure dans les configurations de code de votre application.
Sélectionnez Ajouter un certificat ou un secret pour configurer des informations d’identification pour votre application.
Sur la page Certificats & secrets, sélectionnez + Nouvelle clé secrète client.
Dans le panneau volant Ajouter un secret client qui s’ouvre :
- Pour la Description, entrez la valeur Current.
- Pour la Expire valeur, conservez la valeur recommandée par défaut de 180 jours.
- Sélectionnez Ajouter pour ajouter le secret.
Sur la page Certificats & secrets, copiez la propriété Valeur du secret client à utiliser dans une étape ultérieure.
Note
La valeur de la clé secrète client n’est affichée qu’une fois après la création de l'inscription de l'application. Vous pouvez ajouter d’autres secrets client sans invalider ce secret client, mais il n’existe aucun moyen d’afficher cette valeur à nouveau.
Attribuer des rôles au principal du service d’application
Ensuite, déterminez les rôles (autorisations) dont votre application a besoin sur les ressources et attribuez ces rôles au principal de service que vous avez créé. Les rôles peuvent être attribués au niveau de la ressource, du groupe de ressources ou de l’étendue de l’abonnement. Cet exemple montre comment attribuer des rôles à l’étendue du groupe de ressources, car la plupart des applications regroupent toutes leurs ressources Azure dans un seul groupe de ressources.
Dans le portail Azure, accédez à la page Vue d’ensemble du groupe de ressources qui contient votre application.
Dans le menu de navigation de gauche, sélectionnez Contrôle d’accès (IAM) .
Dans la page Contrôle d’accès (IAM), sélectionnez + Ajouter , puis choisissez Ajouter une attribution de rôle dans le menu déroulant. La page Ajouter une attribution de rôle fournit plusieurs onglets pour configurer et attribuer des rôles.
Sous l’onglet Rôle , utilisez la zone de recherche pour localiser le rôle que vous souhaitez attribuer. Sélectionnez le rôle, puis choisissez Suivant.
Sous l’onglet Membres :
- Pour la valeur Attribuer l’accès à, sélectionnez Utilisateur, groupe ou principal de service.
- Pour la valeur Membres , choisissez + Sélectionner des membres pour ouvrir le volet volant Sélectionner des membres .
- Recherchez le principal de service que vous avez créé précédemment et sélectionnez-le dans les résultats filtrés. Choisissez Sélectionner pour choisir le groupe et fermer le volet déroulant.
- Sélectionnez Vérifier + affecter en bas de l’onglet Membres .
Sous l’onglet Révision + affectation , sélectionnez Vérifier + affecter en bas de la page.
Définir une variable d’environnement
ClientSecretCredential prend l’ID de locataire, l’ID client et le secret client comme arguments de constructeur. Définissez ces valeurs dans les variables d’environnement et lisez-les dans votre application, comme illustré dans l’exemple suivant.
Définissez les variables d’environnement suivantes avec des valeurs que vous obtenez à partir du processus d’inscription de l’application :
-
AZURE_CLIENT_ID: identifie l’application inscrite dans Azure. -
AZURE_TENANT_ID: ID du locataire Microsoft Entra. -
AZURE_CLIENT_SECRET: l’identifiant secret que vous générez pour l’application.
export AZURE_CLIENT_ID=<your-client-id>
export AZURE_TENANT_ID=<your-tenant-id>
export AZURE_CLIENT_SECRET=<your-client-secret>
Implémenter le code
Pour authentifier les objets clients du Kit de développement logiciel (SDK) Azure auprès d’Azure, votre application doit utiliser le type ClientSecretCredential du crate azure_identity.
Commencez par ajouter le crate azure_identity à votre application :
cargo add azure_identity
Ensuite, pour tout code Rust qui instancie un client Kit de développement logiciel (SDK) Azure dans votre application, procédez comme suit :
- Importez le
azure_identitycrate. - Créez une instance de
ClientSecretCredential. - Transmettez l’instance au constructeur client du Kit de développement logiciel (SDK) Azure.
Le segment de code suivant montre un exemple :
use azure_identity::ClientSecretCredential;
use azure_core::credentials::Secret;
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 client_secret = std::env::var("AZURE_CLIENT_SECRET")?;
// Create a credential using the service principal
let credential = ClientSecretCredential::new(
&tenant_id,
client_id,
Secret::new(client_secret),
None,
)?;
// Create a client for the specified Key Vault
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(())
}
L’exemple lit les variables d’environnement AZURE_TENANT_ID, AZURE_CLIENT_ID et AZURE_CLIENT_SECRET, puis transmet leurs valeurs à ClientSecretCredential.