Comprendre Kafka en 10 Minutes
Qu'est-ce que Kafka ?
Apache Kafka est une plateforme de streaming de donnees distribuee. En termes simples, c'est un systeme qui permet a des applications d'envoyer et de recevoir des messages en temps reel, de maniere fiable et a grande echelle.
L'Analogie du Bureau de Poste
Imaginez Kafka comme un bureau de poste ultra-moderne :
┌─────────────────────────────────────────────────────────────┐
│ BUREAU DE POSTE KAFKA │
├─────────────────────────────────────────────────────────────┤
│ │
│ Expediteurs (Producers) │
│ └─ Les personnes qui envoient des lettres │
│ │
│ Boites aux Lettres (Topics) │
│ └─ Des casiers organises par sujet │
│ (ex: "commandes", "factures", "alertes") │
│ │
│ Destinataires (Consumers) │
│ └─ Les personnes qui recuperent leurs lettres │
│ │
│ Particularite: │
│ └─ Les lettres ne sont PAS supprimees apres lecture! │
│ └─ Plusieurs personnes peuvent lire la meme lettre │
│ └─ On peut relire d'anciennes lettres │
│ │
└─────────────────────────────────────────────────────────────┘
Pourquoi Utiliser Kafka ?
Avant Kafka: Avec Kafka:
App A ──────► App B App A ──┐
App A ──────► App C │
App A ──────► App D ▼
App B ──────► App C ┌─────┐
App B ──────► App E ═══► │KAFKA│
App C ──────► App D └─────┘
App D ──────► App E │
┌───┬───┼───┬───┐
Connexions: N*(N-1) ▼ ▼ ▼ ▼ ▼
= Spaghetti! A B C D E
Connexions: 2*N
= Simple!
Les 5 Concepts Cles
1. Messages (ou Records)
Un message est l'unite de base de Kafka. C'est comme une lettre avec :
┌─────────────────────────────────────┐
│ MESSAGE KAFKA │
├─────────────────────────────────────┤
│ │
│ Key (optionnelle): "user-123" │
│ └─ Identifiant pour le routage │
│ │
│ Value: {"name": "Alice", ...} │
│ └─ Le contenu du message │
│ │
│ Timestamp: 2025-01-05T10:30:00 │
│ └─ Quand le message a ete envoye │
│ │
│ Headers (optionnels) │
│ └─ Metadonnees supplementaires │
│ │
└─────────────────────────────────────┘
2. Topics
Un topic est une categorie ou un flux de messages. Pensez-y comme une chaine YouTube : les producteurs publient des videos (messages), et les abonnes (consumers) les regardent.
Topic: "commandes"
┌────────────────────────────────────────────────┐
│ msg1 │ msg2 │ msg3 │ msg4 │ msg5 │ msg6 │ ... │
└────────────────────────────────────────────────┘
▲ ▲
│ │
Anciens messages Nouveaux messages
3. Partitions
Les topics sont divises en partitions pour la scalabilite. C'est comme avoir plusieurs files d'attente paralleles.
Topic "commandes" avec 3 partitions:
Partition 0: [ msg1 | msg4 | msg7 | msg10 ]
Partition 1: [ msg2 | msg5 | msg8 | msg11 ]
Partition 2: [ msg3 | msg6 | msg9 | msg12 ]
Avantages:
├─ Parallelisme: 3 consumers peuvent lire en meme temps
├─ Scalabilite: Distribue sur plusieurs serveurs
└─ Ordre: Garanti DANS une partition
4. Producers (Producteurs)
Les producers envoient des messages vers Kafka. Ils choisissent dans quelle partition envoyer.
┌─────────────┐
│ PRODUCER │
├─────────────┤
│ │ ┌───────────────┐
│ send() ───┼──────► │ Topic: orders │
│ │ └───────────────┘
└─────────────┘
Strategies de routage:
├─ Avec cle: hash(key) % nb_partitions
│ └─ Meme cle = meme partition (ordre garanti)
└─ Sans cle: Round-robin
└─ Distribution equilibree
5. Consumers (Consommateurs)
Les consumers lisent les messages depuis Kafka. Ils peuvent travailler en groupe.
Consumer Group "order-processors":
┌───────────────────────────────────────────┐
│ Topic "commandes" │
│ ┌──────────┬──────────┬──────────┐ │
│ │Partition0│Partition1│Partition2│ │
│ └────┬─────┴────┬─────┴────┬─────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ Consumer 1 Consumer 2 Consumer 3 │
│ (P0) (P1) (P2) │
└───────────────────────────────────────────┘
Regles importantes:
├─ 1 partition = 1 seul consumer par groupe
├─ 1 consumer peut lire plusieurs partitions
└─ Plusieurs groupes peuvent lire le meme topic
Demarrage Rapide
Installation avec Docker
La facon la plus simple de demarrer :
# Creer un fichier docker-compose.yml
cat > docker-compose.yml << 'EOF'
version: '3'
services:
zookeeper:
image: confluentinc/cp-zookeeper:7.4.0
environment:
ZOOKEEPER_CLIENT_PORT: 2181
kafka:
image: confluentinc/cp-kafka:7.4.0
depends_on:
- zookeeper
ports:
- "9092:9092"
environment:
KAFKA_BROKER_ID: 1
KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092
KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
EOF
# Demarrer Kafka
docker-compose up -d
# Verifier que ca fonctionne
docker-compose logs kafka | grep "started"
Commandes de Base
Creer un topic
# Creer un topic nomme "test" avec 3 partitions
docker exec -it kafka kafka-topics \
--create \
--topic test \
--partitions 3 \
--replication-factor 1 \
--bootstrap-server localhost:9092
Lister les topics
docker exec -it kafka kafka-topics \
--list \
--bootstrap-server localhost:9092
Envoyer des messages (Producer)
# Mode interactif - tapez vos messages
docker exec -it kafka kafka-console-producer \
--topic test \
--bootstrap-server localhost:9092
# Tapez:
# Hello Kafka!
# Mon premier message
# Ctrl+C pour quitter
Lire des messages (Consumer)
# Lire depuis le debut
docker exec -it kafka kafka-console-consumer \
--topic test \
--from-beginning \
--bootstrap-server localhost:9092
# Lire en temps reel (sans --from-beginning)
docker exec -it kafka kafka-console-consumer \
--topic test \
--bootstrap-server localhost:9092
Exemple Pratique : Premier Flux de Donnees
Scenario : Systeme de Commandes
Imaginons un site e-commerce simple :
┌──────────┐ ┌───────────────┐ ┌──────────────┐
│ Site │ │ KAFKA │ │ Service │
│ Web │────►│ Topic:orders │────►│ Traitement │
│ │ │ │ │ │
└──────────┘ └───────────────┘ └──────────────┘
│
│
▼
┌──────────────┐
│ Service │
│ Facturation │
└──────────────┘
Etape 1 : Creer le Topic
docker exec -it kafka kafka-topics \
--create \
--topic orders \
--partitions 3 \
--replication-factor 1 \
--bootstrap-server localhost:9092
Etape 2 : Simuler le Site Web (Producer)
# Terminal 1 : Producer
docker exec -it kafka kafka-console-producer \
--topic orders \
--bootstrap-server localhost:9092
# Envoyez ces commandes (JSON):
{"orderId": "001", "product": "Laptop", "amount": 999}
{"orderId": "002", "product": "Mouse", "amount": 29}
{"orderId": "003", "product": "Keyboard", "amount": 79}
Etape 3 : Simuler les Services (Consumers)
# Terminal 2 : Service de Traitement
docker exec -it kafka kafka-console-consumer \
--topic orders \
--group order-processing \
--from-beginning \
--bootstrap-server localhost:9092
# Terminal 3 : Service de Facturation
docker exec -it kafka kafka-console-consumer \
--topic orders \
--group billing \
--from-beginning \
--bootstrap-server localhost:9092
Les deux services recoivent tous les messages car ils sont dans des groupes differents.
Schema Recapitulatif
┌─────────────────────────────────────────────────────────────────┐
│ KAFKA EN UN COUP D'OEIL │
├─────────────────────────────────────────────────────────────────┤
│ │
│ CLUSTER KAFKA │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Topic: orders │ │
│ │ ┌──────────────────────────────────────────────┐ │ │
│ │ │ P0: [ord1] [ord4] [ord7] │ │ │
│ │ │ P1: [ord2] [ord5] [ord8] │ │ │
│ │ │ P2: [ord3] [ord6] [ord9] │ │ │
│ │ └──────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ Topic: logs │ │
│ │ ┌──────────────────────────────────────────────┐ │ │
│ │ │ P0: [log1] [log2] [log3] [log4] │ │ │
│ │ └──────────────────────────────────────────────┘ │ │
│ │ │ │
│ └────────────────────────────────────────────────────────┘ │
│ │
│ ▲ │ │
│ │ │ │
│ │ WRITE READ │ │
│ │ ▼ │
│ │
│ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐ │
│ │ Producer │ │ Producer │ │ Consumer │ │ Consumer │ │
│ │ (App A) │ │ (App B) │ │ Group A │ │ Group B │ │
│ └───────────┘ └───────────┘ └───────────┘ └───────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
Cas d'Utilisation Courants
1. Messaging entre Microservices
Service ───► Kafka ───► Service
Commandes "orders" Inventaire
2. Collecte de Logs
App 1 ─┐
App 2 ─┼──► Kafka ───► Elasticsearch
App 3 ─┘ "logs"
3. Streaming en Temps Reel
Capteurs IoT ───► Kafka ───► Analytics
"sensor-data"
4. Synchronisation de Donnees
Base de ───► Kafka ───► Data
Donnees "changes" Warehouse
(CDC)
Vocabulaire Essentiel
| Terme | Definition Simple |
|---|---|
| Broker | Un serveur Kafka |
| Cluster | Plusieurs brokers ensemble |
| Topic | Une categorie de messages |
| Partition | Une subdivision d'un topic |
| Offset | La position d'un message dans une partition |
| Producer | Application qui envoie des messages |
| Consumer | Application qui lit des messages |
| Consumer Group | Groupe de consumers qui se partagent le travail |
| Replication | Copie des donnees sur plusieurs brokers |
| ZooKeeper | Service de coordination (bientot remplace par KRaft) |
Points Cles a Retenir
┌─────────────────────────────────────────────────────────────┐
│ 5 POINTS A RETENIR │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. Kafka = File de messages distribuee │
│ └─ Les messages sont stockes et durables │
│ │
│ 2. Topics = Categories de messages │
│ └─ Organisez vos donnees par sujet │
│ │
│ 3. Partitions = Scalabilite │
│ └─ Plus de partitions = plus de parallelisme │
│ │
│ 4. Consumer Groups = Traitement distribue │
│ └─ Partagez la charge entre plusieurs instances │
│ │
│ 5. Messages persistants = Replay possible │
│ └─ Relisez les donnees passees si besoin │
│ │
└─────────────────────────────────────────────────────────────┘
Prochaines Etapes
Maintenant que vous comprenez les bases, voici comment aller plus loin :
- Pratiquez : Creez des topics, envoyez et lisez des messages
- Explorez : Configurez plusieurs consumers dans un groupe
- Approfondissez : Decouvrez les garanties de livraison (at-least-once, exactly-once)
- Produisez : Integrez Kafka dans une vraie application
Ressources Recommandees
- Documentation Officielle Kafka
- Confluent Developer
- Mes autres articles sur Kafka (monitoring, performance, securite)
A Retenir
- Kafka est un systeme de messaging distribue pour le streaming de donnees
- Topics organisent les messages par categorie
- Partitions permettent le parallelisme et la scalabilite
- Producers envoient, Consumers recoivent
- Consumer Groups permettent le traitement distribue
- Les messages sont persistants et rejouables
Vous souhaitez approfondir vos connaissances Kafka ou mettre en place une architecture de streaming ? Contactez-moi pour un accompagnement personnalise.