Authentifier des applications .NET auprès des services Azure pendant le développement local à l’aide de principaux de service

Article
08/07/2024

Les développeurs doivent déboguer et tester des applications cloud sur leur station de travail locale. Lorsqu’une application s’exécute sur la station de travail d’un développeur pendant le développement local, elle doit toujours s’authentifier auprès des services Azure utilisés par l’application. Cet article explique comment configurer des objets de principal de service d’application dédiés à utiliser pendant le développement local.

Diagramme montrant comment une application .NET locale utilise les informations d’identification du développeur pour se connecter à Azure à l’aide d’outils de développement installés localement.

Les principaux de service d’application dédiés pour le développement local vous permettent de suivre le principe des privilèges minimum pendant le développement de l’application. Étant donné que les autorisations sont limitées exactement à ce qui est nécessaire pour l’application pendant le développement, le code de l’application ne peut pas accéder accidentellement à une ressource Azure destinée à une autre application. Cela empêche également l’apparition de bogues lorsque l’application est déplacée en production parce qu’elle était trop privilégiée dans l’environnement de développement.

Un principal de service d’application est configuré pour l’application lorsque l’application est inscrite dans Azure. Lors de l’inscription d’une application pour le développement local, il est recommandé de :

Créer une inscription d’application distincte pour chaque développeur travaillant sur l’application. Cela crée des principaux de service d’application distincts pour chaque développeur à utiliser pendant le développement local et évite aux développeurs d’avoir à partager des informations d’identification pour un seul principal de service d’application.
Créer une inscription d’application distincte par application. Cela limite les autorisations de l’application à ce qui est nécessaire à l’application.

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 et utilise ces informations pour authentifier l’application auprès des ressources Azure dont elle a besoin.

1. Enregistrement de l'application dans Azure AD

Les objets de principal du service d’application sont créés avec une inscription d’application dans Azure. Pour ce faire, utilisez le Portail Azure ou Azure CLI.

Azure portal
Azure CLI

Connectez-vous au portail Azure et suivez les étapes ci-dessous.

Instructions	Capture d'écran
Dans le portail Azure : Entrez inscriptions d’applications dans la barre de recherche en haut du Portail Azure. Sélectionnez l’élément étiqueté Inscriptions d’applications sous le titre Services dans le menu qui apparaît sous la barre de recherche.
Dans la page Inscriptions d’applications, sélectionnez + Nouvelle inscription.
Dans la page Inscription d’une application, remplissez le formulaire comme suit : Nom → Entrez un nom pour l’inscription de l’application dans Azure. Nous vous recommandons d’inclure dans ce nom le nom de l’application, l’utilisateur pour lequel l’inscription de l’application est destinée et un identificateur tel que « dev » pour indiquer que cette inscription d’application est destinée à être utilisée dans le développement local. Types de comptes pris en charge → Comptes dans cet annuaire organisationnel uniquement. Sélectionnez Inscrire pour inscrire votre application et créer le principal du service d’application.
Dans la page Inscription de l’application pour votre application : ID d’application (client) → Il s’agit de l’ID d’application que l’application utilisera pour accéder à Azure pendant le développement local. Copiez cette valeur dans un emplacement temporaire dans un éditeur de texte, car vous en aurez besoin dans une prochaine étape. ID de répertoire (locataire) → Cette valeur sera également nécessaire à votre application lorsqu’elle s’authentifie auprès d’Azure. Copiez cette valeur dans un emplacement temporaire dans un éditeur de texte, car vous en aurez besoin dans une prochaine étape. Informations d’identification client → Vous devez définir les informations d’identification du client pour l’application avant que votre application puisse s’authentifier auprès d’Azure et utiliser les services Azure. Sélectionnez Ajouter un certificat ou un secret pour ajouter des informations d’identification pour votre application.
Dans la page Certificats et secrets, sélectionnez + Nouvelle clé secrète client.
La boîte de dialogue Ajouter une clé secrète client s’affiche à droite de la page. Dans cette boîte de dialogue : Description → Entrez la valeur Current. Expire → Sélectionnez une valeur de 24 mois. Sélectionnez Ajouter pour ajouter le secret.
Dans la page Certificats et secrets, la valeur de la clé secrète client vous est présentée. Copiez cette valeur dans un emplacement temporaire dans un éditeur de texte, car vous en aurez besoin dans une prochaine étape. IMPORTANT : c’est la seule fois que vous verrez cette valeur. Une fois que vous aurez quitté ou actualisé cette page, vous ne pourrez plus voir cette valeur. Vous pouvez ajouter une clé secrète client supplémentaire sans invalider cette clé secrète client, mais vous ne verrez plus cette valeur.

Les commandes Azure CLI peuvent être exécutées dans Azure Cloud Shell ou sur une station de travail dans laquelle l’interface Azure CLI est installée.

Tout d’abord, utilisez la commande az ad sp create-for-rbac pour créer un principal de service pour l’application. Cela crée également l’inscription de l’application pour l’application en même temps.

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. C’est le seul endroit où vous pouvez voir la clé secrète client (mot de passe) du principal de service. Toute fois, vous pourrez ajouter par la suite un nouveau mot de passe sans invalider le principal de service ou les mots de passe existants si nécessaire.

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

Étant donné que plusieurs développeurs travaillent généralement sur une application, il est recommandé de créer un groupe Microsoft Entra pour encapsuler les rôles (autorisations) dont l’application a besoin dans le développement local plutôt que d’attribuer les rôles à des objets de principal de service individuels. Cette approche offre les avantages suivants :

Chaque développeur est assuré d’avoir les mêmes rôles attribués, car les rôles sont attribués au niveau du groupe.
Si un nouveau rôle est nécessaire pour l’application, il doit uniquement être ajouté au groupe pour l’application.
Si un nouveau développeur rejoint l’équipe, un nouveau principal de 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.

Azure portal
Azure CLI

Instructions	Capture d'écran
Accédez à la page Microsoft Entra ID du Portail Azure en tapant Microsoft Entra ID dans la zone de recherche en haut de la page. Sélectionnez Microsoft Entra ID sous la section Services.
Dans la page Microsoft Entra ID, sélectionnez Groupes dans le menu de gauche.
Dans la page Tous les groupes, sélectionnez Nouveau groupe.
Dans la page Nouveau groupe : Type de groupe → Sécurité Nom du groupe → Nom du groupe de sécurité, généralement créé à partir du nom de l’application. Il est également utile d’inclure une chaîne telle que local-dev dans le nom du groupe pour indiquer l’objectif du groupe. Description du groupe → Description de l’objectif du groupe. Sélectionnez le lien Aucun membre sélectionné sous Membres pour ajouter des membres au groupe.
Dans la boîte de dialogue Ajouter des membres : Utilisez la zone de recherche pour filtrer la liste des noms principaux dans la liste. Sélectionnez les principaux de service d’application pour le développement local pour cette application. À mesure que les objets sont sélectionnés, ils sont grisés et déplacés vers la liste Éléments sélectionnés en bas de la boîte de dialogue. Lorsque vous avez terminé, sélectionnez le bouton Sélectionner .
Sur la page Nouveau groupe, sélectionnez Créer pour créer le groupe. Le groupe est créé et vous êtes redirigé vers la page Tous les groupes. L’affichage du groupe peut prendre jusqu’à 30 secondes. Vous devrez peut-être actualiser la page en raison de la mise en cache dans le Portail Azure.

La commande az ad group create permet de créer des groupes dans Microsoft Entra ID. Les paramètres --display-name et --mail-nickname sont obligatoires. Le nom donné au groupe doit être basé sur le nom de l’application. Il est également utile d’inclure une expression telle que « local-dev » dans le nom du groupe pour indiquer l’objectif du groupe.

az ad group create \
    --display-name MyDisplay \
    --mail-nickname MyDisplay \
    --description {group-description}

Pour ajouter des membres au groupe, vous avez besoin de l’ID d’objet du principal de 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. La commande avec le paramètre --filter accepte les filtres de style OData et peut être utilisée pour filtrer la liste comme indiqué. Le paramètre --query limite les colonnes aux colonnes intéressantes.

az ad sp list \
    --filter "startswith(displayName, 'msdocs')" \
    --query "[].{objectId:objectId, displayName:displayName}" \
    --output table

Vous pouvez ensuite utiliser 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}

3 - Attribuer des rôles à l’application

Ensuite, déterminez les rôles (autorisations) dont votre application a besoin sur les ressources et attribuez ces rôles à votre application. Dans cet exemple, les rôles seront attribués au groupe Microsoft Entra créé à l’étape 2. Les groupes peuvent se voir attribuer un rôle au niveau d’une ressource, d’un groupe de ressources ou d’un 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.

Azure portal
Azure CLI

Instructions	Capture d'écran
Recherchez le groupe de ressources pour votre application en recherchant le nom du groupe de ressources à l’aide de la zone de recherche en haut du Portail Azure. Accédez à votre groupe de ressources en sélectionnant le nom du groupe de ressources sous le titre Groupes de ressources dans la boîte de dialogue.
Dans la page du groupe de ressources, sélectionnez Contrôle d’accès (IAM) dans le menu de gauche.
Dans la page Contrôle d’accès (IAM) : Sélectionnez l’onglet Attributions de rôles. Sélectionnez + Ajouter dans le menu supérieur, puis Ajouter une attribution de rôle dans le menu déroulant résultant.
La page Ajouter une attribution de rôle répertorie tous les rôles qui peuvent être attribués pour le groupe de ressources. Utilisez la zone de recherche pour filtrer la liste afin de la rendre plus facile à gérer. Cet exemple montre comment filtrer les rôles d’objets blob de stockage. Sélectionnez le rôle que vous voulez attribuer. Sélectionnez Suivant pour accéder à l’écran suivant.
La page de rôle suivante Ajouter une attribution vous permet de spécifier l’utilisateur auquel attribuer le rôle. Sélectionnez Utilisateur, groupe ou principal de service sous Attribuer l’accès à. Sélectionnez + Sélectionner des membres sous Membres. Une boîte de dialogue s’ouvre sur le côté droit du Portail Azure.
Dans la boîte de dialogue Sélectionner des membres : La zone de texte Sélectionner peut être utilisée pour filtrer la liste des utilisateurs et des groupes de votre abonnement. Si nécessaire, tapez les premiers caractères du groupe Microsoft Entra de développement local que vous avez créé pour l’application. Sélectionnez le groupe Microsoft Entra de développement local associé à votre application. Sélectionnez Sélectionner en bas de la boîte de dialogue pour continuer.
Le groupe Microsoft Entra apparaît désormais comme sélectionné dans l’écran Ajouter une attribution de rôle. Sélectionnez Vérifier + affecter pour accéder à la page finale, puis Vérifier + attribuer à nouveau pour terminer le processus.

Pour attribuer un rôle à un principal de service d’application dans Azure, utilisez la commande az role assignment create :

az role assignment create --assignee "{appId}" \
    --role "{roleName}" \
    --resource-group "{resourceGroupName}"

Pour obtenir les noms de rôle auxquels un principal de service peut être attribué, utilisez la commande az role definition list :

az role definition list \
    --query "sort_by([].{roleName:roleName, description:description}, &roleName)" \
    --output table

Par exemple, pour autoriser le principal de service d’application avec l’appId 00000000-0000-0000-0000-000000000000 à accéder en lecture, écriture et suppression aux conteneurs d’objets blob et aux données de Stockage Azure de tous les comptes de stockage dans le groupe de ressources msdocs-dotnet-sdk-auth-example, attribuez le principal de service d’application au rôle Contributeur aux données Blob du stockage à l’aide de la commande suivante :

az role assignment create --assignee "00000000-0000-0000-0000-000000000000" \
    --role "Storage Blob Data Contributor" \
    --resource-group "msdocs-dotnet-sdk-auth-example"

Pour plus d’informations sur l’attribution d’autorisations au niveau de la ressource ou de l’abonnement avec Azure CLI, consultez Attribuer des rôles Azure à l’aide d’Azure CLI.

4 - Définir des variables d’environnement d’application

Au moment de l’exécution, DefaultAzureCredential recherche les informations du principal de service dans une collection de 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 lorsque vous utilisez un principal de service :

AZURE_CLIENT_ID → Valeur de l’ID d’application.
AZURE_TENANT_ID → Valeur de l’ID de locataire.
AZURE_CLIENT_SECRET → Mot de passe/informations d’identification générés pour l’application.

Lorsque vous travaillez localement avec Visual Studio, les variables d’environnement peuvent être définies dans le launchsettings.json fichier du Properties dossier de votre projet. Lorsque l’application démarre, ces valeurs sont automatiquement extraites. Gardez à l’esprit que ces configurations ne transitent pas avec votre application quand elle est déployée. Vous devez donc toujours 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": "00000000-0000-0000-0000-000000000000",
        "AZURE_TENANT_ID":"11111111-1111-1111-1111-111111111111",
        "AZURE_CLIENT_SECRET": "=abcdefghijklmnopqrstuvwxyz"
      }
    },
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development",
        "AZURE_CLIENT_ID": "00000000-0000-0000-0000-000000000000",
        "AZURE_TENANT_ID": "11111111-1111-1111-1111-111111111111",
        "AZURE_CLIENT_SECRET": "=abcdefghijklmnopqrstuvwxyz"
      }
    }
  }

Lorsque vous travaillez localement avec Visual Studio Code, les variables d’environnement peuvent être définies dans le fichier launch.json du dossier de votre projet. Lorsque l’application démarre, ces valeurs sont automatiquement extraites. Gardez à l’esprit que ces configurations ne transitent pas avec votre application quand elle est déployée. Vous devez donc toujours configurer des variables d’environnement sur votre environnement d’hébergement cible.

"configurations": [
{
    "env": {
        "ASPNETCORE_ENVIRONMENT": "Development",
        "AZURE_CLIENT_ID": "00000000-0000-0000-0000-000000000000",
        "AZURE_TENANT_ID":"11111111-1111-1111-1111-111111111111",
        "AZURE_CLIENT_SECRET": "=abcdefghijklmnopqrstuvwxyz"
    }
}

Vous pouvez définir des variables d’environnement pour Windows à partir de la ligne de commande. Toutefois, quand vous utilisez cette approche, les valeurs sont accessibles à toutes les applications s’exécutant sur ce système d’exploitation, ce qui peut entraîner des conflits si vous n’êtes pas prudent. 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 "00000000-0000-0000-0000-000000000000"
setx AZURE_TENANT_ID "11111111-1111-1111-1111-111111111111"
setx AZURE_CLIENT_SECRET "=abcdefghijklmnopqrstuvwxyz"

# Set system environment variables - requires running as admin
setx ASPNETCORE_ENVIRONMENT "Development"
setx AZURE_CLIENT_ID "00000000-0000-0000-0000-000000000000" /m
setx AZURE_TENANT_ID "11111111-1111-1111-1111-111111111111" /m
setx AZURE_CLIENT_SECRET "=abcdefghijklmnopqrstuvwxyz" /m

Vous pouvez également utiliser PowerShell pour définir des variables d’environnement au niveau de l’utilisateur ou de la machine :

# Set user environment variables
[Environment]::SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development", "User")
[Environment]::SetEnvironmentVariable("AZURE_CLIENT_ID", "00000000-0000-0000-0000-000000000000", "User")
[Environment]::SetEnvironmentVariable("AZURE_TENANT_ID", "11111111-1111-1111-1111-111111111111", "User")
[Environment]::SetEnvironmentVariable("AZURE_CLIENT_SECRET", "=abcdefghijklmnopqrstuvwxyz", "User")

# Set system environment variables - requires running as admin
[Environment]::SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development", "Machine")
[Environment]::SetEnvironmentVariable("AZURE_CLIENT_ID", "00000000-0000-0000-0000-000000000000", "Machine")
[Environment]::SetEnvironmentVariable("AZURE_TENANT_ID", "11111111-1111-1111-1111-111111111111", "Machine")
[Environment]::SetEnvironmentVariable("AZURE_CLIENT_SECRET", "=abcdefghijklmnopqrstuvwxyz", "Machine")

5 - Implémenter DefaultAzureCredential dans votre application

DefaultAzureCredential est une séquence bien arrêtée et ordonnée de mécanismes d’authentification auprès de Microsoft Entra. Chaque mécanisme d’authentification est une classe dérivée de la classe TokenCredential (on parle d’informations d’identification). Au moment de l’exécution, DefaultAzureCredential tente de s’authentifier en utilisant les premières informations d’identification. Si ces informations d’identification ne parviennent pas à acquérir un jeton d’accès, les informations d’identification suivantes de la séquence sont utilisées, et ainsi de suite jusqu’à l’obtention d’un jeton d’accès. De cette façon, votre application peut utiliser différentes informations d’identification dans différents environnements sans qu’il soit nécessaire d’écrire du code propre à l’environnement.

L’ordre et les emplacements dans lesquels DefaultAzureCredential recherchent les informations d’identification se trouvent dans DefaultAzureCredential.

Pour utiliser DefaultAzureCredential, ajoutez les packages Azure.Identity et éventuellement Microsoft.Extensions.Azure à votre application :

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 de client du Kit de développement logiciel (SDK) Azure. Ces classes et vos propres services personnalisés doivent être inscrits afin qu’ils soient accessibles par le biais de l’injection de dépendances dans votre application. Dans Program.cs, effectuez les étapes suivantes pour inscrire une classe cliente et DefaultAzureCredential :

Incluez les espaces de noms Azure.Identity et Microsoft.Extensions.Azure via les directives using.
Inscrivez le client du service Azure à l’aide de la méthode d’extension correspondante préfixée avec Add.
Passez une instance de DefaultAzureCredential à la méthode UseCredential.

Par exemple :

using Microsoft.Extensions.Azure;
using Azure.Identity;

builder.Services.AddAzureClients(clientBuilder =>
{
    clientBuilder.AddBlobServiceClient(
        new Uri("https://<account-name>.blob.core.windows.net"));
    clientBuilder.UseCredential(new DefaultAzureCredential());
});

Une alternative à UseCredential consiste à instancier directement DefaultAzureCredential :

using Azure.Identity;

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

Lorsque le code précédent s’exécute sur votre poste de travail de développement local, il recherche dans les variables d’environnement un principal de service d’application ou, dans les outils de développement installés localement comme Visual Studio, un ensemble d’informations d’identification de développeur. Vous pouvez utiliser l’une ou l’autre de ces approches pour authentifier l’application auprès des ressources Azure pendant le développement local.

Quand vous le déployez sur Azure, ce même code peut également authentifier votre application auprès d’autres ressources Azure. DefaultAzureCredential peut récupérer les paramètres d’environnement et les configurations d’identité managée pour s’authentifier automatiquement auprès d’autres services.

Partager via