Skip to content

iotkitv3/edge

BranchesTags

Repository files navigation

Internet of Things – Machine Learning Fast Data Pipeline mit Docker/Kubernetes

⇧ Home

Bei dieser Fast Data Pipeline werden

  • Sensordaten (Temperatur) von einen IoT Gerät erhoben und
  • weitergerreicht (Publish) an einem Raspberry Pi (Edge) mit MQTT Broker
  • der Low-Code Service Node-RED holt diese Daten (Subscribe)
    • wandelt diese nach HTTP (REST) für die Prozess Workflow Engine (BPMN) und
    • reicht sie an ein Hochverfügbares Messaging System (Kafka) weiter für Verarbeitungen wie Maschine Learning.

Dabei kommen folgende Technologien/Produkte zum Einsatz:

Installation und Konfiguration

Internet of Things (IoTKitV3)

  • MQTTPublish Beispiel in mbed Studio importieren und ca. auf Zeile 21 den hostname mit der IP-Adresse auswechseln wo der Mosquitto Server läuft.
  • Programm Compilieren und auf Board laden.

Wenn alles eingerichtet ist, können die Sensordaten via Jupyter Notebooks verarbeitet werden.

Wird ein Magnet an den Hall Sensor gehalten, wird ein BPMN Prozess gestartet.

Je nach Board können auch weitere Daten wie

  • das Drücken des Buttons
  • das Drehen des Encoders
  • das lesen einer NFC Karte ausgewertet werden.

Für Details siehe das MQTTPublish Beispielprogramm.

Edge (Raspberry Pi)

Raspberry Pi 2 oder 3 als Edge aufsetzen

Der Raspberry Pi (2, 3) eignet sich als Edge.

Dazu ist der Raspbery Pi (2, 3) wie folgt aufzusetzen:

  • Raspbian Lite wie auf raspberrypi.org beschrieben, downloaden und auf SD Karte speichern.
  • Auf der SD Karte eine Datei «ssh» ohne Endung erstellen.
  • Auf Windows Git/Bash oder Putty o.ä. installieren. Mac und Linux brauchen nur Git.
  • Raspberry Pi via Kabel mit dem Router LERNKUBE verbinden und via ssh Verbinden
  • mosquitto und Node-RED manuell Installieren, wie auf den entsprechenden Produktseiten beschrieben.

Raspberry Pi 4 als Edge aufsetzen

Der Raspberry Pi 4 hat mehr Leistung, deshalb lohnt es sich eine Kubernetes Umgebung einzurichten.

Dazu verwenden wir Ubuntu Server für ARM 64bit. Eine ausführliche Anleitung gibt es hier.

Anschliessend erfolgt die Installation von der Ubuntu Kubernetes Distribution microk8s. Eine ausführliche Anleitung gibt es hier.

Nach der Installation der benötigten Grundinfrastruktur können wir loslegen und die eigentliche Software als Container starten.

Wir verwenden wie im Workflow Beispiel Node-RED und Mosquitto und bauen das Beispiel dann Stück für Stück aus.

# IoT Umgebung 
kubectl apply -f https://raw.githubusercontent.com/mc-b/duk/master/iot/mosquitto-arm64.yaml
kubectl apply -f https://raw.githubusercontent.com/mc-b/duk/master/iot/nodered-arm64.yaml

Der Mosquitto Broker ist auf Port 31883 (nur MQTT-Protokoll, kein UI) und Node-Red auf Port 32600 verfügbar.

Cloud Umgebung

Variante a) lernMAAS mit ModTec Umgebung

In einer lernMAAS Umgebung ist eine VM mit Namen modtec-XX (XX = Hostanteil für VPN) zu erstellen und auf dem lokalen Notebook kann die Umgebung vom ModTec Kurs verwendet werden.

Bei beiden Umgebungen sind alle benötigten Services wie Camunda, Node-RED, Kafka etc. bereits gestartet.

Evtl. muss der BPMN Prozess noch veröffentlicht werden.

Variante b) Cloud und Cloud-init

Erstellen Sie einen Account für die AWS oder Azure Cloud.

Erstellen Sie eine neue Virtuelle Maschine mit min. 2 CPUs, 4 GB RAM. Als Betriebsystem nehmen Sie Ubuntu ab der Version 18.04.

Im Feld custom data o.ä. füllen Sie folgende Cloud-init Konfiguration ein:

#cloud-config
users:
  - name: ubuntu
    sudo: ALL=(ALL) NOPASSWD:ALL
    groups: users, admin
    home: /home/ubuntu
    shell: /bin/bash
    lock_passwd: false
    plain_text_passwd: 'password'        
# login ssh and console with password
ssh_pwauth: true
disable_root: false    
packages:
  - unzip
runcmd:
  - sudo snap install microk8s --classic
  - sudo usermod -a -G microk8s ubuntu
  - sudo microk8s enable dns ingress
  - sudo mkdir -p /home/ubuntu/.kube
  - sudo microk8s config >/home/ubuntu/.kube/config
  - sudo chown -f -R ubuntu /home/ubuntu/.kube
  - sudo snap install kubectl --classic
  - sudo mkdir /data
  - sudo microk8s kubectl apply -f https://raw.githubusercontent.com/mc-b/lernkube/master/data/DataVolume.yaml
  - sudo microk8s kubectl apply -f https://raw.githubusercontent.com/mc-b/duk/master/addons/dashboard-skip-login-no-ingress.yaml
  - (cd /tmp; git clone https://github.com/mc-b/mlg; cd mlg; microk8s kubectl apply -f jupyter/jupyter-mlg.yaml; cp -rpv data/* /data/ )
  - sudo microk8s kubectl apply -f https://raw.githubusercontent.com/mc-b/duk/master/iot/mosquitto.yaml
  - sudo microk8s kubectl apply -f https://raw.githubusercontent.com/mc-b/duk/master/kafka/zookeeper.yaml
  - sudo microk8s kubectl apply -f https://raw.githubusercontent.com/mc-b/duk/master/kafka/kafka.yaml
  - sudo microk8s kubectl apply -f https://raw.githubusercontent.com/mc-b/iot.kafka/master/iot-kafka-alert.yaml
  - sudo microk8s kubectl apply -f https://raw.githubusercontent.com/mc-b/iot.kafka/master/iot-kafka-consumer.yaml
  - sudo microk8s kubectl apply -f https://raw.githubusercontent.com/mc-b/iot.kafka/master/iot-kafka-pipe.yaml
  - sudo microk8s kubectl apply -f https://raw.githubusercontent.com/mc-b/duk/master/iot/nodered-kafka.yaml
  - sudo microk8s kubectl apply -f https://raw.githubusercontent.com/mc-b/misegr/master/bpmn/camunda.yaml
  - sudo apt-get update  
  - sudo apt-get install -y mosquitto-clients curl git unzip
  - sudo chmod -R o=u,g=u /data  
  - sudo chmod 777 /data

Nach erfolgreicher Installation sind folgende Services verfügbar:

ACHTUNG: das ist eine Lernumgebung, werden die Ports gegen das gesamte Internet geöffnet ist die VM ungeschützt im Internet. Ports nur für eigene IP-Adresse (Router) öffnen.

Hinweis: Statt die VM über das Cloud UI zu Erstellen, kann auch das CLI der Cloud Anbieter verwendet werden. Dazu erstellt man eine Datei cloud-init.cfg und fügt obigen Inhalt in die Datei. Die weiteren Befehle stehen hier.

Veröffentlichung des BPMN Prozesses

Die Pipeline braucht einen vorbereitenden BPMN Prozess. Diesen können Sie über das Juypter Notebook http://[ip vm]:32088/notebooks/Microservices-BPMN-microk8s.ipynb veröffentlichen.

Node-RED (MQTT - nach HTTP/REST)

Die MQTT Messages vom IoTKit Board sollen vom MQTT Protokoll in das HTTP/REST Protokoll umgewandelt werden.

Um dies zu Demonstrieren erstellen wir eine Input MQTT Node welche das Topic iotkit/alert empfängt, eine Node welche eine JSON Struktur erzeugt und eine Node welche die JSON Daten via HTTP/REST an die BPMN Workflow Umgebung weiterleitet.

  • In Node-RED
    • mqtt Input Node auf Flow 1 platzieren, mit Mosquitto Server verbinden und als Topic iotkit/alert eintragen.
    • debug Output Node auf Flow 1 platzieren und mit Input Node verbinden - damit können wir die MQTT Messages kontrollieren
    • change Node auf Flow 1 platzieren und als msg.payload folgenden JSON String {"variables":{"rnr":{"value":"123","type":"long"},"rbetrag":{"value":"200.00","type":"String"}}} eintragen.
    • http request Node auf Flow 1 platzieren, als Methode POST und als URL http://camunda:8080/engine-rest/process-definition/key/RechnungStep3/start eintragen
    • Zur Kontrolle ebenfalls eine debug noch hinten platzieren.
    • Alle Nodes wie oben in der Grafik verbinden und veröffentlichen (deploy).
  • In Camunda BPMN Workflow Engine https://localhost:30443/camunda (URL kann abweichen, je nach Umgebung) einloggen mittels User/Password demo/demo. Bei jedem Alarm welcher vom Board (Hall Sensor) mittels Magneten ausgelöst wird, sollte ein neuer Rechnungsprozess gestartet werden.

Details zum BPMN Prozess und der URL wie ein Prozess gestartet werden kann steht im Frontend Beispiel bei $.post.

Der Flow zum importieren und anpassen, siehe Node-RED-REST.json.

Node-RED (MQTT - Kafka Messaging)

Die MQTT Messages sollen nun an Apache Kafka weitergeleitet werden. Das hat den Vorteil, dass wir diese

  • in andere Formate, z.B. von Binär nach JSON, umwandeln können
  • sie Persistieren können
  • ein Eventlog erhalten
  • etc.

Um Apache Kafka anzusprechen brauchen wir ein paar zusätzliche Plugins.

Diese können in Node-RED mittels Pulldownmenu rechts -> Palette verwalten, Tab Installieren hinzugefügt werden. Es handelt es sich um die Plugins:

  • node-red-contrib-kafka-node-latest - mindestens Version 0.2
  • node-red-contrib-kafka-manager - letzte Version

Dadurch erhalten wird neu Nodes für die Integration mit Apache Kafka.

  • In Node-RED
    • mqtt Input Node auf Flow 1 platzieren, mit Mosquitto Server verbinden, als Topic iotkit/# und bei Output a String eintragen.
    • debug Output Node auf Flow 1 platzieren und mit Input Node verbinden - damit können wir die MQTT Messages kontrollieren
    • change Node auf Flow 1 platzieren und als Regel Ändern Wert msg.topic von iotkit/alert in broker_message, weitere Regel hinzufügen und gleich verfahren für iotkit/sensor nach broker_message.
    • Kafka Producer auf Flow 1 platzieren und mit Kafka Server (kafka:9092) verbinden
    • Alle Nodes wie oben in der Grafik verbinden und veröffentlichen (deploy).
  • Kubernetes
    • Neben Kafka wurden drei Microservices, iot-kafka-alert (Weiterleitung iotkit/alert Topic an Camunda), iot-kafka-consumer (Schreiben der Sensordaten nach /data/ml-data.csv) und iot-kafka-pipe (Umwandeln der Sensordaten ins JSON Format), gestartet.
    • Das Ergebnis kann mittels kubectl logs deployment/iot-.... angeschaut werden.
    kubectl logs deployment/iot-kafka-alert
    kubectl logs deployment/iot-kafka-consumer
    kubectl logs deployment/iot-kafka-pipe
  • In Camunda BPMN Workflow Engine https://localhost:30443/camunda (URL kann abweichen, je nach Umgebung) einloggen mittels User/Password demo/demo. Bei jedem Alarm welcher vom Board (Hall Sensor) mittels Magneten ausgelöst wird, sollte ein neuer Rechnungsprozess gestartet werden.

Topics auslesen, lesen und schreiben auf Topics in Kafka Container, siehe Projekt duk.

Der Flow zum importieren und anpassen, siehe Node-RED-Kafka.json.

Machine Learning mit Juypter Notebooks

Ein Jupyter Notebook ist eine Open-Source-Webanwendung, mit der Sie wiederholende Abläufe erstellen können. Die Live-Code, Gleichungen, Visualisierungen und Text enthalten können.

Verwendungsmöglichkeiten:

  • Datenbereinigung und -transformation
  • numerische Simulation
  • statistische Modellierung
  • Datenvisualisierung
  • maschinelles Lernen und vieles mehr.

Jupyter Notebooks laufen lokal, ein einem Container oder in der Cloud.

Maschinelles Lernen ist ein Oberbegriff für die «künstliche» Generierung von Wissen aus Erfahrung. Ein künstliches System lernt aus Beispielen und kann diese nach Beendigung der Lernphase verallgemeinern. Das heisst, es werden nicht einfach die Beispiele auswendig gelernt, sondern es «erkennt» Muster und Gesetzmässigkeiten in den Lerndaten.

Das Juypter Notebook MLTempHumSensor demonstriert Predictive Maintenance anhand von Demodaten.

Sollen die Live Daten des IoTKitV3 ausgewertet werden, ist der Code unter "Gegenprüfung mit Testdaten" wie folgt zu ändern:

test = pd.read_csv('ml-data.csv', header=None, names=['sensor', 'temp', 'hum', 'class'] )

Wird das Beispiel jetzt nochmals von vorne durchgespielt (Kernel -> Restart & Run All), erfolgt ein Vergleich mit den Live Daten des IoTKitV3.

About

Edge Computing

Resources

Readme

License

Apache-2.0 license
Activity
Custom properties

Stars

0 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

No packages published

Languages