Microservicios .NET: implementa paso a paso

Implementar microservicios escalables con .NET y C# es una de las habilidades más demandadas en la arquitectura de software moderna. Este tutorial paso a paso te guiará desde los fundamentos hasta la puesta en producción de un sistema distribuido, utilizando contenedores, mensajería asíncrona y patrones de resiliencia. Aprenderás a diseñar servicios independientes que escalen horizontalmente sin comprometer la consistencia ni la velocidad de desarrollo.

¿Qué son los microservicios y por qué usarlos con .NET?

Los microservicios dividen una aplicación monolítica en componentes pequeños, autónomos y desplegables de forma independiente. .NET ofrece un ecosistema maduro con ASP.NET Core, Entity Framework Core y bibliotecas como Polly para resiliencia. Al adoptar esta arquitectura, obtienes escalabilidad granular, equipos autónomos y despliegues frecuentes. Para profundizar en los patrones de diseño, puedes explorar el curso de microservicios .NET, que cubre casos prácticos reales.

Preparación del entorno de desarrollo

Antes de escribir código, configura tu máquina con las herramientas necesarias:

• .NET 8 SDK: descárgalo desde el sitio oficial de Microsoft.
• Docker Desktop: para contenerizar cada microservicio.
• Visual Studio 2022 o VS Code con extensiones de C#.
• Postman o curl para probar endpoints.

Verifica la instalación ejecutando dotnet --version. Luego crea una solución con varios proyectos: uno para la API de pedidos, otro para pagos y otro para notificaciones. La modularidad desde el inicio facilita el mantenimiento.

Diseño de la comunicación entre servicios

La comunicación puede ser síncrona (HTTP/REST) o asíncrona (colas de mensajes). Para alta escalabilidad, prefiere mensajería con RabbitMQ o Azure Service Bus. Cada servicio publica eventos cuando cambia su estado; otros servicios se suscriben y reaccionan. Este patrón evita acoplamiento fuerte y permite que cada componente escale por separado. Si deseas ver una implementación completa de este patrón, el curso de microservicios .NET incluye ejemplos con RabbitMQ y Docker Compose.

Implementación de un endpoint REST básico

Crea un controlador en ASP.NET Core que exponga un recurso /api/pedidos. Usa inyección de dependencias para separar la lógica de negocio del acceso a datos. Por ejemplo:

[ApiController]
[Route("api/[controller]")]
public class PedidosController : ControllerBase
{
    private readonly IPedidoService _service;
    public PedidosController(IPedidoService service) => _service = service;

    [HttpGet]
    public async Task<IActionResult> Get() => Ok(await _service.ObtenerTodos());
}

Este diseño limpio permite probar cada servicio de forma aislada y reemplazar implementaciones sin afectar a otros.

Contenerización con Docker

Cada microservicio debe empaquetarse en una imagen Docker. Crea un Dockerfile en la raíz del proyecto:

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["Pedidos.API/Pedidos.API.csproj", "Pedidos.API/"]
RUN dotnet restore "Pedidos.API/Pedidos.API.csproj"
COPY . .
RUN dotnet publish "Pedidos.API/Pedidos.API.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "Pedidos.API.dll"]

Luego usa docker-compose.yml para orquestar múltiples servicios, incluyendo bases de datos y colas de mensajes.

Escalabilidad horizontal y balanceo de carga

Para escalar, despliega varias instancias del mismo servicio detrás de un balanceador como Nginx o el API Gateway de Ocelot. Configura health checks en cada endpoint para que el balanceador redirija tráfico solo a instancias saludables. Con Docker Compose puedes simularlo fácilmente:

services:
  pedidos-api:
    build: ./Pedidos.API
    ports:
      - "5001:80"
    deploy:
      replicas: 3

Esta configuración permite probar la resiliencia localmente antes de ir a producción.

Resiliencia con Polly

Las fallas son inevitables en sistemas distribuidos. Usa la biblioteca Polly para implementar reintentos con backoff exponencial, circuit breakers y timeouts. Por ejemplo, al llamar al servicio de pagos desde pedidos:

var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));

await retryPolicy.ExecuteAsync(() => httpClient.PostAsJsonAsync("pagos", pedido));

Este enfoque evita que un servicio caído derribe a toda la aplicación. Para una guía más detallada sobre resiliencia y patrones avanzados, revisa el curso de microservicios .NET donde se explican circuit breakers y bulkheads.

Monitoreo y logging centralizado

Sin visibilidad, un sistema de microservicios es imposible de depurar. Implementa logging estructurado con Serilog y envía los logs a una consola centralizada como Seq o ELK. Además, expone métricas con Prometheus y dashboards con Grafana. Cada servicio debe incluir un correlation ID en cada request para rastrear el flujo completo.

Ejemplo de configuración de Serilog

Log.Logger = new LoggerConfiguration()
    .WriteTo.Console()
    .WriteTo.Seq("http://localhost:5341")
    .Enrich.WithProperty("Service", "Pedidos.API")
    .CreateLogger();

Con esto, puedes filtrar errores por servicio y tiempo de respuesta.

Despliegue en producción

Para producción, usa Kubernetes (K8s) para orquestar contenedores, escalar automáticamente y gestionar actualizaciones rolling. Define manifiestos YAML para deployments, services e ingress. Por ejemplo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: pedidos-api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: pedidos
  template:
    metadata:
      labels:
        app: pedidos
    spec:
      containers:
      - name: pedidos
        image: pedidos-api:latest
        ports:
        - containerPort: 80

Kubernetes maneja la escalabilidad automática basada en CPU o métricas personalizadas.

Próximos pasos y aprendizaje continuo

Implementar microservicios escalables con .NET y C# es un viaje que combina diseño, código y operaciones. Este tutorial te ha dado los fundamentos prácticos, pero la práctica constante es clave. Si deseas acelerar tu curva de aprendizaje con proyectos guiados, el curso de microservicios .NET te ofrece ejercicios, laboratorios y mentoría. Empieza hoy y construye sistemas que crezcan con tu negocio.