Exercice - Implémenter l’authentification interactive à l’aide de MSAL.NET

10 minutes

Dans cet exercice, vous découvrez comment effectuer les actions suivantes :

Inscrire une application avec la plateforme d’identités Microsoft
Utiliser la classe PublicClientApplicationBuilder dans MSAL.net
Acquérir un jeton de manière interactive dans une application console

Prérequis

Un compte Azure avec un abonnement actif. Si vous n’en avez pas, vous pouvez vous inscrire à une évaluation gratuite sur https://azure.com/free.
Visual Studio Code : Vous pouvez installer Visual Studio Code depuis https://code.visualstudio.com.
Une version du kit de développement logiciel (SDK) https://dotnet.microsoft.com/download/dotnet .NET (6.0, 7.0 ou 8.0)

Inscrire une nouvelle application

Connectez-vous au portail : https://portal.azure.com
Recherchez et sélectionnez Microsoft Entra ID.
Sous Gérer, sélectionnez Inscriptions d’applications>Nouvelle inscription.

Lorsque la page Inscrire une application s’affiche, saisissez les informations d’inscription de votre application :

Champ	Valeur
Nom	`az204appreg`
Types de comptes pris en charge	Sélectionnez Comptes dans cet annuaire organisationnel uniquement
URI de redirection (facultatif)	Sélectionnez Client public/natif (mobile & bureau) et entrez `http://localhost` dans la case à droite.

Sélectionnez Inscrire.

Microsoft Entra ID attribue un ID d’application unique (client) à votre application, et vous êtes redirigé vers la page Vue d’ensemble de votre application.

Configurer l’application console

Lancez Visual Studio Code et ouvrez un terminal en sélectionnant Terminal et Nouveau terminal.
Créez un dossier pour le projet et accédez à ce dossier.
```
md az204-auth
cd az204-auth
```
Créez l’application console .NET.
```
dotnet new console
```
Ouvrez le dossier az204-auth dans Visual Studio Code.
```
code . -r
```

Créer l’application console

Dans cette section, vous ajoutez les packages et le code nécessaires au projet.

Ajouter des packages et des instructions using

Ajoutez le package Microsoft.Identity.Client au projet dans un terminal dans Visual Studio Code.
```
dotnet add package Microsoft.Identity.Client
```
Ouvrez le fichier Program.cs et ajoutez des instructions using pour inclure Microsoft.Identity.Client et activer les opérations asynchrones.
```
using System.Threading.Tasks;
using Microsoft.Identity.Client;
```
Modifiez la méthode Main pour activer la méthode asynchrone.
```
public static async Task Main(string[] args)
```

Ajouter du code pour l’authentification interactive

Vous aurez besoin de deux variables pour stocker les ID de l’application (client) et du répertoire (locataire). Vous pouvez copier ces valeurs à partir du portail. Ajoutez le code suivant et remplacez les valeurs de chaîne par les valeurs appropriées à partir du portail.
```
private const string _clientId = "APPLICATION_CLIENT_ID";
private const string _tenantId = "DIRECTORY_TENANT_ID";
```

Utilisez la classe PublicClientApplicationBuilder pour générer le contexte d’autorisation.

var app = PublicClientApplicationBuilder
    .Create(_clientId)
    .WithAuthority(AzureCloudInstance.AzurePublic, _tenantId)
    .WithRedirectUri("http://localhost")
    .Build();

Code	Description
`.Create`	Crée un `PublicClientApplicationBuilder` à partir d’un clientID.
`.WithAuthority`	Ajoute une autorité connue correspondant à un serveur ADFS. Dans le code, nous spécifions le cloud public et utilisons le locataire pour l’application que nous avons inscrite.

Acquérir un jeton

Quand vous avez inscrit l’application az204appreg, elle a généré automatiquement une autorisation API user.read pour Microsoft Graph. Vous utilisez cette autorisation pour acquérir un jeton.

Définissez l’étendue d’autorisation pour la demande de jeton. Ajoutez le code suivant sous PublicClientApplicationBuilder.
```
string[] scopes = { "user.read" };
```

Ajoutez du code pour demander le jeton et écrire le résultat dans la console.

AuthenticationResult result = await app.AcquireTokenInteractive(scopes).ExecuteAsync();

Console.WriteLine($"Token:\t{result.AccessToken}");

Vérifier l’application terminée

Le contenu du fichier Program.cs doit ressembler à l’exemple suivant :

using System;
using System.Threading.Tasks;
using Microsoft.Identity.Client;

namespace az204_auth
{
    class Program
    {
        private const string _clientId = "APPLICATION_CLIENT_ID";
        private const string _tenantId = "DIRECTORY_TENANT_ID";

        public static async Task Main(string[] args)
        {
            var app = PublicClientApplicationBuilder
                .Create(_clientId)
                .WithAuthority(AzureCloudInstance.AzurePublic, _tenantId)
                .WithRedirectUri("http://localhost")
                .Build(); 
            string[] scopes = { "user.read" };
            AuthenticationResult result = await app.AcquireTokenInteractive(scopes).ExecuteAsync();

            Console.WriteLine($"Token:\t{result.AccessToken}");
        }
    }
}

Exécution de l'application

Dans le terminal Visual Studio Code, exécutez dotnet build pour vérifier la présence d’erreurs, puis dotnet run pour exécuter l’application.
L’application ouvre le navigateur par défaut, qui vous invite à sélectionner le compte avec lequel vous souhaitez vous authentifier. Si plusieurs comptes sont répertoriés, sélectionnez celui qui est associé au locataire utilisé dans l’application.
Si c’est la première fois que vous vous authentifiez auprès de l’application inscrite, vous recevez une notification Autorisations demandées vous demandant d’approuver l’application afin de lire les données associées à votre compte. Sélectionnez Accepter.
Vous devriez voir des résultats similaires à l’exemple ci-dessous dans la console.
```
Token:  eyJ0eXAiOiJKV1QiLCJub25jZSI6IlVhU.....
```