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

Bu makalede, Microsoft Entra Id gruplarını ve rollerini kullanmak için yapılandırma Blazor WebAssembly açıklanmaktadır.

Microsoft Entra (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 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
• ME-ID ile barındırılan

Makalenin kılavuzunda istemci ve sunucu uygulamaları için yönergeler sağlanır:

• İsteMCİ: Tek başına Blazor WebAssembly uygulamalar veya barındırılanClient Blazorbir çözümün uygulaması.
• SUNUCU: ASP.NET Core sunucu API'si/web API'si uygulamaları veya barındırılan Server Blazor bir çözümün uygulaması. Tek başına Blazor WebAssembly bir uygulama için makale boyunca SUNUCU kılavuzunu yoksayabilirsiniz.

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.

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

Kapsamlar

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 (https://graph.microsoft.com/User.Readtemsilci) kapsamlar tarafından belirlendiğinden, İstemci uygulaması Azure portalında temsilci User.Readkapsamı () ile yapılandırılır.
• Sunucu uygulaması Azure portalında uygulama GroupMember.Read.Allkapsamıhttps://graph.microsoft.com/GroupMember.Read.All () ile yapılandırılır çünkü erişim, uygulamanın grup üyeleri hakkındaki verilere erişmek için bireysel kullanıcı yetkilendirmesine değil, grup üyeliği hakkında bilgi almasına yöneliktir.

Önceki kapsamlar, daha önce listelenen makalelerde açıklanan ME Kimliği dağıtım senaryolarında gereken kapsamlara ek olarak gereklidir (Microsoft Hesapları ile Tek Başına, ME-ID ile Tek Başına ve ME-Id ile Barındırılan).

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

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

Grup Üyeliği Talepleri özniteliği

Ö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.
• İsteMCİ ve SUNUCU uygulamaları içindeki erişimi denetlemek için yetkilendirme ilkelerini kullanın.

İsteMCİ uygulamasında şunların özelliklerini içerecek şekilde genişletinRemoteUserAccount:

• Roles: ME-ID Uygulama Rolleri dizisi (Uygulama Rolleri bölümünde ele alınmıştır)
• Wids: İyi bilinen kimlik taleplerinde ME-ID Yönetici Rolleri (wids)
• 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 BlazorSample;

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

    [JsonPropertyName("wids")]
    public List<string>? Wids { get; set; }

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

için Microsoft.Graphclient uygulamasına bir paket başvurusu ekleyin.

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. User.Read Makalede örnek wwwroot/appsettings.json dosyasında gösterildiği gibi erişim belirtecinin kapsamını belirtin.

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

• Uygulama Rolü talepleri () (appRoleUygulama Rolleri bölümünde ele alınmıştır).
• ME-ID Yönetici Rolü talepleri (directoryRole).
• Kullanıcının cep telefonu numarası () ve ofis konumuofficeLocation (mobilePhone) için örnek kullanıcı profili veri talepleri.
• 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 BlazorSample;

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

    public CustomAccountFactory(IAccessTokenProviderAccessor accessor,
        IServiceProvider serviceProvider,
        ILogger<CustomAccountFactory> logger)
        : base(accessor)
    {
        this.serviceProvider = serviceProvider;
        this.logger = logger;
    }

    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?.Roles?.ForEach((role) =>
                {
                    userIdentity.AddClaim(new Claim("appRole", role));
                });

                account?.Wids?.ForEach((wid) =>
                {
                    userIdentity.AddClaim(new Claim("directoryRole", wid));
                });

                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 requestMemberOf = client.Users[account?.Oid].MemberOf;
                    var graphGroups = await requestMemberOf.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;
    }
}

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

namespace BlazorSample;

public class CustomAccountFactory() 
    : AccountClaimsPrincipalFactory<CustomUserAccount>(accessor)
{
    private readonly ILogger<CustomAccountFactory> logger;
    private readonly IServiceProvider serviceProvider;

    public CustomAccountFactory(IAccessTokenProviderAccessor accessor,
        IServiceProvider serviceProvider,
        ILogger<CustomAccountFactory> logger)
        : base(accessor)
    {
        this.serviceProvider = serviceProvider;
        this.logger = logger;
    }

    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)
            {
                account?.Roles?.ForEach((role) =>
                {
                    userIdentity.AddClaim(new Claim("appRole", role));
                });

                account?.Wids?.ForEach((wid) =>
                {
                    userIdentity.AddClaim(new Claim("directoryRole", wid));
                });

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

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

                    var requestMemberOf = client.Users[account?.Oid].MemberOf;
                    var memberships = await requestMemberOf.Request().GetAsync();

                    if (memberships is not null)
                    {
                        foreach (var entry in memberships)
                        {
                            if (entry.ODataType == "#microsoft.graph.group")
                            {
                                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.

Değeri wids olan b79fbf4d-3ef9-4689-8143-76b194e85509 talep (ve dolayısıyla directoryRole talep), kiracının konuk olmayan hesapları için mevcuttur. Me-ID Yönetici Rol Şablonu Kimliği'ne başvurmaz.

İsteMCİ uygulamasında 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);
    })
    .AddAccountClaimsPrincipalFactory<RemoteAuthenticationState, CustomUserAccount,
        CustomAccountFactory>();

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

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

Yetkilendirme yapılandırması

İsteMCİ uygulamasında, dosyadaki her Uygulama Rolü, ME Kimliği Yönetici Rolü veya güvenlik grubu Program 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 kimliklerinin tam listesi için Entra belgelerindeki Rol şablonu kimlikleri bölümüne bakın. Yetkilendirme ilkeleri hakkında daha fazla bilgi için bkz . ASP.NET Core'da ilke tabanlı yetkilendirme.

Aşağıdaki örneklerde, client uygulaması 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.";
        }
    }
}

Önceki yaklaşımları kullanarak, uygulama rolleri için ilke tabanlı erişim de oluşturabilirsiniz. Burada, ilke için kullanılan GUID, Azure portalındaki uygulama bildiriminin öğesinde appRoles ayarlanır ve güvenlik grupları da sağlanır ve burada ilke için kullanılan GUID, Azure portal Grupları bölmesindeki grup Nesne Kimliği ile eşleşir.

Sunucu API'si/web API'si erişimini yetkilendirme

SUNUCU API'si uygulaması, bir erişim belirteci , widsve talepleri içerdiğinde groupsgüvenlik grupları, ME-ID Yönetici Rolleri ve Uygulama Rolleri için yetkilendirme ilkeleriyle güvenli API uç noktalarına erişmeleri için kullanıcılara yetki verebilirrole. Aşağıdaki örnek, dosyadaki ME-ID Faturalama Yöneticisi rolü için (iyi bilinen kimlikler/Rol Şablonu Kimlikleri) taleplerini kullanarak wids bir ilke oluşturur:Program

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

ME-ID Yönetici Rolleri kimliklerinin tam listesi için Azure belgelerindeki Rol şablonu kimlikleri bölümüne bakın. Yetkilendirme ilkeleri hakkında daha fazla bilgi için bkz . ASP.NET Core'da ilke tabanlı yetkilendirme.

SERVER uygulamasındaki bir denetleyiciye erişim, ilke adıyla bir [Authorize] özniteliğin kullanılmasına dayanabilir (API belgeleri: ). AuthorizeAttribute

Aşağıdaki örnek, faturalama verilerine BillingDataController erişimi ilke adıyla Azure Faturalama Yöneticileri'ne BillingAdministratorsınırlar:

using Microsoft.AspNetCore.Authorization;

[Authorize(Policy = "BillingAdministrator")]
[ApiController]
[Route("[controller]")]
public class BillingDataController : ControllerBase
{
    ...
}

Daha fazla bilgi için, bkz. ASP.NET Core'da ilke tabanlı yetkilendirme.

Uygulama Rolleri

Uygulamayı Azure portalında Uygulama Rolleri üyelik talepleri sağlayacak şekilde yapılandırmak için, Uygulamanıza uygulama rolleri ekleme ve Bunları Entra belgelerindeki belirteçte alma bölümüne bakın.

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

• Admin
• Developer

Microsoft Entra 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.

Varsayılan dizinle çalışırken, Uygulamanıza uygulama rolleri ekleme başlığındaki yönergeleri izleyin ve rolleri yapılandırmak ve atamak 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, erişim kısıtlamalarını uygulamak için bu bölümün bileşen düzeyindeki örneğinde daha sonra kullanılır:

"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 İstemci uygulamasına öğesini ekleyin ve kaydedin CustomAccountFactory . Çerçeve tarafından otomatik olarak kaldırıldığı için özgün role talebi kaldırmak için kod sağlamanız gerekmez.

client uygulamasının Program dosyasında, denetimler için ClaimsPrincipal.IsInRole rol talebi olarak "appRole" adlı talebi belirtin:

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

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

BIR SERVER uygulamasının Program dosyasında, denetimler için ClaimsPrincipal.IsInRole rol talebi olarak "http://schemas.microsoft.com/ws/2008/06/identity/claims/role" adlı talebi belirtin:

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApi(options =>
    {
        Configuration.Bind("AzureAd", options);
        options.TokenValidationParameters.RoleClaimType = 
            "http://schemas.microsoft.com/ws/2008/06/identity/claims/role";
    },
    options => { Configuration.Bind("AzureAd", options); });

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 appRole gerekir. Talebin 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. İsteMCİ uygulamasının bileşenlerindeki yetkilendirme mekanizmalarından herhangi biri, kullanıcıyı yetkilendirmek için rolünü kullanabilirAdmin:

• 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"))
  

SERVER uygulamasının denetleyicilerindeki yetkilendirme mekanizmalarından herhangi biri, kullanıcıyı yetkilendirmek için rolü kullanabilirAdmin:

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

  [Authorize(Roles = "Admin")]
  

• Yordam mantığı

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

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 (Entra belgeleri)
• groupMembershipClaims attribute (Entra belgeleri)
• Uygulamanıza uygulama rolleri ekleme ve bunları belirteçte alma (Entra 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