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

Einführung in Mikroservices mit C#

Die Mikroservice-Architektur (MSA) ist ein Ansatz zur Softwareentwicklung, bei dem eine Anwendung als eine Sammlung kleiner, unabhängig bereitstellbarer Dienste aufgebaut wird. Jeder Dienst implementiert eine einzelne Geschäftsfunktion, hat seine eigene Datenbank und kann in verschiedenen Sprachen geschrieben sein. Im .NET-Ökosystem bieten die Plattform C# und ASP.NET Core jedoch einige der besten Werkzeuge zum Erstellen zuverlässiger Mikroservices.

In diesem Artikel betrachten wir den gesamten Zyklus der Erstellung von Mikroservices in C#: vom Architekturentwurf bis zur Bereitstellung in Containern. Sie erfahren, wie Sie die Kommunikation zwischen den Diensten organisieren, deren Ausfallsicherheit und Skalierbarkeit gewährleisten.

1. Entwurf der Mikroservice-Architektur auf .NET

Der erste Schritt besteht darin, eine monolithische Anwendung korrekt in Dienste aufzuteilen. Eine gute Praxis ist es, dem Prinzip des Domain-Driven Design (DDD) zu folgen und Bounded Contexts (abgegrenzte Kontexte) zu identifizieren.

1.1. Festlegung der Dienstgrenzen

Jeder Mikroservice sollte für eine einzelne Geschäftseinheit oder einen Geschäftsprozess verantwortlich sein. Für einen Online-Shop könnte man beispielsweise folgende Dienste definieren:

• Catalog Service — Verwaltung von Produkten
• Order Service — Auftragsabwicklung
• Payment Service — Zahlungen
• Notification Service — Benachrichtigungen

Wichtig: Jeder Dienst besitzt seine eigene Datenbank. Dies verhindert Kopplung und ermöglicht die unabhängige Skalierung der Dienste.

1.2. Projektstruktur von ASP.NET Core

Ein typischer Mikroservice in C# besteht aus mehreren Schichten:

• API Layer — Controller und Middleware
• Application Layer — CQRS, MediatR, Befehle und Abfragen
• Domain Layer — Entitäten, Value Objects, Aggregate
• Infrastructure Layer — Repositories, DbContext, externe Dienste

Beispiel einer minimalen Verzeichnisstruktur:

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

2. Implementierung eines Mikroservices in C#: Praxisbeispiel

Wir erstellen einen einfachen Dienst zur Verwaltung eines Produktkatalogs mit ASP.NET Core 8 und Entity Framework Core.

2.1. Konfiguration der WebApplication

In der Datei Program.cs konfigurieren wir eine minimale API:

var builder = WebApplication.CreateBuilder(args);

// Dienste hinzufügenbuilder.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();

// Minimal API Endpunktapp.MapGet("/api/products", async (IMediator mediator) =>{    var products = await mediator.Send(new GetProductsQuery());    return Results.Ok(products);});

app.Run();

2.2. Datenmodell und CQRS

Wir erstellen die Entität 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;}

Wir verwenden das CQRS-Muster mit MediatR zur Trennung von Befehlen und Abfragen:

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

public class GetProductsHandler : IRequestHandler<GetProduc