Autenticação e autorização do ASP.NET Core BlazorASP.NET Core Blazor authentication and authorization

Por Steve SandersonBy Steve Sanderson

Importante

Blazor Webassembly na versão préviaBlazor WebAssembly in preview

o Blazor Server tem suporte no ASP.NET Core 3,0.Blazor Server is supported in ASP.NET Core 3.0. Blazor Webassembly está em visualização para ASP.NET Core 3,1.Blazor WebAssembly is in preview for ASP.NET Core 3.1.

O ASP.NET Core dá suporte à configuração e ao gerenciamento de segurança em aplicativos Blazor.ASP.NET Core supports the configuration and management of security in Blazor apps.

Os cenários de segurança diferem entre o servidor Blazor e Blazor aplicativos Webassembly.Security scenarios differ between Blazor Server and Blazor WebAssembly apps. Como os aplicativos do Blazor Server são executados no servidor, as verificações de autorização são capazes de determinar:Because Blazor Server apps run on the server, authorization checks are able to determine:

  • As opções de interface do usuário apresentadas ao usuário (por exemplo, as entradas de menu disponíveis a um usuário).The UI options presented to a user (for example, which menu entries are available to a user).
  • As regras de acesso para áreas do aplicativo e componentes.Access rules for areas of the app and components.

Blazor aplicativos Webassembly são executados no cliente. WebAssembly apps run on the client. A autorização é somente usada para determinar quais opções da interface do usuário serão apresentadas.Authorization is only used to determine which UI options to show. Como as verificações do lado do cliente podem ser modificadas ou ignoradas por um usuário, um aplicativo Webassembly Blazor não pode impor regras de acesso de autorização.Since client-side checks can be modified or bypassed by a user, a Blazor WebAssembly app can't enforce authorization access rules.

AutenticaçãoAuthentication

Blazor usa os mecanismos de autenticação ASP.NET Core existentes para estabelecer a identidade do usuário. uses the existing ASP.NET Core authentication mechanisms to establish the user's identity. O mecanismo exato depende de como o aplicativo Blazor está hospedado, Blazor servidor ou Blazor Webassembly.The exact mechanism depends on how the Blazor app is hosted, Blazor Server or Blazor WebAssembly.

autenticação do Blazor ServerBlazor Server authentication

os aplicativos do Blazor Server operam em uma conexão em tempo real que é criada usando SignalR.Blazor Server apps operate over a real-time connection that's created using SignalR. A autenticação em aplicativos baseados em SignalR é tratada quando a conexão é estabelecida.Authentication in SignalR-based apps is handled when the connection is established. A autenticação pode ser baseada em um cookie ou um algum outro token de portador.Authentication can be based on a cookie or some other bearer token.

O modelo de projeto do Blazor Server pode configurar a autenticação para você quando o projeto é criado.The Blazor Server project template can set up authentication for you when the project is created.

Siga as diretrizes do Visual Studio no artigo Introdução ao ASP.NET Core Blazor para criar um novo projeto do Blazor Server com um mecanismo de autenticação.Follow the Visual Studio guidance in the Introdução ao ASP.NET Core Blazor article to create a new Blazor Server project with an authentication mechanism.

Depois de escolher o modelo de aplicativo doBlazor Server na caixa de diálogo criar um novo ASP.NET Core aplicativo Web , selecione alterar em autenticação.After choosing the Blazor Server App template in the Create a new ASP.NET Core Web Application dialog, select Change under Authentication.

Uma caixa de diálogo é aberta para oferecer o mesmo conjunto de mecanismos de autenticação para outros projetos ASP.NET Core:A dialog opens to offer the same set of authentication mechanisms available for other ASP.NET Core projects:

  • Sem AutenticaçãoNo Authentication
  • Contas de usuário individuais – contas de usuário podem ser armazenadas:Individual User Accounts – User accounts can be stored:
  • Contas corporativas ou de estudanteWork or School Accounts
  • Autenticação do WindowsWindows Authentication

autenticação de Webassembly BlazorBlazor WebAssembly authentication

Em Blazor aplicativos Webassembly, as verificações de autenticação podem ser ignoradas porque todo o código do lado do cliente pode ser modificado por usuários.In Blazor WebAssembly apps, authentication checks can be bypassed because all client-side code can be modified by users. Isso também ocorre com todas as tecnologias de aplicativo do lado do cliente, incluindo estruturas de SPA do JavaScript ou aplicativos nativos em qualquer sistema operacional.The same is true for all client-side app technologies, including JavaScript SPA frameworks or native apps for any operating system.

Adicione uma referência de pacote para Microsoft. AspNetCore. Components. Authorization ao arquivo de projeto do aplicativo.Add a package reference for Microsoft.AspNetCore.Components.Authorization to the app's project file.

A implementação de um serviço de AuthenticationStateProvider personalizado para aplicativos Webassembly Blazor é abordada nas seções a seguir.Implementation of a custom AuthenticationStateProvider service for Blazor WebAssembly apps is covered in the following sections.

Serviço AuthenticationStateProviderAuthenticationStateProvider service

os aplicativos do Blazor Server incluem um serviço de AuthenticationStateProvider interno que obtém dados de estado de autenticação do HttpContext.Userde ASP.NET Core.Blazor Server apps include a built-in AuthenticationStateProvider service that obtains authentication state data from ASP.NET Core's HttpContext.User. Essa é a maneira que o estado de autenticação se integra a mecanismos de autenticação existentes no lado do servidor do ASP.NET Core.This is how authentication state integrates with existing ASP.NET Core server-side authentication mechanisms.

O AuthenticationStateProvider é o serviço subjacente usado pelos componentes AuthorizeView e CascadingAuthenticationState para obter o estado de autenticação.AuthenticationStateProvider is the underlying service used by the AuthorizeView component and CascadingAuthenticationState component to get the authentication state.

Normalmente, você não usa o AuthenticationStateProvider diretamente.You don't typically use AuthenticationStateProvider directly. Use as abordagens do componente AuthorizeView ou Task descritas mais adiante neste artigo.Use the AuthorizeView component or Task approaches described later in this article. A principal desvantagem de usar o AuthenticationStateProvider diretamente é que o componente não será notificado automaticamente se os dados subjacentes do estado de autenticação forem alterados.The main drawback to using AuthenticationStateProvider directly is that the component isn't notified automatically if the underlying authentication state data changes.

O serviço AuthenticationStateProvider pode fornecer os dados de ClaimsPrincipal do usuário atual, conforme mostrado no seguinte exemplo:The AuthenticationStateProvider service can provide the current user's ClaimsPrincipal data, as shown in the following example:

@page "/"
@using Microsoft.AspNetCore.Components.Authorization
@inject AuthenticationStateProvider AuthenticationStateProvider

<button @onclick="@LogUsername">Write user info to console</button>

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

        if (user.Identity.IsAuthenticated)
        {
            Console.WriteLine($"{user.Identity.Name} is authenticated.");
        }
        else
        {
            Console.WriteLine("The user is NOT authenticated.");
        }
    }
}

Se user.Identity.IsAuthenticated for true e como o usuário é um ClaimsPrincipal, será possível enumerar as declarações e avaliar a associação nas funções.If user.Identity.IsAuthenticated is true and because the user is a ClaimsPrincipal, claims can be enumerated and membership in roles evaluated.

Para obter mais informações sobre a DI (injeção de dependência) e os serviços, confira Injeção de dependência de Blazor ASP.NET Core e Injeção de dependência no ASP.NET Core.For more information on dependency injection (DI) and services, see Injeção de dependência de Blazor ASP.NET Core and Injeção de dependência no ASP.NET Core.

Implementar um AuthenticationStateProvider personalizadoImplement a custom AuthenticationStateProvider

Se você estiver criando um aplicativo Webassembly Blazor ou se a especificação do seu aplicativo for absolutamente necessária um provedor personalizado, implemente um provedor e substitua GetAuthenticationStateAsync:If you're building a Blazor WebAssembly app or if your app's specification absolutely requires a custom provider, implement a provider and override GetAuthenticationStateAsync:

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Components.Authorization;

namespace BlazorSample.Services
{
    public class CustomAuthStateProvider : AuthenticationStateProvider
    {
        public override Task<AuthenticationState> GetAuthenticationStateAsync()
        {
            var identity = new ClaimsIdentity(new[]
            {
                new Claim(ClaimTypes.Name, "mrfibuli"),
            }, "Fake authentication type");

            var user = new ClaimsPrincipal(identity);

            return Task.FromResult(new AuthenticationState(user));
        }
    }
}

O serviço CustomAuthStateProvider é registrado em Startup.ConfigureServices:The CustomAuthStateProvider service is registered in Startup.ConfigureServices:

// using Microsoft.AspNetCore.Components.Authorization;
// using BlazorSample.Services;

services.AddScoped<AuthenticationStateProvider, CustomAuthStateProvider>();

Ao usarem o CustomAuthStateProvider, todos os usuários são autenticados com o nome de usuário mrfibuli.Using the CustomAuthStateProvider, all users are authenticated with the username mrfibuli.

Expor o estado de autenticação como um parâmetro em cascataExpose the authentication state as a cascading parameter

Se os dados do estado de autenticação forem necessários para a lógica do procedimento, como ao realizar uma ação disparada pelo usuário, obtenha os dados de estado de autenticação definindo um parâmetro em cascata do tipo Task<AuthenticationState>:If authentication state data is required for procedural logic, such as when performing an action triggered by the user, obtain the authentication state data by defining a cascading parameter of type Task<AuthenticationState>:

@page "/"

<button @onclick="@LogUsername">Log username</button>

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

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

        if (user.Identity.IsAuthenticated)
        {
            Console.WriteLine($"{user.Identity.Name} is authenticated.");
        }
        else
        {
            Console.WriteLine("The user is NOT authenticated.");
        }
    }
}

Observação

Em um componente de aplicativo Webassembly Blazor, adicione o namespace Microsoft.AspNetCore.Components.Authorization (@using Microsoft.AspNetCore.Components.Authorization).In a Blazor WebAssembly app component, add the Microsoft.AspNetCore.Components.Authorization namespace (@using Microsoft.AspNetCore.Components.Authorization).

Se user.Identity.IsAuthenticated for true, será possível enumerar as declarações e avaliar a associação nas funções.If user.Identity.IsAuthenticated is true, claims can be enumerated and membership in roles evaluated.

Configure o Task<AuthenticationState> parâmetro em cascata usando os componentes AuthorizeRouteView e CascadingAuthenticationState no arquivo app. Razor :Set up the Task<AuthenticationState> cascading parameter using the AuthorizeRouteView and CascadingAuthenticationState components in the App.razor file:

<Router AppAssembly="@typeof(Program).Assembly">
    <Found Context="routeData">
        <AuthorizeRouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)" />
    </Found>
    <NotFound>
        <CascadingAuthenticationState>
            <LayoutView Layout="@typeof(MainLayout)">
                <p>Sorry, there's nothing at this address.</p>
            </LayoutView>
        </CascadingAuthenticationState>
    </NotFound>
</Router>

AutorizaçãoAuthorization

Depois que o usuário é autenticado, as regras de autorização são aplicadas para controlar o que ele poderá fazer.After a user is authenticated, authorization rules are applied to control what the user can do.

O acesso geralmente é concedido ou negado com base nos seguintes casos:Access is typically granted or denied based on whether:

  • Se o usuário está autenticado (conectado).A user is authenticated (signed in).
  • Se o usuário está em uma função.A user is in a role.
  • Se o usuário tem uma declaração.A user has a claim.
  • Se uma política é atendida.A policy is satisfied.

Todos esses conceitos são iguais no MVC do ASP.NET Core ou em aplicativos Razor Pages.Each of these concepts is the same as in an ASP.NET Core MVC or Razor Pages app. Para obter mais informações sobre a segurança do ASP.NET Core, confira os artigos em Identidade e segurança do ASP.NET Core.For more information on ASP.NET Core security, see the articles under ASP.NET Core Security and Identity.

Componente AuthorizeViewAuthorizeView component

O componente AuthorizeView exibe de forma seletiva a interface do usuário, caso o usuário esteja autorizado a vê-la.The AuthorizeView component selectively displays UI depending on whether the user is authorized to see it. Essa abordagem é útil quando você precisa apenas exibir dados para o usuário e não precisa usar a identidade dele na lógica de procedimento.This approach is useful when you only need to display data for the user and don't need to use the user's identity in procedural logic.

O componente expõe uma variável context do tipo AuthenticationState, que pode ser usada para acessar informações sobre o usuário conectado:The component exposes a context variable of type AuthenticationState, which you can use to access information about the signed-in user:

<AuthorizeView>
    <h1>Hello, @context.User.Identity.Name!</h1>
    <p>You can only see this content if you're authenticated.</p>
</AuthorizeView>

Também é possível fornecer um conteúdo diferente para ser exibido caso o usuário não esteja autenticado:You can also supply different content for display if the user isn't authenticated:

<AuthorizeView>
    <Authorized>
        <h1>Hello, @context.User.Identity.Name!</h1>
        <p>You can only see this content if you're authenticated.</p>
    </Authorized>
    <NotAuthorized>
        <h1>Authentication Failure!</h1>
        <p>You're not signed in.</p>
    </NotAuthorized>
</AuthorizeView>

O conteúdo das marcas de <Authorized> e <NotAuthorized> pode incluir itens arbitrários, como outros componentes interativos.The content of <Authorized> and <NotAuthorized> tags can include arbitrary items, such as other interactive components.

As condições de autorização, como funções ou políticas que controlam o acesso ou as opções da interface do usuário, são abordadas na seção Autorização.Authorization conditions, such as roles or policies that control UI options or access, are covered in the Authorization section.

Se as condições de autorização não forem especificadas, o AuthorizeView usará uma política padrão e tratará:If authorization conditions aren't specified, AuthorizeView uses a default policy and treats:

  • Usuários autenticados (conectados) como autorizados.Authenticated (signed-in) users as authorized.
  • Usuários não autenticados (não conectados) como não autorizados.Unauthenticated (signed-out) users as unauthorized.

Autorização baseada em funções e em políticasRole-based and policy-based authorization

O componente AuthorizeView dá suporte à autorização baseada em funções ou baseada em políticas.The AuthorizeView component supports role-based or policy-based authorization.

Para a autorização baseada em funções, use o parâmetro Roles:For role-based authorization, use the Roles parameter:

<AuthorizeView Roles="admin, superuser">
    <p>You can only see this if you're an admin or superuser.</p>
</AuthorizeView>

Para obter mais informações, consulte Autorização baseada em função no ASP.NET Core.For more information, see Autorização baseada em função no ASP.NET Core.

Para a autorização baseada em políticas, use o parâmetro Policy:For policy-based authorization, use the Policy parameter:

<AuthorizeView Policy="content-editor">
    <p>You can only see this if you satisfy the "content-editor" policy.</p>
</AuthorizeView>

A autorização baseada em declarações é um caso especial de autorização baseada em políticas.Claims-based authorization is a special case of policy-based authorization. Por exemplo, você pode definir uma política que exige que os usuários tenham determinada declaração.For example, you can define a policy that requires users to have a certain claim. Para obter mais informações, consulte Autorização baseada em políticas no ASP.NET Core.For more information, see Autorização baseada em políticas no ASP.NET Core.

Essas APIs podem ser usadas em um servidor Blazor ou Blazor aplicativos Webassembly.These APIs can be used in either Blazor Server or Blazor WebAssembly apps.

Se Roles e Policy não forem especificados, o AuthorizeView usará a política padrão.If neither Roles nor Policy is specified, AuthorizeView uses the default policy.

Conteúdo exibido durante a autenticação assíncronaContent displayed during asynchronous authentication

Blazor permite que o estado de autenticação seja determinado de forma assíncrona. allows for authentication state to be determined asynchronously. O cenário principal para essa abordagem é em Blazor aplicativos Webassembly que fazem uma solicitação para um ponto de extremidade externo para autenticação.The primary scenario for this approach is in Blazor WebAssembly apps that make a request to an external endpoint for authentication.

Enquanto a autenticação estiver em andamento, AuthorizeView não exibirá nenhum conteúdo por padrão.While authentication is in progress, AuthorizeView displays no content by default. Para exibir o conteúdo enquanto a autenticação ocorre, use o elemento <Authorizing>:To display content while authentication occurs, use the <Authorizing> element:

<AuthorizeView>
    <Authorized>
        <h1>Hello, @context.User.Identity.Name!</h1>
        <p>You can only see this content if you're authenticated.</p>
    </Authorized>
    <Authorizing>
        <h1>Authentication in progress</h1>
        <p>You can only see this content while authentication is in progress.</p>
    </Authorizing>
</AuthorizeView>

Essa abordagem normalmente não é aplicável a aplicativos Blazor Server.This approach isn't normally applicable to Blazor Server apps. os aplicativos do Blazor Server conhecem o estado de autenticação assim que o estado é estabelecido.Blazor Server apps know the authentication state as soon as the state is established. Authorizing conteúdo pode ser fornecido em um componente de AuthorizeView do aplicativo Blazor Server, mas o conteúdo nunca é exibido.Authorizing content can be provided in a Blazor Server app's AuthorizeView component, but the content is never displayed.

Atributo [Authorize][Authorize] attribute

O atributo [Authorize] pode ser usado em componentes do Razor:The [Authorize] attribute can be used in Razor components:

@page "/"
@attribute [Authorize]

You can only see this if you're signed in.

Observação

Em um componente de aplicativo Webassembly Blazor, adicione o namespace Microsoft.AspNetCore.Authorization (@using Microsoft.AspNetCore.Authorization) aos exemplos nesta seção.In a Blazor WebAssembly app component, add the Microsoft.AspNetCore.Authorization namespace (@using Microsoft.AspNetCore.Authorization) to the examples in this section.

Importante

Use apenas [Authorize] em componentes @page atingidos por meio do roteador Blazor.Only use [Authorize] on @page components reached via the Blazor Router. A autorização é realizada apenas como um aspecto do roteamento e não para componentes filho renderizados dentro de uma página.Authorization is only performed as an aspect of routing and not for child components rendered within a page. Para autorizar a exibição de partes específicas dentro de uma página, use AuthorizeView.To authorize the display of specific parts within a page, use AuthorizeView instead.

O atributo [Authorize] também dá suporte à autorização baseada em funções ou em políticas.The [Authorize] attribute also supports role-based or policy-based authorization. Para a autorização baseada em funções, use o parâmetro Roles:For role-based authorization, use the Roles parameter:

@page "/"
@attribute [Authorize(Roles = "admin, superuser")]

<p>You can only see this if you're in the 'admin' or 'superuser' role.</p>

Para a autorização baseada em políticas, use o parâmetro Policy:For policy-based authorization, use the Policy parameter:

@page "/"
@attribute [Authorize(Policy = "content-editor")]

<p>You can only see this if you satisfy the 'content-editor' policy.</p>

Se Roles e Policy não forem especificados, [Authorize] usará a política padrão, que tratará:If neither Roles nor Policy is specified, [Authorize] uses the default policy, which by default is to treat:

  • Usuários autenticados (conectados) como autorizados.Authenticated (signed-in) users as authorized.
  • Usuários não autenticados (não conectados) como não autorizados.Unauthenticated (signed-out) users as unauthorized.

Personalizar conteúdo não autorizado com o componente RouterCustomize unauthorized content with the Router component

O componente Router, em conjunto com o componente AuthorizeRouteView, permite que o aplicativo especifique conteúdo personalizado se:The Router component, in conjunction with the AuthorizeRouteView component, allows the app to specify custom content if:

  • O conteúdo não for encontrado.Content isn't found.
  • O usuário não atender à condição [Authorize] aplicada ao componente.The user fails an [Authorize] condition applied to the component. O atributo [Authorize] é abordado na seção atributo de[Authorize] .The [Authorize] attribute is covered in the [Authorize] attribute section.
  • A autenticação assíncrona estiver em andamento.Asynchronous authentication is in progress.

No modelo de projeto padrão do Blazor Server, o arquivo app. Razor demonstra como definir o conteúdo personalizado:In the default Blazor Server project template, the App.razor file demonstrates how to set custom content:

<Router AppAssembly="@typeof(Program).Assembly">
    <Found Context="routeData">
        <AuthorizeRouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)">
            <NotAuthorized>
                <h1>Sorry</h1>
                <p>You're not authorized to reach this page.</p>
                <p>You may need to log in as a different user.</p>
            </NotAuthorized>
            <Authorizing>
                <h1>Authentication in progress</h1>
                <p>Only visible while authentication is in progress.</p>
            </Authorizing>
        </AuthorizeRouteView>
    </Found>
    <NotFound>
        <CascadingAuthenticationState>
            <LayoutView Layout="@typeof(MainLayout)">
                <h1>Sorry</h1>
                <p>Sorry, there's nothing at this address.</p>
            </LayoutView>
        </CascadingAuthenticationState>
    </NotFound>
</Router>

O conteúdo das marcas <NotFound>, <NotAuthorized>e <Authorizing> pode incluir itens arbitrários, como outros componentes interativos.The content of <NotFound>, <NotAuthorized>, and <Authorizing> tags can include arbitrary items, such as other interactive components.

Se o elemento <NotAuthorized> não for especificado, o AuthorizeRouteView usará a seguinte mensagem de fallback:If the <NotAuthorized> element isn't specified, the AuthorizeRouteView uses the following fallback message:

Not authorized.

Notificação sobre mudanças no estado de autenticaçãoNotification about authentication state changes

Se o aplicativo determinar que os dados sobre o estado de autenticação subjacente foram alterados (por exemplo, porque o usuário se desconectou ou porque outro usuário alterou suas funções), um AuthenticationStateProvider personalizado poderá invocar opcionalmente o método NotifyAuthenticationStateChanged na classe base AuthenticationStateProvider.If the app determines that the underlying authentication state data has changed (for example, because the user signed out or another user has changed their roles), a custom AuthenticationStateProvider can optionally invoke the method NotifyAuthenticationStateChanged on the AuthenticationStateProvider base class. Isso notificará os consumidores a respeito dos dados de estado de autenticação (por exemplo, AuthorizeView) para realizar uma nova renderização usando os novos dados.This notifies consumers of the authentication state data (for example, AuthorizeView) to rerender using the new data.

Lógica de procedimentoProcedural logic

Se for necessário que o aplicativo verifique as regras de autorização como parte da lógica de procedimento, use um parâmetro em cascata do tipo Task<AuthenticationState> para obter o ClaimsPrincipal do usuário.If the app is required to check authorization rules as part of procedural logic, use a cascaded parameter of type Task<AuthenticationState> to obtain the user's ClaimsPrincipal. O Task<AuthenticationState> pode ser combinado com outros serviços, como IAuthorizationService, para avaliar as políticas.Task<AuthenticationState> can be combined with other services, such as IAuthorizationService, to evaluate policies.

@inject IAuthorizationService AuthorizationService

<button @onclick="@DoSomething">Do something important</button>

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

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

        if (user.Identity.IsAuthenticated)
        {
            // Perform an action only available to authenticated (signed-in) users.
        }

        if (user.IsInRole("admin"))
        {
            // Perform an action only available to users in the 'admin' role.
        }

        if ((await AuthorizationService.AuthorizeAsync(user, "content-editor"))
            .Succeeded)
        {
            // Perform an action only available to users satisfying the 
            // 'content-editor' policy.
        }
    }
}

Observação

Em um componente de aplicativo Webassembly Blazor, adicione os namespaces de Microsoft.AspNetCore.Authorization e Microsoft.AspNetCore.Components.Authorization:In a Blazor WebAssembly app component, add the Microsoft.AspNetCore.Authorization and Microsoft.AspNetCore.Components.Authorization namespaces:

@using Microsoft.AspNetCore.Authorization
@using Microsoft.AspNetCore.Components.Authorization

Autorização em aplicativos Webassembly BlazorAuthorization in Blazor WebAssembly apps

Em Blazor aplicativos Webassembly, as verificações de autorização podem ser ignoradas porque todo o código do lado do cliente pode ser modificado por usuários.In Blazor WebAssembly apps, authorization checks can be bypassed because all client-side code can be modified by users. Isso também ocorre com todas as tecnologias de aplicativo do lado do cliente, incluindo estruturas de SPA do JavaScript ou aplicativos nativos em qualquer sistema operacional.The same is true for all client-side app technologies, including JavaScript SPA frameworks or native apps for any operating system.

Sempre execute as verificações de autorização no servidor em qualquer ponto de extremidade da API acessada pelo aplicativo do lado do cliente.Always perform authorization checks on the server within any API endpoints accessed by your client-side app.

Solucionar problemas de errosTroubleshoot errors

Erros comuns:Common errors:

  • A autorização requer um parâmetro em cascata do tipo Task<Authenticationstate >. Considere o uso de CascadingAuthenticationState para fornecer isso.Authorization requires a cascading parameter of type Task<AuthenticationState>. Consider using CascadingAuthenticationState to supply this.

  • O valor null é recebido para authenticationStateTasknull value is received for authenticationStateTask

É provável que o projeto não tenha sido criado usando um modelo de servidor Blazor com autenticação habilitada.It's likely that the project wasn't created using a Blazor Server template with authentication enabled. Encapsule um <CascadingAuthenticationState> em torno de alguma parte da árvore da interface do usuário, por exemplo, em App.razor, da seguinte maneira:Wrap a <CascadingAuthenticationState> around some part of the UI tree, for example in App.razor as follows:

<CascadingAuthenticationState>
    <Router AppAssembly="typeof(Startup).Assembly">
        ...
    </Router>
</CascadingAuthenticationState>

O CascadingAuthenticationState fornece o parâmetro em cascata Task<AuthenticationState> que, por sua vez, ele recebe do serviço DI subjacente AuthenticationStateProvider.The CascadingAuthenticationState supplies the Task<AuthenticationState> cascading parameter, which in turn it receives from the underlying AuthenticationStateProvider DI service.

Recursos adicionaisAdditional resources