Read Model vs Write Model : quelle différence en CQRS ?
En CQRS, le Read Model prépare les données à afficher ; le Write Model décide des changements et protège les règles, même face aux demandes concurrentes.
Article
Une liste de commandes, une recherche et un tableau de bord ont des besoins différents. Le read model prépare ces vues et permet de gérer leur mise à jour.
Alice ouvre « Mes commandes » : sa commande C42 y apparaît « en préparation », alors qu’elle a été expédiée hier. L’expédition est bien enregistrée ; c’est le programme qui calcule cette liste qui a mal traduit le changement. Le corriger ne suffit pas, car les lignes qu’il a déjà écrites restent fausses. Comment refaire la liste sans la couper pour les clients qui la consultent, et sans perdre les commandes qui changent pendant ce temps ?
La réparation consiste à construire une seconde version de la liste à côté de celle qui sert encore, à partir d’une copie de l’état des commandes et des changements survenus depuis cette copie, puis à la contrôler et à y faire passer les lecteurs, en gardant l’ancienne pour revenir en arrière. Elle n’est possible que si la vue a été préparée pour cela : chacune de ses valeurs doit pouvoir être recalculée à partir des données qui font référence.
CQRS, pour Command Query Responsibility Segregation, sépare deux responsabilités dans une application. Le modèle d’écriture reçoit les demandes de changement, comme « expédier C42 », et les accepte ou les refuse selon les règles du métier ; ses données font référence. Le modèle de lecture, ou read model, prépare ce que les écrans affichent, sans décider de l’expédition ni des autres changements métier. Ces données d’affichage peuvent être stockées à part, dans une table ou un index organisé pour un écran. Le traitement qui tient cette copie à jour s’appelle une projection, et le mot désigne souvent aussi la copie obtenue, appelée ici « vue ».
Une application en prépare souvent plusieurs, parce que chaque écran pose une question différente : la liste des commandes d’un client, une recherche par produit, un tableau de bord des montants. Martin Fowler décrit ce principe pour les bases dédiées au reporting : une copie des données utiles, organisée autour des besoins de consultation, où dupliquer une information est permis parce que personne n’y modifie les données. Il en donne aussi la contrepartie : cette copie doit être tenue à jour.
Dans cet exemple fictif, la liste est tenue à jour par un consommateur : un programme qui lit, dans l’ordre, le flux des changements acceptés par le modèle d’écriture, et met à jour la ligne concernée pour chacun. Chaque changement porte une position, P100, P101, P102, qui le situe dans ce flux. Le consommateur enregistre la position du dernier changement traité, pour reprendre au bon endroit après un arrêt. Cette mise à jour suit la décision, si bien que la liste peut avoir un léger retard ; la réponse à donner pendant ce retard est une autre question que la réparation traitée ici.
La liste contient une ligne par commande : l’identifiant, l’identifiant du client propriétaire (U7 pour Alice), le montant total en centimes, le statut, et la version de la commande dont la ligne est tirée. Dans cet exemple, le modèle d’écriture numérote les versions de chaque commande, et chaque changement accepté fait avancer ce numéro. Voici C42 telle que le modèle d’écriture la conserve, et la ligne que la liste corrigée, nommée commandes_v2, doit contenir pour elle :
Source C42, version 8 :
client_id=U7, total_centimes=12000, statut=expediee
Projection commandes_v2 :
C42 | U7 | 12000 | expediee | source_version=8
Chaque valeur de cette ligne se calcule à partir de la commande enregistrée. C’est la condition qui rend la vue réparable. Si un employé pouvait saisir un commentaire directement dans la liste, ce commentaire n’existerait nulle part ailleurs, et refaire la liste le ferait disparaître. Une donnée originale de ce genre doit passer par le modèle d’écriture et y être conservée, comme les autres.
L’identifiant U7 est recopié dans la ligne pour que la liste puisse retrouver les commandes d’Alice sans consulter une autre table. La clé est un identifiant, pas un nom, car un nom peut être partagé ou changer. Cette copie sert à filtrer, pas à autoriser : chaque lecture de la liste vérifie encore que la personne qui la demande a le droit de voir les commandes renvoyées.
La question que la vue sert compte autant que ses colonnes. Pour afficher l’état actuel des commandes, une copie cohérente de l’état actuel suffit à repartir de zéro. Un graphique du « montant engagé à chaque fin de journée » demanderait en revanche des faits passés que l’état actuel a pu perdre : une commande annulée depuis peut ne plus dire qu’elle comptait la veille. Avant de déclarer une vue jetable, vérifiez donc toutes les questions qu’elle sert réellement, et la source qui permet de répondre à chacune.
Revenons au défaut. Le consommateur a traité l’expédition de C42 avec un calcul erroné, écrit « en préparation », puis enregistré la position de ce changement comme traitée. Une fois le programme corrigé et relancé, il reprend après cette position : il traitera bien les prochaines expéditions, mais il ne revient ni sur C42 ni sur les autres lignes déjà calculées. Le faire repartir du début du flux ne corrigerait tout que si ce flux avait conservé chaque changement depuis la création de la première commande.
Vider la liste pour la recalculer en place aurait un autre défaut : pendant le calcul, Alice et les autres clients verraient une liste vide ou partielle. La nouvelle version se construit donc à côté. La vue actuelle, commandes_v1, continue de servir les lectures avec son défaut connu, pendant que le programme corrigé calcule commandes_v2 à partir de la source. Le chapitre CQRS de Cosmic Python part de la même situation, une vue restée fausse après un défaut ou une panne, et la répare avec un outil qui interroge l’état actuel du côté écriture. Il reste à alimenter v2 sans perdre les commandes qui changent pendant ce calcul.
La reconstruction part d’un instantané : une copie de l’état de toutes les commandes à un instant donné. Les commandes continuent pourtant de changer pendant que v2 se remplit, et ces changements doivent l’atteindre aussi. Il faut donc savoir exactement où l’instantané s’arrête dans le flux. L’exemple suppose que la source fournit un instantané S et une position P100 associés : S contient les changements jusqu’à P100, et le flux conserve ceux qui suivent. La coupure est alors sans trou : chaque changement se trouve soit dans S, soit dans la partie du flux qui suit P100.
Lire la position P100, puis exporter les tables pendant plusieurs minutes, ne garantit pas cette propriété : si l’export ne lit pas toutes les tables au même instant, il mélange des états antérieurs et postérieurs à P100. Le mécanisme d’export ou de capture utilisé doit l’offrir explicitement, comme le fait PostgreSQL : quand un consommateur s’abonne aux changements de la base en créant, par l’interface de réplication en flux, un emplacement de réplication logique (replication slot), la base peut exporter un instantané qui montre exactement l’état après lequel tous les changements figureront dans le flux. Une copie lue avec cet instantané peut ensuite être mise à jour à partir de l’emplacement sans perdre de changement, selon la documentation de PostgreSQL sur le décodage logique.
Pendant toute l’opération, commandes_v1 reste active. Le reconstructeur, c’est-à-dire le programme qui calcule v2, charge S pendant que de nouveaux changements, de P101 à P106, arrivent et sont conservés dans le flux. Il reprend ensuite le flux strictement après P100 et applique ces changements à v2. Le tableau suit l’opération jusqu’à la bascule, décrite plus loin.
| Étape | Vue servie | Travail sur v2 |
|---|---|---|
| Instantané à P100 | v1 | Charger S, marquer la coupure P100 |
| Source arrivée à P106 | v1 | Appliquer P101 à P106 |
| Contrôles à P106 | v1 | Comparer un état source au même point et vérifier les accès |
| Bascule | v2 | Continuer la consommation au-delà de P106 |
Le flux doit conserver les changements pendant toute la construction. Un flux peut ne garder ses changements qu’un temps limité, sa durée de rétention. Si le chargement de S dure plus longtemps, P101 a pu disparaître avant d’être lu, et v2 est incomplète. Vous recommencez alors depuis une nouvelle coupure, ou vous employez une autre procédure dont l’absence de trou est prouvée. Avancer malgré le trou, puis afficher un indicateur « à jour », masquerait une perte.
Pendant le rattrapage, le reconstructeur peut s’arrêter à tout moment, et un même changement peut lui parvenir deux fois. PostgreSQL le dit de ses emplacements de réplication : après un arrêt brutal, des changements récents peuvent être renvoyés, et c’est au client d’éviter les effets d’un message traité plus d’une fois. Ici, chaque changement porte l’état complet de la commande et sa version. Le calcul remplace une ligne seulement si la version reçue est plus récente que celle que la ligne indique déjà. Recevoir deux fois la version 8 de C42 laisse donc la ligne inchangée la seconde fois. Le changement n’est pas exécuté une seule fois, mais sa réapplication est sans effet : l’opération est idempotente, elle produit le même résultat qu’elle soit appliquée une fois ou plusieurs.
Le point de reprise est enregistré avec les lignes qu’il couvre, dans une même transaction de la projection. Si le reconstructeur tombe avant la validation, ni la ligne ni la position ne sont enregistrées, et le changement sera repris. S’il tombe après, la position enregistrée dit exactement ce qui est fait, parce que le reconstructeur traite les changements dans l’ordre : sa position couvre tous ceux qui la précèdent. Avec deux transactions séparées, la position pourrait avancer sans que la ligne soit écrite, et le changement serait perdu.
Les suppressions demandent un soin particulier. Supposons que C42 soit supprimée en version 9, puis que son état complet en version 8 arrive en retard. Si la suppression avait simplement effacé la ligne, rien n’indiquerait plus que la version 9 a existé, et la version 8 recréerait la commande. La suppression laisse donc une marque qui garde sa version, ou un suivi équivalent.
Ces règles valent pour des changements qui portent un état complet. Pour des événements différentiels, comme « ajouter deux articles », la version permet encore d’écarter un doublon, mais la règle « accepter toute version plus récente » ne suffit plus : appliquer la version 10 sans la version 9 laisserait un trou. Chaque étape doit alors être appliquée, dans l’ordre et sans doublon, ce qui demande un autre calcul.
Le reconstructeur calcule v2 et rien d’autre : il n’envoie aucun courriel et ne lance aucun paiement. Comme le montre la figure plus haut, d’autres traitements réagissent aussi aux changements, par exemple pour envoyer la confirmation d’expédition. Si ces réactions étaient branchées sur le rejeu de l’historique, chaque client recevrait de nouveau toutes ses confirmations. Les effets externes ont leur propre suivi, distinct de celui de la vue.
À P106, v2 a rattrapé la source. Avant d’y envoyer les lecteurs, comparez-la à un état de la source correspondant au même point : le nombre de lignes, les sommes par statut, les suppressions et un échantillon de commandes, dont C42, qui doit maintenant apparaître « expédiée ». La comparaison doit tenir compte des versions, car comparer v2 à une source qui a continué d’évoluer produirait de faux écarts. Des totaux identiques ne prouvent pas non plus que chaque ligne soit juste : deux erreurs de sens contraire peuvent se compenser, et l’échantillon peut en repérer.
Le contrôle porte aussi sur ce que voit chaque client. Alice ne doit pas voir les commandes de Bruno ; une commande expédiée apparaît sous le bon statut ; les filtres et la pagination donnent les résultats attendus. Le contrôle mesure enfin si v2 absorbe les lectures et les changements à la charge prévue. Une vue juste mais incapable de suivre le rythme du flux prendrait du retard dès la bascule ; elle ne peut pas devenir la vue active.
Les lectures passent de v1 à v2 par le changement d’une seule référence, fait de manière atomique : une requête lit v1 ou v2, jamais un mélange des deux. Les requêtes déjà commencées et les caches doivent avoir un comportement défini, sans quoi un cache continuerait de servir des réponses tirées de v1. Dans le contrat de l’exemple, chaque requête garde la même version de vue pendant toute son exécution, et les nouvelles requêtes passent sur v2. Une pagination longue demande une règle de plus : un client qui parcourt une liste commencée sur v1 ne doit pas recevoir la page suivante depuis v2, dont les lignes peuvent être ordonnées autrement. Son curseur indique donc la version de la vue, ou expire explicitement à la bascule.
L’ancienne vue, v1, et son alimentation restent en service pendant une période d’observation bornée. Si un défaut nouveau apparaît dans v2, la référence peut revenir vers v1, en sachant que l’ancien défaut d’affichage y existe encore. Ce retour évite un incident plus grave, mais il ne répare rien. Il suppose que v1 ait continué de recevoir les changements : arrêter son alimentation dès la bascule rendrait le retour plus complexe, vers une vue périmée.
Après cette période, v1, son consommateur et ses caches sont retirés. La procédure consigne la version du calcul, la coupure P100, la position atteinte et les résultats des contrôles, si bien que la prochaine reconstruction pourra comparer ses résultats aux mêmes preuves.
Après la bascule, Alice voit C42 « expédiée », la liste n’a jamais été coupée, et les commandes modifiées pendant la reconstruction y figurent aussi. Ce résultat tient à des choix faits avant le défaut. Chaque valeur de la vue se recalcule à partir de la source, pour toutes les questions que la vue sert. La source fournit un instantané relié à une position du flux, et le flux garde les changements assez longtemps pour le rattrapage. Un changement reçu deux fois ou un état plus ancien ne dégrade pas la vue, grâce à la version de chaque commande, et le point de reprise est enregistré dans la même transaction que la ligne. Ne créez pas de vue de lecture stockée sans savoir la refaire de cette façon : une copie supplémentaire des données demande un moyen de la reconstruire.
Explorer
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.
En CQRS, le Read Model prépare les données à afficher ; le Write Model décide des changements et protège les règles, même face aux demandes concurrentes.
Deux clients achètent le dernier billet : comment éviter la double vente et envoyer la confirmation ? Transaction, concurrence et outbox expliquées pas à pas.
Réserver un vol puis un hôtel peut échouer à mi-parcours. Une saga organise les étapes, leur reprise et les compensations pour terminer le traitement.
Laisser un commentaire
Votre commentaire sera relu avant d'être publié.