Technologie

IoT Streaming Analytics mit Kafka, Flink, Druid und Superset

15. Juni 2023

Button Github Button Linkedin


💡 Einleitung

In diesem neuen Blog-Beitrag (und dem zugehörigen GitHub-Repo) präsentieren wir eine Fallstudie eines unserer Kunden aus dem Bereich Internet of Things (IoT). In diesem spezifischen Anwendungsfall möchten wir ein Dashboard erstellen, um schnell Geräte zu identifizieren, deren Verhalten von der gemessenen Norm abweicht. Dies könnten zum Beispiel vernetzte Türen in einer Stadt sein, wobei ein Bereich einen Netzwerkausfall erleidet, der dazu führt, dass alle Türen in diesem Bereich den Zugang verweigern. Mit Streaming Analytics können wir solche Ereignisse sofort erkennen, während sie auftreten, und Nutzer oder den Support über die Dienstunterbrechung informieren.

Das Endprodukt ist ein Dashboard mit Live-Streaming-Analytics. Es sieht wie folgt aus:

Superset Dashboard

Wir verwenden die folgenden Technologien:

  1. Apache Kafka
  2. Apache Flink
  3. Apache Druid
  4. Apache Superset

Die Architektur, mit Apache Kafka als zentralem Nervensystem, ist unten beschrieben.

Kafka, Flink, Druid und Superset Architektur

Wir nutzen Apache Kafka als unser zentrales Datensystem, mit dem alle anderen Dienste interagieren, um Daten entweder zu konsumieren (lesen) oder zu produzieren (schreiben). Druid ist unsere Datenbank, um Kafka-Topics und Analytics-Daten zu ingestieren und zu speichern, und Superset dient als unser BI-Tool für Echtzeit-Dashboards, die Druid abfragen. Flink ist als Stream-Processing-Engine ebenfalls mit dabei und übernimmt zwei Aufgaben:

  1. Echtzeit-Join zwischen zwei Kafka-Topics zur Datenanreicherung.
  2. Alerting-System, das Ereignisse überwacht, über Zeitfenster aggregiert und Alarme an Kafka sendet.

Beachten Sie, dass wir bisher ausschließlich Apache-Technologien einsetzen; das liegt daran, dass wir die Open-Source-Community unterstützen 🤗.

Diese Lösung baut auf unseren früheren Blog-Beiträgen auf, die Sie hier finden:

  1. Kafka 101 Tutorial - Erste Schritte mit Confluent Kafka
  2. Kafka 101 Tutorial - Streaming Analytics mit Apache Flink
  3. Kafka 101 Tutorial - Echtzeit-Dashboarding mit Druid und Superset

🐳 Voraussetzungen

Um dieses Projekt auszuführen, benötigen Sie lediglich minimale Voraussetzungen: Docker und Docker Compose müssen auf Ihrem Computer installiert sein.

Im Detail benötigen Sie:

  1. Docker
  2. Docker Compose zur Orchestrierung der Infrastruktur.
  3. Miniconda, um eine virtuelle Python-Umgebung zu erstellen und die Python-Skripte auszuführen.
  4. Einen Mapbox API-Key, um Kartendaten in Superset anzuzeigen. Erstellen Sie dazu einfach ein kostenloses Konto bei Mapbox; Sie erhalten einen kostenlosen API-Key mit mehr als genug Credits.

Die Versionen, die ich verwendet habe:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

## Docker
docker --version
> Docker version 24.0.2, build cb74dfcd85

## Docker Compose
docker-compose --version
> Docker Compose version 2.18.1

## Conda
conda --version
> conda 22.11.1

## Python
python --version
> Python 3.11.3

Falls Ihre Versionen abweichen, sollte das kein großes Problem sein, solange Sie eventuelle Warnungen oder Fehler selbst beheben können.

🐍 Virtuelle Python-Umgebung

Um alle Python-Abhängigkeiten für die Kafka-Producer und andere Skripte zu installieren, empfehle ich die Verwendung von Miniconda.

Stellen Sie sicher, dass Miniconda installiert ist, sodass der Befehl conda verfügbar ist.

Führen Sie innerhalb des Projektverzeichnisses folgende Befehle aus:

1
2
3
4
5
6
7
8

## Umgebung erstellen
conda create -n <env-name> python=3.11

## Umgebung aktivieren
conda activate <env-name>

## Python-Bibliotheken installieren
pip install -r requirements.txt

Damit sind Sie startklar! Denken Sie daran, die virtuelle Umgebung immer zu aktivieren, wenn Sie Python-Skripte aus diesem Projekt ausführen.

🏭 Infrastruktur

Um alles zu starten, führen Sie einfach das Skript start.sh aus, das die gesamte Infrastruktur für Sie hochfährt.

1
2
3
4
5
6
7
8

## Repo klonen
git clone https://github.com/theodorecurtil/iot_streaming_analytics.git

## In das Verzeichnis wechseln
cd iot_streaming_analytics

## Infrastruktur starten
./start.sh

⚠️ Eventuell müssen Sie das Skript start.sh erst ausführbar machen. Falls nötig, nutzen Sie dazu:

1

chmod +x start.sh

Das Druid Docker-Compose-File benötigt den Namen des Docker-Netzwerks. Sie werden während des start-Skripts danach gefragt. Wenn Sie den Standardnamen nicht geändert haben, lautet er meist <projektverzeichnis>_default, und Sie können einfach Enter drücken.

Das Skript fragt auch nach Ihrem Mapbox API-Key. Falls Sie kein Konto erstellen möchten, geben Sie einfach einen beliebigen Text ein. Alles wird funktionieren, nur die Kartendaten im Superset Dashboard werden fehlen.

An einem Punkt wird das Skript Sie auffordern, die Druid-Datenbank zurückzusetzen und dann die Python-Producer zu starten. Bevor Sie fortfahren, machen Sie den folgenden Check.

⚕️ Sanity Check

Um sicherzustellen, dass alle Dienste laufen (Sie werden sehen, dass mittlerweile viele Docker-Container aktiv sind), besuchen Sie folgende URLs:

  1. Kafka: http://localhost:9021
  2. Flink: http://localhost:18081
  3. Druid: Benutzername druid_system, Passwort password2 http://localhost:8888
  4. Superset: Benutzername admin, Passwort admin http://localhost:8088

Sie sollten etwa dies sehen:

Kafka, Flink, Druid und Superset Benutzeroberflächen

🖼️ Superset Dashboard hochladen

Laden Sie das Dashboard aus dem Verzeichnis ./superset_dashboard/IOT-STREAMING-ANALYTICS.zip in Superset hoch.

Sobald alles läuft, können wir die synthetischen Daten-Producer starten.

⏯️ Kafka Producer starten

Öffnen Sie ein neues Terminalfenster und wechseln Sie in das Verzeichnis producers.

Zuerst senden wir die Gerätedaten (Devices) an den Kafka-Cluster. Die Daten sehen so aus:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

{
    "deviceId": "b90f632f-02a2-475b-a0bd-a4353b26fd84",
    "payload": {
        "location": {
            "countryCode": "CH",
            "region": "Zurich",
            "city": "Zürich",
            "loc": "47.3757424811726,8.529675964932226",
            "timezone": "Europe/Zurich"
        }
    }
}

Nutzen Sie diesen Befehl, um 1000 Gerätedatensätze an Kafka zu senden:

1
2
3

conda activate <env-name>

python producer_devices.py

Sie sollten die Daten bereits im Kafka-Topic und in der Druid-Tabelle DEVICES sehen. Auch das Superset Dashboard sollte die Geräte bereits auf einer Karte von Zürich anzeigen.

Als Nächstes simulieren wir IoT-Ereignisse von den Geräten:

1

python producer_events.py false &

Dies sendet normale Ereignisse (meist accessGranted) als Hintergrundprozess. Nun simulieren wir eine Netzwerkstörung in einem Teil der Stadt (Wiedikon), wo Geräte nur noch accessRejected-Ereignisse senden:

1

python producer_events.py true &

🐿️ Flink Jobs starten

Gehen Sie zurück zum Hauptterminal und drücken Sie Enter, um die Flink-Jobs zu starten.

Das Dashboard sollte nun mehrere Diagramme zeigen, wobei der Bereich der Störung deutlich erkennbar ist, da die Anzahl der accessRejected-Ereignisse dort über einen Zeitraum abnormal hoch war.

☠️ Infrastruktur stoppen

Wenn Sie fertig sind, nutzen Sie das stop.sh Skript, um alles zu beenden:

1
2

## Im Verzeichnis iot_streaming_analytics
./stop.sh

Stellen auch hier sicher, dass das Skript ausführbar ist.

📌 Fazit

In diesem Blog-Beitrag haben wir die Lösung demonstriert, die wir für einen Kunden implementiert haben, um Streaming Analytics und Echtzeit-Einblicke mit Kafka, Flink, Druid und Superset zu generieren.

📝 Hat Ihnen der Beitrag gefallen?

Dann lassen Sie uns in Kontakt treten! Unser Engineering-Team wird sich so schnell wie möglich bei Ihnen melden.