Introdução ao Identity no ASP.NET Core

ASP.NET Core Identity:

• É uma API que suporta a funcionalidade de logon da interface do usuário (UI).
• Gerencia usuários, senhas, dados de perfil, funções, declarações, tokens, confirmação por email e muito mais.

Os usuários podem criar uma conta com as informações de logon armazenadas em Identity ou podem usar um provedor de logon externo. Os provedores de logon externo suportados incluem Facebook, Google, conta Microsoft e Twitter.

Para obter informações sobre como exigir autenticação para todos os usuários do aplicativo, consulte Criar um aplicativo ASP.NET Core com dados do usuário protegidos por autorização.

O código-fonte Identity está disponível no GitHub. Gere a estrutura Scaffold Identity e exiba os arquivos gerados para revisar como o modelo interage com Identity.

Identity normalmente é configurado usando um banco de dados SQL Server para armazenar nomes de usuário, senhas e dados de perfil. Como alternativa, outro repositório persistente pode ser usado, por exemplo, Armazenamento de Tabelas do Azure.

Neste tópico, você aprenderá a usar Identity para registrar, fazer login e desconectar um usuário. Observação: os modelos tratam o nome de usuário e o email como os mesmos para os usuários. Para obter instruções mais detalhadas sobre como criar aplicativos que usam Identity, confira Próximas Etapas.

Para obter mais informações sobre Identity em aplicativos Blazor, consulte ASP.NET Core Blazor autenticação e autorização e os artigos que o seguem na documentação Blazor.

ASP.NET Core Identity não está relacionado à plataforma de identidade Microsoft. A plataforma de identidade da Microsoft é:

• Uma evolução da plataforma de desenvolvedor Azure Active Directory (Azure AD).
• Uma solução de identidade alternativa para autenticação e autorização em aplicativos ASP.NET Core.

ASP.NET Core Identity adiciona a funcionalidade de logon da interface do usuário (IU) para aplicativos web do ASP.NET Core. Para proteger APIs Web e SPAs, use uma das seguintes opções:

• Microsoft Entra ID
• Servidor Identity Duende

O Duende Identity Server é um framework OpenID Connect e OAuth 2.0 para ASP.NET Core. O Duende Identity Server habilita os seguintes recursos de segurança:

• AaaS (autenticação como serviço)
• SSO (logon único) em vários tipos de aplicativo
• Controle de acesso para APIs
• Portal de Federação

Para obter mais informações, confira a documentação do Duende Identity Server (site da Duende Software).

Veja ou baixe o código de exemplo (como baixar).

Crie um Blazor Web App com autenticação

Crie um ASP.NET Core Blazor Web App project com contas individuais.

dotnet new blazor -au Individual -o BlazorApp1

dotnet new blazor -au Individual -uld -o BlazorApp1

O projeto gerado inclui os componentes IdentityRazor. Os componentes são encontrados na pasta Components/Account do projeto do servidor. Por exemplo:

• Components/Account/Pages/Register.razor
• Components/Account/Pages/Login.razor
• Components/Account/Pages/Manage/ChangePassword.razor

Identity Razor os componentes são descritos individualmente na documentação para casos de uso específicos e estão sujeitos a alterações a cada versão. Quando você gera um Blazor Web App com Contas Individuais, IdentityRazor componentes são incluídos no projeto gerado. Os componentes IdentityRazor também podem ser inspecionados na pasta Components/Account do projeto do servidor no modelo de projeto Blazor Web App (dotnet/aspnetcore repositório do GitHub).

Para obter mais informações, consulte ASP.NET Core Blazor autenticação e autorização e os artigos que a seguem na documentação Blazor. A maioria dos artigos na área Security e Identity do conjunto de documentação principal do ASP.NET Core se aplicam a aplicativos Blazor. No entanto, o Blazor conjunto de documentação contém artigos e diretrizes que substituem ou adicionam informações. Recomendamos estudar primeiro o conjunto de documentação de ASP.NET Core geral, seguido pelo acesso aos artigos na documentação BlazorSecurity e Identity.

Criar um Razor aplicativo Páginas com autenticação

Crie um projeto de Aplicativo Web ASP.NET Core (projeto Razor Pages) com Contas Individuais.

dotnet new webapp -au Individual -o WebApp1

dotnet new webapp -au Individual -uld -o WebApp1

O projeto gerado fornece ASP.NET Core Identity como uma Razor biblioteca de classes (RCL). A biblioteca de classes IdentityRazor expõe os pontos de extremidade com a área Identity. Por exemplo:

• Areas/Identity/Pages/Account/Register
• Areas/Identity/Pages/Account/Login
• Areas/Identity/Pages/Account/Manage/ChangePassword

As páginas são descritas individualmente na documentação para casos de uso específicos e estão sujeitas a alterações a cada versão. Para exibir todas as páginas na RCL, consulte a origem de referência ASP.NET Core (dotnet/aspnetcore GitHub repositório, Identity/UI/src/Areas/Identity/Pages pasta). Você pode estruturar páginas individuais ou todas as páginas no aplicativo. Para obter mais informações, consulte Scaffold Identity em projetos ASP.NET Core.

Criar um aplicativo MVC com autenticação

Crie um project MVC ASP.NET Core com contas individuais.

dotnet new mvc -au Individual -o WebApplication1

dotnet new mvc -au Individual -uld -o WebApplication1

O projeto gerado fornece ASP.NET Core Identity como uma Razor biblioteca de classes (RCL). A IdentityRazor biblioteca de classes é baseada em Razor Páginas e expõe pontos de extremidade na área Identity. Por exemplo:

• Areas/Identity/Pages/Account/Register
• Areas/Identity/Pages/Account/Login
• Areas/Identity/Pages/Account/Manage/ChangePassword

As páginas são descritas individualmente na documentação para casos de uso específicos e estão sujeitas a alterações a cada versão. Para exibir todas as páginas na RCL, consulte a origem de referência ASP.NET Core (dotnet/aspnetcore GitHub repositório, Identity/UI/src/Areas/Identity/Pages pasta). Você pode estruturar páginas individuais ou todas as páginas no aplicativo. Para obter mais informações, consulte Scaffold Identity em projetos ASP.NET Core.

Executar migrações

Aplique as migrações para inicializar o banco de dados.

  dotnet tool install --global dotnet-ef

dotnet ef database update

Teste de Registro e Login

Execute o aplicativo e registre um usuário. Dependendo do tamanho da tela, talvez você precise selecionar o botão de alternância de navegação para conferir os links Registrar e Logon.

Exibição do banco de dados Identity

Configurar os serviços Identity

Os serviços são adicionados em Program.cs. O padrão típico é chamar os métodos na seguinte ordem:

1. Add{Service}
2. builder.Services.Configure{Service}

using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using WebApp1.Data;

var builder = WebApplication.CreateBuilder(args);

var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(connectionString));
builder.Services.AddDatabaseDeveloperPageExceptionFilter();

builder.Services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
    .AddEntityFrameworkStores<ApplicationDbContext>();
builder.Services.AddRazorPages();

builder.Services.Configure<IdentityOptions>(options =>
{
    // Password settings.
    options.Password.RequireDigit = true;
    options.Password.RequireLowercase = true;
    options.Password.RequireNonAlphanumeric = true;
    options.Password.RequireUppercase = true;
    options.Password.RequiredLength = 6;
    options.Password.RequiredUniqueChars = 1;

    // Lockout settings.
    options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5);
    options.Lockout.MaxFailedAccessAttempts = 5;
    options.Lockout.AllowedForNewUsers = true;

    // User settings.
    options.User.AllowedUserNameCharacters =
    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@+";
    options.User.RequireUniqueEmail = false;
});

builder.Services.ConfigureApplicationCookie(options =>
{
    // Cookie settings
    options.Cookie.HttpOnly = true;
    options.ExpireTimeSpan = TimeSpan.FromMinutes(5);

    options.LoginPath = "/Identity/Account/Login";
    options.AccessDeniedPath = "/Identity/Account/AccessDenied";
    options.SlidingExpiration = true;
});

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseMigrationsEndPoint();
}
else
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthentication();
app.UseAuthorization();

app.MapRazorPages();

app.Run();

O código anterior configura Identity com valores da opção padrão. Os serviços são disponibilizados para o aplicativo por meio da injeção de dependência.

Identity é habilitado quando você chama UseAuthentication. UseAuthentication adiciona autenticação Middleware ao pipeline de solicitações.

O aplicativo gerado pelo modelo não usa a autorização. app.UseAuthorization é incluído para que você certifique-se de que ele seja adicionado na ordem correta caso o aplicativo adicione uma autorização. UseRouting, UseAuthentication e UseAuthorization devem ser chamados na ordem mostrada no código anterior.

Para obter mais informações sobre IdentityOptions, confira IdentityOptions e a Inicialização do aplicativo.

ASP.NET Core Identity métricas

ASP.NET Core Identity métricas fornecem recursos de monitoramento para processos de autenticação e gerenciamento de usuários. Essas métricas ajudam você a detectar padrões de entrada incomuns que podem indicar ameaças à segurança, acompanhar o desempenho das operações de identidade e entender como os usuários interagem com recursos de autenticação, como autenticação de dois fatores. Essa observabilidade é particularmente valiosa para aplicativos com requisitos de segurança estritos ou aqueles com alto tráfego de autenticação.

Para obter detalhes completos sobre as métricas disponíveis e como usá-las, consulte ASP.NET Core métricas.

Scaffold, Login, LogOut e Confirmação de Registro

dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design
dotnet aspnet-codegenerator identity -dc WebApp1.Data.ApplicationDbContext --files "Account.Register;Account.Login;Account.Logout;Account.RegisterConfirmation"

dotnet aspnet-codegenerator identity -dc WebApp1.Data.ApplicationDbContext --files "Account.Register;Account.Login;Account.Logout;Account.RegisterConfirmation" --useSqLite

Examinar Registro

Quando um usuário clica no botão Registrar na página Register, a ação RegisterModel.OnPostAsync é chamada. O usuário foi criado por CreateAsync(TUser) no objeto _userManager:

public async Task<IActionResult> OnPostAsync(string returnUrl = null)
{
    returnUrl = returnUrl ?? Url.Content("~/");
    ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync())
                                          .ToList();
    if (ModelState.IsValid)
    {
        var user = new IdentityUser { UserName = Input.Email, Email = Input.Email };
        var result = await _userManager.CreateAsync(user, Input.Password);
        if (result.Succeeded)
        {
            _logger.LogInformation("User created a new account with password.");

            var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
            code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
            var callbackUrl = Url.Page(
                "/Account/ConfirmEmail",
                pageHandler: null,
                values: new { area = "Identity", userId = user.Id, code = code },
                protocol: Request.Scheme);

            await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
                $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");

            if (_userManager.Options.SignIn.RequireConfirmedAccount)
            {
                return RedirectToPage("RegisterConfirmation", 
                                      new { email = Input.Email });
            }
            else
            {
                await _signInManager.SignInAsync(user, isPersistent: false);
                return LocalRedirect(returnUrl);
            }
        }
        foreach (var error in result.Errors)
        {
            ModelState.AddModelError(string.Empty, error.Description);
        }
    }

    // If we got this far, something failed, redisplay form
    return Page();
}

Desabilitar a verificação padrão da conta

Com os modelos padrão, o usuário é redirecionado para Account.RegisterConfirmation, no qual pode selecionar um link para confirmar a conta. O padrão Account.RegisterConfirmation é usado apenas para teste. A verificação automática de conta deve ser desabilitada em um aplicativo de produção.

Para exigir uma conta confirmada e impedir o logon imediato no registro, defina DisplayConfirmAccountLink = false em /Areas/Identity/Pages/Account/RegisterConfirmation.cshtml.cs:

[AllowAnonymous]
public class RegisterConfirmationModel : PageModel
{
    private readonly UserManager<IdentityUser> _userManager;
    private readonly IEmailSender _sender;

    public RegisterConfirmationModel(UserManager<IdentityUser> userManager, IEmailSender sender)
    {
        _userManager = userManager;
        _sender = sender;
    }

    public string Email { get; set; }

    public bool DisplayConfirmAccountLink { get; set; }

    public string EmailConfirmationUrl { get; set; }

    public async Task<IActionResult> OnGetAsync(string email, string returnUrl = null)
    {
        if (email == null)
        {
            return RedirectToPage("/Index");
        }

        var user = await _userManager.FindByEmailAsync(email);
        if (user == null)
        {
            return NotFound($"Unable to load user with email '{email}'.");
        }

        Email = email;
        // Once you add a real email sender, you should remove this code that lets you confirm the account
        DisplayConfirmAccountLink = false;
        if (DisplayConfirmAccountLink)
        {
            var userId = await _userManager.GetUserIdAsync(user);
            var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
            code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
            EmailConfirmationUrl = Url.Page(
                "/Account/ConfirmEmail",
                pageHandler: null,
                values: new { area = "Identity", userId = userId, code = code, returnUrl = returnUrl },
                protocol: Request.Scheme);
        }

        return Page();
    }
}

Iniciar sessão

O formulário de Logon é exibido quando:

• O link Logon é selecionado.
• Um usuário tenta acessar uma página restrita na qual não está autorizado a acessar ou quando não foi autenticado pelo sistema.

Quando o formulário da página de login é enviado, a ação OnPostAsync é chamada. PasswordSignInAsync é chamado no objeto _signInManager.

public async Task<IActionResult> OnPostAsync(string returnUrl = null)
{
    returnUrl = returnUrl ?? Url.Content("~/");

    if (ModelState.IsValid)
    {
        // This doesn't count login failures towards account lockout
        // To enable password failures to trigger account lockout, 
        // set lockoutOnFailure: true
        var result = await _signInManager.PasswordSignInAsync(Input.Email,
                           Input.Password, Input.RememberMe, lockoutOnFailure: true);
        if (result.Succeeded)
        {
            _logger.LogInformation("User logged in.");
            return LocalRedirect(returnUrl);
        }
        if (result.RequiresTwoFactor)
        {
            return RedirectToPage("./LoginWith2fa", new
            {
                ReturnUrl = returnUrl,
                RememberMe = Input.RememberMe
            });
        }
        if (result.IsLockedOut)
        {
            _logger.LogWarning("User account locked out.");
            return RedirectToPage("./Lockout");
        }
        else
        {
            ModelState.AddModelError(string.Empty, "Invalid login attempt.");
            return Page();
        }
    }

    // If we got this far, something failed, redisplay form
    return Page();
}

Para obter informações sobre como tomar decisões de autorização, consulte Introduction to authorization in ASP.NET Core.

Fazer logoff

O link de Logoff invoca a ação LogoutModel.OnPost.

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.Extensions.Logging;
using System.Threading.Tasks;

namespace WebApp1.Areas.Identity.Pages.Account
{
    [AllowAnonymous]
    public class LogoutModel : PageModel
    {
        private readonly SignInManager<IdentityUser> _signInManager;
        private readonly ILogger<LogoutModel> _logger;

        public LogoutModel(SignInManager<IdentityUser> signInManager, ILogger<LogoutModel> logger)
        {
            _signInManager = signInManager;
            _logger = logger;
        }

        public void OnGet()
        {
        }

        public async Task<IActionResult> OnPost(string returnUrl = null)
        {
            await _signInManager.SignOutAsync();
            _logger.LogInformation("User logged out.");
            if (returnUrl != null)
            {
                return LocalRedirect(returnUrl);
            }
            else
            {
                return RedirectToPage();
            }
        }
    }
}

No código anterior, o código return RedirectToPage(); precisa ser um redirecionamento para que o navegador execute uma nova solicitação e a identidade do usuário seja atualizada.

SignOutAsync limpa as declarações do usuário armazenadas em cookie.

A postagem é especificada em Pages/Shared/_LoginPartial.cshtml:

@using Microsoft.AspNetCore.Identity
@inject SignInManager<IdentityUser> SignInManager
@inject UserManager<IdentityUser> UserManager

<ul class="navbar-nav">
@if (SignInManager.IsSignedIn(User))
{
    <li class="nav-item">
        <a  class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Manage/Index" 
                                              title="Manage">Hello @User.Identity.Name!</a>
    </li>
    <li class="nav-item">
        <form class="form-inline" asp-area="Identity" asp-page="/Account/Logout" 
                                  asp-route-returnUrl="@Url.Page("/", new { area = "" })" 
                                  method="post" >
            <button  type="submit" class="nav-link btn btn-link text-dark">Logout</button>
        </form>
    </li>
}
else
{
    <li class="nav-item">
        <a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Register">Register</a>
    </li>
    <li class="nav-item">
        <a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Login">Login</a>
    </li>
}
</ul>

Teste Identity

Os modelos de projeto da web padrão permitem acesso anônimo às páginas iniciais. Para testar Identity, adicione [Authorize]:

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.Extensions.Logging;

namespace WebApp1.Pages
{
    [Authorize]
    public class PrivacyModel : PageModel
    {
        private readonly ILogger<PrivacyModel> _logger;

        public PrivacyModel(ILogger<PrivacyModel> logger)
        {
            _logger = logger;
        }

        public void OnGet()
        {
        }
    }
}

Se estiver conectado, desconecte-se. Execute o aplicativo e selecione o link Privacy. Você é redirecionado à página de logon.

Explorar o Identity

Para explorar Identity em mais detalhes:

• Criar a identidade completa da origem da interface do usuário
• Examine o código-fonte de cada página e percorra passo a passo no depurador.

Componentes do Identity

Todos os pacotes NuGet dependentes do Identity estão incluídos na estrutura compartilhada ASP.NET Core.

O principal pacote para Identity é Microsoft.AspNetCore.Identity. Esse pacote contém o conjunto principal de interfaces para ASP.NET Core Identity e é incluído por Microsoft.AspNetCore.Identity.EntityFrameworkCore.

Migrando para ASP.NET Core Identity

Para obter mais informações e orientações sobre como migrar sua loja existente Identity, consulte Migrar autenticação e Identity.

Como definir a força da senha

Confira a Configuração para ver um exemplo que define os requisitos mínimos de senha.

AddDefaultIdentity e AddIdentity

AddDefaultIdentity foi introduzido no ASP.NET Core 2.1. Chamar AddDefaultIdentity é semelhante a chamar o seguinte:

• AddIdentity
• AddDefaultUI
• AddDefaultTokenProviders

Consulte fonte de AddDefaultIdentity para obter mais informações.

Impedir a publicação de ativos estáticos Identity

Para impedir a publicação de ativos Identity estáticos (folhas de estilo e arquivos JavaScript para Identity interface do usuário) na raiz web, adicione a propriedade ResolveStaticWebAssetsInputsDependsOn e o alvo RemoveIdentityAssets ao arquivo de projeto do aplicativo.

<PropertyGroup>
  <ResolveStaticWebAssetsInputsDependsOn>RemoveIdentityAssets</ResolveStaticWebAssetsInputsDependsOn>
</PropertyGroup>

<Target Name="RemoveIdentityAssets">
  <ItemGroup>
    <StaticWebAsset Remove="@(StaticWebAsset)" Condition="%(SourceId) == 'Microsoft.AspNetCore.Identity.UI'" />
  </ItemGroup>
</Target>

Próximas etapas

• ASP.NET Core Blazor autenticação e autorização
• ASP.NET Core Identity código-fonte
• Como trabalhar com funções em ASP.NET Core Identity

• Para obter informações sobre como configurar Identity usando SQLite, consulte How to config Identity for SQLite (dotnet/AspNetCore.Docs #5131).
• Configurar o Identity
• Criar um aplicativo ASP.NET Core com dados do usuário protegidos por autorização
• Adicionar, baixar e excluir dados do usuário para Identity
• Habilitar a geração de código QR para autenticação TOTP
• Migrar Autenticação e Identity para ASP.NET Core
• Confirmação da conta e recuperação de senha
• Autenticação multifator no ASP.NET Core
• Hospedar ASP.NET Core em uma fazenda web

Por Rick Anderson

ASP.NET Core Identity:

• É uma API que suporta a funcionalidade de logon da interface do usuário (UI).
• Gerencia usuários, senhas, dados de perfil, funções, declarações, tokens, confirmação por email e muito mais.

Os usuários podem criar uma conta com as informações de logon armazenadas em Identity ou podem usar um provedor de logon externo. Os provedores de logon externo suportados incluem Facebook, Google, conta Microsoft e Twitter.

Para obter informações sobre como exigir autenticação para todos os usuários do aplicativo, consulte Criar um aplicativo ASP.NET Core com dados do usuário protegidos por autorização.

O código-fonte Identity está disponível no GitHub. Gere a estrutura Scaffold Identity e exiba os arquivos gerados para revisar como o modelo interage com Identity.

Identity normalmente é configurado usando um banco de dados SQL Server para armazenar nomes de usuário, senhas e dados de perfil. Como alternativa, outro repositório persistente pode ser usado, por exemplo, Armazenamento de Tabelas do Azure.

Neste tópico, você aprenderá a usar Identity para registrar, fazer login e desconectar um usuário. Observação: os modelos tratam o nome de usuário e o email como os mesmos para os usuários. Para obter instruções mais detalhadas sobre como criar aplicativos que usam Identity, confira Próximas Etapas.

ASP.NET Core Identity não está relacionado à plataforma de identidade Microsoft. A plataforma de identidade da Microsoft é:

• Uma evolução da plataforma de desenvolvedor Azure Active Directory (Azure AD).
• Uma solução de identidade alternativa para autenticação e autorização em aplicativos ASP.NET Core.

ASP.NET Core Identity adiciona a funcionalidade de logon da interface do usuário (IU) para aplicativos web do ASP.NET Core. Para proteger APIs Web e SPAs, use uma das seguintes opções:

• Microsoft Entra ID
• Servidor Identity Duende

O Duende Identity Server é um framework OpenID Connect e OAuth 2.0 para ASP.NET Core. O Duende Identity Server habilita os seguintes recursos de segurança:

• AaaS (autenticação como serviço)
• SSO (logon único) em vários tipos de aplicativo
• Controle de acesso para APIs
• Portal de Federação

Para obter mais informações, confira a documentação do Duende Identity Server (site da Duende Software).

Veja ou baixe o código de exemplo (como baixar).

Criar um aplicativo Web com autenticação

Crie um aplicativo Web ASP.NET Core project com contas de usuário individuais.

dotnet new webapp --auth Individual -o WebApp1

dotnet new webapp --auth Individual -uld -o WebApp1

O projeto gerado fornece ASP.NET Core Identity como uma biblioteca de classes Razor. A biblioteca de classes IdentityRazor expõe os pontos de extremidade com a área Identity. Por exemplo:

• /Identity/Conta/Logon
• /Identity/Account/Logout
• /Identity/Conta/Gerenciar

Executar migrações

Aplique as migrações para inicializar o banco de dados.

  dotnet tool install --global dotnet-ef

dotnet ef database update

Teste de Registro e Login

Execute o aplicativo e registre um usuário. Dependendo do tamanho da tela, talvez você precise selecionar o botão de alternância de navegação para conferir os links Registrar e Logon.

Exibição do banco de dados Identity

Configurar os serviços Identity

Os serviços são adicionados em Program.cs. O padrão típico é chamar os métodos na seguinte ordem:

1. Add{Service}
2. builder.Services.Configure{Service}

using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using WebApp1.Data;

var builder = WebApplication.CreateBuilder(args);

var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(connectionString));
builder.Services.AddDatabaseDeveloperPageExceptionFilter();

builder.Services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
    .AddEntityFrameworkStores<ApplicationDbContext>();
builder.Services.AddRazorPages();

builder.Services.Configure<IdentityOptions>(options =>
{
    // Password settings.
    options.Password.RequireDigit = true;
    options.Password.RequireLowercase = true;
    options.Password.RequireNonAlphanumeric = true;
    options.Password.RequireUppercase = true;
    options.Password.RequiredLength = 6;
    options.Password.RequiredUniqueChars = 1;

    // Lockout settings.
    options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5);
    options.Lockout.MaxFailedAccessAttempts = 5;
    options.Lockout.AllowedForNewUsers = true;

    // User settings.
    options.User.AllowedUserNameCharacters =
    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@+";
    options.User.RequireUniqueEmail = false;
});

builder.Services.ConfigureApplicationCookie(options =>
{
    // Cookie settings
    options.Cookie.HttpOnly = true;
    options.ExpireTimeSpan = TimeSpan.FromMinutes(5);

    options.LoginPath = "/Identity/Account/Login";
    options.AccessDeniedPath = "/Identity/Account/AccessDenied";
    options.SlidingExpiration = true;
});

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseMigrationsEndPoint();
}
else
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthentication();
app.UseAuthorization();

app.MapRazorPages();

app.Run();

O código anterior configura Identity com valores da opção padrão. Os serviços são disponibilizados para o aplicativo por meio da injeção de dependência.

Identity é habilitado quando você chama UseAuthentication. UseAuthentication adiciona autenticação Middleware ao pipeline de solicitações.

O aplicativo gerado pelo modelo não usa a autorização. app.UseAuthorization é incluído para que você certifique-se de que ele seja adicionado na ordem correta caso o aplicativo adicione uma autorização. UseRouting, UseAuthentication e UseAuthorization devem ser chamados na ordem mostrada no código anterior.

Para obter mais informações sobre IdentityOptions, confira IdentityOptions e a Inicialização do aplicativo.

Scaffold, Login, LogOut e Confirmação de Registro

dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design
dotnet aspnet-codegenerator identity -dc WebApp1.Data.ApplicationDbContext --files "Account.Register;Account.Login;Account.Logout;Account.RegisterConfirmation"

dotnet aspnet-codegenerator identity -dc WebApp1.Data.ApplicationDbContext --files "Account.Register;Account.Login;Account.Logout;Account.RegisterConfirmation" --useSqLite

Examinar Registro

Quando um usuário clica no botão Registrar na página Register, a ação RegisterModel.OnPostAsync é chamada. O usuário foi criado por CreateAsync(TUser) no objeto _userManager:

public async Task<IActionResult> OnPostAsync(string returnUrl = null)
{
    returnUrl = returnUrl ?? Url.Content("~/");
    ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync())
                                          .ToList();
    if (ModelState.IsValid)
    {
        var user = new IdentityUser { UserName = Input.Email, Email = Input.Email };
        var result = await _userManager.CreateAsync(user, Input.Password);
        if (result.Succeeded)
        {
            _logger.LogInformation("User created a new account with password.");

            var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
            code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
            var callbackUrl = Url.Page(
                "/Account/ConfirmEmail",
                pageHandler: null,
                values: new { area = "Identity", userId = user.Id, code = code },
                protocol: Request.Scheme);

            await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
                $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");

            if (_userManager.Options.SignIn.RequireConfirmedAccount)
            {
                return RedirectToPage("RegisterConfirmation", 
                                      new { email = Input.Email });
            }
            else
            {
                await _signInManager.SignInAsync(user, isPersistent: false);
                return LocalRedirect(returnUrl);
            }
        }
        foreach (var error in result.Errors)
        {
            ModelState.AddModelError(string.Empty, error.Description);
        }
    }

    // If we got this far, something failed, redisplay form
    return Page();
}

Desabilitar a verificação padrão da conta

Com os modelos padrão, o usuário é redirecionado para Account.RegisterConfirmation, no qual pode selecionar um link para confirmar a conta. O padrão Account.RegisterConfirmation é usado apenas para teste. A verificação automática de conta deve ser desabilitada em um aplicativo de produção.

Para exigir uma conta confirmada e impedir o logon imediato no registro, defina DisplayConfirmAccountLink = false em /Areas/Identity/Pages/Account/RegisterConfirmation.cshtml.cs:

[AllowAnonymous]
public class RegisterConfirmationModel : PageModel
{
    private readonly UserManager<IdentityUser> _userManager;
    private readonly IEmailSender _sender;

    public RegisterConfirmationModel(UserManager<IdentityUser> userManager, IEmailSender sender)
    {
        _userManager = userManager;
        _sender = sender;
    }

    public string Email { get; set; }

    public bool DisplayConfirmAccountLink { get; set; }

    public string EmailConfirmationUrl { get; set; }

    public async Task<IActionResult> OnGetAsync(string email, string returnUrl = null)
    {
        if (email == null)
        {
            return RedirectToPage("/Index");
        }

        var user = await _userManager.FindByEmailAsync(email);
        if (user == null)
        {
            return NotFound($"Unable to load user with email '{email}'.");
        }

        Email = email;
        // Once you add a real email sender, you should remove this code that lets you confirm the account
        DisplayConfirmAccountLink = false;
        if (DisplayConfirmAccountLink)
        {
            var userId = await _userManager.GetUserIdAsync(user);
            var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
            code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
            EmailConfirmationUrl = Url.Page(
                "/Account/ConfirmEmail",
                pageHandler: null,
                values: new { area = "Identity", userId = userId, code = code, returnUrl = returnUrl },
                protocol: Request.Scheme);
        }

        return Page();
    }
}

Iniciar sessão

O formulário de Logon é exibido quando:

• O link Logon é selecionado.
• Um usuário tenta acessar uma página restrita na qual não está autorizado a acessar ou quando não foi autenticado pelo sistema.

Quando o formulário da página de login é enviado, a ação OnPostAsync é chamada. PasswordSignInAsync é chamado no objeto _signInManager.

public async Task<IActionResult> OnPostAsync(string returnUrl = null)
{
    returnUrl = returnUrl ?? Url.Content("~/");

    if (ModelState.IsValid)
    {
        // This doesn't count login failures towards account lockout
        // To enable password failures to trigger account lockout, 
        // set lockoutOnFailure: true
        var result = await _signInManager.PasswordSignInAsync(Input.Email,
                           Input.Password, Input.RememberMe, lockoutOnFailure: true);
        if (result.Succeeded)
        {
            _logger.LogInformation("User logged in.");
            return LocalRedirect(returnUrl);
        }
        if (result.RequiresTwoFactor)
        {
            return RedirectToPage("./LoginWith2fa", new
            {
                ReturnUrl = returnUrl,
                RememberMe = Input.RememberMe
            });
        }
        if (result.IsLockedOut)
        {
            _logger.LogWarning("User account locked out.");
            return RedirectToPage("./Lockout");
        }
        else
        {
            ModelState.AddModelError(string.Empty, "Invalid login attempt.");
            return Page();
        }
    }

    // If we got this far, something failed, redisplay form
    return Page();
}

Para obter informações sobre como tomar decisões de autorização, consulte Introduction to authorization in ASP.NET Core.

Fazer logoff

O link de Logoff invoca a ação LogoutModel.OnPost.

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.Extensions.Logging;
using System.Threading.Tasks;

namespace WebApp1.Areas.Identity.Pages.Account
{
    [AllowAnonymous]
    public class LogoutModel : PageModel
    {
        private readonly SignInManager<IdentityUser> _signInManager;
        private readonly ILogger<LogoutModel> _logger;

        public LogoutModel(SignInManager<IdentityUser> signInManager, ILogger<LogoutModel> logger)
        {
            _signInManager = signInManager;
            _logger = logger;
        }

        public void OnGet()
        {
        }

        public async Task<IActionResult> OnPost(string returnUrl = null)
        {
            await _signInManager.SignOutAsync();
            _logger.LogInformation("User logged out.");
            if (returnUrl != null)
            {
                return LocalRedirect(returnUrl);
            }
            else
            {
                return RedirectToPage();
            }
        }
    }
}

No código anterior, o código return RedirectToPage(); precisa ser um redirecionamento para que o navegador execute uma nova solicitação e a identidade do usuário seja atualizada.

SignOutAsync limpa as declarações do usuário armazenadas em cookie.

A postagem é especificada em Pages/Shared/_LoginPartial.cshtml:

@using Microsoft.AspNetCore.Identity
@inject SignInManager<IdentityUser> SignInManager
@inject UserManager<IdentityUser> UserManager

<ul class="navbar-nav">
@if (SignInManager.IsSignedIn(User))
{
    <li class="nav-item">
        <a  class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Manage/Index" 
                                              title="Manage">Hello @User.Identity.Name!</a>
    </li>
    <li class="nav-item">
        <form class="form-inline" asp-area="Identity" asp-page="/Account/Logout" 
                                  asp-route-returnUrl="@Url.Page("/", new { area = "" })" 
                                  method="post" >
            <button  type="submit" class="nav-link btn btn-link text-dark">Logout</button>
        </form>
    </li>
}
else
{
    <li class="nav-item">
        <a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Register">Register</a>
    </li>
    <li class="nav-item">
        <a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Login">Login</a>
    </li>
}
</ul>

Teste Identity

Os modelos de projeto da web padrão permitem acesso anônimo às páginas iniciais. Para testar Identity, adicione [Authorize]:

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.Extensions.Logging;

namespace WebApp1.Pages
{
    [Authorize]
    public class PrivacyModel : PageModel
    {
        private readonly ILogger<PrivacyModel> _logger;

        public PrivacyModel(ILogger<PrivacyModel> logger)
        {
            _logger = logger;
        }

        public void OnGet()
        {
        }
    }
}

Se estiver conectado, desconecte-se. Execute o aplicativo e selecione o link Privacy. Você é redirecionado à página de logon.

Explorar o Identity

Para explorar Identity em mais detalhes:

• Criar a identidade completa da origem da interface do usuário
• Examine o código-fonte de cada página e percorra passo a passo no depurador.

Componentes do Identity

Todos os pacotes NuGet dependentes do Identity estão incluídos na estrutura compartilhada ASP.NET Core.

O principal pacote para Identity é Microsoft.AspNetCore.Identity. Esse pacote contém o conjunto principal de interfaces para ASP.NET Core Identity e é incluído por Microsoft.AspNetCore.Identity.EntityFrameworkCore.

Migrando para ASP.NET Core Identity

Para obter mais informações e orientações sobre como migrar sua loja existente Identity, consulte Migrar autenticação e Identity.

Como definir a força da senha

Confira a Configuração para ver um exemplo que define os requisitos mínimos de senha.

AddDefaultIdentity e AddIdentity

AddDefaultIdentity foi introduzido no ASP.NET Core 2.1. Chamar AddDefaultIdentity é semelhante a chamar o seguinte:

• AddIdentity
• AddDefaultUI
• AddDefaultTokenProviders

Consulte fonte de AddDefaultIdentity para obter mais informações.

Impedir a publicação de ativos estáticos Identity

Para impedir a publicação de ativos Identity estáticos (folhas de estilo e arquivos JavaScript para Identity interface do usuário) na raiz web, adicione a propriedade ResolveStaticWebAssetsInputsDependsOn e o alvo RemoveIdentityAssets ao arquivo de projeto do aplicativo.

<PropertyGroup>
  <ResolveStaticWebAssetsInputsDependsOn>RemoveIdentityAssets</ResolveStaticWebAssetsInputsDependsOn>
</PropertyGroup>

<Target Name="RemoveIdentityAssets">
  <ItemGroup>
    <StaticWebAsset Remove="@(StaticWebAsset)" Condition="%(SourceId) == 'Microsoft.AspNetCore.Identity.UI'" />
  </ItemGroup>
</Target>

Próximas etapas

• ASP.NET Core Identity código-fonte
• Como trabalhar com funções em ASP.NET Core Identity

• Consulte este problema do GitHub para obter informações sobre como configurar Identity usando SQLite.
• Configurar o Identity
• Criar um aplicativo ASP.NET Core com dados do usuário protegidos por autorização
• Adicionar, baixar e excluir dados do usuário para Identity
• Habilitar a geração de código QR para autenticação TOTP
• Migrar Autenticação e Identity para ASP.NET Core
• Confirmação da conta e recuperação de senha
• Autenticação de dois fatores com SMS em ASP.NET Core
• Hospedar ASP.NET Core em uma fazenda web

Por Rick Anderson

ASP.NET Core Identity:

• É uma API que suporta a funcionalidade de logon da interface do usuário (UI).
• Gerencia usuários, senhas, dados de perfil, funções, declarações, tokens, confirmação por email e muito mais.

Os usuários podem criar uma conta com as informações de logon armazenadas em Identity ou podem usar um provedor de logon externo. Os provedores de logon externo suportados incluem Facebook, Google, conta Microsoft e Twitter.

Para obter informações sobre como exigir autenticação para todos os usuários do aplicativo, consulte Criar um aplicativo ASP.NET Core com dados do usuário protegidos por autorização.

O código-fonte Identity está disponível no GitHub. Gere a estrutura Scaffold Identity e exiba os arquivos gerados para revisar como o modelo interage com Identity.

Identity normalmente é configurado usando um banco de dados SQL Server para armazenar nomes de usuário, senhas e dados de perfil. Como alternativa, outro repositório persistente pode ser usado, por exemplo, Armazenamento de Tabelas do Azure.

Neste tópico, você aprenderá a usar Identity para registrar, fazer login e desconectar um usuário. Observação: os modelos tratam o nome de usuário e o email como os mesmos para os usuários. Para obter instruções mais detalhadas sobre como criar aplicativos que usam Identity, confira Próximas Etapas.

Plataforma de identidade doMicrosoft é:

• Uma evolução da plataforma de desenvolvedor Azure Active Directory (Azure AD).
• Uma solução de identidade alternativa para autenticação e autorização em aplicativos ASP.NET Core.
• Não relacionado a ASP.NET Core Identity.

ASP.NET Core Identity adiciona a funcionalidade de logon da interface do usuário (IU) para aplicativos web do ASP.NET Core. Para proteger APIs Web e SPAs, use uma das seguintes opções:

• Microsoft Entra ID
• Duende IdentityServer. O IdentityServer da Duende é um produto de terceiros.

O Duende IdentityServer é uma estrutura OpenID Connect e OAuth 2.0 para ASP.NET Core. O IdentityServer da Duende habilita os seguintes recursos de segurança:

• AaaS (autenticação como serviço)
• SSO (logon único) em vários tipos de aplicativo
• Controle de acesso para APIs
• Portal de Federação

Para obter mais informações, consulte Visão geral do Duende IdentityServer.

Para obter mais informações sobre outros provedores de autenticação, consulte Conjunto de opções de autenticação do OSS para ASP.NET Core

Veja ou baixe o código de exemplo (como baixar).

Criar um aplicativo Web com autenticação

Crie um aplicativo Web ASP.NET Core project com contas de usuário individuais.

dotnet new webapp --auth Individual -o WebApp1

dotnet new webapp --auth Individual -uld -o WebApp1

O projeto gerado fornece ASP.NET Core Identity como uma biblioteca de classes Razor. A biblioteca de classes IdentityRazor expõe os pontos de extremidade com a área Identity. Por exemplo:

• /Identity/Conta/Logon
• /Identity/Account/Logout
• /Identity/Conta/Gerenciar

Executar migrações

Aplique as migrações para inicializar o banco de dados.

  dotnet tool install --global dotnet-ef

dotnet ef database update

Teste de Registro e Login

Execute o aplicativo e registre um usuário. Dependendo do tamanho da tela, talvez você precise selecionar o botão de alternância de navegação para conferir os links Registrar e Logon.

Exibição do banco de dados Identity

Configurar os serviços Identity

Os serviços são adicionados em ConfigureServices. O padrão típico consiste em chamar todos os métodos Add{Service} e, em seguida, chamar todos os métodos services.Configure{Service}.

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>(options =>
     // options.UseSqlite(
        options.UseSqlServer(
            Configuration.GetConnectionString("DefaultConnection")));
    services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
        .AddEntityFrameworkStores<ApplicationDbContext>();
    services.AddRazorPages();

    services.Configure<IdentityOptions>(options =>
    {
        // Password settings.
        options.Password.RequireDigit = true;
        options.Password.RequireLowercase = true;
        options.Password.RequireNonAlphanumeric = true;
        options.Password.RequireUppercase = true;
        options.Password.RequiredLength = 6;
        options.Password.RequiredUniqueChars = 1;

        // Lockout settings.
        options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5);
        options.Lockout.MaxFailedAccessAttempts = 5;
        options.Lockout.AllowedForNewUsers = true;

        // User settings.
        options.User.AllowedUserNameCharacters =
        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@+";
        options.User.RequireUniqueEmail = false;
    });

    services.ConfigureApplicationCookie(options =>
    {
        // Cookie settings
        options.Cookie.HttpOnly = true;
        options.ExpireTimeSpan = TimeSpan.FromMinutes(5);

        options.LoginPath = "/Identity/Account/Login";
        options.AccessDeniedPath = "/Identity/Account/AccessDenied";
        options.SlidingExpiration = true;
    });
}

O código destacado anteriormente configura Identity com valores de opção padrão. Os serviços são disponibilizados para o aplicativo por meio da injeção de dependência.

Identity é habilitado quando você chama UseAuthentication. UseAuthentication adiciona autenticação Middleware ao pipeline de solicitações.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
        app.UseDatabaseErrorPage();
    }
    else
    {
        app.UseExceptionHandler("/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();
    app.UseStaticFiles();

    app.UseRouting();

    app.UseAuthentication();
    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapRazorPages();
    });
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>(options =>
        // options.UseSqlite(
        options.UseSqlServer(
            Configuration.GetConnectionString("DefaultConnection")));
    services.AddDatabaseDeveloperPageExceptionFilter();
    services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
        .AddEntityFrameworkStores<ApplicationDbContext>();
    services.AddRazorPages();

    services.Configure<IdentityOptions>(options =>
    {
        // Password settings.
        options.Password.RequireDigit = true;
        options.Password.RequireLowercase = true;
        options.Password.RequireNonAlphanumeric = true;
        options.Password.RequireUppercase = true;
        options.Password.RequiredLength = 6;
        options.Password.RequiredUniqueChars = 1;

        // Lockout settings.
        options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5);
        options.Lockout.MaxFailedAccessAttempts = 5;
        options.Lockout.AllowedForNewUsers = true;

        // User settings.
        options.User.AllowedUserNameCharacters =
        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@+";
        options.User.RequireUniqueEmail = false;
    });

    services.ConfigureApplicationCookie(options =>
    {
        // Cookie settings
        options.Cookie.HttpOnly = true;
        options.ExpireTimeSpan = TimeSpan.FromMinutes(5);

        options.LoginPath = "/Identity/Account/Login";
        options.AccessDeniedPath = "/Identity/Account/AccessDenied";
        options.SlidingExpiration = true;
    });
}

O código anterior configura Identity com valores da opção padrão. Os serviços são disponibilizados para o aplicativo por meio da injeção de dependência.

Identity é habilitado quando você chama UseAuthentication. UseAuthentication adiciona autenticação Middleware ao pipeline de solicitações.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
        app.UseMigrationsEndPoint();
    }
    else
    {
        app.UseExceptionHandler("/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();
    app.UseStaticFiles();

    app.UseRouting();

    app.UseAuthentication();
    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapRazorPages();
    });
}

O aplicativo gerado pelo modelo não usa a autorização. app.UseAuthorization é incluído para que você certifique-se de que ele seja adicionado na ordem correta caso o aplicativo adicione uma autorização. UseRouting, UseAuthentication, UseAuthorization e UseEndpoints devem ser chamados na ordem mostrada no código anterior.

Para obter mais informações sobre IdentityOptions e Startup, confira IdentityOptions e Inicialização do aplicativo.

Scaffold, Login, LogOut e Confirmação de Registro

dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design
dotnet aspnet-codegenerator identity -dc WebApp1.Data.ApplicationDbContext --files "Account.Register;Account.Login;Account.Logout;Account.RegisterConfirmation"

dotnet aspnet-codegenerator identity -dc WebApp1.Data.ApplicationDbContext --files "Account.Register;Account.Login;Account.Logout;Account.RegisterConfirmation" --useSqLite

Examinar Registro

Quando um usuário clica no botão Registrar na página Register, a ação RegisterModel.OnPostAsync é chamada. O usuário foi criado por CreateAsync(TUser) no objeto _userManager:

public async Task<IActionResult> OnPostAsync(string returnUrl = null)
{
    returnUrl = returnUrl ?? Url.Content("~/");
    ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync())
                                          .ToList();
    if (ModelState.IsValid)
    {
        var user = new IdentityUser { UserName = Input.Email, Email = Input.Email };
        var result = await _userManager.CreateAsync(user, Input.Password);
        if (result.Succeeded)
        {
            _logger.LogInformation("User created a new account with password.");

            var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
            code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
            var callbackUrl = Url.Page(
                "/Account/ConfirmEmail",
                pageHandler: null,
                values: new { area = "Identity", userId = user.Id, code = code },
                protocol: Request.Scheme);

            await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
                $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");

            if (_userManager.Options.SignIn.RequireConfirmedAccount)
            {
                return RedirectToPage("RegisterConfirmation", 
                                      new { email = Input.Email });
            }
            else
            {
                await _signInManager.SignInAsync(user, isPersistent: false);
                return LocalRedirect(returnUrl);
            }
        }
        foreach (var error in result.Errors)
        {
            ModelState.AddModelError(string.Empty, error.Description);
        }
    }

    // If we got this far, something failed, redisplay form
    return Page();
}

Desabilitar a verificação padrão da conta

Com os modelos padrão, o usuário é redirecionado para Account.RegisterConfirmation, no qual pode selecionar um link para confirmar a conta. O padrão Account.RegisterConfirmation é usado apenas para teste. A verificação automática de conta deve ser desabilitada em um aplicativo de produção.

Para exigir uma conta confirmada e impedir o logon imediato no registro, defina DisplayConfirmAccountLink = false em /Areas/Identity/Pages/Account/RegisterConfirmation.cshtml.cs:

[AllowAnonymous]
public class RegisterConfirmationModel : PageModel
{
    private readonly UserManager<IdentityUser> _userManager;
    private readonly IEmailSender _sender;

    public RegisterConfirmationModel(UserManager<IdentityUser> userManager, IEmailSender sender)
    {
        _userManager = userManager;
        _sender = sender;
    }

    public string Email { get; set; }

    public bool DisplayConfirmAccountLink { get; set; }

    public string EmailConfirmationUrl { get; set; }

    public async Task<IActionResult> OnGetAsync(string email, string returnUrl = null)
    {
        if (email == null)
        {
            return RedirectToPage("/Index");
        }

        var user = await _userManager.FindByEmailAsync(email);
        if (user == null)
        {
            return NotFound($"Unable to load user with email '{email}'.");
        }

        Email = email;
        // Once you add a real email sender, you should remove this code that lets you confirm the account
        DisplayConfirmAccountLink = false;
        if (DisplayConfirmAccountLink)
        {
            var userId = await _userManager.GetUserIdAsync(user);
            var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
            code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
            EmailConfirmationUrl = Url.Page(
                "/Account/ConfirmEmail",
                pageHandler: null,
                values: new { area = "Identity", userId = userId, code = code, returnUrl = returnUrl },
                protocol: Request.Scheme);
        }

        return Page();
    }
}

Iniciar sessão

O formulário de Logon é exibido quando:

• O link Logon é selecionado.
• Um usuário tenta acessar uma página restrita na qual não está autorizado a acessar ou quando não foi autenticado pelo sistema.

Quando o formulário da página de login é enviado, a ação OnPostAsync é chamada. PasswordSignInAsync é chamado no objeto _signInManager.

public async Task<IActionResult> OnPostAsync(string returnUrl = null)
{
    returnUrl = returnUrl ?? Url.Content("~/");

    if (ModelState.IsValid)
    {
        // This doesn't count login failures towards account lockout
        // To enable password failures to trigger account lockout, 
        // set lockoutOnFailure: true
        var result = await _signInManager.PasswordSignInAsync(Input.Email,
                           Input.Password, Input.RememberMe, lockoutOnFailure: true);
        if (result.Succeeded)
        {
            _logger.LogInformation("User logged in.");
            return LocalRedirect(returnUrl);
        }
        if (result.RequiresTwoFactor)
        {
            return RedirectToPage("./LoginWith2fa", new
            {
                ReturnUrl = returnUrl,
                RememberMe = Input.RememberMe
            });
        }
        if (result.IsLockedOut)
        {
            _logger.LogWarning("User account locked out.");
            return RedirectToPage("./Lockout");
        }
        else
        {
            ModelState.AddModelError(string.Empty, "Invalid login attempt.");
            return Page();
        }
    }

    // If we got this far, something failed, redisplay form
    return Page();
}

Para obter informações sobre como tomar decisões de autorização, consulte Introduction to authorization in ASP.NET Core.

Fazer logoff

O link de Logoff invoca a ação LogoutModel.OnPost.

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.Extensions.Logging;
using System.Threading.Tasks;

namespace WebApp1.Areas.Identity.Pages.Account
{
    [AllowAnonymous]
    public class LogoutModel : PageModel
    {
        private readonly SignInManager<IdentityUser> _signInManager;
        private readonly ILogger<LogoutModel> _logger;

        public LogoutModel(SignInManager<IdentityUser> signInManager, ILogger<LogoutModel> logger)
        {
            _signInManager = signInManager;
            _logger = logger;
        }

        public void OnGet()
        {
        }

        public async Task<IActionResult> OnPost(string returnUrl = null)
        {
            await _signInManager.SignOutAsync();
            _logger.LogInformation("User logged out.");
            if (returnUrl != null)
            {
                return LocalRedirect(returnUrl);
            }
            else
            {
                return RedirectToPage();
            }
        }
    }
}

No código anterior, o código return RedirectToPage(); precisa ser um redirecionamento para que o navegador execute uma nova solicitação e a identidade do usuário seja atualizada.

SignOutAsync limpa as declarações do usuário armazenadas em cookie.

A postagem é especificada em Pages/Shared/_LoginPartial.cshtml:

@using Microsoft.AspNetCore.Identity
@inject SignInManager<IdentityUser> SignInManager
@inject UserManager<IdentityUser> UserManager

<ul class="navbar-nav">
@if (SignInManager.IsSignedIn(User))
{
    <li class="nav-item">
        <a  class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Manage/Index" 
                                              title="Manage">Hello @User.Identity.Name!</a>
    </li>
    <li class="nav-item">
        <form class="form-inline" asp-area="Identity" asp-page="/Account/Logout" 
                                  asp-route-returnUrl="@Url.Page("/", new { area = "" })" 
                                  method="post" >
            <button  type="submit" class="nav-link btn btn-link text-dark">Logout</button>
        </form>
    </li>
}
else
{
    <li class="nav-item">
        <a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Register">Register</a>
    </li>
    <li class="nav-item">
        <a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Login">Login</a>
    </li>
}
</ul>

Teste Identity

Os modelos de projeto da web padrão permitem acesso anônimo às páginas iniciais. Para testar Identity, adicione [Authorize]:

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.Extensions.Logging;

namespace WebApp1.Pages
{
    [Authorize]
    public class PrivacyModel : PageModel
    {
        private readonly ILogger<PrivacyModel> _logger;

        public PrivacyModel(ILogger<PrivacyModel> logger)
        {
            _logger = logger;
        }

        public void OnGet()
        {
        }
    }
}

Se estiver conectado, desconecte-se. Execute o aplicativo e selecione o link Privacy. Você é redirecionado à página de logon.

Explorar o Identity

Para explorar Identity em mais detalhes:

• Criar a identidade completa da origem da interface do usuário
• Examine o código-fonte de cada página e percorra passo a passo no depurador.

Componentes do Identity

Todos os pacotes NuGet dependentes do Identity estão incluídos na estrutura compartilhada ASP.NET Core.

O principal pacote para Identity é Microsoft.AspNetCore.Identity. Esse pacote contém o conjunto principal de interfaces para ASP.NET Core Identity e é incluído por Microsoft.AspNetCore.Identity.EntityFrameworkCore.

Migrando para ASP.NET Core Identity

Para obter mais informações e orientações sobre como migrar sua loja existente Identity, consulte Migrar autenticação e Identity.

Como definir a força da senha

Confira a Configuração para ver um exemplo que define os requisitos mínimos de senha.

Impedir a publicação de ativos estáticos Identity

Para impedir a publicação de ativos Identity estáticos (folhas de estilo e arquivos JavaScript para Identity interface do usuário) na raiz web, adicione a propriedade ResolveStaticWebAssetsInputsDependsOn e o alvo RemoveIdentityAssets ao arquivo de projeto do aplicativo.

<PropertyGroup>
  <ResolveStaticWebAssetsInputsDependsOn>RemoveIdentityAssets</ResolveStaticWebAssetsInputsDependsOn>
</PropertyGroup>

<Target Name="RemoveIdentityAssets">
  <ItemGroup>
    <StaticWebAsset Remove="@(StaticWebAsset)" Condition="%(SourceId) == 'Microsoft.AspNetCore.Identity.UI'" />
  </ItemGroup>
</Target>

Próximas etapas

• ASP.NET Core Identity código-fonte
• AddDefaultIdentity fonte
• Consulte este problema do GitHub para obter informações sobre como configurar Identity usando SQLite.
• Configurar o Identity
• Criar um aplicativo ASP.NET Core com dados do usuário protegidos por autorização
• Adicionar, baixar e excluir dados do usuário para Identity
• Habilitar a geração de código QR para autenticação TOTP
• Migrar Autenticação e Identity para ASP.NET Core
• Confirmação da conta e recuperação de senha
• Autenticação de dois fatores com SMS em ASP.NET Core
• Hospedar ASP.NET Core em uma fazenda web