Microservicios en C#: arquitectura y práctica de la A a la Z

Introducción a los microservicios en C#

La arquitectura de microservicios (MSA) es un enfoque de desarrollo de software donde la aplicación se construye como un conjunto de servicios pequeños e implementados de forma independiente. Cada servicio implementa una capacidad de negocio única, tiene su propia base de datos y puede escribirse en diferentes lenguajes. Sin embargo, en el ecosistema .NET, la plataforma C# y ASP.NET Core proporcionan algunas de las mejores herramientas para construir microservicios robustos.

En este artículo, exploraremos el ciclo completo de creación de microservicios en C#: desde el diseño de la arquitectura hasta la implementación en contenedores. Aprenderá cómo organizar la interacción entre servicios, garantizar su tolerancia a fallos y escalabilidad.

1. Diseño de la arquitectura de microservicios en .NET

El primer paso es dividir correctamente una aplicación monolítica en servicios. Una buena práctica es seguir el principio de Domain-Driven Design (DDD) e identificar Bounded Contexts (contextos delimitados).

1.1. Definición de los límites de los servicios

Cada microservicio debe ser responsable de una entidad o proceso de negocio único. Por ejemplo, para una tienda en línea, podemos identificar:

• Catalog Service — gestión de productos
• Order Service — procesamiento de pedidos
• Payment Service — pagos
• Notification Service — notificaciones

Importante: cada servicio posee su propia base de datos. Esto evita el acoplamiento y permite escalar los servicios de forma independiente.

1.2. Estructura del proyecto ASP.NET Core

Un microservicio típico en C# consta de varias capas:

• API Layer — controladores y middleware
• Application Layer — CQRS, MediatR, comandos y consultas
• Domain Layer — entidades, value objects, agregados
• Infrastructure Layer — repositorios, DbContext, servicios externos

Ejemplo de una estructura de directorio mínima:

MyMicroservice/├── MyMicroservice.Api/│   └── Controllers/├── MyMicroservice.Application/│   └── Commands/├── MyMicroservice.Domain/│   └── Entities/└── MyMicroservice.Infrastructure/    └── Data/

2. Implementación de un microservicio en C#: ejemplo práctico

Crearemos un servicio simple para gestionar un catálogo de productos utilizando ASP.NET Core 8 y Entity Framework Core.

2.1. Configuración de WebApplication

En el archivo Program.cs configuramos la API mínima:

var builder = WebApplication.CreateBuilder(args);

// Agregamos serviciosbuilder.Services.AddDbContext<CatalogDbContext>(options =>    options.UseSqlServer(builder.Configuration.GetConnectionString("CatalogDb")));

builder.Services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(typeof(Program).Assembly));

builder.Services.AddEndpointsApiExplorer();builder.Services.AddSwaggerGen();

var app = builder.Build();

// Middlewareif (app.Environment.IsDevelopment()){    app.UseSwagger();    app.UseSwaggerUI();}

app.UseHttpsRedirection();

// Endpoint de API mínimaapp.MapGet("/api/products", async (IMediator mediator) =>{    var products = await mediator.Send(new GetProductsQuery());    return Results.Ok(products);});

app.Run();

2.2. Modelo de datos y CQRS

Crearemos la entidad Product:

public class Product{    public Guid Id { get; set; }    public string Name { get; set; } = string.Empty;    public decimal Price { get; set; }    public string Category { get; set; } = string.Empty;}

Usamos el patrón CQRS con MediatR para separar comandos y consultas:

public record GetProductsQuery() : IRequest<List<Product>>;

public class GetProductsHandler : IRequestHandler<GetProduc