Úvod do Identity na ASP.NET Core

IdentityASP.NET Core:

• 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 vyžadovat ověřování pro všechny uživatele aplikace, najdete v tématu Vytvoření aplikace ASP.NET Core s uživatelskými daty chráněnými autorizací.

Zdrojový kód Identity je k dispozici na GitHub. 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 Server k ukládání uživatelských jmen, hesel a dat profilu. Alternativně lze 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 dokumentaci ASP.NET Core Blazor ověřování a autorizace a články, které ho následují v dokumentaci Blazor.

ASP.NET Core Identity nesouvisí s platformou Microsoft Identity Platform. 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á funkcionalitu přihlášení pomocí uživatelského rozhraní do webových aplikací ASP.NET Core. K zabezpečení webových rozhraní API a spA použijte jednu z následujících možností:

• Microsoft Entra ID
• 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 k 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).

Zobrazit nebo stáhnout ukázkový kód (jak stahovat).

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

Vytvořte ASP.NET Core Blazor Web App project 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. Zvolte 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

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ý project zahrnuje komponenty IdentityRazor. Komponenty se nacházejí ve složce Components/Account serveru project. 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. Při generování Blazor Web App s Individuálními účty jsou vygenerovanému projektu zahrnuty komponenty IdentityRazor. Komponenty IdentityRazor lze také zkontrolovat ve složce projektu Components/Account v šabloně projektu Blazor Web App (dotnet/aspnetcore úložiště GitHub).

Note

Odkazy na dokumentaci ke .NET referenčnímu zdroji obvykle načítají výchozí větev úložiště, která představuje aktuální vývoj pro příští verzi .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 Postup výběru značky verze zdrojového kódu ASP.NET Core (dotnet/AspNetCore.Docs #26205).

Další informace najdete v ASP.NET Core Blazor ověřování a autorizaci a následujících článcích v dokumentaci Blazor. Většina článků v Security a Identity oblasti hlavní sady dokumentace ASP.NET Core platí pro aplikace Blazor. Blazor Sada dokumentace ale obsahuje články a pokyny, které nahrazují nebo přidávají informace. Doporučujeme nejprve studovat sadu obecné dokumentace ASP.NET Core, po které následuje přístup k článkům v dokumentaci BlazorSecurity a Identity.

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

Vytvořte project webové aplikace ASP.NET Core (Razor Pages) s jednotlivými účty.

Visual Studio

• Vyberte šablonu webové aplikace ASP.NET Core (Razor Pages). Zvolte Další.
• Jako typ ověřování vyberte jednotlivé účty.
• Vyberte Vytvořit.

.NET

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ý project poskytuje ASP.NET Core Identity jako knihovnu tříd Razor (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, podívejte se na referenční zdroj ASP.NET Core (dotnet/aspnetcore GitHub úložiště, 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 Scaffold Identity v projektech ASP.NET Core.

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

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

Visual Studio

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

.NET

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ý project poskytuje ASP.NET Core Identity jako knihovnu tříd Razor (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, podívejte se na referenční zdroj ASP.NET Core (dotnet/aspnetcore GitHub úložiště, 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 Scaffold 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

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 pro EF Core najdete v referenčních informacích k nástrojům EF Core 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, přečtěte si, jak použít dotnet tool install příkaz s možností --arch. Další informace najdete v části GitHub dotnet/aspnetcore.docs issue #29262 - Přidání parametru „-a arm64“ na Apple Silicon.

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

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 Core 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 pokynů Scaffold identity do Razor projekt s autorizací a vygenerujte kód uvedený v této části.

.NET

Pokud jste vytvořili project 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 vytváření Identity najdete v tématu Razor.

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 ke stránce s omezeným přístupem, ke které nemá povolení nebo když nebyli ověřeni systémem.

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 Introduction 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í webové projektové šablony umožňují anonymní přístup na domovské stránky. 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.

Součásti služby Identity

Všechny balíčky NuGet závislé na Identity 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 Identity a 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 byl zaveden v ASP.NET Core 2.1. Volání AddDefaultIdentity je podobné následujícímu volání:

• AddIdentity
• AddDefaultUI
• AddDefaultTokenProviders

Další informace najdete v tématu AddDefaultIdentity source.

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

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

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

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

Další kroky

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

• Informace o konfiguraci Identity pomocí SQLite najdete v tématu Jak nakonfigurovat Identity pro SQLite (dotnet/AspNetCore.Docs #5131).
• Konfigurace 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ěřování TOTP
• Identity
• Potvrzení účtu a obnovení hesla
• Vícefaktorové ověřování v ASP.NET Core
• Host ASP.NET Core ve webové farmě