So erstellen Sie ein IIoT-System mit Apache NiFi, MiNiFi, C2 Server, MQTT und Raspberry Pi

Wie lange dauert es Ihrer Meinung nach, um einen fortschrittlichen industriellen IoT-Prototyp zu erstellen, der:

  • Sammeln Sie in jeder Fabrik Daten von Sensoren zu einem Gateway
  • Verschieben Sie Sensordaten von einer oder mehreren Fabriken in die Cloud oder ins Rechenzentrum
  • Automatische Warmbereitstellung neuer Konfigurationen auf allen Edge-Geräten
  • Unterstützt großes Datenvolumen und End-to-End-Sicherheit

Mit dem richtigen Tool können Sie ein solches System in weniger als einer Stunde erstellen! In diesem Blog-Beitrag zeige ich Ihnen, wie Sie einen erweiterten IIoT-Prototyp mit Raspberry Pi-Hardware und Open Source-Software (MQTT-Broker, Apache NiFi, MiNiFi und MiNiFi C2 Server) implementieren. Ich werde mich auf die Architektur, die Konnektivität, die Datenerfassung und die automatische Neukonfiguration konzentrieren.

Dieser Artikel soll der Beginn einer Reihe von Artikeln über IoT sein. Kantenverarbeitung und Datenanalyse werden Gegenstand der folgenden Artikel sein, also bleiben Sie dran :)

Industrielle IoT-Architektur

Es gibt viele IoT-Referenzarchitekturen. In industriellen Umgebungen haben Sie häufig keinen direkten Zugriff auf Sensoren und Steuerungssysteme. Ein Gateway wird verwendet, um die OT- und die IT-Welt zu verbinden. Aus diesem Grund umfasst die IIoT-Architektur häufig Edge-Geräte, Gateways, regionale Hubs und schließlich Speicher- / Verarbeitungssysteme.

Das folgende Bild zeigt die globale Architektur unseres Systems und die Softwaretools, die wir auf jeder Ebene verwenden werden.

Auf der Randebene sammeln Sensoren Informationen über die digitale Welt und senden sie über eine Vielzahl von drahtgebundenen und drahtlosen Protokollen (seriell, RS-485, MODBUS, CAN-Bus, OPC UA, BLE, WiFi usw.) an ein Gateway. In unserem Beispiel verwenden wir verschiedene Sensoren (Licht, Temperatur, Kameras, Beschleunigungsmesser usw.), die Daten über WLAN an das Gateway senden.

Das Gateway ist ein Raspberry Pi, auf dem ein Mosquitto Broker und ein MiNiFi-Agent ausgeführt werden. Mosquitto ist ein Open Source, ein leichtgewichtiger Messaging-Broker, mit dem wir Sensordaten über das MQTT-Protokoll verfügbar machen. MQTT hat einen minimalen Platzbedarf, wodurch es für IoT-Anwendungen und ressourcenbeschränkte Hardware wie Telefone oder Mikrocontroller geeignet ist.

Apache MiNiFi - ein Teilprojekt von Apache NiFi - ist ein leichtes Mittel, das die Kernfunktionen von Apache NiFi implementiert und sich auf die Datenerfassung am Rande konzentriert.

MiNiFi-Designziele sind: geringe Größe und geringer Ressourcenverbrauch, zentrale Verwaltung von Agenten und Edge Intelligence. MiNiFi kann über das Site-to-Site-Protokoll (S2S) problemlos in NiFi integriert werden, um eine End-to-End-Flow-Management-Lösung zu erstellen, die skalierbar und sicher ist und eine vollständige Aufbewahrungskette für Informationen (Herkunft) bietet.

In unserem System abonniert MiNiFi alle Themen des Mosquitto-Brokers und leitet jede neue Nachricht auf regionaler Ebene an NiFi weiter. Wir können es auch verwenden, um eine Verbindung zum SCADA-System oder einem anderen OT-Datenanbieter herzustellen.

Auf regionaler Ebene haben wir zwei Komponenten:

Apache NiFi ist eine leistungsstarke Datenflussplattform mit mehr als 200 sofort einsatzbereiten Anschlüssen. Dank der Benutzeroberfläche wird das Entwerfen von Datenflüssen schnell und einfach.

NiFi tauscht der Einfachheit halber keinen Strom aus. In der Tat handelt es sich um ein hoch skalierbares verteiltes System mit garantierter Lieferung, Gegendruck und Lastverteilung. Diese Funktionen machen NiFi zu einem großartigen Werkzeug für IoT-Anwendungen, bei denen die Netzwerkqualität eine Herausforderung darstellen kann.

In unserem System spielt NiFi die zentrale Rolle, Daten aus jeder Fabrik zu sammeln und an mehrere Systeme und Anwendungen (HDFS, HBase, Kafka, S3 usw.) weiterzuleiten.

MiNiFi C2 Server (MiNiFi Commande & Control) ist ein weiteres Teilprojekt von Apache NiFi, das derzeit entwickelt wird. Seine Aufgabe ist es, Hunderten oder Tausenden von MiNiFi-Agenten in freier Wildbahn einen zentralen Konfigurationspunkt zu bieten. Der C2-Server verwaltet versionierte Anwendungsklassen (MiNiFi-Flow-Konfigurationen) und macht sie über eine Rest-API verfügbar. MiNiFi-Agenten können mit einer definierten Häufigkeit eine Verbindung zu dieser API herstellen, um ihre Konfiguration zu aktualisieren.

Sobald die Daten auf den Servern des Unternehmens, in der Cloud oder im Rechenzentrum landen , können zahlreiche Anwendungen implementiert werden. Echtzeitüberwachung, Prozessanalyse und -optimierung oder vorausschauende Wartung sind nur einige Beispiele. Die Datenverarbeitung und die Implementierung von Anwendungsfällen werden in einem zukünftigen Artikel behandelt.

Systemimplementierung

Beginnen wir mit dem Bau unseres Prototyps.

Raspberry Pi vorbereiten: MQTT und MiNiFi

Führen Sie die folgenden Befehle auf Ihrem Raspberry Pi aus, um den Mosquitto MQTT-Broker und den MiNiFi-Agenten zu installieren.

Um eine geringe Größe zu erreichen, ist MiNiFi mit einem minimalen Satz von Standardprozessoren ausgestattet. Sie können jeden NiFi-Prozessor hinzufügen, indem Sie den NAR (NiFi Archive) im lib-Verzeichnis bereitstellen. Im letzten Befehl des folgenden Blocks füge ich den NAR des MQTT-Prozessors hinzu.

sudo apt-get update#install and run Mosquitto broker on default port 1883sudo apt-get install mosquittomosquitto#install and prepare MiNiFi agentwget //apache.crihan.fr/dist/nifi/minifi/0.4.0/minifi-0.4.0-bin.tar.gztar -xvf minifi-0.4.0-bin.tar.gzcd minifi-0.4.0#add mqtt processorwget //github.com/ahadjidj-hw/NiFi/raw/master/nifi-mqtt-nar-1.5.0.nar -P ./lib/

Standardmäßig muss zum Konfigurieren eines MiNiFi-Agenten die Datei ./conf/config.yml bearbeitet werden, um die Liste der verwendeten Prozessoren und deren Konfigurationen einzuschließen. Die Konfiguration kann manuell geschrieben oder mithilfe der NiFi-Benutzeroberfläche entworfen und der Flow als Vorlage exportiert werden. Die Vorlage ist eine XML-Datei, die wir mit dem MiNiFi-Toolkit in eine YML-Datei konvertieren müssen. Hier ist ein Beispiel für eine Konfigurationsdatei, die eine Datei enthält und jede Leitung über S2S an ein entferntes NiFi sendet.

Für unser Projekt werden wir diese manuellen Schritte nicht verwenden. Bei vielen MiNiFi-Agenten, die in geografisch verteilten Fabriken ausgeführt werden, ist es nicht möglich, die Datei config.yml manuell zu stoppen, zu bearbeiten und dann jeden Agenten jedes Mal neu zu starten, wenn sich seine Konfiguration ändern muss.

MiNiFi verwendet einen "Change Ingestor", mit dem der Agent über eine mögliche neue Konfiguration informiert wird. Change Ingestors sind steckbare Module, und derzeit werden drei Ingestors unterstützt. OOTB:

  • FileChangeIngestor
  • RestChangeIngestor
  • PullHttpChangeIngestor

Wir werden einen PullHttpChangeIngestor verwenden, um jeden Zeitraum einen C2-Server abzufragen und jede neue verfügbare Konfiguration herunterzuladen. Um diesen Ingestor zu konfigurieren, bearbeiten Sie die Datei ./conf/bootstrap.conf, kommentieren Sie die entsprechenden Zeilen aus und legen Sie die Ingestor-Eigenschaften wie folgt fest:

nifi.minifi.notifier.ingestors=org.apache.nifi.minifi.bootstrap.configuration.ingestors.PullHttpChangeIngestor
# Hostname on which to pull configurations from
nifi.minifi.notifier.ingestors.pull.http.hostname=c2-server
# Port on which to pull configurations from
nifi.minifi.notifier.ingestors.pull.http.port=10080
# Path to pull configurations from
nifi.minifi.notifier.ingestors.pull.http.path=/c2/config
# Query string to pull configurations with
nifi.minifi.notifier.ingestors.pull.http.query=class=iot-minifi-raspberry-agent
# Period on which to pull configurations from, defaults to 5 minutes if commented out
nifi.minifi.notifier.ingestors.pull.http.period.ms=60000

Bei dieser Konfiguration fragt jeder MiNiFi-Agent alle 1 Minute die C2-Server-REST-API unter // c2-server: 10080 / c2 / config ab und fragt nach der neuesten Konfiguration für die Klasse „iot-minifi-raspberry-agent“.

Hinweis: Die Frequenz von 1 Minute dient nur zu Demozwecken. Sie werden Ihre Agenten nicht so häufig aktualisieren.

Starten Sie Ihren Agenten jetzt nicht und wechseln Sie zur regionalen Ebene und konfigurieren Sie den MiNiFi C2-Server und NiFi.

Installieren und Konfigurieren des MiNiFi C2-Servers

Installieren Sie den MiNiFi C2-Server auf einem öffentlichen Server, der über die MiNiFi-Agenten erreichbar ist. Sie können die hierarchische C2-Bereitstellung für Anwendungen mit eingeschränkten Netzwerken verwenden, wie in den folgenden Zeilen beschrieben. Führen Sie den folgenden Befehl aus, um den C2-Server zu installieren:

wget //apache.crihan.fr/dist/nifi/minifi/0.4.0/minifi-c2-0.4.0-bin.tar.gztar -xvf minifi-c2-0.4.0-bin.tar.gzcd minifi-c2-0.4.0

Der C2-Server macht MiNiFi-Anwendungen über eine nach Klassen organisierte REST-API verfügbar. C2 unterstützt steckbare „Konfigurationsanbieter“ und unterstützt derzeit:

  • The CacheConfigurationProvider, whichlooks at the directory on the filesystem or on S3
  • The DelegatingConfigurationProvider, which delegates to another C2 server to allow for hierarchical C2 structures
  • The NiFiRestConfigurationProvider, which pulls templates from a NiFi instance over its REST API

Configure the C2 Server to use NiFi as a configuration provider. Edit the file ./conf/minifi-c2-context.xml and provide the NiFi server address //nifi-dev:8080

Installing and configuring the NiFi Server

Install NiFi on a server reachable from the C2 server and run it.

wget //apache.crihan.fr/dist/nifi/1.6.0/nifi-1.6.0-bin.tar.gztar -xvf nifi-1.6.0-bin.tar.gzcd nifi-1.6.0./bin/nifi.sh start

Let’s connect to the NiFi UI at //nifi-dev:8080/nifi/ and create the flow that will run in the MiNiFi agents. But before this, add an input port to the root canvas and name it “from Raspberry MiNiFi”. This is where NiFi will receive flow files from MiNiFi.

Add a consumeMQTT processor to subscribe to the Mosquitto broker and subscribe to all topics under iot/sensors. Note that the tcp://raspberrypi:1883 here is equivalent to tcp://localhost:1883, since this flow will be running on the Raspberry Pi.

Use an UpdateAttribute processor to add a “version” attribute that we will use to show the re-configuration feature. You can add any attribute you want: timestamp, agent name, location, and so on.

And finally, add a Remote Process Group (RPG) to send the consumed events to NiFi. Connect these three processors.

Your flow now looks like the below screenshot. The left flow will be running in NiFi to receive data from MiNiFi. The right flow here is only for design and will effectively run on each Raspberry Pi.

Save the right flow as a template under the name “iot-minifi-raspberry-agent.v1”. The naming convention here is very important. We must use the same name as the class name used in the MiNiFi bootstrap configuration.

Deploy and start the application

Before starting the MiNiFi agents on the Raspberry Pi, let’s see if the C2 server is well configured. Open the following URL in your web browser : //c2-server:10080/c2/config?class=iot-minifi-raspberry-agent&version=1 . The C2 Server replies with a file containing the configuration of the template we built, in YML format . That’s great.

If you look to the C2 logs, you can see that the server received a query with the parameters {class=[iot-minifi-raspberry-agent], version=[1]}

Now that communication between the different components of the architecture (MQTT, MiNiFi, NiFi and C2) is working, start the MiNiFi agent on the Raspberry Pi with the command:

./bin/minifi.sh start

After a few seconds, you see the following C2 server logs. The host 192.168.1.50 (this is the Raspberry Pi’s IP address) asked the C2 server to give it the latest version of the class “iot-minifi-raspberry-agent”. Compared to our previous call with the web browser, you’ll notice that the MiNiFi agent didn’t specify a version. If you open now the MiNiFi agent configuration at ./conf/config.yml you will find the same conf file that we retrieved from the C2 Rest API.

Also, the MQTT shows that the MiNiFi agent connected to the broker and subscribed to the topics iot/sensors/#

Perfect! The IIoT system is running like a charm. Now let’s start our sensors to generate data and publish it in MQTT. MiNiFi will then start consuming data and sending it to NiFi as shown in the following screenshot where we have received 196 messages.

Now let’s inspect one of these messages with the provenance feature of NiFi. This data comes from the light sensor “iot/sensors/LightIntensity/z” and the application version is 1.

Automagic Warm Redeploy

Now that our IIoT is running and data is flowing from every factory to our data center, let’s deploy a new application. For our test, we will make a minor modification to our MiNiFi agent configuration. Go to the NiFi web UI and edit the updateAttribute processor. Set the “version” attribute to 2 instead of 1 and save the flow in a new template “iot-minifi-raspberry-agent.v2”. That’s all! The new application will be automagically deployed.

You can see the C2 server logs below showing that a new version V2 was detected. The C2 server does not have this version in its cache and start a download and conversion process.

Then, the MiNiFi agents detect the new configuration, backup the previous configuration, deploy the new one, and restart.

Now let’s look to the data coming from the agents. As you can see in the provenance UI below, this data comes from a Gyroscope and has an application version 2.

Conclusions

Apache NiFi and its eco-system (MiNiFi and C2 server) are powerful tools for end-to-end IoT data management. It can be used to easily and quickly build advanced IoT applications with flexible architectures and advanced features (automatic warm deploy, data provenance, backpressure, and so on).

In future articles, I’ll show you how to use this data, secure the platform, and implement advanced edge processing scenarios. In the meantime, you can read this article on how Renault, a multinational automobile manufacturer, uses Apache NiFi in IIoT projects and what are the best practices that they adopted.

Thanks for reading. As always, feedback and suggestions are welcome.

If you found this article useful then give it some claps and follow me for more Big Data and IoT articles!