Rozšírenie REST API v ASP.NET Core 8 o PostgreSQL 16 a Docker Compose

Predpoklady

Predtým než začneme, uistite sa, že máte v systéme nainštalovaný nasledovný softvér. Tieto nástroje sú potrebné na vývoj a spustenie aplikácie:

• .NET Core SDK: Umožňuje vývoj aplikácií v ASP.NET Core.
• Docker: Platforma na zostavovanie, distribúciu a spúšťanie aplikácií v kontajneroch.
• Zdrojový kód: Dostupný na GitHub.

Rozšírenie existujúceho projektu

V predchádzajúcom článku sme vytvorili jednoduché REST API v ASP.NET Core s úložiskom dát v pamäti (in-memory). Teraz projekt vylepšíme integráciou PostgreSQL ako databázy. Zároveň použijeme Docker Compose na orchestráciu backendu, databázy a už skôr vytvorenej klientskej aplikácie.

Pridanie Entity Framework Core

Entity Framework (EF) Core je Object‑Relational Mapper (ORM), ktorý zjednodušuje prácu s databázou pomocou .NET objektov.

Nainštalujte potrebné balíčky pomocou nasledujúcich príkazov:

dotnet tool install --global dotnet-ef
dotnet add package Microsoft.EntityFrameworkCore --version 8.0.8
dotnet add package Microsoft.EntityFrameworkCore.Design --version 8.0.8
dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL --version 8.0.4

Vytvorte triedu DataContext v súbore DataContext.cs, ktorá bude slúžiť na interakciu s databázou:

public class DataContext : DbContext
{
  public DataContext(DbContextOptions<DataContext> options) : base(options)
  {
  }

  protected override void OnModelCreating(ModelBuilder modelBuilder)
  {
    // Seed the database with migration
    modelBuilder.Entity<ToDo>().HasData(
      new ToDo { Id = 1, Name = "Do the dishes", IsDone = false },
      new ToDo { Id = 2, Name = "Walk the dog", IsDone = false },
      new ToDo { Id = 3, Name = "Buy groceries", IsDone = false }
    );
  }

  public DbSet<ToDo> ToDos { get; set; }
}

DbSet<ToDo> reprezentuje tabuľku v databáze a OnModelCreating slúži na inicializačné (seed) dáta.

Rozšírte model ToDo o anotácie:

public class ToDo
{
  [Column("id")]
  public long Id { get; set; } // Unique identifier for the todo item

  [Column("name")]
  [MaxLength(100)]
  public string Name { get; set; } // Descriptive name of the todo item

  [Column("is_done")]
  public bool IsDone { get; set; } // Status indicating whether the todo is completed
}

Na konfiguráciu pripojenia k databáze pridajte do Program.cs connection string poskladaný z environment premenných:

// Get connection string
string connectionString =
  $"Host={Environment.GetEnvironmentVariable("ASPNETCORE_POSTGRES_HOST")}; " +
  $"Port={Environment.GetEnvironmentVariable("ASPNETCORE_POSTGRES_PORT")}; " +
  $"Database={Environment.GetEnvironmentVariable("ASPNETCORE_POSTGRES_DATABASE")}; " +
  $"Username={Environment.GetEnvironmentVariable("ASPNETCORE_POSTGRES_USER")}; " +
  $"Password={Environment.GetEnvironmentVariable("ASPNETCORE_POSTGRES_PASSWORD")};";
Console.WriteLine($"Connection string: {connectionString}");

// Register the DataContext with postgresql
builder.Services.AddDbContext<DataContext>(options =>
  options.UseNpgsql(connectionString));

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

// Register our custom service with the lifetime of the request
builder.Services.AddScoped<IToDoService, ToDoService>();

Prechod na asynchrónne programovanie

Databázové operácie by mali byť neblokujúce. Upravte rozhranie IToDoService na asynchrónne metódy:

public interface IToDoService
{
  Task<ToDo> AddToDo(AddToDoDto addToDo);
  Task<ToDo?> GetToDo(long id);
  Task<List<ToDo>> GetToDos();
  Task DeleteToDo(long id);
  Task UpdateToDo(long id, UpdateToDoDto updateToDo);
}

Následne implementujte asynchrónne metódy v triede ToDoService:

public class ToDoService : IToDoService
{
  private readonly DataContext _context; // Store ToDos in database

  public ToDoService(DataContext context)
  {
    _context = context;
  }

  public async Task<ToDo> AddToDo(AddToDoDto addToDo)
  {
    var newToDo = new ToDo
    {
      Name = addToDo.Name,
      IsDone = false
    };
    _context.ToDos.Add(newToDo);
    await _context.SaveChangesAsync();
    // EF Core populates the generated Id on the tracked entity after saving,
    // so there is no need to query the database again.
    return newToDo;
  }
}

Tomu prispôsobte aj metódy v kontroléri:

// Add a new ToDo
[HttpPost]
public async Task<ActionResult<ToDo>> AddToDo(AddToDoDto addToDo)
{
  _logger.LogInformation($"API: AddToDo called with ToDo Name {addToDo.Name}");

  var toDo = await _toDoService.AddToDo(addToDo);

  return CreatedAtAction(nameof(GetToDo), new { id = toDo.Id }, toDo);
}

Orchestrácia služieb pomocou Docker Compose

Docker Compose zjednodušuje správu viacerých kontajnerizovaných služieb. V tomto kroku budeme orchestrovať štyri služby:

• Backend (tento článok)
• Frontend (predchádzajúci článok)
• PostgreSQL databáza
• PGAdmin (správa databázy)

Vytvorte súbor docker-compose.yml:

services:
  todo:
    build:
      context: ../react-18-todo-list
      dockerfile: Dockerfile
    container_name: todo
    ports:
      - 5173:5173

  todo-api:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: todo-api
    ports:
      - 5277:5277
    depends_on:
      - postgres

  postgres:
    image: postgres:16.4
    container_name: postgres
    ports:
      - 5432:5432
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres

  pgadmin:
    image: dpage/pgadmin4
    container_name: pgadmin
    ports:
      - 8080:80
    environment:
      - PGADMIN_DEFAULT_EMAIL=admin@admin.com
      - PGADMIN_DEFAULT_PASSWORD=admin

Spustite služby:

docker compose up -d

Na začiatku je databáza prázdna. Použijeme migrácie na vytvorenie tabuliek v databáze:

# Export environment variables
export ASPNETCORE_POSTGRES_PORT=5432
export ASPNETCORE_POSTGRES_HOST=localhost
export ASPNETCORE_POSTGRES_DATABASE=postgres
export ASPNETCORE_POSTGRES_USER=postgres
export ASPNETCORE_POSTGRES_PASSWORD=postgres
# The Migrations/ folder is already in the repository, so you only need to
# apply it. (If you are building the project from scratch alongside this
# article, create it first with: dotnet ef migrations add InitialMigration)
dotnet ef database update --project aspnet-core-8-todo-list-api.csproj

Klientsku aplikáciu nájdete na http://localhost:5173. Databázu si môžete overiť cez PGAdmin na http://localhost:8080 s použitím uvedených prihlasovacích údajov.

Záver

Úspešne sme integrovali PostgreSQL do REST API v ASP.NET Core a pomocou Docker Compose sme orchestriovali celú aplikáciu. Vaša aplikácia teraz podporuje perzistentné ukladanie dát.