Microservices en C# : architecture et pratique de A à Z

Introduction aux microservices en C#

L'architecture microservices est devenue le standard de facto pour la construction d'applications complexes, évolutives et résilientes. Contrairement au monolithe, où tout le code est regroupé dans un seul processus, les microservices divisent le système en petits services déployables indépendamment. La plateforme .NET (C#) fournit tous les outils nécessaires pour créer des microservices professionnels : d'ASP.NET Core pour les API web aux bibliothèques pour la gestion des files d'attente, la conteneurisation et l'orchestration.

Dans cet article, nous examinerons le parcours complet, de la conception de l'architecture à l'implémentation pratique d'un microservice en C# avec des exemples de code.

1. Fondamentaux de l'architecture microservices

Principes et anti-patrons

Avant d'écrire du code, il est important de comprendre les principes clés :

\n
• Responsabilité unique (SRP) : Chaque service est responsable d'une fonction métier (par exemple, service de commandes, service de paiement).
\n
• Faible couplage : Les services communiquent via le réseau (HTTP, gRPC, files d'attente) et ne connaissent pas le fonctionnement interne des autres.
\n
• Déploiement indépendant : Vous pouvez mettre à jour un service sans arrêter les autres.
\n
• Décentralisation des données : Chaque service possède sa propre base de données (Database per Service).
\n

Anti-patrons à éviter : services trop petits (nanoservices), base de données partagée, chaînes d'appels synchrones (chattiness).

Communication entre services

Pour l'interaction des microservices en C#, on utilise :

\n
• Synchrone : REST API (HTTP/JSON) ou gRPC (protocole binaire, plus rapide).
\n
• Asynchrone : Files d'attente de messages (RabbitMQ, Azure Service Bus, Kafka) — méthode préférée pour un faible couplage.
\n

2. Implémentation pratique d'un microservice en C#

Exemple : Service de gestion des commandes

Créons un microservice simple avec ASP.NET Core 8. Utilisons Clean Architecture pour séparer les couches.

Étape 1 : Projet et structure

dotnet new webapi -n OrderService\ncd OrderService

Créons les dossiers : Controllers, Models, Services, Data.

Étape 2 : Modèle de données

// Models/Order.cs\npublic class Order\n{\n    public int Id { get; set; }\n    public string CustomerName { get; set; }\n    public decimal TotalAmount { get; set; }\n    public DateTime CreatedAt { get; set; }\n}

Étape 3 : Contexte de base de données (Entity Framework Core)

// Data/OrderDbContext.cs\npublic class OrderDbContext : DbContext\n{\n    public OrderDbContext(DbContextOptions<OrderDbContext> options) : base(options) { }\n    public DbSet<Order> Orders { get; set; }\n}

Étape 4 : Couche service

// Services/IOrderService.cs\npublic interface IOrderService\n{\n    Task<Order> CreateOrderAsync(Order order);\n    Task<List<Order>> GetAllOrdersAsync();\n}\n\n// Services/OrderService.cs\npublic class OrderService : IOrderService\n{\n    private readonly OrderDbContext _context;\n    public OrderService(OrderDbContext context)\n    {\n        _context = context;\n    }\n\n    public async Task<Order> CreateOrderAsync(Order order)\n    {\n        _context.Orders.Add(order);\n        await _context.SaveChangesAsync();\n        return order;\n    }\n\n    public async Task<List<Order>> GetAllOrdersAsync()\n    {\n        return await _context.Orders.ToListAsync();\n    }\n}

Étape 5 : Contrôleur

// Controllers/OrdersController.cs\n[ApiController]\n[Route("api/[controller]")]\npublic class OrdersController : ControllerBase\n{\n    private readonly IOrderService _orderService;\n    public OrdersController(IOrderService orderService)\n    {\n        _orderService = orderService;\n    }\n\