A Graph API használata a ASP.NET Core használatával Blazor WebAssembly

Ez a cikk bemutatja, hogyan használhatja a Microsoft Graphot az alkalmazásokban Blazor WebAssembly , így az alkalmazások hozzáférhetnek a Microsoft Cloud-erőforrásokhoz.

Két módszerről van szó:

• Graph SDK: A Microsoft Graph SDK leegyszerűsíti a Microsoft Graphhoz hozzáférő kiváló minőségű, hatékony és rugalmas alkalmazások készítését. Ennek a megközelítésnek a bevezetéséhez válassza a cikk tetején található Graph SDK gombot.

• Nevezett HttpClient a Graph API-vel: Egy elnevezett HttpClient rendszer közvetlenül kiadhat Microsoft Graph API-kérelmeket a Microsoft Graph-hoz. Ennek a megközelítésnek a bevezetéséhez válassza a cikk tetején található Elnevezett HttpClient és Graph API gombot.

A jelen cikkben ismertetett útmutató nem a Microsoft Graph dokumentációjának és az Azure egyéb Microsoft-dokumentációs csoportokban található azure-beli biztonsági útmutatójának lecserélésére szolgál. A Microsoft Graph éles környezetben való implementálása előtt értékelje ki a cikk További erőforrások szakaszában található biztonsági útmutatást. Kövesse a Microsoft ajánlott eljárásait az alkalmazások biztonsági réseinek korlátozásához.

A Microsoft Graph használatának további megközelítéseit az alábbi Microsoft Graph- Blazor WebAssembly és Azure-minták biztosítják:

• Microsoft Graph mintaalkalmazásBlazor WebAssembly: A minta egy gyári megközelítést alkalmaz a Microsoft Graph SDK-val az Office 365-adatok beszerzéséhez. A minta alapértelmezett HttpClient használatával gráf ügyfélkéréseket kezdeményez. Ha az alapértelmezett HttpClient és az alkalmazás BaseAddress = new Uri(builder.HostEnvironment.BaseAddress) alapcímét más célokra, például az alkalmazás webes gyökeréből származó adatok betöltésére kell használnia, fontolja meg a Graph kliens gyártójának átszervezését, hogy egy Graph kérésekhez dedikált nevet HttpClient használjon.
• ASP.NET Core a .NET 8-ban Blazor WebAssembly | önálló alkalmazás | felhasználói bejelentkezés, védett webes API-hozzáférés (Microsoft Graph) | Microsoft-identitásplatform: A minta egy progresszív webalkalmazás (PWA), amely egy engedélyezési üzenetkezelőt használ, és HttpClient graph-adatokat kér le. Az előző mintához hasonlóan ez a minta is egy alapértelmezett HttpClient Graph-kliens kérést használ. A Microsoft Graph SDK használata helyett a minta JSON-ként kéri le a felhasználói fiók adatait egy összetevő Microsoft Graph API-kérésén keresztül. Ez hasonló a cikkben szereplő HttpClient és Graph API megközelítéshez (a cikk tetején található gombbal megtekintheti az útmutatót), azzal a különbséggel, hogy a cikk útmutatója egy elnevezett HttpClient graph-kéréseket használ.

Ha visszajelzést szeretne küldeni az előző két minta bármelyikéről, nyisson meg egy problémát a minta GitHub-adattárában. Ha az Azure-minta problémáját nyitja meg, a nyitó megjegyzésben adjon meg egy hivatkozást a mintára, mert az Azure-mintaadattár (Azure-Samples) számos mintát tartalmaz. Ismertesse részletesen a problémát, és szükség szerint adjon meg mintakódot. Helyezzen egy minimális alkalmazást a GitHubra, amely reprodukálja a problémát vagy a hibát. A nyilvános adattárban való véglegesítés előtt mindenképpen távolítsa el az Azure-fiók konfigurációs adatait a mintából.

Ha visszajelzést szeretne küldeni, vagy segítséget szeretne kérni ezzel a cikkel vagy ASP.NET Core-jal kapcsolatban, tekintse meg ASP.NET Core Blazor alapjait.

Fontos

A cikkben ismertetett forgatókönyvek a Microsoft Entra (ME-ID) identitásszolgáltatóként való használatára vonatkoznak, nem pedig az AAD B2C-ra. A Microsoft Graph ügyféloldali Blazor WebAssembly alkalmazással és az AAD B2C-identitásszolgáltatóval való használata jelenleg nem támogatott, mert az alkalmazáshoz ügyféloldali titkos ügyfélkód szükséges, amely nem védhető az ügyféloldali Blazor alkalmazásban. Önálló AAD B2C-alkalmazás esetén használja a Blazor WebAssembly Graph API-t, és hozzon létre egy háttérkiszolgálói (webes) API-t a Graph API eléréséhez a felhasználók nevében. Az ügyféloldali alkalmazás hitelesíti és engedélyezi a felhasználók számára , hogy meghívják a webes API-t, hogy biztonságosan hozzáférjenek a Microsoft Graphhoz, és adatokat adjanak vissza az ügyféloldali Blazor alkalmazásnak a kiszolgálóalapú webes API-ból. Az ügyfél titkos kódja biztonságosan megmarad a kiszolgálóalapú webes API-ban, nem az Blazor ügyfélalkalmazásban. Soha ne tároljon ügyfélkulcsot ügyféloldali Blazor alkalmazásban.

A cikkben szereplő példák kihasználják az új .NET/C# funkciókat. Ha a példákat .NET 7 vagy korábbi verzióval használja, kisebb módosításokra van szükség. A Microsoft Graphtal való interakcióra vonatkozó szöveges és kódbeli példák azonban megegyeznek a ASP.NET Core minden verziójában.

Az alábbi útmutató a Microsoft Graph 5-ös verzióra vonatkozik.

Az alkalmazásokban Blazor használható Microsoft Graph SDK-t Microsoft Graph .NET ügyfélkódtárnak nevezzük.

A Graph SDK-példákhoz az alábbi csomaghivatkozások szükségesek az önálló Blazor WebAssembly alkalmazásban. Az első két csomagra már hivatkozunk, ha az alkalmazás engedélyezve van az MSAL-hitelesítéshez, például az alkalmazás létrehozásakor a Microsoft Entra-azonosítóval rendelkező ASP.NET Core Blazor WebAssembly önálló alkalmazás biztonságossá tételével kapcsolatos útmutatást követve.

• Microsoft.AspNetCore.Components.WebAssembly.Authentication
• Microsoft.Authentication.WebAssembly.Msal
• Microsoft.Extensions.Http
• Microsoft.Graph

Megjegyzés:

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.

Az Azure Portalon adjon delegált engedélyeket (hatóköröket)† olyan Microsoft Graph-adatokhoz, amelyeket az alkalmazásnak egy felhasználó nevében elérhetővé kell tennie. A cikkben szereplő példában az alkalmazás regisztrációjának tartalmaznia kell a felhasználói adatok olvasására vonatkozó delegált engedélyt (Microsoft.Graph>User.Read az API-engedélyek hatóköre, Típus: Delegált). A User.Read hatókör lehetővé teszi, hogy a felhasználók bejelentkezhessenek az alkalmazásba, és lehetővé teszik az alkalmazás számára a bejelentkezett felhasználók profiljának és céges adatainak olvasását. További információ: Engedélyek és hozzájárulások áttekintése a Microsoft identitásplatformon és A Microsoft Graph-engedélyekáttekintése.

†Engedélyek és hatókörök ugyanazt jelentik, és felcserélhetők a biztonsági dokumentációban és az Azure portálon. Hacsak a szöveg nem az Azure portalra hivatkozik, ez a cikk a Graph-engedélyekre való hivatkozáskor a hatókört és a/hatóköröket használja.

A hatókörök a kis- és nagybetűkre nem érzékenyek, ezért a User.Read ugyanaz, mint a user.read. Nyugodtan használhatja bármelyik formátumot, de egységes választást ajánlunk az alkalmazáskódok között.

Miután hozzáadta a Microsoft Graph API-hatóköröket az alkalmazás regisztrációhoz az Azure Portalon, adja hozzá az alábbi alkalmazásbeállítások konfigurációját az alkalmazás fájljába wwwroot/appsettings.json , amely tartalmazza a Graph alap URL-címét a Microsoft Graph verziójával és hatóköreivel. Az alábbi példában a User.Read hatókör a cikk későbbi szakaszaiban szereplő példákhoz van megadva. A hatókörök nem érzékenyek a kis- és nagybetűkre.

"MicrosoftGraph": {
  "BaseUrl": "https://graph.microsoft.com",
  "Version": "{VERSION}",
  "Scopes": [
    "user.read"
  ]
}

Az előző példában a {VERSION} helyőrző a Microsoft Graph API verziója (például: v1.0).

Az alábbiakban egy teljes wwwroot/appsettings.json konfigurációs fájlt mutatunk be egy olyan alkalmazáshoz, amely ME-ID használ identitásszolgáltatóként, ahol a Microsoft Graph felhasználói adatok olvasása (user.read hatóköre) van megadva:

{
  "AzureAd": {
    "Authority": "https://login.microsoftonline.com/{TENANT ID}",
    "ClientId": "{CLIENT ID}",
    "ValidateAuthority": true
  },
  "MicrosoftGraph": {
    "BaseUrl": "https://graph.microsoft.com",
    "Version": "v1.0",
    "Scopes": [
      "user.read"
    ]
  }
}

Az előző példában a {TENANT ID} helyőrző a címtár (bérlő) azonosítója, a {CLIENT ID} helyőrző pedig az alkalmazás (ügyfél) azonosítója. További információért lásd: Az ASP.NET Core Blazor WebAssembly önálló alkalmazás biztonságossá tétele a Microsoft Entra IDsegítségével.

Adja hozzá a következő GraphClientExtensions osztályt az önálló alkalmazáshoz. A hatókörök a Scopes tulajdonságához kerülnek a AccessTokenRequestOptions metódusban.

Ha nem szerez be hozzáférési tokent, az alábbi kód nem állítja be a Bearer engedélyezési fejlécet a Graph-kérelmekhez.

GraphClientExtensions.cs:

using Microsoft.AspNetCore.Components.WebAssembly.Authentication;
using Microsoft.Authentication.WebAssembly.Msal.Models;
using Microsoft.Graph;
using Microsoft.Kiota.Abstractions;
using Microsoft.Kiota.Abstractions.Authentication;
using IAccessTokenProvider = 
    Microsoft.AspNetCore.Components.WebAssembly.Authentication.IAccessTokenProvider;

namespace BlazorSample;

internal static class GraphClientExtensions
{
    public static IServiceCollection AddGraphClient(
            this IServiceCollection services, string? baseUrl, List<string>? scopes)
    {
        if (string.IsNullOrEmpty(baseUrl) || scopes?.Count == 0)
        {
            return services;
        }

        services.Configure<RemoteAuthenticationOptions<MsalProviderOptions>>(
            options =>
            {
                scopes?.ForEach((scope) =>
                {
                    options.ProviderOptions.DefaultAccessTokenScopes.Add(scope);
                });
            });

        services.AddScoped<IAuthenticationProvider, GraphAuthenticationProvider>();

        services.AddScoped(sp =>
        {
            return new GraphServiceClient(
                new HttpClient(),
                sp.GetRequiredService<IAuthenticationProvider>(),
                baseUrl);
        });

        return services;
    }

    private class GraphAuthenticationProvider(IAccessTokenProvider tokenProvider, 
        IConfiguration config) : IAuthenticationProvider
    {
        private readonly IConfiguration config = config;

        public IAccessTokenProvider TokenProvider { get; } = tokenProvider;

        public async Task AuthenticateRequestAsync(RequestInformation request, 
            Dictionary<string, object>? additionalAuthenticationContext = null, 
            CancellationToken cancellationToken = default)
        {
            var result = await TokenProvider.RequestAccessToken(
                new AccessTokenRequestOptions()
                {
                    Scopes = 
                        config.GetSection("MicrosoftGraph:Scopes").Get<string[]>() ??
                        [ "user.read" ]
                });

            if (result.TryGetToken(out var token))
            {
                request.Headers.Add("Authorization", 
                    $"{CoreConstants.Headers.Bearer} {token.Value}");
            }
        }
    }
}

Fontos

A DefaultAccessTokenScopes versus AdditionalScopesToConsent szakaszban található magyarázatból megtudhatja, hogy az előző kód miért a DefaultAccessTokenScopes elemet használja a hatókörök hozzáadására a AdditionalScopesToConsent helyett.

A fájlban Program adja hozzá a Graph-ügyfélszolgáltatásokat és -konfigurációt a AddGraphClient bővítménymetódussal. Az alábbi kód alapértelmezés szerint az 1.0-s verziójú Microsoft Graph alapcímet és User.Read hatóköröket tartalmazza, ha ezek a beállítások nem találhatók az alkalmazásbeállítások fájljában:

var baseUrl = string.Join("/",
    builder.Configuration.GetSection("MicrosoftGraph")["BaseUrl"] ??
        "https://graph.microsoft.com",
    builder.Configuration.GetSection("MicrosoftGraph")["Version"] ??
        "v1.0");
var scopes = builder.Configuration.GetSection("MicrosoftGraph:Scopes")
    .Get<List<string>>() ?? [ "user.read" ];

builder.Services.AddGraphClient(baseUrl, scopes);

Graph API meghívása egy összetevőből a Graph SDK használatával

Az alábbi UserData összetevő egy injektált GraphServiceClient használatával szerzi be a felhasználó ME-ID profiladatait, és megjeleníti a mobiltelefonszámát.

A ME-ID-ban létrehozott tesztfelhasználók esetében győződjön meg arról, hogy a felhasználó ME-ID profiljának mobiltelefonszámot ad meg az Azure portálon.

UserData.razor:

@page "/user-data"
@using Microsoft.AspNetCore.Authorization
@using Microsoft.Graph
@attribute [Authorize]
@inject GraphServiceClient Client

<PageTitle>User Data</PageTitle>

<h1>Microsoft Graph User Data</h1>

@if (!string.IsNullOrEmpty(user?.MobilePhone))
{
    <p>Mobile Phone: @user.MobilePhone</p>
}

@code {
    private Microsoft.Graph.Models.User? user;

    protected override async Task OnInitializedAsync()
    {
        user = await Client.Me.GetAsync();
    }
}

Hivatkozás hozzáadása az összetevő oldalához az NavMenu összetevőben (Layout/NavMenu.razor):

<div class="nav-item px-3">
    <NavLink class="nav-link" href="user-data">
        <span class="bi bi-list-nested-nav-menu" aria-hidden="true"></span> User Data
    </NavLink>
</div>

Jótanács

Ha felhasználókat szeretne hozzáadni egy alkalmazáshoz, olvassa el a Felhasználók hozzárendelése alkalmazásregisztrációhoz alkalmazásszerepkörökkel vagy anélkül című szakaszt.

Ha helyileg teszteli a Graph SDK-t, javasoljuk, hogy minden teszthez használjon egy új InPrivate/inkognitó böngésző-munkamenetet, hogy a cookie-k ne zavarják a teszteket. További információért lásd: Az ASP.NET Core Blazor WebAssembly önálló alkalmazás biztonságossá tétele a Microsoft Entra IDsegítségével.

Felhasználói jogcímek testreszabása a Graph SDK használatával

Az alábbi példában az alkalmazás mobiltelefonszám- és irodahely-jogcímeket hoz létre egy felhasználó számára a ME-ID felhasználói profil adataiból. Az alkalmazásnak konfigurálnia kell a User.Read Graph API-hatókört a ME-ID-ban. Az ehhez a forgatókönyvhöz tartozó tesztfelhasználóknak rendelkezniük kell egy mobiltelefonszámmal és egy irodával a ME-ID profiljukban, amelyet az Azure Portalon lehet hozzáadni.

Az alábbi egyéni felhasználói fiók-előállítóban:

• A ILogger (logger) az egyszerűség kedvéért szerepel abban az esetben, ha adatokat vagy hibákat szeretne naplózni a CreateUserAsync metódusban.
• Ha egy AccessTokenNotAvailableException kivétel fordul elõ, a rendszer átirányítja a felhasználót az identitásszolgáltatóhoz, hogy bejelentkezzen a fiókjába. A hozzáférési jogkivonat kérése meghiúsulása esetén további vagy eltérő műveletek is végrehajthatók. Az alkalmazás például rögzítheti a AccessTokenNotAvailableException-t, és létrehozhat egy támogatási jegyet a további vizsgálat érdekében.
• A keretrendszer a RemoteUserAccount felhasználó fiókját jelöli. Ha az alkalmazás egy egyéni felhasználói fiókosztályt igényel, amely kiterjeszti a RemoteUserAccount-ot, cserélje le az egyéni felhasználói fiókosztályt RemoteUserAccount-re az alábbi kódban.

CustomAccountFactory.cs:

using System.Security.Claims;
using Microsoft.AspNetCore.Components.WebAssembly.Authentication;
using Microsoft.AspNetCore.Components.WebAssembly.Authentication.Internal;
using Microsoft.Graph;
using Microsoft.Kiota.Abstractions.Authentication;

public class CustomAccountFactory(IAccessTokenProviderAccessor accessor,
        IServiceProvider serviceProvider, ILogger<CustomAccountFactory> logger,
        IConfiguration config) 
    : AccountClaimsPrincipalFactory<RemoteUserAccount>(accessor)
{
    private readonly ILogger<CustomAccountFactory> logger = logger;
    private readonly IServiceProvider serviceProvider = serviceProvider;
    private readonly string? baseUrl = string.Join("/",
        config.GetSection("MicrosoftGraph")["BaseUrl"] ?? 
            "https://graph.microsoft.com",
        config.GetSection("MicrosoftGraph")["Version"] ??
            "v1.0");

    public override async ValueTask<ClaimsPrincipal> CreateUserAsync(
        RemoteUserAccount account,
        RemoteAuthenticationUserOptions options)
    {
        var initialUser = await base.CreateUserAsync(account, options);

        if (initialUser.Identity is not null &&
            initialUser.Identity.IsAuthenticated)
        {
            var userIdentity = initialUser.Identity as ClaimsIdentity;

            if (userIdentity is not null && !string.IsNullOrEmpty(baseUrl))
            {
                try
                {
                    var client = new GraphServiceClient(
                        new HttpClient(),
                        serviceProvider
                            .GetRequiredService<IAuthenticationProvider>(),
                        baseUrl);

                    var user = await client.Me.GetAsync();

                    if (user is not null)
                    {
                        userIdentity.AddClaim(new Claim("mobilephone",
                            user.MobilePhone ?? "(000) 000-0000"));
                        userIdentity.AddClaim(new Claim("officelocation",
                            user.OfficeLocation ?? "Not set"));
                    }
                }
                catch (AccessTokenNotAvailableException exception)
                {
                    exception.Redirect();
                }
            }
        }

        return initialUser;
    }
}

Konfigurálja az MSAL-hitelesítést az egyéni felhasználói fiók előállítójának használatára.

Győződjön meg arról, hogy a Program fájl a Microsoft.AspNetCore.Components.WebAssembly.Authentication névteret használja:

using Microsoft.AspNetCore.Components.WebAssembly.Authentication;

Az ebben a szakaszban szereplő példa az alap URL verziójának és hatóköreinek a konfigurációs fájlból való olvasásának megközelítésére épül, a MicrosoftGraph szakaszon keresztül a wwwroot/appsettings.json fájlban. A következő soroknak már jelen kell lenniük a Program fájlban, az e cikkben korábban adott útmutatást követve.

var baseUrl = string.Join("/",
    builder.Configuration.GetSection("MicrosoftGraph")["BaseUrl"] ??
        "https://graph.microsoft.com",
    builder.Configuration.GetSection("MicrosoftGraph")["Version"] ??
        "v1.0");
var scopes = builder.Configuration.GetSection("MicrosoftGraph:Scopes")
    .Get<List<string>>() ?? [ "user.read" ];

builder.Services.AddGraphClient(baseUrl, scopes);

A Program fájlban keresse meg a AddMsalAuthentication bővítménymetódus hívását. Frissítse a kódot a következőre, amely tartalmaz egy AddAccountClaimsPrincipalFactory hívást, amely hozzáad egy fiókjogcím-felelős gyárat a CustomAccountFactory elemhez.

Ha az alkalmazás olyan egyéni felhasználói fiók osztályt használ, amely kiterjeszti a RemoteUserAccount elemet, akkor az alábbi kódban cserélje le ezt az osztályt a RemoteUserAccount elemre.

builder.Services.AddMsalAuthentication<RemoteAuthenticationState,
    RemoteUserAccount>(options =>
    {
        builder.Configuration.Bind("AzureAd", 
            options.ProviderOptions.Authentication);
    })
    .AddAccountClaimsPrincipalFactory<RemoteAuthenticationState, RemoteUserAccount,
        CustomAccountFactory>();

A következő UserClaims összetevővel tanulmányozhatja a felhasználó jogcímeit, miután a felhasználó me-id azonosítóval hitelesít:

UserClaims.razor:

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

<h1>User Claims</h1>

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

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

    protected override async Task OnInitializedAsync()
    {
        var authState = await AuthenticationStateProvider
            .GetAuthenticationStateAsync();
        var user = authState.User;

        claims = user.Claims;
    }
}

Hivatkozás hozzáadása az összetevő oldalához az NavMenu összetevőben (Layout/NavMenu.razor):

<div class="nav-item px-3">
    <NavLink class="nav-link" href="user-claims">
        <span class="bi bi-list-nested-nav-menu" aria-hidden="true"></span> User Claims
    </NavLink>
</div>

Ha helyileg teszteli a Graph SDK-t, javasoljuk, hogy minden teszthez használjon egy új InPrivate/inkognitó böngésző-munkamenetet, hogy a cookie-k ne zavarják a teszteket. További információért lásd: Az ASP.NET Core Blazor WebAssembly önálló alkalmazás biztonságossá tétele a Microsoft Entra IDsegítségével.

Az alábbi útmutató a Microsoft Graph v4-hez vonatkozik. Ha SDK v4-ről v5-re frissít egy alkalmazást, tekintse meg a Microsoft Graph .NET SDK v5 változásnaplóját és frissítési útmutatóját.

Az alkalmazásokban Blazor használható Microsoft Graph SDK-t Microsoft Graph .NET ügyfélkódtárnak nevezzük.

A Graph SDK-példákhoz az alábbi csomaghivatkozások szükségesek az önálló Blazor WebAssembly alkalmazásban. Az első két csomagra már hivatkozunk, ha az alkalmazás engedélyezve van az MSAL-hitelesítéshez, például az alkalmazás létrehozásakor a Microsoft Entra-azonosítóval rendelkező ASP.NET Core Blazor WebAssembly önálló alkalmazás biztonságossá tételével kapcsolatos útmutatást követve.

• Microsoft.AspNetCore.Components.WebAssembly.Authentication
• Microsoft.Authentication.WebAssembly.Msal
• Microsoft.Extensions.Http
• Microsoft.Graph

Megjegyzés:

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.

Az Azure Portalon adjon delegált engedélyeket (hatóköröket)† olyan Microsoft Graph-adatokhoz, amelyeket az alkalmazásnak egy felhasználó nevében elérhetővé kell tennie. A cikkben szereplő példában az alkalmazás regisztrációjának tartalmaznia kell a felhasználói adatok olvasására vonatkozó delegált engedélyt (Microsoft.Graph>User.Read az API-engedélyek hatóköre, Típus: Delegált). A User.Read hatókör lehetővé teszi, hogy a felhasználók bejelentkezhessenek az alkalmazásba, és lehetővé teszik az alkalmazás számára a bejelentkezett felhasználók profiljának és céges adatainak olvasását. További információ: Engedélyek és hozzájárulások áttekintése a Microsoft identitásplatformon és A Microsoft Graph-engedélyekáttekintése.

†Engedélyek és hatókörök ugyanazt jelentik, és felcserélhetők a biztonsági dokumentációban és az Azure portálon. Hacsak a szöveg nem az Azure portalra hivatkozik, ez a cikk a Graph-engedélyekre való hivatkozáskor a hatókört és a/hatóköröket használja.

A hatókörök a kis- és nagybetűkre nem érzékenyek, ezért a User.Read ugyanaz, mint a user.read. Nyugodtan használhatja bármelyik formátumot, de egységes választást ajánlunk az alkalmazáskódok között.

Miután hozzáadta a Microsoft Graph API-hatóköröket az alkalmazás regisztrációhoz az Azure Portalon, adja hozzá az alábbi alkalmazásbeállítások konfigurációját az alkalmazás fájljába wwwroot/appsettings.json , amely tartalmazza a Graph alap URL-címét a Microsoft Graph verziójával és hatóköreivel. Az alábbi példában a User.Read hatókör a cikk későbbi szakaszaiban szereplő példákhoz van megadva. A hatókörök nem érzékenyek a kis- és nagybetűkre.

"MicrosoftGraph": {
  "BaseUrl": "https://graph.microsoft.com",
  "Version": "{VERSION}",
  "Scopes": [
    "user.read"
  ]
}

Az előző példában a {VERSION} helyőrző a Microsoft Graph API verziója (például: v1.0).

Az alábbiakban egy teljes wwwroot/appsettings.json konfigurációs fájlt mutatunk be egy olyan alkalmazáshoz, amely ME-ID használ identitásszolgáltatóként, ahol a Microsoft Graph felhasználói adatok olvasása (user.read hatóköre) van megadva:

{
  "AzureAd": {
    "Authority": "https://login.microsoftonline.com/{TENANT ID}",
    "ClientId": "{CLIENT ID}",
    "ValidateAuthority": true
  },
  "MicrosoftGraph": {
    "BaseUrl": "https://graph.microsoft.com",
    "Version": "v1.0",
    "Scopes": [
      "user.read"
    ]
  }
}

Az előző példában a {TENANT ID} helyőrző a címtár (bérlő) azonosítója, a {CLIENT ID} helyőrző pedig az alkalmazás (ügyfél) azonosítója. További információért lásd: Az ASP.NET Core Blazor WebAssembly önálló alkalmazás biztonságossá tétele a Microsoft Entra IDsegítségével.

Adja hozzá a következő GraphClientExtensions osztályt az önálló alkalmazáshoz. A hatókörök a Scopes tulajdonságához kerülnek a AccessTokenRequestOptions metódusban. Az IHttpProvider.OverallTimeout alapértelmezett érték 100 másodpercről 300 másodpercre bővül, hogy minél több időt kapjon a HttpClient Microsoft Graph válasza.

Ha nem szerez be hozzáférési tokent, az alábbi kód nem állítja be a Bearer engedélyezési fejlécet a Graph-kérelmekhez.

GraphClientExtensions.cs:

using System.Net.Http.Headers;
using Microsoft.AspNetCore.Components.WebAssembly.Authentication;
using Microsoft.Authentication.WebAssembly.Msal.Models;
using Microsoft.Graph;

namespace BlazorSample;

internal static class GraphClientExtensions
{
    public static IServiceCollection AddGraphClient(
        this IServiceCollection services, string? baseUrl, List<string>? scopes)
    {
        if (string.IsNullOrEmpty(baseUrl) || scopes?.Count == 0)
        {
            return services;
        }

        services.Configure<RemoteAuthenticationOptions<MsalProviderOptions>>(
            options =>
            {
                scopes?.ForEach((scope) =>
                {
                    options.ProviderOptions.DefaultAccessTokenScopes.Add(scope);
                });
            });

        services.AddScoped<IAuthenticationProvider, GraphAuthenticationProvider>();

        services.AddScoped<IHttpProvider, HttpClientHttpProvider>(sp =>
            new HttpClientHttpProvider(new HttpClient()));

        services.AddScoped(sp =>
        {
            return new GraphServiceClient(
                baseUrl,
                sp.GetRequiredService<IAuthenticationProvider>(),
                sp.GetRequiredService<IHttpProvider>());
        });

        return services;
    }

    private class GraphAuthenticationProvider(IAccessTokenProvider tokenProvider, 
        IConfiguration config) : IAuthenticationProvider
    {
        private readonly IConfiguration config = config;

        public IAccessTokenProvider TokenProvider { get; } = tokenProvider;

        public async Task AuthenticateRequestAsync(HttpRequestMessage request)
        {
            var result = await TokenProvider.RequestAccessToken(
                new AccessTokenRequestOptions()
                { 
                    Scopes = config.GetSection("MicrosoftGraph:Scopes").Get<string[]>()
                });

            if (result.TryGetToken(out var token))
            {
                request.Headers.Authorization ??= new AuthenticationHeaderValue(
                    "Bearer", token.Value);
            }
        }
    }

    private class HttpClientHttpProvider(HttpClient client) : IHttpProvider
    {
        private readonly HttpClient client = client;

        public ISerializer Serializer { get; } = new Serializer();

        public TimeSpan OverallTimeout { get; set; } = TimeSpan.FromSeconds(300);

        public Task<HttpResponseMessage> SendAsync(HttpRequestMessage request)
        {
            return client.SendAsync(request);
        }

        public Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
            HttpCompletionOption completionOption,
            CancellationToken cancellationToken)
        {
            return client.SendAsync(request, completionOption, cancellationToken);
        }

        public void Dispose()
        {
        }
    }
}

Fontos

A DefaultAccessTokenScopes versus AdditionalScopesToConsent szakaszban található magyarázatból megtudhatja, hogy az előző kód miért a DefaultAccessTokenScopes elemet használja a hatókörök hozzáadására a AdditionalScopesToConsent helyett.

A fájlban adja hozzá a Program Graph-ügyfélszolgáltatásokat és -konfigurációt a AddGraphClient bővítménymetódussal:

var baseUrl = string.Join("/",
    builder.Configuration.GetSection("MicrosoftGraph")["BaseUrl"] ??
        "https://graph.microsoft.com",
    builder.Configuration.GetSection("MicrosoftGraph")["Version"] ??
        "v1.0");
var scopes = builder.Configuration.GetSection("MicrosoftGraph:Scopes")
    .Get<List<string>>() ?? [ "user.read" ];

builder.Services.AddGraphClient(baseUrl, scopes);

Graph API meghívása egy összetevőből a Graph SDK használatával

Az alábbi UserData összetevő egy injektált GraphServiceClient használatával szerzi be a felhasználó ME-ID profiladatait, és megjeleníti a mobiltelefonszámát. A ME-ID-ban létrehozott tesztfelhasználók esetében győződjön meg arról, hogy a felhasználó ME-ID profiljának mobiltelefonszámot ad meg az Azure portálon.

UserData.razor:

@page "/user-data"
@using Microsoft.AspNetCore.Authorization
@using Microsoft.Graph
@attribute [Authorize]
@inject GraphServiceClient Client

<PageTitle>User Data</PageTitle>

<h1>Microsoft Graph User Data</h1>

@if (!string.IsNullOrEmpty(user?.MobilePhone))
{
    <p>Mobile Phone: @user.MobilePhone</p>
}

@code {
    private Microsoft.Graph.User? user;

    protected override async Task OnInitializedAsync()
    {
        var request = Client.Me.Request();
        user = await request.GetAsync();
    }
}

Hivatkozás hozzáadása az összetevő oldalához az NavMenu összetevőben (Layout/NavMenu.razor):

<div class="nav-item px-3">
    <NavLink class="nav-link" href="user-data">
        <span class="bi bi-list-nested-nav-menu" aria-hidden="true"></span> User Data
    </NavLink>
</div>

Jótanács

Ha felhasználókat szeretne hozzáadni egy alkalmazáshoz, olvassa el a Felhasználók hozzárendelése alkalmazásregisztrációhoz alkalmazásszerepkörökkel vagy anélkül című szakaszt.

Ha helyileg teszteli a Graph SDK-t, javasoljuk, hogy minden teszthez használjon egy új InPrivate/inkognitó böngésző-munkamenetet, hogy a cookie-k ne zavarják a teszteket. További információért lásd: Az ASP.NET Core Blazor WebAssembly önálló alkalmazás biztonságossá tétele a Microsoft Entra IDsegítségével.

Felhasználói jogcímek testreszabása a Graph SDK használatával

Az alábbi példában az alkalmazás mobiltelefonszám- és irodahely-jogcímeket hoz létre egy felhasználó számára a ME-ID felhasználói profil adataiból. Az alkalmazásnak konfigurálnia kell a User.Read Graph API-hatókört a ME-ID-ban. Az ehhez a forgatókönyvhöz tartozó tesztfelhasználóknak rendelkezniük kell egy mobiltelefonszámmal és egy irodával a ME-ID profiljukban, amelyet az Azure Portalon lehet hozzáadni.

Az alábbi egyéni felhasználói fiók-előállítóban:

• A ILogger (logger) az egyszerűség kedvéért szerepel abban az esetben, ha adatokat vagy hibákat szeretne naplózni a CreateUserAsync metódusban.
• Ha egy AccessTokenNotAvailableException kivétel fordul elõ, a rendszer átirányítja a felhasználót az identitásszolgáltatóhoz, hogy bejelentkezzen a fiókjába. A hozzáférési jogkivonat kérése meghiúsulása esetén további vagy eltérő műveletek is végrehajthatók. Az alkalmazás például rögzítheti a AccessTokenNotAvailableException-t, és létrehozhat egy támogatási jegyet a további vizsgálat érdekében.
• A keretrendszer a RemoteUserAccount felhasználó fiókját jelöli. Ha az alkalmazás egy egyéni felhasználói fiókosztályt igényel, amely kiterjeszti a RemoteUserAccount-ot, cserélje le az egyéni felhasználói fiókosztályt RemoteUserAccount-re az alábbi kódban.

CustomAccountFactory.cs:

using System.Security.Claims;
using Microsoft.AspNetCore.Components.WebAssembly.Authentication;
using Microsoft.AspNetCore.Components.WebAssembly.Authentication.Internal;
using Microsoft.Graph;

public class CustomAccountFactory(IAccessTokenProviderAccessor accessor, 
        IServiceProvider serviceProvider, ILogger<CustomAccountFactory> logger)
    : AccountClaimsPrincipalFactory<RemoteUserAccount>(accessor)
{
    private readonly ILogger<CustomAccountFactory> logger = logger;
    private readonly IServiceProvider serviceProvider = serviceProvider;

    public override async ValueTask<ClaimsPrincipal> CreateUserAsync(
        RemoteUserAccount account,
        RemoteAuthenticationUserOptions options)
    {
        var initialUser = await base.CreateUserAsync(account, options);

        if (initialUser.Identity is not null && 
            initialUser.Identity.IsAuthenticated)
        {
            var userIdentity = initialUser.Identity as ClaimsIdentity;

            if (userIdentity is not null)
            {
                try
                {
                    var client = ActivatorUtilities
                        .CreateInstance<GraphServiceClient>(serviceProvider);
                    var request = client.Me.Request();
                    var user = await request.GetAsync();

                    if (user is not null)
                    {
                        userIdentity.AddClaim(new Claim("mobilephone",
                            user.MobilePhone ?? "(000) 000-0000"));
                        userIdentity.AddClaim(new Claim("officelocation",
                            user.OfficeLocation ?? "Not set"));
                    }
                }
                catch (AccessTokenNotAvailableException exception)
                {
                    exception.Redirect();
                }
            }
        }

        return initialUser;
    }
}

Konfigurálja az MSAL-hitelesítést az egyéni felhasználói fiók előállítójának használatára.

Győződjön meg arról, hogy a Program fájl a Microsoft.AspNetCore.Components.WebAssembly.Authentication névteret használja:

using Microsoft.AspNetCore.Components.WebAssembly.Authentication;

Az ebben a szakaszban szereplő példa az alap URL verziójának és hatóköreinek a konfigurációs fájlból való olvasásának megközelítésére épül, a MicrosoftGraph szakaszon keresztül a wwwroot/appsettings.json fájlban. A következő soroknak már jelen kell lenniük a Program fájlban, az e cikkben korábban adott útmutatást követve.

var baseUrl = string.Join("/",
    builder.Configuration.GetSection("MicrosoftGraph")["BaseUrl"] ??
        "https://graph.microsoft.com",
    builder.Configuration.GetSection("MicrosoftGraph")["Version"] ??
        "v1.0");
var scopes = builder.Configuration.GetSection("MicrosoftGraph:Scopes")
    .Get<List<string>>() ?? [ "user.read" ];

builder.Services.AddGraphClient(baseUrl, scopes);

A Program fájlban keresse meg a AddMsalAuthentication bővítménymetódus hívását. Frissítse a kódot a következőre, amely tartalmaz egy AddAccountClaimsPrincipalFactory hívást, amely hozzáad egy fiókjogcím-felelős gyárat a CustomAccountFactory elemhez.

Ha az alkalmazás olyan egyéni felhasználói fiók osztályt használ, amely kiterjeszti a RemoteUserAccount elemet, akkor az alábbi kódban cserélje le ezt az osztályt a RemoteUserAccount elemre.

builder.Services.AddMsalAuthentication<RemoteAuthenticationState,
    RemoteUserAccount>(options =>
    {
        builder.Configuration.Bind("AzureAd", 
            options.ProviderOptions.Authentication);
    })
    .AddAccountClaimsPrincipalFactory<RemoteAuthenticationState, RemoteUserAccount,
        CustomAccountFactory>();

A következő UserClaims összetevővel tanulmányozhatja a felhasználó jogcímeit, miután a felhasználó me-id azonosítóval hitelesít:

UserClaims.razor:

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

<h1>User Claims</h1>

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

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

    protected override async Task OnInitializedAsync()
    {
        var authState = await AuthenticationStateProvider
            .GetAuthenticationStateAsync();
        var user = authState.User;

        claims = user.Claims;
    }
}

Hivatkozás hozzáadása az összetevő oldalához az NavMenu összetevőben (Layout/NavMenu.razor):

<div class="nav-item px-3">
    <NavLink class="nav-link" href="user-claims">
        <span class="bi bi-list-nested-nav-menu" aria-hidden="true"></span> User Claims
    </NavLink>
</div>

Ha helyileg teszteli a Graph SDK-t, javasoljuk, hogy minden teszthez használjon egy új InPrivate/inkognitó böngésző-munkamenetet, hogy a cookie-k ne zavarják a teszteket. További információért lásd: Az ASP.NET Core Blazor WebAssembly önálló alkalmazás biztonságossá tétele a Microsoft Entra IDsegítségével.

Az alábbi példák a Graph API-hívások nevesített HttpClient használatával kérik le a felhasználó mobiltelefonszámát egy hívás feldolgozásához vagy a felhasználó jogcímeinek testreszabásához, hogy mobiltelefonszám-jogcímet és egy irodai tartózkodási helyet tartalmazó jogcímet tartalmazzanak.

A példákhoz a Microsoft.Extensions.Http csomagra való hivatkozás szükséges az önálló Blazor WebAssembly alkalmazáshoz.

Megjegyzés:

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.

Az Azure Portalon adjon delegált engedélyeket (hatóköröket)† olyan Microsoft Graph-adatokhoz, amelyeket az alkalmazásnak egy felhasználó nevében elérhetővé kell tennie. A cikkben szereplő példában az alkalmazás regisztrációjának tartalmaznia kell a felhasználói adatok olvasására vonatkozó delegált engedélyt (Microsoft.Graph>User.Read az API-engedélyek hatóköre, Típus: Delegált). A User.Read hatókör lehetővé teszi, hogy a felhasználók bejelentkezhessenek az alkalmazásba, és lehetővé teszik az alkalmazás számára a bejelentkezett felhasználók profiljának és céges adatainak olvasását. További információ: Engedélyek és hozzájárulások áttekintése a Microsoft identitásplatformon és A Microsoft Graph-engedélyekáttekintése.

†Engedélyek és hatókörök ugyanazt jelentik, és felcserélhetők a biztonsági dokumentációban és az Azure portálon. Hacsak a szöveg nem az Azure portalra hivatkozik, ez a cikk a Graph-engedélyekre való hivatkozáskor a hatókört és a/hatóköröket használja.

A hatókörök a kis- és nagybetűkre nem érzékenyek, ezért a User.Read ugyanaz, mint a user.read. Nyugodtan használhatja bármelyik formátumot, de egységes választást ajánlunk az alkalmazáskódok között.

Miután hozzáadta a Microsoft Graph API-hatóköröket az alkalmazás regisztrációhoz az Azure Portalon, adja hozzá az alábbi alkalmazásbeállítások konfigurációját az alkalmazás fájljába wwwroot/appsettings.json , amely tartalmazza a Graph alap URL-címét a Microsoft Graph verziójával és hatóköreivel. Az alábbi példában a User.Read hatókör a cikk későbbi szakaszaiban szereplő példákhoz van megadva. A hatókörök nem érzékenyek a kis- és nagybetűkre.

"MicrosoftGraph": {
  "BaseUrl": "https://graph.microsoft.com",
  "Version": "{VERSION}",
  "Scopes": [
    "user.read"
  ]
}

Az előző példában a {VERSION} helyőrző a Microsoft Graph API verziója (például: v1.0).

Az alábbiakban egy teljes wwwroot/appsettings.json konfigurációs fájlt mutatunk be egy olyan alkalmazáshoz, amely ME-ID használ identitásszolgáltatóként, ahol a Microsoft Graph felhasználói adatok olvasása (user.read hatóköre) van megadva:

{
  "AzureAd": {
    "Authority": "https://login.microsoftonline.com/{TENANT ID}",
    "ClientId": "{CLIENT ID}",
    "ValidateAuthority": true
  },
  "MicrosoftGraph": {
    "BaseUrl": "https://graph.microsoft.com",
    "Version": "v1.0",
    "Scopes": [
      "user.read"
    ]
  }
}

Az előző példában a {TENANT ID} helyőrző a címtár (bérlő) azonosítója, a {CLIENT ID} helyőrző pedig az alkalmazás (ügyfél) azonosítója. További információért lásd: Az ASP.NET Core Blazor WebAssembly önálló alkalmazás biztonságossá tétele a Microsoft Entra IDsegítségével.

Hozza létre a következő GraphAuthorizationMessageHandler osztály- és projektkonfigurációt a fájlban a Program Graph API használatához. Az alap URL-címet és a hatóköröket a kezelő a konfigurációból adja meg.

GraphAuthorizationMessageHandler.cs:

using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.WebAssembly.Authentication;

namespace BlazorSample;

public class GraphAuthorizationMessageHandler : AuthorizationMessageHandler
{
    public GraphAuthorizationMessageHandler(IAccessTokenProvider provider,
        NavigationManager navigation, IConfiguration config)
        : base(provider, navigation)
    {
        ConfigureHandler(
            authorizedUrls: [ 
                string.Join("/",
                    config.GetSection("MicrosoftGraph")["BaseUrl"] ??
                        "https://graph.microsoft.com",
                    config.GetSection("MicrosoftGraph")["Version"] ??
                        "v1.0")
            ],
            scopes: config.GetSection("MicrosoftGraph:Scopes")
                        .Get<List<string>>() ?? [ "user.read" ]);
    }
}

Az engedélyezett URL záró perjele (/) kötelező. Az előző kód az alkalmazásbeállításokból hozza létre a következő engedélyezett URL-címet, vagy alapértelmezésként használja a következő engedélyezett URL-t, ha az alkalmazásbeállítások hiányoznak: https://graph.microsoft.com/v1.0/.

A Program fájlban konfigurálja a Graph API-hoz megadott HttpClient-t.

builder.Services.AddTransient<GraphAuthorizationMessageHandler>();

builder.Services.AddHttpClient("GraphAPI",
        client => client.BaseAddress = new Uri(
            string.Join("/",
                builder.Configuration.GetSection("MicrosoftGraph")["BaseUrl"] ??
                    "https://graph.microsoft.com",
                builder.Configuration.GetSection("MicrosoftGraph")["Version"] ??
                    "v1.0",
                string.Empty)))
    .AddHttpMessageHandler<GraphAuthorizationMessageHandler>();

Az előző példában a GraphAuthorizationMessageHandlerDelegatingHandler rendszer átmeneti szolgáltatásként van regisztrálva a következőhöz AddHttpMessageHandler: . Az átmeneti regisztráció ajánlott a IHttpClientFactory számára, amely a saját DI-hatóköröket kezeli. További információt a következő források tartalmaznak:

• Segédkomponens alaposztályok DI-hatókör kezeléséhez
• Ügyféloldali átmeneti eldobható erőforrások észlelése

Az alapcímen záró perjelre (/) van szükség. Az előző kódban a harmadik argumentum, string.Join, string.Empty annak biztosítására szolgál, hogy a záró perjel jelen legyen: https://graph.microsoft.com/v1.0/.

A Graph API meghívása egy összetevőből egy megnevezett HttpClient használatával

Az UserInfo.cs osztály kijelöli a szükséges felhasználói profiltulajdonságokat az JsonPropertyNameAttribute attribútummal és a ME-ID által használt JSON-névvel. Az alábbi példa a felhasználó mobiltelefonszámának és irodahelyének tulajdonságait állítja be.

UserInfo.cs:

using System.Text.Json.Serialization;

namespace BlazorSample;

public class UserInfo
{
    [JsonPropertyName("mobilePhone")]
    public string? MobilePhone { get; set; }

    [JsonPropertyName("officeLocation")]
    public string? OfficeLocation { get; set; }
}

A következő UserData összetevőben létrehozunk egy HttpClient graph API-t, amely kérést küld a felhasználó profiladataira. Az me erőforrás (me) hozzá lesz adva az alap URL-címhez a Graph API-kérés verziójával. A Graph által visszaadott JSON-adatok deszerializálva vannak az UserInfo osztálytulajdonságokba. Az alábbi példában a mobiltelefonszám lesz bekértve. Hozzáadhat hasonló kódot, amely tartalmazza a felhasználó ME-ID profilirodája helyét, ha szeretné (userInfo.OfficeLocation). Ha a hozzáférési jogkivonat kérése sikertelen, a rendszer átirányítja a felhasználót az alkalmazásba egy új hozzáférési jogkivonathoz való bejelentkezéshez.

UserData.razor:

@page "/user-data"
@using Microsoft.AspNetCore.Authorization
@using Microsoft.AspNetCore.Components.WebAssembly.Authentication
@attribute [Authorize]
@inject IConfiguration Config
@inject IHttpClientFactory ClientFactory

<PageTitle>User Data</PageTitle>

<h1>Microsoft Graph User Data</h1>

@if (!string.IsNullOrEmpty(userInfo?.MobilePhone))
{
    <p>Mobile Phone: @userInfo.MobilePhone</p>
}

@code {
    private UserInfo? userInfo;

    protected override async Task OnInitializedAsync()
    {
        try
        {
            var client = ClientFactory.CreateClient("GraphAPI");

            userInfo = await client.GetFromJsonAsync<UserInfo>("me");
        }
        catch (AccessTokenNotAvailableException exception)
        {
            exception.Redirect();
        }
    }
}

Hivatkozás hozzáadása az összetevő oldalához az NavMenu összetevőben (Layout/NavMenu.razor):

<div class="nav-item px-3">
    <NavLink class="nav-link" href="user-data">
        <span class="bi bi-list-nested-nav-menu" aria-hidden="true"></span> User Data
    </NavLink>
</div>

Jótanács

Ha felhasználókat szeretne hozzáadni egy alkalmazáshoz, olvassa el a Felhasználók hozzárendelése alkalmazásregisztrációhoz alkalmazásszerepkörökkel vagy anélkül című szakaszt.

Az alábbi sorozat a Graph API-hatókörök új felhasználói folyamatát ismerteti:

1. Az új felhasználó először jelentkezik be az alkalmazásba.
2. A felhasználó hozzájárul ahhoz, hogy az alkalmazást az Azure hozzájárulási felhasználói felületén használja.
3. A felhasználó először fér hozzá egy összetevőlaphoz, amely először kéri le a Graph API-adatokat.
4. A rendszer átirányítja a felhasználót az Azure hozzájárulási felhasználói felületére, hogy hozzájáruljon a Graph API-hatókörökhöz.
5. A Rendszer visszaadja a Graph API felhasználói adatait.

Ha azt szeretné, hogy a hatókör kiépítése (a Graph API-hatókörökhöz való hozzájárulás) a kezdeti bejelentkezéskor történjen, adja meg a hatóköröket az MSAL-hitelesítéshez alapértelmezett hozzáférési jogkivonat-hatókörként a Program fájlban:

+ var scopes = builder.Configuration.GetSection("MicrosoftGraph:Scopes")
+     .Get<List<string>>() ?? [ "user.read" ];

builder.Services.AddMsalAuthentication(options =>
{
    builder.Configuration.Bind("AzureAd", options.ProviderOptions.Authentication);

+   foreach (var scope in scopes)
+   {
+       options.ProviderOptions.DefaultAccessTokenScopes.Add(scope);
+   }
});

Fontos

A DefaultAccessTokenScopes versus AdditionalScopesToConsent szakaszban található magyarázatból megtudhatja, hogy az előző kód miért a DefaultAccessTokenScopes elemet használja a hatókörök hozzáadására a AdditionalScopesToConsent helyett.

Amikor az előző módosításokat végrehajtotta az alkalmazáson, a felhasználói folyamat a következő sorrendet alkalmazza:

1. Az új felhasználó először jelentkezik be az alkalmazásba.
2. A felhasználó hozzájárul ahhoz, hogy az alkalmazás és a Graph API hatóköreit az Azure hozzájárulási felhasználói felületén használja.
3. A felhasználó először fér hozzá egy összetevőlaphoz, amely először kéri le a Graph API-adatokat.
4. A Rendszer visszaadja a Graph API felhasználói adatait.

Ha helyileg teszteli a Graph API-t, javasoljuk, hogy minden teszthez használjon egy új InPrivate/inkognitó böngésző-munkamenetet, hogy a cookie-k ne zavarják a tesztelést. További információért lásd: Az ASP.NET Core Blazor WebAssembly önálló alkalmazás biztonságossá tétele a Microsoft Entra IDsegítségével.

Felhasználói jogosultságok testreszabása névvel HttpClient

Az alábbi példában az alkalmazás mobiltelefonszámot és irodahelyi jogcímeket hoz létre a felhasználó számára a ME-ID felhasználói profil adataiból. Az alkalmazásnak konfigurálnia kell a User.Read Graph API-hatókört a ME-ID-ban. A ME-ID-ban található tesztfelhasználói fiókokhoz kötelező megadni a mobiltelefonszámot és az irodai helyszínt. Ezeket az Azure portálon a felhasználói profilokhoz adhatják hozzá.

Ha még nem adta hozzá az osztályt az UserInfo alkalmazáshoz a jelen cikk korábbi útmutatóját követve, adja hozzá a következő osztályt, és jelölje ki a szükséges felhasználói profiltulajdonságokat a JsonPropertyNameAttribute ME-ID által használt attribútummal és JSON-névvel. Az alábbi példa a felhasználó mobiltelefonszámának és irodahelyének tulajdonságait állítja be.

UserInfo.cs:

using System.Text.Json.Serialization;

namespace BlazorSample;

public class UserInfo
{
    [JsonPropertyName("mobilePhone")]
    public string? MobilePhone { get; set; }

    [JsonPropertyName("officeLocation")]
    public string? OfficeLocation { get; set; }
}

Az alábbi egyéni felhasználói fiók-előállítóban:

• A ILogger (logger) az egyszerűség kedvéért szerepel abban az esetben, ha adatokat vagy hibákat szeretne naplózni a CreateUserAsync metódusban.
• Ha egy AccessTokenNotAvailableException kivétel fordul elõ, a rendszer átirányítja a felhasználót az identitásszolgáltatóhoz, hogy bejelentkezzen a fiókjába. A hozzáférési jogkivonat kérése meghiúsulása esetén további vagy eltérő műveletek is végrehajthatók. Az alkalmazás például rögzítheti a AccessTokenNotAvailableException-t, és létrehozhat egy támogatási jegyet a további vizsgálat érdekében.
• A keretrendszer a RemoteUserAccount felhasználó fiókját jelöli. Ha az alkalmazásnak egy egyéni felhasználói fiókosztályra van szüksége, amely kiterjeszti RemoteUserAccount, cserélje le az egyéni felhasználói fiókosztályt RemoteUserAccount-re az alábbi kódban.

CustomAccountFactory.cs:

using System.Net.Http.Json;
using System.Security.Claims;
using Microsoft.AspNetCore.Components.WebAssembly.Authentication;
using Microsoft.AspNetCore.Components.WebAssembly.Authentication.Internal;

public class CustomAccountFactory(IAccessTokenProviderAccessor accessor,
        IHttpClientFactory clientFactory,
        ILogger<CustomAccountFactory> logger)
    : AccountClaimsPrincipalFactory<RemoteUserAccount>(accessor)
{
    private readonly ILogger<CustomAccountFactory> logger = logger;
    private readonly IHttpClientFactory clientFactory = clientFactory;

    public override async ValueTask<ClaimsPrincipal> CreateUserAsync(
        RemoteUserAccount account,
        RemoteAuthenticationUserOptions options)
    {
        var initialUser = await base.CreateUserAsync(account, options);

        if (initialUser.Identity is not null && 
            initialUser.Identity.IsAuthenticated)
        {
            var userIdentity = initialUser.Identity as ClaimsIdentity;

            if (userIdentity is not null)
            {
                try
                {
                    var client = clientFactory.CreateClient("GraphAPI");

                    var userInfo = await client.GetFromJsonAsync<UserInfo>("me");

                    if (userInfo is not null)
                    {
                        userIdentity.AddClaim(new Claim("mobilephone",
                            userInfo.MobilePhone ?? "(000) 000-0000"));
                        userIdentity.AddClaim(new Claim("officelocation",
                            userInfo.OfficeLocation ?? "Not set"));
                    }
                }
                catch (AccessTokenNotAvailableException exception)
                {
                    exception.Redirect();
                }
            }
        }

        return initialUser;
    }
}

Az MSAL-hitelesítés az egyéni felhasználói fiók-gyártó használatára van beállítva. Először győződjön meg arról, hogy a Program fájl a névteret Microsoft.AspNetCore.Components.WebAssembly.Authentication használja:

using Microsoft.AspNetCore.Components.WebAssembly.Authentication;

A Program fájlban keresse meg a AddMsalAuthentication bővítménymetódus hívását. Frissítse a kódot a következőre, amely tartalmaz egy AddAccountClaimsPrincipalFactory hívást, amely hozzáad egy fiókjogcím-felelős gyárat a CustomAccountFactory elemhez.

Ha az alkalmazás egy olyan egyéni felhasználói fiók osztályt használ, amely kiterjeszti a RemoteUserAccount-et, cserélje le az alkalmazás egyéni felhasználói fiók osztályát a RemoteUserAccount-re az alábbi kódban.

builder.Services.AddMsalAuthentication<RemoteAuthenticationState, 
    RemoteUserAccount>(options =>
    {
        builder.Configuration.Bind("AzureAd", 
            options.ProviderOptions.Authentication);
    })
    .AddAccountClaimsPrincipalFactory<RemoteAuthenticationState, RemoteUserAccount, 
        CustomAccountFactory>();

Az előző példa egy olyan alkalmazásra mutat, amely ME-ID MSAL-hitelesítést használ. Hasonló minták léteznek az OIDC- és API-hitelesítéshez. További információért lásd az című cikk Blazor WebAssembly szakaszában található példákat.

A következő UserClaims összetevővel tanulmányozhatja a felhasználó jogcímeit, miután a felhasználó me-id azonosítóval hitelesít:

UserClaims.razor:

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

<h1>User Claims</h1>

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

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

    protected override async Task OnInitializedAsync()
    {
        var authState = await AuthenticationStateProvider
            .GetAuthenticationStateAsync();
        var user = authState.User;

        claims = user.Claims;
    }
}

Hivatkozás hozzáadása az összetevő oldalához az NavMenu összetevőben (Layout/NavMenu.razor):

<div class="nav-item px-3">
    <NavLink class="nav-link" href="user-claims">
        <span class="bi bi-list-nested-nav-menu" aria-hidden="true"></span> User Claims
    </NavLink>
</div>

Ha helyileg teszteli a Graph API-t, javasoljuk, hogy minden teszthez használjon egy új InPrivate/inkognitó böngésző-munkamenetet, hogy a cookie-k ne zavarják a tesztelést. További információért lásd: Az ASP.NET Core Blazor WebAssembly önálló alkalmazás biztonságossá tétele a Microsoft Entra IDsegítségével.

Felhasználók hozzárendelése alkalmazásregisztrációhoz alkalmazásszerepkörökkel vagy anélkül

Felhasználókat adhat hozzá egy alkalmazásregisztrációhoz, és szerepköröket rendelhet hozzá a felhasználókhoz az Alábbi lépésekkel az Azure Portalon.

Felhasználó hozzáadásához válassza a Felhasználók lehetőséget az Azure Portal ME-ID területén:

1. Válassza az Új felhasználó>Új felhasználó létrehozása lehetőséget.
2. Használja a Felhasználói sablon létrehozása parancsot.
3. Adja meg a felhasználó adatait a Identity területen.
4. Létrehozhat egy kezdeti jelszót, vagy hozzárendelhet egy kezdeti jelszót, amelyet a felhasználó az első bejelentkezéskor módosít. Ha a portál által létrehozott jelszót használja, jegyezze fel most.
5. Válassza a Létrehozás lehetőséget a felhasználó létrehozásához. Amikor bezárul az új felhasználói felület létrehozása , válassza a Frissítés lehetőséget a felhasználói lista frissítéséhez és az új felhasználó megjelenítéséhez.
6. A cikkben szereplő példákhoz rendeljen egy mobiltelefonszámot az új felhasználóhoz úgy, hogy kiválasztja a nevét a felhasználók listájából, kiválasztja a Tulajdonságok lehetőséget, és a kapcsolattartási adatokat a mobiltelefonszám megadásához szerkeszti.

Felhasználók hozzárendelése az alkalmazáshoz alkalmazásszerepkörök nélkül:

1. Az Azure Portal ME-ID területén nyissa meg a Nagyvállalati alkalmazásokat.
2. Válassza ki az alkalmazást a listából.
3. Válassza a Felhasználók és csoportok elemet.
4. Válassza a Felhasználó/csoport hozzáadása lehetőséget.
5. Válasszon ki egy felhasználót.
6. Válassza a Hozzárendelés gombot.

Felhasználók hozzárendelése az alkalmazáshoz alkalmazásszerepkörökkel:

1. Szerepkörök hozzáadása az alkalmazás regisztrációhoz az Azure Portalon az ASP.NET Core Blazor WebAssembly és a Microsoft Entra azonosítócsoportokkal és szerepkörökkel kapcsolatos útmutatását követve.
2. Az Azure Portal ME-ID területén nyissa meg a Nagyvállalati alkalmazásokat.
3. Válassza ki az alkalmazást a listából.
4. Válassza a Felhasználók és csoportok elemet.
5. Válassza a Felhasználó/csoport hozzáadása lehetőséget.
6. Válasszon ki egy felhasználót, és válassza ki a szerepkörét az alkalmazás eléréséhez. A rendszer több szerepkört is hozzárendel egy felhasználóhoz úgy, hogy megismétli a felhasználó alkalmazáshoz való hozzáadásának folyamatát, amíg a felhasználó összes szerepköre ki nem van rendelve. A több szerepkörrel rendelkező felhasználók minden hozzárendelt szerepkör esetében egyszer szerepelnek a Felhasználók és az alkalmazás felhasználóinak csoportlistájában.
7. Válassza a Hozzárendelés gombot.

DefaultAccessTokenScopes és AdditionalScopesToConsent

A cikkben szereplő példák a Graph API-hatóköröket a következővel DefaultAccessTokenScopesépítik ki: nem AdditionalScopesToConsent.

AdditionalScopesToConsent nem használható, mert nem tudja kiépíteni a Graph API-hatóköröket a felhasználók számára, amikor első alkalommal jelentkeznek be az alkalmazásba az MSAL használatával az Azure hozzájárulási felhasználói felületén keresztül. Amikor a felhasználó először próbál hozzáférni a Graph API-hoz a Graph SDK-val, kivétellel szembesül:

Microsoft.Graph.Models.ODataErrors.ODataError: Access token is empty.

Miután egy felhasználó elérhetővé teszi a Graph API-hatóköröket DefaultAccessTokenScopes, az alkalmazás felhasználhatja ezeket AdditionalScopesToConsent a következő felhasználói bejelentkezéshez. Az alkalmazáskód módosítása azonban nincs értelme egy olyan éles alkalmazásnak, amely megköveteli az új felhasználók delegált Graph-hatókörökkel való rendszeres hozzáadását vagy új delegált Graph API-hatókörök hozzáadását az alkalmazáshoz.

Az előző vitafórum arról, hogyan építhet ki hatóköröket a Graph API-hozzáféréshez, amikor a felhasználó először jelentkezik be az alkalmazásba, csak a következőkre vonatkozik:

• A Graph SDK-t alkalmazó alkalmazások.
• Alkalmazások, amelyek a Graph API elérésére elnevezett HttpClient-t használnak, és amelyek arra kérik a felhasználókat, hogy az első alkalommal történő bejelentkezéskor járuljanak hozzá a Graph keretekhez.

Nevezett HttpClient használata esetén, amely nem kéri a felhasználóktól, hogy az első bejelentkezéskor hozzájáruljanak a Graph hatókörökhöz, a rendszer átirányítja őket az Azure Graph API hatókörök hozzájárulási felhasználói felületére, amikor először kérnek hozzáférést a Graph API-hoz az DelegatingHandler előre konfigurált, elnevezett HttpClient felületen keresztül. Ha a Graph-hatóköröket kezdetben nem hagyják jóvá a megnevezett HttpClient megközelítéssel, akkor sem DefaultAccessTokenScopes, sem AdditionalScopesToConsent nem kerül meghívásra az alkalmazás által. További információkért tekintse meg a cikkben szereplő elnevezett HttpClient lefedettséget.

További erőforrások

Általános útmutató

• A Microsoft Graph dokumentációja
• Microsoft Graph-mintaalkalmazásBlazor WebAssembly: Ez a minta bemutatja, hogyan érheti el a Microsoft Graph .NET SDK-t az Office 365-ös adatok alkalmazásokból való Blazor WebAssembly eléréséhez.
• .NET-alkalmazások létrehozása Microsoft Graph-oktatóanyaggal és Microsoft Graph-mintaalkalmazással ASP.NET Core-alkalmazással: Bár ezek az erőforrások nem vonatkoznak közvetlenül a Graph ügyféloldaliBlazor WebAssembly alkalmazásokból való meghívására, a csatolt erőforrások ME-ID alkalmazáskonfigurációja és Microsoft Graph-kódolási eljárásai relevánsak az önálló Blazor WebAssembly alkalmazások esetében, és általános ajánlott eljárásokat kell tanulmányozni.

Biztonsági útmutató

• A Microsoft Graph hitelesítésének áttekintése
• A Microsoft Graph-engedélyek áttekintése
• Microsoft Graph-engedélyek – referencia
• Engedélyek és hozzájárulások áttekintése a Microsoft identitásplatformon
• A biztonság növelése a minimális jogosultság elvével
• Azure-jogosultságok eszkalálásával kapcsolatos cikkek az interneten (Google keresési eredmények)
• A Microsoft biztonsági ajánlott eljárásai: A kiemelt hozzáférés védelme