Sur cette page
# Sémantique exactly-once de Kafka : fonctionnement et limites
La sémantique exactly-once (EOS) de Kafka est un ensemble de garanties qui fait en sorte que chaque enregistrement soit écrit dans le log et fasse avancer la position de son consommateur une fois et une seule, même lorsque les producteurs font de nouvelles tentatives, que des brokers tombent en panne ou qu'une application redémarre. Apache Kafka l'implémente au moyen de deux mécanismes : un producteur idempotent qui écarte les écritures en double grâce à un identifiant de producteur unique et à un numéro de séquence par partition, et des transactions qui regroupent les écritures vers plusieurs topics et le commit des offsets en une seule unité atomique. C'est la garantie de livraison la plus forte qu'offre la plateforme, et elle est bien réelle. Mais elle vaut à l'intérieur de Kafka, pas pour une base de données externe, un stockage objet ou un service tiers dans lequel vous écrivez, et c'est là que la plupart des équipes se font piéger.
La sémantique exactly-once est-elle vraiment possible avec Kafka ?
Oui. La version 0.11 a introduit la sémantique exactly-once en 2017, et Confluent soutenait alors que cette sémantique de messages est atteignable dans un vrai système de messagerie, et pas seulement en théorie. La réserve tient à la définition : aucun système distribué ne peut promettre qu'une livraison réseau n'a lieu qu'une fois, car un émetteur ne peut pas distinguer une requête perdue d'un acquittement perdu. Ce que Kafka fournit, c'est un traitement exactly-once : les pannes provoquent toujours des tentatives répétées, mais le log écarte les doublons et valide leurs effets de façon atomique, si bien que le résultat est identique à celui d'un monde où chaque message serait arrivé une seule fois.
Les trois garanties de livraison, et celle appliquée par défaut
Tout système de messagerie propose trois sémantiques de livraison des messages.
- Livraison at-most-once. Aucune nouvelle tentative côté producteur ; le consommateur effectue le commit avant le traitement. Rapide, jamais de doublon, mais la moindre panne entraîne une perte de données.
- Sémantique at-least-once. Le producteur renvoie ; le consommateur effectue le commit après le traitement. Rien n'est perdu, mais un doublon reste possible : c'est le comportement par défaut en pratique.
- Exactly-once. Les doublons sont écartés et le commit est atomique avec la sortie.
Depuis Kafka 3.0, le producteur Java est livré avec enable.idempotence=true et acks=all ; un producteur standard élimine donc déjà les doublons dus aux nouvelles tentatives. De bout en bout, on reste pourtant en at-least-once : sans transactions ni consommateur read_committed, un crash entre le traitement et le commit provoque le rejeu d'enregistrements.
Pourquoi l'exactly-once est un problème difficile
Quatre modes de défaillance doivent être résolus simultanément, tous classiques dans les systèmes distribués. Un producteur qui renvoie après un acquittement perdu ajoute deux fois le même enregistrement. Un consommateur qui s'arrête après le traitement mais avant le commit retraite les données à la reprise. Une tâche qui écrit des résultats et valide sa position modifie deux états indépendants qui doivent aboutir ensemble ou pas du tout. Enfin, une instance zombie, isolée mais toujours active, continue d'écrire dans un stream que son remplaçant a repris.
Les briques sur lesquelles s'appuie Kafka
Les garanties de Kafka reposent sur cinq composants : la couche d'idempotence du producteur ; un transactional.id stable ; un coordinateur de transactions côté broker ; le topic interne __transaction_state, ainsi que les marqueurs de commit et d'abandon écrits dans chaque partition de données ; et le paramètre isolation.level=read_committed côté consommateur.
Comment les producteurs idempotents éliminent-ils les doublons ?
Définissez enable.idempotence=true et le broker attribue à ce producteur un identifiant unique. Chaque lot porte cet identifiant et un compteur qui croît de façon monotone au sein d'un topic. Le broker mémorise la valeur la plus élevée acceptée : un lot renvoyé après un acquittement perdu est donc reconnu comme doublon, écarté et acquitté comme un succès. Une écriture, un enregistrement dans le log.
Cela ne couvre que les nouvelles tentatives du producteur au sein d'une même session. Si le processus redémarre, il obtient un nouvel identifiant de producteur et les écritures antérieures au crash ne peuvent plus être rapprochées : c'est précisément ce que règle transactional.id.
Comment producteurs et consommateurs transactionnels fonctionnent ensemble
Un producteur transactionnel définit un transactional.id stable et unique, puis suit une séquence d'appels fixe : initTransactions() au démarrage, puis beginTransaction(), les appels send(), et commitTransaction() ou abortTransaction().
initTransactions() s'enregistre auprès du coordinateur de transactions, incrémente l'epoch du producteur pour isoler toute instance plus ancienne portant la même identité, et résout le travail inachevé, ce qui sécurise la reprise. Au commit, le coordinateur consigne le résultat dans __transaction_state, puis écrit des marqueurs dans chaque topic concerné, ce qui garantit des écritures atomiques sur plusieurs partitions.
L'exactly-once est un contrat entre producteur et consommateur, et rien n'en parvient côté lecture si vous ne configurez pas isolation.level=read_committed. La valeur par défaut, read_uncommitted, renvoie les enregistrements annulés et réduit le dispositif à néant ; un consommateur read_committed ignore les données abandonnées et ne lit pas au-delà du dernier offset stable.
Le modèle consume-transform-produce
En production, l'essentiel du traitement exactly-once prend la forme d'une boucle consume-transform-produce : lire un topic Kafka en entrée, transformer, écrire dans un topic de sortie, valider la position d'entrée. Le commit doit se faire à l'intérieur de la transaction. Désactivez enable.auto.commit et transmettez les offsets consommés à sendOffsetsToTransaction(), afin que résultats et positions réussissent ou échouent ensemble.
Une application de traitement de flux bâtie sur l'API Kafka Streams en bénéficie d'office : définissez processing.guarantee=exactly_once_v2 et le framework s'en charge, y compris pour les state stores qu'il maintient pour les jointures et agrégations sur des flux de données. L'implémentation v2 utilise un seul producteur par instance, isolé via les métadonnées du consumer group, au lieu du modèle initial à un producteur par tâche ; c'est pourquoi l'exactly-once est assez peu coûteux pour rester activé dans n'importe quelle application Streams.
Là où s'arrête la garantie
C'est le point que les articles concurrents laissent dans le flou. Une transaction Kafka couvre le log et les offsets de consommateur validés avec elle. Rien d'autre. Si votre consommateur écrit dans Postgres, S3 ou une passerelle de paiement, cette écriture n'est pas incluse, et un crash entre les deux produit une double écriture en aval, même si l'état propre du broker est parfait. L'exactly-once de bout en bout exige donc la coopération du sink :
- Rendre le sink idempotent. Faire un upsert sur une clé naturelle, ou écrire vers un chemin d'objet déterministe : la solution la plus simple et la plus durable.
- Stocker les positions dans le sink. Valider données et offset dans une même transaction externe, puis reprendre à partir de cette valeur lors de la reprise.
- Utiliser un connecteur qui participe. Kafka Connect prend en charge la livraison exactly-once pour les connecteurs source et pour les sinks qui implémentent un commit en deux phases : vérifiez connecteur par connecteur.
Les effets de bord hors du périmètre du commit (envoyer un e-mail, débiter une carte) ne peuvent jamais être couverts ; dédoublonnez-les à la frontière à l'aide d'une clé d'idempotence. Si un pipeline émet des doublons que vous ne savez pas expliquer, le support Kafka 24/7 d'AceMQ y affecte un ingénieur senior, avec des objectifs de réponse à partir de 15 minutes, selon le plan.
Impact sur les performances et compromis
L'idempotence est quasiment gratuite et déjà activée par défaut. Les transactions Kafka coûtent davantage : les enregistrements ne deviennent visibles pour les consommateurs read_committed qu'une fois les marqueurs écrits, si bien que la latence est grosso modo bornée par votre intervalle de commit ; c'est pour cette raison que Kafka Streams ramène commit.interval.ms à 100 ms en mode EOS. Le surcoût reste modéré lorsqu'un commit couvre un lot conséquent de messages transactionnels, et devient lourd lorsqu'il en couvre très peu.
Une transaction bloquée est le risque le plus sérieux : elle fige le dernier offset stable et bloque tous les consommateurs read_committed de cette partition jusqu'à l'expiration de transaction.timeout.ms. Les équipes qui utilisent Kafka pour des registres comptables ou de la facturation jugent que cela en vaut la peine ; pour l'analytique, l'at-least-once associé à un sink en upsert est plus simple et moins coûteux.
Comment vérifier que l'exactly-once fonctionne réellement
Une configuration qui semble correcte dans un fichier properties ne prouve rien. Quatre vérifications détectent l'essentiel des problèmes.
isolation.levelsur chaque consommateur du topic de sortie. La valeur par défaut estread_uncommitted: un seul service en aval non converti lit discrètement des enregistrements annulés. C'est de très loin l'erreur de configuration la plus fréquente.- Un
transactional.idstable qui survit aux redémarrages. Une identité dérivée du nom d'hôte d'un conteneur change à chaque déploiement et ne peut pas isoler son propre zombie. - Le lag des consommateurs read_committed. Une partition dont le lag cesse de baisser alors que le log continue de croître signale généralement une transaction jamais validée ni abandonnée.
- Un producteur tué en pleine transaction dans un environnement de test. Vérifiez que rien de la tentative abandonnée n'atteint le topic de sortie ; la production est un mauvais endroit pour tester ce chemin pour la première fois.
Décider d'atteindre l'exactly-once est un choix de conception ; maintenir la sémantique exactly-once au fil des mises à niveau, des rééquilibrages et des basculements du coordinateur est un problème d'exploitation. Les plus de 11 experts seniors d'AceMQ accompagnent plus de 160 clients grands comptes dans plus de 26 pays. Découvrez les services Kafka pour entreprises d'AceMQ pour que cette frontière soit tracée avant qu'elle ne vous coûte un rapprochement.
Si la question derrière cet article relève de l'architecture plutôt que d'un incident en cours (stratégie de partitionnement, dimensionnement, conception de la sécurité, migration), le conseil Kafka d'AceMQ y affecte un ingénieur senior attitré. Pour un cluster exploité par votre équipe et que vous voulez voir couvert en cas de panne, le contrat qu'il vous faut est le support Kafka 24/7.
Cet article est l'étape cinq sur dix du guide d'exploitation de Kafka, qui aborde les décisions opérationnelles dans l'ordre où elles se présentent sur un parc en production.
Questions fréquentes
La sémantique exactly-once est-elle possible avec Kafka ?
Oui, Apache Kafka prend en charge la sémantique exactly-once depuis la version 0.11, publiée en 2017. Elle est mise en œuvre sous forme de traitement exactement une fois, et non de livraison exactement une fois sur le réseau : des enregistrements peuvent toujours être transmis plusieurs fois, mais le broker écarte les répétitions et valide les résultats de manière atomique, si bien que le résultat équivaut à une livraison unique. La garantie s'applique aux données écrites dans les topics Kafka et aux positions des consommateurs validées dans la même transaction. Tout système externe dans lequel votre application écrit doit assurer sa propre protection contre les doublons.
Comment activer la livraison exactly-once dans Kafka ?
Configurez trois éléments ensemble. Côté producteur, définissez enable.idempotence=true et un transactional.id stable et unique, puis encadrez les envois par initTransactions(), beginTransaction() et commitTransaction(). Côté consommateur, désactivez l'auto-commit et définissez isolation.level=read_committed, puis transmettez les positions consommées à sendOffsetsToTransaction() afin qu'elles soient validées de manière atomique avec vos résultats. Si vous utilisez Kafka Streams, processing.guarantee=exactly_once_v2 fait tout cela à votre place.
Kafka fonctionne-t-il en at-least-once par défaut ?
En pratique, oui. Un producteur Kafka récent utilise par défaut enable.idempotence=true et acks=all, ce qui supprime les doublons dus aux nouvelles tentatives du producteur, mais les consommateurs valident toujours leur position indépendamment du traitement qu'ils effectuent. Un plantage entre le traitement d'un enregistrement et la validation entraîne un nouveau traitement de cet enregistrement à la reprise : c'est la sémantique de livraison au moins une fois (at-least-once). Pour atteindre l'exactly-once, il faut des transactions côté producteur et l'isolation read_committed côté consommateur.
Qu'est-ce que le modèle consume-transform-produce dans Kafka ?
Le consume-transform-produce est la boucle exactly-once standard : une application lit les enregistrements d'un topic d'entrée, les transforme, écrit les résultats dans un topic de sortie et valide la position d'entrée. La propriété exactly-once vient de la validation de cette position dans la même transaction que les résultats, via sendOffsetsToTransaction(). Si la validation est annulée, ni les enregistrements écrits ni l'avancée de la position ne deviennent visibles, et le travail est simplement rejoué proprement. Kafka Streams met en œuvre ce modèle en interne lorsque l'exactly-once est activé.
Quel est le coût en performances des transactions Kafka ?
L'idempotence n'ajoute quasiment aucune surcharge mesurable et elle est activée par défaut. Les transactions ajoutent de la latence, car les enregistrements ne deviennent visibles pour les consommateurs read_committed qu'après l'écriture des marqueurs de validation : le débit dépend donc fortement du volume de travail couvert par chaque validation. Les gros lots amortissent bien ce coût et ne sacrifient en général qu'un pourcentage modeste du débit, tandis que les très petits lots peuvent être considérablement plus lents. Le principal risque opérationnel est une validation bloquée qui retient les consommateurs en aval jusqu'à l'expiration de son délai.
Guides, comparatifs et études
Approfondir : Kafka
Guides
3Comparatifs
9- NATS vs Kafka en 2026 : comparatif Core NATS, JetStream et Kafka
- Mosquitto vs Kafka : broker MQTT ou journal d'événements ?
- Kafka vs Kinesis : le comparatif
- Meilleurs fournisseurs Kafka managé en 2026, au-delà des hyperscalers
- Kafka Bring Your Own Cloud (BYOC) : les offres comparées
- Alternatives à Confluent et concurrents après le rachat par IBM

