Skupiny Microsoft Entra (ME-ID), role správce a role aplikací

Článek
11/06/2024

Tento článek vysvětluje, jak nakonfigurovat Blazor WebAssembly použití skupin a rolí Microsoft Entra ID (ME-ID).

ME-ID poskytuje několik přístupů autorizace, které je možné kombinovat s ASP.NET Core Identity:

Skupiny
- Zabezpečení
- Microsoft 365
- Distribuce
Role
- Předdefinované role správce ME-ID
- Aplikační role

Pokyny v tomto článku se týkají Blazor WebAssembly scénářů nasazení ME-ID popsaných v následujících článcích:

Příklady v tomto článku využívají nové funkce .NET/C#. Při použití příkladů s .NET 7 nebo staršími jsou vyžadovány menší úpravy. Příklady textu a kódu, které se týkají interakce s ME-ID a Microsoft Graphem, jsou ale stejné pro všechny verze ASP.NET Core.

Ukázková aplikace

Přejděte k ukázkové aplikaci s názvem BlazorWebAssemblyEntraGroupsAndRoles, prostřednictvím složky nejnovější verze z kořenového adresáře úložiště s následujícím odkazem. Ukázka je k dispozici pro .NET 8 nebo novější. Postup spuštění aplikace najdete v souboru ukázkové aplikace README .

Ukázková aplikace obsahuje komponentu UserClaims pro zobrazení deklarací identity uživatele. Komponenta UserData zobrazí základní vlastnosti účtu uživatele.

Zobrazení nebo stažení ukázkového kódu (postup stažení)

Požadavek

Pokyny v tomto článku implementují rozhraní Microsoft Graph API podle pokynů sady Graph SDK při použití rozhraní Graph API s ASP.NET Core Blazor WebAssembly. Podle pokynů k implementaci sady Graph SDK nakonfigurujte aplikaci a otestujte ji a ověřte, že aplikace může získat data rozhraní Graph API pro testovací uživatelský účet. Další informace najdete v článku o zabezpečení v článku o rozhraní Graph API, kde najdete křížové odkazy na koncepty zabezpečení Microsoft Graphu.

Při místním testování pomocí sady Graph SDK doporučujeme pro každý test použít novou relaci prohlížeče v privátním nebo anonymním režimu, aby se zabránilo zasahování souborů cookie do souborů cookie. Další informace najdete v tématu Zabezpečení samostatné aplikace ASP.NET Core Blazor WebAssembly pomocí Microsoft Entra ID.

Online nástroje pro registraci aplikace ME-ID

Tento článek se týká webu Azure Portal po zobrazení výzvy ke konfiguraci registrace aplikace ME-ID, ale Centrum pro správu Microsoft Entra je také možností správy registrací aplikací ME-ID. Můžete použít buď rozhraní, ale pokyny v tomto článku se týkají gest na webu Azure Portal.

Rozsahy

Oprávnění a obory znamenají totéž a používají se zaměnitelně v dokumentaci k zabezpečení a na webu Azure Portal. Pokud text odkazuje na web Azure Portal, tento článek při odkazech na oprávnění Graphu používá obory oborů/.

Obory nerozlišují malá a velká písmena, takže User.Read jsou stejné jako user.read. Nebojte se použít některý z formátů, ale doporučujeme konzistentní volbu napříč kódem aplikace.

Aby bylo možné povolit volání rozhraní Microsoft Graph API pro profil uživatele, přiřazení rolí a data členství ve skupinách, je aplikace nakonfigurovaná s delegovaným User.Read oborem (https://graph.microsoft.com/User.Read) na webu Azure Portal, protože přístup ke čtení uživatelských dat je určený obory udělenými (delegovaným) jednotlivým uživatelům. Tento obor se vyžaduje kromě oborů požadovaných ve scénářích nasazení ME-ID popsaných výše uvedenými články (samostatně s účty Microsoft nebo samostatně s ME-ID).

Mezi další požadované obory patří:

DelegovanýRoleManagement.Read.Directory obor (https://graph.microsoft.com/RoleManagement.Read.Directory): Umožňuje aplikaci číst nastavení řízení přístupu na základě role (RBAC) pro adresář vaší společnosti jménem přihlášeného uživatele. To zahrnuje čtení šablon rolí adresáře, rolí adresáře a členství. Členství v rolích adresáře se používají k vytváření directoryRole deklarací identity v aplikaci pro předdefinované role správce ME-ID. Vyžaduje se souhlas správce.
DelegovanýAdministrativeUnit.Read.All obor (https://graph.microsoft.com/AdministrativeUnit.Read.All): Umožňuje aplikaci číst jednotky pro správu a členství v jednotce správy jménem přihlášeného uživatele. Tato členství slouží k vytváření administrativeUnit deklarací identity v aplikaci. Vyžaduje se souhlas správce.

Další informace najdete v tématu Přehled oprávnění a souhlasu na platformě Microsoftu identity a přehled oprávnění Microsoft Graphu.

Vlastní uživatelský účet

Přiřaďte uživatele ke skupinám zabezpečení ME-ID a rolím správce ME-ID na webu Azure Portal.

Příklady v tomto článku:

Předpokládejme, že je uživatel přiřazen k roli správce fakturace ME-ID na webu Azure Portal pro autorizaci pro přístup k datům rozhraní API serveru.
Pomocí zásad autorizace můžete řídit přístup v aplikaci.

Rozšířit RemoteUserAccount na zahrnutí vlastností pro:

Roles: Pole role aplikací ME-ID (probírané v části Role aplikací)
Oid: Deklarace identity identifikátoru neměnného objektu () (oidjedinečně identifikuje uživatele v rámci tenantů a napříč tenanty)

CustomUserAccount.cs:

using System.Text.Json.Serialization;
using Microsoft.AspNetCore.Components.WebAssembly.Authentication;

namespace BlazorWebAssemblyEntraGroupsAndRoles;

public class CustomUserAccount : RemoteUserAccount
{
    [JsonPropertyName("roles")]
    public List<string>? Roles { get; set; }

    [JsonPropertyName("oid")]
    public string? Oid { get; set; }
}

Přidání odkazu na balíček do aplikace pro Microsoft.Graph.

Poznámka:

Pokyny k přidávání balíčků do aplikací .NET najdete v článcích v části Instalace a správa balíčků na webu Pracovní postup používání balíčků (dokumentace k NuGetu). Ověřte správné verze balíčků na NuGet.org.

Přidejte třídy a konfiguraci sady Graph SDK v pokynech sady Graph SDK k rozhraní Graph API s článkem ASP.NET CoreBlazor WebAssembly. User.ReadRoleManagement.Read.DirectoryZadejte obory a AdministrativeUnit.Read.All obory přístupového tokenu, jak ukazuje článek v ukázkovém wwwroot/appsettings.json souboru.

Do aplikace přidejte následující objekt pro vytváření vlastních uživatelských účtů. Vlastní uživatelská továrna se používá k vytvoření:

Deklarace identity rolí aplikací () (roleprobírané v části Role aplikací)
Příklad deklarací identity dat profilu uživatele pro mobilní telefonní číslo (mobilePhone) a umístění kanceláře (officeLocation).
Deklarace identity role správce ME-ID (directoryRole).
Deklarace identity jednotek správy ME-ID (administrativeUnitMe-ID Administrative Unit).
Deklarace identity skupiny ME-ID (directoryGroup).
(ILoggerlogger) pro usnadnění v případě, že chcete protokolovat informace nebo chyby.

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;

namespace BlazorWebAssemblyEntraGroupsAndRoles;

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

    public override async ValueTask<ClaimsPrincipal> CreateUserAsync(
        CustomUserAccount 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) &&
                account.Oid is not null)
            {
                account?.Roles?.ForEach((role) =>
                {
                    userIdentity.AddClaim(new Claim("role", role));
                });

                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"));
                    }

                    var memberOf = client.Users[account?.Oid].MemberOf;

                    var graphDirectoryRoles = await memberOf.GraphDirectoryRole.GetAsync();

                    if (graphDirectoryRoles?.Value is not null)
                    {
                        foreach (var entry in graphDirectoryRoles.Value)
                        {
                            if (entry.RoleTemplateId is not null)
                            {
                                userIdentity.AddClaim(
                                    new Claim("directoryRole", entry.RoleTemplateId));
                            }
                        }
                    }

                    var graphAdministrativeUnits = await memberOf.GraphAdministrativeUnit.GetAsync();

                    if (graphAdministrativeUnits?.Value is not null)
                    {
                        foreach (var entry in graphAdministrativeUnits.Value)
                        {
                            if (entry.Id is not null)
                            {
                                userIdentity.AddClaim(
                                    new Claim("administrativeUnit", entry.Id));
                            }
                        }
                    }

                    var graphGroups = await memberOf.GraphGroup.GetAsync();

                    if (graphGroups?.Value is not null)
                    {
                        foreach (var entry in graphGroups.Value)
                        {
                            if (entry.Id is not null)
                            {
                                userIdentity.AddClaim(
                                    new Claim("directoryGroup", entry.Id));
                            }
                        }
                    }
                }
                catch (AccessTokenNotAvailableException exception)
                {
                    exception.Redirect();
                }
            }
        }

        return initialUser;
    }
}

Předchozí kód:

Nezahrnuje tranzitivní členství. Pokud aplikace vyžaduje přímé a přechodné deklarace členství ve skupinách, nahraďte MemberOf vlastnost (IUserMemberOfCollectionWithReferencesRequestBuilder) (TransitiveMemberOfIUserTransitiveMemberOfCollectionWithReferencesRequestBuilder).
Nastaví hodnoty GUID v directoryRole deklarací identity jsou ID šablon rolí správce ME-ID (Microsoft.Graph.Models.DirectoryRole.RoleTemplateId). ID šablon jsou stabilní identifikátory pro vytváření zásad autorizace uživatelů v aplikacích, které jsou popsané dále v tomto článku. Nepoužívejte entry.Id pro hodnoty deklarací role adresáře, protože nejsou stabilní v rámci tenantů.

Dále nakonfigurujte ověřování MSAL tak, aby používalo vlastní objekt pro vytváření uživatelských účtů.

Ověřte, že Program soubor používá Microsoft.AspNetCore.Components.WebAssembly.Authentication obor názvů:

using Microsoft.AspNetCore.Components.WebAssembly.Authentication;

Aktualizujte AddMsalAuthentication volání následujícím kódem. Všimněte si, že Blazor architektura RemoteUserAccount je nahrazena aplikací CustomUserAccount pro ověřování MSAL a objekt pro vytváření deklarací identity účtů:

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

Ověřte přítomnost kódu sady Graph SDK v Program souboru popsaném rozhraním Graph API s článkem ASP.NET Core Blazor WebAssembly :

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

Důležité

Ověřte v registraci aplikace na webu Azure Portal, že jsou udělena následující oprávnění:

User.Read
RoleManagement.Read.Directory (Vyžaduje souhlas správce)
AdministrativeUnit.Read.All (Vyžaduje souhlas správce)

Ověřte správnost wwwroot/appsettings.json konfigurace podle pokynů sady Graph SDK .

wwwroot/appsettings.json:

{
  "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",
      "RoleManagement.Read.Directory",
      "AdministrativeUnit.Read.All"
    ]
  }
}

Zadejte hodnoty pro následující zástupné symboly z registrace ME-ID aplikace na webu Azure Portal:

{TENANT ID}: Hodnota GUID ID adresáře (tenanta).
{CLIENT ID}: Hodnota GUID ID aplikace (klienta).

Konfigurace autorizace

Vytvořte zásadu pro každou roli aplikace (podle názvu role), předdefinované role správce ME (podle ID šablony role nebo GUID) nebo skupiny zabezpečení (podle ID objektu nebo GUID) v Program souboru. Následující příklad vytvoří zásadu pro předdefinované role správce fakturace ME-ID:

builder.Services.AddAuthorizationCore(options =>
{
    options.AddPolicy("BillingAdministrator", policy => 
        policy.RequireClaim("directoryRole", 
            "b0f54661-2d74-4c50-afa3-1ec803f12efe"));
});

Úplný seznam ID (GUID) pro role správce ME-ID najdete v dokumentaci k šablonám rolí. Id skupiny Azure nebo ID skupiny O365 najdete v podokně Skupiny na webu Azure Portal v registraci aplikace. Další informace o zásadách autorizace najdete v tématu Autorizace na základě zásad v ASP.NET Core.

V následujících příkladech aplikace používá předchozí zásady k autorizaci uživatele.

Komponenta AuthorizeView funguje se zásadami:

<AuthorizeView Policy="BillingAdministrator">
    <Authorized>
        <p>
            The user is in the 'Billing Administrator' ME-ID Administrator Role
            and can see this content.
        </p>
    </Authorized>
    <NotAuthorized>
        <p>
            The user is NOT in the 'Billing Administrator' role and sees this
            content.
        </p>
    </NotAuthorized>
</AuthorizeView>

Přístup k celé komponentě může být založený na zásadě pomocí direktivy atributu[Authorize] (AuthorizeAttribute):

@page "/"
@using Microsoft.AspNetCore.Authorization
@attribute [Authorize(Policy = "BillingAdministrator")]

Pokud uživatel nemá oprávnění, přesměruje se na přihlašovací stránku ME-ID.

Kontrolu zásad je možné provést také v kódu s procedurální logikou.

CheckPolicy.razor:

@page "/checkpolicy"
@using Microsoft.AspNetCore.Authorization
@inject IAuthorizationService AuthorizationService

<h1>Check Policy</h1>

<p>This component checks a policy in code.</p>

<button @onclick="CheckPolicy">Check 'BillingAdministrator' policy</button>

<p>Policy Message: @policyMessage</p>

@code {
    private string policyMessage = "Check hasn't been made yet.";

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

    private async Task CheckPolicy()
    {
        var user = (await authenticationStateTask).User;

        if ((await AuthorizationService.AuthorizeAsync(user, 
            "BillingAdministrator")).Succeeded)
        {
            policyMessage = "Yes! The 'BillingAdministrator' policy is met.";
        }
        else
        {
            policyMessage = "No! 'BillingAdministrator' policy is NOT met.";
        }
    }
}

Pomocí předchozích přístupů můžete také vytvořit přístup založený na zásadách pro skupiny zabezpečení, kde identifikátor GUID použitý pro zásadu odpovídá

Aplikační role

Pokud chcete aplikaci nakonfigurovat na webu Azure Portal tak, aby poskytovala deklarace identity členství v rolích aplikací, přečtěte si téma Přidání rolí aplikace do vaší aplikace a jejich příjem v tokenu v dokumentaci k ME-ID.

Následující příklad předpokládá, že aplikace je nakonfigurovaná se dvěma rolemi a role jsou přiřazeny testovacímu uživateli:

Admin
Developer

I když nemůžete přiřadit role skupinám bez účtu ME-ID Premium, můžete přiřadit role uživatelům a přijímat deklarace rolí pro uživatele se standardním účtem Azure. Pokyny v této části nevyžadují účet ME-ID Premium.

Pomocí některého z následujících přístupů přidejte role aplikací do ME-ID:

Při práci s výchozím adresářem postupujte podle pokynů v tématu Přidání rolí aplikace do aplikace a jejich přijetí v tokenu a vytvořte role ME-ID.
Pokud nepracujete s výchozím adresářem, upravte manifest aplikace na webu Azure Portal a nastavte role aplikace ručně v appRoles položce souboru manifestu. Následuje příklad appRoles položky, která vytvoří Admin a Developer role. Tyto ukázkové role se později používají na úrovni komponenty k implementaci omezení přístupu:

Důležité

Následující přístup se doporučuje jenom pro aplikace, které nejsou zaregistrované ve výchozím adresáři účtu Azure. U aplikací registrovaných ve výchozím adresáři se podívejte na předchozí odrážku tohoto seznamu.
```
"appRoles": [
  {
    "allowedMemberTypes": [
      "User"
    ],
    "description": "Administrators manage developers.",
    "displayName": "Admin",
    "id": "{ADMIN GUID}",
    "isEnabled": true,
    "lang": null,
    "origin": "Application",
    "value": "Admin"
  },
  {
    "allowedMemberTypes": [
      "User"
    ],
    "description": "Developers write code.",
    "displayName": "Developer",
    "id": "{DEVELOPER GUID}",
    "isEnabled": true,
    "lang": null,
    "origin": "Application",
    "value": "Developer"
  }
],
```
{ADMIN GUID} Pro zástupné {DEVELOPER GUID} symboly a zástupné symboly v předchozím příkladu můžete vygenerovat identifikátory GUID pomocí online generátoru GUID (výsledek hledání Google pro "generátor guid").

Přiřazení role uživateli (nebo skupině, pokud máte účet Azure úrovně Premium):

V oblasti ME-ID webu Azure Portal přejděte k podnikovým aplikacím.
Vyberte aplikaci. Na bočním panelu vyberte Spravovat>uživatele a skupiny.
Zaškrtněte políčko u jednoho nebo více uživatelských účtů.
V nabídce nad seznamem uživatelů vyberte Upravit přiřazení.
U položky Vybrat roli vyberte Možnost Žádný.
V seznamu zvolte roli a pomocí tlačítka Vybrat ji vyberte.
K přiřazení role použijte tlačítko Přiřadit v dolní části obrazovky.

Více rolí se přiřazuje na webu Azure Portal opětovným přidáním uživatele pro každé další přiřazení role. K opětovnému přidání uživatele použijte tlačítko Přidat uživatele nebo skupinu v horní části seznamu uživatelů. Pomocí předchozích kroků přiřaďte uživateli jinou roli. Tento proces můžete opakovat tolikrát, kolikrát je potřeba k přidání dalších rolí uživateli (nebo skupině).

Zobrazený CustomAccountFactory v části Vlastní uživatelský účet je nastavený tak, aby fungoval s role deklarací identity s hodnotou pole JSON. Přidejte a zaregistrujte CustomAccountFactory aplikaci, jak je znázorněno v části Vlastní uživatelský účet . Není nutné zadávat kód pro odebrání původní role deklarace identity, protože se automaticky odebere rozhraním.

Program V souboru přidejte nebo potvrďte deklaraci identity s názvem "role" jako deklaraci identity role pro ClaimsPrincipal.IsInRole kontroly:

builder.Services.AddMsalAuthentication(options =>
{
    ...

    options.UserOptions.RoleClaim = "role";
});

Poznámka:

Pokud raději používáte directoryRoles deklaraci identity (role správce ME-ID), přiřaďte mu RemoteAuthenticationUserOptions.RoleClaim"directoryRoles" .

Po dokončení předchozích kroků pro vytváření a přiřazování rolí uživatelům (nebo skupinám, pokud máte účet Azure úrovně Premium) a implementovali CustomAccountFactory ho se sadou Graph SDK, jak je vysvětleno výše v tomto článku a použití rozhraní Graph API s ASP.NET Core Blazor WebAssembly, byste měli vidět role deklaraci identity pro každou přiřazenou roli, kterou má přiřazený přihlášený uživatel (nebo role přiřazené skupinám, kterých jsou členy). Spusťte aplikaci s testovacím uživatelem a ověřte, že deklarace identity existují podle očekávání. Při místním testování pomocí sady Graph SDK doporučujeme pro každý test použít novou relaci prohlížeče v privátním nebo anonymním režimu, aby se zabránilo zasahování souborů cookie do souborů cookie. Další informace najdete v tématu Zabezpečení samostatné aplikace ASP.NET Core Blazor WebAssembly pomocí Microsoft Entra ID.

Přístupy k autorizaci komponent jsou v tomto okamžiku funkční. Jakýkoli z mechanismů autorizace v komponentách aplikace může tuto roli použít Admin k autorizaci uživatele:

AuthorizeView komponenta
```
<AuthorizeView Roles="Admin">
```
[Authorize] attribute – direktiva (AuthorizeAttribute)
```
@attribute [Authorize(Roles = "Admin")]
```

Procedurální logika

var authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
var user = authState.User;

if (user.IsInRole("Admin")) { ... }

Podporuje se více testů rolí:

Vyžadovat, aby byl uživatel v komponentě Admin AuthorizeView nebo Developer v roli:
```
<AuthorizeView Roles="Admin, Developer">
    ...
</AuthorizeView>
```
Vyžadovat, aby byl uživatel v komponentě Admin i Developer v rolíchAuthorizeView:
```
<AuthorizeView Roles="Admin">
    <AuthorizeView Roles="Developer" Context="innerContext">
        ...
    </AuthorizeView>
</AuthorizeView>
```
Další informace o Context vnitřní AuthorizeViewčásti najdete v tématu ASP.NET Ověřování a autorizace jádraBlazor.
Vyžadovat, aby byl uživatel v atributu Admin [Authorize] nebo Developer v roli:
```
@attribute [Authorize(Roles = "Admin, Developer")]
```

Vyžadovat, aby byl uživatel v atributu Admin [Authorize] i Developer v rolích:

@attribute [Authorize(Roles = "Admin")]
@attribute [Authorize(Roles = "Developer")]

Vyžadovat, aby byl uživatel v procedurálním kódu nebo Developer v Admin roli:

@code {
    private async Task DoSomething()
    {
        var authState = await AuthenticationStateProvider
            .GetAuthenticationStateAsync();
        var user = authState.User;

        if (user.IsInRole("Admin") || user.IsInRole("Developer"))
        {
            ...
        }
        else
        {
            ...
        }
    }
}

Vyžadovat, aby byl uživatel v procedurálním kódu jak Admin Developer v rolích, tak změnou podmíněného operátoru OR (||) na podmíněný operátor AND (&&) v předchozím příkladu:
```
if (user.IsInRole("Admin") && user.IsInRole("Developer"))
```

Podporuje se více testů rolí:

Vyžadovat, aby byl uživatel v atributu Admin [Authorize] nebo Developer v roli:
```
[Authorize(Roles = "Admin, Developer")]
```
Vyžadovat, aby byl uživatel v atributu Admin [Authorize] i Developer v rolích:
```
[Authorize(Roles = "Admin")]
[Authorize(Roles = "Developer")]
```

Vyžadovat, aby byl uživatel v procedurálním kódu nebo Developer v Admin roli:

static readonly string[] scopeRequiredByApi = new string[] { "API.Access" };

...

[HttpGet]
public IEnumerable<ReturnType> Get()
{
    HttpContext.VerifyUserHasAnyAcceptedScope(scopeRequiredByApi);

    if (User.IsInRole("Admin") || User.IsInRole("Developer"))
    {
        ...
    }
    else
    {
        ...
    }

    return ...
}

Vyžadovat, aby byl uživatel v procedurálním kódu jak Admin Developer v rolích, tak změnou podmíněného operátoru OR (||) na podmíněný operátor AND (&&) v předchozím příkladu:
```
if (User.IsInRole("Admin") && User.IsInRole("Developer"))
```

Vzhledem k tomu, že porovnávání řetězců .NET rozlišují malá a velká písmena, rozlišují se také odpovídající názvy rolí. Například Admin (velkáA) není považována za stejnou roli jako admin (malá).a

Písmena Pascal se obvykle používají pro názvy rolí (například BillingAdministrator), ale použití případu Pascal není striktní požadavek. Jsou povolena různá schémata, jako jsou velbloudí případ, případ kebabu a hadí případ. Použití mezer v názvech rolí je také neobvyklé, ale povolené. Jedná se například billing administrator o neobvyklý formát názvu role v aplikacích .NET, ale je platný.

Sdílet prostřednictvím

Skupiny Microsoft Entra (ME-ID), role správce a role aplikací

Ukázková aplikace

Požadavek

Online nástroje pro registraci aplikace ME-ID

Rozsahy

Vlastní uživatelský účet

Konfigurace autorizace

Aplikační role

Další materiály

Další materiály