Úvod do Identity ASP.NET Core

ASP.NET Core Identity:

• Je rozhraní API, které podporuje funkce přihlášení pomocí uživatelského rozhraní.
• Spravuje uživatele, hesla, profilová data, role, deklarace identity, tokeny, potvrzení e-mailu a další.

Uživatelé můžou vytvořit účet s přihlašovacími údaji uloženými v Identity nebo můžou použít externího zprostředkovatele přihlášení. Mezi podporované externí zprostředkovatele přihlášení patří Facebook, Google, Účet Microsoft a Twitter.

Informace o tom, jak globálně vyžadovat ověření všech uživatelů, najdete v tématu Vyžadování ověřených uživatelů.

Identity Zdrojový kód je k dispozici na GitHubu. Generování uživatelského rozhraní Identity a zobrazení vygenerovaných souborů pro kontrolu interakce šablony s Identity.

Identity se obvykle konfiguruje pomocí databáze SQL Serveru k ukládání uživatelských jmen, hesel a dat profilu. Alternativně je možné použít jiné trvalé úložiště, například Azure Table Storage.

V tomto tématu se dozvíte, jak se pomocí Identity registrace, přihlášení a odhlášení uživatele. Poznámka: Šablony považují uživatelské jméno a e-maily za stejné pro uživatele. Podrobnější pokyny k vytváření aplikací, které používají Identity, najdete v tématu Další kroky.

Další informace o Identity v aplikacích Blazor najdete v ASP.NET Core ověřování a autorizace Blazor a články, které jej následují v Blazor dokumentaci.

ASP.NET Core Identity nesouvisí s platformou identity Microsoft. Microsoft Identity Platform je:

• Vývoj vývojářské platformy Azure Active Directory (Azure AD).
• Alternativní řešení identit pro ověřování a autorizaci v aplikacích ASP.NET Core

ASP.NET Core Identity přidává do webových aplikací ASP.NET Core funkce přihlášení uživatelského rozhraní. K zabezpečení webových rozhraní API a spA použijte jednu z následujících možností:

• Microsoft Entra ID
• Azure Active Directory B2C (Azure AD B2C)
• Duende Identity Server

Duende Identity Server je architektura OpenID Connect a OAuth 2.0 pro ASP.NET Core. Duende Identity Server umožňuje následující funkce zabezpečení:

• Ověřování jako služba (AaaS)
• Jednotné přihlašování nebo vypnutí (SSO) u více typů aplikací
• Řízení přístupu pro rozhraní API
• Federační brána

Important

Duende Software může vyžadovat, abyste zaplatili licenční poplatek za produkční využití serveru Duende Identity Server. Další informace najdete v tématu Migrace z ASP.NET Core v .NET 5 na .NET 6.

Další informace najdete v dokumentaci k Duende Identity Serveru (web Duende Software).

Zobrazení nebo stažení ukázkového kódu (postup stažení)

Vytvořte Blazor Web App s ověřováním

Vytvořte projekt ASP.NET Core Blazor Web App s individuálními účty.

Note

Pro více informací o prostředí Pages se podívejte do části Razor.

Pro více o MVC, podívejte se na část Vytvoření aplikace MVC s ověřováním.

Visual Studio

• Blazor Web App Vyberte šablonu. Vyberte Další.
• Proveďte následující výběry:
  • Typ ověřování: Jednotlivé účty
  • Interaktivní režim vykreslování: Server
  • Umístění interaktivity: Globální
• Vyberte Vytvořit.

.NET CLI

dotnet new blazor -au Individual -o BlazorApp1

Tato -o|--output možnost vytvoří složku pro aplikaci a nastaví název aplikace nebo obor názvů.

Předchozí příkaz vytvoří Blazor Web App pomocí SQLite. Pokud chcete vytvořit aplikaci pomocí LocalDB, spusťte následující příkaz:

dotnet new blazor -au Individual -uld -o BlazorApp1

Vygenerovaný projekt obsahuje IdentityRazor komponenty. Komponenty se nacházejí ve Components/Account složce projektu serveru. Například:

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

Identity Razor komponenty jsou popsány jednotlivě v dokumentaci pro konkrétní případy použití a mohou se měnit s každým vydáním. Když vygenerujete Blazor Web App s jednotlivými účty, budou součástí IdentityRazor komponenty vygenerovaného projektu. Komponenty IdentityRazor je možné také zkontrolovat ve Components/Account složce projektu serveru v Blazor Web App šabloně projektu (dotnet/aspnetcore úložiště GitHub).

Note

Odkazy na referenční zdroj .NET v dokumentaci obvykle otevřou výchozí větev úložiště, která představuje aktuální vývoj další verze .NET. Pokud chcete vybrat značku pro konkrétní verzi, použijte rozevírací seznam pro přepnutí mezi větvemi nebo značkami. Další informace najdete v tématu Jak vybrat značku verze zdrojového kódu ASP.NET Core (dotnet/AspNetCore.Docs #26205).

Další informace najdete v tématu ASP.NET Core Ověřování a autorizaceBlazor a v článcích, které na něj navazují v Blazor dokumentaci. Většina článků v části Zabezpečení a Identity oblast hlavní sady dokumentace ASP.NET Core platí pro Blazor aplikace. Blazor Sada dokumentace ale obsahuje články a pokyny, které nahrazují nebo přidávají informace. Doporučujeme nejprve studovat obecnou sadu dokumentace pro ASP.NET Core, po které následuje přístup k článkům v tématu BlazorZabezpečení a Identity dokumentace.

Vytvořte Razor aplikaci Pages s ověřováním

Vytvořte projekt ASP.NET základní webové aplikace (Razor stránky) s jednotlivými účty.

Visual Studio

• Vyberte šablonu ASP.NET Základní webová aplikace (Razorstránky). Vyberte Další.
• Jako typ ověřování vyberte jednotlivé účty.
• Vyberte Vytvořit.

.NET CLI

dotnet new webapp -au Individual -o WebApp1

Tato -o|--output možnost vytvoří složku pro aplikaci a nastaví název aplikace nebo obor názvů.

Předchozí příkaz vytvoří Razor aplikaci Pages pomocí SQLite. Pokud chcete vytvořit aplikaci pomocí LocalDB, spusťte následující příkaz:

dotnet new webapp -au Individual -uld -o WebApp1

Vygenerovaný projekt poskytuje ASP.NET Core Identity jako Razor knihovnu tříd (RCL). Knihovna IdentityRazor tříd zveřejňuje koncové body s Identity rozsahem. Například:

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

Stránky jsou popsány jednotlivě v dokumentaci pro konkrétní případy použití a mohou se změnit při každém vydání. Pokud chcete zobrazit všechny stránky v seznamu RCL, přečtěte si referenční zdroj ASP.NET Core (dotnet/aspnetcoreúložiště GitHub, Identity/UI/src/Areas/Identity/Pages složka). V aplikaci můžete navrhnout jednotlivé stránky nebo všechny stránky. Další informace najdete v tématu Generování uživatelského rozhraní Identity v projektech ASP.NET Core.

Vytvoření aplikace MVC s ověřováním

Vytvořte projekt ASP.NET Core MVC s individuálními účty.

Visual Studio

• Vyberte šablonu ASP.NET Core Web App (model –View-Controller). Vyberte Další.
• Jako typ ověřování vyberte jednotlivé účty.
• Vyberte Vytvořit.

.NET CLI

dotnet new mvc -au Individual -o WebApplication1

Tato -o|--output možnost vytvoří složku pro aplikaci a nastaví název aplikace nebo obor názvů.

Předchozí příkaz vytvoří aplikaci MVC pomocí SQLite. Pokud chcete vytvořit webovou aplikaci pomocí LocalDB, spusťte následující příkaz:

dotnet new mvc -au Individual -uld -o WebApplication1

Vygenerovaný projekt poskytuje ASP.NET Core Identity jako Razor knihovnu tříd (RCL). Knihovna IdentityRazor tříd je založena na Razor stránkách a zveřejňuje rozhraní s Identity zónou. Například:

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

Stránky jsou popsány jednotlivě v dokumentaci pro konkrétní případy použití a mohou se změnit při každém vydání. Pokud chcete zobrazit všechny stránky v seznamu RCL, přečtěte si referenční zdroj ASP.NET Core (dotnet/aspnetcoreúložiště GitHub, Identity/UI/src/Areas/Identity/Pages složka). V aplikaci můžete navrhnout jednotlivé stránky nebo všechny stránky. Další informace najdete v tématu Generování uživatelského rozhraní Identity v projektech ASP.NET Core.

Provedení migrací

Použijte migrace k inicializaci databáze.

Visual Studio

V konzole Správce balíčků (PMC) spusťte následující příkaz:

Update-Database

.NET CLI

Migrace nejsou v tomto kroku při použití SQLite nezbytné.

Pokud dotnet ef není nainstalovaný, nainstalujte ho jako globální nástroj:

  dotnet tool install --global dotnet-ef

Další informace o rozhraní příkazového řádku najdete EF CoreEF Core v referenčních informacích k nástrojům pro .NET CLI.

Note

Ve výchozím nastavení architektura binárních souborů .NET, které se mají nainstalovat, představuje aktuálně spuštěnou architekturu operačního systému. Pokud chcete zadat jinou architekturu operačního systému, přečtěte si téma instalace nástroje dotnet, možnost --arch. Další informace najdete v tématu o problému GitHubu dotnet/AspNetCore.Docs #29262.

V případě LocalDB spusťte následující příkaz:

dotnet ef database update

Testování registrace a přihlášení

Spusťte aplikaci a zaregistrujte uživatele. V závislosti na velikosti obrazovky možná budete muset vybrat přepínací tlačítko navigace, aby se zobrazily odkazy Pro registraci a přihlášení .

Identity Zobrazení databáze

Visual Studio

• V nabídce Zobrazení vyberte SQL Server Průzkumník objektů (SSOX).
• Přejděte na (localdb)MSSQLLocalDB(SQL Server 13). Klikněte pravým tlačítkem na dbo. AspNetUsers>View Data:

.NET CLI

Ke správě a zobrazení databáze SQLite můžete stáhnout mnoho nástrojů třetích stran, například prohlížeč databáze pro SQLite.

Konfigurace Identity služeb

Služby jsou přidány do Program.cs. Typickým vzorem je volání metod v následujícím pořadí:

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

Předchozí kód konfiguruje Identity výchozí hodnoty možností. Služby jsou pro aplikaci zpřístupněny prostřednictvím dependency injection.

Identity je povolen voláním UseAuthentication. UseAuthenticationpřidá middleware pro ověřování do kanálu požadavku.

Aplikace generovaná šablonou nepoužívá autorizaci. app.UseAuthorization je součástí, aby se zajistilo, že je přidaná ve správném pořadí, pokud aplikace přidá autorizaci. UseRouting, UseAuthenticationa UseAuthorization musí být volána v pořadí uvedeném v předchozím kódu.

Další informace naleznete v IdentityOptionstématu IdentityOptions a spuštění aplikace.

metriky ASP.NET Core Identity

metriky ASP.NET Core Identity poskytují možnosti monitorování pro procesy správy a ověřování uživatelů. Tyto metriky vám pomůžou rozpoznat neobvyklé vzory přihlašování, které můžou indikovat bezpečnostní hrozby, sledovat výkon operací identit a pochopit, jak uživatelé komunikují s funkcemi ověřování, jako je dvojúrovňové ověřování. Tato pozorovatelnost je obzvláště cenná pro aplikace s přísnými požadavky na zabezpečení nebo pro aplikace, u kterých dochází k vysokému ověřovacímu provozu.

Úplné podrobnosti o dostupných metrikách a jejich použití najdete v tématu ASP.NET Základní metriky.

Generování uživatelského rozhraní – Registrace, Přihlášení, Odhlášení a RegistraceConfirmace

Visual Studio

Přidejte soubor Register, LoginLogOuta RegisterConfirmation soubory. Postupujte podle identity scaffold v projektu Razor s pokyny pro autorizaci k vygenerování kódu uvedeného v této části.

.NET CLI

Pokud jste vytvořili projekt s názvem WebApp1 a nepoužíváte SQLite, spusťte následující příkazy. V opačném případě použijte správný obor názvů pro ApplicationDbContext:

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"

Pokud používáte SQLite, připojte --useSqLite nebo -sqlite:

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

PowerShell jako oddělovač příkazů používá středník. Při použití PowerShellu uvozujte středníky v seznamu souborů nebo vložte seznam souborů do dvojitých uvozovek, jak ukazuje předchozí příklad.

Další informace o generování Identitynajdete v tématu Generování identity do projektu Razor s autorizací.

Kontrola registru

Když uživatel klikne na tlačítko Zaregistrovat na Register stránce, RegisterModel.OnPostAsync vyvolá se akce. Uživatel je vytvořen CreateAsync(TUser) v objektu _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();
}

Zakázání výchozího ověření účtu

U výchozích šablon se uživatel přesměruje na Account.RegisterConfirmation, kde může vybrat odkaz pro potvrzení účtu. Výchozí hodnota Account.RegisterConfirmation se používá jenom pro testování, automatické ověření účtu by mělo být v produkční aplikaci zakázané.

Pokud chcete vyžadovat potvrzený účet a zabránit okamžitému přihlášení při registraci, nastavte v DisplayConfirmAccountLink = false:/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();
    }
}

Přihlášení

Přihlašovací formulář se zobrazí v následujících případech:

• Je vybrán odkaz Přihlásit se.
• Uživatel se pokusí získat přístup k omezené stránce, ke které nemá oprávnění k přístupu nebo když je systém neověřil.

Při odeslání formuláře na přihlašovací stránce se volá akce OnPostAsync. PasswordSignInAsync je volána u objektu _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();
}

Informace o tom, jak provádět rozhodnutí o autorizaci, najdete v tématu Úvod k autorizaci v ASP.NET Core.

Odhlášení ze systému

Odkaz Odhlásit se vyvolá akci 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();
            }
        }
    }
}

V předchozím kódu musí být kód return RedirectToPage(); přesměrováním, aby prohlížeč provedl nový požadavek a aktualizovala se identita uživatele.

SignOutAsync vymaže deklarace identity uživatele uložené v souboru cookie.

Příspěvek je specifikován v 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>

Zkouška Identity

Výchozí šablony webových projektů umožňují anonymní přístup k domovských stránkách. Chcete-li testovat Identity, přidejte [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()
        {
        }
    }
}

Pokud jste přihlášení, odhlaste se. Spusťte aplikaci a vyberte Privacy odkaz. Budete přesměrováni na přihlašovací stránku.

Prozkoumat Identity

Abychom Identity prozkoumali podrobněji:

• Vytvoření kompletního zdroje uživatelského rozhraní pro identitu
• Prozkoumejte zdroj každé stránky a procházejte krok za krokem ladicím programem.

Identity Součásti

IdentityVšechny balíčky NuGet závislé na nuGetu jsou součástí sdílené architektury ASP.NET Core.

Primárním balíčkem je Identity Microsoft.AspNetCore.Identity. Tento balíček obsahuje základní sadu rozhraní pro ASP.NET Core Identitya je součástí Microsoft.AspNetCore.Identity.EntityFrameworkCore.

Migrace na ASP.NET Core Identity

Další informace a pokyny k migraci stávajícího Identity obchodu najdete v tématu Migrace ověřování a Identity.

Nastavení síly hesla

Viz ukázku Konfigurace která určuje minimální požadavky na heslo.

AddDefaultIdentity a AddIdentity

AddDefaultIdentity byla zavedena v ASP.NET Core 2.1. Volání AddDefaultIdentity je podobné následujícímu volání:

• AddIdentity
• AddDefaultUI
• AddDefaultTokenProviders

Další informace najdete ve zdroji AddDefaultIdentity.

Zabraňte publikování statických Identity souborů

Pokud chcete zabránit publikování statických Identity prostředků (šablon stylů a souborů JavaScriptu pro Identity uživatelské rozhraní) do kořenového adresáře webu, přidejte do souboru projektu aplikace následující ResolveStaticWebAssetsInputsDependsOn vlastnost a RemoveIdentityAssets cíl:

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

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

Další kroky

• Ověřování a autorizace ASP.NET Core Blazor
• zdrojový kód ASP.NET Core Identity
• Jak pracovat s rolemi v ASP.NET Core Identity

• Informace o konfiguraci Identity pomocí SQLite naleznete v tématu Konfigurace Identity pro SQLite (dotnet/AspNetCore.Docs #5131).
• Konfigurovat Identity
• Vytvoření aplikace ASP.NET Core s uživatelskými daty chráněnými autorizací
• Přidání, stažení a odstranění uživatelských dat do Identity projektu ASP.NET Core
• Povolení generování kódu QR pro ověřovací aplikace TOTP v ASP.NET Core
• Identity
• Potvrzení účtu a obnovení hesla v ASP.NET Core
• Vícefaktorové ověřování v ASP.NET Core
• Hostování ASP.NET Core ve webové farmě