Mikroservices in C#: Architektur und Praxis für .NET-Entwickler

Mikroservices auf C#: Von der Theorie zur Praxis mit .NET

Die Microservice-Architektur ist zum Standard für die Erstellung skalierbarer und ausfallsicherer Anwendungen geworden. Die Plattform .NET (C#) bietet alle notwendigen Werkzeuge zur Erstellung solcher Systeme: von der integrierten Containerisierungsunterstützung bis hin zu leistungsstarken Frameworks für die serviceübergreifende Kommunikation. In diesem Artikel analysieren wir die wichtigsten Prinzipien der Erstellung von Microservices auf C# und betrachten praktische Codebeispiele.

1. Grundlagen der Microservice-Architektur auf .NET

Microservices sind ein Ansatz, bei dem eine Anwendung in unabhängige, lose gekoppelte Dienste aufgeteilt wird. Jeder Dienst ist für seine eigene Geschäftsfunktion verantwortlich und kann unabhängig von anderen entwickelt, bereitgestellt und skaliert werden.

Wichtige Prinzipien für .NET-Entwickler:

• Single Responsibility — jeder Microservice löst eine Aufgabe.
• Datenunabhängigkeit — jeder Dienst hat seine eigene Datenbank (Database per Service).
• Loose Coupling — Dienste kommunizieren über APIs, nicht über gemeinsamen Speicher.
• Autonomie — ein Dienst kann geändert und neu bereitgestellt werden, ohne das gesamte System zu stoppen.

Verwenden Sie den folgenden Befehl, um ein neues Microservice-Projekt auf C# zu erstellen:

dotnet new webapi -n UserServicedotnet new webapi -n OrderServicedotnet new webapi -n NotificationService

Jedes Projekt erhält seine eigene Program.cs, Konfigurationen und Abhängigkeiten.

2. Serviceübergreifende Kommunikation: REST und gRPC

In .NET gibt es zwei Hauptansätze für die Kommunikation zwischen Microservices: synchron (REST/gRPC) und asynchron (über Message Broker). Betrachten wir beide.

REST API mit HttpClient

Der einfachste Weg ist die Verwendung von HttpClientFactory zur Erstellung eines typisierten Clients.

// In Program.cs des OrderServicebuilder.Services.AddHttpClient<IUserServiceClient, UserServiceClient>(client =>{    client.BaseAddress = new Uri("http://userservice:5000");});

// UserServiceClient.cspublic class UserServiceClient : IUserServiceClient{    private readonly HttpClient _httpClient;

    public UserServiceClient(HttpClient httpClient)    {        _httpClient = httpClient;    }

    public async Task<UserDto> GetUserAsync(int userId)    {        var response = await _httpClient.GetAsync($"/api/users/{userId}");        response.EnsureSuccessStatusCode();        return await response.Content.ReadFromJsonAsync<UserDto>();    }}

Empfehlung: Verwenden Sie Polly (Bibliothek für .NET) zur Implementierung von Wiederholungsrichtlinien und Circuit Breaker.

gRPC für leistungsstarke Szenarien

gRPC arbeitet über HTTP/2 und verwendet Protocol Buffers zur Serialisierung. Dies ist deutlich schneller als JSON.

// Dienstdefinition in user.protoservice UserGrpcService {  rpc GetUser (GetUserRequest) returns (UserResponse);}

// Servercode auf C#public class UserGrpcServiceImpl : UserGrpcService.UserGrpcServiceBase{    public override Task<UserResponse> GetUser(GetUserRequest request, ServerCallContext context)    {        var user = _dbContext.Users.Find(request.UserId);        return Task.FromResult(new UserResponse         {             Id = user.Id,             Name = user.Name,             Email = user.Email         });    }}

3. Datenverwaltung und Transaktionen

In Microservices gehört jede Datenbank nur einem einzigen Dienst. Dies schließt direkte SQL-Abfragen zwischen Diensten aus. Für die Datenarbeit in .NET ist Entity Framework Core der Standard.

Beispielkonfiguration von DbContext für einen Microservice

public cla