Ejercicio: configuración de la compatibilidad con Identity

10 minutos

Identity funciona de fábrica sin ninguna personalización. Los componentes estándar de la interfaz de usuario de Identity se empaquetan en una biblioteca de clases Razor (RCL) de .NET Standard. Dado que se usa una biblioteca de clases Razor, se agregan pocos archivos al proyecto.

Después de aplicar la migración inicial de EF Core, se crean las tablas auxiliares de base de datos. En el diagrama siguiente se muestran los esquemas de las tablas compatibles:

Diagrama de base de datos.

Nota

La imagen anterior muestra las claves y las relaciones de la base de datos. La clave es un único valor, mientras que el infinito (lateral 8) corresponde a varios. Una base de datos puede tener tipos de relación de 1 a 1, de 1 a varios y de varios a varios. Las claves son únicas. El diagrama muestra cómo se crean estas combinaciones y las relaciones que existen.

En esta unidad, Identity se agregará al proyecto de Razor Pages de ASP.NET Core existente.

Adición de Identity al proyecto

Instale el proveedor de scaffolding de código ASP.NET Core:
```
dotnet tool install dotnet-aspnet-codegenerator --version 3.1.2
```
Se mostrará la siguiente salida:
```
You can invoke the tool from this directory using the following commands: 'dotnet tool run dotnet-aspnet-codegenerator' or 'dotnet dotnet-aspnet-codegenerator'.
Tool 'dotnet-aspnet-codegenerator' (version '3.1.2') was successfully installed. Entry is added to the manifest file /home/<USER>/aspnet-learn/src/ContosoPets.Ui/.config/dotnet-tools.json.
```
El proveedor de scaffolding es una herramienta de .NET Core con el que se puede realizar lo siguiente:
- Utilizarlo para agregar los componentes de Identity predeterminados al proyecto.
- Habilitar la personalización de los componentes de la interfaz de usuario de Identity en la unidad siguiente.
- Invocarlo a través de dotnet aspnet-codegenerator en este módulo.
Agregue los siguientes paquetes NuGet al proyecto:
```
dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design --version 3.1.2 && \
    dotnet add package Microsoft.AspNetCore.Identity.EntityFrameworkCore --version 3.1.3 && \
    dotnet add package Microsoft.AspNetCore.Identity.UI --version 3.1.3 && \
    dotnet add package Microsoft.EntityFrameworkCore.Design --version 3.1.3 && \
    dotnet add package Microsoft.EntityFrameworkCore.SqlServer --version 3.1.3
```
Estos paquetes instalan plantillas y dependencias de generación de código que usa el proveedor de scaffolding.
Sugerencia

Para ver los generadores disponibles, haga lo siguiente:
- En el shell de comandos, ejecute dotnet aspnet-codegenerator -h.
- Cuando se encuentre en Visual Studio, haga clic con el botón derecho en Explorador de soluciones y seleccione Agregar > Nuevo elemento con scaffold.
Use el proveedor de scaffolding para agregar los componentes de Identity predeterminados al proyecto. En la raíz del proyecto, ejecute el comando siguiente:
```
dotnet aspnet-codegenerator identity \
    --useDefaultUI \
    --dbContext ContosoPetsAuth
```
En el comando anterior:
- El generador identificado como identity se usa para agregar el marco de identidad al proyecto.
- La opción --useDefaultUI indica que se usará una biblioteca de clases Razor que contiene los elementos de la interfaz de usuario predeterminados. Bootstrap se usará para aplicar estilo a los componentes.
- La opción --dbContext sirve para indicar el nombre de una clase de contexto de base de datos de EF Core que se va a generar.
Haga clic en el icono de actualización del editor para actualizar el Explorador de archivos.

Aparece una estructura de directorio Areas en la raíz del proyecto:
- Areas
  - Identity
    - Data
      - ContosoPetsAuth.cs
    - Pages
      - _ValidationScriptsPartial.cshtml
      - _ViewStart.cshtml
    - IdentityHostingStartup.cs
Las áreas proporcionan una manera de crear particiones de una aplicación web de ASP.NET Core en grupos funcionales más pequeños.

Adición del proveedor de base de datos PostgreSQL

Para instalar el proveedor de base de datos PostgreSQL para EF Core, ejecute el comando siguiente desde la raíz del proyecto:

dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL --version 3.1.3

Este paquete NuGet proporciona conocimientos a EF Core de cómo interactuar con una base de datos PostgreSQL.

Configuración de la conexión de base de datos

Reemplace el método Configure de Areas/Identity/IdentityHostingStartup.cs por el código siguiente:

public void Configure(IWebHostBuilder builder)
{
    builder.ConfigureServices((context, services) => {
        var connBuilder = new NpgsqlConnectionStringBuilder(
            context.Configuration.GetConnectionString("ContosoPetsAuthConnection"))
        {
            Username = context.Configuration["DbUsername"],
            Password = context.Configuration["DbPassword"]
        };

        services.AddDbContext<ContosoPetsAuth>(options =>
            options.UseNpgsql(connBuilder.ConnectionString));

        services.AddDefaultIdentity<IdentityUser>()
            .AddDefaultUI()
            .AddEntityFrameworkStores<ContosoPetsAuth>();
    });
}

public void Configure(IWebHostBuilder builder)
{
    builder.ConfigureServices((context, services) => {
        var connBuilder = new SqlConnectionStringBuilder(
            context.Configuration.GetConnectionString("ContosoPetsAuthConnection"))
        {
            UserID = context.Configuration["DbUsername"],
            Password = context.Configuration["DbPassword"]
        };

        services.AddDbContext<ContosoPetsAuth>(options =>
            options.UseSqlServer(connBuilder.ConnectionString));

        services.AddDefaultIdentity<IdentityUser>()
            .AddDefaultUI()
            .AddEntityFrameworkStores<ContosoPetsAuth>();
    });
}

En el código anterior:

El proveedor de configuración de Azure Key Vault se usa implícitamente para recuperar el nombre de usuario y la contraseña de la base de datos:

Username = context.Configuration["DbUsername"],
Password = context.Configuration["DbPassword"]

UserID = context.Configuration["DbUsername"],
Password = context.Configuration["DbPassword"]

El nombre de usuario y la contraseña de la base de datos se insertan en la cadena de conexión almacenada en appsettings.json.
La clase de contexto de base de datos de EF Core, llamada ContosoPetsAuth, se configura con la cadena de conexión apropiada.
Se registran los servicios de Identity, incluidos la interfaz de usuario predeterminada, los proveedores de tokens y la autenticación basada en cookies.

Además, en IdentityHostingStartup.cs, agregue el código siguiente al bloque de instrucciones using en la parte superior. Guarde los cambios.
```
using Npgsql;
```
El código anterior resuelve la referencia a la clase NpgsqlConnectionStringBuilder en el método Configure.
```
using Microsoft.Data.SqlClient;
```
El código anterior resuelve la referencia a la clase SqlConnectionStringBuilder en el método Configure.
En el método Configure de Startup.cs, reemplace el comentario // Add the app.UseAuthentication code por el código siguiente. Guarde los cambios.
```
app.UseAuthentication();
```
El código anterior habilita las capacidades de autenticación. Más concretamente, se agrega una instancia del middleware de autenticación ASP.NET Core a la canalización de control de solicitudes HTTP de la aplicación.
Ejecute el comando siguiente para imprimir la cadena de conexión de base de datos a la consola. Copie la cadena de conexión en el portapapeles.
```
echo $dbConnectionString
```

En appsettings.json, reemplace la cadena de conexión de ContosoPetsAuthConnection por la cadena de conexión del paso anterior. Guarde los cambios.

La sección ConnectionStrings debería tener un aspecto similar al siguiente JSON:

"ConnectionStrings": {
    "ContosoPetsAuthConnection": "Server={HOST NAME}.postgres.database.azure.com;Database=contosopets;Port=5432;Ssl Mode=Require;"
}

"ConnectionStrings": {
    "ContosoPetsAuthConnection": "Data Source={HOST NAME}.database.windows.net;Initial Catalog=ContosoPets;Connect Timeout=30;Encrypt=True;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False"
}

Ejecute el siguiente comando para compilar la aplicación:
```
dotnet build
```
La compilación se ejecuta correctamente sin advertencias. Si se produce un error en la compilación, compruebe la salida con el fin de obtener información para solucionar problemas.

Actualización de la base de datos

Instale la herramienta de migración de Entity Framework Core:
```
dotnet tool install dotnet-ef --version 3.1.3
```
Se mostrará la siguiente salida:
```
You can invoke the tool from this directory using the following commands: 'dotnet tool run dotnet-ef' or 'dotnet dotnet-ef'.
Tool 'dotnet-ef' (version '3.1.3') was successfully installed. Entry is added to the manifest file /home/<USER>/aspnet-learn/src/ContosoPets.Ui/.config/dotnet-tools.json.
```
La herramienta de migración es una herramienta de .NET Core que permite hacer lo siguiente:
- Generar código denominado migración para crear y actualizar la base de datos que admite el modelo de entidad de Identity.
- Ejecutar migraciones en una base de datos existente.
- Invocarlo a través de dotnet ef en este módulo.

Cree y ejecute una migración de EF Core para actualizar la base de datos:

dotnet ef migrations add CreateIdentitySchema && \
    dotnet ef database update

La migración de EF Core CreateIdentitySchema ha aplicado un script de cambios del lenguaje de definición de datos (DDL) para crear las tablas que son compatibles con Identity. Por ejemplo, en el fragmento siguiente se muestra una instrucción CREATE TABLE que genera la migración:

info: Microsoft.EntityFrameworkCore.Database.Command[20101]
  Executed DbCommand (329ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
  CREATE TABLE "AspNetUsers" (
      "Id" text NOT NULL,
      "UserName" character varying(256) NULL,
      "NormalizedUserName" character varying(256) NULL,
      "Email" character varying(256) NULL,
      "NormalizedEmail" character varying(256) NULL,
      "EmailConfirmed" boolean NOT NULL,
      "PasswordHash" text NULL,
      "SecurityStamp" text NULL,
      "ConcurrencyStamp" text NULL,
      "PhoneNumber" text NULL,
      "PhoneNumberConfirmed" boolean NOT NULL,
      "TwoFactorEnabled" boolean NOT NULL,
      "LockoutEnd" timestamp with time zone NULL,
      "LockoutEnabled" boolean NOT NULL,
      "AccessFailedCount" integer NOT NULL,
      CONSTRAINT "PK_AspNetUsers" PRIMARY KEY ("Id")
  );

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

Ejecute el comando siguiente para enumerar las tablas de la base de datos:

db -c "SELECT tablename FROM pg_catalog.pg_tables WHERE schemaname != 'pg_catalog' AND schemaname != 'information_schema' ORDER BY tablename"

El resultado confirma la creación de las tablas:

       tablename
-----------------------
 AspNetRoleClaims
 AspNetRoles
 AspNetUserClaims
 AspNetUserLogins
 AspNetUserRoles
 AspNetUserTokens
 AspNetUsers
 __EFMigrationsHistory
(8 rows)

db -Q "SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='dbo' ORDER BY TABLE_NAME" -Y 25

Aparece el resultado siguiente, que confirma la creación de las tablas.

TABLE_NAME
-------------------------
__EFMigrationsHistory
AspNetRoleClaims
AspNetRoles
AspNetUserClaims
AspNetUserLogins
AspNetUserRoles
AspNetUsers
AspNetUserTokens

(8 rows affected)

En Pages/Shared/_Layout.cshtml, reemplace el comentario @* Add the _LoginPartial partial view *@ por lo siguiente. Guarde los cambios.
```
<partial name="_LoginPartial" />
```
El marcado anterior representa la vista parcial _LoginPartial en el encabezado de cualquier página que use el diseño predeterminado. El scaffold de Identity ha agregado _LoginPartial. En esta vista parcial se muestran al usuario los vínculos Iniciar sesión y Registrarse, en caso de que el usuario no haya iniciado sesión.
Ejecute el siguiente comando para compilar la aplicación:
```
dotnet build --no-restore
```
La opción --no-restore se incluye porque no se han agregado paquetes NuGet desde la última compilación. El proceso de compilación omite la restauración de paquetes NuGet y se realiza correctamente sin ninguna advertencia. Si se produce un error en la compilación, compruebe la salida con el fin de obtener información para solucionar problemas.
Implemente la aplicación en Azure App Service ejecutando el comando siguiente:
```
az webapp up
```
Nota

El archivo .azure/config de la raíz del proyecto contiene los valores de configuración que usa az webapp up.
Ejecute el comando siguiente para ver la dirección URL de la aplicación. En el explorador, vaya a la dirección URL.
```
echo $webAppUrl
```
Haga clic en el vínculo Registrarse del encabezado de la aplicación. Rellene el formulario para crear una cuenta nueva.

Después de que el registro se haya realizado correctamente:
- Se le redirigirá a la página principal.
- El encabezado de la aplicación muestra Hola [dirección de correo electrónico] y un vínculo de Cerrar sesión.
- Se crea una cookie llamada .AspNetCore.Identity.Application. Identity conserva las sesiones de usuario con autenticación basada en cookies.
Haga clic en el vínculo Cerrar sesión del encabezado de la aplicación.

Después de haber cerrado la sesión correctamente, se elimina la cookie .AspNetCore.Identity.Application para finalizar la sesión de usuario.

Continuar

Ejercicio: configuración de la compatibilidad con Identity

Adición de Identity al proyecto

Adición del proveedor de base de datos PostgreSQL

Configuración de la conexión de base de datos

Actualización de la base de datos

Adición de los vínculos de inicio de sesión y registro