Article

CQRS : protéger une décision avec une transaction et une outbox

Deux clients achètent le dernier billet : comment éviter la double vente et envoyer la confirmation ? Transaction, concurrence et outbox expliquées pas à pas.

Deux clients essaient d’acheter le dernier billet d’un spectacle. Le système doit accepter une seule des deux ventes, puis envoyer la confirmation par courriel sans la perdre si un serveur tombe. Une transaction de base de données, avec une mise à jour qui vérifie le stock en le diminuant, empêche la double vente. Une boîte d’envoi, ou outbox, enregistre l’intention d’envoyer le courriel dans la même transaction que la vente ; un processus séparé l’envoie ensuite, et reprend l’envoi après une panne.

L’article suit la vente d’Alice et la tentative de Bilal, du clic jusqu’au courriel. D’abord la règle à garantir, que deux achats simultanés peuvent contourner, et l’instruction SQL qui les départage. Ensuite le courriel, qui ne peut pas entrer dans la transaction, et la boîte d’envoi qui le remplace. Pour finir, ce que cette transaction locale ne couvre pas.

La règle que le modèle de commande doit garantir

CQRS sépare deux responsabilités. Le modèle de lecture prépare ce que les écrans affichent, par exemple « 1 billet restant ». Le modèle de commande, aussi appelé modèle d’écriture, reçoit les demandes de changement, comme « vendre un billet à Alice », et décide de les accepter ou de les refuser selon les règles du métier. Ses données font foi, et le modèle de lecture en dérive. Cet article porte sur ce second modèle, et sur la façon dont il garantit sa décision.

Ici, la règle est simple : ne pas vendre plus de billets qu’il n’en reste. Une règle de ce genre, qui doit rester vraie après chaque vente, est un invariant. Les écrans d’Alice et de Bilal affichent tous deux « 1 billet restant », et cet affichage peut être exact au moment de la lecture. Il ne réserve rien pour autant : le modèle de commande doit garantir qu’une seule des deux ventes aboutit.

Lire le stock, puis vendre, laisse passer deux ventes

Le traitement le plus naturel lit le stock, constate qu’il reste un billet, puis enregistre la vente. Alice et Bilal valident leur achat au même moment. Leurs deux traitements lisent « 1 restant » avant que l’un d’eux ait écrit ; chacun conclut qu’il peut vendre et enregistre sa vente. Le dernier billet est vendu deux fois.

Ouvrir une transaction autour de ces deux étapes ne suffit pas toujours à l’empêcher. Une transaction garantit que ses écritures sont validées ensemble ou annulées ensemble. Ce qu’elle voit des autres transactions en cours dépend en revanche de son niveau d’isolation, un réglage de la base. PostgreSQL utilise par défaut le niveau READ COMMITTED, où une lecture ordinaire voit, des autres transactions, les données validées avant son début (documentation PostgreSQL 18, §13.2.1). Les deux transactions lisent donc « 1 restant », et ce niveau ne les oblige pas à relire le stock avant d’écrire. Des niveaux plus stricts peuvent refuser l’une des deux transactions, mais l’application doit alors être prête à la recommencer depuis le début (même documentation, §13.2.2).

La vérification et la modification doivent donc être coordonnées, pour qu’aucune vente concurrente ne puisse invalider la vérification. Le moyen le plus direct consiste à les écrire dans la même instruction.

Vérifier et diminuer le stock dans la même instruction

Prenons une réalisation illustrative sous PostgreSQL, au niveau par défaut READ COMMITTED. Une ligne de la table stocks porte le nombre de billets restants du spectacle S1 : il en reste 1. La vente d’Alice reçoit l’identifiant V42. Le code représente le déroulement applicatif autour du SQL ; les contrôles d’identité et de demande répétée sont supposés effectués selon leur contrat.

BEGIN;
UPDATE stocks
   SET restant = restant - 1
 WHERE spectacle_id = 'S1' AND restant > 0
 RETURNING restant;

-- Si aucune ligne n’est retournée : ROLLBACK et refus.
-- Sinon, dans la même transaction :
INSERT INTO ventes(id, spectacle_id, client_id)
VALUES ('V42', 'S1', 'alice');
COMMIT;

La condition restant > 0 place la vérification dans l’instruction qui modifie le stock. Alice exécute l’UPDATE la première : la ligne passe à 0 et reste verrouillée jusqu’à la fin de sa transaction. Bilal lance le même UPDATE et attend. Si Alice valide, PostgreSQL réévalue la condition de Bilal sur la version modifiée de la ligne : 0 > 0 est faux, l’instruction de Bilal ne modifie aucune ligne, et l’application refuse sa vente. Si Alice annule sa transaction, le stock reste à 1 et Bilal peut acheter. Ce comportement de réévaluation est décrit dans la documentation PostgreSQL 18 sur READ COMMITTED.

Préférez cette instruction unique à une lecture suivie d’une écriture : la vérification ne peut plus être oubliée ni séparée de la modification, et la base départage elle-même les demandes simultanées. La vente d’Alice est enregistrée dans la même transaction que la baisse du stock. Si l’insertion échoue, le ROLLBACK rend le billet ; si elle réussit, le COMMIT valide les deux écritures ensemble. Une contrainte CHECK (restant >= 0) sur la table protège en plus le stockage contre une valeur négative, quel que soit le code qui l’écrit, sans remplacer les autres règles de vente.

Ce raisonnement vaut pour des accès concurrents à une même ligne et pour le comportement documenté de PostgreSQL à ce niveau d’isolation. Avec une autre base ou un autre niveau, un verrou posé avant la lecture ou un contrôle de version peuvent jouer le même rôle, à condition de vérifier leurs garanties. Une règle répartie sur plusieurs lignes ou plusieurs systèmes demande davantage ; la section sur ce que la transaction locale ne couvre pas y revient.

Le courriel ne peut pas entrer dans la transaction

Alice doit maintenant recevoir sa confirmation. Supposons que le traitement envoie le courriel, puis que l’enregistrement de la vente échoue : Alice reçoit la confirmation d’une vente absente de la base. Dans l’ordre inverse, la vente est validée, puis le processus tombe avant l’envoi : la vente existe et personne ne prévient Alice.

Le service de messagerie ne participe généralement pas à la transaction locale : celle-ci ne couvre que les écritures de sa propre base. Chris Richardson pose le problème dans ces termes : le service doit mettre à jour sa base et envoyer un message, sans pouvoir recourir à une transaction distribuée. Appeler la messagerie entre deux écritures ne rend donc pas l’ensemble atomique, c’est-à-dire entièrement validé ou entièrement annulé.

Faites-en une règle sans exception : pendant son exécution, la commande n’appelle aucun système extérieur, qu’il s’agisse d’envoyer un courriel, d’interroger un autre service ou de publier sur un bus de messages. Sa transaction reste courte, et sa réussite ne dépend que des données qu’elle maîtrise. Tout échange avec l’extérieur vient après la validation ; il reste à l’organiser sans perdre la décision de le faire.

Enregistrer la vente et l’intention d’envoyer ensemble

Le pattern outbox, ou boîte d’envoi transactionnelle, ajoute une table à la base des ventes. La transaction y note le message à transmettre en même temps qu’elle enregistre la vente. Pour Alice, le SQL précédent reçoit une instruction de plus :

BEGIN;
UPDATE stocks
   SET restant = restant - 1
 WHERE spectacle_id = 'S1' AND restant > 0
 RETURNING restant;

-- Si aucune ligne n’est retournée : ROLLBACK et refus.
-- Sinon, dans la même transaction :
INSERT INTO ventes(id, spectacle_id, client_id)
VALUES ('V42', 'S1', 'alice');
INSERT INTO outbox(id, type, vente_id)
VALUES ('E42', 'VenteEnregistree', 'V42');
COMMIT;

L’entrée E42 signifie « la vente V42 doit être confirmée ». Comme elle est validée avec la vente, les deux existent ensemble ou aucune n’existe : si la transaction échoue, ni la vente ni son message ne sont conservés. Un processus de fond, appelé worker ou relais, lit ensuite la boîte d’envoi et transmet chaque entrée, ici au service qui envoie les courriels. S’il tombe, l’intention reste enregistrée, et il la reprend avec le même identifiant à son redémarrage. Pendant ce temps, Alice voit « vente V42 enregistrée, confirmation en attente », puis l’état réel de sa confirmation.

Une transaction locale valide ensemble le stock S1 à zéro, la vente V42 et l’entrée E42. Après COMMIT, le relais transmet E42 au service de courriel ; l’envoi peut se répéter, sa déduplication dépend du contrat du service.
Le pattern outbox : dans une seule transaction, la commande enregistre l'état et l'intention de publier. Après la validation, un worker relève la boîte d'envoi et appelle l'extérieur.

Le relais peut consulter périodiquement la table ou suivre le journal de transactions de la base ; Richardson décrit ces deux façons de faire. Ce choix technique ne change pas la propriété recherchée : la vente et l’intention de la faire connaître sont conservées durablement, ensemble.

Après une panne, la confirmation peut partir deux fois

Une panne peut aussi survenir après l’envoi, mais avant que le relais ait noté sa réussite. À la reprise, E42 paraît encore en attente, et le relais la transmet de nouveau. Richardson le signale : le relais peut publier un message plus d’une fois.

Le destinataire doit donc reconnaître les répétitions : c’est le rôle de l’idempotence, qui permet de répéter une même demande sans multiplier son effet. Dans cet exemple, le service d’envoi accepte E42 comme clé d’idempotence et garantit, dans les limites de son contrat, qu’une reprise avec cette clé ne déclenche pas un nouvel envoi. Cette propriété se vérifie chez lui ; l’outbox ne la crée pas. Si le service ne l’offre pas, un doublon reste possible. Une table des messages déjà traités, comme celle que décrit Chris Richardson, protège les écritures faites dans la même transaction de base, mais elle ne rend pas atomique l’envoi d’un courriel.

L’outbox ne garantit pas non plus que le destinataire sera disponible ou acceptera le message. Il faut suivre les entrées en attente, réessayer les erreurs temporaires en espaçant les tentatives, et traiter les échecs persistants. Sans ce suivi, une confirmation pourrait rester dans la boîte d’envoi sans jamais atteindre Alice.

Ce que la transaction locale ne couvre pas

Tout ce qui précède suppose une condition : la règle porte sur des données que la même transaction peut lire et modifier. Le stock de S1, la vente V42 et l’entrée E42 sont dans la même base. Le domain-driven design appelle agrégat un groupe d’objets que l’application charge, modifie et enregistre comme une unité, parce que leurs règles doivent être protégées ensemble. Pour la billetterie, il pourrait réunir le stock d’une représentation et les informations nécessaires à l’attribution d’un billet. Le résumé de Martin Fowler, d’après Eric Evans, pose qu’une transaction ne doit pas franchir les frontières d’un agrégat.

La frontière doit être assez large pour vérifier la règle, sans réunir inutilement tout le système. Un agrégat trop large augmente les conflits entre des opérations qui auraient pu rester indépendantes : si les stocks de toutes les représentations tenaient dans une seule ligne, chaque achat attendrait les autres. Cette recommandation de conception ne justifie pas pour autant de supprimer une vérification indispensable parce qu’elle sort de la frontière choisie.

Certaines règles dépendent en effet d’un autre système, par exemple un compte client géré ailleurs, qui doit être actif. Pour la même raison que le courriel, la commande ne l’interroge pas pendant son exécution : sa transaction ne couvre pas l’autre système. Elle décide avec les données qu’elle possède, par exemple l’état du compte vérifié avant l’envoi de la commande, ou recopié localement à partir des changements que l’autre système publie. Cette information ne verrouille rien de l’autre côté. Le compte peut être suspendu juste après la vérification, et une copie locale peut le montrer actif bien plus longtemps : rien ne borne son retard sans un mécanisme prévu pour cela. Relire cette copie dans la transaction ne garantit donc pas que le droit distant est encore valable.

La réponse dépend alors du métier, et deux voies se distinguent. Dans la première, le métier tolère qu’une vente soit acceptée après la suspension réelle du compte, sur la foi d’une vérification antérieure, puis corrigée. Une saga, suite de transactions locales coordonnées, peut déclencher cette correction sous forme de compensation : une action métier qui corrige une étape déjà faite, comme un avoir ou une annulation. Chris Richardson rappelle qu’une saga n’offre ni retour en arrière automatique ni isolation : d’autres traitements voient la vente avant sa correction. Dans la seconde voie, la règle doit être strictement garantie : la vente reste provisoire jusqu’à ce qu’un protocole établisse le droit requis, par exemple une réservation temporaire confirmée par le système du compte, avec une règle explicite pour une suspension survenue pendant l’attente ; ou la frontière est redessinée pour réunir les deux données dans le même agrégat. Une saga peut orchestrer ce protocole, mais elle ne fournit pas cette garantie à elle seule. Les autorisations suivent la même logique : un droit stable se vérifie avant la commande ; un droit qui peut changer pendant l’opération doit appartenir aux données que la transaction protège elle-même, une copie relue ne suffit pas.

Ce qui reste après chaque panne

Le parcours d’Alice et de Bilal peut maintenant se relire panne par panne.

MomentCe que la base contientCe qui se passe ensuite
Alice et Bilal achètent en même tempsUne seule vente, V42, et un stock à 0Bilal reçoit un refus
Arrêt avant le COMMITNi vente ni intention ; le stock reste à 1Alice ne reçoit pas de confirmation de vente ; le billet reste en vente
Arrêt après le COMMIT, avant l’envoiLa vente V42 et l’entrée E42Le relais reprend E42 et fait envoyer le courriel
Arrêt après l’envoi, avant que le relais note sa réussiteLa vente V42 et l’entrée E42, toujours en attenteE42 repart ; le service de courriel reconnaît sa clé et n’envoie pas de second courriel, si son contrat le garantit

Dans aucun de ces cas le billet n’est vendu deux fois, et l’intention de confirmation n’est jamais perdue. La mise à jour conditionnelle a départagé Alice et Bilal, et la boîte d’envoi a gardé l’intention de confirmation ; la clé d’idempotence acceptée par le service de courriel évite le second envoi dans le seul cas où cette intention repart. Ces quatre situations sont aussi les quatre essais à mener, chacun séparément, sur une implémentation réelle : le SQL montré protège le stock, sans remplacer un test de bout en bout.

Sources

Explorer

Sur le même sujet

Choisis dans l’index d’après les étiquettes de cet article — les plus proches d’abord, hors de sa série. Rien n’est écrit à la main : un article publié demain avec les mêmes étiquettes y prendra place.

Laisser un commentaire

Elle n'est jamais affichée ni publiée. Elle sert à regrouper vos commentaires et, si vous vous inscrivez un jour avec elle, à vous les rendre.

Votre commentaire sera relu avant d'être publié.