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#.
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 :
Le Saga Pattern est particulièrement utile pour les architectures de microservices où :
Imaginez un système de ressources humaines (RH) où l'intégration d'un nouvel employé implique plusieurs microservices :
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émentons le modèle Saga avec orchestration pour le processus d'intégration des employés.
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."); } }
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.
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."); } }
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!