Mikroservices in C#: Architektur und Praxis von A bis Z

Einführung in Mikroservices mit C#

Die Mikroservice-Architektur ist zum De-facto-Standard für die Entwicklung komplexer, skalierbarer und ausfallsicherer Anwendungen geworden. Im Gegensatz zum Monolithen, bei dem der gesamte Code in einem einzigen Prozess vereint ist, unterteilen Mikroservices das System in kleine, unabhängig bereitstellbare Dienste. Die .NET-Plattform (C#) bietet alle notwendigen Werkzeuge zur Erstellung professioneller Mikroservices: von ASP.NET Core für Web-APIs bis hin zu Bibliotheken für die Arbeit mit Warteschlangen, Containerisierung und Orchestrierung.

In diesem Artikel betrachten wir den gesamten Weg von der Architekturplanung bis zur praktischen Implementierung eines Mikroservices in C# mit Codebeispielen.

1. Grundlagen der Mikroservice-Architektur

Prinzipien und Antipatterns

Bevor wir Code schreiben, ist es wichtig, die Schlüsselprinzipien zu verstehen:

\n
• Einzelverantwortung (SRP): Jeder Service ist für eine einzige Geschäftsfunktion verantwortlich (z. B. Bestellservice, Zahlungsservice).
\n
• Lockere Kopplung: Services kommunizieren über das Netzwerk (HTTP, gRPC, Warteschlangen) und kennen die interne Struktur der anderen nicht.
\n
• Unabhängige Bereitstellung: Sie können einen Service aktualisieren, ohne andere zu stoppen.
\n
• Daten-Dezentralisierung: Jeder Service besitzt seine eigene Datenbank (Database per Service).
\n

Antipatterns, die vermieden werden sollten: Zu kleine Services (Nanoservices), gemeinsame Datenbank, synchrone Aufrufketten (Chattiness).

Kommunikation zwischen Services

Für die Interaktion von Mikroservices in C# werden verwendet:

\n
• Synchron: REST API (HTTP/JSON) oder gRPC (binäres Protokoll, schneller).
\n
• Asynchron: Nachrichtenwarteschlangen (RabbitMQ, Azure Service Bus, Kafka) – bevorzugte Methode für lockere Kopplung.
\n

2. Praktische Implementierung eines Mikroservices in C#

Beispiel: Bestellverwaltungsservice

Erstellen wir einen einfachen Mikroservice mit ASP.NET Core 8. Wir verwenden Clean Architecture zur Schichtentrennung.

Schritt 1: Projekt und Struktur

dotnet new webapi -n OrderService\ncd OrderService

Ordner erstellen: Controllers, Models, Services, Data.

Schritt 2: Datenmodell

// 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}

Schritt 3: Datenbankkontext (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}

Schritt 4: Serviceschicht

// 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}

Schritt 5: Controller

// 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\