Tutoriel : préparer une application web ASP.NET Core pour l’authentification dans un locataire externe

Article
04/17/2024

Ce tutoriel est la partie 2 d’une série montrant comment créer une application web ASP.NET Core et la préparer pour l’authentification en utilisant le centre d’administration Microsoft Entra. Dans la première partie de cette série, vous avez enregistré une application et configuré des flux d’utilisateurs dans votre locataire externe. Ce tutoriel montre comment créer une application web ASP.NET Core et la configurer pour l’authentification.

Dans ce tutoriel, vous allez :

Créer un projet ASP.NET Core dans Visual Studio Code
Ajouter les packages NuGet nécessaires
Configurer les paramètres de l’application
Ajouter du code pour implémenter l’authentification

Prérequis

Tutoriel : Préparer votre locataire externe pour la création d’une application web ASP.NET Core.
Même si vous pouvez utiliser n’importe quel environnement de développement intégré (IDE) prenant en charge les applications ASP.NET Core, ce tutoriel utilise Visual Studio Code. Vous pouvez le télécharger ici.
SDK .NET 7.0.

Créer un projet ASP.NET Core

Ouvrez Visual Studio Code, sélectionnez Fichier>Ouvrir le dossier.... Accédez à et sélectionnez l’emplacement dans lequel vous souhaitez créer votre projet.
Ouvrez un nouveau terminal en sélectionnant Terminal>Nouveau Terminal.
Entrez la commande suivante pour créer un projet ASP.NET Core modèle-vue-contrôleur (MVC).
```
dotnet new mvc -n dotnetcore_webapp
```

Installer des packages d’identité

Les packages NuGet liés à l’identité doivent être installés dans le projet pour authentifier les utilisateurs.

Entrez les commandes suivantes pour accéder au dossier dotnetcore_webapp et installer le package NuGet approprié :
```
cd dotnetcore_webapp
dotnet add package Microsoft.Identity.Web.UI
```

Configurer l’application pour l’authentification

Ouvrez le fichier appsettings.json et remplacez le code existant par ce qui suit.
```
{
  "AzureAd": {
    "Authority": "https://Enter_the_Tenant_Subdomain_Here.ciamlogin.com/",
    "ClientId": "Enter_the_Application_Id_Here",
    "ClientCredentials": [
      {
        "SourceType": "ClientSecret",
        "ClientSecret": "Enter_the_Client_Secret_Here"
      }
    ],
    "CallbackPath": "/signin-oidc",
    "SignedOutCallbackPath": "/signout-callback-oidc"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}
```
- Authority - l’instance du fournisseur d’identité et de l’audience de connexion pour l’application. Remplacez Enter_the_Tenant_Subdomain_Here par le sous-domaine de votre locataire externe. Pour ce faire, sélectionnez Vue d’ensemble dans le menu de la barre latérale, puis basculez vers l’onglet Vue d’ensemble. Recherchez le domaine principal, sous la forme caseyjensen.onmicrosoft.com. Le sous-domaine est caseyjensen.
- ClientId – Identificateur de l’application, également appelé client. Remplacez le texte entre guillemets par la valeur du paramètre ID d’application (locataire) enregistrée précédemment à partir de la page Vue d’ensemble de l’application inscrite.
- ClientSecret - Valeur de la clé secrète client que vous avez créée dans Préparer votre locataire. Remplacez le texte entre guillemets par la valeur de clé secrète client dans le centre d’administration Microsoft Entra.
- CallbackPath – Identificateur destiné à aider le serveur à rediriger une réponse vers l’application appropriée.
Enregistrez les modifications apportées au fichier.
Ouvrez le fichier Properties/launchSettings.json.
Dans la section https de profiles, modifiez l’URL https dans applicationUrl afin qu’elle lise https://localhost:7274. Vous avez utilisé cette URL pour définir l’URI de redirection.
Enregistrez les changements apportés à votre fichier.

Ajouter une autorisation à HomeController.cs

Le fichier HomeController.cs contient le code pour la page d’accueil de l’application et doit pouvoir autoriser l’utilisateur. L’espace de noms Microsoft.AspNetCore.Authorization fournit les classes et les interfaces pour implémenter l’autorisation à l’application web, et l’attribut [Authorize] est utilisé pour préciser que seuls les utilisateurs authentifiés peuvent utiliser l’application web.

Dans votre éditeur de code, ouvrez le fichier Controllers\HomeController.cs.
L’autorisation doit être ajoutée au contrôleur. Ajoutez Microsoft.AspNetCore.Authorization afin que le début du fichier soit identique à l’extrait de code suivant :
```
using System.Diagnostics;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using dotnetcore_webapp.Models;
```
Par ailleurs, ajoutez l’attribut [Authorize] directement au-dessus de la définition de classe HomeController.
```
[Authorize]
```

Ajouter l’authentification et l’autorisation à Program.cs

Program.cs doit être modifié pour ajouter l’authentification et l’autorisation à l’application web. Cela consiste notamment à ajouter des espaces de noms pour l’authentification et l’autorisation et à permettre la connexion des utilisateurs avec la plateforme d'identité Microsoft.

Pour ajouter les espaces de noms nécessaires, ouvrez Program.cs et ajoutez l’extrait de code suivant en haut du fichier :

using Microsoft.AspNetCore.Authentication.OpenIdConnect;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc.Authorization;
using Microsoft.Identity.Web;
using Microsoft.Identity.Web.UI;
using System.IdentityModel.Tokens.Jwt;

Ajoutez ensuite les services d’authentification à l’application, ce qui permettra à l’application web de connecter les utilisateurs avec la plateforme d'identité Microsoft. Vous pouvez remplacer le reste du code de Program.cs par l’extrait de code suivant :

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllersWithViews();

// This is required to be instantiated before the OpenIdConnectOptions starts getting configured.
// By default, the claims mapping will map claim names in the old format to accommodate older SAML applications.
// For instance, 'http://schemas.microsoft.com/ws/2008/06/identity/claims/role' instead of 'roles' claim.
// This flag ensures that the ClaimsIdentity claims collection will be built from the claims in the token
JwtSecurityTokenHandler.DefaultMapInboundClaims = false;

// Sign-in users with the Microsoft identity platform
builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(builder.Configuration)
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddInMemoryTokenCaches();

builder.Services.AddControllersWithViews(options =>
{
    var policy = new AuthorizationPolicyBuilder()
        .RequireAuthenticatedUser()
        .Build();
    options.Filters.Add(new AuthorizeFilter(policy));
}).AddMicrosoftIdentityUI();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();
app.UseAuthorization();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();

Étape suivante

Étape 3 : ajouter la connexion et la déconnexion à une application web ASP.NET Core pour un locataire externe

Partager via