Authentifier les applications .NET aux services Azure pendant le développement local à l'aide de principes de service.

Pendant le développement local, les applications doivent s’authentifier auprès d’Azure pour accéder à différents services Azure. Les deux approches les plus courantes pour l'authentification locale sont l'utilisation d'un compte de développeur ou d'un principal de service. Cet article explique comment utiliser un principal de service d'application. Dans les sections à venir, vous allez apprendre :

Comment inscrire une application auprès de Microsoft Entra pour créer un principal de service
Comment utiliser des groupes Microsoft Entra pour gérer efficacement les autorisations
Comment attribuer des rôles aux permissions d'étendue ?
Comment s’authentifier à l’aide d’un principal de service à partir de votre code d’application

L’utilisation de principaux de service d’application dédié vous permet d’adhérer au principe du privilège minimum lors de l’accès aux ressources Azure. Les autorisations sont limitées aux exigences spécifiques de l’application pendant le développement, ce qui empêche l’accès accidentel aux ressources Azure destinées à d’autres applications ou services. Cette approche permet également d’éviter les problèmes lorsque l’application est déplacée en production en s’assurant qu’elle n’est pas sur-privilégiée dans l’environnement de développement.

Diagramme montrant comment une application .NET locale utilise un principal de service pour se connecter aux ressources Azure.

Lorsque l’application est inscrite dans Azure, un principal de service d’application est créé. Pour le développement local :

Créez une inscription d’application distincte pour chaque développeur travaillant sur l’application pour vous assurer que chaque développeur dispose de son propre principal du service d’application, ce qui évite de devoir partager des informations d’identification.
Créez une inscription d’application distincte pour chaque application afin de limiter les autorisations de l’application uniquement à ce qui est nécessaire.

Pendant le développement local, les variables d’environnement sont définies avec l’identité du principal du service d’application. La bibliothèque Azure Identity lit ces variables d’environnement pour authentifier l’application auprès des ressources Azure requises.

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 d’Azure CLI.

Portail Azure
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.

Les commandes Azure CLI peuvent être exécutées dans le Azure Cloud Shell ou sur une station de travail avec l'Azure CLI installée.

Utilisez la commande az ad sp create-for-rbac pour créer une inscription et un principal de service pour l’application.

az ad sp create-for-rbac --name <service-principal-name>

La sortie de cette commande ressemble au code JSON suivant :

{
  "appId": "00000000-0000-0000-0000-000000000000",
  "displayName": "<service-principal-name>",
  "password": "abcdefghijklmnopqrstuvwxyz",
  "tenant": "11111111-1111-1111-1111-111111111111"
}

Copiez cette sortie dans un fichier temporaire dans un éditeur de texte, car vous aurez besoin de ces valeurs dans une prochaine étape.

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.

Créer un groupe Microsoft Entra pour le développement local

Créez un groupe Microsoft Entra pour encapsuler les rôles (autorisations) dont l’application a besoin dans le développement local plutôt que d’affecter les rôles à des objets de principal de service individuels. Cette approche offre les avantages suivants :

Chaque développeur a les mêmes rôles attribués au niveau du groupe.
Si un nouveau rôle est nécessaire pour l’application, il doit uniquement être ajouté au groupe de l’application.
Si un nouveau développeur rejoint l’équipe, un nouveau principal du service d’application est créé pour le développeur et ajouté au groupe, ce qui garantit que le développeur dispose des autorisations appropriées pour travailler sur l’application.

Portail Azure
Azure CLI

Accédez à la page de vue d’ensemble Microsoft Entra ID dans le portail Azure.
Sélectionnez Tous les groupes dans le menu de gauche.
Sur la page Groupes , sélectionnez Nouveau groupe.
Dans la page Nouveau groupe, renseignez les champs de formulaire suivants :
- type de groupe: sélectionnez la sécurité .
- nom du groupe: entrez un nom pour le groupe qui inclut une référence à l’application ou au nom de l’environnement.
- description du groupe: entrez une description qui explique l’objectif du groupe.
Sélectionnez le lien Aucun membre sélectionné sous Membres pour ajouter des membres au groupe.
Dans le volet volant qui s’ouvre, recherchez le principal de service que vous avez créé précédemment et sélectionnez-le dans les résultats filtrés. Cliquez sur le bouton Select en bas du panneau pour confirmer votre sélection.
Sélectionnez Créer en bas de la page Nouveau groupe pour créer le groupe et revenir à la page Tous les groupes. Si vous ne voyez pas le nouveau groupe répertorié, attendez un instant et actualisez la page.

Utilisez la commande az ad group create pour créer des groupes dans Microsoft Entra ID.
```
az ad group create \
    --display-name <group-name> \
    --mail-nickname <group-mail-nickname> \
    --description <group-description>
```
Les paramètres --display-name et --mail-nickname sont requis. Le nom donné au groupe doit être basé sur le nom et l’environnement de l’application pour indiquer l’objectif du groupe.
Pour ajouter des membres au groupe, vous avez besoin de l’ID d’objet du principal du service d’application, qui est différent de l’ID d’application. Utilisez la commande az ad sp list pour lister les principaux de service disponibles :
```
az ad sp list \
    --filter "startswith(displayName, '<group-name>')" \
    --query "[].{objectId:id, displayName:displayName}"
```
Le paramètre --filter accepte les filtres de style OData et peut être utilisé pour filtrer la liste comme indiqué. Le paramètre --query limite la sortie aux seules colonnes intéressantes.

Utilisez la commande az ad group member add pour ajouter des membres au groupe :

az ad group member add \
    --group <group-name> \
    --member-id <object-id>

Attribuer des rôles au groupe

Ensuite, déterminez les rôles (autorisations) dont votre application a besoin sur les ressources et attribuez ces rôles au groupe Microsoft Entra que vous avez créé. Les groupes peuvent être affectés à un rôle 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.

Portail Azure
Azure CLI

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 panneau volant Sélectionner des membres.
- Recherchez le groupe Microsoft Entra que vous avez créé précédemment et sélectionnez-le dans les résultats filtrés. Choisissez Select pour sélectionner le groupe et fermer le panneau volant.
- Sélectionnez Vérifier + attribuer en bas de l’onglet Membres.
Sous l’onglet Révision + assigner, sélectionnez Révision + assigner en bas de la page.

Utilisez la commande az role definition list pour obtenir les noms des rôles auxquels un groupe Microsoft Entra ou un principal de service peut être affecté.
```
az role definition list \
    --query "sort_by([].{roleName:roleName, description:description}, &roleName)" \
    --output table
```
Utilisez la commande az role assignment create pour attribuer un rôle au groupe Microsoft Entra que vous avez créé :
```
az role assignment create \
    --assignee "<group-object-Id>" \
    --role "<role-name>" \
    --resource-group "<resource-group-name>"
```
Pour plus d’informations sur l’attribution d’autorisations au niveau de la ressource ou de l’abonnement à l’aide d’Azure CLI, consultez Attribuer des rôles Azure à l’aide d’Azure CLI.

Définir les variables d’environnement d’application

À l’exécution, certaines informations d’identification de la bibliothèque d’identités Azure, telles que DefaultAzureCredential, EnvironmentCredential et ClientSecretCredential, recherchent des informations sur le principal du service selon la convention dans les variables d’environnement. Il existe plusieurs façons de configurer des variables d’environnement lors de l’utilisation de .NET, en fonction de vos outils et de votre environnement.

Quelle que soit l’approche choisie, configurez les variables d’environnement suivantes pour un principal de service :

AZURE_CLIENT_ID: utilisé pour identifier l’application inscrite dans Azure.
AZURE_TENANT_ID: Identifiant du client Microsoft Entra.
AZURE_CLIENT_SECRET: informations d’identification secrètes générées pour l’application.

Dans Visual Studio, les variables d’environnement peuvent être définies dans le fichier launchsettings.json dans le dossier Properties de votre projet. Ces valeurs sont extraites automatiquement au démarrage de l’application. Toutefois, ces configurations ne se déplacent pas avec votre application pendant le déploiement. Vous devez donc configurer des variables d’environnement sur votre environnement d’hébergement cible.

"profiles": {
    "SampleProject": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "https://localhost:7177;http://localhost:5177",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development",
        "AZURE_CLIENT_ID": "<your-client-id>",
        "AZURE_TENANT_ID":"<your-tenant-id>",
        "AZURE_CLIENT_SECRET": "<your-client-secret>"
      }
    },
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development",
        "AZURE_CLIENT_ID": "<your-client-id>",
        "AZURE_TENANT_ID":"<your-tenant-id>",
        "AZURE_CLIENT_SECRET": "<your-client-secret>"
      }
    }
  }

Dans Visual Studio Code, les variables d’environnement peuvent être définies dans le fichier launch.json de votre projet. Ces valeurs sont extraites automatiquement au démarrage de l’application. Toutefois, ces configurations ne se déplacent pas avec votre application pendant le déploiement. Vous devez donc configurer des variables d’environnement sur votre environnement d’hébergement cible.

"configurations": [
{
    "env": {
        "ASPNETCORE_ENVIRONMENT": "Development",
        "AZURE_CLIENT_ID": "<your-client-id>",
        "AZURE_TENANT_ID":"<your-tenant-id>",
        "AZURE_CLIENT_SECRET": "<your-client-secret>"
    }
}

Vous pouvez définir des variables d’environnement pour Windows à partir de la ligne de commande. Toutefois, les valeurs sont accessibles à toutes les applications s’exécutant sur ce système d’exploitation et peuvent provoquer des conflits. Par conséquent, utilisez la prudence avec cette approche. Les variables d’environnement peuvent être définies au niveau de l’utilisateur ou du système.

# Set user environment variables
setx ASPNETCORE_ENVIRONMENT "Development"
setx AZURE_CLIENT_ID "<your-client-id>"
setx AZURE_TENANT_ID "<your-tenant-id>"
setx AZURE_CLIENT_SECRET "<your-client-secret>"

# Set system environment variables - requires running as admin
setx ASPNETCORE_ENVIRONMENT "Development" /m
setx AZURE_CLIENT_ID "<your-client-id>" /m
setx AZURE_TENANT_ID "<your-tenant-id>" /m
setx AZURE_CLIENT_SECRET "<your-client-secret>" /m

PowerShell peut également être utilisé pour définir des variables d’environnement au niveau utilisateur ou système :

# Set user environment variables
[Environment]::SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development", "User")
[Environment]::SetEnvironmentVariable("AZURE_CLIENT_ID", "<your-client-id>", "User")
[Environment]::SetEnvironmentVariable("AZURE_TENANT_ID", "<your-tenant-id>", "User")
[Environment]::SetEnvironmentVariable("AZURE_CLIENT_SECRET", "<your-client-secret>", "User")

# Set system environment variables - requires running as admin
[Environment]::SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development", "Machine")
[Environment]::SetEnvironmentVariable("AZURE_CLIENT_ID", "<your-client-id>", "Machine")
[Environment]::SetEnvironmentVariable("AZURE_TENANT_ID", "<your-tenant-id>", "Machine")
[Environment]::SetEnvironmentVariable("AZURE_CLIENT_SECRET", "<your-client-secret>", "Machine")

S’authentifier auprès des services Azure à partir de votre application

La bibliothèque d’identités Azure fournit diverses informations d’identification : implémentations de TokenCredential adaptées à la prise en charge de différents scénarios et flux d’authentification Microsoft Entra. Les étapes ci-dessous montrent comment utiliser ClientSecretCredential pour les principaux du service à la fois localement et en production.

Implémenter le code

Ajoutez le package Azure.Identity. Dans un projet ASP.NET Core, installez également le package Microsoft.Extensions.Azure :

Ligne de commande
Gestionnaire de package NuGet

Dans un terminal de votre choix, accédez au répertoire du projet d’application et exécutez les commandes suivantes :

dotnet add package Azure.Identity
dotnet add package Microsoft.Extensions.Azure

Les services Azure sont accessibles à l’aide de classes clientes spécialisées à partir des différentes bibliothèques clientes du Kit de développement logiciel (SDK) Azure. Ces classes et vos propres services personnalisés doivent être inscrits pour l’injection de dépendances afin qu’ils puissent être utilisés dans votre application. Dans Program.cs, effectuez les étapes suivantes pour configurer une classe cliente pour l’injection de dépendances et l’authentification basée sur des jetons :

Incluez les espaces de noms Azure.Identity et Microsoft.Extensions.Azure via des directives using.
Inscrivez le client de service Azure à l’aide de la méthode d’extension au préfixe Add correspondante.
Configurez ClientSecretCredential avec les tenantId, clientIdet clientSecret.
Transmettez l’instance ClientSecretCredential à la méthode UseCredential.

builder.Services.AddAzureClients(clientBuilder =>
{
    var tenantId = Environment.GetEnvironmentVariable("AZURE_TENANT_ID");
    var clientId = Environment.GetEnvironmentVariable("AZURE_CLIENT_ID");
    var clientSecret = Environment.GetEnvironmentVariable("AZURE_CLIENT_SECRET");

    clientBuilder.AddBlobServiceClient(
        new Uri("https://<account-name>.blob.core.windows.net"));

    clientBuilder.UseCredential(new ClientSecretCredential(tenantId, clientId, clientSecret));
});

Une alternative à la méthode UseCredential consiste à fournir directement les informations d’identification au client de service :

var tenantId = Environment.GetEnvironmentVariable("AZURE_TENANT_ID");
var clientId = Environment.GetEnvironmentVariable("AZURE_CLIENT_ID");
var clientSecret = Environment.GetEnvironmentVariable("AZURE_CLIENT_SECRET");

builder.Services.AddSingleton<BlobServiceClient>(_ =>
    new BlobServiceClient(
        new Uri("https://<account-name>.blob.core.windows.net"),
        new ClientSecretCredential(tenantId, clientId, clientSecret)));

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-04-02