¡Saludos! Esta publicación será un tutorial de tres partes, con la intención final de llevar a cabo el despliegue de una migración de EF Core de una base de datos PostgreSQL en el servicio de Servidores Flexibles para Bases de Datos PostgreSQL en Azure Cloud.

A modo de contextualización, una migración de Entity Framework Core (EF Core) es un mecanismo que provee .Net que permite a los desarrolladores mantener sincronizado el esquema de una base de datos a medida que el proyecto va requiriendo nuevos cambios. Estas migraciones generan los scripts de actualización necesarios para actualizar la base de datos, sin causar pérdida de datos o la destrucción de la base de datos física.

Las ventajas principales de utilizar migraciones de EF Core están asociadas a la posibilidad de realizar cambios simples y complejos sobre una BD, a medida que el proyecto evoluciona en el ciclo de vida de desarrollo de software. Además de servir como control de versiones de los cambios que se han realizado a la base de datos garantizando una ejecución incremental de cada una de las actualizaciones.

Para seguir esta práctica, estas son las tecnologías que van a ser utilizadas a lo largo de esta primera parte:

• Podman o Docker. En este tutorial se hará uso de Podman para la configuración de una imagen en la cual se encontrará el servidor de base de datos PostgreSQL y una imagen basada en .Net 6 para la compilación y ejecución de la migración de forma local. Por las similitudes entre las dos herramientas, Docker puede ser utilizado de igual manera con los mismos argumentos. Sin embargo, para todos los ejemplos se hará uso de Podman para creación y administración de contenedores.

• pgAdmin como herramienta para gestionar y visualizar la base de datos creada.

¡Manos a la obra!

1. Creación de red de contenedores con Podman

Iniciaremos con la construcción de la red de trabajo necesaria para la comunicación entre los contenedores que serán creados y administrados con Podman. Nuestra red de contenedores será nombrada db-net y en ella serán creados los contenedores PostgreSQL y .Net. Ejecutamos el siguiente comando:

podman network create db-net

2. Contenedor con PostgreSQL

Para configurar la base de datos a nivel local, se hará uso de un contenedor sobre el cuál correrá nuestra base de datos PostgreSQL. El contenedor quedará asociado a la red creada previamente.

podman run -d \
  --name postgres-db \
  --network db-net \
  -e POSTGRES_USER=postgres \
  -e POSTGRES_PASSWORD=test123 \
  -e POSTGRES_DB=SampleMigrationDB \
  -p 5432:5432 \
  postgres:15

Este comando crea un contenedor de PostgreSQL versión 15 con el nombre postgres-db. Por medio de variables de entorno, se especifica el usuario, clave y nombre de la base de datos y el puerto de escucha, que por defecto es el 5432. Este puerto es mapeado al puerto 5432 de la máquina local.

Para validar que la base de datos pueda ser accedida, accederemos a ella haciendo uso de pgAdmin.

-- Script para visualizar tablas existentes

SELECT table_name 
FROM information_schema.tables
WHERE table_schema='public'
AND table_type='BASE TABLE';

Logramos acceder a la base de datos y observamos que aún no hay tablas creadas en la misma. Para crearlas, haremos uso de .Net 6.X y Entity Framework Core, que nos permitirán definir el modelo de datos con el que se creará el esquema de la base de datos.

3. Configuración de proyecto de migración con SDK .Net 6 y Entity Framework Core

Se utilizará la imagen oficial del SDK 6.0 de .Net. Se crea el contenedor, asociándolo a la red db-net para que los contenedores puedan comunicarse entre ellos.

podman run -it \
  --network db-net \
  -v ./sample:/home/sample \
  --name sample-migration \
  mcr.microsoft.com/dotnet/sdk:6.0 bash

Este comando abrirá una terminal interactiva dentro del contenedor en el cuál configuraremos nuestro proyecto. Al hacer uso de la opción para montar un volumen -v, podremos desde la máquina local modificar los archivos, sin la necesidad de instalar .Net directamente. Nota: los comandos deben ser ejecutados desde la ruta en que queremos que los archivos sean almacenados.

Para inicializar un nuevo proyecto de .Net llamado SampleMigration, ejecutamos este comando:

dotnet new webapi -n SampleMigration

Al inicializar la aplicación, se crea con los siguientes archivos por defecto necesarios para crear la migración de base de datos.

Para hacer uso de la migración de base de datos, debemos instalar Entity Framework Core y el proveedor del gestor de base de datos que será utilizado. En este caso se hará uso de una base de datos PostgreSQL.

Instalar el proveedor de PostgreSQL para Entity Framework Core

dotnet add package Microsoft.EntityFrameworkCore.Design --version 6.0.0

Instalar el paquete de diseño de Entity Framework Core

dotnet tool install --global dotnet-ef --version 6.0.0

Agregar la ruta donde se encuentra la instalación de la herramienta al PATH:

export PATH="$PATH:/root/.dotnet/tools"

Podremos acceder a los archivos que se encuentran en el contenedor desde nuestra máquina local. Haciendo uso de un IDE o editor de texto, modificamos el archivo appsettings.json para configurar la cadena de conexión a la base de datos.

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "DefaultConnection": "Server=postgres-db;Port=5432;Database=SampleMigrationDB;User Id=postgres;Password=test123;"
  }
}

Como se puede observar, la cadena de conexión está compuesta por el nombre del servidor de BD (corresponde al nombre del contenedor PostgreSQL, hace referencia al huésped de la BD), el puerto, el nombre de la base de datos, el ID (nombre de usuario que se conecta a la BD) y la clave de conexión.

Para crear el modelo de datos, se define un nuevo directorio Models en la raíz del proyecto, dentro del cuál se define la estructura de la BD. En este directorio se crean las tablas de la BD.

Para este ejemplo, crearemos dos clases Customer y Product.

// Archivo Models/Customer.cs

namespace SampleMigration.Models
{
    public class Customer 
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public DateTime CreatedAt { get; set; }
    }

}

// Archivo Models/Product.cs

namespace SampleMigration.Models
{
    public class Product
    {
        public int Id { get; set; }
        public string Description { get; set; }
        public int Quantity { get; set; }
        public decimal Price { get; set; }
    }

}

Dentro de un nuevo directorio Data en la raíz del proyecto, se crea el archivo SampleMigrationDbContext.cs. Este archivo contiene la importación del paquete del modelado en el que se crearon las clases y se importa el paquete Microsoft.EntityFrameworkCore.

// Archivo Data/SampleMigrationDbContext.cs

using SampleMigration.Models;
using Microsoft.EntityFrameworkCore;

namespace SampleMigration.Data
{
    public class SampleMigrationDbContext : DbContext
    {
        public SampleMigrationDbContext(DbContextOptions<SampleMigrationDbContext> options) : base(options) { }

        public DbSet<Customer> Customers { get; set; }
        public DbSet<Product> Products { get; set; }
    }
}

En el archivo Program.cs, añadiremos la configuración para hacer uso del DbContext que se acaba de configurar, utilizando Npgsql.

// Archivo ./Program.cs

using SampleMigration.Data;
using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Configure the DbContext with the Connection string
builder.Services.AddDbContext<SampleMigrationDbContext>(options =>
    options.UseNpgsql(builder.Configuration.GetConnectionString("DefaultConnection")));

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

Hemos terminado de configurar el proyecto. Sin embargo, se debe validar que el proyecto pueda ser compilado de manera correcta antes de poder realizar la migración. Para esto, ejecutamos el siguiente comando dentro del contenedor en la carpeta del proyecto SampleMigration:

dotnet build

¡Perfecto! Con estas configuraciones ya podemos crear la primera migración de la BD. Dentro del directorio SampleMigration, en el contenedor, ejecutar:

dotnet ef migrations add tablesCreation

tablesCreation es el nombre que le estamos asignando a la primera migración que se va a realizar. Esta migración creará dos tablas Customers y Products con los campos especificados en cada una de estas clases.

Una vez añadida la primera migración, observamos que se crea el directorio Migrations en la raíz del proyecto con un hash que representa la fecha y hora de la creación de la migración.

Ahora que hemos validado que el proyecto compila correctamente y que se ha creado la primera migración, podemos proceder a aplicar la migración para crear las tablas de la base de datos. Para aplicar la migración, ejecutamos dentro del contenedor:

dotnet ef database update

Si todo ha salido bien hasta aquí, verás un mensaje similar al de la imagen:

En pgAdmin podremos verificar que las tablas hayan sido creadas exitosamente, haciendo uso del siguiente script:

SELECT table_name 
FROM information_schema.tables
WHERE table_schema='public'
AND table_type='BASE TABLE';

En la tabla __EFMigrationsHistory se guarda el historial de todas las migraciones que han sido aplicadas sobre la base de datos, por esta razón, es importante que evitemos eliminarla o modificar su contenido. Con este historial, futuras modificaciones que se realicen sobre la base de datos se harán de forma consecutiva.

Con esto hemos creado una migración de BD con .Net 6 y Entity Framework que despliega correctamente en un servidor local de PostgreSQL.

Hemos llegado al final de la primera parte. Espero que hayas aprendido algo nuevo o solucionado tus dudas sobre cómo crear migraciones de bases de datos PostgreSQL de forma local con .Net 6 y Entity Framework Core.

En la segunda parte, revisaremos cómo configurar una base de datos en una red privada en la nube de Azure y conectarnos de forma remota para migrar el modelo de datos.

Gracias por acompañarme en esta experiencia de aprendizaje. Por favor, siéntete libre de dejar tus comentarios y retroalimentación de la publicación.