Bevezetés a Identity ASP.NET Core

IdentityASP.NET Core:

• 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.

További információ arról, hogyan igényelhet hitelesítést az összes alkalmazásfelhasználó számára: Az engedélyezés által védett felhasználói adatokkal rendelkező ASP.NET Core alkalmazás létrehozása.

A Identity forráskód GitHub é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 egy SQL Server-adatbázis használatával van konfigurálva a felhasználónevek, jelszavak és profiladatok tárolására. Másik lehetőségként további állandó tároló is használható, például 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ókért a IdentityBlazor alkalmazásokban használt ASP.NET Core Blazor hitelesítésről és engedélyezésről nézze meg a Blazor dokumentációt és az azt követő cikkeket.

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

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

ASP.NET Core Identity felhasználói felületi bejelentkezési funkciókat ad hozzá az 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ó
• Duende Identity Szerver

A Duende Identity Server egy OpenID Connect- és OAuth 2.0-keretrendszer ASP.NET Core. 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-szabályozás API-khoz
• Szövetségi átjáró

Important

Duende Software esetleg licencdíjat kérhet a Duende Identity Server üzemeltetési használatáért. További információ: Migrate from ASP.NET Core in .NET 5 to .NET 6.

További információt a Duende Identity Server dokumentációjában (Duende Software webhelyén) talál.

A mintakód megjelenítése vagy letöltése (letöltés).

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

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

Note

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 Tovább gombot.
• 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 parancssori felület

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 project IdentityRazor összetevőket tartalmaznak. Az összetevők a kiszolgáló project Components/Account mappájában találhatók. Például:

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

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. Ha egyéni fiókokkal hoz létre Blazor Web App, a generált projekt tartalmaz IdentityRazor összetevőket. A összetevők a szerver projekt mappájában is megtekinthetők a projekt sablonban ( GitHub adattár).

Note

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ókért lásd a következőt: Hogyan válassza ki az ASP.NET Core forráskód verziócímkéjét (dotnet/AspNetCore.Docs #26205).

További információ: ASP.NET Core Blazor hitelesítés és engedélyezés és az azt követő cikkek a Blazor dokumentációban. A Security és Identity fő ASP.NET Core dokumentációs készletének legtöbb cikke Blazor alkalmazásokra 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 tanulmányozza az általános ASP.NET Core dokumentációt, majd a BlazorSecurity és Identity dokumentációban található cikkeket.

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

Hozzon létre egy ASP.NET Core webalkalmazás projektet (Razor Pages) egyéni fiókokkal.

Visual Studio

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

.NET parancssori felület

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 egy ASP.NET Core Identity osztálykönyvtárat (RCL) biztosít. 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ó: Scaffold Identity ASP.NET Core projektekben.

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

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

Visual Studio

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

.NET parancssori felület

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 egy ASP.NET Core Identity osztálykönyvtárat (RCL) biztosít. 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ó: Scaffold 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 Csomagkezelő konzolon (PMC):

Update-Database

.NET parancssori felület

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 Core parancssori felületéről további információt a EF Core eszközökkel kapcsolatos .NET parancssori felület című témakörben talál.

Note

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. Egy másik architektúra megadásához tekintse át, hogyan használhatja a dotnet tool install parancsot az "--arch" beállítással. További információért lásd: GitHub dotnet/aspnetcore.docs hibajegy #29262 - Apple Siliconon adja hozzá az „-a arm64” kapcsolót.

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 View menüben válassza a 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 parancssori felület

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.

ASP.NET Core Identity metrikák

ASP.NET Core Identity metrikák monitorozási képességeket biztosítanak a felhasználókezelési és hitelesítési folyamatokhoz. Ezek a metrikák segítenek észlelni a biztonsági fenyegetéseket jelző szokatlan bejelentkezési mintákat, nyomon követheti az identitásműveletek teljesítményét, és megismerheti, hogy a felhasználók hogyan használják a hitelesítési funkciókat, például a kéttényezős hitelesítést. Ez a megfigyelhetőség különösen hasznos a szigorú biztonsági követelményekkel rendelkező vagy magas hitelesítési forgalmat tapasztaló alkalmazások számára.

Az elérhető metrikákról és azok használatáról a ASP.NET Core metrikák című témakörben olvashat.

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 Scaffold identitás beillesztési Razor projekt engedélyezési utasításait, hogy létrehozza az ebben a szakaszban látható kódot.

.NET parancssori felület

Ha WebApp1 néven hozta létre a projektet, és nem az SQLite-t használja, 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.

A Identity állványzatával kapcsolatos további információkért lásd: Az állvány-identitást egy Razor projekt engedélyezéssel.

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.
• Egy felhasználó olyan korlátozott oldalhoz próbál hozzáférni, amelyhez nem jogosult hozzáférni vagy ha a rendszer nem hitelesítette őket.

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

Az engedélyezési döntések meghozataláról további információt a A ASP.NET Core engedélyezési folyamatában talál.

Kijelentkezik

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 projekt sablonok lehetővé teszik a névtelen hozzáférést 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

Az összes Identity függő NuGet-csomag megtalálható a ASP.NET Core megosztott keretrendszerben.

A Identity elsődleges csomagja a Microsoft.AspNetCore .Identity. Ez a csomag tartalmazza az ASP.NET Core Identity alapvető interfészeinek készletét, és Microsoft.AspNetCore.Identity.EntityFrameworkCore foglaltatik benne.

ASP.NET Core-ra való áttérés 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 az ASP.NET Core 2.1-ben került bevezetésre. A AddDefaultIdentity hívása a következőhöz hasonló:

• AddIdentity
• AddDefaultUI
• AddDefaultTokenProviders

További információkért lásd a AddDefaultIdentity source részt.

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

Ha meg szeretné akadályozni a statikus Identity objektumok (Identity felhasználói felülethez tartozó stíluslapok és JavaScript-fájlok) közzétételét a webes gyökérben, adja hozzá a következő ResolveStaticWebAssetsInputsDependsOn tulajdonságot és RemoveIdentityAssets célhelyet az alkalmazás project fá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 hitelesítés és engedélyezés
• ASP.NET Core Identity forráskód
• Az ASP.NET Core

• A Identity SQLite használatával történő konfigurálásáról további információt a Az Identity SQLite-hez való konfigurálásáról (dotnet/AspNetCore.Docs #5131) talál.
• Identity konfigurálása
• ASP.NET Core-alkalmazás létrehozása engedélyezéssel védett felhasználói adatokkal
• Felhasználói adatok hozzáadása, letöltése és törlése Identity egy ASP.NET Core projektben
• QR-kód létrehozásának engedélyezése TOTP-hitelesítéshez
• Hitelesítés és Identity migrálása ASP.NET Core-ra
• Fiók megerősítése és jelszó helyreállítása
• Többtényezős hitelesítés a ASP.NET Core-ban
• ASP.NET Core alkalmazás hosztolása egy webfarmban