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.

Obter e abrir o projeto inicial

Observação

Se você quiser usar o .devcontainer nos GitHub Codespaces, navegue até os codespaces do repositório MicrosoftDocs/mslearn-secure-aspnet-core-identity. Crie um codespace usando o branch main e pule para a etapa 3.

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 ou selecione Reabrir no Contêiner se quiser usar o .devcontainer.

Dica

Se você perder o prompt para reabrir no contêiner, pressione Ctrl+Shift+P para abrir a paleta de comandos. Pesquise e selecione Contêineres de Desenvolvimento: Reabrir no Contêiner.
Depois que o projeto for carregado (localmente ou no contêiner), 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.

Explorar o aplicativo

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 .devcontainer 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.
Se você optar por importar um certificado de desenvolvimento dentro do contêiner, o caminho do contêiner /root/.aspnet/ será exposto como .devcontainer/persisted-data/.aspnet fora do contêiner. Isso é feito para sua conveniência.

Se você estiver usando o .devcontainer nos GitHub Codespaces, nenhuma ação será necessária. Os Codespaces lidam com a conexão SSL do proxy automaticamente.
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.
Pressione Ctrl+C no painel do terminal para interromper o aplicativo.

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 6.0.2 --global
```
O scaffolder é uma ferramenta do .NET Core 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 6.0.2
dotnet add package Microsoft.AspNetCore.Identity.EntityFrameworkCore --version 6.0.3
dotnet add package Microsoft.AspNetCore.Identity.UI --version 6.0.3
dotnet add package Microsoft.EntityFrameworkCore.Design --version 6.0.3
dotnet add package Microsoft.EntityFrameworkCore.SqlServer --version 6.0.3
```
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
```
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 seguinte Areas estrutura de diretório aparece no diretório RazorPagesPizza:
- Areas
  - Identity (é exibido na mesma linha que Áreas)
    - Data
      - RazorPagesPizzaAuth.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"); 
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.UseAuthentication();
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<IdentityUser> informa os serviços de identidade que eles devem usar o modelo de usuário padrão.
  - 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 RazorPagesPizzaAuthDbContext é usada.
- app.UseAuthentication(); habilita funcionalidades de autenticação. Mais especificamente, uma instância do middleware de autenticação ASP.NET Core é adicionada ao pipeline de tratamento de solicitação HTTP do aplicativo.

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ê estiver usando o .devcontainer, altere a cadeia de conexão da seguinte maneira. Salve suas alterações.

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

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, pode 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 6.0.3 --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.

Crie e execute uma migração do EF Core para atualizar o banco de dados:

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. _LoginPartial foi adicionado pelo scaffold do Identity. 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!

Verifique se você salvou 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 ainda não foi configurado para enviar emails de confirmação, o link de confirmação é fornecido nesta 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.
Pressione Ctrl+C no painel do terminal para interromper o aplicativo.

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.

Continuar