Esercitazione: Preparare un'app Web ASP.NET Core per l'autenticazione in un tenant esterno

Articolo
06/21/2024

Questa esercitazione è la parte 2 di una serie che illustra come creare un'applicazione Web ASP.NET Core e prepararla per l'autenticazione usando l'interfaccia di amministrazione di Microsoft Entra. Nella parte 1 di questa serie è stata registrata un'applicazione e sono stati configurati i flussi utente nel tenant esterno. Questa esercitazione illustra come creare un'app Web ASP.NET Core e configurarla per l'autenticazione.

In questa esercitazione si apprenderà come:

Creare un progetto di ASP.NET Core in Visual Studio Core
Aggiungere i pacchetti NuGet necessari
Configurare le impostazioni per l'applicazione
Aggiungere codice per implementare l'autenticazione

Prerequisiti

Esercitazione: Preparare il tenant esterno per la creazione di un'app Web core ASP.NET.
Anche se è possibile usare qualsiasi ambiente di sviluppo integrato (IDE) che supporta ASP.NET applicazioni Core, questa esercitazione usa Visual Studio Code. È possibile scaricarlo qui.
.NET 7.0 SDK.

Creare un progetto ASP.NET Core

Aprire Visual Studio Code, selezionare File>Apri cartella. Passare a e selezionare il percorso in cui creare il progetto.
Aprire un nuovo terminale selezionando Terminale>Nuovo terminale.
Immettere il comando seguente per creare un progetto MVC (Model View Controller) ASP.NET Core.
```
dotnet new mvc -n dotnetcore_webapp
```

Installare i pacchetti Identity

I pacchetti NuGet correlati all'identità devono essere installati nel progetto per autenticare gli utenti.

Immettere i comandi seguenti per passare alla cartella dotnetcore_webapp e installare il pacchetto NuGet pertinente:
```
cd dotnetcore_webapp
dotnet add package Microsoft.Identity.Web.UI
```

Configurare l'applicazione per l'autenticazione

Aprire il file appsettings.json e sostituire il codice esistente con il frammento di codice seguente.
```
{
  "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'istanza del provider di identità e il gruppo di destinatari di accesso per l'app. Sostituire Enter_the_Tenant_Subdomain_Here con il sottodominio del tenant esterno. Per trovarlo, selezionare Panoramica nel menu della barra laterale, quindi passare alla scheda Panoramica. Trovare il dominio primario nel formato caseyjensen.onmicrosoft.com. Il sottodominio è caseyjensen.
- ClientId - Identificatore dell'applicazione, detto anche client. Sostituire il testo tra virgolette con valore ID applicazione (client) registrato in precedenza dalla pagina di panoramica dell'applicazione registrata.
- ClientSecret - Valore del segreto client creato in Preparare il tenant. Sostituire il testo tra virgolette con il valore del segreto client nell'interfaccia di amministrazione di Microsoft Entra.
- CallbackPath - Identificatore che consente al server di reindirizzare una risposta all'applicazione appropriata.
Salvare le modifiche apportate al file .
Aprire il file Proprietà/launchSettings.json.
Nella sezione https di profiles, modificare l'URL https in applicationUrl in modo che legga https://localhost:7274. Questo URL è stato usato per definire l'URI di reindirizzamento.
Salvare le modifiche apportate al file.

Aggiungere l'autorizzazione a HomeController.cs

Il file HomeController.cs contiene il codice per la home page dell'applicazione e deve avere la possibilità di autorizzare l'utente. Lo spazio dei nomi Microsoft.AspNetCore.Authorization fornisce le classi e le interfacce per implementare l'autorizzazione per l'app Web, e l'attributo [Authorize] viene usato per specificare che solo gli utenti autenticati possono usare l'app Web.

Nell'editor di codice aprire il file Controller\HomeController.cs.
Deve essere aggiunta l'autorizzazione al controller; aggiungere Microsoft.AspNetCore.Authorization in modo che la parte superiore del file sia identica al frammento di codice seguente:
```
using System.Diagnostics;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using dotnetcore_webapp.Models;
```
Aggiungere inoltre l'attributo [Authorize] direttamente sopra la definizione della classe HomeController.
```
[Authorize]
```

Aggiungere l'autenticazione e l'autorizzazione a Program.cs

Il Program.cs deve essere modificato per aggiungere l'autenticazione e l'autorizzazione all'app Web. Sono inclusi l'aggiunta di spazi dei nomi per l'autenticazione e l'autorizzazione e la possibilità di accedere agli utenti con Microsoft Identity Platform.

Per aggiungere gli spazi dei nomi necessari, aprire Program.cs e aggiungere il frammento di codice seguente all'inizio del file:

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;

Aggiungere quindi i servizi di autenticazione all'applicazione che consentirà all'app Web di accedere agli utenti con Microsoft Identity Platform. È possibile sostituire il resto del codice in Program.cs con il frammento di codice seguente:

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();

Passaggio successivo

Passaggio 3: Aggiungere l'accesso e la disconnessione a un'applicazione Web ASP.NET Core per un tenant esterno

Condividi tramite