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

Articolo
06/29/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.

Usare l'URL di dominio personalizzato (facoltativo)

Usare un dominio personalizzato per personalizzare completamente l'URL di autenticazione. Dal punto di vista dell'utente, gli utenti rimangono nel dominio durante il processo di autenticazione, anziché essere reindirizzati a ciamlogin.com nome di dominio.

Seguire questa procedura per usare un dominio personalizzato:

Usare la procedura descritta in Abilitare domini URL personalizzati per le app nei tenant esterni per abilitare l'URL di dominio personalizzato per il tenant esterno.
Aprire appsettings.json file:
1. Aggiornare il valore della Authority proprietà in https://Enter_the_Custom_Domain_Here/Enter_the_Tenant_ID_Here. Sostituire Enter_the_Custom_Domain_Here con l'URL del dominio personalizzato e Enter_the_Tenant_ID_Here con l'ID tenant. Se non si ha l'ID tenant, vedere come leggere i dettagli del tenant.
2. Aggiungere knownAuthorities una proprietà con un valore [Enter_the_Custom_Domain_Here].

Dopo aver apportato le modifiche al file di appsettings.json , se l'URL del dominio personalizzato è login.contoso.com e l'ID tenant è aaaabbbbbb-0000-cccc-1111-dddd2222eeee, il file dovrebbe essere simile al frammento di codice seguente:

{
  "AzureAd": {
    "Authority": "https://login.contoso.com/aaaabbbb-0000-cccc-1111-dddd2222eeee",
    "ClientId": "Enter_the_Application_Id_Here",
    "ClientCredentials": [
      {
        "SourceType": "ClientSecret",
        "ClientSecret": "Enter_the_Client_Secret_Here"
      }
    ],
    "CallbackPath": "/signin-oidc",
    "SignedOutCallbackPath": "/signout-callback-oidc",
    "KnownAuthorities": ["login.contoso.com"]
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

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