Microservices en C# (.NET) : architecture et pratique

Microservices en C# (.NET) : de la théorie à la pratique

Dans le développement logiciel moderne, l'architecture microservices est devenue la norme pour construire des systèmes évolutifs et résilients. La plateforme .NET fournit tous les outils nécessaires pour créer des microservices fiables en C#. Dans cet article, nous examinerons les principes clés de l'architecture, des exemples de code pratiques et les meilleures pratiques pour vous aider à commencer à construire des microservices en C#.

1. Fondamentaux de l'architecture microservices sur .NET

Les microservices sont une approche de développement où une application est divisée en petits services indépendants, chacun responsable d'une fonction métier spécifique. Dans l'écosystème .NET, on utilise ASP.NET Core, un framework léger et multiplateforme.

Principes clés des microservices en C# :

• Indépendance de déploiement — chaque service peut être mis à jour sans arrêter les autres.
• Faible couplage — les services communiquent via des API (REST, gRPC) ou des files de messages.
• Base de données propre — chaque microservice possède ses propres données (Database per Service).
• Résilience — la panne d'un service ne doit pas bloquer l'ensemble du système.

Commençons par créer un microservice simple en C#. Utilisons le modèle ASP.NET Core Web API.

// Création d'un nouveau projet microservicedotnet new webapi -n OrderServicecd OrderService

// Exemple de contrôleur 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. Communication inter-services : REST, gRPC et files de messages

Les microservices doivent communiquer entre eux. Dans .NET, trois approches principales sont disponibles :

REST API (HTTP)

La méthode la plus simple et la plus courante. Utilisez HttpClient avec une factory pour une gestion correcte des connexions.

// Exemple d'appel d'un autre microservice via 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;    }}

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

gRPC

Pour une communication synchrone haute performance, utilisez gRPC. Il est basé sur HTTP/2 et Protocol Buffers.

// Définition du service dans le fichier .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;}

// Partie serveur en C#public class OrderProcessorService : OrderProcessor.OrderProcessorB