Tweetoscope25_GROUP-6_MARCHESINI_DEBOSCHERE_GIRAUD

Vidéo du projet

Lien vers la vidéo (filesender) : Lien vidéo

Rapport complet du projet

📘 Rapport complet : rapport.pdf

Rappel fonctionnement de la pipeline :

• ReplayerProducer lit un fichier (largeTestBase.txt), produit chaque tweet dans tweets.raw (clé = tweetId, valeur = JSON du tweet).

• FilterService consomme tweets.raw, applique un filtre simple (lang=en et ≥2 mots), republie les tweets retenus dans tweets.filtered.

• ExtractorService consomme tweets.filtered, extrait tous les hashtags par regex, et envoie chaque hashtag (clé=hashtag, valeur=hashtag) dans hashtags.

• CounterStreams (Kafka Streams) regroupe (groupByKey) par hashtag et compte via count() → émet les mises à jour dans counts (clé=hashtag, valeur=Long).

• VisualizerService consomme counts, maintient un dictionnaire clé→compte et affiche un Top-K en console.

Tweetoscope – Pipeline Kafka (Kubernetes)

Prérequis

• Accès SSH à la machine du cluster (kubectl est sur le serveur, pas en local).

• Un alias kns qui pointe sur kubectl.

• Image encore disponible sur Docker Hub : valentincentrale/tweetoscope-app:latest. (normalement oui)

• Namespace de travail (sur student29 : student29-ns).

• Avoir copié les manifests (uniquement eux !) et s'être connecté en ssh :

scp -r k8s student29@mfspc1:~/tweetoscope/

• Une fois sur le serveur :

cd ~/tweetoscope
export NS=student29-ns
alias kns='kubectl -n student29-ns'

Lancer la stack

• Kafka

kns -n "$NS" apply -f k8s/kafka.yaml
kns -n "$NS" rollout status deploy/kafka

• Créer les topics

kns -n "$NS" apply -f k8s/topics-job.yaml
kns -n "$NS" logs job/topics-init -f

• Déployer les 4 apps

kns -n "$NS" apply -f k8s/apps.yaml

• Déployer le replayer (début de la partie traitement de données)

kns -n "$NS" apply  -f k8s/replayer-job.yaml

Observer

• Dans 7 terminaux :

kns -n "$NS" logs -f deploy/kafka
kns -n "$NS" logs -f -l job-name=replayer
kns -n "$NS" logs deploy/filter -f
kns -n "$NS" logs deploy/extractor -f
kns -n "$NS" logs deploy/counter -f
kns -n "$NS" logs deploy/visualizer -f

• tuer un pod :

kns -n "$NS" delete pod -l app=extractor

• arrêter temporairement un composant :

kns -n "$NS" scale deploy/visualizer --replicas=0
kns -n "$NS" scale deploy/visualizer --replicas=1

• relancer le replayer (1 des 2):

kns -n "$NS" delete job/replayer && kns -n "$NS" apply -f k8s/replayer-job.yaml

Tout arrêter proprement

• Arrêter les apps :

kns -n "$NS" delete -f k8s/apps.yaml

• Arrêter le job de topics :

kns -n "$NS" delete -f k8s/topics-job.yaml

• Arrêter Kafka :

kns -n "$NS" delete -f k8s/kafka.yaml

Tweetoscope – Pipeline Kafka (Docker Compose)

Prérequis

• Docker installé (+ docker compose si jamais c'est pas inclu mais normalement c'est le cas avec les dernières versions de docker).

• Accès réseau pour tirer l’image confluentinc/cp-kafka:7.6.1

Lancer la stack (depuis la racine du repo)

# (1) construire l'image applicative (compile binaire et dépendances, tout est dans le docker)
docker compose build app-base

# (2) démarrer Kafka (KRaft) et attendre qu'il soit ok
docker compose up -d kafka
docker compose logs -f kafka   # attendre "Kafka Server started"

# (3) créer les topics
docker compose up --abort-on-container-exit topics-init

# (4) démarrer la pipeline
docker compose up replayer filter extractor counter visualizer

Voir les logs

Dans des terminaux séparés :

docker compose logs -f replayer
docker compose logs -f filter
docker compose logs -f extractor
docker compose logs -f counter
docker compose logs -f visualizer

Si besoin : Pour sniffer un topic directement depuis le conteneur Kafka (ex : counts) :

docker compose exec kafka bash -lc \
'kafka-console-consumer --bootstrap-server kafka:9092 --topic counts --from-beginning \
 --property print.key=true \
 --property value.deserializer=org.apache.kafka.common.serialization.LongDeserializer \
 --timeout-ms 5000'

Relancer/observer à nouveau

• Relancer uniquement l’injection : docker compose restart replayer

• Tout rejouer depuis le début (topics vides, offsets remis à zéro) : docker compose down -v && docker compose up --build

• Rejouer depuis le début sans supprimer les volumes en réinitialisant les offsets de groupe :

docker compose exec kafka bash -lc \
'kafka-consumer-groups --bootstrap-server kafka:9092 --group filter-service --reset-offsets --to-earliest --topic tweets.raw --execute'
docker compose exec kafka bash -lc \
'kafka-consumer-groups --bootstrap-server kafka:9092 --group extractor-service --reset-offsets --to-earliest --topic tweets.filtered --execute'
docker compose exec kafka bash -lc \
'kafka-consumer-groups --bootstrap-server kafka:9092 --group hashtag-counter --reset-offsets --to-earliest --topic hashtags --execute'

Puis relancer replayer ou renvoyer des messages.

Fichier source

Fichier de relecture : par défaut on lance le replayer sur /data/largeTestBase.txt

TODO : faire en sorte qu'on puisse relancer en ligne de commande peut se modifier sinon dans docker-compose.yml :

replayer:
  command: ["java","-cp","/app/app.jar:/app/dependency/*","tweetoscope.kafka.ReplayerProducer","/data/miniTestBase.txt"]

Puis il faut relancer : docker compose up replayer

Autres changements

Si on veut changer les filtres (langue, nb de mots mini, etc) : ces paramètres sont codés en constantes dans FilterService pour l'instant. Toute modification du code java nécessite une recompilation :

docker compose build app-base
docker compose up filter

Arrêter proprement pour pas planter votre PC

• Arrêter seulement les apps :

docker compose stop replayer filter extractor counter visualizer

• Arrêter tout (Kafka inclus) en conservant les données :

docker compose down

• Arrêter tout en supprimant les données (topics/offsets/état Streams) :

docker compose down -v

Vérification de la qualité du code via SonarQube

Lien vers la page SonarQube : lien