Das Saga-Muster in Microservices

Hallo Entwickler,

Microservices haben die Art und Weise revolutioniert, wie wir skalierbare und flexible Systeme aufbauen. Allerdings führen sie auch zu Komplexitäten, insbesondere bei der Verwaltung verteilter Transaktionen über mehrere Dienste hinweg. Hier kommt das Saga-Muster ins Spiel – ein leistungsstarkes Entwurfsmuster für die Handhabung lang laufender Transaktionen in Microservices. In diesem Beitrag werden wir untersuchen, was das Saga-Muster ist, wie es funktioniert, und es in Aktion mit einem Anwendungsfall für die Personalabteilung (HR) in C# sehen.

Was ist das Saga-Muster?

Das Saga-Muster unterteilt eine große, verteilte Transaktion in eine Reihe kleinerer Schritte, die jeweils von einem bestimmten Mikrodienst abgewickelt werden. Diese Schritte werden nacheinander ausgeführt, wobei für jeden Schritt ausgleichende Aktionen definiert sind, um einen Rollback durchzuführen, wenn etwas schief geht.

Es gibt zwei Hauptansätze zur Implementierung des Saga-Musters:

1. Choreografie: Jeder Dienst hört auf Ereignisse, reagiert auf sie und orchestriert sich selbst.
2. Orchestrierung: Ein zentraler Koordinierungsdienst verwaltet den Ablauf der Transaktion.

Warum das Saga-Muster verwenden?

Das Saga-Muster ist besonders nützlich für Microservices-Architekturen, bei denen:

• Transaktionen umfassen mehrere Dienste (z. B. Personalwesen, Gehaltsabrechnung, Personalbeschaffung).
• Skalierbarkeit und Entkopplung sind unerlässlich.
• Es ist wichtig, mit Teilausfällen elegant umzugehen.

HR-Anwendungsfall: Mitarbeiter-Onboarding

Stellen Sie sich ein Personalwesensystem vor, bei dem die Einarbeitung eines neuen Mitarbeiters mehrere Microservices umfasst:

1. Benutzerservice: Erstellt ein Mitarbeiterkonto.
2. Gehaltsabrechnungsdienst: Richtet Gehaltsabrechnungsdetails ein.
3. Benefits Service: Registriert den Mitarbeiter für Benefits.

Diese Dienste müssen zusammenarbeiten, um den Onboarding-Prozess abzuschließen. Wenn der Lohn- und Gehaltsabrechnungsdienst fehlschlägt, sollte das System die Kontoerstellung und die Leistungsregistrierung rückgängig machen.

Implementierung des Saga-Musters in C

Lassen Sie uns das Saga-Muster mit Orchestrierung für den Mitarbeiter-Onboarding-Prozess implementieren.

Schritt 1: Definieren Sie den Saga-Koordinator

Der Saga-Koordinator verwaltet den Ablauf der Transaktion. Hier ist eine grundlegende Implementierung in C#:

public class SagaCoordinator
{
    private readonly IUserService _userService;
    private readonly IPayrollService _payrollService;
    private readonly IBenefitsService _benefitsService;

    public SagaCoordinator(IUserService userService, IPayrollService payrollService, IBenefitsService benefitsService)
    {
        _userService = userService;
        _payrollService = payrollService;
        _benefitsService = benefitsService;
    }

    public async Task ExecuteOnboardingSagaAsync(Employee employee)
    {
        try
        {
            Console.WriteLine("Starting onboarding saga...");

            // Step 1: Create user account
            await _userService.CreateUserAsync(employee);

            // Step 2: Set up payroll
            await _payrollService.SetupPayrollAsync(employee);

            // Step 3: Register benefits
            await _benefitsService.RegisterBenefitsAsync(employee);

            Console.WriteLine("Onboarding completed successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error during onboarding: {ex.Message}");
            await CompensateAsync(employee);
        }
    }

    private async Task CompensateAsync(Employee employee)
    {
        Console.WriteLine("Compensating...");
        await _benefitsService.RollbackBenefitsAsync(employee);
        await _payrollService.RollbackPayrollAsync(employee);
        await _userService.DeleteUserAsync(employee);
        Console.WriteLine("Compensation complete.");
    }
}

Schritt 2: Definieren Sie die Dienste

Jeder Dienst implementiert seine spezifische Logik und Kompensationsaktionen.

public interface IUserService
{
    Task CreateUserAsync(Employee employee);
    Task DeleteUserAsync(Employee employee);
}

public interface IPayrollService
{
    Task SetupPayrollAsync(Employee employee);
    Task RollbackPayrollAsync(Employee employee);
}

public interface IBenefitsService
{
    Task RegisterBenefitsAsync(Employee employee);
    Task RollbackBenefitsAsync(Employee employee);
}

Implementierungen dieser Schnittstellen würden mit Datenbanken oder anderen APIs interagieren.

Schritt 3: Führen Sie die Saga aus

So können Sie den Saga Coordinator verwenden:

public class SagaCoordinator
{
    private readonly IUserService _userService;
    private readonly IPayrollService _payrollService;
    private readonly IBenefitsService _benefitsService;

    public SagaCoordinator(IUserService userService, IPayrollService payrollService, IBenefitsService benefitsService)
    {
        _userService = userService;
        _payrollService = payrollService;
        _benefitsService = benefitsService;
    }

    public async Task ExecuteOnboardingSagaAsync(Employee employee)
    {
        try
        {
            Console.WriteLine("Starting onboarding saga...");

            // Step 1: Create user account
            await _userService.CreateUserAsync(employee);

            // Step 2: Set up payroll
            await _payrollService.SetupPayrollAsync(employee);

            // Step 3: Register benefits
            await _benefitsService.RegisterBenefitsAsync(employee);

            Console.WriteLine("Onboarding completed successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error during onboarding: {ex.Message}");
            await CompensateAsync(employee);
        }
    }

    private async Task CompensateAsync(Employee employee)
    {
        Console.WriteLine("Compensating...");
        await _benefitsService.RollbackBenefitsAsync(employee);
        await _payrollService.RollbackPayrollAsync(employee);
        await _userService.DeleteUserAsync(employee);
        Console.WriteLine("Compensation complete.");
    }
}

Vorteile des Saga-Musters

1. Resilienz: Ermöglicht die Wiederherstellung nach Ausfällen in lang laufenden Prozessen.
2. Skalierbarkeit: Entkoppelt Dienste bei gleichzeitiger Wahrung der Transaktionsintegrität.
3. Flexibilität: Unterstützt verschiedene Arbeitsabläufe durch maßgeschneiderte Vergütungslogik.

Letzte Gedanken

Das Saga-Muster ist ein wichtiges Entwurfsmuster für die Aufrechterhaltung der Datenkonsistenz in verteilten Systemen wie Microservices. In unserem HR-Beispiel wurde sichergestellt, dass der gesamte Onboarding-Prozess entweder erfolgreich abgeschlossen oder ordnungsgemäß zurückgesetzt wurde, wodurch die Systemintegrität gewahrt blieb.

Durch die Nutzung von Mustern wie Saga können wir robuste Systeme entwerfen, die die Komplexität verteilter Transaktionen bewältigen.

Codieren Sie weiter

Das obige ist der detaillierte Inhalt vonDas Saga-Muster in Microservices. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!