Introduction à Identity sur ASP.NET CoreIntroduction to Identity on ASP.NET Core

Par Rick AndersonBy Rick Anderson

ASP.NET Core Identity est un système d’appartenance qui ajoute des fonctionnalités de connexion pour les applications ASP.NET Core.ASP.NET Core Identity is a membership system that adds login functionality to ASP.NET Core apps. Les utilisateurs peuvent créer un compte avec les informations de connexion stockées dans l’identité, ou ils peuvent utiliser un fournisseur de connexion externe.Users can create an account with the login information stored in Identity or they can use an external login provider. Fournisseurs de connexion externe pris en charge incluent Facebook, Google, Account Microsoft et Twitter.Supported external login providers include Facebook, Google, Microsoft Account, and Twitter.

Identité peut être configurée à l’aide d’une base de données SQL Server pour stocker les noms d’utilisateur, les mots de passe et les données de profil.Identity can be configured using a SQL Server database to store user names, passwords, and profile data. Vous pouvez également un autre magasin persistant peut être utilisé, par exemple, stockage Table Azure.Alternatively, another persistent store can be used, for example, Azure Table Storage.

Afficher ou télécharger l’exemple de code (comment télécharger)).View or download the sample code (how to download)).

Dans cette rubrique, vous allez apprendre à utiliser l’identité pour vous inscrire, connectez-vous et déconnecter un utilisateur.In this topic, you learn how to use Identity to register, log in, and log out a user. Pour obtenir des instructions plus détaillées sur la création d’applications qui utilisent l’identité, consultez la section étapes suivantes à la fin de cet article.For more detailed instructions about creating apps that use Identity, see the Next Steps section at the end of this article.

AddDefaultIdentity et AddIdentityAddDefaultIdentity and AddIdentity

AddDefaultIdentity a été introduit dans ASP.NET Core 2.1.AddDefaultIdentity was introduced in ASP.NET Core 2.1. Appel AddDefaultIdentity revient à appeler ce qui suit :Calling AddDefaultIdentity is similar to calling the following:

Consultez AddDefaultIdentity source pour plus d’informations.See AddDefaultIdentity source for more information.

Créer une application Web avec l’authentificationCreate a Web app with authentication

Créer un projet d’Application Web ASP.NET Core avec des comptes d’utilisateur individuels.Create an ASP.NET Core Web Application project with Individual User Accounts.

  • Sélectionnez Fichier > Nouveau > Projet.Select File > New > Project.
  • Sélectionnez Nouvelle application web ASP.NET Core.Select ASP.NET Core Web Application. Nommez le projet application Web 1 pour avoir le même espace de noms en tant que le téléchargement du projet.Name the project WebApp1 to have the same namespace as the project download. Cliquez sur OK.Click OK.
  • Sélectionnez une ASP.NET Core Web Application, puis sélectionnez modifier l’authentification.Select an ASP.NET Core Web Application, then select Change Authentication.
  • Sélectionnez comptes d’utilisateur individuels et cliquez sur OK.Select Individual User Accounts and click OK.

Fournit le projet généré ASP.NET Core Identity comme un bibliothèque de classes Razor.The generated project provides ASP.NET Core Identity as a Razor Class Library. La bibliothèque de classes d’identité Razor expose des points de terminaison avec le Identity zone.The Identity Razor Class Library exposes endpoints with the Identity area. Exemple :For example:

  • / Identity/Account/Login/Identity/Account/Login
  • Identité/compte/déconnecter/Identity/Account/Logout
  • /Identity/Account/Manage/Identity/Account/Manage

Appliquer des migrationsApply migrations

Appliquer les migrations pour initialiser la base de données.Apply the migrations to initialise the database.

Exécutez la commande suivante dans la Console Gestionnaire de Package (PMC) :Run the following command in the Package Manager Console (PMC):

PM> Update-Database

Registre de test et de connexionTest Register and Login

Exécutez l’application et inscrire un utilisateur.Run the app and register a user. Selon la taille de votre écran, vous devrez peut-être sélectionner le bouton de navigation pour afficher le inscrire et connexion des liens.Depending on your screen size, you might need to select the navigation toggle button to see the Register and Login links.

Afficher la base de données d’identitéView the Identity database

  • À partir du menu Affichage, sélectionnez l’Explorateur d’objets SQL Server (SSOX).From the View menu, select SQL Server Object Explorer (SSOX).
  • Accédez à (localdb) MSSQLLocalDB (SQL Server 13).Navigate to (localdb)MSSQLLocalDB(SQL Server 13). Cliquez avec le bouton droit sur dbo. AspNetUsers > Afficher les données :Right-click on dbo.AspNetUsers > View Data:

Menu contextuel sur la table AspNetUsers dans l’Explorateur d’objets SQL Server

Configurer les services d’identitéConfigure Identity services

Les services sont ajoutés dans ConfigureServices.Services are added in ConfigureServices. Le modèle par défaut consiste à appeler toutes les méthodes Add{Service}, puis toutes les méthodes services.Configure{Service}.The typical pattern is to call all the Add{Service} methods, and then call all the services.Configure{Service} methods.

public void ConfigureServices(IServiceCollection services)
{
    services.Configure<CookiePolicyOptions>(options =>
    {
        options.CheckConsentNeeded = context => true;
        options.MinimumSameSitePolicy = SameSiteMode.None;
    });

    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(
            Configuration.GetConnectionString("DefaultConnection")));
    services.AddDefaultIdentity<IdentityUser>()
        .AddDefaultUI(UIFramework.Bootstrap4)
        .AddEntityFrameworkStores<ApplicationDbContext>();

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

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

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

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

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

    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}

Le code précédent configure l’identité avec des valeurs d’option par défaut.The preceding code configures Identity with default option values. Services sont accessibles à l’application via l’injection de dépendances.Services are made available to the app through dependency injection.

Identity est activé en appelant UseAuthentication.Identity is enabled by calling UseAuthentication. UseAuthenticationAjoute l’authentification intergiciel (middleware) au pipeline de demande.UseAuthentication adds authentication middleware to the request pipeline.

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

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

    app.UseAuthentication();

    app.UseMvc();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

    services.AddIdentity<ApplicationUser, IdentityRole>()
        .AddEntityFrameworkStores<ApplicationDbContext>()
        .AddDefaultTokenProviders();

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

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

        // User settings
        options.User.RequireUniqueEmail = true;
    });

    services.ConfigureApplicationCookie(options =>
    {
        // Cookie settings
        options.Cookie.HttpOnly = true;
        options.ExpireTimeSpan = TimeSpan.FromMinutes(30);
        // If the LoginPath isn't set, ASP.NET Core defaults 
        // the path to /Account/Login.
        options.LoginPath = "/Account/Login";
        // If the AccessDeniedPath isn't set, ASP.NET Core defaults 
        // the path to /Account/AccessDenied.
        options.AccessDeniedPath = "/Account/AccessDenied";
        options.SlidingExpiration = true;
    });

    // Add application services.
    services.AddTransient<IEmailSender, EmailSender>();

    services.AddMvc();
}

Services sont accessibles à l’application via l’injection de dépendances.Services are made available to the application through dependency injection.

Identity est activée pour l’application en appelant UseAuthentication dans le Configure (méthode).Identity is enabled for the application by calling UseAuthentication in the Configure method. UseAuthenticationAjoute l’authentification intergiciel (middleware) au pipeline de demande.UseAuthentication adds authentication middleware to the request pipeline.

// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
        app.UseBrowserLink();
        app.UseDatabaseErrorPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
    }

    app.UseStaticFiles();

    app.UseAuthentication();

    app.UseMvc(routes =>
    {
        routes.MapRoute(
            name: "default",
            template: "{controller=Home}/{action=Index}/{id?}");
    });
}
public void ConfigureServices(IServiceCollection services)
{
    // Add framework services.
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

    services.AddIdentity<ApplicationUser, IdentityRole>()
        .AddEntityFrameworkStores<ApplicationDbContext>()
        .AddDefaultTokenProviders();

    services.AddMvc();

    // Configure Identity
    services.Configure<IdentityOptions>(options =>
    {
        // Password settings
        options.Password.RequireDigit = true;
        options.Password.RequiredLength = 8;
        options.Password.RequireNonAlphanumeric = false;
        options.Password.RequireUppercase = true;
        options.Password.RequireLowercase = false;

        // Lockout settings
        options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(30);
        options.Lockout.MaxFailedAccessAttempts = 10;

        // Cookie settings
        options.Cookies.ApplicationCookie.ExpireTimeSpan = TimeSpan.FromDays(150);
        options.Cookies.ApplicationCookie.LoginPath = "/Account/Login";

        // User settings
        options.User.RequireUniqueEmail = true;
    });

    // Add application services.
    services.AddTransient<IEmailSender, AuthMessageSender>();
    services.AddTransient<ISmsSender, AuthMessageSender>();
}

Ces services sont accessibles à l’application via l’injection de dépendances.These services are made available to the application through dependency injection.

Identity est activée pour l’application en appelant UseIdentity dans le Configure (méthode).Identity is enabled for the application by calling UseIdentity in the Configure method. UseIdentityAjoute l’authentification par cookie intergiciel (middleware) au pipeline de demande.UseIdentity adds cookie-based authentication middleware to the request pipeline.

public void Configure(IApplicationBuilder app,
    IHostingEnvironment env, 
    ILoggerFactory loggerFactory)
{
    loggerFactory.AddConsole(Configuration.GetSection("Logging"));
    loggerFactory.AddDebug();

    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
        app.UseDatabaseErrorPage();
        app.UseBrowserLink();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
    }

    app.UseStaticFiles();

    app.UseIdentity();

    // Add external authentication middleware below. To configure them please see https://go.microsoft.com/fwlink/?LinkID=532715

    app.UseMvc(routes =>
    {
        routes.MapRoute(
            name: "default",
            template: "{controller=Home}/{action=Index}/{id?}");
    });
}

Pour plus d’informations, consultez le IdentityOptions classe et démarrage de l’Application.For more information, see the IdentityOptions Class and Application Startup.

Inscription d’une structure, de connexion et de déconnexionScaffold Register, Login, and LogOut

Suivez le structurer d’identité dans un projet Razor avec l’autorisation obtenir des instructions pour générer le code indiqué dans cette section.Follow the Scaffold identity into a Razor project with authorization instructions to generate the code shown in this section.

Ajoutez les fichiers de Registre, de connexion et de déconnexion.Add the Register, Login, and LogOut files.

Examinez le RegistreExamine Register

Lorsqu’un utilisateur clique sur le inscrire lien, le RegisterModel.OnPostAsync action est appelée.When a user clicks the Register link, the RegisterModel.OnPostAsync action is invoked. L’utilisateur est créé par CreateAsync sur la _userManager objet.The user is created by CreateAsync on the _userManager object. _userManager est fourni par l’injection de dépendances) :_userManager is provided by dependency injection):

public async Task<IActionResult> OnPostAsync(string returnUrl = null)
{
    returnUrl = returnUrl ?? Url.Content("~/");
    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);
            var callbackUrl = Url.Page(
                "/Account/ConfirmEmail",
                pageHandler: null,
                values: new { 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>.");

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

Lorsqu’un utilisateur clique sur le inscrire lien, le Register action est appelée sur AccountController.When a user clicks the Register link, the Register action is invoked on AccountController. Le Register action crée l’utilisateur en appelant CreateAsync sur le _userManager objet (fourni à AccountController par injection de dépendances) :The Register action creates the user by calling CreateAsync on the _userManager object (provided to AccountController by dependency injection):

//
// POST: /Account/Register
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Register(RegisterViewModel model)
{
    if (ModelState.IsValid)
    {
        var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
        var result = await _userManager.CreateAsync(user, model.Password);
        if (result.Succeeded)
        {
            // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
            // Send an email with this link
            //var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
            //var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
            //await _emailSender.SendEmailAsync(model.Email, "Confirm your account",
            //    "Please confirm your account by clicking this link: <a href=\"" + callbackUrl + "\">link</a>");
            await _signInManager.SignInAsync(user, isPersistent: false);
            _logger.LogInformation(3, "User created a new account with password.");
            return RedirectToAction(nameof(HomeController.Index), "Home");
        }
        AddErrors(result);
    }

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

Si l’utilisateur a été créé avec succès, l’utilisateur est connecté par l’appel à _signInManager.SignInAsync.If the user was created successfully, the user is logged in by the call to _signInManager.SignInAsync.

Remarque : Consultez confirmation de compte pour savoir comment empêcher la connexion immédiate lors de l’inscription.Note: See account confirmation for steps to prevent immediate login at registration.

Connectez-vousLog in

Le formulaire de connexion s’affiche lorsque :The Login form is displayed when:

  • Le connectez-vous lien est sélectionné.The Log in link is selected.
  • Un utilisateur tente d’accéder à une page restreinte qu’ils ne sont pas autorisés à accéder aux ou lorsqu’ils n’ont pas été authentifiés par le système.A user attempts to access a restricted page that they aren't authorized to access or when they haven't been authenticated by the system.

Lors de l’envoi du formulaire sur la page de connexion, le OnPostAsync action est appelée.When the form on the Login page is submitted, the OnPostAsync action is called. PasswordSignInAsync est appelée sur le _signInManager objet (fourni par l’injection de dépendances).PasswordSignInAsync is called on the _signInManager object (provided by dependency injection).

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

La base de Controller classe expose un User propriété auxquelles vous pouvez accéder à partir de méthodes de contrôleur.The base Controller class exposes a User property that you can access from controller methods. Par exemple, vous pouvez énumérer User.Claims et prendre des décisions d’autorisation.For instance, you can enumerate User.Claims and make authorization decisions. Pour plus d'informations, consultez Introduction aux autorisations dans ASP.NET Core.For more information, see Introduction aux autorisations dans ASP.NET Core.

Le formulaire de connexion s’affiche lorsque les utilisateurs sélectionnent le connectez-vous lier ou sont redirigés lorsqu’ils accèdent à une page qui requiert une authentification.The Login form is displayed when users select the Log in link or are redirected when accessing a page that requires authentication. Lorsque l’utilisateur soumet le formulaire sur la page de connexion, le AccountController Login action est appelée.When the user submits the form on the Login page, the AccountController Login action is called.

Le Login action appels PasswordSignInAsync sur le _signInManager objet (fourni à AccountController par injection de dépendances).The Login action calls PasswordSignInAsync on the _signInManager object (provided to AccountController by dependency injection).

//
// POST: /Account/Login
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
{
    ViewData["ReturnUrl"] = returnUrl;
    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(model.Email, 
            model.Password, model.RememberMe, lockoutOnFailure: false);
        if (result.Succeeded)
        {
            _logger.LogInformation(1, "User logged in.");
            return RedirectToLocal(returnUrl);
        }
        if (result.RequiresTwoFactor)
        {
            return RedirectToAction(nameof(SendCode), new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
        }
        if (result.IsLockedOut)
        {
            _logger.LogWarning(2, "User account locked out.");
            return View("Lockout");
        }
        else
        {
            ModelState.AddModelError(string.Empty, "Invalid login attempt.");
            return View(model);
        }
    }

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

La base (Controller ou PageModel) classe expose un User propriété.The base (Controller or PageModel) class exposes a User property. Par exemple, User.Claims peuvent être énumérés afin de prendre des décisions d’autorisation.For example, User.Claims can be enumerated to make authorization decisions.

Se déconnecterLog out

Le déconnecter lien appelle le LogoutModel.OnPost action.The Log out link invokes the LogoutModel.OnPost action.

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

SignOutAsync efface les revendications de l’utilisateur stockées dans un cookie.SignOutAsync clears the user's claims stored in a cookie. Ne pas rediriger après avoir appelé SignOutAsync ou l’utilisateur sera pas me déconnecter.Don't redirect after calling SignOutAsync or the user will not be signed out.

POST est spécifié dans le Pages/Shared/_LoginPartial.cshtml:Post is specified in the 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>


En cliquant sur le déconnecter lien appelle le LogOut action.Clicking the Log out link calls the LogOut action.

//
// POST: /Account/LogOut
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> LogOut()
{
    await _signInManager.SignOutAsync();
    _logger.LogInformation(4, "User logged out.");
    return RedirectToAction(nameof(HomeController.Index), "Home");
}

Le code précédent appelle la _signInManager.SignOutAsync (méthode).The preceding code calls the _signInManager.SignOutAsync method. Le SignOutAsync méthode efface les revendications de l’utilisateur stockées dans un cookie.The SignOutAsync method clears the user's claims stored in a cookie.

Tester l’identitéTest Identity

Les modèles de projet web par défaut autoriser l’accès anonyme pour les pages d’accueil.The default web project templates allow anonymous access to the home pages. Pour tester l’identité, vous devez ajouter [Authorize] à la page de la confidentialité.To test Identity, add [Authorize] to the Privacy page.

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

namespace WebApp1.Pages
{
    [Authorize]
    public class PrivacyModel : PageModel
    {
        public void OnGet()
        {
        }
    }
}

Si vous êtes connecté, déconnectez-vous. Exécutez l’application et sélectionnez le confidentialité lien.If you are signed in, sign out. Run the app and select the Privacy link. Vous êtes redirigé vers la page de connexion.You are redirected to the login page.

Explorez l’identitéExplore Identity

Pour Explorer d’identité plus en détail :To explore Identity in more detail:

Composants d'IdentityIdentity Components

Tous les identités NuGet packages dépendants sont inclus dans le Microsoft.AspNetCore.App métapackage.All the Identity dependent NuGet packages are included in the Microsoft.AspNetCore.App metapackage.

Le package principal pour l’identité est Microsoft.AspNetCore.Identity.The primary package for Identity is Microsoft.AspNetCore.Identity. Ce package contient l’ensemble principal d’interfaces pour ASP.NET Core Identity et est inclus par Microsoft.AspNetCore.Identity.EntityFrameworkCore.This package contains the core set of interfaces for ASP.NET Core Identity, and is included by Microsoft.AspNetCore.Identity.EntityFrameworkCore.

Migration vers ASP.NET Core IdentityMigrating to ASP.NET Core Identity

Pour plus d’informations et des conseils sur la migration de votre magasin d’identités existant, consultez migrer l’authentification et identité.For more information and guidance on migrating your existing Identity store, see Migrate Authentication and Identity.

Définition du niveau de mot de passeSetting password strength

Consultez Configuration pour obtenir un exemple qui définit les exigences de mot de passe minimale.See Configuration for a sample that sets the minimum password requirements.

Étapes suivantesNext Steps