BlogKafka

Architecture événementielle Kafka : patterns, conception et modes de défaillance

Scott Sternloff

Par Scott Sternloff, Architecte d’entreprise senior

LinkedIn · Mis à jour le · Lecture : 7 min

Architecture événementielle Kafka : patterns, conception et modes de défaillance
Sur cette page

Une architecture événementielle Kafka utilise les topics Kafka comme journal durable entre les services : les producteurs publient des faits tels que OrderPlaced, et un nombre quelconque de consumer groups y réagissent indépendamment, à leur propre rythme, avec la possibilité de rejouer l'historique. Kafka fournit l'ordre par partition, la rétention et le rejeu. Il ne décide ni du contenu d'un événement, ni de l'évolution des schémas, ni de la façon d'éviter les doubles écritures, ni du sort d'un message qui échoue en boucle. Ce sont ces décisions que couvre ce guide.

Pour le fonctionnement interne du broker, consultez l'architecture Kafka.

Trois patterns que l'on qualifie tous d'orientés événements

L'article de Martin Fowler de 2017 distingue des patterns souvent confondus, et celui que vous mettez en œuvre détermine la conception des topics et la rétention.

PatternContenu de l'événementConséquence dans Kafka
Notification d'événementUn fait succinct et un ID : la commande 123 a été passéeLes consommateurs interrogent le service source pour obtenir les détails : la charge sur son API augmente donc avec chaque nouveau consommateur. Une rétention classique basée sur le temps suffit.
Transfert d'état porté par l'événementL'état dont les consommateurs ont besoinLes consommateurs conservent une copie locale et n'interrogent plus la source. Un topic compacté (cleanup.policy=compact) conserve la dernière valeur par clé, ce qui permet à un nouveau consommateur de reconstruire cette copie.
Event sourcingChaque changement d'état, en tant que système de référenceLes événements ne doivent jamais être supprimés : retention.ms=-1 sur un topic en politique delete, et non la compaction, qui supprime les événements plus anciens de chaque clé.

La rétention par défaut de Kafka est de sept jours (log.retention.hours=168) : tout topic à partir duquel un état est reconstruit exige donc une décision explicite sur la rétention. La plupart des systèmes combinent les deux premiers patterns ; l'event sourcing implique de rejouer chaque événement dans un code qui comprend encore le schéma le plus ancien.

Conception des topics et des clés

Granularité. Un topic par type d'événement (orders.order-placed) est simple à sécuriser et à faire évoluer. Un topic par stream d'entité (orders.events, regroupant passée, payée et expédiée) conserve tous les changements d'une commande dans une même séquence. Kafka n'ordonne les enregistrements qu'au sein d'une partition : si un consommateur a besoin de « passée » avant « payée » pour une même commande, les deux types doivent partager un topic.

Clés. Utilisez l'ID de l'entité ou de l'agrégat comme clé d'enregistrement, afin que le partitionneur par défaut envoie tous les événements d'une commande vers la même partition. Une clé dominée par quelques valeurs très sollicitées, comme un gros tenant, surcharge une partition et un consommateur. Ajouter des partitions par la suite modifie le hachage des clés et rompt l'ordre par clé au moment du changement : dimensionnez donc dès le départ en prévision de la croissance ; consultez notre guide sur la stratégie de partitionnement Kafka. Définissez la réplication et la rétention par topic plutôt que de vous reposer sur les valeurs par défaut du broker.

Schémas et compatibilité

Les événements sont un contrat entre des équipes qui ne se parleront peut-être jamais. Associez un schéma (Avro, Protobuf ou JSON Schema) à chaque topic et laissez un registre rejeter les changements incompatibles dès l'enregistrement, et non dans la stack trace d'un consommateur. Confluent Schema Registry (Confluent Community License) utilise BACKWARD par défaut : les consommateurs sur le nouveau schéma peuvent lire les anciennes données, vous pouvez donc supprimer des champs et en ajouter des facultatifs, et vous mettez à niveau les consommateurs en premier. Apicurio Registry est une alternative sous licence Apache 2.0.

  • Utilisez BACKWARD_TRANSITIVE ou FULL_TRANSITIVE sur les topics destinés au rejeu : les modes transitifs vérifient toutes les versions antérieures, et un rejeu les lit toutes.
  • Ne passez jamais un topic partagé en NONE pour imposer un changement cassant ; publiez une nouvelle version du topic.
  • Pour plusieurs types d'événements dans un même topic, remplacez la stratégie par défaut TopicNameStrategy par RecordNameStrategy ou TopicRecordNameStrategy.

Dotez chaque événement d'une enveloppe : un ID d'événement unique, le type, l'horodatage de l'événement et un ID de corrélation.

Ordre et idempotence

Côté producteur, les clients Kafka actuels utilisent par défaut acks=all et enable.idempotence=true, et la documentation du producteur précise que l'ordre est préservé avec l'idempotence activée tant que max.in.flight.requests.per.connection reste inférieur ou égal à 5. Vérifiez que d'anciens services ne les ont pas surchargés :

acks=all
enable.idempotence=true
max.in.flight.requests.per.connection=5

Le producteur idempotent ne supprime que les doublons issus de ses propres nouvelles tentatives. Un consommateur qui traite un lot et s'arrête avant de valider ses offsets le retraite après le rééquilibrage. Rendez chaque handler idempotent : enregistrez les ID d'événements traités dans la même transaction que l'effet de bord, ou faites un upsert sur la clé entité et version.

Le pattern outbox avec Debezium

Le bug de perte de données le plus courant dans les services orientés événements est la double écriture : commit en base, puis publication dans Kafka. Si le processus s'arrête entre les deux, la base de données et le flux d'événements divergent.

Le pattern outbox transactionnel supprime la seconde écriture. Le service insère l'événement dans une table outbox au sein de la même transaction que la modification métier ; Debezium lit le journal des modifications de la base et son outbox event router transforme chaque ligne en événement métier :

transforms=outbox
transforms.outbox.type=io.debezium.transforms.outbox.EventRouter
# outbox columns: id, aggregatetype, aggregateid, type, payload
# default topic: outbox.event.${routedByValue} (the aggregatetype)
# default record key: aggregateid

Utiliser aggregateid comme clé conserve l'ordre des événements de chaque agrégat. Purgez régulièrement les anciennes lignes de l'outbox et dédupliquez sur l'id de l'outbox, car un redémarrage du connecteur peut publier une ligne deux fois. Nos ingénieurs du support Debezium exploitent ce pattern sur PostgreSQL, SQL Server et Oracle. Les options Outbox et CDC sont comparées dans Alternatives à Debezium.

Consumer groups, nouvelles tentatives et topics dead-letter

Chaque consumer group reçoit tous les événements ; au sein d'un groupe, chaque partition est attribuée à un seul membre : le nombre de partitions plafonne donc le parallélisme. Kafka 4.0 a rendu le nouveau protocole de consumer group (KIP-848) disponible en version stable pour des rééquilibrages plus rapides, mais les clients utilisent par défaut group.protocol=classic et doivent l'activer explicitement avec group.protocol=consumer ; consultez notre guide sur le rééquilibrage Kafka.

Kafka ne propose pas de dead-letter queue (DLQ) pour les consommateurs ordinaires : la gestion des échecs relève donc de votre conception :

  1. Nouvelle tentative sur place pour les erreurs transitoires, avec backoff et plafond. L'ordre est préservé mais la partition est bloquée, et chaque boucle de poll doit se terminer dans le délai max.poll.interval.ms (cinq minutes par défaut), faute de quoi le consommateur quitte le groupe.
  2. Topics de nouvelle tentative tels que orders.retry.5m pour les erreurs susceptibles de se résorber. La partition continue de s'écouler, mais l'événement retraité n'est plus dans l'ordre pour sa clé.
  3. Un topic dead-letter pour les événements qui n'aboutiront jamais, avec des en-têtes indiquant l'erreur, le topic source, la partition et l'offset, une alerte et un chemin de rejeu.

Spring for Apache Kafka et les frameworks similaires implémentent les topics de nouvelle tentative et dead-letter. Les connecteurs sink de Kafka Connect utilisent errors.tolerance=all avec errors.deadletterqueue.topic.name. Pour des traitements de type file d'attente sans ordre par clé, Kafka 4.2 a rendu les share groups prêts pour la production, avec acquittement par enregistrement.

L'exactly-once là où il compte

Les transactions Kafka apportent un traitement exactly-once aux pipelines consume-transform-produce qui restent dans Kafka : une application Kafka Streams avec processing.guarantee=exactly_once_v2, ou un producteur transactionnel qui valide de façon atomique les offsets consommés et les enregistrements produits, lus en aval avec isolation.level=read_committed (la valeur par défaut du consommateur est read_uncommitted). Elles ne couvrent pas les effets de bord hors de Kafka, comme une écriture en base ou un appel de paiement, qui exigent toujours des handlers idempotents. Notre guide sur la sémantique exactly-once de Kafka en explique le fonctionnement.

Observabilité

  • Consumer lag par partition, et pas seulement par groupe : une partition bloquée passe inaperçue dans un total sain. Consultez consumer lag Kafka.
  • Latence de bout en bout : horodatage de l'événement comparé à l'heure de traitement, par consumer group.
  • Topics dead-letter : alerte sur tout nouvel enregistrement.
  • Fréquence des rééquilibrages, erreurs des producteurs et partitions sous-répliquées.
  • Traçage : un ID de corrélation dans les en-têtes des enregistrements, pour suivre une transaction d'un service à l'autre.

Modes de défaillance courants

  • Message empoisonné. Un seul événement mal formé fait échouer toutes les nouvelles tentatives et bloque sa partition. Solution : nouvelles tentatives limitées, puis un topic dead-letter.
  • Boucles de rééquilibrage. Un handler lent dépasse max.poll.interval.ms, ses partitions sont réattribuées et le cycle recommence. Solution : réduire max.poll.records ou accélérer les handlers.
  • Perte silencieuse due à la rétention. Un consommateur hors ligne plus longtemps que la rétention du topic revient sur des événements supprimés et, avec auto.offset.reset à sa valeur par défaut latest, saute en avant sans aucune erreur. Consultez politique de rétention Kafka.
  • Partitions surchargées dues à des clés déséquilibrées, changements de schéma cassants imposés de force, et doubles écritures sans pattern outbox.

Si certains flux sont en réalité des files d'attente de tâches avec routage et priorités, consultez RabbitMQ vs Kafka.

Quand faire appel à nous

Les ingénieurs du support Kafka d'AceMQ revoient la conception des topics, des clés, des schémas et des nouvelles tentatives, et prennent l'appel en cas de panne, sur Kafka autogéré, Confluent Platform et Amazon MSK ; nos services managés Kafka prennent en charge l'exploitation de vos clusters.

Références

Questions fréquentes

Qu'est-ce qu'une architecture événementielle avec Kafka ?

Les services publient dans des topics Kafka des faits décrivant ce qui s'est passé, et d'autres services les consomment via des consumer groups, chacun à son rythme. Kafka conserve les événements pendant une période de rétention, ce qui permet à un consommateur nouveau ou en cours de reprise d'en faire le rejeu, et préserve leur ordre au sein de chaque partition.

Kafka est-il adapté à une architecture événementielle ?

Oui, lorsque de nombreux consommateurs ont besoin des mêmes événements, que le rejeu compte et qu'un ordre par entité suffit. Il est moins adapté au routage message par message, aux priorités ou au mode requête-réponse entre quelques services, où un broker comme RabbitMQ est plus simple.

Faut-il un topic par type d'événement ou par entité ?

Un topic par type d'événement est plus simple à sécuriser et à faire évoluer. Un topic par stream d'entité, avec l'ID de l'entité comme clé, conserve tous les événements d'une entité dans l'ordre. Si des consommateurs dépendent de l'ordre entre différents types d'événements d'une même entité, ceux-ci doivent partager un topic.

Comment éviter la double écriture entre ma base de données et Kafka ?

Utilisez le pattern outbox transactionnel : écrivez l'événement dans une table outbox dans la même transaction que la modification métier, et laissez un outil de CDC (capture des changements de données) comme Debezium le publier. L'outbox event router utilise l'ID d'agrégat comme clé des enregistrements, ce qui conserve l'ordre des événements de chaque agrégat.

Kafka dispose-t-il d'une dead-letter queue ?

Pas pour les consommateurs ordinaires. Les connecteurs sink de Kafka Connect peuvent écrire les enregistrements en échec dans un topic dead-letter via errors.deadletterqueue.topic.name. Les consommateurs applicatifs implémentent eux-mêmes les topics de nouvelle tentative et dead-letter, ou via un framework comme Spring for Apache Kafka.

Ai-je besoin de la sémantique exactly-once de Kafka ?

Uniquement pour les pipelines qui lisent depuis Kafka et y réécrivent, et où un doublon fausse le résultat, comme les agrégations. L'exactly-once ne couvre ni les écritures en base ni les appels d'API externes : les handlers doivent donc rester idempotents.

Scott Sternloff

Auteur

Scott SternloffArchitecte d’entreprise senior

Architecte d’entreprise senior chez AceMQ. Il signe ici les contenus techniques : architecture RabbitMQ, Kafka et Redis, clustering et migrations.

Parler à un ingénieur

Besoin d’un coup de main sur Kafka ?

Des ingénieurs seniors qui l’exploitent en production. Demandez un devis ou une consultation gratuite, sans argumentaire commercial.

Consultation gratuite

Un regard expert sur votre cluster Kafka

Que vous deviez résoudre un incident de production, planifier une migration ou obtenir un second avis sur votre architecture, notre équipe est prête. Pas d’argumentaire commercial, seulement des réponses.

Nous écrire