Az ASP.NET Core Identity bemutatása

ASP.NET Core Identity:

• Egy api, amely támogatja a felhasználói felület (UI) bejelentkezési funkcióit.
• Kezeli a felhasználókat, jelszavakat, profiladatokat, szerepköröket, jogcímeket, jogkivonatokat, e-mail-megerősítést stb.

A felhasználók létrehozhatnak egy fiókot a Identity tárolt bejelentkezési adatokkal, vagy használhatnak külső bejelentkezési szolgáltatót. A támogatott külső bejelentkezési szolgáltatók közé tartozik a Facebook, a Google, a Microsoft-fiók és a Twitter.

Ha tudni szeretné, hogyan követelheti meg globálisan az összes felhasználó hitelesítését, olvassa el Hitelesített felhasználók megkövetelésecímű témakört.

A Identity forráskód a GitHubon érhető el. Scaffold Identity, és tekintse meg a létrehozott fájlokat, hogy áttekintse a sablon és a Identityközötti interakciót.

Identity általában SQL Server-adatbázis használatával van konfigurálva felhasználónevek, jelszavak és profiladatok tárolására. Másik lehetőségként egy másik állandó tároló is használható, például az Azure Table Storage.

Ebben a témakörben megtudhatja, hogyan használhatja a Identity egy felhasználó regisztrálására, bejelentkezésére és kijelentkezésére. Megjegyzés: a sablonok a felhasználónevet és az e-mailt azonosként kezelik. A Identityhasználó alkalmazások létrehozásával kapcsolatos részletesebb útmutatásért lásd következő lépéseket.

További információért a Identity alkalmazásokkal kapcsolatos Blazor témában tekintse meg az ASP.NET Core Blazor hitelesítési és engedélyezési útmutatót, valamint az azt követő cikkeket a Blazor dokumentációban.

ASP.NET Core Identity nem kapcsolódik a Microsoft identitásplatformhoz. A Microsoft identitásplatformja a következő:

• Az Azure Active Directory (Azure AD) fejlesztői platformjának fejlődése.
• Alternatív identitáskezelési megoldás a hitelesítéshez és engedélyezéshez ASP.NET Core-alkalmazásokban.

ASP.NET Core Identity felhasználói felület (UI) bejelentkezési funkciót ad hozzá ASP.NET Core-webalkalmazásokhoz. A webes API-k és SPA-k védelméhez használja az alábbiak egyikét:

• Microsoft Entra-azonosító
• Azure Active Directory B2C (Azure AD B2C)
• Duende Identity Szerver

A Duende Identity Server egy OpenID Connect- és OAuth 2.0-keretrendszer ASP.NET Core-hoz. A Duende Identity Server a következő biztonsági funkciókat teszi lehetővé:

• Hitelesítés szolgáltatásként (AaaS)
• Egyszeri bejelentkezés/kijelentkezés (SSO) több alkalmazástípuson keresztül
• Hozzáférés-vezérlés API-khoz
• Szövetségi átjáró

Fontos

Duende Software esetleg licencdíjat kérhet a Duende Identity Server üzemeltetési használatáért. További információ: Migrálás ASP.NET Core-ból .NET 5-ről .NET 6-ra.

További információ: Duende Identity Server dokumentációja (Duende Software webhely).

A mintakód megtekintése vagy letöltése (hogyan kell letölteni).

Hozzon létre egy Blazor Web App hitelesítéssel

Hozzon létre egy ASP.NET Core-projektet Blazor Web App egyéni fiókokkal.

Jegyzet

Razor A Pages-élményről a Pages-alkalmazás létrehozása Razor hitelesítési szakaszában olvashat.

MVC-élményért tekintse meg az MVC-alkalmazás létrehozása hitelesítési szakaszt .

Visual Studio

• Válassza ki a sablont Blazor Web App . Válassza a Következőlehetőséget.
• Végezze el a következő beállításokat:
  • Hitelesítési típus: Egyéni fiókok
  • interaktív renderelési mód: kiszolgáló
  • Interaktivitás helye: Globális
• Válassza a Create gombot.

.NET CLI

dotnet new blazor -au Individual -o BlazorApp1

A -o|--output beállítás létrehoz egy mappát az alkalmazás számára, és beállítja az alkalmazás nevét/névterét.

Az előző parancs segítségével létrehoz egy Blazor Web App SQLite segítségével. Az alkalmazás LocalDB-vel való létrehozásához futtassa a következő parancsot:

dotnet new blazor -au Individual -uld -o BlazorApp1

A létrehozott projekt összetevőket tartalmaz IdentityRazor . Az összetevők a Components/Account mappában találhatók. Például:

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

Identity Razor az összetevőket külön-külön ismertetjük a dokumentációban az adott használati esetekre vonatkozóan, és az egyes kiadások változhatnak. Amikor egyéni fiókokkal hoz létre Blazor Web App-t, a IdentityRazor összetevők bekerülnek a létrehozott projektbe. Az IdentityRazor összetevőket a Blazor ASP.NET Core referenciaforrásdotnet/aspnetcore (GitHub-adattár) projektsablonjában is megvizsgálhatja.

Jegyzet

A .NET referenciaforrásra mutató dokumentációs hivatkozások általában betöltik az adattár alapértelmezett ágát, amely a .NET következő kiadásának aktuális fejlesztését jelöli. Egy adott kiadás címkéjének kiválasztásához használja az Ágak vagy címkék közötti váltás legördülő listát. További információ: A ASP.NET Core-forráskód (dotnet/AspNetCore.Docs #26205) verziócímkéjének kiválasztása.

További információ: ASP.NET Core-hitelesítés Blazor és -engedélyezés , valamint az azt követő cikkek a Blazor dokumentációban. A fő ASP.NET Alapdokumentáció-készlet biztonságával és Identity területével kapcsolatos cikkek többsége az alkalmazásokra Blazor vonatkozik. A Blazor dokumentációs készlet azonban olyan cikkeket és útmutatást tartalmaz, amelyek felülírják vagy hozzáadják az információkat. Javasoljuk, hogy először az általános ASP.NET Core-dokumentációt tanulmányozza, majd a Blazor dokumentációban található Identity cikkeket.

Pages-alkalmazás Razor létrehozása hitelesítéssel

Hozzon létre egy ASP.NET Core Web Application (Razor Pages) projektet egyéni fiókokkal.

Visual Studio

• Válassza ki a ASP.NET Core Web App (Razor Pages) sablont . Válassza a Következőlehetőséget.
• A hitelesítés típusához válassza az Egyéni fiókok lehetőséget.
• Válassza a Create gombot.

.NET CLI

dotnet new webapp -au Individual -o WebApp1

A -o|--output beállítás létrehoz egy mappát az alkalmazás számára, és beállítja az alkalmazás nevét/névterét.

Az előző parancs létrehoz egy Razor Pages-alkalmazást az SQLite használatával. Az alkalmazás LocalDB-vel való létrehozásához futtassa a következő parancsot:

dotnet new webapp -au Individual -uld -o WebApp1

A létrehozott projekt ASP.NET Core-t Identity biztosít osztálykódtárkéntRazor (RCL). A IdentityRazor osztálytár a végpontokat a Identity területtel teszi elérhetővé. Például:

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

A lapokat a dokumentáció külön-külön írja le adott használati esetekre vonatkozóan, és az egyes kiadások változhatnak. Az RCL összes lapjának megtekintéséhez tekintse meg a ASP.NET Core referenciaforrást (dotnet/aspnetcore GitHub-adattár, Identity/UI/src/Areas/Identity/Pages mappa). Az egyes oldalakat vagy az összes lapot be lehet illeszteni az alkalmazásba. További információ: Állványzat Identity ASP.NET Core-projektekben.

MVC-alkalmazás létrehozása hitelesítéssel

Hozzon létre egy ASP.NET Core MVC-projektet egyéni fiókokkal.

Visual Studio

• Válassza ki a ASP.NET Core Web App (Model-View-Controller) sablont. Válassza a Következőlehetőséget.
• A hitelesítés típusához válassza az Egyéni fiókok lehetőséget.
• Válassza a Create gombot.

.NET CLI

dotnet new mvc -au Individual -o WebApplication1

A -o|--output beállítás létrehoz egy mappát az alkalmazás számára, és beállítja az alkalmazás nevét/névterét.

Az előző parancs létrehoz egy MVC-alkalmazást az SQLite használatával. A webalkalmazás LocalDB-vel való létrehozásához futtassa a következő parancsot:

dotnet new mvc -au Individual -uld -o WebApplication1

A létrehozott projekt ASP.NET Core-t Identity biztosít osztálykódtárkéntRazor (RCL). Az IdentityRazor osztálykönyvtár a Razor oldalakon alapul, és végpontokat biztosít a Identity területtel. Például:

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

A lapokat a dokumentáció külön-külön írja le adott használati esetekre vonatkozóan, és az egyes kiadások változhatnak. Az RCL összes lapjának megtekintéséhez tekintse meg a ASP.NET Core referenciaforrást (dotnet/aspnetcore GitHub-adattár, Identity/UI/src/Areas/Identity/Pages mappa). Az egyes oldalakat vagy az összes lapot be lehet illeszteni az alkalmazásba. További információ: Állványzat Identity ASP.NET Core-projektekben.

Migrálások alkalmazása

Az adatbázis inicializálásához alkalmazza a migrációkat.

Visual Studio

Futtassa a következő parancsot a Package Manager-konzolon (PMC):

Update-Database

.NET CLI

Az SQLite használatakor ebben a lépésben nincs szükség migrálásra.

Ha dotnet ef nincs telepítve, telepítse globális eszközként:

  dotnet tool install --global dotnet-ef

A EF Coreparancssori felületével kapcsolatos további információkért tekintse meg EF Core .NET CLI-eszközökre vonatkozó hivatkozását.

Jegyzet

Alapértelmezés szerint a telepíteni kívánt .NET bináris fájlok architektúrája a jelenleg futó operációsrendszer-architektúrát jelöli. Ha másik operációsrendszer-architektúrát szeretne megadni, tekintse meg dotnet eszköz telepítését, az --arch lehetőséget. További információ: GitHub-probléma dotnet/AspNetCore.Docs #29262.

A LocalDB esetében futtassa a következő parancsot:

dotnet ef database update

Regisztráció és bejelentkezés tesztelése

Indítsa el az alkalmazást, majd regisztráljon felhasználót. A képernyő méretétől függően előfordulhat, hogy a navigációs váltógombot kell választania a Regisztráció és Bejelentkezési hivatkozás megtekintéséhez.

A Identity adatbázis megtekintése

Visual Studio

• A Nézet menüben válassza SQL Server Object Explorer (SSOX) lehetőséget.
• Navigáljon (localdb)MSSQLLocalDB(SQL Server 13). Kattintson jobb gombbal a dbo.AspNetUsers>Adatok megtekintése:

.NET CLI

Számos külső gyártótól származó eszközt tölthet le az SQLite-adatbázisok kezeléséhez és megtekintéséhez, például DB Browser for SQLite.

Identity-szolgáltatások konfigurálása

A szolgáltatások hozzáadva vannak Program.cs-ban. A tipikus minta a metódusok meghívása a következő sorrendben:

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

Az előző kód alapértelmezett beállításértékekkel konfigurálja Identity. Az alkalmazás számára a szolgáltatások függőséginjektálásáltal érhetők el.

Identity UseAuthenticationhívásával engedélyezve van. UseAuthentication hitelesítési köztes szoftvert hozzáadja a kéréskezelési folyamathoz.

A sablon által létrehozott alkalmazás nem használja a engedélyt. Az app.UseAuthorization beillesztésre kerül annak érdekében, hogy az engedélyezés hozzáadása esetén a megfelelő sorrend legyen biztosítva az alkalmazásban. UseRouting, UseAuthenticationés UseAuthorization az előző kódban látható sorrendben kell meghívni.

A IdentityOptions-ról további információkért lásd: IdentityOptions és az Alkalmazásindítás.

Vázszerkezetbejelentkezés, Bejelentkezés, Kijelentkezés és Regisztrációmegerősítés

Visual Studio

Adja hozzá a Register, Login, LogOutés RegisterConfirmation fájlokat. Kövesse a(z) Scaffold azonosítót egy Razor projektben a(z) engedélyezési utasításokkal, hogy létrehozza az ebben a szakaszban látható kódot.

.NET CLI

Ha a projektet WebApp1néven hozta létre, és nem használja az SQLite-et, futtassa az alábbi parancsokat. Egyébként használja a megfelelő névteret a 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"

SQLite használatakor fűzze hozzá --useSqLite vagy -sqlite:

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

A PowerShell pontosvesszőt használ parancselválasztóként. A PowerShell használatakor meneküljön el a fájllistában szereplő pontosvesszők elől, vagy tegye a fájllistát dupla idézőjelek közé, ahogy az előző példa is mutatja.

További információkért az állványzatokkal kapcsolatban Identity, lásd: Állvány identitását egy Razor projekthez az engedélyezési-tal.

Nyilvántartás vizsgálata

Amikor egy felhasználó a lapon a Register gombra kattint, a rendszer meghívja a RegisterModel.OnPostAsync műveletet. A felhasználót CreateAsync(TUser) hozza létre a _userManager objektumon:

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

Alapértelmezett fiókellenőrzés letiltása

Az alapértelmezett sablonokkal a rendszer átirányítja a felhasználót a Account.RegisterConfirmation, ahol kiválaszthat egy hivatkozást a fiók megerősítéséhez. Az alapértelmezett Account.RegisterConfirmation csak teszteléshez van beállítva , az automatikus fiókellenőrzést le kell tiltani egy éles alkalmazásban.

Ha meg szeretne követelni egy megerősített fiókot, és meg szeretné akadályozni az azonnali bejelentkezést a regisztrációkor, állítsa be a 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();
    }
}

Bejelentkezés

A bejelentkezési űrlap a következő esetekben jelenik meg:

• A Bejelentkezés hivatkozás van kiválasztva.
• A felhasználó megpróbál hozzáférni egy korlátozott laphoz, amelyhez nincs jogosultsága vagy eléréséhez, amennyiben a rendszer még nem hitelesítette őt.

A Bejelentkezési lap űrlapjának elküldésekor a rendszer meghívja a OnPostAsync műveletet. PasswordSignInAsync a _signInManager objektumon van meghívva.

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

További információ az engedélyezési döntések meghozataláról: Engedélyezés bemutatása ASP.NET Core.

Jelentkezz ki

A Kijelentkezés hivatkozás meghívja a LogoutModel.OnPost műveletet.

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

Az előző kódban a return RedirectToPage(); kódnak átirányításnak kell lennie, hogy a böngésző új kérést hajt végre, és a felhasználó identitása frissüljön.

SignOutAsync törli a felhasználó cookie-ben tárolt jogcímeit.

A bejegyzés itt van meghatározva: 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>

Teszt Identity

Az alapértelmezett webes projektsablonok névtelen hozzáférést biztosítanak a kezdőlapokhoz. Tesztelje a Identity-et úgy, hogy hozzáadja a [Authorize]-et.

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()
        {
        }
    }
}

Ha bejelentkezett, jelentkezzen ki. Futtassa az alkalmazást, és válassza a Privacy hivatkozást. A rendszer átirányítja a bejelentkezési oldalra.

A Identity felfedezése

A Identity részletesebb megismerése:

• Teljes identitás UI-forrás létrehozása
• Vizsgálja meg az egyes lapok forrását, és lépjen végig a hibakeresőn.

Identity összetevők

A NuGet-csomagokat, amelyek Identity-tól függenek, a ASP.NET Core megosztott keretrendszertartalmazza.

A Identity elsődleges csomagja a Microsoft.AspNetCore .Identity. Ez a csomag tartalmazza az ASP.NET Core Identityinterfészkészletét, és az alapvető készletet a Microsoft.AspNetCore.Identity.EntityFrameworkCoretartalmazza.

Migrálás ASP.NET Core Identity

További információkért és útmutatásért a meglévő Identity bolt migrálásához lásd: Hitelesítés áttelepítése és Identity.

Jelszó erősségének beállítása

Lásd a Konfiguráció példát, amely meghatározza a jelszó minimális követelményeit.

AddDefaultIdentity és AddIdentity

AddDefaultIdentity ASP.NET Core 2.1-ben vezették be. A AddDefaultIdentity hívása a következőhöz hasonló:

• AddIdentity
• AddDefaultUI
• AddDefaultTokenProviders

További információért lásd az AddDefaultIdentity kód szakaszát.

Statikus Identity-objektumok közzétételének megakadályozása

Ha meg szeretné akadályozni, hogy statikus Identity objektumokat (Identity felhasználói felülethez tartozó stíluslapok és JavaScript-fájlok) tegyenek közzé a webes gyökérkönyvtárban, adja hozzá az alábbi ResolveStaticWebAssetsInputsDependsOn tulajdonságot és RemoveIdentityAssets célhelyet az alkalmazás projektfájljához:

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

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

Következő lépések

• ASP.NET Core Blazor autentikáció és autorizáció
• ASP.NET Core Identity forráskód
• Hogyan dolgozzunk a szerepkörökkel az ASP.NET Core-ban Identity

• Az SQLite használatával történő konfigurálásról Identity további információt az SQLite konfigurációja Identity (dotnet/AspNetCore.Docs #5131) című témakörben talál.
• Identity konfigurálása
• ASP.NET Core-alkalmazás létrehozása engedélyezési által védett felhasználói adatokkal
• Felhasználói adatok hozzáadása, letöltése és törlése Identity ASP.NET Core-projektben
• QR-kódlétrehozás engedélyezése TOTP-hitelesítő alkalmazásokhoz a ASP.NET Core
• Hitelesítés és Identity áttelepítése az ASP.NET Core rendszerbe
• Fiók megerősítése és jelszó visszaállítása az ASP.NET Core-ban
• Többtényezős hitelesítés a ASP.NET Core-ban
• ASP.NET Core üzemeltetése egy webfarmban