Architecture Streaming-First - Démo Techtalk PMU

Présentation et démo d'une architecture de données streaming-first comparée aux architectures traditionnelles à base d'échanges de fichiers quotidiens.

🎯 Objectifs

Démontrer les avantages d'une architecture streaming-first pour :

• Réduire la latence des données (de J+1 à temps réel)
• Améliorer la qualité et la fraîcheur des données
• Éliminer les désynchronisations entre backends
• Optimiser l'expérience client et les opérations métier

🏗️ Architecture

CSV Files ──→ [CSV-to-Kafka Producer] ──┐
                                         ├──→ Kafka (Avro) ──→ ClickHouse ──→ Superset
Random Data → [Streaming Producer] ─────┘           ↓
                                            Schema Registry

Stack Technologique

• Apache Kafka : Broker de messages distribué
• Schema Registry : Gestion des schémas Avro (format obligatoire)
• Producteurs Avro :
  • CSV-to-Kafka Producer : Lecture de fichiers et envoi en Avro
  • Streaming Producer : Génération temps réel et envoi en Avro
• Apache Flink : Stream processing (transformations, jointures, agrégations)
• ClickHouse : Data warehouse OLAP temps réel (lecture Avro native)
• Apache Superset : Business Intelligence et analytics
• Kafka UI : Interface de monitoring Kafka

⚠️ Format Avro Obligatoire

Toutes les données dans Kafka sont obligatoirement en format Avro avec enregistrement des schémas dans Schema Registry. ClickHouse est configuré pour lire directement en AvroConfluent.

📖 Documentation complète : Voir AVRO_PRODUCERS.md

🚀 Démarrage Rapide

Prérequis

• Docker & Docker Compose
• 8GB RAM minimum
• Ports disponibles : 8080, 8081, 8083, 8088, 9092, 3000, 2181

Lancer la démo

# Démarrer tous les services
docker-compose up -d

# Vérifier que tous les services sont démarrés
docker-compose ps

# Suivre les logs
docker-compose logs -f

Vérifier que les données sont en Avro

# Exécuter le script de vérification
./verify-avro.sh

Ce script vérifie :

• ✅ Que Schema Registry enregistre les schémas Avro
• ✅ Que les producteurs envoient en Avro
• ✅ Que ClickHouse lit en format AvroConfluent
• ✅ Que les données arrivent correctement

Initialiser Superset

# Accéder au conteneur Superset
docker exec -it superset bash

# Exécuter le script d'initialisation
/app/docker/init-superset.sh

# Sortir du conteneur
exit

Accès aux interfaces

• Présentation Slidev : http://localhost:3030
• Superset (BI) : http://localhost:8088 (admin/admin)
• Kafka UI : http://localhost:8080
• Flink Dashboard : http://localhost:8088
• ClickHouse : http://localhost:8123

📊 Configuration Superset

1. Ajouter la source de données ClickHouse

1. Se connecter à Superset (admin/admin)
2. Settings → Database Connections → + Database
3. Sélectionner "ClickHouse"
4. Configuration :

   Host: clickhouse
   Port: 8123
   Database: streaming_demo
   Username: admin
   Password: admin
   

2. Créer des datasets

Datasets disponibles :

• bets : Paris en temps réel
• customers : Données clients
• events : Événements sportifs
• bets_by_sport_mv : Agrégations par sport (vue matérialisée)
• top_customers_mv : Top clients (vue matérialisée)
• event_stats_mv : Statistiques par événement

3. Exemples de requêtes SQL

-- Volume de paris par sport (dernière heure)
SELECT 
    sport,
    count() as bet_count,
    sum(amount) as total_amount,
    avg(odds) as avg_odds
FROM bets
WHERE timestamp >= now() - INTERVAL 1 HOUR
GROUP BY sport
ORDER BY total_amount DESC;

-- Top 10 clients par montant parié
SELECT 
    customer_id,
    count() as bet_count,
    sum(amount) as total_wagered,
    avg(amount) as avg_bet
FROM bets
GROUP BY customer_id
ORDER BY total_wagered DESC
LIMIT 10;

-- Évolution des paris par fenêtre de 5 minutes
SELECT 
    toStartOfFiveMinute(timestamp) as window,
    count() as bets,
    sum(amount) as volume
FROM bets
WHERE timestamp >= now() - INTERVAL 1 HOUR
GROUP BY window
ORDER BY window;

📈 Cas d'usage de la démo

Simulation de paris sportifs

Le générateur de fichiers simule :

• Fichiers CSV de paris : Toutes les 15 secondes
• Fichiers JSON de clients : Toutes les 25 secondes
• Fichiers JSON de cotes : Toutes les 35 secondes

Flux de données

1. Ingestion : Kafka Connect surveille /data/input et ingère les fichiers
2. Streaming : Les données sont publiées dans Kafka
3. Processing : Flink transforme et enrichit les données
4. Storage : ClickHouse ingère en streaming via Kafka Engine
5. Analytics : Superset permet l'exploration OLAP

🎓 Présentation Slidev

Lancer la présentation

# Installer les dépendances
npm install

# Démarrer Slidev
npm run dev

# Build pour production
npm run build

✨ Nouveauté : Slide Dynamique avec ClickHouse

La présentation contient une slide interactive qui interroge ClickHouse en temps réel !

Composant LiveClickHouseStats.vue

Juste après la slide "Démo Time!", une slide affiche :

• 📊 KPIs temps réel : nombre de paris, montants, moyennes
• 🏆 Top 5 sports avec graphiques animés
• 📈 Statistiques live : taux d'acceptation, débit, derniers paris
• 🔄 Rafraîchissement auto : données mises à jour toutes les 3 secondes
• ✨ Animations : flash sur nouveaux paris, transitions fluides

Tester le composant :

# 1. Démarrer l'architecture
docker-compose up -d

# 2. Attendre 30-60 secondes que les données arrivent

# 3. Tester l'API ClickHouse
./test-clickhouse-api.sh

# 4. Lancer Slidev
npm run dev

# 5. Naviguer vers la slide après "Démo Time!"

📖 Documentation complète : components/README.md

Structure de la présentation

1. Introduction : Contexte et objectifs
2. Architectures batch : Description et problématiques
3. Problématiques métier : Impacts concrets
4. Streaming-First : Principes et architecture
5. Comparaison : Tableau batch vs streaming
6. Démo : Architecture type et mise en pratique
7. ✨ Stats Temps Réel : Visualisation live depuis ClickHouse (nouveau !)

🛠️ Commandes utiles

Docker

# Arrêter tous les services
docker-compose down

# Arrêter et supprimer les volumes (reset complet)
docker-compose down -v

# Redémarrer un service spécifique
docker-compose restart kafka

# Voir les logs d'un service
docker-compose logs -f file-generator

Kafka

# Lister les topics
docker exec kafka kafka-topics --bootstrap-server localhost:9092 --list

# Consommer un topic
docker exec kafka kafka-console-consumer \
  --bootstrap-server localhost:9092 \
  --topic bets \
  --from-beginning

# Créer un topic manuellement
docker exec kafka kafka-topics \
  --bootstrap-server localhost:9092 \
  --create \
  --topic test \
  --partitions 3 \
  --replication-factor 1

ClickHouse

# Se connecter au client ClickHouse
docker exec -it clickhouse clickhouse-client

# Exécuter une requête
docker exec clickhouse clickhouse-client --query "SELECT count() FROM streaming_demo.bets"

📊 Métriques de performance

Latence

• Batch traditionnel : 24h - 7 jours
• Streaming-First : < 1 seconde

Throughput

• Kafka : 1M+ messages/sec
• Flink : 100K+ events/sec/core
• ClickHouse : 1M+ rows/sec ingestion

🔧 Troubleshooting

Les services ne démarrent pas

# Vérifier les logs
docker-compose logs

# Vérifier l'espace disque
df -h

# Vérifier la mémoire
docker stats

Kafka Connect ne trouve pas les fichiers

# Vérifier les permissions
ls -la data/input/

# Vérifier le montage du volume
docker exec kafka-connect ls -la /data/input/

ClickHouse n'ingère pas les données

# Vérifier la table Kafka
docker exec clickhouse clickhouse-client --query "SELECT * FROM streaming_demo.bets_kafka_queue LIMIT 10"

# Vérifier les erreurs
docker-compose logs clickhouse

📚 Ressources

• Apache Kafka Documentation
• Apache Flink Documentation
• ClickHouse Documentation
• Apache Superset Documentation
• Slidev Documentation

🤝 Contribution

Cette démo est conçue pour un techtalk. N'hésitez pas à l'adapter à vos besoins.

📝 License

MIT