Le modèle Saga dans les microservices

Salut les développeurs,

Les microservices ont révolutionné la façon dont nous construisons des systèmes évolutifs et flexibles. Cependant, ils introduisent également des complexités, en particulier lors de la gestion de transactions distribuées entre services. C'est là qu'intervient le Saga Pattern : un modèle de conception puissant pour gérer les transactions de longue durée dans les microservices. Dans cet article, nous explorerons ce qu'est le modèle Saga, comment il fonctionne et le verrons en action avec un cas d'utilisation des ressources humaines (RH) en C#.

Qu'est-ce que le modèle de saga ?

Le modèle Saga divise une transaction importante et distribuée en une série d'étapes plus petites, chacune gérée par un microservice spécifique. Ces étapes sont exécutées en séquence, avec des actions compensatoires définies pour chaque étape pour revenir en arrière en cas de problème.

Il existe deux approches principales pour mettre en œuvre le modèle Saga :

1. Chorégraphie : Chaque service écoute et réagit aux événements, s'orchestré.
2. Orchestration : Un service de coordinateur central gère le flux de la transaction.

Pourquoi utiliser le modèle Saga ?

Le Saga Pattern est particulièrement utile pour les architectures de microservices où :

• Les transactions couvrent plusieurs services (par exemple, RH, paie, recrutement).
• L'évolutivité et le découplage sont essentiels.
• Il est crucial de gérer les échecs partiels avec élégance.

Cas d'utilisation RH : intégration des employés

Imaginez un système de ressources humaines (RH) où l'intégration d'un nouvel employé implique plusieurs microservices :

1. Service utilisateur : Crée un compte employé.
2. Service de paie : configure les détails de la paie.
3. Service d'avantages sociaux : enregistre l'employé aux avantages sociaux.

Ces services doivent travailler ensemble pour mener à bien le processus d'intégration. Si le service de paie échoue, le système doit annuler la création du compte et l'enregistrement des avantages.

Implémentation du modèle Saga en C

Implémentons le modèle Saga avec orchestration pour le processus d'intégration des employés.

Étape 1 : Définir le coordinateur de la saga

Le Coordinateur Saga gère le flux de la transaction. Voici une implémentation de base en 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.");
    }
}

Étape 2 : Définir les services

Chaque service met en œuvre sa logique spécifique et ses actions compensatoires.

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);
}

Les implémentations de ces interfaces interagiraient avec des bases de données ou d'autres API.

Étape 3 : Exécuter la saga

Voici comment utiliser le coordinateur de saga :

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.");
    }
}

Avantages du modèle Saga

1. Résilience : permet la récupération après des échecs dans des processus de longue durée.
2. Évolutivité : découple les services tout en maintenant l'intégrité transactionnelle.
3. Flexibilité : prend en charge divers flux de travail en adaptant la logique de rémunération.

Pensées finales

Le modèle Saga est un modèle de conception essentiel pour maintenir la cohérence des données dans les systèmes distribués tels que les microservices. Dans notre exemple RH, cela garantissait que l'ensemble du processus d'intégration était terminé avec succès ou annulé en douceur, préservant ainsi l'intégrité du système.

En tirant parti de modèles comme Saga, nous pouvons concevoir des systèmes robustes qui gèrent la complexité des transactions distribuées.

Continuez à coder

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!