Prendre RDV
Lexique · DevOps / Cloud / Data

Apache Kafka : définition, architecture et exemple

La plateforme distribuée de streaming d'événements qui stocke et transporte des flux de données en temps réel : origine, topics, partitions, producteurs, consommateurs, exemple et comparaison avec RabbitMQ.

Par Équipe Blent· Mis à jour le · 15 min de lecture· Niveau intermédiaire

Apache Kafka en bref

Type
Plateforme de streaming d'événements
Origine
LinkedIn (2010 à 2011)
Créateurs
Jay Kreps, Neha Narkhede, Jun Rao
Gouvernance
Apache Software Foundation

Définition : Apache Kafka

Apache Kafka est une plateforme open source de streaming d'événements distribuée. Elle conserve les messages dans un journal ordonné et partitionné, répliqué sur plusieurs serveurs appelés brokers. Des producteurs y écrivent des événements dans des topics, et des consommateurs les relisent à leur rythme, chacun mémorisant sa position. Cette conception offre un débit élevé, une bonne tolérance aux pannes et la possibilité de rejouer l'historique. Créé chez LinkedIn puis confié à la fondation Apache, Kafka sert de colonne vertébrale à de nombreux pipelines de données en temps réel.

En une phrase : Kafka enregistre les événements dans un journal partitionné et répliqué, que plusieurs applications peuvent lire et relire indépendamment, en temps réel.

Dans cette définition

Qu'est-ce qu'Apache Kafka ?

Apache Kafka est une plateforme de streaming d'événements : elle reçoit des messages envoyés par des applications, les stocke durablement dans un journal, puis les met à disposition d'autres applications qui les lisent en continu. Contrairement à une file de messages classique, elle ne supprime pas un message une fois lu, ce qui permet à plusieurs systèmes de consommer les mêmes données et de les rejouer.

Kafka naît chez LinkedIn, où Jay Kreps, Neha Narkhede et Jun Rao le conçoivent pour collecter les journaux d'activité et alimenter les pipelines de données. Il est publié en open source en 2011 et devient un projet de premier niveau de la fondation Apache en 2012. Les trois créateurs fondent ensuite Confluent, qui propose une offre commerciale et managée. Notre article Apache Kafka : tout savoir sur le Data Streaming en détaille les composants.

Dans une plateforme data, Kafka transporte les événements, tandis que des moteurs de calcul comme Apache Spark ou Apache Flink les transforment. Il est aussi comparé aux agents de messages comme RabbitMQ, dont la philosophie est différente.

À retenir : Kafka n'est pas une file qui se vide à la lecture, mais un journal que l'on relit. Chaque consommateur garde sa propre position dans ce journal.

Comment fonctionne Apache Kafka ?

Kafka ne supprime pas un message lorsqu'il est lu : il l'ajoute à la fin d'un journal, et chaque lecteur avance dans ce journal à son propre rythme.

  1. Publier un événement

    Un producteur envoie un message (clé, valeur, horodatage) vers un topic. La clé détermine la partition cible : les messages de même clé restent donc ordonnés entre eux.

  2. Écrire dans une partition

    Le broker qui dirige la partition ajoute le message à la fin de son journal et lui attribue un offset, un numéro séquentiel unique au sein de cette partition.

  3. Répliquer les données

    Chaque partition est copiée sur plusieurs brokers. Un leader reçoit les écritures, des followers les répliquent, et l'un d'eux prend le relais si le leader tombe.

  4. Conserver le journal

    Les messages sont gardés selon une durée ou une taille configurées, indépendamment de leur lecture. Un topic peut aussi être compacté pour ne garder que la dernière valeur par clé.

  5. Consommer en groupe

    Les consommateurs d'un même groupe se répartissent les partitions d'un topic. Chaque partition est lue par un seul membre du groupe, ce qui permet de paralléliser la lecture.

  6. Valider la progression

    Chaque consommateur enregistre l'offset atteint (commit). Après une panne ou un redémarrage, il reprend à cet endroit, ou peut revenir en arrière pour rejouer l'historique.

L'architecture de Kafka

Un cluster Kafka est un ensemble de brokers, des serveurs qui stockent les données et répondent aux clients. Les données sont organisées en topics, eux-mêmes découpés en partitions réparties entre les brokers. Depuis l'arrivée de KRaft, les brokers gèrent eux-mêmes les métadonnées du cluster, sans service ZooKeeper séparé, et la version 4.0 a retiré l'ancien mode.

Les briques principales

  • Producteurs : les applications qui publient des événements dans un topic.
  • Consommateurs : les applications qui lisent les événements, seules ou en groupe.
  • Kafka Connect : un framework qui importe ou exporte des données entre Kafka et des systèmes externes, grâce à des connecteurs.
  • Kafka Streams : une bibliothèque Java qui traite les flux directement dans une application.

Les garanties de livraison

SémantiqueSignification
Au plus une foisLe message peut être perdu, mais jamais traité deux fois
Au moins une foisLe message n'est jamais perdu, mais peut être traité deux fois
Exactement une foisLe message est traité une seule fois, grâce aux producteurs idempotents et aux transactions

Le choix dépend du coût d'un doublon ou d'une perte. Le mode « au moins une fois » est courant, associé à des traitements idempotents côté consommateur.

Exemple : publier et lire des événements avec Python

Cet exemple utilise la bibliothèque confluent-kafka pour publier des commandes dans un topic, puis les lire dans un groupe de consommateurs.

python
from confluent_kafka import Producer, Consumer
import json

# Producteur : la clé garantit l'ordre des commandes d'un même client
producteur = Producer({"bootstrap.servers": "localhost:9092"})
commande = {"id": 1042, "client": "c-77", "montant": 59.9}
producteur.produce(
    "commandes",
    key=commande["client"],
    value=json.dumps(commande),
)
producteur.flush()  # attendre la confirmation du broker

# Consommateur : les membres d'un même group.id se répartissent les partitions
consommateur = Consumer({
    "bootstrap.servers": "localhost:9092",
    "group.id": "facturation",
    "auto.offset.reset": "earliest",  # lire depuis le début si aucun offset
})
consommateur.subscribe(["commandes"])

while True:
    message = consommateur.poll(1.0)
    if message is None or message.error():
        continue
    print(message.partition(), message.offset(), message.value())

Le producteur utilise l'identifiant du client comme clé : toutes ses commandes arrivent dans la même partition, donc dans l'ordre. Le consommateur appartient au groupe facturation : si l'on lance une seconde instance, Kafka répartit les partitions entre les deux. Un autre groupe, par exemple analytique, relirait les mêmes commandes indépendamment.

bash
# Créer un topic de 3 partitions répliquées 3 fois
kafka-topics.sh --bootstrap-server localhost:9092 \
  --create --topic commandes --partitions 3 --replication-factor 3

En production, ces clusters sont souvent exploités sur Kubernetes ou consommés comme un service managé.

Les principaux cas d'usage d'Apache Kafka

Kafka est utilisé dès que des événements doivent circuler entre de nombreux systèmes, en continu et sans perte.

  • Pipelines de données

    Transporter les données des applications vers un entrepôt ou un lac de données.

  • Streaming en temps réel

    Alimenter Spark, Flink ou Kafka Streams pour calculer des indicateurs au fil de l'eau.

  • Collecte de logs et métriques

    Centraliser les journaux et la télémétrie de nombreux services avant leur analyse.

  • Architectures événementielles

    Faire communiquer des microservices par événements plutôt que par appels directs.

  • Capture de changements (CDC)

    Diffuser les modifications d'une base de données vers d'autres systèmes.

  • Détection de fraude et alertes

    Analyser les transactions à mesure qu'elles arrivent pour réagir immédiatement.

Quels sont les avantages d'Apache Kafka ?

Kafka combine débit, durabilité et découplage, ce qui explique sa présence dans la plupart des architectures de données en temps réel.

  • Débit très élevé grâce aux écritures séquentielles et au partitionnement, avec une montée en charge horizontale.
  • Durabilité des messages, répliqués sur plusieurs brokers et conservés selon une rétention configurable.
  • Découplage entre producteurs et consommateurs, qui évoluent et tombent en panne indépendamment.
  • Relecture possible de l'historique, utile pour corriger un traitement ou alimenter un nouveau système.
  • Ordre garanti au sein d'une partition, donc pour tous les messages d'une même clé.
  • Écosystème riche : Kafka Connect, Kafka Streams, registre de schémas et offres managées sur tous les grands Clouds.

Quelles sont les limites d'Apache Kafka ?

Kafka est un outil puissant mais exigeant : sa complexité d'exploitation et ses choix de conception ne conviennent pas à tous les besoins.

  • Exploitation complexe d'un cluster : dimensionnement, équilibrage des partitions, surveillance et mises à jour.
  • Courbe d'apprentissage réelle : partitions, offsets, groupes de consommateurs et sémantiques de livraison.
  • Pas d'ordre global : l'ordre n'est garanti qu'au sein d'une partition.
  • Nombre de partitions difficile à corriger : il influence le parallélisme et le réglage initial pèse sur la suite.
  • Moins adapté au routage fin de messages ou aux files de tâches individuelles que les brokers de messages classiques.
  • Surdimensionné pour un faible volume d'événements, où une file simple ou un service managé suffit.

Kafka vs RabbitMQ : quelles différences ?

Kafka et RabbitMQ transportent tous deux des messages, mais ils reposent sur des modèles différents.

CritèreApache KafkaRabbitMQ
ModèleJournal distribué et persistantFile de messages avec routage
Après la lectureLe message reste, selon la rétentionLe message est supprimé après acquittement
RelectureOui, par les offsetsNon, hors fonctionnalités spécifiques
DébitTrès élevé, par partitionnementÉlevé, mais plus limité à grande échelle
RoutageSimple, par topic et par cléRiche, avec échanges et règles de routage
Usage typiqueFlux d'événements, pipelines de donnéesTâches asynchrones, communication entre services

Kafka s'impose pour les flux volumineux, la relecture et le partage d'un même événement entre plusieurs systèmes. RabbitMQ convient mieux à la distribution de tâches individuelles et aux schémas de routage élaborés. Pour gérer la charge d'applications à base d'agents, notre article sur les files d'attente et agents IA illustre le second cas.

Ce n'est pas un choix binaire. Certaines architectures utilisent Kafka pour transporter les événements entre domaines, et une file de tâches pour le travail asynchrone de chaque service.

Bonnes pratiques pour exploiter Kafka

Quelques réflexes évitent la plupart des difficultés :

  • Choisir la clé avec soin : elle détermine la partition, donc l'ordre et la répartition de la charge.
  • Dimensionner les partitions : leur nombre limite le parallélisme des consommateurs et reste difficile à réduire.
  • Répliquer : un facteur de réplication de 3 est courant en production.
  • Concevoir des consommateurs idempotents : un message peut être livré deux fois en cas de reprise.
  • Surveiller le retard (lag) : l'écart entre le dernier offset écrit et celui lu signale un consommateur trop lent.
  • Gérer les schémas : un registre de schémas évite de casser les consommateurs lors d'un changement de format.

Quand utiliser Apache Kafka ?

Le choix de Kafka dépend du volume d'événements, du besoin de relecture et du nombre de systèmes qui consomment les mêmes données.

Pertinent si

Kafka se justifie

  • Les événements arrivent en continu et en grand nombre.
  • Plusieurs applications doivent lire les mêmes données, chacune à son rythme.
  • La relecture de l'historique est un besoin réel.
  • L'équipe peut exploiter un cluster ou recourir à un service managé.
Moins adapté si

Une solution plus simple suffit

  • Le volume est faible et quelques tâches asynchrones suffisent.
  • Le besoin est un routage complexe de messages vers des files de travail.
  • Chaque message doit être traité une fois puis disparaître.
  • L'équipe n'a pas les moyens d'exploiter un système distribué.

Technologies et outils associés à Apache Kafka

Kafka s'intègre à des moteurs de traitement, des bases de données, des orchestrateurs et des plateformes managées.

Les concepts à connaître autour d'Apache Kafka

Ces notions expliquent le comportement de Kafka et les choix de conception d'un pipeline d'événements.

Ressources pour approfondir Apache Kafka

Trois articles du blog Blent pour passer de la définition à la comparaison des outils de messagerie et à leur usage.

Questions fréquentes

Questions fréquentes

Ni tout à fait l'un ni l'autre. Kafka stocke les événements dans un journal durable, comme une base, et les distribue à des consommateurs, comme une file. Mais il ne propose pas de requêtes arbitraires et conserve les messages après leur lecture.

Expertise

À propos de l'auteur

Équipe Blent

Les ingénieurs et mentors Blent conçoivent des plateformes data, industrialisent des pipelines et des modèles en production, et forment chaque année des centaines de professionnels au data engineering et à l'IA.

Sources et méthodologie

  • Documentation officielle Apache Kafka (kafka.apache.org)
  • Kreps, Narkhede, Rao, Kafka: a Distributed Messaging System for Log Processing, NetDB 2011
  • Retours d'expérience des projets et formations Blent
Lexique

Explorer le lexique

Voir toutes les définitions