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

10 minutes

Dans cet exercice, vous allez apprendre à effectuer les actions suivantes :

Inscrire une application auprès de 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

Conditions préalables

Un compte Azure avec un abonnement actif. Si vous n’en avez pas encore, vous pouvez vous inscrire à un essai gratuit à https://azure.com/free
Visual Studio Code: vous pouvez installer Visual Studio Code à partir de https://code.visualstudio.com.
Version du Kit de développement logiciel (SDK) .NET https://dotnet.microsoft.com/download/dotnet (6.0, 7.0 ou 8.0)

Inscrire une nouvelle application

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

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

Champ	Valeur
Nom	`az204appreg`
types de comptes pris en charge	Sélectionnez Comptes dans ce répertoire d'organisation uniquement
URI de redirection (facultatif)	Sélectionnez client natif/public (mobile & bureau) et entrez `http://localhost` dans la zone à droite.

Sélectionnez Inscrire.

Microsoft Entra ID affecte un ID d’application (client) unique à 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, puis nouveau terminal.
Créez un dossier pour le projet et passez au 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
```

Générer l’application console

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

Ajouter des paquets 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 async.

public static async Task Main(string[] args)

Ajouter du code pour l’authentification interactive

Vous avez besoin de deux variables pour contenir les ID d’application (client) et d’annuaire (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 enregistrée.

Acquérir un jeton

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

Définissez l’étendue des autorisations pour la demande de jeton. Ajoutez le code suivant sous le 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}");

Passer en revue 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écuter l’application

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