Microsoft Entra-grupper (ME-ID), administratörsroller och app-roller
Viktig
Den här informationen gäller en förhandsversionsprodukt som kan ändras avsevärt innan den släpps kommersiellt. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, med avseende på den information som tillhandahålls här.
Den aktuella versionen finns i den .NET 9-versionen av den här artikeln.
Den här artikeln beskriver hur du konfigurerar Blazor WebAssembly för att använda grupper och roller i Microsoft Entra-ID (ME-ID).
ME-ID innehåller flera auktoriseringsmetoder som kan kombineras med ASP.NET Core Identity:
- Grupper
- Säkerhet
- Microsoft 365
- Fördelning
- Roller
- ME-ID inbyggda administratörsroller
- Applikationsroller
Vägledningen i den här artikeln gäller för de Blazor WebAssembly ME-ID distributionsscenarier som beskrivs i följande artiklar:
Exemplen i den här artikeln drar nytta av nya .NET/C#-funktioner. När du använder exemplen med .NET 7 eller tidigare krävs mindre ändringar. De text- och kodexempel som gäller interaktion med ME-ID och Microsoft Graph är dock desamma för alla versioner av ASP.NET Core.
Exempelapp
Få åtkomst till exempelappen med namnet BlazorWebAssemblyEntraGroupsAndRoles
, via den senaste versionsmappen från lagringsplatsens rot med följande länk. Exemplet tillhandahålls för .NET 8 eller senare. Se exempelappens README
-fil för steg om hur du kör appen.
Exempelappen innehåller en UserClaims
komponent för att visa en användares anspråk. Komponenten UserData
visar användarens grundläggande kontoegenskaper.
Visa eller ladda ned exempelkod (hur du laddar ned)
Förutsättning
Vägledningen i den här artikeln implementerar Microsoft Graph API enligt Graph SDK vägledning i Använda Graph API med ASP.NET Core Blazor WebAssembly. Följ Graph SDK implementeringsvägledning för att konfigurera appen och testa den för att bekräfta att appen kan hämta Graph API-data för ett testanvändarkonto. Se även länkar för säkerhetsartikeln i Graph API-artikeln för att granska säkerhetsbegreppen i Microsoft Graph.
När du testar med Graph SDK lokalt rekommenderar vi att du använder en ny privat/inkognito-webbläsarsession för varje test för att förhindra att kvardröjande cookies stör testerna. Mer information finns i Secure an ASP.NET Core Blazor WebAssembly standalone app with Microsoft Entra ID.
ME-ID onlineverktyg för appregistrering
Den här artikeln refererar till Azure-portalen hela tiden när du uppmanas att konfigurera appens ME-ID appregistrering, men Microsoft Entra Admin Center är också ett bra alternativ för att hantera ME-ID appregistreringar. Båda gränssnitten kan användas, men vägledningen i den här artikeln beskriver särskilt gester för Azure-portalen.
Scope
Behörigheter och omfång betyder samma sak och används synonymt i säkerhetsdokumentation och Azure-portalen. Om inte texten refererar till Azure-portalen använder den här artikeln omfången / när den refererar till Graph-behörigheter.
Scopes är okänsliga för skiftläget, så User.Read
är samma som user.read
. Använd gärna något av formaten, men vi rekommenderar ett konsekvent val i programkoden.
För att tillåta Microsoft Graph API- anrop för användarprofil, rolltilldelning och gruppmedlemskapsdata konfigureras appen med delegeradUser.Read
omfattning (https://graph.microsoft.com/User.Read
) i Azure-portalen eftersom åtkomst till att läsa användardata bestäms av de omfång som beviljas (delegeras) till enskilda användare. Det här omfånget krävs utöver de omfång som krävs i ME-ID distributionsscenarier som beskrivs i artiklarna ovan (fristående med Microsoft-konton eller fristående med ME-ID).
Ytterligare nödvändiga omfång är:
-
Delegerad
RoleManagement.Read.Directory
omfång (https://graph.microsoft.com/RoleManagement.Read.Directory
): Tillåter att appen läser rbac-inställningarna (rollbaserad åtkomstkontroll) för företagets katalog för den inloggade användarens räkning. Detta omfattar läsning av katalogrollmallar, katalogroller och medlemskap. Katalogrollmedlemskap används för att skapadirectoryRole
anspråk i appen för ME-ID inbyggda administratörsroller. Administratörsmedgivande krävs. -
Delegerad
AdministrativeUnit.Read.All
omfång (https://graph.microsoft.com/AdministrativeUnit.Read.All
): Tillåter att appen läser administrativa enheter och administratörsenhetsmedlemskap för den inloggade användarens räkning. Dessa medlemskap används för att skapaadministrativeUnit
krav i appen. Administratörsmedgivande krävs.
Mer information finns i Översikt över behörigheter och medgivande i Microsofts identitetsplattform och Översikt över Microsoft Graph-behörigheter.
Anpassat användarkonto
Tilldela användare till ME-ID säkerhetsgrupper och ME-ID administratörsroller i Azure-portalen.
Exemplen i den här artikeln:
- Anta att en användare har tilldelats rollen ME-ID faktureringsadministratör i Azure-portalen ME-ID klientorganisation för auktorisering för åtkomst till server-API-data.
- Använd auktoriseringsprinciper för att styra åtkomsten i appen.
Utöka RemoteUserAccount för att inkludera egenskaper för:
-
Roles
: arrayen ME-ID Approller (beskrivs i avsnittet Approller) -
Oid
: Oföränderligt objektidentifieraranspråk (oid
) (identifierar unikt en användare inom och mellan tenanter)
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; }
}
Lägg till en paketreferens i appen för Microsoft.Graph
.
Not
Mer information om hur du lägger till paket i .NET-appar finns i artiklarna under Installera och hantera paket på Arbetsflöde för paketförbrukning (NuGet-dokumentation). Bekräfta rätt paketversioner på NuGet.org.
Lägg till Graph SDK-verktygsklasser och konfiguration i Graph SDK vägledning för artikeln Use Graph API with ASP.NET Core Blazor WebAssembly . Ange omfången User.Read
, RoleManagement.Read.Directory
och AdministrativeUnit.Read.All
för åtkomsttoken som visas i artikelns exempel wwwroot/appsettings.json
-fil.
Lägg till följande anpassade användarkontofabrik i appen. Den anpassade användarfabriken används för att upprätta:
Approllsanspråk (
role
) (täckts i avsnittet App Roller).Exempel på användarprofildataanspråk för användarens mobiltelefonnummer (
mobilePhone
) och kontorsplats (officeLocation
).ME-ID Administrator-rollens anspråk (
directoryRole
).ME-ID krav från den administrativa enheten (
administrativeUnit
).ME-ID Gruppens anspråk (
directoryGroup
).En ILogger (
logger
) för enkelhetens skull om du vill logga information eller felmeddelanden.
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;
}
}
Föregående kod:
- Inkluderar inte transitiva medlemskap. Om appen kräver direkta och transitiva gruppmedlemskapsanspråk ersätter du egenskapen
MemberOf
(IUserMemberOfCollectionWithReferencesRequestBuilder
) medTransitiveMemberOf
(IUserTransitiveMemberOfCollectionWithReferencesRequestBuilder
). - Anger GUID-värden i
directoryRole
-anspråk är ME-ID Administratörsroll Mall-ID (Microsoft.Graph.Models.DirectoryRole.RoleTemplateId
). Mall-ID:t är stabila identifierare för att skapa användarauktoriseringsprinciper i appar, som beskrivs senare i den här artikeln. Använd inteentry.Id
för anspråksvärden för katalogroller eftersom de inte är stabila mellan klientorganisationer.
Konfigurera sedan MSAL-autentiseringen så att den använder den anpassade användarkontofabriken.
Bekräfta att Program
-filen använder namnområdet Microsoft.AspNetCore.Components.WebAssembly.Authentication:
using Microsoft.AspNetCore.Components.WebAssembly.Authentication;
Uppdatera AddMsalAuthentication-anropet till följande. Observera att Blazor ramverkets RemoteUserAccount ersätts av appens CustomUserAccount
för MSAL-autentiserings- och kontoanspråkens huvudfabrik:
builder.Services.AddMsalAuthentication<RemoteAuthenticationState,
CustomUserAccount>(options =>
{
builder.Configuration.Bind("AzureAd",
options.ProviderOptions.Authentication);
options.UserOptions.RoleClaim = "role";
})
.AddAccountClaimsPrincipalFactory<RemoteAuthenticationState, CustomUserAccount,
CustomAccountFactory>();
Bekräfta förekomsten av Graph SDK--koden i Program
-filen som beskrivs i artikeln Use Graph API with 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);
Viktig
Bekräfta i appens registrering i Azure-portalen att följande behörigheter har beviljats:
User.Read
-
RoleManagement.Read.Directory
(kräver administratörsmedgivande) -
AdministrativeUnit.Read.All
(kräver administratörsmedgivande)
Bekräfta att wwwroot/appsettings.json
konfigurationen är korrekt enligt Graph SDK vägledning.
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"
]
}
}
Ange värden för följande platshållare från appens ME-ID registrering i Azure-portalen:
-
{TENANT ID}
: GUID-värdet för katalog-ID (klientorganisation). -
{CLIENT ID}
: GUID-värdet för program-ID (klient).
Auktoriseringskonfiguration
Skapa en princip för varje approll (efter rollnamn), ME-ID inbyggd administratörsroll (efter rollmalls-ID/GUID) eller säkerhetsgrupp (efter objekt-ID/GUID) i Program
-filen. I följande exempel skapas en policy för den inbyggda rollen Faktureringsadministratör (ME-ID ):
builder.Services.AddAuthorizationCore(options =>
{
options.AddPolicy("BillingAdministrator", policy =>
policy.RequireClaim("directoryRole",
"b0f54661-2d74-4c50-afa3-1ec803f12efe"));
});
En fullständig lista över ID:er (GUID) för ME-ID administratörsroller finns i Rollmalls-ID i ME-ID-dokumentationen. För ett Azure-säkerhets- eller O365-grupp-ID (GUID) kan du se Objekt-ID för gruppen i Azure-portalen under Grupper-panelen i appens registrering. Mer information om auktoriseringsprinciper finns i Principbaserad auktorisering i ASP.NET Core.
I följande exempel använder appen föregående princip för att auktorisera användaren.
Den AuthorizeView
-komponenten fungerar i enlighet med policyn:
<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>
Åtkomst till en hel komponent kan baseras på principen med hjälp av ett [Authorize]
attributdirektiv (AuthorizeAttribute):
@page "/"
@using Microsoft.AspNetCore.Authorization
@attribute [Authorize(Policy = "BillingAdministrator")]
Om användaren inte har behörighet omdirigeras de till ME-ID inloggningssida.
En principkontroll kan också utföras i kod med procedurlogik.
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.";
}
}
}
Med hjälp av ovanstående metoder kan du också skapa principbaserad åtkomst för säkerhetsgrupper, där GUID:t som används för principen matchar
Applikationsroller
Information om hur du konfigurerar applikationen i Azure-portalen för att tillhandahålla medlemskapsanspråk för App Roller finns i avsnittet Lägg till approller i ditt program och ta emot dem i token i dokumentationen ME-ID.
I följande exempel förutsätts att appen är konfigurerad med två roller och att rollerna tilldelas till en testanvändare:
Admin
Developer
Även om du inte kan tilldela roller till grupper utan ett ME-ID Premium-konto, kan du tilldela roller till användare och ta emot rollanspråk för användare med ett Standard Azure-konto. Vägledningen i det här avsnittet kräver inte ett ME-ID Premium-konto.
Använd någon av följande metoder för att lägga till applikationsroller i ME-ID:
När du arbetar med standardkatalogenföljer du anvisningarna i lägger till approller i ditt program och tar emot dem i token för att skapa roller ME-ID.
Om du inte arbetar med standardkatalogenredigerar du appens manifest i Azure-portalen för att upprätta appens roller manuellt i
appRoles
posten för manifestfilen. Följande är ett exempelappRoles
post som skaparAdmin
ochDeveloper
roller. Dessa exempelroller används senare på komponentnivå för att implementera åtkomstbegränsningar:Viktig
Följande metod rekommenderas endast för appar som inte är registrerade i Azure-kontots standardkatalog. För appar som är registrerade i standardkatalogen, se föregående punkt i den här listan.
"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" } ],
För platshållarna
{ADMIN GUID}
och{DEVELOPER GUID}
i föregående exempel kan du generera GUID:er med en GUID-generator online (Google-sökresultat för "guid generator").
Så här tilldelar du en roll till en användare (eller grupp om du har ett Azure-konto på Premium-nivå):
- Gå till företagsprogram i ME-ID-området i Azure-portalen.
- Välj appen. Välj Hantera>användare och grupper i sidofältet.
- Markera kryssrutan för ett eller flera användarkonton.
- På menyn ovanför listan över användare väljer du Redigera tilldelning.
- För posten Välj en roll väljer du Ingen markerad.
- Välj en roll i listan och använd knappen Välj för att välja den.
- Använd knappen Tilldela längst ned på skärmen för att tilldela rollen.
Flera roller tilldelas i Azure-portalen genom att lägga till en användare för varje ytterligare rolltilldelning. Använd knappen Lägg till användare/grupp överst i listan över användare för att lägga till en användare igen. Använd föregående steg för att tilldela användaren en annan roll. Du kan upprepa den här processen så många gånger som behövs för att lägga till ytterligare roller till en användare (eller grupp).
Det CustomAccountFactory
som visas i avsnittet anpassat användarkonto konfigureras för att agera på ett role
anspråk med ett JSON-matrisvärde. Lägg till och registrera CustomAccountFactory
i appen som du ser i avsnittet Anpassat användarkonto. Du behöver inte ange kod för att ta bort det ursprungliga role
anspråket eftersom det tas bort automatiskt av ramverket.
I filen Program
lägger du till eller bekräftar anspråket med namnet "role
" som rollanspråk för ClaimsPrincipal.IsInRole kontroller:
builder.Services.AddMsalAuthentication(options =>
{
...
options.UserOptions.RoleClaim = "role";
});
Notera
Om du föredrar att använda directoryRoles
-anspråk (Administratörsroller förME-ID), tilldela "directoryRoles
" till RemoteAuthenticationUserOptions.RoleClaim.
När du har slutfört föregående steg för att skapa och tilldela roller till användare (eller grupper om du har ett Azure-konto på Premium-nivå) och implementerat CustomAccountFactory
med Graph SDK, enligt beskrivningen tidigare i den här artikeln och i Använd Graph API med ASP.NET Core Blazor WebAssembly, bör du se ett role
anspråk för varje tilldelad roll som en inloggad användare tilldelas (eller roller som tilldelats till grupper som de är medlemmar i). Kör appen med en testanvändare för att bekräfta att anspråken finns som förväntat. När du testar med Graph SDK lokalt rekommenderar vi att du använder en ny privat/inkognito-webbläsarsession för varje test för att förhindra att kvardröjande cookies stör testerna. För mer information, se Secure an ASP.NET Core Blazor WebAssembly fristående app med Microsoft Entra ID.
Metoderna för komponentauktorisering fungerar just nu. Någon av auktoriseringsmekanismerna i appens komponenter kan använda rollen Admin
för att auktorisera användaren:
-
<AuthorizeView Roles="Admin">
[Authorize]
attributdirektiv (AuthorizeAttribute)@attribute [Authorize(Roles = "Admin")]
-
var authState = await AuthenticationStateProvider.GetAuthenticationStateAsync(); var user = authState.User; if (user.IsInRole("Admin")) { ... }
Flera rolltester stöds:
Kräv att användaren finns i antingen rollen
Admin
ellerDeveloper
med komponentenAuthorizeView
:<AuthorizeView Roles="Admin, Developer"> ... </AuthorizeView>
Kräv att användaren finns i rollerna både och
Admin
ochDeveloper
med komponentenAuthorizeView
.<AuthorizeView Roles="Admin"> <AuthorizeView Roles="Developer" Context="innerContext"> ... </AuthorizeView> </AuthorizeView>
Mer information om
Context
för den inre AuthorizeViewfinns i ASP.NET Core Blazor-autentisering och auktorisering.Kräv att användaren finns i antingen rollen
Admin
ellerDeveloper
med attributet[Authorize]
:@attribute [Authorize(Roles = "Admin, Developer")]
Kräv att användaren finns i både rollerna
Admin
ochDeveloper
med attributet[Authorize]
:@attribute [Authorize(Roles = "Admin")] @attribute [Authorize(Roles = "Developer")]
Kräv att användaren finns i antingen
Admin
ellerDeveloper
roll med procedurkod:@code { private async Task DoSomething() { var authState = await AuthenticationStateProvider .GetAuthenticationStateAsync(); var user = authState.User; if (user.IsInRole("Admin") || user.IsInRole("Developer")) { ... } else { ... } } }
Kräv att användaren finns i både rollerna
Admin
ochDeveloper
med procedurkod genom att ändra villkorsstyrda ELLER (||
) till en villkorsstyrd AND (&&
) i föregående exempel:if (user.IsInRole("Admin") && user.IsInRole("Developer"))
Flera rolltester stöds:
Kräv att användaren finns i antingen rollen
Admin
ellerDeveloper
med attributet[Authorize]
:[Authorize(Roles = "Admin, Developer")]
Kräv att användaren är i både i-rollerna
Admin
ochDeveloper
med attributet[Authorize]
.[Authorize(Roles = "Admin")] [Authorize(Roles = "Developer")]
Kräv att användaren finns i antingen
Admin
ellerDeveloper
roll med procedurkod: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 ... }
Kräv att användaren finns i både rollerna
Admin
ochDeveloper
med procedurkod genom att ändra villkorsstyrda ELLER (||
) till en villkorsstyrd OCH (&&
) i föregående exempel.if (User.IsInRole("Admin") && User.IsInRole("Developer"))
Eftersom .NET-strängjämförelser är skiftlägeskänsliga är matchande rollnamn också skiftlägeskänsliga. Till exempel behandlas Admin
(stora bokstäver A
) inte som samma roll som admin
(små bokstäver a
).
Pascal-fallet används vanligtvis för rollnamn (till exempel BillingAdministrator
), men användningen av Pascal-fallet är inte ett strikt krav. Olika höljescheman, till exempel kamelfodring, kebabfodring och ormfodring, är tillåtna. Att använda blanksteg i rollnamn är också ovanligt men tillåtet. Till exempel är billing administrator
ett ovanligt rollnamnsformat i .NET-appar men giltigt.
Ytterligare resurser
- Rollmall-ID:n (ME-ID dokumentation)
-
groupMembershipClaims
attribut (ME-ID dokumentation) - Lägg till applikationsroller i din applikation och ta emot dem i en token (ME-ID dokumentation)
- Programroller (Azure-dokumentation)
- anspråksbaserad auktorisering i ASP.NET Core
- Rollbaserad auktorisering i ASP.NET Core
- ASP.NET Core Blazor-autentisering och auktorisering
ASP.NET Core