Microservicios en C# (.NET): arquitectura y práctica

Microservicios en C# (.NET): de la teoría a la práctica

En el desarrollo de software moderno, la arquitectura de microservicios se ha convertido en el estándar para construir sistemas escalables y tolerantes a fallos. La plataforma .NET proporciona todas las herramientas necesarias para crear microservicios robustos en C#. En este artículo, exploraremos los principios clave de la arquitectura, ejemplos prácticos de código y las mejores prácticas que te ayudarán a comenzar a construir microservicios en C#.

1. Fundamentos de la arquitectura de microservicios en .NET

Los microservicios son un enfoque de desarrollo en el que una aplicación se divide en servicios pequeños e independientes, cada uno responsable de una función de negocio específica. En el ecosistema .NET, para esto se utiliza ASP.NET Core, un framework ligero y multiplataforma.

Principios clave de los microservicios en C#:

• Independencia de despliegue — cada servicio puede actualizarse sin detener los demás.
• Bajo acoplamiento — los servicios se comunican a través de API (REST, gRPC) o colas de mensajes.
• Base de datos propia — cada microservicio posee sus propios datos (Database per Service).
• Tolerancia a fallos — la falla de un servicio no debe bloquear todo el sistema.

Comencemos creando un microservicio simple en C#. Usaremos la plantilla ASP.NET Core Web API.

// Creación de un nuevo proyecto de microserviciodotnet new webapi -n OrderServicecd OrderService

// Ejemplo de un controlador simple[ApiController][Route("api/[controller]")]public class OrdersController : ControllerBase{    private readonly IOrderRepository _repository;

    public OrdersController(IOrderRepository repository)    {        _repository = repository;    }

    [HttpGet("{id}")]    public async Task<IActionResult> GetOrder(int id)    {        var order = await _repository.GetByIdAsync(id);        if (order == null)            return NotFound();        return Ok(order);    }

    [HttpPost]    public async Task<IActionResult> CreateOrder(OrderDto orderDto)    {        var order = new Order(orderDto.CustomerId, orderDto.TotalAmount);        await _repository.AddAsync(order);        return CreatedAtAction(nameof(GetOrder), new { id = order.Id }, order);    }}

2. Comunicación entre servicios: REST, gRPC y colas

Los microservicios deben comunicarse entre sí. En .NET están disponibles tres enfoques principales:

REST API (HTTP)

La forma más simple y común. Usa HttpClient con una fábrica para una gestión adecuada de las conexiones.

// Ejemplo de llamada a otro microservicio a través de HttpClientpublic class InventoryServiceClient{    private readonly HttpClient _httpClient;

    public InventoryServiceClient(HttpClient httpClient)    {        _httpClient = httpClient;    }

    public async Task<bool> CheckStockAsync(int productId, int quantity)    {        var response = await _httpClient.GetAsync(            $"/api/inventory/check?productId={productId}&quantity={quantity}");        return response.IsSuccessStatusCode;    }}

// Registro en Program.csbuilder.Services.AddHttpClient<InventoryServiceClient>(client =>{    client.BaseAddress = new Uri("http://inventory-service:5001");});

gRPC

Para comunicación síncrona de alto rendimiento, usa gRPC. Está basado en HTTP/2 y Protocol Buffers.

// Definición del servicio en archivo .protosyntax = "proto3";

service OrderProcessor {  rpc ProcessOrder (OrderRequest) returns (OrderResponse);}

message OrderRequest {  int32 order_id = 1;  string customer_email = 2;}

message OrderResponse {  bool success = 1;  string message = 2;}

// Parte del servidor en C#public class OrderProcessorService : OrderProcessor.OrderProcessorB