Exercício – Configurar o suporte ao Identity

15 minutos

O Identity funciona instantaneamente sem nenhuma personalização. Nesta unidade, o Identity será adicionado a um projeto Razor Pages ASP.NET Core existente.

Abrir o projeto inicial

Para usar o GitHub Codespace recomendado, navegue até seus Codespaces para o repositório MicrosoftDocs/mslearn-secure-aspnet-core-identity. Crie um novo Codespace usando o branch main e, em seguida, pule para Explorar o aplicativo.

Para usar um contêiner de desenvolvimento local, siga estas etapas:

Em uma janela do Visual Studio Code, pressione a tecla F1 para abrir a paleta de comandos. Pesquise e selecione Dev-Containers: Clonar repositório no volume do contêiner....
Insira a seguinte URL do repositório: https://github.com/MicrosoftDocs/mslearn-secure-aspnet-core-identity. Selecione o branch main. O Visual Studio Code criará o Contêiner de Desenvolvimento. Aceite os prompts para instalar as extensões recomendadas.
Pule para Explorar o aplicativo.

Para usar um ambiente de desenvolvimento local, siga estas etapas:

Em uma janela de terminal, execute o seguinte comando para obter o projeto inicial:
```
git clone https://github.com/MicrosoftDocs/mslearn-secure-aspnet-core-identity
```
Alterne para o diretório do código-fonte e inicie o Visual Studio Code:
```
cd mslearn-secure-aspnet-core-identity
code .
```
O Visual Studio Code se abre. Aceite os prompts para instalar as extensões recomendadas, mas NÃO selecionar Reabrir no contêiner, se solicitado. Continue com as próximas etapas.

Explorar o aplicativo

Depois que o projeto for carregado, pressione Ctrl+Shift+` para abrir um novo painel de terminal.
No novo painel do terminal, defina sua localização para o diretório RazorPagesPizza:
```
cd RazorPagesPizza
```
No painel Explorer, expanda o diretório RazorPagesPizza para exibir o código. RazorPagesPizza é o diretório do projeto. Ao prosseguir, suponha que todos os caminhos discutidos neste módulo são relativos a esse local.

Vamos executar o aplicativo para obter uma introdução rápida.
No painel do terminal, crie o projeto e execute o aplicativo:
```
dotnet run
```
Anote a URL exibida na saída do terminal. Por exemplo, https://localhost:7192.
Abra o aplicativo no navegador selecionando a URL com Ctrl+clique.
Importante

Se você estiver usando o Contêiner de Desenvolvimento no Docker, o navegador não confiará no certificado SSL de dentro do contêiner. Para exibir o aplicativo Web, você deve executar uma das seguintes ações:
- Ignorar o erro do certificado. Se estiver usando Microsoft Edge, selecione Avançado e Continuar para localhost (não recomendado). Os detalhes variam conforme o navegador.
- Salvar o certificado e adicioná-lo às autoridades de certificação confiáveis.
- Importar um certificado de desenvolvimento dentro do contêiner. Para obter mais detalhes, confira os comentários gerados em ./devcontainer/devcontainter.json.
Explorar o aplicativo Web no navegador. Usando os links no cabeçalho:
1. Navegar até a Lista de Pizzas
2. Navegue de volta para Página Inicial
Observe que você não precisa se autenticar.
Para interromper o aplicativo, pressione Ctrl+C no painel do terminal.

Adicionar a Identidade do ASP.NET Core ao projeto

A implementação padrão de identidade pode ser adicionada com dotnet ferramentas de linha de comando.

Instale o scaffolder de código do ASP.NET Core:
```
dotnet tool install dotnet-aspnet-codegenerator --version 8.0.* --global
```
O scaffolder é uma ferramenta do .NET que:
- É usada para adicionar os componentes padrão de Identidade ao projeto.
- Permite a personalização de componentes da interface do usuário do Identity na próxima unidade.
- É invocada por meio de dotnet aspnet-codegenerator neste módulo.

Adicione os seguintes pacotes NuGet ao projeto:

dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design --version 8.0.*
dotnet add package Microsoft.AspNetCore.Identity.EntityFrameworkCore --version 8.0.*
dotnet add package Microsoft.AspNetCore.Identity.UI --version 8.0.*
dotnet add package Microsoft.EntityFrameworkCore.Design --version 8.0.*
dotnet add package Microsoft.EntityFrameworkCore.SqlServer --version 8.0.*
dotnet add package Microsoft.EntityFrameworkCore.Tools --version 8.0.*

Esses pacotes instalam dependências e modelos de geração de código que são usados pelo scaffolder.

Dica

Para exibir os geradores disponíveis:

No shell de comando, execute dotnet aspnet-codegenerator -h.
Quando estiver no Visual Studio, clique com o botão direito do mouse no projeto no Gerenciador de Soluções e selecione Adicionar>Novo Item com Scaffold.

Use o scaffolder para adicionar os componentes padrão do Identity ao projeto. Execute o seguinte comando no terminal:
```
dotnet aspnet-codegenerator identity --useDefaultUI --dbContext RazorPagesPizzaAuth --userClass RazorPagesPizzaUser
```
No comando anterior:
- O gerador identificado como identity é usado para adicionar o Identity Framework ao projeto.
- A opção --useDefaultUI indica que uma RCL (biblioteca de classes Razor) que contém os elementos padrão da interface do usuário será usada. O Bootstrap será usado para aplicar um estilo aos componentes.
- A opção --dbContext especifica o nome de uma classe de contexto de banco de dados do EF Core a ser gerada.
- A opção --userClass especifica o nome da classe do usuário a ser gerado. A classe de usuário padrão é IdentityUser, mas como a classe de usuário será estendida em uma unidade posterior, uma classe de usuário personalizada chamada RazorPagesPizzaUser será especificada. A classe RazorPagesPizzaUser é derivada de IdentityUser.
A seguinte Areas estrutura de diretório aparece no diretório RazorPagesPizza:
- Areas
  - Identity (é exibido na mesma linha que Áreas)
    - Data
      - RazorPagesPizzaAuth.cs
      - RazorPagesPizzaUser.cs
    - Pages
      - _ValidationScriptsPartial.cshtml
      - _ViewStart.cshtml
Dica

Se o Areas diretório não aparecer automaticamente no painel Do Explorer, selecione o botão Atualizar Explorer no cabeçalho MSLEARN-SECURE-ASPNET-CORE-IDENTITY no painel Explorer.

As áreas fornecem uma maneira de particionar um aplicativo Web ASP.NET Core em grupos funcionais menores.

O scaffolder também fez as seguintes alterações em Program.cs realçadas abaixo, reformatadas para melhorar a legibilidade:
```
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using RazorPagesPizza.Areas.Identity.Data;
var builder = WebApplication.CreateBuilder(args);
var connectionString = builder.Configuration.GetConnectionString("RazorPagesPizzaAuthConnection") 
    ?? throw new InvalidOperationException("Connection string 'RazorPagesPizzaAuthConnection' not found.");

builder.Services.AddDbContext<RazorPagesPizzaAuth>(options => options.UseSqlServer(connectionString));

builder.Services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
    .AddEntityFrameworkStores<RazorPagesPizzaAuth>();

// Add services to the container.
builder.Services.AddRazorPages();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}

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

app.UseRouting();

app.UseAuthorization();

app.MapRazorPages();

app.Run();
```
No código anterior:
- A cadeia de conexão RazorPagesPizzaAuthConnection é lida de appsettings.json.
- A classe de contexto de banco de dados do EF Core, chamada RazorPagesPizzaAuth, é configurada com a cadeia de conexão.
- Os serviços do Identity são registrados, incluindo a interface do usuário padrão, os provedores de token e a autenticação baseada em cookie.
  - .AddDefaultIdentity<RazorPagesPizzaUser> informa aos serviços de identidade que eles devem usar o modelo de usuário padrão RazorPagesPizzaUser.
  - A expressão do Lambda options => options.SignIn.RequireConfirmedAccount = true especifica que os usuários devem confirmar suas contas de email.
  - .AddEntityFrameworkStores<RazorPagesPizzaAuth>() especifica que a Identidade usa o repositório padrão do Entity Framework Core para seu banco de dados. A classe RazorPagesPizzaAuth DbContext é usada.

Configurar a conexão de banco de dados

A seção ConnectionStrings em appsettings.json deverá ser semelhante ao seguinte JSON:

"ConnectionStrings": {
    "RazorPagesPizzaAuthConnection": "Server=(localdb)\\mssqllocaldb;Database=RazorPagesPizza;Trusted_Connection=True;MultipleActiveResultSets=true"
}

Essa cadeia de conexão aponta para uma instância de SQL Server Express LocalDB por padrão. Se você está desenvolvendo localmente, não faça nada. Essa é a cadeia de conexão correta.

Em Codespaces ou Contêineres de Desenvolvimento, a cadeia de conexão está incorreta. Se estiver usando o Contêiner de Desenvolvimento, deverá alterar a cadeia de conexão da seguinte maneira. Certifique-se de salvar as alterações.

"ConnectionStrings": {
    "RazorPagesPizzaAuthConnection": "Data Source=localhost;Initial Catalog=RazorPagesPizza;Integrated Security=False;User Id=sa;Password=P@ssw0rd;MultipleActiveResultSets=True;Encrypt=False"
}

Isso atualiza a cadeia de conexão para se conectar à instância do SQL Server dentro do contêiner.

Atualizar o banco de dados

Agora que você verificou a cadeia de conexão, poderá gerar e executar uma migração para criar o banco de dados.

Execute o comando a seguir para criar o aplicativo:
```
dotnet build
```
O build tem êxito sem nenhum aviso. Se o build falhar, verifique o resultado para obter informações de solução de problemas.
Instale a ferramenta de migração do Entity Framework Core:
```
dotnet tool install dotnet-ef --version 8.0.* --global
```
A ferramenta de migração é uma ferramenta do .NET que:
- Gera um código chamado de migração para criar e atualizar o banco de dados que dá suporte ao modelo de entidade do Identity.
- Executa migrações em um banco de dados existente.
- É invocada por meio de dotnet ef neste módulo.

Para atualizar o banco de dados, crie e execute uma migração do EF Core:

dotnet ef migrations add CreateIdentitySchema
dotnet ef database update

A migração do EF Core CreateIdentitySchema aplicou um script de alteração de DDL (linguagem de definição de dados) para criar as tabelas que dão suporte ao Identity. Por exemplo, a seguinte saída descreve uma instrução CREATE TABLE gerada pela migração:

info: Microsoft.EntityFrameworkCore.Database.Command[20101]
      Executed DbCommand (98ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
      CREATE TABLE [AspNetUsers] (
          [Id] nvarchar(450) NOT NULL,
          [UserName] nvarchar(256) NULL,
          [NormalizedUserName] nvarchar(256) NULL,
          [Email] nvarchar(256) NULL,
          [NormalizedEmail] nvarchar(256) NULL,
          [EmailConfirmed] bit NOT NULL,
          [PasswordHash] nvarchar(max) NULL,
          [SecurityStamp] nvarchar(max) NULL,
          [ConcurrencyStamp] nvarchar(max) NULL,
          [PhoneNumber] nvarchar(max) NULL,
          [PhoneNumberConfirmed] bit NOT NULL,
          [TwoFactorEnabled] bit NOT NULL,
          [LockoutEnd] datetimeoffset NULL,
          [LockoutEnabled] bit NOT NULL,
          [AccessFailedCount] int NOT NULL,
          CONSTRAINT [PK_AspNetUsers] PRIMARY KEY ([Id])
      );

Dica

O comando ef gerou um erro sobre a inexistência de suporte para LocalDb? Verifique se você definiu a cadeia de conexão, conforme a seção "Configurar a conexão de banco de dados".

A extensão do SQL Server foi adicionada ao Visual Studio Code, se necessária, quando você aceitou as extensões recomendadas. Pressione Ctrl+Alt+D para alternar para o painel do SQL Server.
Expanda os nós sob a conexão de banco de dados. Expanda o nó Bancos de Dados, o nó RazorPagesPizza e o nó Tabelas. Observe a lista de tabelas. Isso confirma que a migração foi bem-sucedida.

Observação

A imagem anterior mostra um exemplo usando o LocalDB do SQL Server Express. Ao usar o .devcontainer, a conexão se chama mssql-container.

Retorne ao painel Gerenciador. Em Pages/Shared/_Layout.cshtml, substitua o comentário @* Add the _LoginPartial partial view *@ pelo indicado a seguir.

<partial name="_LoginPartial" />

A marcação anterior renderiza a exibição parcial _LoginPartial dentro do cabeçalho de qualquer página que usa o layout padrão. O scaffolding de identidade adicionado _LoginPartial. Essa exibição parcial apresenta ao usuário os links Fazer Logon e Registrar-se, caso o usuário não esteja conectado.

Testar a funcionalidade identidade

Isso é tudo o que é necessário para adicionar a implementação de identidade padrão. É hora de testar!

Salve todas as alterações.
No painel do terminal, crie o projeto e execute o aplicativo:
```
dotnet run
```
Navegue até o aplicativo em seu navegador como antes.
Clique no link Registrar-se no cabeçalho do aplicativo. Preencha o formulário para criar uma conta.

A página Confirmação de registro é exibida. Como o aplicativo não foi configurado para enviar emails de confirmação, o link de confirmação é fornecido nessa página.
Clique no link de confirmação. Uma mensagem de confirmação é exibida.
Clique no link de Entrada no cabeçalho do aplicativo e entre.

Após uma entrada bem-sucedida:
- Você será redirecionado para a home page.
- O cabeçalho do aplicativo exibe Olá [endereço de email]! e um link Saída.
- Um cookie chamado .AspNetCore.Identity.Application é criado. O Identity preserva as sessões de usuário com a autenticação baseada em cookie.
Clique no link Logoff no cabeçalho do aplicativo.

Após o logoff bem-sucedido, o cookie .AspNetCore.Identity.Application é excluído para encerrar a sessão do usuário.
Para interromper o aplicativo, pressione Ctrl+C no painel do terminal.

Resumo

Nesta unidade, você adicionou a implementação de identidade padrão a um aplicativo Web. Na próxima unidade, você vai aprender a estender e personalizar a Identidade.