ASP.NET Core Blazor Web App védelme a Microsoft Entra ID-vel

Ez a cikk azt ismerteti, hogyan védhet meg Blazor Web App Microsoft-webcsomagokkal Identity a Microsoft Entra ID-hoz egy mintaalkalmazás használatával.

A cikk ezen verziója az Entra implementálását ismerteti a Frontend háttérrendszer (BFF) mintájának bevezetése nélkül. A BFF-minta a külső szolgáltatásokra irányuló hitelesített kérések készítéséhez hasznos. Módosítsa a cikk verzióválasztóját BFF-mintára , ha az alkalmazás specifikációja kéri a BFF-minta bevezetését.

A következő specifikáció vonatkozik:

Az Blazor Web Appautomatikus renderelési módot használja globális interaktivitással (InteractiveAuto).
A kiszolgálóprojekt meghívja AddAuthenticationStateSerialization, hogy adjon hozzá egy kiszolgálóoldali hitelesítési állapotszolgáltatót, amely PersistentComponentState használ a hitelesítési állapot ügyfélhez való áramlásához. Az ügyfél meghívja AddAuthenticationStateDeserialization, hogy deszerializálja és használja a kiszolgáló által átadott hitelesítési állapotot. A hitelesítési állapot a WebAssembly-alkalmazás élettartamára van rögzítve.
Az alkalmazás a Microsoft Entra ID-t használja, a Microsoft Identity webcsomagokon alapulva.
Az automatikus nem interaktív jogkivonat-frissítést a keretrendszer felügyeli.
Az alkalmazás kiszolgálóoldali és ügyféloldali szolgáltatás absztrakciókat használ a generált időjárási adatok megjelenítéséhez:
- Amikor a Weather összetevőt a kiszolgálón jeleníti meg az időjárási adatok megjelenítéséhez, a ServerWeatherForecaster-t használja. A Microsoft Identity webcsomagjai api-t biztosítanak egy elnevezett alsóbb rétegbeli webszolgáltatás létrehozásához webes API-hívások indításához. Az IDownstreamApi be van injektálva a ServerWeatherForecaster-be, amelyet arra használnak, hogy a CallApiForUserAsync-t meghívják, és így időjárási adatokat szerezzenek be egy külső webes API-ból (MinimalApiJwt projekt).
- Amikor a Weather összetevő megjelenik az ügyfélen, az összetevő a ClientWeatherForecaster szolgáltatás implementálását használja, amely egy előre konfigurált HttpClient (az ügyfélprojekt Program fájljában) használ egy webes API-hívást a kiszolgálóprojekt Minimal API-jára (/weather-forecast) az időjárási adatokhoz. A Minimal API-végpont lekéri az időjárási adatokat a ServerWeatherForecaster osztályból, és visszaadja az ügyfélnek az összetevő általi megjelenítéshez.

Mintamegoldás

A mintamegoldás a következő projektekből áll:

BlazorWebAppEntra: A kiszolgálóoldali Blazor Web Appprojekt, amely egy minimális API-végpontot tartalmaz az időjárási adatokhoz.
BlazorWebAppEntra.Client: A Blazor Web Appügyféloldali projektje.
MinimalApiJwt: Háttérrendszer webes API, amely egy példa Minimal API végpontot tartalmaz az időjárási adatokhoz.

A mintát a Blazor mintatár legújabb verziómappájában érheti el az alábbi hivatkozással. A minta a BlazorWebAppEntra .NET 9 vagy újabb verziójának mappájában található.

Indítsa el a megoldást a Aspire/Aspire.AppHost projektből.

Mintakód megtekintése vagy letöltése (letöltés)

Microsoft Entra ID-alkalmazásregisztrációk

Azt javasoljuk, hogy külön regisztrációkat használjunk alkalmazásokhoz és webes API-khoz, még akkor is, ha az alkalmazások és a webes API-k ugyanabban a megoldásban vannak. Az alábbi útmutató a BlazorWebAppEntra mintamegoldás alkalmazás- és MinimalApiJwt webes API-jára vonatkozik, de ugyanez az útmutató általában az alkalmazások és webes API-k Entra-alapú regisztrációira vonatkozik.

Először regisztrálja a webes API-t (MinimalApiJwt), hogy aztán hozzáférést biztosítson a webes API-hoz az alkalmazás regisztrálásakor. A webes API bérlőazonosítója és ügyfél-azonosítója a webes API Program fájlban történő konfigurálására szolgál. A webes API regisztrálása után tegye elérhetővé a webes API-t az alkalmazásregisztrációkban>API közzététele, egy tartomány nevével: Weather.Get. Jegyezze fel az alkalmazásazonosító URI-ját az alkalmazás konfigurációjában való használatra.

Ezután regisztrálja az alkalmazást (BlazorWebAppEntra) egy webplatform-konfigurációval, amely két bejegyzést tartalmaz az Átirányítási URI területen: és https://localhost/signin-oidc (ezeken az URI-kon nincs szükség portokra).https://localhost/signout-callback-oidc Állítsa be az előtérbeli bejelentkezési URL-címethttps://localhost/signout-callback-oidc (nincs szükség portra). Az alkalmazás appsettings.json fájljában szerepel az alkalmazás bérlőazonosítója, bérlői tartománya és ügyfél-azonosítója, valamint a webes API alapcíme, az alkalmazásazonosító URI-ja és az időjárási hatókör neve, amelyek az alkalmazás beállításához szükségesek. Adjon api-engedélyt a webes API eléréséhez az Alkalmazásregisztrációk>. Ha az alkalmazás biztonsági specifikációja kéri, rendszergazdai hozzájárulást adhat a szervezetnek a webes API eléréséhez. A jogosult felhasználók és csoportok hozzá vannak rendelve az alkalmazás regisztrációihoz az Alkalmazásregisztrációk>, valamint a Nagyvállalati alkalmazásokhoz.

Az Entra vagy az Azure Portal implicit engedélyezési és hibrid folyamatok alkalmazásregisztrációs konfigurációjában ne jelölje be az engedélyezési végpont egyik jelölőnégyzetét sem az Access-jogkivonatok vagy az azonosító jogkivonatok visszaadásához. Az OpenID Connect kezelője automatikusan kéri a megfelelő tokeneket az engedélyezési végponttól a visszaadott kód segítségével.

Hozzon létre egy ügyféltitkosítványt az alkalmazás regisztrációjában az Entra vagy az Azure Portalon (Tanúsítványok kezelése & titkos kulcsokÚj ügyféltitkosítvány). Őrizze meg az ügyféltitkot Érték a következő szakaszban való használathoz.

A cikk későbbi részében további Entra-konfigurációs útmutatást talál az egyes beállításokhoz.

Kiszolgálóoldali Blazor Web App projekt (`BlazorWebAppEntra`)

A BlazorWebAppEntra projekt a Blazor Web Appkiszolgálóoldali projektje.

Ügyféloldali Blazor Web App projekt (`BlazorWebAppEntra.Client`)

A BlazorWebAppEntra.Client projekt a Blazor Web Appügyféloldali projektje.

Ha a felhasználónak be kell jelentkeznie vagy ki kell jelentkeznie az ügyféloldali renderelés során, a rendszer elindítja a teljes oldal újrabetöltését.

Backend web API projekt (`MinimalApiJwt`)

A MinimalApiJwt projekt egy háttérbeli webes API több előtérbeli projekthez. A projekt minimális API-végpontot konfigurál az időjárási adatokhoz.

A MinimalApiJwt.http fájl használható az időjárási adatkérés teszteléséhez. Vegye figyelembe, hogy a végpont teszteléséhez a MinimalApiJwt projektnek futnia kell, a végpont pedig a fájlba van kódolva. További információ: .http-fájlok használata a Visual Studio 2022-ben.

A projekt csomagokat és konfigurációt tartalmaz OpenAPI-dokumentumok létrehozásához.

A biztonságos időjárás-előrejelzési adatvégpont a projekt fájljában Program található:

app.MapGet("/weather-forecast", () =>
{
    var forecast = Enumerable.Range(1, 5).Select(index =>
        new WeatherForecast
        (
            DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
            Random.Shared.Next(-20, 55),
            summaries[Random.Shared.Next(summaries.Length)]
        ))
        .ToArray();
    return forecast;
}).RequireAuthorization();

A RequireAuthorization bővítménymetódus az útvonaldefiníció engedélyezését igényli. A projekthez hozzáadott vezérlők esetében adja hozzá az [Authorize] attribútumot a vezérlőhöz vagy a művelethez.

A háttérrendszer webes API-projektjének konfigurálása (`MinimalApiJwt`)

Konfigurálja a projektet a JwtBearerOptions AddJwtBearer hívásban a MinimalApiJwt projekt Program fájljában.

A web API-alkalmazás regisztrációja esetén a Weather.Get hatókör az Entra vagy az Azure Portalon van konfigurálva az Api közzététele nézetben.

Authority az OIDC-hívásokhoz szükséges jogosultságot állítja be.

jwtOptions.Authority = "{AUTHORITY}";

Az alábbi példák egy bérlőazonosítót aaaabbbb-0000-cccc-1111-dddd2222eeee és egy könyvtárnevet használnak contoso.

Ha az alkalmazás egy ME-ID-bérlőnél van regisztrálva, a hatóságnak meg kell egyeznie az identitásszolgáltató által visszaadott JWT kibocsátóval (iss).

jwtOptions.Authority = "https://sts.windows.net/aaaabbbb-0000-cccc-1111-dddd2222eeee";

Ha az alkalmazás regisztrálva van egy Microsoft Entra Külső ID bérlőben:

jwtOptions.Authority = "https://contoso.ciamlogin.com/aaaabbbb-0000-cccc-1111-dddd2222eeee/v2.0";

Ha az alkalmazás regisztrálva van egy AAD B2C-bérlőben:

jwtOptions.Authority = "https://login.microsoftonline.com/aaaabbbb-0000-cccc-1111-dddd2222eeee/v2.0";

Note

Az Azure Active Directory B2C 2025. május 1-étől már nem érhető el szolgáltatásként az új ügyfelek számára. Az AAD B2C-bérlők az olyan ügyfelek számára támogatottak, akiknek a fiókjai 2025. május 1. előtt lettek létrehozva, egészen 2030-ig. További információ: Azure AD B2C: Gyakori kérdések (GYIK).

Audience beállítja a célközönséget minden fogadott JWT hozzáférési jogkivonathoz.

jwtOptions.Audience = "{AUDIENCE}";

Egyeztesse az értéket kifejezetten az Alkalmazásazonosító URI elérési útjával, ami az Weather.Get hatókör hozzáadásakor van konfigurálva az API-k elérhetővé tételénél az Entra vagy az Azure Portal felületén. Az értékben ne adja meg a "Weather.Get" hatókörnevet.

Az alábbi példák az alkalmazás (ügyfél) azonosítóját 11112222-bbbb-3333-cccc-4444dddd5555használják. A harmadik példa a következő bérlői tartományt contoso.onmicrosoft.comhasználja: .

ME-ID bérlő példája

jwtOptions.Audience = "api://11112222-bbbb-3333-cccc-4444dddd5555";

Microsoft Entra külső azonosító bérlő:

jwtOptions.Audience = "11112222-bbbb-3333-cccc-4444dddd5555";

AAD B2C-bérlő példa:

jwtOptions.Audience = "https://contoso.onmicrosoft.com/11112222-bbbb-3333-cccc-4444dddd5555";

A kiszolgálóprojekt konfigurálása (`BlazorWebAppEntra`)

AddMicrosoftIdentityWebApp A Microsoft Identity Web (Microsoft.Identity.Web NuGet-csomag, API-dokumentáció) BlazorWebAppEntraProgram van konfigurálva a projekt fájljában.

Szerezze be az alkalmazás (ügyfél) azonosítóját, bérlői (közzétevői) tartományát és címtár-(bérlői) azonosítóját az alkalmazás Entra vagy Azure Portalon való regisztrációjából. A Weather.Get hatókör számára az alkalmazásazonosító URI-t a webes API regisztrációjából szerezhetjük be. Ne adja meg a hatókör nevét, amikor az alkalmazásazonosító URI-t megszerzi a portálról.

A hitelesítési konfiguráció a bérlő típusától függ:

ME-ID bérlő konfigurációja
Microsoft Entra külső azonosító konfigurálása

ME-ID bérlőkonfiguráció

Ez a szakasz egy Microsoft Entra-azonosítóban vagy Azure AAD B2C-bérlőben regisztrált alkalmazásra vonatkozik.

A(z) BlazorWebAppEntra projekt Program fájljában adja meg az alábbi helyőrzők értékeit a Microsoft Identity Web konfigurációjában.

builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(msIdentityOptions =>
    {
        msIdentityOptions.CallbackPath = "/signin-oidc";
        msIdentityOptions.ClientId = "{CLIENT ID (BLAZOR APP)}";
        msIdentityOptions.Domain = "{DIRECTORY NAME}.onmicrosoft.com";
        msIdentityOptions.Instance = "https://login.microsoftonline.com/";
        msIdentityOptions.ResponseType = "code";
        msIdentityOptions.TenantId = "{TENANT ID}";
    })
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDownstreamApi("DownstreamApi", configOptions =>
    {
        configOptions.BaseUrl = "{BASE ADDRESS}";
        configOptions.Scopes = ["{APP ID URI}/Weather.Get"];
    })
    .AddDistributedTokenCaches();

Helyőrzők az előző konfigurációban:

{CLIENT ID (BLAZOR APP)}: Az alkalmazás (ügyfél) azonosítója.
{DIRECTORY NAME}: A bérlői (közzétevői) tartomány könyvtárneve.
{TENANT ID}: A címtár (bérlő) azonosítója.
{BASE ADDRESS}: A webes API alapcíme.
{APP ID URI}: A webes API-hatókörök alkalmazásazonosítójának URI-ja. A rendszer a következő formátumok egyikét használja, ahol a {CLIENT ID (WEB API)} helyőrző a webes API Entra-regisztrációjának ügyfélazonosítója, a {DIRECTORY NAME} helyőrző pedig a bérlői (közzétevői) tartomány könyvtárneve (például: contoso).
- ME-ID bérlő formátuma: api://{CLIENT ID (WEB API)}
- B2C-bérlő formátuma: https://{DIRECTORY NAME}.onmicrosoft.com/{CLIENT ID (WEB API)}

Example:

builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(msIdentityOptions =>
    {
        msIdentityOptions.CallbackPath = "/signin-oidc";
        msIdentityOptions.ClientId = "00001111-aaaa-2222-bbbb-3333cccc4444";
        msIdentityOptions.Domain = "contoso.onmicrosoft.com";
        msIdentityOptions.Instance = "https://login.microsoftonline.com/";
        msIdentityOptions.ResponseType = "code";
        msIdentityOptions.TenantId = "aaaabbbb-0000-cccc-1111-dddd2222eeee";
    })
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDownstreamApi("DownstreamApi", configOptions =>
    {
        configOptions.BaseUrl = "https://localhost:7277";
        configOptions.Scopes = ["api://11112222-bbbb-3333-cccc-4444dddd5555/Weather.Get"];
    })
    .AddDistributedTokenCaches();

Microsoft Entra külső azonosító konfigurálása

Ez a szakasz egy Microsoft Entra külső azonosítójú bérlőben regisztrált alkalmazásra vonatkozik.

A(z) BlazorWebAppEntra projekt Program fájljában adja meg az alábbi helyőrzők értékeit a Microsoft Identity Web konfigurációjában.

builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(msIdentityOptions =>
    {
        msIdentityOptions.CallbackPath = "/signin-oidc";
        msIdentityOptions.Authority = "https://{DIRECTORY NAME}.ciamlogin.com/{TENANT ID}/v2.0";
        msIdentityOptions.ClientId = "{CLIENT ID (BLAZOR APP)}";
        msIdentityOptions.ResponseType = "code";
    })
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDownstreamApi("DownstreamApi", configOptions =>
    {
        configOptions.BaseUrl = "{BASE ADDRESS}";
        configOptions.Scopes = ["{APP ID URI}/Weather.Get"];
    })
    .AddDistributedTokenCaches();

Helyőrzők az előző konfigurációban:

{DIRECTORY NAME}: A bérlői (közzétevői) tartomány könyvtárneve.
{CLIENT ID (BLAZOR APP)}: Az alkalmazás (ügyfél) azonosítója.
{BASE ADDRESS}: A webes API alapcíme.
{APP ID URI}: A webes API-hatókörök alkalmazásazonosítójának URI-ja. A rendszer az alábbi formátumok valamelyikét használja, ahol a {CLIENT ID (WEB API)} helyőrző a webes API Entra-regisztrációjának ügyfélazonosítója, a {DIRECTORY NAME} helyőrző pedig a bérlői (közzétevői) tartomány könyvtárneve (például: contoso).
- ME-ID vagy Microsoft Entra External ID bérlői formátuma: api://{CLIENT ID (WEB API)}
- B2C-bérlő formátuma: https://{DIRECTORY NAME}.onmicrosoft.com/{CLIENT ID (WEB API)}

Example:

builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(msIdentityOptions =>
    {
        msIdentityOptions.CallbackPath = "/signin-oidc";
        msIdentityOptions.Authority = "https://contoso.ciamlogin.com/aaaabbbb-0000-cccc-1111-dddd2222eeee/v2.0";
        msIdentityOptions.ClientId = "00001111-aaaa-2222-bbbb-3333cccc4444";
        msIdentityOptions.ResponseType = "code";
    })
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDownstreamApi("DownstreamApi", configOptions =>
    {
        configOptions.BaseUrl = "https://localhost:7277";
        configOptions.Scopes = ["api://11112222-bbbb-3333-cccc-4444dddd5555/Weather.Get"];
    })
    .AddDistributedTokenCaches();

A visszahívási útvonalnak (CallbackPath) meg kell egyeznie az alkalmazás Entra-ban vagy Azure Portalon való regisztrálásakor konfigurált átirányítási URI-val (bejelentkezési visszahívási útvonal). Az elérési utak az alkalmazás regisztrációjának Hitelesítési paneljén vannak konfigurálva. A CallbackPath alapértelmezett értéke /signin-oidc a https://localhost/signin-oidc regisztrált átirányítási URI-ja esetén (nincs szükség portra).

A SignedOutCallbackPath az alkalmazás alapútvonalán belüli kérelem elérési útja, amelyet az OpenID Connect kezelője fog el, ahová először kerül visszairányításra a felhasználói ügynök az Entra-ból való kijelentkezés után. A mintaalkalmazás nem állít be értéket az elérési úthoz, mert a rendszer a "/signout-callback-oidc" alapértelmezett értékét használja. A kérés elfogása után az OpenID Connect kezelője átirányítja a SignedOutRedirectUri vagy a RedirectUri-re, ha az meg van adva.

Warning

Ne tárolja az alkalmazás titkos kulcsait, kapcsolati sztringeket, hitelesítő adatokat, jelszavakat, személyes azonosítószámokat (PIN-eket), titkos C#/.NET-kódot vagy titkos kulcsokat/jogkivonatokat az ügyféloldali kódban, ami mindig nem biztonságos. Tesztelési/előkészítési és éles környezetekben a kiszolgálóoldali Blazor kód- és webes API-knak biztonságos hitelesítési folyamatokat kell használniuk, amelyek nem őrzik meg a hitelesítő adatokat a projektkódban vagy a konfigurációs fájlokban. A helyi fejlesztési tesztelésen kívül javasoljuk, hogy kerülje a környezeti változók bizalmas adatok tárolására való használatát, mivel a környezeti változók nem a legbiztonságosabb megközelítések. A helyi fejlesztési teszteléshez a Titkos kulcskezelő eszköz ajánlott a bizalmas adatok védelméhez. További információ: Bizalmas adatok és hitelesítő adatok biztonságos karbantartása.

A cikk ezen verziója az Entra implementálását ismerteti a backend a felhasználói felülethez (BFF) minta segítségével. Módosítsa a cikk verzióválasztóját nem BFF-mintára , ha az alkalmazás specifikációja nem kéri a BFF-minta bevezetését.

A következő specifikáció vonatkozik:

Az Blazor Web Appautomatikus renderelési módot használja globális interaktivitással (InteractiveAuto).
A kiszolgálóprojekt meghívja AddAuthenticationStateSerialization, hogy adjon hozzá egy kiszolgálóoldali hitelesítési állapotszolgáltatót, amely PersistentComponentState használ a hitelesítési állapot ügyfélhez való áramlásához. Az ügyfél meghívja AddAuthenticationStateDeserialization, hogy deszerializálja és használja a kiszolgáló által átadott hitelesítési állapotot. A hitelesítési állapot a WebAssembly-alkalmazás élettartamára van rögzítve.
Az alkalmazás a Microsoft Entra ID-t használja, a Microsoft Identity webcsomagokon alapulva.
Az automatikus nem interaktív jogkivonat-frissítést a keretrendszer felügyeli.
A Backend for Frontend (BFF) mintát alkalmazzák a szolgáltatásfelderítéshez Aspire használatával és a YARP segítségével a kérések proxyzásához a háttéralkalmazás időjárás-előrejelzési végpontjára.
- A háttérbeli webes API a JWT-bearer hitelesítés használatával ellenőrzi a Blazor Web App által a bejelentkezési cookie során mentett JWT-jogkivonatokat.
- Aspire javítja a .NET-felhőbeli natív alkalmazások létrehozásának élményét. Egységes, véleményezett eszközöket és mintákat biztosít az elosztott alkalmazások létrehozásához és futtatásához.
- A YARP (Még egy fordított proxy) egy fordított proxykiszolgáló létrehozásához használt kódtár.
Az alkalmazás kiszolgálóoldali és ügyféloldali szolgáltatás absztrakciókat használ a generált időjárási adatok megjelenítéséhez.
- Amikor a Weather összetevőt a kiszolgálón jeleníti meg az időjárási adatok megjelenítéséhez, a ServerWeatherForecaster-t használja. A Microsoft Identity webcsomagjai api-t biztosítanak egy elnevezett alsóbb rétegbeli webszolgáltatás létrehozásához webes API-hívások indításához. Az IDownstreamApi be van injektálva a ServerWeatherForecaster-be, amelyet arra használnak, hogy a CallApiForUserAsync-t meghívják, és így időjárási adatokat szerezzenek be egy külső webes API-ból (MinimalApiJwt projekt).
- Amikor a Weather összetevő megjelenik az ügyfélen, az összetevő a ClientWeatherForecaster szolgáltatás implementálását használja, amely egy előre konfigurált HttpClient (az ügyfélprojekt Program fájljában) használ egy webes API-hívást a kiszolgálóprojekt Minimal API-jára (/weather-forecast) az időjárási adatokhoz. A Minimal API-végpont hívással GetAccessTokenForUserAsyncszerez be egy hozzáférési jogkivonatot a felhasználó számára. A megfelelő hatókörökkel együtt egy fordított proxyhívás történik a külső webes API (MinimalApiJwt projekt) felé, ami megszerzi és visszaadja az időjárási adatokat az ügyfélnek, hogy az összetevő renderelhesse azokat.

Prerequisites

Aspire a Visual Studio 17.10-es vagy újabb verzióját igényli.

Tekintse meg a .Aspire

Mintamegoldás

A mintamegoldás a következő projektekből áll:

Aspire:
- Aspire.AppHost: Az alkalmazás magas szintű vezénylési problémáinak kezelésére szolgál.
- Aspire.ServiceDefaults: Az alapértelmezett Aspire alkalmazáskonfigurációkat tartalmazza, amelyek szükség szerint bővíthetők és testre szabhatók.
MinimalApiJwt: Háttérrendszer webes API, amely egy példa Minimal API végpontot tartalmaz az időjárási adatokhoz.
BlazorWebAppEntra: A Blazor Web Appkiszolgálóoldali projektje .
BlazorWebAppEntra.Client: A Blazor Web Appügyféloldali projektje.

A mintát a Blazor mintatár legújabb verziómappájában érheti el az alábbi hivatkozással. A minta a BlazorWebAppEntraBff .NET 9 vagy újabb verziójának mappájában található.

Mintakód megtekintése vagy letöltése (letöltés)

Microsoft Entra ID-alkalmazásregisztrációk

Ezután regisztrálja az alkalmazást (BlazorWebAppEntra) egy webplatform-konfigurációval, amely két bejegyzést tartalmaz az Átirányítási URI területen: és https://localhost/signin-oidc (ezeken az URI-kon nincs szükség portokra).https://localhost/signout-callback-oidc Az alkalmazás appsettings.json fájljában szerepel az alkalmazás bérlőazonosítója, bérlői tartománya és ügyfél-azonosítója, valamint a webes API alapcíme, az alkalmazásazonosító URI-ja és az időjárási hatókör neve, amelyek az alkalmazás beállításához szükségesek. Adjon api-engedélyt a webes API eléréséhez az Alkalmazásregisztrációk>. Ha az alkalmazás biztonsági specifikációja kéri, rendszergazdai hozzájárulást adhat a szervezetnek a webes API eléréséhez. A jogosult felhasználók és csoportok hozzá vannak rendelve az alkalmazás regisztrációihoz az Alkalmazásregisztrációk>, valamint a Nagyvállalati alkalmazásokhoz.

A cikk későbbi részében további Entra-konfigurációs útmutatást talál az egyes beállításokhoz.

Aspire projektek

További információkért a Aspire használatáról és a mintaalkalmazás .AppHost és .ServiceDefaults projektjeiről tekintse meg a Aspire dokumentációját.

Ellenőrizze, hogy teljesítette-e a Aspireelőfeltételeit. További információért lásd a Előfeltételek szakaszt a Gyorsindítás: Első Aspire megoldásának felépítése részben.

A mintaalkalmazás csak egy nem biztonságos HTTP-indítási profilt (http) konfigurál a fejlesztési tesztelés során való használatra. További információkért, beleértve a nem biztonságos és biztonságos indítási beállításokra vonatkozó példát, olvassa el a nem biztonságos átvitel engedélyezése (Aspiredokumentáció) című témakörtAspire.

Kiszolgálóoldali Blazor Web App projekt (`BlazorWebAppEntra`)

A BlazorWebAppEntra projekt a Blazor Web Appkiszolgálóoldali projektje.

Ügyféloldali Blazor Web App projekt (`BlazorWebAppEntra.Client`)

A BlazorWebAppEntra.Client projekt a Blazor Web Appügyféloldali projektje.

Ha a felhasználónak be kell jelentkeznie vagy ki kell jelentkeznie az ügyféloldali renderelés során, a rendszer elindítja a teljes oldal újrabetöltését.

Backend web API projekt (`MinimalApiJwt`)

A MinimalApiJwt projekt egy háttérbeli webes API több előtérbeli projekthez. A projekt minimális API-végpontot konfigurál az időjárási adatokhoz. A Blazor Web App kiszolgálóoldali projekt (BlazorWebAppEntra) kérelmei a MinimalApiJwt projekthez kerülnek átirányításra.

A projekt csomagokat és konfigurációt tartalmaz OpenAPI-dokumentumok létrehozásához.

A biztonságos időjárás-előrejelzési adatvégpont a projekt fájljában Program található:

app.MapGet("/weather-forecast", () =>
{
    var forecast = Enumerable.Range(1, 5).Select(index =>
        new WeatherForecast
        (
            DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
            Random.Shared.Next(-20, 55),
            summaries[Random.Shared.Next(summaries.Length)]
        ))
        .ToArray();
    return forecast;
}).RequireAuthorization();

A háttérrendszer webes API-projektjének konfigurálása (`MinimalApiJwt`)

Konfigurálja a MinimalApiJwt projektet a JwtBearerOptions hívás AddJwtBearer projekt Program fájljában.

A web API-alkalmazás regisztrációja esetén a Weather.Get hatókör az Entra vagy az Azure Portalon van konfigurálva az Api közzététele nézetben.

Authority az OIDC-hívásokhoz szükséges jogosultságot állítja be.

jwtOptions.Authority = "{AUTHORITY}";

Az alábbi példák egy bérlőazonosítót aaaabbbb-0000-cccc-1111-dddd2222eeee és egy könyvtárnevet használnak contoso.

Ha az alkalmazás egy ME-ID-bérlőnél van regisztrálva, a hatóságnak meg kell egyeznie az identitásszolgáltató által visszaadott JWT kibocsátóval (iss).

jwtOptions.Authority = "https://sts.windows.net/aaaabbbb-0000-cccc-1111-dddd2222eeee";

Ha az alkalmazás regisztrálva van egy Microsoft Entra Külső ID bérlőben:

jwtOptions.Authority = "https://contoso.ciamlogin.com/aaaabbbb-0000-cccc-1111-dddd2222eeee/v2.0";

Ha az alkalmazás regisztrálva van egy AAD B2C-bérlőben:

jwtOptions.Authority = "https://login.microsoftonline.com/aaaabbbb-0000-cccc-1111-dddd2222eeee/v2.0";

Note

Az Azure Active Directory B2C 2025. május 1-étől már nem érhető el szolgáltatásként az új ügyfelek számára. Az AAD B2C-bérlőket támogatjuk azoknak az ügyfeleknek, akiknek a fiókját 2025. május 1. előtt hozták létre, egészen 2030-ig. További információ: Azure AD B2C: Gyakori kérdések (GYIK).

Audience beállítja a célközönséget minden fogadott JWT hozzáférési jogkivonathoz.

jwtOptions.Audience = "{AUDIENCE}";

ME-ID bérlő példája

jwtOptions.Audience = "api://11112222-bbbb-3333-cccc-4444dddd5555";

Microsoft Entra külső azonosító tárhely:

jwtOptions.Audience = "11112222-bbbb-3333-cccc-4444dddd5555";

AAD B2C-bérlő példa:

jwtOptions.Audience = "https://contoso.onmicrosoft.com/11112222-bbbb-3333-cccc-4444dddd5555";

A kiszolgálóprojekt konfigurálása (`BlazorWebAppEntra`)

AddMicrosoftIdentityWebApp A Microsoft Identity Web (Microsoft.Identity.Web NuGet-csomag, API-dokumentáció) BlazorWebAppEntraProgram van konfigurálva a projekt fájljában.

A hitelesítési konfiguráció a bérlő típusától függ:

ME-ID bérlő konfigurációja
Microsoft Entra külső azonosító konfigurálása

ME-ID tenant konfiguráció

Ez a szakasz egy Microsoft Entra-azonosítóban vagy Azure AAD B2C-bérlőben regisztrált alkalmazásra vonatkozik.

A(z) BlazorWebAppEntra projekt Program fájljában adja meg az alábbi helyőrzők értékeit a Microsoft Identity Web konfigurációjában.

builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(msIdentityOptions =>
    {
        msIdentityOptions.CallbackPath = "/signin-oidc";
        msIdentityOptions.ClientId = "{CLIENT ID (BLAZOR APP)}";
        msIdentityOptions.Domain = "{DIRECTORY NAME}.onmicrosoft.com";
        msIdentityOptions.Instance = "https://login.microsoftonline.com/";
        msIdentityOptions.ResponseType = "code";
        msIdentityOptions.TenantId = "{TENANT ID}";
    })
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDownstreamApi("DownstreamApi", configOptions =>
    {
        configOptions.BaseUrl = "{BASE ADDRESS}";
        configOptions.Scopes = ["{APP ID URI}/Weather.Get"];
    })
    .AddDistributedTokenCaches();

Adja meg ugyanazt az alsóbb rétegbeli API-hatókört a kérésátalakítónak:

List<string> scopes = ["{APP ID URI}/Weather.Get"];

Helyőrzők az előző konfigurációban:

{CLIENT ID (BLAZOR APP)}: Az alkalmazás (ügyfél) azonosítója.
{DIRECTORY NAME}: A bérlői (közzétevői) tartomány könyvtárneve.
{TENANT ID}: A címtár (bérlő) azonosítója.
{BASE ADDRESS}: A webes API alapcíme.
{APP ID URI}: A webes API-hatókörök alkalmazásazonosítójának URI-ja. A rendszer a következő formátumok egyikét használja, ahol a {CLIENT ID (WEB API)} helyőrző a webes API Entra-regisztrációjának ügyfélazonosítója, a {DIRECTORY NAME} helyőrző pedig a bérlői (közzétevői) tartomány könyvtárneve (például: contoso).
- ME-ID bérlő formátuma: api://{CLIENT ID (WEB API)}
- B2C-bérlő formátuma: https://{DIRECTORY NAME}.onmicrosoft.com/{CLIENT ID (WEB API)}

Example:

builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(msIdentityOptions =>
    {
        msIdentityOptions.CallbackPath = "/signin-oidc";
        msIdentityOptions.ClientId = "00001111-aaaa-2222-bbbb-3333cccc4444";
        msIdentityOptions.Domain = "contoso.onmicrosoft.com";
        msIdentityOptions.Instance = "https://login.microsoftonline.com/";
        msIdentityOptions.ResponseType = "code";
        msIdentityOptions.TenantId = "aaaabbbb-0000-cccc-1111-dddd2222eeee";
    })
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDownstreamApi("DownstreamApi", configOptions =>
    {
        configOptions.BaseUrl = "https://localhost:7277";
        configOptions.Scopes = 
            ["api://11112222-bbbb-3333-cccc-4444dddd5555/Weather.Get"];
    })
    .AddDistributedTokenCaches();

Example:

List<string> scopes = ["api://11112222-bbbb-3333-cccc-4444dddd5555/Weather.Get"];

Microsoft Entra külső azonosító konfigurálása

Ez a szakasz egy Microsoft Entra külső azonosítójú bérlőben regisztrált alkalmazásra vonatkozik.

A(z) BlazorWebAppEntra projekt Program fájljában adja meg az alábbi helyőrzők értékeit a Microsoft Identity Web konfigurációjában.

builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(msIdentityOptions =>
    {
        msIdentityOptions.CallbackPath = "/signin-oidc";
        msIdentityOptions.Authority = "https://{DIRECTORY NAME}.ciamlogin.com/{TENANT ID}/v2.0";
        msIdentityOptions.ClientId = "{CLIENT ID (BLAZOR APP)}";
        msIdentityOptions.ResponseType = "code";
    })
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDownstreamApi("DownstreamApi", configOptions =>
    {
        configOptions.BaseUrl = "{BASE ADDRESS}";
        configOptions.Scopes = ["{APP ID URI}/Weather.Get"];
    })
    .AddDistributedTokenCaches();

Adja meg ugyanazt az alsóbb rétegbeli API-hatókört a kérésátalakítónak:

List<string> scopes = ["{APP ID URI}/Weather.Get"];

Helyőrzők az előző konfigurációban:

{DIRECTORY NAME}: A bérlői (közzétevői) tartomány könyvtárneve.
{CLIENT ID (BLAZOR APP)}: Az alkalmazás (ügyfél) azonosítója.
{BASE ADDRESS}: A webes API alapcíme.
{APP ID URI}: A webes API-hatókörök alkalmazásazonosítójának URI-ja. A rendszer a következő formátumok egyikét használja, ahol a {CLIENT ID (WEB API)} helyőrző a webes API Entra-regisztrációjának ügyfélazonosítója, a {DIRECTORY NAME} helyőrző pedig a bérlői (közzétevői) tartomány könyvtárneve (például: contoso).
- ME-ID vagy Microsoft Entra külső azonosító bérlő formátum: api://{CLIENT ID (WEB API)}
- B2C-bérlő formátuma: https://{DIRECTORY NAME}.onmicrosoft.com/{CLIENT ID (WEB API)}

Example:

builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(msIdentityOptions =>
    {
        msIdentityOptions.CallbackPath = "/signin-oidc";
        msIdentityOptions.Authority = "https://contoso.ciamlogin.com/aaaabbbb-0000-cccc-1111-dddd2222eeee/v2.0";
        msIdentityOptions.ClientId = "00001111-aaaa-2222-bbbb-3333cccc4444";
        msIdentityOptions.ResponseType = "code";
    })
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDownstreamApi("DownstreamApi", configOptions =>
    {
        configOptions.BaseUrl = "https://localhost:7277";
        configOptions.Scopes = ["api://11112222-bbbb-3333-cccc-4444dddd5555/Weather.Get"];
    })
    .AddDistributedTokenCaches();

Example:

List<string> scopes = ["api://11112222-bbbb-3333-cccc-4444dddd5555/Weather.Get"];

Warning

Az éles alkalmazásoknak éles, elosztott gyorsító szolgáltatót kell használniuk. Ellenkező esetben előfordulhat, hogy az alkalmazás teljesítménye bizonyos esetekben gyenge. További információért lásd a Termelési elosztott jogkivonat-gyorsítótár-szolgáltató használata szakaszt.

Warning

Az ügyfél titkos kódjának létrehozása

Ez a szakasz csak a kiszolgálói projektre vonatkozik.Blazor Web App

Az ügyfél titkos kódjának az alkalmazáshoz való megadásához használja az alábbi módszerek egyikét vagy mindkettőt:

Secret Manager-eszköz: A Secret Manager eszköz privát adatokat tárol a helyi gépen, és csak a helyi fejlesztés során használja.
Azure Key Vault: Az ügyfélkulcsot egy kulcstartóban tárolhatja, amely bármilyen környezetben használható, beleértve a fejlesztői környezetet is, amikor helyileg dolgozik. Egyes fejlesztők szívesebben használják a kulcstárakat az előkészítéshez és az éles környezetekhez, és a Secret Manager-t a helyi fejlesztéshez.

Határozottan javasoljuk, hogy ne tárolja az ügyfélkulcsokat a projektkódban vagy a konfigurációs fájlokban. Használjon biztonságos hitelesítési folyamatokat, például az ebben a szakaszban szereplő mindkét módszert.

Secret Manager eszköz

A Secret Manager eszköz a konfigurációs kulcs AzureAd:ClientSecretalatt tárolhatja a kiszolgálóalkalmazás ügyféltitkát.

A Blazor kiszolgálóalkalmazás nincs inicializálva a Secret Manager eszközhöz. A következő parancs végrehajtásához használjon egy parancshéjat, például a Visual Studióban a Developer PowerShell parancshéjat. A parancs végrehajtása előtt módosítsa a könyvtárat a cd paranccsal a kiszolgálóprojekt könyvtárára. A parancs létrehoz egy felhasználói titkos kód azonosítót (<UserSecretsId>) a kiszolgálóalkalmazás projektfájljában, amelyet az eszköz belsőleg használ az alkalmazás titkos kulcsainak nyomon követésére:

dotnet user-secrets init

Hajtsa végre a következő parancsot az ügyfél titkos kódjának beállításához. A {SECRET} helyőrző az alkalmazás Entra-regisztrációjából beszerzett ügyfélkód:

dotnet user-secrets set "AzureAd:ClientSecret" "{SECRET}"

A Visual Studio használata esetén a titkos kód beállításának megerősítéséhez kattintson a jobb gombbal a kiszolgálóprojektre a Megoldáskezelőben , és válassza a Felhasználói titkos kódok kezelése lehetőséget.

Azure Key Vault

Az Azure Key Vault biztonságos módszert biztosít az alkalmazás ügyféltitkának az alkalmazás számára való biztosítására.

A kulcstartó létrehozásához és az ügyfél titkos kulcsának beállításához tekintse meg az Azure Key Vault titkos kulcsait (Azure-dokumentáció) ismertető témakört, amely kereszthivatkozásokkal látja el az erőforrásokat az Azure Key Vault használatának megkezdéséhez. A jelen szakaszban szereplő kód implementálásához jegyezze meg a kulcstartó URI-ját és a titok nevét, amikor létrehozza őket az Azure-ban. Az ebben a szakaszban szereplő példában a titkos kód neve "BlazorWebAppEntraClientSecret."

A Key Vault létrehozásakor az Entra vagy az Azure portálon:

Konfigurálja a kulcstartót az Azure szerepköralapú hozzáférés-vezérlés (RABC) használatára. Ha nem Azure-beli virtuális hálózaton működik, beleértve a helyi fejlesztést és tesztelést is, ellenőrizze, hogy engedélyezve van-e a hálózati lépés nyilvános hozzáférése (bejelölve). A nyilvános hozzáférés engedélyezése csak a Key Vault végpontot teszi elérhetővé. A hozzáféréshez továbbra is hitelesített fiókok szükségesek.
Hozzon létre egy Azure kezelt Identity-et (vagy adjon hozzá egy szerepkört a használni kívánt kezelt Identity-hez) a Key Vault Secrets User szerepkörrel. Rendelje hozzá a felügyelt identitást az üzembe helyezést üzemeltető Azure App Service-hez: Identity>Identity>>.

Note

Ha azt is tervezi, hogy helyileg futtat egy alkalmazást egy jogosult felhasználóval a Key Vaulthoz való hozzáféréshez az Azure CLI vagy a Visual Studio Azure Service Authentication használatával, vegye fel a fejlesztői Azure-felhasználói fiókot a Hozzáférés-vezérlés (IAM) szolgáltatásba a Key Vault titkos kulcsfelhasználói szerepkörével. Ha az Azure CLI-t a Visual Studióban szeretné használni, hajtsa végre a parancsot a az login Fejlesztői PowerShell panelen, és kövesse az utasításokat a bérlővel való hitelesítéshez.

A jelen szakaszban szereplő kód implementálásához jegyezze fel a kulcstartó URI-ját (például "https://contoso.vault.azure.net/", perjel szükséges), valamint a titkos kód nevét (például: "BlazorWebAppEntraClientSecret") az Azure-ból a kulcstartó és a titkos kulcs létrehozásakor.

Important

A kulcstartó titkos kódja lejárati dátummal jön létre. Ügyeljen arra, hogy nyomon kövesse, hogy mikor fog lejárni egy kulcstartó titkos kulcsa, és hozzon létre egy új titkos kulcsot az alkalmazás számára az adott dátum letelte előtt.

Adja hozzá a következő AzureHelper osztályt a kiszolgálóprojekthez. A GetKeyVaultSecret metódus egy titkot kér le egy kulcstárból. Módosítsa a névteret (BlazorSample.Helpers) a projekt névtérséma szerint.

Helpers/AzureHelper.cs:

using Azure.Core;
using Azure.Security.KeyVault.Secrets;

namespace BlazorWebAppEntra.Helpers;

public static class AzureHelper
{
    public static string GetKeyVaultSecret(string vaultUri, 
        TokenCredential credential, string secretName)
    {
        var client = new SecretClient(new Uri(vaultUri), credential);
        var secret = client.GetSecretAsync(secretName).Result;

        return secret.Value.Value;
    }
}

Note

Az előző példa DefaultAzureCredential leegyszerűsíti a hitelesítést az Azure-ban üzembe helyező alkalmazások fejlesztése során az Azure-ban használt hitelesítő adatok és a helyi fejlesztés során használt hitelesítő adatok kombinálásával. Amikor éles környezetbe kerül, jobb választás lehet egy alternatív megoldás, például ManagedIdentityCredential. További információ: Azure-ban üzemeltetett .NET-alkalmazások hitelesítése Azure-erőforrásokra rendszer által hozzárendelt felügyelt identitás használatával.

Ha a szolgáltatások regisztrálva vannak a kiszolgálóprojekt Program fájljában, szerezze be és alkalmazza az ügyfél titkos kódját a következő kóddal:

TokenCredential? credential;

if (builder.Environment.IsProduction())
{
    credential = new ManagedIdentityCredential("{MANAGED IDENTITY CLIENT ID}");
}
else
{
    // Local development and testing only
    DefaultAzureCredentialOptions options = new()
    {
        // Specify the tenant ID to use the dev credentials when running the app locally
        // in Visual Studio.
        VisualStudioTenantId = "{TENANT ID}",
        SharedTokenCacheTenantId = "{TENANT ID}"
    };

    credential = new DefaultAzureCredential(options);
}

Amikor MicrosoftIdentityOptions be van állítva, hívja meg GetKeyVaultSecret az alkalmazás ügyféltitkának fogadása és hozzárendelése érdekében.

msIdentityOptions.ClientSecret = AzureHelper.GetKeyVaultSecret("{VAULT URI}", 
    credential, "{SECRET NAME}");

{MANAGED IDENTITY CLIENT ID}: Az Azure-beli felügyelt Identity ügyfél azonosítója (GUID).

{TENANT ID}: A címtár (bérlő) azonosítója. Példa: aaaabbbb-0000-cccc-1111-dddd2222eeee

{VAULT URI}: Key Vault URI. Adja meg a záró perjelet az URI-n. Példa: https://contoso.vault.azure.net/

{SECRET NAME}: Titkos név. Példa: BlazorWebAppEntraClientSecret

A konfiguráció lehetővé teszi a dedikált kulcstartók és titkos kódok megadását az alkalmazás környezeti konfigurációs fájljai alapján. Például különböző konfigurációs értékeket adhat meg a fejlesztés során appsettings.Development.json, az előkészítéskor appsettings.Staging.json, és az éles üzembe helyezéshez appsettings.Production.json. További információ: ASP.NET Core-konfigurációBlazor.

Csak a név- és szerepkör-követelések sorosítása

A Program fájlban az összes igény szerializálva van azáltal, hogy beállítjuk a(z) SerializeAllClaimstrue értékét. Ha csak a CSR-hez szükséges a név és szerepkör attribútumok szerializálása, távolítsa el a beállítást, vagy állítsa be false értékre.

Adja meg a konfigurációt a JSON-konfigurációszolgáltatóval (alkalmazásbeállítások)

A mintamegoldásprojektek úgy konfigurálják a Microsoft Identity Web- és JWT-tulajdonosi hitelesítést a fájljaikban Program , hogy a konfigurációs beállítások felderíthetők legyenek a C# automatikus kiegészítésével. A professzionális alkalmazások általában konfigurációszolgáltatót használnak az OIDC-beállítások konfigurálásához, például az alapértelmezett JSON-konfigurációs szolgáltatóhoz. A JSON-konfigurációszolgáltató betölti a konfigurációt az alkalmazásbeállítások fájljaiból appsettings.json/appsettings.{ENVIRONMENT}.json, ahol a {ENVIRONMENT} helyőrző az alkalmazás futtatókörnyezete. Kövesse az ebben a szakaszban található útmutatást az alkalmazásbeállítások konfigurációs fájljainak használatához.

Az alkalmazásbeállítások fájljában (appsettings.json) a BlazorWebAppEntra projekt esetében adja hozzá a következő JSON-konfigurációt:

{
  "AzureAd": {
    "CallbackPath": "/signin-oidc",
    "ClientId": "{CLIENT ID (BLAZOR APP)}",
    "Domain": "{DIRECTORY NAME}.onmicrosoft.com",
    "Instance": "https://login.microsoftonline.com/",
    "ResponseType": "code",
    "TenantId": "{TENANT ID}"
  },
  "DownstreamApi": {
    "BaseUrl": "{BASE ADDRESS}",
    "Scopes": ["{APP ID URI}/Weather.Get"]
  }
}

Frissítse az előző konfiguráció helyőrzőit, hogy megfeleljenek az alkalmazás által a Program fájlban használt értékeknek:

{CLIENT ID (BLAZOR APP)}: Az alkalmazás (ügyfél) azonosítója.
{DIRECTORY NAME}: A bérlői (közzétevői) tartomány könyvtárneve.
{TENANT ID}: A címtár (bérlő) azonosítója.
{BASE ADDRESS}: A webes API alapcíme.
{APP ID URI}: A webes API-hatókörök alkalmazásazonosítójának URI-ja. A rendszer a következő formátumok egyikét használja, ahol a {CLIENT ID (WEB API)} helyőrző a webes API Entra-regisztrációjának ügyfélazonosítója, a {DIRECTORY NAME} helyőrző pedig a bérlői (közzétevői) tartomány könyvtárneve (például: contoso).
- ME-ID bérlő formátuma: api://{CLIENT ID (WEB API)}
- B2C-bérlő formátuma: https://{DIRECTORY NAME}.onmicrosoft.com/{CLIENT ID (WEB API)}

Example:

"AzureAd": {
  "CallbackPath": "/signin-oidc",
  "ClientId": "00001111-aaaa-2222-bbbb-3333cccc4444",
  "Domain": "contoso.onmicrosoft.com",
  "Instance": "https://login.microsoftonline.com/",
  "ResponseType": "code",
  "TenantId": "aaaabbbb-0000-cccc-1111-dddd2222eeee"
},
"DownstreamApi": {
  "BaseUrl": "https://localhost:7277",
  "Scopes": ["api://11112222-bbbb-3333-cccc-4444dddd5555/Weather.Get"]
}

Frissítse az előző konfigurációban szereplő többi értéket, hogy megfeleljen a Program fájlban használt egyéni/nem alapértelmezett értékeknek.

A konfigurációt a hitelesítés-készítő automatikusan felveszi.

Végezze el a következő módosításokat a Program fájlban:

builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
-   .AddMicrosoftIdentityWebApp(msIdentityOptions =>
-   {
-       msIdentityOptions.CallbackPath = "...";
-       msIdentityOptions.ClientId = "...";
-       msIdentityOptions.Domain = "...";
-       msIdentityOptions.Instance = "...";
-       msIdentityOptions.ResponseType = "...";
-       msIdentityOptions.TenantId = "...";
-   })
+   .AddMicrosoftIdentityWebApp(builder.Configuration.GetSection("AzureAd"))
    .EnableTokenAcquisitionToCallDownstreamApi()
-   .AddDownstreamApi("DownstreamApi", configOptions =>
-   {
-       configOptions.BaseUrl = "...";
-       configOptions.Scopes = ["..."];
-   })
+   .AddDownstreamApi("DownstreamApi", builder.Configuration.GetSection("DownstreamApi"))
    .AddDistributedTokenCaches();

- List<string> scopes = ["{APP ID URI}/Weather.Get"];
- var accessToken = await tokenAcquisition.GetAccessTokenForUserAsync(scopes);
+ var configuration = transformContext.HttpContext.RequestServices.GetRequiredService<IConfiguration>();
+ var scopes = configuration.GetSection("DownstreamApi:Scopes").Get<IEnumerable<string>>();
+ var accessToken = await tokenAcquisition.GetAccessTokenForUserAsync(scopes ??
+     throw new InvalidOperationException("No downstream API scopes!"));

Note

A projektben MinimalApiJwt adja hozzá az alábbi alkalmazásbeállítások konfigurációját a appsettings.json fájlhoz:

"Authentication": {
  "Schemes": {
    "Bearer": {
      "Authority": "https://sts.windows.net/{TENANT ID (WEB API)}",
      "ValidAudiences": ["{APP ID URI (WEB API)}"]
    }
  }
},

Frissítse az előző konfiguráció helyőrzőit, hogy megfeleljenek az alkalmazás által a Program fájlban használt értékeknek:

{TENANT ID (WEB API)}: A webes API bérlőazonosítója.
{APP ID URI (WEB API)}: A webes API alkalmazásazonosítójának URI-ja.

A hatósági formátumok a következő mintákat fogadják el:

ME-ID bérlő típusa: https://sts.windows.net/{TENANT ID}
Microsoft Entra külső azonosító: https://{DIRECTORY NAME}.ciamlogin.com/{TENANT ID}/v2.0
B2C-bérlő típusa: https://login.microsoftonline.com/{TENANT ID}/v2.0

A célközönségformátumok a következő mintákat használják ({CLIENT ID} a webes API ügyfélazonosítója; {DIRECTORY NAME} a címtár neve, például contoso: ):

ME-ID bérlő típusa: api://{CLIENT ID}
Microsoft Entra külső azonosító: {CLIENT ID}
B2C-bérlő típusa: https://{DIRECTORY NAME}.onmicrosoft.com/{CLIENT ID}

A beállítást a JWT-jogosítvány hitelesítési modulja automatikusan észleli.

Távolítsa el a következő sorokat a Program fájlból:

- jwtOptions.Authority = "...";
- jwtOptions.Audience = "...";

A konfigurációval kapcsolatos további információkért tekintse meg a következő erőforrásokat:

Éles disztribútált token gyorsítótár-szolgáltató használata

A memóriabeli elosztott token gyorsítótárak akkor jönnek létre, amikor a AddDistributedTokenCaches függvényt hívjuk, hogy biztosítsák az elosztott token gyorsítótárazás alapvető implementációját.

Az éles környezetbeli webalkalmazásoknak és webes API-knak elosztott token gyorsítótárat kell használniuk (például: Redis, Microsoft SQL Server, Microsoft Azure Cosmos DB).

Note

Egy gépen történő helyi fejlesztéshez és teszteléshez a memóriabeli jogkivonat-gyorsítótárakat használhatja elosztott jogkivonat-gyorsítótárak helyett:

builder.Services.AddInMemoryTokenCaches();

A fejlesztési és tesztelési időszak későbbi szakaszában válasszon egy gyártási elosztott jogkivonat-gyorsítótár szolgáltatót.

AddDistributedMemoryCache Hozzáad egy alapértelmezett implementációt IDistributedCache , amely gyorsítótárelemeket tárol a memóriában, amelyet a Microsoft Identity Web használ a tokenek gyorsítótárazásához.

Az elosztott jogkivonat-gyorsítótárat a következők konfigurálják MsalDistributedTokenCacheAdapterOptions:

A hibakeresési célokra történő fejlesztés során letilthatja az L1 gyorsítótárat a következő beállítással DisableL1Cachetrue: . Mindenképpen állítsa vissza false éles környezetre.
Állítsa be az L1-gyorsítótár L1CacheOptions.SizeLimit maximális méretét, hogy a gyorsítótár ne futtassa túl a kiszolgáló memóriáját. Az alapértelmezett érték 500 MB.
Hibakeresési célokra történő fejlesztés során letilthatja a jogkivonat titkosítását nyugalmi állapotban, ha a Encrypt értéket false-re állítja, ami az alapértelmezett érték. Mindenképpen állítsa vissza true éles környezetre.
Állítsa be a token eltávolítását a gyorsítótárból a következővel SlidingExpiration. Az alapértelmezett érték 1 óra.
További információért, beleértve az útmutatást az L2-gyorsítótár hibáinak visszahívásával (OnL2CacheFailure) és az aszinkron L2-gyorsítótár-írások (EnableAsyncL2Write) kezelésével kapcsolatban, tekintse meg a MsalDistributedTokenCacheAdapterOptions és a Tokengyorsítótár szerializálása: Elosztott jogkivonat-gyorsítótárak című dokumentumot.

builder.Services.AddDistributedMemoryCache();

builder.Services.Configure<MsalDistributedTokenCacheAdapterOptions>(
    options => 
    {
      // The following lines that are commented out reflect
      // default values. We recommend overriding the default
      // value of Encrypt to encrypt tokens at rest.

      //options.DisableL1Cache = false;
      //options.L1CacheOptions.SizeLimit = 500 * 1024 * 1024;
      options.Encrypt = true;
      //options.SlidingExpiration = TimeSpan.FromHours(1);
    });

AddDistributedMemoryCacheA NuGet-csomagraMicrosoft.Extensions.Caching.Memory való hivatkozás szükséges.

Note

A csomagok .NET-alkalmazásokhoz való hozzáadásáról a Csomagok telepítése és kezelésea csomaghasználati munkafolyamatban (NuGet-dokumentáció) című cikkben talál útmutatást. Ellenőrizze a megfelelő csomagverziókat a NuGet.org.

Éles elosztott gyorsítótár-szolgáltató konfigurálásához lásd az elosztott gyorsítótárazást a ASP.NET Core-ban.

Warning

Az alkalmazás éles környezetben való üzembe helyezésekor mindig cserélje le a memóriában elosztott jogkivonat-gyorsítótárakat egy valódi jogkivonat-gyorsítótár-szolgáltatóra. Ha nem sikerül egy éles környezetben működő elosztott gyorsítótár-szolgáltatót alkalmaznia a jogkivonatokhoz, az alkalmazás teljesítménye jelentősen romolhat.

Bővebb információért lásd: Tokengyorsítótár szerializálása: Elosztott gyorsítótárak. Azonban a bemutatott kód példák nem vonatkoznak az ASP.NET Core alkalmazásokra, amelyek az elosztott gyorsítótárakat AddDistributedMemoryCache konfigurálják, nem pedig AddDistributedTokenCache.

Használjon megosztott Adatvédelmi kulcsgyűrűt éles környezetben, hogy a webfarm kiszolgálói közötti alkalmazáspéldányok visszafejthessék a jogkivonatokat, amikor MsalDistributedTokenCacheAdapterOptions.Encrypt be van állítva true.

Note

Egy gépen történő korai fejlesztéshez és helyi teszteléshez később beállíthatja Encryptfalse és konfigurálhatja a megosztott adatvédelmi kulcsgyűrűt:

options.Encrypt = false;

A fejlesztési és tesztelési időszak későbbi szakaszában engedélyezze a tokentitkosítást, és vezessen be egy megosztott adatvédelmi kulcsgyűrűt.

Az alábbi példa bemutatja, hogyan használható az Azure Blob Storage és az Azure Key Vault (PersistKeysToAzureBlobStorage/ProtectKeysWithAzureKeyVault) a megosztott kulcsgyűrűhöz. A szolgáltatáskonfigurációk alapeseti forgatókönyvek bemutató célokra. Az éles alkalmazások üzembe helyezése előtt ismerkedjen meg az Azure-szolgáltatásokkal, és fogadja el az ajánlott eljárásokat az Azure-szolgáltatások dedikált dokumentációs készleteivel, amelyek a szakasz végén vannak összekapcsolva.

Ellenőrizze a következő csomagok jelenlétét a következő kiszolgálóprojektben Blazor Web App:

Note

A következő lépések végrehajtása előtt győződjön meg arról, hogy az alkalmazás regisztrálva van a Microsoft Entra szolgáltatásban.

A következő kód általában egy éles környezetben elosztott token gyorsítótár szolgáltató implementálásával egy időben van implementálva. Az Azure-ban és az Azure-on kívüli egyéb lehetőségek is elérhetők az adatvédelmi kulcsok több alkalmazáspéldányon történő kezelésére, de a mintaalkalmazás bemutatja az Azure-szolgáltatások használatát.

Konfigurálja az Azure Blob Storage-t az adatvédelmi kulcsok karbantartásához. Kövesse az ASP.NET Core kulcstároló-szolgáltatóinak útmutatását.

Konfigurálja az Azure Key Vaultot az inaktív adatvédelmi kulcsok titkosításához. Kövesse az ASP.NET Core Data Protection konfigurálása című útmutatót.

Használja a következő kódot abban a fájlban, amelyben a Program szolgáltatások regisztrálva vannak:

TokenCredential? credential;

if (builder.Environment.IsProduction())
{
    credential = new ManagedIdentityCredential("{MANAGED IDENTITY CLIENT ID}");
}
else
{
    // Local development and testing only
    DefaultAzureCredentialOptions options = new()
    {
        // Specify the tenant ID to use the dev credentials when running the app locally
        // in Visual Studio.
        VisualStudioTenantId = "{TENANT ID}",
        SharedTokenCacheTenantId = "{TENANT ID}"
    };

    credential = new DefaultAzureCredential(options);
}

builder.Services.AddDataProtection()
    .SetApplicationName("BlazorWebAppEntra")
    .PersistKeysToAzureBlobStorage(new Uri("{BLOB URI}"), credential)
    .ProtectKeysWithAzureKeyVault(new Uri("{KEY IDENTIFIER}"), credential);

Bármilyen alkalmazásnevet átadhat a SetApplicationName-nek. Csak győződjön meg arról, hogy minden alkalmazástelepítés ugyanazt az értéket használja.

{MANAGED IDENTITY CLIENT ID}: Az Azure-beli felügyelt Identity ügyfél azonosítója (GUID).

{TENANT ID}: Bérlőazonosító.

{BLOB URI}: A kulcsfájl teljes URI-ja. Az URI-t az Azure Storage hozza létre a kulcsfájl létrehozásakor. Ne használjon SAS-t.

{KEY IDENTIFIER}: Kulcstitkosításhoz használt Azure Key Vault-kulcsazonosító. A hozzáférési szabályzat lehetővé teszi, hogy az alkalmazás hozzáférjen a kulcstartóhoz Get, Unwrap Keyés Wrap Key engedélyekkel. A kulcs verzióját az Entra vagy az Azure Portal kulcsából szerzi be a rendszer a létrehozás után. Ha engedélyezi a kulcstartó kulcsának automatikus beírását, győződjön meg arról, hogy verzió nélküli kulcsazonosítót használ az alkalmazás kulcstartójának konfigurációjában, ahol nincs kulcs GUID azonosítója az azonosító végén (például: https://contoso.vault.azure.net/keys/data-protection).

Note

Nem éles környezetekben az előző példa a DefaultAzureCredential segítségével leegyszerűsíti a hitelesítést. Az Azure-ba telepítendő alkalmazások fejlesztése során az Azure-beli üzemeltetési környezetek hitelesítő adatait a helyi fejlesztés hitelesítő adataival kombinálja. További információ: Azure-ban üzemeltetett .NET-alkalmazások hitelesítése Azure-erőforrásokra rendszer által hozzárendelt felügyelt identitás használatával.

Másik lehetőségként úgy is konfigurálhatja az alkalmazást, hogy a JSON konfigurációszolgáltatóval adja meg az alkalmazásbeállítások fájljainak értékeit. Adja hozzá a következőket az alkalmazásbeállítások fájlhoz:

"DistributedTokenCache": {
  "DisableL1Cache": false,
  "L1CacheSizeLimit": 524288000,
  "Encrypt": true,
  "SlidingExpirationInHours": 1
},
"DataProtection": {
  "BlobUri": "{BLOB URI}",
  "KeyIdentifier": "{KEY IDENTIFIER}"
}

Példaszakasz DataProtection :

"DataProtection": {
  "BlobUri": "https://contoso.blob.core.windows.net/data-protection/keys.xml",
  "KeyIdentifier": "https://contoso.vault.azure.net/keys/data-protection"
}

Note

Az előző példában szereplő kulcsazonosító verzió nélküli. Az azonosító végén nincs GUID-kulcsverzió. Ez különösen akkor fontos, ha úgy dönt, hogy automatikus kulcsváltást konfigurál a kulcshoz. További információ: Titkosítási kulcs automatikus elforgatásának konfigurálása az Azure Key Vaultban: Kulcsforgatási szabályzat.

Végezze el a következő módosításokat a Program fájlban:

builder.Services.Configure<MsalDistributedTokenCacheAdapterOptions>(
    options =>
    {
+       var config = builder.Configuration.GetSection("DistributedTokenCache");

-       options.DisableL1Cache = false;
+       options.DisableL1Cache = config.GetValue<bool>("DisableL1Cache");

-       options.L1CacheOptions.SizeLimit = 500 * 1024 * 1024;
+       options.L1CacheOptions.SizeLimit = config.GetValue<long>("L1CacheSizeLimit");

-       options.Encrypt = true;
+       options.Encrypt = config.GetValue<bool>("Encrypt");

-       options.SlidingExpiration = TimeSpan.FromHours(1);
+       options.SlidingExpiration = 
+           TimeSpan.FromHours(config.GetValue<int>("SlidingExpirationInHours"));
    });

- builder.Services.AddDataProtection()
-     .SetApplicationName("BlazorWebAppEntra")
-     .PersistKeysToAzureBlobStorage(new Uri("{BLOB URI}"), credential)
-     .ProtectKeysWithAzureKeyVault(new Uri("{KEY IDENTIFIER}"), credential);

Adja hozzá a következő kódot, amelyben a szolgáltatások konfigurálva vannak a Program fájlban:

var config = builder.Configuration.GetSection("DataProtection");

builder.Services.AddDataProtection()
    .SetApplicationName("BlazorWebAppEntra")
    .PersistKeysToAzureBlobStorage(
        new Uri(config.GetValue<string>("BlobUri") ??
        throw new Exception("Missing Blob URI")),
        credential)
    .ProtectKeysWithAzureKeyVault(
        new Uri(config.GetValue<string>("KeyIdentifier") ?? 
        throw new Exception("Missing Key Identifier")), 
        credential);

A megosztott adatvédelmi kulcsgyűrűk és kulcstárolók használatával kapcsolatos további információkért tekintse meg a következő erőforrásokat:

YARP-továbbító célelőtagja

A Blazor Web App kiszolgálóprojekt YARP-továbbítója, ahol a felhasználó hozzáférési jogkivonata a MinimalApiJwt webes API-híváshoz van csatolva, megadja a célelőtagot https://weatherapi. Ez az érték megegyezik a AddProject projekt Program fájljában a Aspire.AppHost számára átadott projektnévvel.

Továbbító a kiszolgálóprojektben Blazor Web App (BlazorWebAppEntra):

app.MapForwarder("/weather-forecast", "https://weatherapi", transformBuilder =>
{
    ...
}).RequireAuthorization();

Egyező projektnév az ProgramAspire Alkalmazásgazda projekt fájljában (Aspire.AppHost):

var weatherApi = builder.AddProject<Projects.MinimalApiJwt>("weatherapi");

Az Blazor Web App éles környezetbe történő üzembe helyezésekor nem szükséges megváltoztatni a YARP átirányító célelőtagját. A Microsoft Identity Web Downstream API-csomag a konfiguráción keresztül átadott alap URI-t használja a webes API-hívás indításához, nem a ServerWeatherForecaster YARP-továbbító célelőtagját. Éles környezetben a YARP-továbbító csupán átalakítja a kérést, és hozzáadja a felhasználó hozzáférési tokenjét.

Átirányítás a kijelentkezés kezdőlapjára

A LogInOrOut összetevő (Layout/LogInOrOut.razor) egy rejtett mezőt állít be a visszatérési URL-címhez (ReturnUrl) az aktuális URL-címre (currentURL). Amikor a felhasználó kijelentkezik az alkalmazásból, az identitásszolgáltató visszaküldi a felhasználót arra a lapra, ahonnan kijelentkezett. Ha a felhasználó kijelentkezik egy biztonságos oldalról, a rendszer ugyanarra a biztonságos lapra küldi vissza őket, és a hitelesítési folyamat során visszaküldi őket. Ez a hitelesítési folyamat ésszerű, ha a felhasználóknak rendszeresen módosítaniuk kell a fiókokat.

Másik lehetőségként használja a következő LogInOrOut összetevőt, amely kijelentkezéskor nem ad vissza URL-címet.

Layout/LogInOrOut.razor:

<div class="nav-item px-3">
    <AuthorizeView>
        <Authorized>
            <form action="authentication/logout" method="post">
                <AntiforgeryToken />
                <button type="submit" class="nav-link">
                    <span class="bi bi-arrow-bar-left-nav-menu" aria-hidden="true">
                    </span> Logout
                </button>
            </form>
        </Authorized>
        <NotAuthorized>
            <a class="nav-link" href="authentication/login">
                <span class="bi bi-person-badge-nav-menu" aria-hidden="true"></span>
                Login
            </a>
        </NotAuthorized>
    </AuthorizeView>
</div>

Időjárási adatok biztonsága

Az alkalmazás időjárási adatainak biztonságossá tételéről további információt az Adatok biztonságossá Blazor Web Apptétele interaktív automatikus rendereléssel című témakörben talál.

Troubleshoot

Logging

A kiszolgálóalkalmazás egy standard ASP.NET Core-alkalmazás. A kiszolgálóalkalmazás alacsonyabb naplózási szintjének engedélyezéséhez tekintse meg a ASP.NET Alapvető naplózási útmutatót .

Ha engedélyezni szeretné a hibakeresést vagy a nyomkövetési naplózást a hitelesítéshezBlazor WebAssembly, tekintse meg a Blazor szakaszát, amelyben a cikk verzióválasztója ASP.NET Core a .NET 7-es vagy újabb verziójában.

Gyakori hibák

A hibakereső megszakít egy kivételnél a Microsoft Entra külső azonosítójával történő kijelentkezéskor.

Az alábbi kivétel leállítja a Visual Studio hibakeresőt a Microsoft Entra külső azonosítójú kijelentkezés során:

Uncaught TypeError TypeError: Failed to execute 'postMessage' on 'Window': The provided value cannot be converted to a sequence.

A kivétel az Entra JavaScript-kódból származik, így ez nem jelent problémát ASP.NET Core-val kapcsolatban. A kivétel nem befolyásolja az alkalmazások működését az éles környezetben, ezért a kivétel figyelmen kívül hagyható a helyi fejlesztési tesztelés során.
Az alkalmazás vagy Identity szolgáltató (IP) helytelen konfigurálása

A leggyakoribb hibákat a helytelen konfiguráció okozza. Az alábbiakban néhány példát láthat:
- A forgatókönyv követelményeitől függően egy hiányzó vagy helytelen szolgáltató, példány, bérlőazonosító, bérlői tartomány, ügyfélazonosító vagy átirányítási URI megakadályozza, hogy egy alkalmazás hitelesítse az ügyfeleket.
- A helytelen kérelemtartományok megakadályozzák, hogy az ügyfelek hozzáférjenek a kiszolgáló webes API-végpontjaihoz.
- Helytelen vagy hiányzó kiszolgálói API-engedélyek megakadályozzák, hogy az ügyfelek hozzáférjenek a kiszolgáló webes API-végpontjaihoz.
- Az alkalmazás futtatása más porton, mint ahogy az IP-címhez tartozó alkalmazásregisztráció átirányítási URI-jában meg van adva. Vegye figyelembe, hogy a Microsoft Entra-azonosítóhoz és egy localhost fejlesztési tesztelési címen futó alkalmazáshoz nincs szükség portra, de az alkalmazás portkonfigurációjának és a portnak, amelyen az alkalmazás fut, meg kell egyeznie a nemlocalhost címekhez.
A cikkben szereplő konfigurációs lefedettség példákat mutat be a megfelelő konfigurációra. Gondosan ellenőrizze, hogy az alkalmazás és az IP-cím helytelenül van-e konfigurálva.

Ha a konfiguráció helyesnek tűnik:
- Alkalmazásnaplók elemzése.
- Vizsgálja meg az ügyfélalkalmazás és az IP- vagy kiszolgálóalkalmazás közötti hálózati forgalmat a böngésző fejlesztői eszközeivel. Miután kérést küldtek, az IP vagy a kiszolgálóalkalmazás gyakran visszaad egy pontos hibaüzenetet vagy egy olyan üzenetet, amely arra utal, hogy mi okozza a problémát. A fejlesztői eszközökkel kapcsolatos útmutatást a következő cikkekben találja:
  - Google Chrome (Google-dokumentáció)
  - Microsoft Edge
  - Mozilla Firefox (Mozilla-dokumentáció)
A dokumentációs csapat válaszol a cikkekben szereplő dokumentumokkal kapcsolatos visszajelzésekre és hibákra (nyissa meg a problémát az Oldal visszajelzési szakaszából), de nem tud terméktámogatást nyújtani. Számos nyilvános támogatási fórum áll rendelkezésre az alkalmazások hibaelhárításához. A következőket javasoljuk:
Az előző fórumok nem a Microsoft tulajdonában vagy ellenőrzése alatt állnak.

A nem biztonsági, nem bizalomérzékeny és nem bizalmas, reprodukálható keretrendszer hibajelentései esetén indítson problémát az ASP.NET Core termékegységgel. Ne nyisson meg egy problémát a termékegységben, amíg nem vizsgálja meg alaposan a probléma okát, és nem tudja önállóan és a közösség segítségével megoldani a problémát egy nyilvános támogatási fórumon. A termékegység nem tudja elhárítani a külső szolgáltatásokat érintő egyszerű helytelen konfiguráció vagy használati esetek miatt hibásan működő egyes alkalmazásokat. Ha egy jelentés bizalmas jellegű, vagy a kiberbűnözők által kihasználható termék biztonsági hibáját írja le, tekintse meg a Biztonsági problémák és hibák jelentése (dotnet/aspnetcore GitHub-adattár) című témakört.
Jogosulatlan ME-ID ügyfél

info: Microsoft.AspNetCore.Authorization.DefaultAuthorizationService[2] Az engedélyezés nem sikerült. Ezek a követelmények nem teljesültek: DenyAnonymousAuthorizationRequirement: Hitelesített felhasználót igényel.

Bejelentkezési visszahívási hiba a ME-ID-ből:
- Hiba: unauthorized_client
- Leírás: AADB2C90058: The provided application is not configured to allow public clients.
A hiba megoldása:
1. Az Azure Portalon érheti el az alkalmazás jegyzékfájlját.
2. Állítsa be az allowPublicClient attribútumotnull vagy true értékre.

Cookie-k és webhelyadatok

A cookie-k és a webhelyadatok az alkalmazásfrissítések során is megmaradhatnak, és zavarhatják a tesztelést és a hibaelhárítást. Törölje az alábbiakat, amikor alkalmazáskódot módosít, felhasználói fiókot változtat a szolgáltatónál, vagy amikor a szolgáltatói alkalmazás konfigurációját módosítja:

Felhasználói bejelentkezési cookie-k
Alkalmazás cookie-k
Gyorsítótárazott és tárolt webhelyadatok

Egy módszer a maradandó cookie-k és webhelyadatok tesztelés és hibaelhárítás során történő zavaró hatásának elkerülésére a következő:

Böngésző konfigurálása
- Használjon egy böngészőt a teszteléshez, amely konfigurálható az összes cookie és webhelyadatok törlésére minden alkalommal, amikor a böngésző bezárul.
- Győződjön meg arról, hogy a böngésző manuálisan vagy az IDE által bezárva van az alkalmazás, a tesztfelhasználó vagy a szolgáltató konfigurációjának bármilyen módosításához.
Egyéni paranccsal nyisson meg egy böngészőt InPrivate vagy Inkognitó módban a Visual Studióban:
- Nyissa meg a Tallózás párbeszédpanelt a Visual Studio Futtatás gombjáról.
- Válassza a Hozzáadás gombot.
- Adja meg a böngésző elérési útját a Program mezőben. A következő végrehajtható elérési utak a Windows 10 tipikus telepítési helyei. Ha a böngésző más helyen van telepítve, vagy nem Windows 10-et használ, adja meg a böngésző végrehajtható fájljának elérési útját.
  - Microsoft Edge: C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe
  - Google Chrome: C:\Program Files (x86)\Google\Chrome\Application\chrome.exe
  - Mozilla Firefox: C:\Program Files\Mozilla Firefox\firefox.exe
- Az Argumentumok mezőben adja meg azt a parancssori beállítást, amelyet a böngésző inPrivate vagy Inkognitó módban való megnyitáshoz használ. Egyes böngészőkben az alkalmazás URL-címe szükséges.
  - A -inprivatehasználata Microsoft Edge-ben.
  - Google Chrome: Használja a --incognito --new-window {URL}, ahol a {URL} helyőrző a megnyitni kívánt URL-cím (például https://localhost:5001).
  - Mozilla Firefox: Használja a -private -url {URL}, ahol a {URL} helyőrző a megnyitni kívánt URL-cím (például https://localhost:5001).
- Adjon meg egy nevet a Barátságos név mezőben. Például Firefox Auth Testing.
- Válassza az OK gombot.
- Annak érdekében, hogy ne kelljen kiválasztania a böngészőprofilt az alkalmazással végzett tesztelés egyes iterációihoz, állítsa be a profilt alapértelmezettként az Alapértelmezettként beállítás gombbal.
- Győződjön meg arról, hogy az IDE bezárja a böngészőt az alkalmazás, a tesztfelhasználó vagy a szolgáltató konfigurációjának bármilyen módosításához.

Alkalmazásfrissítések

A működő alkalmazások a .NET SDK fejlesztői gépen való frissítése vagy az alkalmazás csomagverzióinak módosítása után azonnal meghiúsulhatnak. Bizonyos esetekben az inkognitó csomagok megszakíthatják az alkalmazásokat a nagyobb frissítések végrehajtásakor. A legtöbb ilyen probléma az alábbi utasítások követésével javítható:

Törölje a helyi rendszer NuGet-csomag gyorsítótárait a parancshéjból való dotnet nuget locals all --clear végrehajtásával.
Törölje a projekt bin és obj mappáit.
Állítsa vissza és építse újra a projektet.
Az alkalmazás ismételt üzembe helyezése előtt törölje a kiszolgáló üzembehelyezési mappájában lévő összes fájlt.

Note

Az alkalmazás cél-keretrendszerével nem kompatibilis csomagverziók használata nem támogatott. A csomaggal kapcsolatos információkért használja a NuGet-katalógust.

A megoldás indítása a megfelelő projektből

Blazor Web App:

Az egyik Backend-for-Frontend (BFF) minta esetében indítsa el a megoldást a Aspire/Aspire.AppHost projektből.
Az egyik nem BFF mintaminta esetében indítsa el a megoldást a kiszolgálóprojektből.

Blazor Server:

Indítsa el a megoldást a kiszolgálóprojektből.

A felhasználó vizsgálata

A következő UserClaims összetevő közvetlenül az alkalmazásokban használható, vagy a további testreszabás alapjául szolgál.

UserClaims.razor:

@page "/user-claims"
@using System.Security.Claims
@using Microsoft.AspNetCore.Authorization
@attribute [Authorize]

<PageTitle>User Claims</PageTitle>

<h1>User Claims</h1>

@if (claims.Any())
{
    <ul>
        @foreach (var claim in claims)
        {
            <li><b>@claim.Type:</b> @claim.Value</li>
        }
    </ul>
}

@code {
    private IEnumerable<Claim> claims = Enumerable.Empty<Claim>();

    [CascadingParameter]
    private Task<AuthenticationState>? AuthState { get; set; }

    protected override async Task OnInitializedAsync()
    {
        if (AuthState == null)
        {
            return;
        }

        var authState = await AuthState;
        claims = authState.User.Claims;
    }
}

További erőforrások

Webes API meghívása egy ASP.NET Core-alkalmazásból Blazor : Microsoft identitásplatform webes API-hívásokhoz
A Microsoft identitásplatform dokumentációja
A Web API dokumentációja | Microsoft-identitásplatform
Webes API-kat hívó webes API: API meghívása: 2. lehetőség: Alsóbb rétegbeli webes API meghívása a segédosztálysal
AzureAD/microsoft-identity-web GitHub-adattár: Hasznos útmutató a Microsoft Identity implementálásához Web for Microsoft Entra ID és Azure Active Directory B2C for ASP.NET Core-alkalmazásokhoz, beleértve a mintaalkalmazásokra mutató hivatkozásokat és a kapcsolódó Azure-dokumentációt. Jelenleg az Azure dokumentációja nem foglalkozik explicit módon a Blazor Web App-vel, de a ME-ID és az Azure tárhelyhez készült Blazor Web App beállítása és konfigurálása megegyezik bármely ASP.NET Core webalkalmazáséval.
AuthenticationStateProvider szolgáltatás
Hitelesítési állapot kezelése az s-ben Blazor Web App
Szolgáltatásabsztrakciók a(z) Blazor Web App-ben

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-11-11

Megosztás a következőn keresztül:

ASP.NET Core Blazor Web App védelme a Microsoft Entra ID-vel

Mintamegoldás

Microsoft Entra ID-alkalmazásregisztrációk

Kiszolgálóoldali Blazor Web App projekt (BlazorWebAppEntra)

Ügyféloldali Blazor Web App projekt (BlazorWebAppEntra.Client)

Backend web API projekt (MinimalApiJwt)

A háttérrendszer webes API-projektjének konfigurálása (MinimalApiJwt)

A kiszolgálóprojekt konfigurálása (BlazorWebAppEntra)

ME-ID bérlőkonfiguráció

Microsoft Entra külső azonosító konfigurálása

Prerequisites

Mintamegoldás

Microsoft Entra ID-alkalmazásregisztrációk

Aspire projektek

Kiszolgálóoldali Blazor Web App projekt (BlazorWebAppEntra)

Ügyféloldali Blazor Web App projekt (BlazorWebAppEntra.Client)

Backend web API projekt (MinimalApiJwt)

A háttérrendszer webes API-projektjének konfigurálása (MinimalApiJwt)

A kiszolgálóprojekt konfigurálása (BlazorWebAppEntra)

ME-ID tenant konfiguráció

Microsoft Entra külső azonosító konfigurálása

Az ügyfél titkos kódjának létrehozása

Secret Manager eszköz

Azure Key Vault

Csak a név- és szerepkör-követelések sorosítása

Adja meg a konfigurációt a JSON-konfigurációszolgáltatóval (alkalmazásbeállítások)

Éles disztribútált token gyorsítótár-szolgáltató használata

YARP-továbbító célelőtagja

Átirányítás a kijelentkezés kezdőlapjára

Időjárási adatok biztonsága

Troubleshoot

Logging

Gyakori hibák

Cookie-k és webhelyadatok

Alkalmazásfrissítések

A megoldás indítása a megfelelő projektből

A felhasználó vizsgálata

További erőforrások

Visszajelzés

További források

Kiszolgálóoldali Blazor Web App projekt (`BlazorWebAppEntra`)

Ügyféloldali Blazor Web App projekt (`BlazorWebAppEntra.Client`)

Backend web API projekt (`MinimalApiJwt`)

A háttérrendszer webes API-projektjének konfigurálása (`MinimalApiJwt`)

A kiszolgálóprojekt konfigurálása (`BlazorWebAppEntra`)

Kiszolgálóoldali Blazor Web App projekt (`BlazorWebAppEntra`)

Ügyféloldali Blazor Web App projekt (`BlazorWebAppEntra.Client`)

Backend web API projekt (`MinimalApiJwt`)

A háttérrendszer webes API-projektjének konfigurálása (`MinimalApiJwt`)

A kiszolgálóprojekt konfigurálása (`BlazorWebAppEntra`)