Supposons un imprimeur d’emballages dont la direction industrielle demande une architecture data temps réel : les arrêts de ligne, connus aujourd’hui par le rapport du lendemain matin, devraient l’être sans attendre. Le comité d’investissement saisi de la demande n’a pas à juger une technologie. Il lui revient d’établir quelle décision serait prise plus tôt, par qui, et ce que vaut l’écart.
Le temps réel se définit ici par un délai : celui qui sépare un événement de la décision qu’il éclaire. Une architecture data temps réel traite les données au fil de leur arrivée pour tenir ce délai quand le traitement par lots planifié ne le tient plus. Elle se justifie usage par usage, lorsqu’une décision identifiée perd de sa valeur à attendre le lot suivant. Ailleurs, un lot plus fréquent suffit et s’exploite plus simplement. Les questions du comité se traitent dans l’ordre où elles engagent la dépense.
Quelle décision serait prise plus tôt ?
Une donnée plus fraîche ne vaut que par la décision qu’elle avance. Le comité demande donc, pour chaque flux candidat, qui agit, par quelle action, et ce qui change si l’information arrive plus tôt.
La réponse dépend du destinataire. Un système qui réagit seul (blocage, alerte, réapprovisionnement) exploite chaque instant gagné. Une personne en poste, chef d’équipe ou technicien de maintenance, agit dans le délai que son organisation lui laisse. Un indicateur lu en réunion hebdomadaire n’avance aucune décision s’il est rafraîchi en continu. Dans l’hypothèse d’ouverture, l’alerte d’arrêt de ligne relève du deuxième cas, le taux de rendement mensuel du troisième.
Une précaution s’ajoute. La réaction la plus immédiate, l’arrêt d’une machine sur un défaut, appartient à l’automate et à la supervision de l’atelier, auxquels la plateforme d’analyse n’a pas à se substituer. Lorsque les événements sont publiés par les applications elles-mêmes, le sujet déborde d’ailleurs la donnée d’analyse : il s’agit d’une architecture event-driven, dont les règles d’échange relèvent de l’architecture SI.
Combien de temps entre l’événement et la décision ?
L’usage emploie « temps réel » pour des délais très différents. Dans « Questioning the Lambda Architecture », article publié sur O’Reilly Radar le 2 juillet 2014, Jay Kreps parle d’une faible latence qu’il situe « de quelques secondes à quelques heures » (notre traduction). Le besoin s’écrit donc comme un délai, usage par usage : le temps maximal entre l’événement et le moment où son destinataire peut agir, la part des événements qui doit le respecter, la conduite à tenir quand il est dépassé.
Ce délai est une chaîne, où le maillon le plus lent pèse le plus : émission par la source, transport, traitement, affichage, puis temps que met la personne à voir l’information et à agir. Posons, par hypothèse, que le technicien de maintenance met dix minutes à rejoindre la ligne. Que l’alerte lui parvienne en dix secondes ou en une minute pèse peu devant ces dix minutes ; une alerte disponible le lendemain ne sert plus à l’intervention. La cible se déduit du maillon humain ou mécanique que la donnée ne raccourcira pas.
Un lot plus fréquent suffirait-il ?
Entre le lot de la nuit et le flux continu, plusieurs paliers existent, et chacun ajoute des contraintes d’exploitation au précédent :
- un lot rapproché, c’est-à-dire le même traitement planifié toutes les heures ou à quelques minutes d’intervalle ;
- un micro-lot (micro-batch), où le flux est découpé en petits lots successifs ;
- une capture des changements (change data capture), où chaque modification d’une table source devient un événement ;
- un flux continu, où chaque événement est traité à son arrivée, par une plateforme de diffusion d’événements et un moteur de traitement de flux.
Le palier à retenir est, selon nous, le premier qui tient le délai écrit à la question précédente. Ce choix du mode d’ingestion, selon la fraîcheur réellement nécessaire, fait partie de ce que cadre notre offre plateforme data.
Les documentations de deux moteurs de traitement de flux, Spark Structured Streaming et Apache Flink, lues le 12 novembre 2026, montrent que la frontière n’est pas tranchée : la première décrit un moteur qui, par défaut, traite le flux en une suite de petits lots ; la seconde présente le lot comme le traitement d’un flux borné (bounded stream), c’est-à-dire fini.
Que demande une architecture data temps réel à ceux qui l’exploitent ?
Un lot qui échoue la nuit se relance avant l’ouverture. Un flux n’a pas de nuit : une panne à trois heures se traite à trois heures, par une astreinte, ou bien l’organisation accepte par écrit que le délai ne soit pas tenu.
D’autres charges tiennent à la nature du flux, telle que la décrivent les documentations d’Apache Kafka, plateforme de diffusion d’événements, et d’Apache Flink, lues le même jour. Le traitement garde un état, par exemple des agrégats en cours, que Flink sauvegarde par des points de reprise (checkpoints) ; la reprise suppose une source capable de rejouer les événements, ce que Kafka permet en les conservant pendant une durée réglée par configuration. L’heure d’un événement n’est pas celle de son traitement : Flink distingue les deux et prévoit que des événements arrivent en retard. Un chiffre affiché peut donc être révisé après coup, ce que ses lecteurs doivent savoir. Kafka garantit l’ordre de lecture à l’intérieur d’une partition ; entre partitions, l’ordre reste à traiter dans la conception.
Le reste relève de l’exploitation courante. Un changement de format à la source atteint les consommateurs sans délai, d’où l’intérêt d’un data contract par flux. Une règle corrigée oblige à recalculer le passé, point sur lequel insiste l’article de Kreps. La détection d’une situation à partir de plusieurs événements, objet du complex event processing, ajoute son propre état à surveiller. Le calcul, enfin, peut tourner en permanence, que les événements affluent ou non.
Que devient le traitement par lots ?
Il reste. L’historique se recharge par lots, une clôture se calcule sur un état arrêté, et certaines sources ne livrent que des fichiers. Le comité s’intéresse à la cohabitation, et d’abord à savoir si la même règle de calcul sera écrite deux fois.
L’article de Jay Kreps décrit deux montages. Dans l’architecture lambda, qu’il attribue à un billet de Nathan Marz, les mêmes données alimentent en parallèle un système par lots et un système de flux, la logique est écrite dans chacun et les résultats sont réunis à la lecture. Kreps, qui rappelle dans ce billet avoir participé à la construction de Kafka, y voit une charge de maintenance. Il propose de ne garder que le flux et de rejouer les événements conservés lorsque le code change, montage qu’il suggère d’appeler architecture kappa.
Quel que soit le montage, deux chiffres peuvent coexister pour une même grandeur : celui du flux, immédiat et révisable, et celui du lot, consolidé. Le comité fait écrire lequel fait foi, et pour quel usage.
Par quel flux commencer, et quand s’arrêter ?
Par un seul flux : celui dont la décision est nommée, dont le destinataire est en poste et dont le délai est écrit. Il est construit de bout en bout, puis mesuré sur des événements réels : délai constaté entre l’événement et l’action, part des événements hors délai, interventions de l’astreinte, calcul consommé. La surveillance de sa fraîcheur reprend les signaux de la data observability.
S’arrêter est une issue normale. Si le lot rapproché tient le délai, le projet s’en tient là. Si l’action n’a pas lieu plus tôt alors que l’information arrive plus tôt, le frein est dans l’organisation, et un deuxième flux ne le lèvera pas.
Dans l’hypothèse de départ, la demande revient devant le comité avec la décision visée, le délai mesuré sur le premier flux et la charge d’exploitation constatée : de quoi autoriser le flux suivant, ou clore le dossier.