Grup Microsoft Entra (ME-ID), Peran Administrator, dan Peran Aplikasi

Artikel
11/06/2024

Artikel ini menjelaskan cara mengonfigurasi Blazor WebAssembly untuk menggunakan grup dan peran Microsoft Entra ID (ME-ID).

ME-ID menyediakan beberapa pendekatan otorisasi yang dapat dikombinasikan dengan ASP.NET Core Identity:

Kelompok
- Keamanan
- Microsoft 365
- Distribusi
Peran
- Peran Administrator bawaan ME-ID
- Peran aplikasi

Panduan dalam artikel ini berlaku untuk Blazor WebAssembly skenario penyebaran ME-ID yang dijelaskan dalam artikel berikut:

Contoh dalam artikel ini memanfaatkan fitur .NET/C# baru. Saat menggunakan contoh dengan .NET 7 atau yang lebih lama, modifikasi kecil diperlukan. Namun, contoh teks dan kode yang berkaitan dengan berinteraksi dengan ME-ID dan Microsoft Graph sama untuk semua versi ASP.NET Core.

Aplikasi sampel

Akses aplikasi sampel, bernama BlazorWebAssemblyEntraGroupsAndRoles, melalui folder versi terbaru dari akar repositori dengan tautan berikut. Sampel disediakan untuk .NET 8 atau yang lebih baru. Lihat file aplikasi README sampel untuk langkah-langkah tentang cara menjalankan aplikasi.

Aplikasi sampel menyertakan UserClaims komponen untuk menampilkan klaim pengguna. Komponen UserData menampilkan properti akun dasar pengguna.

Melihat atau mengunduh kode sampel (cara mengunduh)

Prasyarat

Panduan dalam artikel ini mengimplementasikan Microsoft Graph API per panduan Graph SDK dalam Menggunakan Graph API dengan ASP.NET Core Blazor WebAssembly. Ikuti panduan implementasi Graph SDK untuk mengonfigurasi aplikasi dan mengujinya untuk mengonfirmasi bahwa aplikasi dapat memperoleh data Graph API untuk akun pengguna uji. Selain itu, lihat artikel keamanan api Graph artikel lintas tautan untuk meninjau konsep keamanan Microsoft Graph.

Saat menguji dengan Graph SDK secara lokal, sebaiknya gunakan sesi browser in-private/incognito baru untuk setiap pengujian untuk mencegah cookie yang berlama-lama mengganggu pengujian. Untuk informasi selengkapnya, lihat Mengamankan aplikasi mandiri ASP.NET Core Blazor WebAssembly dengan ID Microsoft Entra.

Alat online pendaftaran aplikasi ME-ID

Artikel ini mengacu pada portal Azure di seluruh saat meminta Anda untuk mengonfigurasi pendaftaran aplikasi ME-ID aplikasi, tetapi Pusat Admin Microsoft Entra juga merupakan opsi yang layak untuk mengelola pendaftaran aplikasi ME-ID. Salah satu antarmuka dapat digunakan, tetapi panduan dalam artikel ini secara khusus mencakup gerakan untuk portal Azure.

Cakupan

Izin dan cakupan berarti hal yang sama dan digunakan secara bergantian dalam dokumentasi keamanan dan portal Azure. Kecuali teks mengacu pada portal Azure, artikel ini menggunakan cakupan/ saat merujuk ke izin Grafik.

Cakupan tidak peka huruf besar/kecil, jadi User.Read sama user.readdengan . Jangan ragu untuk menggunakan salah satu format, tetapi kami merekomendasikan pilihan yang konsisten di seluruh kode aplikasi.

Untuk mengizinkan panggilan Microsoft Graph API untuk profil pengguna, penetapan peran, dan data keanggotaan grup, aplikasi dikonfigurasi dengan cakupan yang didelegasikan User.Read (https://graph.microsoft.com/User.Read) di portal Azure karena akses untuk membaca data pengguna ditentukan oleh cakupan yang diberikan (didelegasikan) kepada pengguna individual. Cakupan ini diperlukan selain cakupan yang diperlukan dalam skenario penyebaran ME-ID yang dijelaskan oleh artikel yang tercantum sebelumnya (Mandiri dengan Akun Microsoft atau Mandiri dengan ME-ID).

Cakupan tambahan yang diperlukan meliputi:

Cakupan yang didelegasikanRoleManagement.Read.Directory (https://graph.microsoft.com/RoleManagement.Read.Directory): Memungkinkan aplikasi membaca pengaturan kontrol akses berbasis peran (RBAC) untuk direktori perusahaan Anda, atas nama pengguna yang masuk. Ini termasuk membaca templat peran direktori, peran direktori, dan keanggotaan. Keanggotaan peran direktori digunakan untuk membuat directoryRole klaim di aplikasi untuk Peran Administrator bawaan ME-ID. Persetujuan admin diperlukan.
Cakupan yang didelegasikanAdministrativeUnit.Read.All (https://graph.microsoft.com/AdministrativeUnit.Read.All): Memungkinkan aplikasi membaca unit administratif dan keanggotaan unit administratif atas nama pengguna yang masuk. Keanggotaan ini digunakan untuk membuat administrativeUnit klaim di aplikasi. Persetujuan admin diperlukan.

Untuk informasi selengkapnya, lihat Gambaran Umum izin dan persetujuan di platform Microsoft identity dan Gambaran Umum izin Microsoft Graph.

Akun pengguna kustom

Tetapkan pengguna ke grup keamanan ME-ID dan Peran Administrator ME-ID di portal Azure.

Contoh dalam artikel ini:

Asumsikan bahwa pengguna ditetapkan ke peran Administrator Penagihan ME-ID di penyewa ME-ID portal Azure untuk otorisasi guna mengakses data API server.
Gunakan kebijakan otorisasi untuk mengontrol akses dalam aplikasi.

Perluas RemoteUserAccount untuk menyertakan properti untuk:

Roles: Array Peran Aplikasi ME-ID (tercakup di bagian Peran Aplikasi)
Oid: Klaim pengidentifikasi objek yang tidak dapat diubah (oid) (secara unik mengidentifikasi pengguna di dalam dan di seluruh penyewa)

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

Tambahkan referensi paket ke aplikasi untuk Microsoft.Graph.

Catatan

Untuk panduan tentang menambahkan paket ke aplikasi .NET, lihat artikel di bagian Menginstal dan mengelola paket di Alur kerja konsumsi paket (dokumentasi NuGet). Konfirmasikan versi paket yang benar di NuGet.org.

Tambahkan kelas dan konfigurasi utilitas Graph SDK dalam panduan Graph SDK dari artikel Gunakan Graph API dengan ASP.NET Core Blazor WebAssembly . User.ReadTentukan cakupan , RoleManagement.Read.Directory, dan AdministrativeUnit.Read.All untuk token akses seperti yang ditunjukkan artikel dalam file contohnyawwwroot/appsettings.json.

Tambahkan pabrik akun pengguna kustom berikut ke aplikasi. Pabrik pengguna kustom digunakan untuk membuat:

Klaim Peran Aplikasi (role) (tercakup di bagian Peran Aplikasi).
Contoh klaim data profil pengguna untuk nomor ponsel pengguna (mobilePhone) dan lokasi kantor (officeLocation).
Klaim Peran Administrator ME-ID (directoryRole).
Klaim Unit Administratif ME-ID (administrativeUnit).
Klaim Grup ME-ID (directoryGroup).
ILogger (logger) untuk kenyamanan jika Anda ingin mencatat informasi atau kesalahan.

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

Kode sebelumnya:

Tidak termasuk keanggotaan transitif. Jika aplikasi memerlukan klaim keanggotaan grup langsung dan transitif, ganti MemberOf properti (IUserMemberOfCollectionWithReferencesRequestBuilder) dengan TransitiveMemberOf (IUserTransitiveMemberOfCollectionWithReferencesRequestBuilder).
Menetapkan nilai GUID dalam directoryRole klaim adalah ID Templat Peran Administrator ME-ID (Microsoft.Graph.Models.DirectoryRole.RoleTemplateId). ID templat adalah pengidentifikasi yang stabil untuk membuat kebijakan otorisasi pengguna di aplikasi, yang dibahas nanti dalam artikel ini. Jangan gunakan entry.Id untuk nilai klaim peran direktori, karena tidak stabil di seluruh penyewa.

Selanjutnya, konfigurasikan autentikasi MSAL untuk menggunakan pabrik akun pengguna kustom.

Konfirmasikan bahwa Program file menggunakan Microsoft.AspNetCore.Components.WebAssembly.Authentication namespace layanan:

using Microsoft.AspNetCore.Components.WebAssembly.Authentication;

AddMsalAuthentication Perbarui panggilan ke yang berikut ini. Perhatikan bahwa Blazor kerangka kerja RemoteUserAccount digantikan oleh aplikasi CustomUserAccount untuk autentikasi MSAL dan pabrik utama klaim akun:

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

Konfirmasikan keberadaan kode Graph SDK dalam file yang Program dijelaskan oleh artikel Gunakan Graph API dengan 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);

Penting

Konfirmasikan dalam pendaftaran aplikasi di portal Azure bahwa izin berikut diberikan:

User.Read
RoleManagement.Read.Directory (Memerlukan persetujuan admin)
AdministrativeUnit.Read.All (Memerlukan persetujuan admin)

Konfirmasikan bahwa wwwroot/appsettings.json konfigurasi sudah benar sesuai panduan 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"
    ]
  }
}

Berikan nilai untuk tempat penampung berikut dari pendaftaran ME-ID aplikasi di portal Azure:

{TENANT ID}: Nilai GUID Id Direktori (Penyewa).
{CLIENT ID}: Nilai GUID Id Aplikasi (Klien).

Konfigurasi otorisasi

Buat kebijakan untuk setiap Peran Aplikasi (berdasarkan nama peran), Peran Administrator bawaan ME-ID (menurut Id Templat Peran/GUID), atau grup keamanan (menurut Id Objek/GUID) dalam Program file. Contoh berikut membuat kebijakan untuk peran Administrator Penagihan bawaan ME-ID:

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

Untuk daftar lengkap ID (GUID) untuk Peran Administrator ME-ID, lihat ID templat peran dalam dokumentasi ME-ID. Untuk keamanan Azure atau ID grup O365 (GUID), lihat Id Objek untuk grup di panel Grup portal Azure pendaftaran aplikasi. Untuk informasi selengkapnya tentang kebijakan otorisasi, lihat Otorisasi berbasis kebijakan di ASP.NET Core.

Dalam contoh berikut, aplikasi menggunakan kebijakan sebelumnya untuk mengotorisasi pengguna.

Komponen AuthorizeView bekerja dengan kebijakan:

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

Akses ke seluruh komponen dapat didasarkan pada kebijakan menggunakan [Authorize] direktif atribut (AuthorizeAttribute):

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

Jika pengguna tidak diotorisasi, mereka akan diarahkan ke halaman masuk ME-ID.

Pemeriksaan kebijakan juga dapat dilakukan dalam kode dengan logika prosedural.

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

Dengan menggunakan pendekatan sebelumnya, Anda juga dapat membuat akses berbasis kebijakan untuk grup keamanan, di mana GUID yang digunakan untuk kebijakan cocok dengan

Peran aplikasi

Untuk mengonfigurasi aplikasi di portal Azure untuk memberikan klaim keanggotaan Peran Aplikasi, lihat Menambahkan peran aplikasi ke aplikasi Anda dan menerimanya dalam token dalam dokumentasi ME-ID.

Contoh berikut mengasumsikan bahwa aplikasi dikonfigurasi dengan dua peran, dan peran ditetapkan ke pengguna uji:

Admin
Developer

Meskipun Anda tidak dapat menetapkan peran ke grup tanpa akun ME-ID Premium, Anda dapat menetapkan peran kepada pengguna dan menerima klaim peran untuk pengguna dengan akun Azure standar. Panduan di bagian ini tidak memerlukan akun ME-ID Premium.

Ambil salah satu pendekatan berikut menambahkan peran aplikasi di ME-ID:

Saat bekerja dengan direktori default, ikuti panduan di Menambahkan peran aplikasi ke aplikasi Anda dan menerimanya dalam token untuk membuat peran ME-ID.
Jika Anda tidak bekerja dengan direktori default, edit manifes aplikasi di portal Azure untuk membuat peran aplikasi secara manual dalam appRoles entri file manifes. Berikut ini adalah contoh appRoles entri yang membuat Admin dan Developer peran. Contoh peran ini digunakan nanti di tingkat komponen untuk menerapkan pembatasan akses:

Penting

Pendekatan berikut ini hanya direkomendasikan untuk aplikasi yang tidak terdaftar di direktori default akun Azure. Untuk aplikasi yang terdaftar di direktori default, lihat poin sebelumnya dari daftar ini.
```
"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} Untuk tempat penampung dan {DEVELOPER GUID} dalam contoh sebelumnya, Anda dapat membuat GUID dengan generator GUID online (hasil pencarian Google untuk "generator guid").

Untuk menetapkan peran kepada pengguna (atau grup jika Anda memiliki akun Azure tingkat Premium):

Navigasikan ke aplikasi Enterprise di area ME-ID portal Azure.
Pilih aplikasi. Pilih Kelola>Pengguna dan grup dari bar samping.
Pilih kotak centang untuk satu atau beberapa akun pengguna.
Dari menu di atas daftar pengguna, pilih Edit penugasan.
Untuk entri Pilih peran, pilih Tidak ada yang dipilih.
Pilih peran dari daftar dan gunakan tombol Pilih untuk memilihnya.
Gunakan tombol Tetapkan di bagian bawah layar untuk menetapkan peran.

Beberapa peran ditetapkan dalam portal Azure dengan menambahkan kembali pengguna untuk setiap penetapan peran tambahan. Gunakan tombol Tambahkan pengguna/grup di bagian atas daftar pengguna untuk menambahkan kembali pengguna. Gunakan langkah-langkah sebelumnya untuk menetapkan peran lain kepada pengguna. Anda dapat mengulangi proses ini sebanyak yang diperlukan untuk menambahkan peran tambahan ke pengguna (atau grup).

Yang CustomAccountFactory diperlihatkan di bagian Akun pengguna kustom disiapkan untuk bertindak berdasarkan role klaim dengan nilai array JSON. Tambahkan dan daftarkan di aplikasi seperti yang CustomAccountFactory ditunjukkan di bagian Akun pengguna kustom. Tidak perlu memberikan kode untuk menghapus klaim asli role karena secara otomatis dihapus oleh kerangka kerja.

Program Dalam file, tambahkan atau konfirmasi klaim bernama "role" sebagai klaim peran untuk ClaimsPrincipal.IsInRole pemeriksaan:

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

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

Catatan

Jika Anda lebih suka menggunakan directoryRoles klaim (Peran Administrator ME-ID), tetapkan "directoryRoles" ke RemoteAuthenticationUserOptions.RoleClaim.

Setelah Anda menyelesaikan langkah-langkah sebelumnya untuk membuat dan menetapkan peran kepada pengguna (atau grup jika Anda memiliki akun Azure tingkat Premium) dan menerapkan CustomAccountFactory dengan Graph SDK, seperti yang dijelaskan sebelumnya dalam artikel ini dan dalam Menggunakan Graph API dengan ASP.NET Core Blazor WebAssembly, Anda akan melihat role klaim untuk setiap peran yang ditetapkan bahwa pengguna yang masuk ditetapkan (atau peran yang ditetapkan ke grup tempat mereka menjadi anggota). Jalankan aplikasi dengan pengguna uji untuk mengonfirmasi klaim ada seperti yang diharapkan. Saat menguji dengan Graph SDK secara lokal, sebaiknya gunakan sesi browser in-private/incognito baru untuk setiap pengujian untuk mencegah cookie yang berlama-lama mengganggu pengujian. Untuk informasi selengkapnya, lihat Mengamankan aplikasi mandiri ASP.NET Core Blazor WebAssembly dengan ID Microsoft Entra.

Pendekatan otorisasi komponen berfungsi pada saat ini. Salah satu mekanisme otorisasi dalam komponen aplikasi dapat menggunakan Admin peran untuk mengotorisasi pengguna:

AuthorizeView komponen
```
<AuthorizeView Roles="Admin">
```
[Authorize] direktif atribut (AuthorizeAttribute)
```
@attribute [Authorize(Roles = "Admin")]
```

Logika prosedural

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

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

Beberapa pengujian peran didukung:

Mengharuskan pengguna berada dalam Admin peran atau Developer dengan AuthorizeView komponen:
```
<AuthorizeView Roles="Admin, Developer">
    ...
</AuthorizeView>
```
Mengharuskan pengguna berada dalam Admin peran dan Developer dengan AuthorizeView komponen:
```
<AuthorizeView Roles="Admin">
    <AuthorizeView Roles="Developer" Context="innerContext">
        ...
    </AuthorizeView>
</AuthorizeView>
```
Untuk informasi selengkapnya tentang Context untuk bagian dalam AuthorizeView, lihat autentikasi dan otorisasi inti Blazor ASP.NET.
Mengharuskan pengguna berada dalam Admin peran atau Developer dengan [Authorize] atribut :
```
@attribute [Authorize(Roles = "Admin, Developer")]
```

Mengharuskan pengguna berada dalam Admin peran dan Developer dengan [Authorize] atribut :

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

Mengharuskan pengguna berada dalam Admin peran atau Developer dengan kode prosedural:

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

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

Wajibkan pengguna berada dalam Admin peran dan Developer dengan kode prosedural dengan mengubah OR bersyarat (||) menjadi AND bersyarat (&&) dalam contoh sebelumnya:
```
if (user.IsInRole("Admin") && user.IsInRole("Developer"))
```

Beberapa pengujian peran didukung:

Mengharuskan pengguna berada dalam Admin peran atau Developer dengan [Authorize] atribut :
```
[Authorize(Roles = "Admin, Developer")]
```
Mengharuskan pengguna berada dalam Admin peran dan Developer dengan [Authorize] atribut :
```
[Authorize(Roles = "Admin")]
[Authorize(Roles = "Developer")]
```

Mengharuskan pengguna berada dalam Admin peran atau Developer dengan kode prosedural:

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 ...
}

Wajibkan pengguna berada dalam Admin peran dan Developer dengan kode prosedural dengan mengubah OR bersyarat (||) menjadi AND bersyarat (&&) dalam contoh sebelumnya:
```
if (User.IsInRole("Admin") && User.IsInRole("Developer"))
```

Karena perbandingan string .NET peka huruf besar/kecil, nama peran yang cocok juga peka huruf besar/kecil. Misalnya, Admin (huruf Abesar ) tidak diperlakukan sebagai peran yang sama dengan admin (huruf akecil ).

Kasus Pascal biasanya digunakan untuk nama peran (misalnya, BillingAdministrator), tetapi penggunaan kasus Pascal bukan persyaratan yang ketat. Skema casing yang berbeda, seperti camel case, kebab case, dan snake case, diizinkan. Menggunakan spasi dalam nama peran juga tidak biasa tetapi diizinkan. Misalnya, billing administrator adalah format nama peran yang tidak biasa di aplikasi .NET tetapi valid.

Bagikan melalui

Grup Microsoft Entra (ME-ID), Peran Administrator, dan Peran Aplikasi

Aplikasi sampel

Prasyarat

Alat online pendaftaran aplikasi ME-ID

Cakupan

Akun pengguna kustom

Konfigurasi otorisasi

Peran aplikasi

Sumber Daya Tambahan:

Sumber Daya Tambahan: