Programmation et développement logiciel

Comment construire un pipeline Kafka qui préserve l’ordre des sessions avec Go

Joshua Oluikpe décrit une conception pratique pour traiter les messages Kafka dans un ordre strict au sein de chaque session, tout en permettant aux sessions indépendantes de fonctionner en parallèle. La conception repose sur le hachage cohérent, un worker Go par session, la nouvelle tentative au sein du même flux et la gestion de points de validation contigus afin d’éviter la perte de messages après un incident.

2026-10-07
6 min de lecture
197 vues
certi.news Editorial Team
Comment construire un pipeline Kafka qui préserve l’ordre des sessions avec Go

Il ne suffit pas de s’appuyer sur l’ordre de Kafka au sein de la partition lorsque des milliers de sessions partagent cette même partition. Dans les systèmes de conversation et les tâches séquentielles, un message correctif comme « définissez la destination sur Paris » peut arriver après le message « réservez un voyage à Londres », mais son exécution avant le premier message détruirait le contexte. La solution décrite par Joshua Oluikpe dans InfoQ transfère une partie de la responsabilité de l’ordre à la couche applicative écrite en Go.

Ordre au sein de la session et parallélisme entre les sessions

La conception repose sur deux niveaux de workers. Le niveau de distribution reçoit les enregistrements Kafka et les achemine selon l’identifiant de session au moyen du hachage cohérent, de sorte que les messages d’une même session arrivent au même worker, tandis que les différentes sessions peuvent être réparties entre plusieurs workers. Ensuite, chaque session active reçoit une goroutine dédiée qui traite un seul message à la fois et dans l’ordre d’arrivée.

Ainsi, une session lente ne devient pas un obstacle pour les autres sessions, comme cela se produit dans un pool de workers plat lorsqu’une nouvelle tentative pour une seule session monopolise entièrement le worker. Les goroutines sont créées à la demande et supprimées après une période d’inactivité, ce qui fait dépendre la consommation de ressources du nombre de sessions actives plutôt que du nombre total de sessions possibles.

Effectuer de nouvelles tentatives sans dépasser les messages

La nouvelle tentative s’effectue au sein de la goroutine de la session elle-même. En cas d’erreur temporaire, telle que l’expiration du délai d’un service dépendant, le worker attend en appliquant un recul exponentiel avec une part d’aléatoire, puis retraite le même message avant de passer aux messages suivants. Comme les messages suivants restent dans le canal derrière le message en échec, le quatrième message ne peut pas dépasser le troisième.

Les erreurs irrécupérables, telles que des données non valides, sont quant à elles directement envoyées vers la liste des messages morts (DLQ). Cette distinction entre les erreurs temporaires et les erreurs définitives élimine le besoin d’une machine à états distincte pour gérer les nouvelles tentatives, mais signifie également que les messages d’une session donnée peuvent s’accumuler pendant la période de recul.

Validation sûre et récupération après un incident

Lorsque plusieurs sessions traitent leurs messages en parallèle, il n’est pas possible de valider uniquement l’offset terminé le plus élevé. Si l’offset 104 est terminé avant le 102 et que 104 est ensuite validé, un incident du consommateur peut entraîner le dépassement définitif de 102. Le système suit donc, pour chaque partition, les offsets en cours de traitement et ceux qui sont terminés, et ne déplace le point de validation que jusqu’au plus grand offset terminé de manière contiguë.

Le redémarrage peut par conséquent commencer à un offset plus ancien et retraiter certains messages. La conception utilise un identifiant d’événement stable pour faciliter la déduplication, mais ne prétend pas garantir une exécution « exactement une fois » ; les effets externes restent liés à la capacité des services dépendants à gérer les duplications de manière idempotente. Dans de rares cas, un trou bloqué peut être dépassé après l’expiration d’un délai défini afin de rétablir la progression de la partition, en l’enregistrant comme un échec opérationnel et en orientant le message vers la DLQ, ce qui constitue un compromis explicite entre continuité et exhaustivité du traitement.

Que faut-il pour une véritable mise en production ?

Les garanties d’ordre ne sont pas complètes avec la seule logique de base. Pendant la redistribution des partitions, le consommateur cesse de recevoir de nouveaux enregistrements, attend la fin du travail en cours, puis valide le dernier watermark contigu avant de transférer la propriété. Lorsque les canaux des workers sont pleins, il suspend temporairement la récupération des messages au lieu de les supprimer, tout en stockant les enregistrements déjà récupérés dans des buffers propres à chaque partition afin que des messages plus récents ne les dépassent pas.

Le système doit également détecter individuellement les offsets bloqués, assurer le suivi entre les frontières asynchrones de Kafka, maintenir les signaux de retard nécessaires à la mise à l’échelle automatique pendant la suspension de la récupération, et vider les travaux ainsi qu’écrire la DLQ avant l’arrêt. Le produit applique aussi le hachage cohérent du côté de l’envoi afin de garantir l’ordre des messages lors d’une production asynchrone.

Résultats et limites

Lors d’un test synthétique portant sur 50 000 messages et 10 sessions, avec injection d’erreurs temporaires dans 10 % des messages, le système a enregistré 14 027 messages par seconde sans aucune violation de l’ordre, avec une latence médiane de 11,7 millisecondes. Lors d’un test de charge sur 1 000 sessions, le débit effectif a atteint 48 805 messages par seconde sur un objectif de 50 000, sans erreur d’envoi, mais la latence de queue a dépassé le budget de 200 millisecondes en raison de la limite de débit de l’API Gateway, et non du mécanisme d’ordonnancement des sessions.

L’auteur indique que le système a traité plus de 40 millions de messages en production sans violation notable de l’ordre, avec seulement 460 messages orientés vers la DLQ, soit environ 0,002 %. Toutefois, ce chiffre repose sur la surveillance opérationnelle et non sur une vérification exhaustive de la séquence de chaque message, et le test de charge supérieur n’a pas vérifié indépendamment l’ordre de chaque session. La valeur pratique de la conception réside donc dans la transformation de l’ordre, qui n’est plus une hypothèse au niveau de Kafka mais une propriété imposée par l’application, tout en conservant la nécessité de tests explicites de séquencement et de garanties d’idempotence dans les services dépendants.

Source de l’actualité
InfoQ - Architecture Articles
Ouvrir la source originale ↗
c
Auteur

certi.news Editorial Team

À retenir

L’article présente une conception en Go pour traiter les messages Apache Kafka dans un ordre strict au sein de chaque session, tout en exécutant les sessions indépendantes en parallèle. La conception repose sur le hachage cohérent, une goroutine par session, les nouvelles tentatives dans le même chemin d’exécution et la validation contiguë des offsets afin de réduire la perte de messages après un incident, mais elle ne garantit pas une exécution exactement une fois.

  • Les messages d’une même session sont dirigés vers le même worker grâce au hachage cohérent, tandis que les différentes sessions sont traitées en parallèle.
  • La goroutine propre à chaque session traite un message à la fois et empêche les messages suivants de dépasser un message faisant l’objet d’une nouvelle tentative.
  • Les erreurs irrécupérables sont envoyées vers une liste de messages morts (DLQ), tandis que les erreurs temporaires font l’objet de nouvelles tentatives avec un recul exponentiel et une part d’aléa.
  • L’offset validé pour chaque partition n’avance que jusqu’au plus grand offset terminé de manière contiguë, afin d’éviter de dépasser des messages qui ne sont pas encore terminés.
  • Un redémarrage peut entraîner le retraitement de certains messages ; la conception s’appuie donc sur des identifiants d’événements stables et sur la capacité des services en aval à gérer les doublons.
  • Les tests mentionnés ont atteint jusqu’à 14 027 messages par seconde tout en préservant l’ordre des sessions, mais les résultats opérationnels et les tests n’ont pas vérifié indépendamment toutes les séquences de messages.

FAQ

Pourquoi l’ordre de Kafka au sein d’une partition ne suffit-il pas ?

Parce que des milliers de sessions peuvent partager la même partition, alors que chaque session peut nécessiter un ordre indépendant tout en permettant aux autres sessions de fonctionner en parallèle.

Comment la conception empêche-t-elle un message suivant de dépasser un message temporairement défaillant ?

La nouvelle tentative est effectuée dans la goroutine de la session, et les messages suivants restent derrière le message bloqué dans le canal jusqu’à ce que son traitement réussisse ou qu’il soit envoyé vers la DLQ.

La conception garantit-elle une exécution exactement une fois des messages ?

Non. Le processus de récupération peut retraiter certains messages, et l’intégrité des effets externes dépend de la capacité des services en aval à gérer les doublons de manière idempotente.

Quelle est la cause du dépassement du temps de latence de queue lors du test de charge ?

L’article l’attribue au quota de débit de l’API Gateway, et non au mécanisme de classement des sessions.

Dans la même catégorie

À lire également

Voir toutes les actualités