Tutorial: Vorbereiten einer ASP.NET Core-Webanwendung für die Authentifizierung in einem externen Mandanten

Artikel
04/18/2024

Dieses Tutorial ist Teil 2 einer Serie, die veranschaulicht, wie Sie eine ASP.NET Core-Webanwendung erstellen und auf die Authentifizierung mithilfe des Microsoft Entra Admin Center vorbereiten. In Teil 1 dieser Reihe haben Sie eine Anwendung registriert und Benutzerflows in Ihrem externen Mandanten konfiguriert. Dieses Tutorial zeigt Ihnen, wie Sie eine ASP.NET Core-Webanwendung erstellen und sie für die Authentifizierung konfigurieren.

In diesem Tutorial lernen Sie:

Erstellen eines ASP.NET Core-Projekts in Visual Studio Code
Hinzufügen der erforderlichen NuGet-Pakete
Konfigurieren der Einstellungen für die Anwendung
Hinzufügen von Code zum Implementieren der Authentifizierung

Voraussetzungen

Tutorial: Vorbereiten Ihres externen Mandanten auf die Erstellung einer ASP.NET Core-Webanwendung.
Sie können jede integrierte Entwicklungsumgebung (IDE) verwenden, die ASP.NET Core-Anwendungen unterstützt. In diesem Tutorial wird Visual Studio Code verwendet. Sie können sie hier herunterladen.
.NET 7.0 SDK

Erstellen eines ASP.NET Core-Projekts

Öffnen Sie Visual Studio Code, und wählen Sie Datei>Ordner öffnen... aus. Navigieren Sie zu dem Speicherort, an dem Ihr Projekt erstellt werden soll, und wählen Sie diesen aus.
Öffnen Sie ein neues Terminal, indem Sie Terminal>Neues Terminal auswählen.
Geben Sie den folgenden Befehl ein, um ein Model View Controller (MVC)-ASP.NET Core-Projekt zu erstellen.
```
dotnet new mvc -n dotnetcore_webapp
```

Identitätspakete installieren

Identitätsbezogene NuGet-Pakete müssen in dem Projekt installiert werden, um Benutzer zu authentifizieren.

Geben Sie die folgenden Befehle ein, um in den Ordner dotnetcore_webapp zu wechseln und das entsprechende NuGet-Paket zu installieren:
```
cd dotnetcore_webapp
dotnet add package Microsoft.Identity.Web.UI
```

Konfigurieren der Anwendung für die Authentifizierung

Öffnen Sie die Datei appsettings.json, und ersetzen Sie den vorhandenen Code durch den folgenden Codeschnipsel.
```
{
  "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: Identitätsanbieterinstanz und Anmeldezielgruppe für die Anwendung. Ersetzen Sie Enter_the_Tenant_Subdomain_Here durch die Unterdomäne Ihres externen Mandanten. Um diese zu finden, wählen Sie Übersicht im Seitenleistenmenü aus, und wechseln Sie dann auf die Registerkarte Übersicht. Suchen Sie die Primäre Domäne in der Form caseyjensen.onmicrosoft.com. Die Unterdomäne ist caseyjensen.
- ClientId – Der Bezeichner der Anwendung, auch als Client bezeichnet. Ersetzen Sie den Text in Anführungszeichen durch den Wert Anwendungs-ID (Client-ID), die zuvor auf der Übersichtsseite der registrierten Anwendung aufgezeichnet wurde.
- ClientSecret: Der Wert des geheimen Clientschlüssels, den Sie in Vorbereiten Ihres Mandanten erstellt haben. Ersetzen Sie den Text in Anführungszeichen durch den Wert des geheimen Clientschlüssels im Microsoft Entra Admin Center.
- CallbackPath: Dies ist ein Bezeichner, der es dem Server ermöglicht, eine Antwort an die entsprechende Anwendung umzuleiten.
Speichern Sie die an der Datei vorgenommenen Änderungen.
Öffnen Sie die Datei Properties/launchSettings.json.
Ändern Sie im https-Abschnitt von profiles die https-URL in applicationUrl, sodass sie https://localhost:7274 lautet. Sie haben diese URL verwendet, um den Umleitungs-URI zu definieren.
Speichern Sie die Änderungen an der Datei.

Hinzufügen der Autorisierung zu HomeController.cs

Die Datei HomeController.cs enthält den Code für die Startseite der Anwendung und muss über die Fähigkeit verfügen, den Benutzer zu autorisieren. Der Microsoft.AspNetCore.Authorization-Namespace stellt die Klassen und Schnittstellen bereit, um die Autorisierung für die Web-App zu implementieren, und das Attribut [Authorize] wird verwendet, um anzugeben, dass nur authentifizierte Benutzer die Web-App verwenden können.

Öffnen Sie in Ihrem Code-Editor die Datei Controllers\HomeController.cs.
Die Autorisierung muss dem Controller hinzugefügt werden, und fügen Sie Microsoft.AspNetCore.Authorization hinzu, damit der Dateianfang mit dem folgenden Ausschnitt identisch ist:
```
using System.Diagnostics;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using dotnetcore_webapp.Models;
```
Fügen Sie außerdem das Attribut [Authorize] direkt über der Klassendefinition HomeController hinzu.
```
[Authorize]
```

Hinzufügen von Authentifizierung und Autorisierung zu Program.cs

Die Datei Program.cs muss geändert werden, um der Web-App Authentifizierung und Autorisierung hinzuzufügen. Dies umfasst das Hinzufügen von Namespaces für die Authentifizierung und Autorisierung sowie das Anmelden von Benutzern über die Microsoft Identity Platform.

Um die erforderlichen Namespaces hinzuzufügen, öffnen Sie die Datei Program.cs und fügen Sie den folgenden Codeschnipsel am Anfang der Datei hinzu:

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;

Fügen Sie als Nächstes die Authentifizierungsdienste zur Anwendung hinzu, mit denen die Web-App in der Lage ist, Benutzer über die Microsoft Identity Platform anzumelden. Sie können den restlichen Code in Program.cs durch den folgenden Codeschnipsel ersetzen:

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

Nächster Schritt

Schritt 3: Hinzufügen der An- und Abmeldung zu einer ASP.NET Core-Webanwendung für einen externen Mandanten

Share via