Article

CQRS : comprendre et gérer le retard des vues de lecture

Une commande validée peut manquer quelques instants dans une liste, même dans un monolithe. Voici d’où vient ce délai et comment le rendre compréhensible.

Alice valide la commande C42 dans votre application. Le service confirme l’enregistrement, puis la liste « Mes commandes », qu’elle ouvre aussitôt, affiche « aucune commande ». Si elle en conclut que l’achat a échoué et recommence, elle crée une seconde commande et, selon le parcours d’achat, peut payer deux fois. La commande existe pourtant : seule la liste, une copie des données préparée pour l’affichage et mise à jour après la décision, n’a pas encore reçu le changement. Ce délai existe même dans un monolithe, une application déployée d’un seul tenant, dès que la liste est mise à jour dans une étape séparée.

Quand ce délai ne peut pas être évité, il peut être rendu compréhensible. La création renvoie une preuve de ce qu’elle a enregistré ; la lecture qui suit attend que la liste ait atteint ce point, pendant un temps borné ; si l’attente ne suffit pas, la réponse le dit au lieu de présenter comme actuelle une liste incomplète. Après l’origine du retard, la lecture de C42 montre chacun de ces gestes : la preuve renvoyée par la création, l’attente de 300 millisecondes, et ce que l’application répond quand cette attente échoue.

Le retard vient de la mise à jour de la vue après la décision

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 « créer 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. Ces données d’affichage peuvent être stockées à part, dans une copie organisée pour un écran : ici, la liste « Mes commandes ». Le traitement qui tient cette copie à jour s’appelle une projection, et le mot désigne souvent aussi la copie elle-même.

Dans cet exemple, la création de C42 se déroule en deux temps. Le modèle d’écriture valide d’abord la transaction qui enregistre la commande. Un traitement séparé, le consommateur, lit ensuite ce changement et met à jour la projection. Entre ces deux moments, la commande est enregistrée mais absente de la liste. Ce retard ne tient pas à la distance entre deux machines : il vient de l’ordre des opérations. Une tâche de fond qui alimente la liste dans le même processus et la même base produit le même écart qu’un service distant.

Werner Vogels appelle eventual consistency, cohérence à terme, la garantie que donne alors la liste : si aucune nouvelle modification n’arrive, toutes les lectures finissent par renvoyer la dernière valeur. Cette définition décrit une garantie que le système doit fournir, pas une conséquence automatique de toute mise à jour en deux temps : la liste rattrape la commande si la propagation reprend et applique correctement les changements conservés, et rien ne dit quand. Dans l’exemple d’Alice, le modèle d’écriture décide sur ses données à jour, et la lecture de référence de C42 passe par le même stockage, sur un chemin qui offre la cohérence forte : toute lecture commencée après une modification terminée en voit le résultat, en l’absence d’une écriture ultérieure qui le remplace. Cette propriété tient au stockage et au chemin de lecture choisis ; CQRS ne la fournit pas de lui-même.

C42 est enregistrée à R818, mais la liste Mes commandes est encore à R817 et ne la contient pas. La projection différée doit appliquer les changements conservés pour rattraper la source.
C42 est confirmée avant sa présence dans la liste. La projection reporte le changement avec un délai variable, à condition de reprendre et d’appliquer correctement les changements conservés.

Le guide CQRS de Microsoft signale le même effet quand les bases de lecture et d’écriture sont séparées : les données lues peuvent ne pas montrer tout de suite les derniers changements, et le cas d’un utilisateur qui agit sur ces données périmées demande une attention particulière. Alice, si elle recommence son achat, est dans ce cas.

Ce retard ordinaire n’est pas, à lui seul, une coupure du réseau au sens du théorème CAP, qui décrit ce qu’une machine peut promettre quand elle ne peut plus échanger avec les autres copies d’une donnée. Dans le cas ordinaire, rien n’est coupé : la projection a simplement un temps de retard sur la décision.

La création renvoie une preuve de ce qu’elle a enregistré

Dans le protocole fictif de l’exemple, la création ne se contente pas de répondre « OK ». Elle renvoie l’identifiant C42, sa version 1 et un jeton de progression, R818. Ce jeton désigne la position validée du changement « C42 créée » dans le flux qui alimente la liste : les changements y sont numérotés dans l’ordre, et la projection sait jusqu’à quel numéro elle les a tous appliqués. La position atteinte couvre ainsi tous les changements précédents, pas seulement le plus grand numéro aperçu. Pour l’application, le jeton est opaque : elle le conserve et le renvoie sans l’interpréter. Ce ne sont pas des champs standard d’HTTP ; ils appartiennent au contrat de cette application.

{
  "commande": "C42",
  "version": 1,
  "enregistrement": "confirme",
  "lecture_attendue": "R818"
}

L’application affiche aussitôt « commande C42 enregistrée ». Elle tire cette confirmation de la réponse de création, pas de la liste. Ce contrat suppose que la commande a été décidée avant la réponse. Si la création était seulement acceptée pour un traitement ultérieur, la réponse devrait au contraire dire « traitement en attente » : un accusé de réception ne prouve pas encore la décision métier.

Le cas d’une réservation montre comment une API distingue données en retard, demande acceptée et résultat confirmé, avec les réponses HTTP et le suivi que le client reçoit à chaque étape.

La lecture attend une progression précise, pendant un temps borné

Alice ouvre ensuite « Mes commandes », et l’application transmet R818 avec sa demande. Le service de lecture connaît le sens du jeton et son périmètre : une projection, un flux ou une partition de ce flux. Il ne compare R818 qu’aux positions de ce même périmètre, car le numéro 818 d’un autre flux ne dirait rien de la liste.

Au moment de la demande, la projection en est à R817 : elle n’a pas encore appliqué la création de C42. Le service de lecture attend au maximum 300 millisecondes dans cet exemple. Ce budget est un choix d’expérience utilisateur, pas une durée recommandée pour toutes les applications.

TempsÉtat observéRésultat de lecture
0 msPosition 817 ; C42 absenteAttente, aucune liste présentée comme actuelle
120 msÉvénement 818 appliqué et position validée avec la vueLa lecture peut être satisfaite
140 msListe lue au moins à la position 818C42 présente ; résultat retourné

Le tableau sépare deux conditions, la position 818 atteinte et la liste lue à cette position, parce qu’elles peuvent ne pas coïncider. Si le service constate la position 818 sur la base principale, puis lit la liste sur une réplique, une autre copie de la base qui sert les lectures et peut avoir son propre retard, il renvoie une liste sans C42 en croyant la condition remplie. La lecture de la vue doit donc être cohérente avec la progression annoncée. Un cache pose le même problème : pour cette lecture, il doit être compatible avec le jeton attendu, invalidé ou contourné.

Le jeton donne une garantie « au moins jusqu’à ce point », proche de ce que Vogels appelle read-your-writes, lire ses propres écritures, mais bornée : pour une lecture qui transmet R818 et dont l’attente est satisfaite, le résultat ne précède pas la création de C42. Une lecture ultérieure qui ne transmet plus le jeton n’a pas cette garantie ; l’étendre à toute la session demanderait de conserver le point atteint et de le transmettre à chaque lecture suivante. Le jeton ne garantit pas que les modifications les plus récentes des autres utilisateurs soient déjà visibles. Il ne dispense pas non plus de vérifier qu’Alice a le droit de voir C42.

Si les 300 millisecondes s’écoulent, la réponse le dit

La projection peut être simplement chargée, arrêtée sur une erreur, ou séparée de sa source. L’application n’a pas à deviner laquelle de ces causes la retient. Le service de lecture rend un résultat explicite :

{
  "lecture": "en_attente",
  "attendu": "R818",
  "atteint": "R817",
  "commande_enregistree": "C42"
}

L’interface conserve la confirmation de C42 et propose de réactualiser la liste. Elle peut afficher les autres commandes déjà connues, à condition de signaler que la mise à jour attendue manque. Elle ne remplace pas cet état par « C42 n’existe pas » et ne recrée pas la commande.

Si Alice demande le détail de C42, le parcours prévoit une autre voie : lire la commande dans la source de référence, avec les mêmes contrôles d’accès. Cette bascule convient à une fiche lue par son identifiant ; elle ne convient pas forcément à une recherche complexe calculée dans un index. Si la source est également indisponible, l’état actuel de C42 ne peut pas être confirmé, même si sa création l’a été. L’interface peut rester disponible, mais sa disponibilité ne crée pas une donnée fraîche.

Le contrat se vérifie en retardant la projection exprès

Quatre essais distinguent les comportements essentiels du protocole. Ils décrivent une recette à exécuter, pas des mesures réalisées sur un service existant.

  • Retarder la projection de 100 ms : la lecture attend, puis contient C42 et une progression compatible avec R818.
  • Arrêter le consommateur : la réponse bornée indique l’attente, conserve l’accusé de création et n’entraîne aucune nouvelle vente.
  • Rattraper la projection après l’expiration : la réactualisation retrouve C42, sans doublon ni confirmation contradictoire.
  • Laisser l’ancienne liste dans le cache : pour la lecture qui exige R818, le cache est écarté ou actualisé.

Le dernier essai vise une copie absente des schémas simplifiés. Le cache est une seconde copie de la liste, et il peut rompre une garantie pourtant tenue par la base.

Éviter le retard quand le besoin ne le justifie pas

Ce contrat a un coût : un jeton à transmettre, une attente à régler, une réponse de plus à afficher. Il n’a de raison d’être que si la liste est mise à jour après la décision. Le guide de Microsoft présente aussi des modèles de lecture et d’écriture qui partagent une même base. Si une petite vue peut être mise à jour dans la même transaction que la commande, le retard de projection disparaît pour elle, à condition que la lecture passe par cette base et non par une réplique ou un cache en retard. Séparer les responsabilités du code n’impose donc pas cette attente.

À l’inverse, un index de recherche coûteux ou un tableau de bord peut justifier une mise à jour différée. Il faut alors choisir les lectures qui exigent un rattrapage et celles qui acceptent une donnée plus ancienne. Réservez le jeton aux lectures où une personne vérifie sa propre action, comme la liste d’Alice juste après son achat ; un tableau de bord consulté par une équipe peut indiquer l’heure de sa dernière mise à jour sans faire attendre personne.

Un retard se distingue enfin d’une vue fausse. Si la liste a été mal calculée, attendre ne la corrigera pas : c’est alors la reconstruction du modèle de lecture qui la répare.

Ce que voit Alice

Alice a vu « commande C42 enregistrée » dès la réponse de création. La liste a affiché C42 après 140 millisecondes, parce que la lecture a attendu la position 818 au lieu de renvoyer l’état précédent. Si le consommateur avait été arrêté, elle aurait vu sa confirmation et une liste signalée comme incomplète, sans raison de recommencer son achat. Le retard vient d’une projection mise à jour après la décision ; le contrat le rend compréhensible en confirmant ce qui a été enregistré, en attendant une progression définie, puis en rendant l’incertitude visible si l’attente échoue.

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é.