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

Introduction aux microservices en C#

L'architecture microservices (MSA) est une approche de développement logiciel où l'application est construite comme un ensemble de petits services déployés indépendamment. Chaque service implémente une capacité métier unique, possède sa propre base de données et peut être écrit dans différents langages. Cependant, dans l'écosystème .NET, la plateforme C# et ASP.NET Core fournissent certains des meilleurs outils pour construire des microservices fiables.

Dans cet article, nous allons parcourir le cycle complet de création de microservices en C# : de la conception de l'architecture au déploiement dans des conteneurs. Vous apprendrez comment organiser l'interaction entre les services, assurer leur tolérance aux pannes et leur scalabilité.

1. Conception de l'architecture des microservices sur .NET

La première étape consiste à découper correctement l'application monolithique en services. Une bonne pratique consiste à suivre le principe du Domain-Driven Design (DDD) et à identifier les Bounded Contexts (contextes délimités).

1.1. Définition des limites des services

Chaque microservice doit être responsable d'une seule entité ou processus métier. Par exemple, pour une boutique en ligne, on peut identifier :

• Catalog Service — gestion des produits
• Order Service — traitement des commandes
• Payment Service — paiements
• Notification Service — notifications

Important : chaque service possède sa propre base de données. Cela évite le couplage et permet de scaler les services indépendamment.

1.2. Structure du projet ASP.NET Core

Un microservice typique en C# se compose de plusieurs couches :

• API Layer — contrôleurs et middleware
• Application Layer — CQRS, MediatR, commandes et requêtes
• Domain Layer — entités, value objects, agrégats
• Infrastructure Layer — repositories, DbContext, services externes

Exemple de structure minimale de répertoire :

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

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

Créons un service simple pour gérer un catalogue de produits en utilisant ASP.NET Core 8 et Entity Framework Core.

2.1. Configuration de WebApplication

Dans le fichier Program.cs, nous configurons l'API minimale :

var builder = WebApplication.CreateBuilder(args);

// Ajout des servicesbuilder.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();

// Point de terminaison de l'API minimaleapp.MapGet("/api/products", async (IMediator mediator) =>{    var products = await mediator.Send(new GetProductsQuery());    return Results.Ok(products);});

app.Run();

2.2. Modèle de données et CQRS

Création de l'entité 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;}

Utilisation du patron CQRS avec MediatR pour séparer les commandes et les requêtes :

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

public class GetProductsHandler : IRequestHandler<GetProduc