Comment j'ai branché Twitter avec mon Splunk

Table des matières

Dans ce billet, je partage un exemple d’application concret des technologies Kafka et Splunk mais surtout de leurs synergies.

Grâce à ces deux briques, je vais pouvoir analyser un flux temps réel de tweets.

Un visuel sera beaucoup plus parlant !

alt

Le scénario appliqué ici génère environ 20 événements par seconde, ce volume est dérisoire au regard des capacités de montée en charge…

Nous verrons qu’il est possible de faire un passage à l’échelle plutôt sympathique en multipliant par 5000 le volume des données traitées !

L’infrastructure

S’agissant d’une maquette, Vagrant est tout indiqué pour instancier l’environnement !

alt
  1. Vagrant prépare deux machines virtuelles sous Virtual Box.
  2. Vagrant provisionne les machines à l’aide de recettes Ansible.
alt

Le playbook regroupe l’ensemble des paramètres qui seront appliqués dans mes recettes :

alt

L’ingestion des données

Ma source d’information est Twitter qui met à disposition une API pour s’abonner à un flux de Tweet filtrés.

Grâce à la librairie Python tweepy je développe rapidement une passerelle Twitter vers Kafka.

#!/usr/bin/python3
from tweepy.streaming import StreamListener
from tweepy import OAuthHandler
from tweepy import Stream
from tweepy import API
import json,configparser
from kafka import KafkaProducer

class TweetListener(StreamListener):

  def on_data(self, data):

    try:
        producer.send('maquette', data.encode("utf-8"))
    except KeyError as msg:
        print(msg)
    return True

  def on_error(self, status):
    print(status)
    return True

if __name__ == '__main__':

  languages=None
  keywords=None
  filter_level=None
  keywords = ['#corona','#coronavirus','#covid','#StayAtHome','#stayhome', '#covid19','#covid2019']
  config = configparser.ConfigParser()
  config.read('config.ini')
  producer = KafkaProducer(bootstrap_servers='relai:9092')
  listener = TweetListener()
  auth = OAuthHandler(config['TwitterAPI']['key'], config['TwitterAPI']['secret'])
  auth.set_access_token(config['TwitterAPI']['token'], config['TwitterAPI']['token_secret'])
  api = API(auth, wait_on_rate_limit=True,
  wait_on_rate_limit_notify=True)
  try:
     stream = Stream(auth, listener)
     stream.filter(track=keywords,languages=languages,filter_level=filter_level)
  except KeyboardInterrupt:
     print("Stopped.")
  finally:
     print('Done.')
     stream.disconnect()

Je confirme le bon fonctionnement à l’aide de Kafkacat.

alt

Pour résumer, l’information est publiée à l’aide du producteur Python et collectée en temps réel à l’aide du consommateur kafkacat.

Interconnexion avec Splunk

Afin de transmettre les informations vers Splunk, j’utilise le projet opensource Kafka-Connect-Splunk.

Ce type de consommateur se place naturellement dans la logique de microService.

De là à le placer dans un cluster Kubernetes, il n’y a qu’un pas…

Le prochain prototype pourrait être intégré en environnement VMWARE grâce au projet Tanzu

alt

Le schéma de flux devient alors le suivant :

alt

Concrètement le connecteur va s’inscrire en consommateur du topic maquette, les messages seront ensuite envoyés sur l’entrée de donnée HTTP Event Collector de Splunk.

Les données étant nativement formatées en JSON, l’indexation est simplifiée.

alt

Visualisation sous Splunk

Les données peuvent être ensuite consultées en temps réel sous Splunk.

Sur base des critères de filtrage, une vingtaine de tweets à la seconde sont indexés.

alt

Montée en charge

Afin d’évaluer le passage à l’échelle, j’utilise le projet opensource kafka-data-gen qui permet de générer des événements aléatoires.

Un évènement se matérialise sous la forme d’un message JSON.

alt

A l’aide de cet outil, je génère 2 millions de messages à une cadence de 100 000 évenements par seconde.

java -jar kafka-data-gen.jar -message-count 2000000 -message-size 256 \
-topic maquette -bootstrap.servers "relai:9092" -acks all -kafka-retries 0 \
-kafka-batch-size 60000 -kafka-linger 1 -kafka-buffer-memory 33554432 \
-eps 100000 -output-kafka=true -output-eventhubs=false

Les statistiques de consommation augmentent de façon conséquente … sans pertes …

alt

Perspective

Cette maquette offre de belles possibilités pour réaliser sa veille sur Twitter : OSINT, suivi des fuites de données, de vulnérabilités …

Le moteur de Splunk permet de construire des corrélations complexes et de déclencher d’autres workflow.

Au delà de Twitter, il est bien évidemment possible d’injecter tout type de données

Journaux systèmes, de firewall ou encore d’EDR comme SentinelOne.

Les possibilités sont sans limites !

Related