Kafka Streams & traitement des données

Contexte

Kafka Streams est une bibliothèque Java légère qui permet de traiter les messages en continu directement dans vos microservices, sans cluster externe (contrairement à Spark ou Flink).

Elle repose sur 4 grands principes :

• scalabilité native via le partitionnement Kafka,
• state stores locaux (RocksDB),
• exactly-once processing garantissant l’unicité des résultats,
• topologies de transformations composables.

Kafka Streams est aujourd’hui utilisé pour :

• le scoring en temps réel,
• la transformation d’événements (ETL streaming),
• l’orchestration de workflow,
• la détection de fraude,
• l’enrichissement de flux.

Lexique

Diagramme

Exemple d’une topologie : lecture → filtrage → enrichissement → branchement → écriture vers plusieurs topics.

Exemple complet Kafka Streams (Java)

Properties props = new Properties();
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "traitement-commandes");
props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
props.put(StreamsConfig.PROCESSING_GUARANTEE_CONFIG, 
          StreamsConfig.EXACTLY_ONCE_V2);
props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");

StreamsBuilder builder = new StreamsBuilder();
KStream commandes = builder.stream("commandes.ecommerce");

// Transformation : filer commandes > 100€
KStream highValue = commandes
  .filter((key, value) -> extractMontant(value) > 100);

// Output vers un topic dédié
highValue.to("commandes.valeurs");

KafkaStreams streams = new KafkaStreams(builder.build(), props);
streams.start();
    

Ici, nous activons le mode exactly-once v2 : Kafka Streams gère automatiquement les transactions, les commits et la synchronisation des state stores.

State Stores : RocksDB et gestion de l’état

Les opérations suivantes utilisent un state store interne :

• groupBy → count(), reduce(), aggregate()
• windowing (time windows)
• joins KStream/KTable
• KTable matérialisée (compactée)

Kafka Streams utilise RocksDB en local, synchronisé via changelog topics.

Avantages :

• latence faible
• persistance locale
• récupération automatique après crash

Repartitions internes :

Si une opération nécessite un regroupement par clé, Kafka Streams crée automatiquement un repartition topic.

Contenu réservé — connectez-vous.

Joins en Kafka Streams

KStream → KStream

Join sur une fenêtre temporelle (ex : corréler paiements & commandes).

KStream → KTable

Enrichissement classique (ex : ajouter données client à une commande).

KTable → KTable

Join d’état (ex : fusionner inventaire et prix produits).

Exemple :

KTable clients = builder.table("clients");
KStream commandes = builder.stream("commandes");

KStream enrichies =
  commandes.join(
    clients,
    (commande, client) -> new CommandeEnrichie(commande, client)
  );
    

Fenêtrage (Windowing)

Kafka Streams propose 3 types de fenêtres :

• Tumbling : fenêtres fixes non superposées
• Hopping : fenêtres glissantes
• Sliding : fenêtres dynamiques (plus coûteuses)

commandes.groupByKey()
  .windowedBy(TimeWindows.ofSizeAndGrace(Duration.ofMinutes(5),
                                         Duration.ofMinutes(1)))
  .count()
  .toStream()
  .to("commandes.stats");
    

Résultat

Vous savez maintenant créer une topologie Kafka Streams complète, gérer l’état, effectuer des joins, appliquer des fenêtres et garantir l’exactly-once processing.

Résumé

Kafka Streams est l’un des outils les plus puissants pour traiter des données en temps réel sans déployer d’infrastructure complexe. Il s’appuie sur Kafka pour la tolérance aux pannes, la scalabilité et la gestion de l’état distribué.

Exercice pratique

• Lire les commandes du topic commandes.ecommerce.
• Filtrer les commandes “expédiées”.
• Les envoyer dans commandes.expediees.
• Ajouter un join avec une KTable “clients”.
• Vérifier le résultat avec un consumer.

Ateliers techniques

Atelier 1 – Pipeline complet de transformation

• Création d’une topologie filtrage → enrichissement → branchement.
• Production de metrics via streams.metadataForLocalThreads().
• Monitoring du pipeline via JMX.

Atelier 2 – Agrégations et fenêtrage

• Exécution d’une agrégation par fenêtre de 5 minutes.
• Publication sur un topic analytique.
• Test de résilience (kill -9 du service).

Atelier 3 – Architecture “Stateful Microservice”

• Utilisation d’un store local RocksDB.
• Visualisation du changelog sur Kafka.
• Migration du state store sans perte.