Microsoft Entra (ME-ID) grupları, Yönetici Rolleri ve Uygulama Rolleri

Bu makalede, Microsoft Entra ID (ME-ID) gruplarını ve rollerini kullanmak için yapılandırma Blazor WebAssembly açıklanmaktadır.

ME-ID, ASP.NET Core Identityile birleştirilebilen çeşitli yetkilendirme yaklaşımları sağlar:

• Grup
  • Güvenlik
  • Microsoft 365
  • Dağıtım
• Rolleri
  • ME-ID yerleşik Yönetici Rolleri
  • Uygulama Rolleri

Bu makaledeki kılavuz, aşağıdaki makalelerde açıklanan ME-ID dağıtım senaryoları için Blazor WebAssembly geçerlidir:

• Microsoft Hesapları ile tek başına
• ME-ID ile tek başına

Bu makaledeki örneklerde yeni .NET/C# özelliklerinden yararlanılmıştır. .NET 7 veya önceki sürümleriyle örnekleri kullanırken küçük değişiklikler yapılması gerekir. Ancak, ME-ID ve Microsoft Graph ile etkileşime yönelik metin ve kod örnekleri, ASP.NET Core'un tüm sürümleri için aynıdır.

Örnek uygulama

adlı BlazorWebAssemblyEntraGroupsAndRolesörnek uygulamaya aşağıdaki bağlantıyla deponun kökünden en son sürüm klasöründen erişin. Örnek, .NET 8 veya üzeri için sağlanır. Uygulamayı çalıştırma adımları için örnek uygulamanın README dosyasına bakın.

Örnek uygulama, kullanıcının UserClaims taleplerini görüntülemek için bir bileşen içerir. Bileşen, UserData kullanıcının temel hesap özelliklerini görüntüler.

Örnek kodu görüntüleme veya indirme (indirme)

Önkoşul

Bu makaledeki kılavuz, ASP.NET CoreBlazor WebAssembly ile Graph API'sini kullanma başlığı altında Graph SDK'sı başına Microsoft Graph API'sini uygular. Graph SDK uygulama kılavuzunu izleyerek uygulamayı yapılandırın ve uygulamanın test kullanıcı hesabı için Graph API verilerini alabildiğini onaylamak üzere test edin. Ayrıca, Microsoft Graph güvenlik kavramlarını gözden geçirmek için Graph API makalesinin güvenlik makalesinin çapraz bağlantılarına bakın.

Graph SDK'sı ile yerel olarak test ederken, kalan tanımlama bilgilerinin testlere müdahale etmesini önlemek için her test için yeni bir özel/gizli tarayıcı oturumu kullanmanızı öneririz. Daha fazla bilgi için bkz. Microsoft Entra ID ile ASP.NET Core Blazor WebAssembly tek başına uygulamasının güvenliğini sağlama.

ME-ID uygulama kaydı çevrimiçi araçları

Bu makale, uygulamanın ME-ID uygulama kaydını yapılandırmanızı isterken Azure portalına başvurur ancak Microsoft Entra Yönetim Merkezi, ME-ID uygulama kayıtlarını yönetmek için de uygun bir seçenektir. Her iki arabirim de kullanılabilir, ancak bu makaledeki yönergeler özellikle Azure portalına yönelik hareketleri kapsar.

Kapsamlar

İzinler ve kapsamlar aynı anlama gelir ve güvenlik belgelerinde ve Azure portalında birbirinin yerine kullanılır. Metin Azure portalına başvurmadığı sürece, bu makalede Graph izinlerine başvururken kapsam/kapsamları kullanılmaktadır.

Kapsamlar büyük/küçük harfe duyarlı değildir, bu nedenle User.Read ile user.readaynıdır. Her iki biçimi de kullanmaktan çekinmeyin, ancak uygulama kodu genelinde tutarlı bir seçim yapmanızı öneririz.

Kullanıcı profili, rol ataması ve grup üyeliği verileri için Microsoft Graph API çağrılarına izin vermek için, kullanıcı verilerini okuma erişimi tek tek kullanıcılara verilen (temsilci) kapsamlara göre belirlendiğinden uygulama Azure portalında temsilciUser.Read kapsamıhttps://graph.microsoft.com/User.Read () ile yapılandırılır. Bu kapsam, daha önce listelenen makalelerde açıklanan ME-ID dağıtım senaryolarında gereken kapsamlara ek olarak gereklidir (Microsoft Hesapları ile tek başına veya ME-ID ile tek başına).

Ek gerekli kapsamlar şunlardır:

• RoleManagement.Read.Directory Temsilci kapsamı (https://graph.microsoft.com/RoleManagement.Read.Directory): Uygulamanın oturum açmış kullanıcı adına şirketinizin dizini için rol tabanlı erişim denetimi (RBAC) ayarlarını okumasına izin verir. Bu, dizin rolü şablonlarını, dizin rollerini ve üyelikleri okumayı içerir. Dizin rolü üyelikleri, uygulamada ME-ID yerleşik Yönetici Rolleri için talep oluşturmak directoryRole için kullanılır. Yönetici onayı gereklidir.
• AdministrativeUnit.Read.All Temsilci kapsamı (https://graph.microsoft.com/AdministrativeUnit.Read.All): Uygulamanın oturum açmış kullanıcı adına yönetim birimlerini ve yönetim birimi üyeliğini okumasına izin verir. Bu üyelikler uygulamada talep oluşturmak administrativeUnit için kullanılır. Yönetici onayı gereklidir.

Daha fazla bilgi için bkz. Microsoft platformunda izinlere ve onaylara genel bakış ve Microsoft identity Graph izinlerine genel bakış.

Özel kullanıcı hesabı

Azure portalında kullanıcıları ME-ID güvenlik gruplarına ve ME-ID Yönetici Rollerine atayın.

Bu makaledeki örnekler:

• Bir kullanıcının sunucu API'si verilerine erişim yetkisi için Azure portal ME-ID kiracısında ME-ID Faturalama Yöneticisi rolüne atandığını varsayın.
• Uygulama içindeki erişimi denetlemek için yetkilendirme ilkelerini kullanın.

Şunların özelliklerini içerecek şekilde genişletin RemoteUserAccount :

• Roles: ME-ID Uygulama Rolleri dizisi (Uygulama Rolleri bölümünde ele alınmıştır)
• Oid: Sabit nesne tanımlayıcı talebi () (oidkiracılar içinde ve kiracılar arasında bir kullanıcıyı benzersiz olarak tanımlar)

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

uygulamasına bir Microsoft.Graphpaket başvurusu ekleyin.

Not

.NET uygulamalarına paket ekleme hakkında yönergeler için, Paket tüketimi iş akışında (NuGet belgeleri) paketleri yüklemek ve yönetmek altındaki makalelere bakın. NuGet.org'da doğru paket sürümlerini onaylayın.

Graph API'sini ASP.NET Core Blazor WebAssembly ile kullanma makalesinin Graph SDK kılavuzuna Graph SDK yardımcı programı sınıflarını ve yapılandırmasını ekleyin. Makalenin User.Readörnek wwwroot/appsettings.json dosyasında gösterildiği gibi erişim belirteci için , RoleManagement.Read.Directoryve AdministrativeUnit.Read.All kapsamlarını belirtin.

Aşağıdaki özel kullanıcı hesabı fabrikasını uygulamaya ekleyin. Özel kullanıcı fabrikası aşağıdakileri oluşturmak için kullanılır:

• Uygulama Rolü talepleri () (roleUygulama Rolleri bölümünde ele alınmıştır).

• Kullanıcının cep telefonu numarası () ve ofis konumuofficeLocation (mobilePhone) için örnek kullanıcı profili veri talepleri.

• ME-ID Yönetici Rolü talepleri (directoryRole).

• ME-ID Yönetim Birimi talepleri (administrativeUnit).

• ME-ID Grubu talepleri (directoryGroup).

• ILogger Bilgileri veya hataları günlüğe kaydetmek istemeniz durumunda kolaylık sağlamak için bir (logger).

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

Yukarıdaki kod:

• Geçişli üyelikleri içermez. Uygulama doğrudan ve geçişli grup üyeliği talepleri gerektiriyorsa ( ) özelliğini (IUserMemberOfCollectionWithReferencesRequestBuilderIUserTransitiveMemberOfCollectionWithReferencesRequestBuilder) ile TransitiveMemberOf değiştirinMemberOf.
• Taleplerdeki directoryRole GUID değerlerini ayarlar: ME-ID Yönetici Rol Şablonu Kimlikleri (Microsoft.Graph.Models.DirectoryRole.RoleTemplateId). Şablon kimlikleri, uygulamalarda kullanıcı yetkilendirme ilkeleri oluşturmaya yönelik kararlı tanımlayıcılardır ve bu tanımlayıcılar bu makalenin devamında ele alınmıştır. Kiracılar arasında kararlı olmadığından dizin rolü talep değerleri için kullanmayın entry.Id .

Ardından, MSAL kimlik doğrulamasını özel kullanıcı hesabı fabrikasını kullanacak şekilde yapılandırın.

Program Dosyanın ad alanını Microsoft.AspNetCore.Components.WebAssembly.Authentication kullandığını onaylayın:

using Microsoft.AspNetCore.Components.WebAssembly.Authentication;

Çağrıyı AddMsalAuthentication aşağıdakilere güncelleştirin. Çerçevenin Blazor RemoteUserAccount , MSAL kimlik doğrulaması ve hesap talepleri sorumlusu fabrikası için uygulamanınkilerle CustomUserAccount değiştirildiğini unutmayın:

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

Graph API'sini ASP.NET Core Blazor WebAssembly ile kullanma makalesi tarafından açıklanan dosyada Program Graph SDK kodunun varlığını onaylayın:

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

Önemli

Uygulamanın Azure portalındaki kaydında aşağıdaki izinlerin verildiğini onaylayın:

• User.Read
• RoleManagement.Read.Directory (Yönetici onayı gerektirir)
• AdministrativeUnit.Read.All (Yönetici onayı gerektirir)

Graph SDK kılavuzuna wwwroot/appsettings.json göre yapılandırmanın doğru olduğunu onaylayın.

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"
    ]
  }
}

Azure portalında uygulamanın ME-ID kaydından aşağıdaki yer tutucular için değerler sağlayın:

• {TENANT ID}: Dizin (Kiracı) Kimliği GUID değeri.
• {CLIENT ID}: Uygulama (İstemci) Kimliği GUID değeri.

Yetkilendirme yapılandırması

Dosyadaki Program her Uygulama Rolü (rol adına göre), ME Kimliği yerleşik Yönetici Rolü (Rol Şablonu Kimliği/GUID'ye göre) veya güvenlik grubu (Nesne Kimliği/GUID ile) için bir ilke oluşturun. Aşağıdaki örnek, ME-ID yerleşik Faturalama Yöneticisi rolü için bir ilke oluşturur:

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

ME-ID Yönetici Rolleri için kimliklerin (GUID) tam listesi için ME-ID belgelerindeki Rol şablonu kimlikleri bölümüne bakın. Azure güvenliği veya O365 grup kimliği (GUID) için, uygulamanın kaydının Azure portalı Gruplar bölmesinde grubun Nesne Kimliği'ne bakın. Yetkilendirme ilkeleri hakkında daha fazla bilgi için bkz . ASP.NET Core'da ilke tabanlı yetkilendirme.

Aşağıdaki örneklerde uygulama, kullanıcıyı yetkilendirmek için önceki ilkeyi kullanır.

Bileşen AuthorizeView ilkeyle çalışır:

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

Bir bileşenin tamamına erişim, bir [Authorize] öznitelik yönergesi (AuthorizeAttribute) kullanılarak ilkeyi temel alabilir:

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

Kullanıcı yetkili değilse, ME-ID oturum açma sayfasına yönlendirilir.

yordam mantığıyla kodda bir ilke denetimi de gerçekleştirilebilir.

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

Yukarıdaki yaklaşımları kullanarak, güvenlik grupları için ilke tabanlı erişim de oluşturabilirsiniz; burada ilke için kullanılan GUID,

Uygulama Rolleri

Uygulamayı Azure portalında Uygulama Rolleri üyelik talepleri sağlayacak şekilde yapılandırmak için bkz . Uygulamanıza uygulama rolleri ekleme ve bunları ME-ID belgelerindeki belirteçte alma.

Aşağıdaki örnekte, uygulamanın iki rolle yapılandırıldığı ve rollerin bir test kullanıcısına atandığı varsayılır:

• Admin
• Developer

ME-ID Premium hesabı olmayan gruplara rol atayamazsınız, ancak kullanıcılara roller atayabilir ve standart bir Azure hesabı olan kullanıcılar için rol talepleri alabilirsiniz. Bu bölümdeki yönergeler için ME-ID Premium hesabı gerekmez.

ME-ID'de uygulama rolleri eklemek için aşağıdaki yaklaşımlardan birini kullanın:

• Varsayılan dizinle çalışırken Uygulamanıza uygulama rolleri ekleme bölümünde yer alan yönergeleri izleyin ve me-id rolleri oluşturmak için bunları belirteçte alın.

• Varsayılan dizinle çalışmıyorsanız, uygulamanın rollerini bildirim dosyasının girişinde el ile oluşturmak için Azure portalında appRoles uygulamanın bildirimini düzenleyin. Aşağıda, ve Developer rolleri oluşturan Admin örnek appRoles bir giriş verilmiştir. Bu örnek roller daha sonra bileşen düzeyinde erişim kısıtlamalarını uygulamak için kullanılır:

  Önemli

  Aşağıdaki yaklaşım yalnızca Azure hesabının varsayılan dizininde kayıtlı olmayan uygulamalar için önerilir. Varsayılan dizinde kayıtlı uygulamalar için bu listenin önceki madde işaretine bakın.

  "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"
    }
  ],
  

  Yukarıdaki örnekteki {ADMIN GUID} ve {DEVELOPER GUID} yer tutucuları için, çevrimiçi GUID oluşturucusu ("guid oluşturucusu" için Google arama sonucu) ile GUID oluşturabilirsiniz.

Bir kullanıcıya (veya Premium katmanı Azure hesabınız varsa gruba) rol atamak için:

1. Azure portalının ME-ID alanında Kurumsal uygulamalar'a gidin.
2. Uygulama'yı seçin. Kenar çubuğunda Kullanıcıları ve grupları Yönet'i>seçin.
3. Bir veya daha fazla kullanıcı hesabının onay kutusunu seçin.
4. Kullanıcı listesinin üst kısmındaki menüden Atamayı düzenle'yi seçin.
5. Rol seçin girdisi için Hiçbiri seçildi'yi seçin.
6. Listeden bir rol seçin ve seçmek için Seç düğmesini kullanın.
7. Rolü atamak için ekranın alt kısmındaki Ata düğmesini kullanın.

Azure portalında her ek rol ataması için bir kullanıcı yeniden eklenerek birden çok rol atanır. Bir kullanıcıyı yeniden eklemek için kullanıcı listesinin en üstündeki Kullanıcı/grup ekle düğmesini kullanın. Kullanıcıya başka bir rol atamak için önceki adımları kullanın. Bir kullanıcıya (veya gruba) ek roller eklemek için bu işlemi gerektiği kadar tekrarlayabilirsiniz.

CustomAccountFactory Özel kullanıcı hesabı bölümünde gösterilen, JSON dizi değerine sahip bir role talep üzerinde işlem yapmak üzere ayarlanır. Özel kullanıcı hesabı bölümünde gösterildiği gibi öğesini uygulamaya ekleyin ve kaydedinCustomAccountFactory. Çerçeve tarafından otomatik olarak kaldırıldığı için özgün role talebi kaldırmak için kod sağlamanız gerekmez.

DosyadaProgram, denetimler için ClaimsPrincipal.IsInRole rol talebi olarak "role" adlı talebi ekleyin veya onaylayın:

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

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

Not

Talebi kullanmayı directoryRoles tercih ediyorsanız (ME-ID Yönetici Rolleri), öğesine "directoryRoles" atayın RemoteAuthenticationUserOptions.RoleClaim.

Bu makalenin önceki bölümlerinde ve ASP.NET Core Blazor WebAssemblyile Graph API'sini kullanma bölümünde açıklandığı gibi, kullanıcılara (veya Premium katman Azure hesabınız varsa gruplara) CustomAccountFactory rol oluşturma ve atamaya yönelik önceki adımları tamamladıktan sonra, oturum açmış bir kullanıcıya atanan her rol (veya üyesi oldukları gruplara atanmış roller) için bir talep görmeniz role gerekir. Taleplerin beklendiği gibi mevcut olduğunu onaylamak için uygulamayı bir test kullanıcısı ile çalıştırın. Graph SDK'sı ile yerel olarak test ederken, kalan tanımlama bilgilerinin testlere müdahale etmesini önlemek için her test için yeni bir özel/gizli tarayıcı oturumu kullanmanızı öneririz. Daha fazla bilgi için bkz. Microsoft Entra ID ile ASP.NET Core Blazor WebAssembly tek başına uygulamasının güvenliğini sağlama.

Bileşen yetkilendirme yaklaşımları bu noktada işlevseldir. Uygulamanın bileşenlerindeki yetkilendirme mekanizmalarından herhangi biri, kullanıcıyı yetkilendirmek için bu rolü kullanabilir Admin :

• AuthorizeView parça

  <AuthorizeView Roles="Admin">
  

• [Authorize] öznitelik yönergesi (AuthorizeAttribute)

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

• Yordam mantığı

  var authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
  var user = authState.User;
  
  if (user.IsInRole("Admin")) { ... }
  

Birden çok rol testi desteklenir:

• Kullanıcının bileşeniyle birlikte veya rolünde Admin olmasını gerektir:AuthorizeView Developer

  <AuthorizeView Roles="Admin, Developer">
      ...
  </AuthorizeView>
  

• Kullanıcının bileşeniyle hem hem Developer de Admin rollerinde olmasını gerektir:AuthorizeView

  <AuthorizeView Roles="Admin">
      <AuthorizeView Roles="Developer" Context="innerContext">
          ...
      </AuthorizeView>
  </AuthorizeView>
  

  iç için hakkında Context daha fazla bilgi için bkz. ASP.NET Çekirdek Blazor kimlik doğrulaması ve yetkilendirme.AuthorizeView

• Kullanıcının özniteliğine sahip veya rolünde Admin olmasını gerektir:[Authorize] Developer

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

• Kullanıcının özniteliğiyle hem hem Developer de Admin rollerinde olmasını gerektir:[Authorize]

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

• Kullanıcının yordam koduyla veya Developer rolünde Admin olmasını gerektir:

  @code {
      private async Task DoSomething()
      {
          var authState = await AuthenticationStateProvider
              .GetAuthenticationStateAsync();
          var user = authState.User;
  
          if (user.IsInRole("Admin") || user.IsInRole("Developer"))
          {
              ...
          }
          else
          {
              ...
          }
      }
  }
  

• Önceki örnekte koşullu VEYA () değerini koşullu AND (&&||) olarak değiştirerek kullanıcının yordam koduyla hem hem Developer de Admin rollerinde olmasını gerektir:

  if (user.IsInRole("Admin") && user.IsInRole("Developer"))
  

Birden çok rol testi desteklenir:

• Kullanıcının özniteliğine sahip veya rolünde Admin olmasını gerektir:[Authorize] Developer

  [Authorize(Roles = "Admin, Developer")]
  

• Kullanıcının özniteliğiyle hem hem Developer de Admin rollerinde olmasını gerektir:[Authorize]

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

• Kullanıcının yordam koduyla veya Developer rolünde Admin olmasını gerektir:

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

• Önceki örnekte koşullu VEYA () değerini koşullu AND (&&||) olarak değiştirerek kullanıcının yordam koduyla hem hem Developer de Admin rollerinde olmasını gerektir:

  if (User.IsInRole("Admin") && User.IsInRole("Developer"))
  

.NET dize karşılaştırmaları büyük/küçük harfe duyarlı olduğundan eşleşen rol adları da büyük/küçük harfe duyarlıdır. Örneğin, Admin (büyük harf A) ile aynı rol admin (küçük harf) olarak değerlendirilmez a.

Pascal büyük/küçük harf genellikle rol adları (örneğin, BillingAdministrator) için kullanılır, ancak Pascal büyük/küçük harf kullanımı katı bir gereksinim değildir. Deve kasası, kebap kasası ve yılan kutusu gibi farklı kasa düzenlerine izin verilir. Rol adlarında boşluk kullanılması da olağan dışıdır ancak buna izin verilir. Örneğin, billing administrator .NET uygulamalarında olağan dışı bir rol adı biçimidir ancak geçerlidir.

Ek kaynaklar

• Rol şablonu kimlikleri (ME-ID belgeleri)
• groupMembershipClaims attribute (ME-ID belgeleri)
• Uygulamanıza uygulama rolleri ekleme ve bunları belirteçte alma (ME-ID belgeleri)
• Uygulama rolleri (Azure belgeleri)
• ASP.NET Core'da talep tabanlı yetkilendirme
• ASP.NET Core'da rol tabanlı yetkilendirme
• ASP.NET Core Blazor kimlik doğrulaması ve yetkilendirme