IoT-Automatisierungspipeline mit Coreflux MQTT Broker und MongoDB bereitstellen

MQTT-Broker gehören zu den zentralen Bausteinen moderner IoT-Infrastrukturen und Automatisierungsumgebungen. Sie dienen als zentraler, einheitlicher und schneller Datenknotenpunkt, der die Zusammenarbeit verschiedener Systeme sowie den effizienten Datenaustausch ermöglicht. Coreflux ist ein leistungsstarker Low-Code-MQTT-Broker, der das klassische MQTT-Broker-Prinzip um erweiterte Funktionen für Echtzeit-Datenverarbeitung, Transformation und die Integration mit verwalteten Datenbanken wie MongoDB, PostgreSQL, MySQL und OpenSearch erweitert.

In diesem ausführlichen DevOps-Tutorial richtest du eine vollständige IoT-Automatisierungspipeline ein, indem du den Coreflux MQTT Broker gemeinsam mit MongoDB auf einer allgemeinen Cloud-Infrastruktur nutzt. Diese skalierbare Lösung für Speicherung und Verarbeitung ermöglicht es dir, IoT-Daten effizient zu erfassen, umzuwandeln und dauerhaft zu speichern, während Zuverlässigkeit und Performance für professionelle Einsatzszenarien erhalten bleiben.

Wichtige Lerninhalte

Bevor du mit der schrittweisen Bereitstellung beginnst, erhältst du einen Überblick über die wichtigsten Inhalte dieses Tutorials:

• Du stellst einen verwalteten MongoDB-Datenbankcluster auf einer Cloud-Plattform für skalierbare IoT-Datenspeicherung bereit.
• Du installierst und betreibst den Coreflux MQTT Broker auf einer Cloud-VM mithilfe eines Marketplace-Images oder Docker.
• Du erstellst ein sicheres privates Netzwerk, um MQTT-Broker und Datenbank ohne öffentliche Freigabe miteinander zu verbinden.
• Du entwickelst Echtzeit-Datenpipelines mit Coreflux Language of Things (LoT) für Low-Code-IoT-Automatisierung.
• Du transformierst MQTT-Daten automatisch und speicherst sie aus MQTT-Topics in MongoDB-Collections.
• Du überprüfst den vollständigen Datenfluss von simulierten Sensoren über Transformationsmodelle bis zur Speicherung in der Datenbank.

Dieses Tutorial bietet dir eine produktionsnahe Grundlage für IoT-Anwendungen, die Echtzeit-Messaging mit persistenter Datenspeicherung kombinieren müssen.

Was du in diesem Tutorial aufbaust

Am Ende dieser Automatisierungsanleitung hast du folgende Komponenten bereitgestellt:

• Einen verwalteten MongoDB-Datenbankcluster für skalierbare Speicherung
• Eine Cloud-VM mit laufendem Coreflux MQTT Broker
• Ein Virtual Private Cloud (VPC)-Netzwerk für sichere IoT-Kommunikation
• Eine Echtzeit-Datensimulation mit der LoT Notebook Extension
• Low-Code-Datentransformationsmodelle und Integrationsrouten zur Datenbank
• Eine vollständige Datenintegrations- und Transformationspipeline für IoT-Automatisierung

Coreflux und Cloud-Plattform-Integration

Coreflux stellt einen leichtgewichtigen MQTT-Broker sowie Datenpipeline-Werkzeuge über die Programmiersprache Language of Things bereit und ermöglicht dadurch eine effiziente IoT-Kommunikation in Cloud-Umgebungen.

Was ist MQTT?

MQTT steht für Message Queuing Telemetry Transport und ist ein leichtgewichtiges Publish-Subscribe-Netzwerkprotokoll, das häufig in IoT-Ökosystemen eingesetzt wird. Es wurde für ressourcenbeschränkte Geräte sowie für Netzwerke mit geringer Bandbreite, hoher Latenz oder unzuverlässiger Verbindung entwickelt. Dadurch ermöglicht MQTT eine effiziente Echtzeitkommunikation auch in Umgebungen mit begrenzter Konnektivität.

Über Coreflux

Coreflux bietet einen leichtgewichtigen MQTT-Broker für effiziente Echtzeitkommunikation zwischen IoT-Geräten und Anwendungen. Zusätzlich enthält Coreflux Funktionen zur Echtzeit-Datentransformation, die an unterschiedliche Anwendungsfälle angepasst werden können. Die Lösung ist auf Skalierbarkeit und Zuverlässigkeit ausgelegt und eignet sich besonders für Umgebungen, in denen niedrige Latenz und hoher Durchsatz entscheidend sind.

Coreflux stellt die Messaging-Grundlage bereit, die benötigt wird, um Daten zuverlässig zwischen Geräten fließen zu lassen. Das gilt sowohl für kleinere IoT-Projekte als auch für umfangreiche industrielle Monitoring-Systeme.

Mit Coreflux in einer Cloud-Umgebung erhältst du:

• Datenverarbeitung: Eine zentrale Verarbeitung deiner Daten dort, wo sie entstehen und gespeichert werden, wodurch Echtzeit-Datenverarbeitung möglich wird.
• Datenintegration: Eine einfache Anbindung an verwaltete Datenbankdienste, damit ein einheitliches Ökosystem für deine Datenanforderungen entsteht.
• Skalierbarkeit: Die Möglichkeit, wachsende Datenmengen und mehr verbundene Geräte zu verarbeiten, ohne die Performance zu beeinträchtigen.
• Zuverlässigkeit: Eine konsistente und verlässliche Nachrichtenübertragung zwischen allen angebundenen Geräten.

Voraussetzungen

Bevor du mit diesem Tutorial zur Bereitstellung eines MQTT-Brokers beginnst, benötigst du:

• Ein Cloud-Konto mit aktivierter Abrechnung
• Grundkenntnisse zu MQTT-Protokollkonzepten und IoT-Architektur
• Visual Studio Code für die LoT Notebook Extension

Netzwerkinfrastruktur für IoT-Automatisierung erstellen

VPC-Netzwerk für sichere MQTT-Kommunikation erstellen

Erstelle zunächst eine Virtual Private Cloud (VPC), damit deine IoT-Dienste und der MQTT-Broker sicher miteinander kommunizieren können, ohne dass öffentlicher Zugriff erforderlich ist.

1. Melde dich im Control Panel deines Cloud-Anbieters an.
2. Wechsle in den Netzwerkbereich und öffne dort den VPC-Bereich über die Seitenleiste.
3. Klicke auf die Option zum Erstellen eines neuen VPC-Netzwerks.

Konfiguriere deine VPC für die IoT-Automatisierung:

• Name: coreflux-integrations-vpc oder ein eigener VPC-Name
• Rechenzentrumsregion: Wähle Frankfurt oder deine bevorzugte Region
• IP-Bereich: Verwende den Standardbereich oder passe ihn nach Bedarf an
• Beschreibung: Ergänze eine aussagekräftige Beschreibung für das Netzwerk deines MQTT-Brokers und deiner Datenbank

Klicke anschließend auf die Schaltfläche zum Erstellen des VPC-Netzwerks.

Die VPC stellt ein isoliertes Netzwerk für alle IoT-Ressourcen bereit und sorgt für eine sichere Kommunikation zwischen dem Coreflux MQTT Broker und den verwalteten Datenbanken.

Verwaltete MongoDB-Datenbank für skalierbare Speicherung einrichten

Verwalteten MongoDB-Cluster erstellen

Verwaltete Datenbanken bieten automatisierte Backups, Monitoring und Wartung. Dadurch eignen sie sich gut für produktive IoT-Workloads und Anforderungen an skalierbare Datenspeicherung.

Verwalteten MongoDB-Cluster erstellen:

1. Öffne im Cloud Control Panel den Datenbankbereich.
2. Klicke auf die Option zum Erstellen eines Datenbankclusters.

Konfiguriere deinen MongoDB-Cluster für die IoT-Automatisierung:

• Datenbank-Engine: Wähle MongoDB aus
• Version: Wähle die aktuelle stabile Version
• Rechenzentrumsregion: Wähle Frankfurt oder dieselbe Region wie für deine VPC
• VPC-Netzwerk: Wähle die zuvor erstellte coreflux-integrations-vpc aus
• Name des Datenbankclusters: mongodb-coreflux-test
• Projekt: Wähle dein Zielprojekt aus

Wähle den passenden Tarif entsprechend deiner IoT-Anforderungen:

• Für Entwicklung: Ein Basistarif mit 1 GB RAM
• Für Produktion: Ein General-Purpose-Tarif oder höher für skalierbare Speicherung

Klicke auf die Schaltfläche zum Erstellen des Datenbankclusters.

Die Erstellung der verwalteten Datenbank dauert in der Regel zwischen einer und fünf Minuten. Nach Abschluss wirst du zur Übersichtsseite der Datenbank weitergeleitet, auf der du Verbindungsdetails einsehen und administrative Aufgaben ausführen kannst.

Datenbankzugriff für die MQTT-Broker-Integration konfigurieren

Du wirst durch erste Einrichtungsschritte geführt, in denen die Verbindungsdetails angezeigt werden und Regeln für eingehenden Zugriff konfiguriert werden können. Es empfiehlt sich, den Zugriff möglichst auf deine eigene IP-Adresse und auf VPC-interne Kommunikation zu beschränken.

1. Klicke auf die Option für den Einstieg oder die Ersteinrichtung, um deine MongoDB-Datenbank zu konfigurieren.
2. Beschränke eingehende Verbindungen optional.
3. Füge die IP-Adresse deines lokalen Computers für administrativen Zugriff hinzu.
4. Die virtuelle Maschine kann über das VPC-Netzwerk automatisch zugelassen werden.

Bei den Verbindungsdetails werden in der Regel zwei Optionen angezeigt: öffentliches Netzwerk und VPC-Netzwerk. Die öffentlichen Netzwerkdetails können für externe Werkzeuge wie MongoDB Compass verwendet werden, während die VPC-Netzwerkdetails vom Coreflux-Dienst genutzt werden sollten, um privat auf die Datenbank zuzugreifen.

Notiere dir die bereitgestellten Verbindungsdetails für öffentlichen Zugriff und VPC-Zugriff, da diese üblicherweise unterschiedlich sind:

• Host: Der Hostname deiner Datenbank
• Benutzer: Der standardmäßige Admin-Benutzer
• Passwort: Das automatisch erzeugte sichere Passwort
• Datenbank: Der Name der Authentifizierungsdatenbank

Datenbankverbindung testen

Du kannst die MongoDB-Verbindung mit MongoDB Compass oder mit dem bereitgestellten Connection String testen, indem du die Zugangsdaten für den öffentlichen Zugriff verwendest:

mongodb://username:password@mongodb-host:27017/defaultauthdb?ssl=true

Anwendungsdatenbank und Benutzer optional erstellen

Für mehr Sicherheit und eine bessere Struktur kannst du einen eigenen Datenbankbenutzer sowie eine eigene Datenbank für deine IoT-Automatisierungsanwendung erstellen. Dies ist auch über MongoDB Compass oder die Kommandozeile möglich, viele Cloud-Plattformen stellen dafür jedoch eine benutzerfreundliche Oberfläche bereit.

1. Öffne den Bereich für Benutzer und Datenbanken in deinem verwalteten Datenbankcluster.
2. Erstelle einen Benutzer.

• Benutzername: coreflux-broker-client
• Passwort: Automatisch generiert

Erstelle eine Datenbank:

• Datenbankname: coreflux-broker-data

Coreflux MQTT Broker auf einer Cloud-VM bereitstellen

Cloud-VM erstellen

1. Wechsle im Cloud Control Panel in den Bereich für virtuelle Maschinen oder Server.
2. Klicke auf die Option zum Erstellen einer neuen virtuellen Maschine.

Konfiguriere deine virtuelle Maschine für die Bereitstellung des MQTT-Brokers:

• Region auswählen: Frankfurt oder dieselbe Region wie für deine verwaltete Datenbank
• VPC-Netzwerk: Wähle coreflux-integrations-vpc aus
• Image auswählen: Öffne den Bereich für Marketplace-Images
• Suche: Suche nach „Coreflux“ und wähle das Coreflux Marketplace-Image aus

Wähle eine Größe passend zu deinem IoT-Workload:

• Für Entwicklung: Ein Basistarif mit 2 GB Arbeitsspeicher
• Für Produktion: Ein Basis- oder General-Purpose-Tarif mit mindestens 4 GB Arbeitsspeicher für skalierbare Performance

Wähle eine Authentifizierungsmethode:

• SSH-Schlüssel: Empfohlen für höhere Sicherheit
• Schlüsselerstellung: Ein Schlüssel kann lokal mit ssh-keygen erstellt werden
• Passwort: Alternative Option

Schließe die Details ab:

• Hostname: coreflux-test-broker
• Projekt: Wähle dein Projekt aus
• Tags: Ergänze passende Tags für die DevOps-Organisation

Klicke auf die Schaltfläche zum Erstellen der virtuellen Maschine.

Öffne anschließend die Übersichtsseite der virtuellen Maschine und warte, bis die Bereitstellung abgeschlossen ist.

Alternative Installation mit Docker auf einer Docker-Image-VM

Nutze denselben Ansatz wie bei der Coreflux-VM und wähle Docker als Marketplace-Image aus.

Sobald deine virtuelle Maschine läuft, verbindest du dich über SSH mit der festgelegten Authentifizierungsmethode oder verwendest die Webkonsole auf der Übersichtsseite der virtuellen Maschine:

ssh root@your-vm-ip

Starte den Coreflux MQTT Broker mit Docker:

docker run -d \
  --name coreflux \
  -p 1883:1883 \
  -p 1884:1884 \
  -p 5000:5000 \
  -p 443:443 \
  coreflux/coreflux-mqtt-broker-t:1.6.3

Dieser Docker-Befehl:

• Startet den Container mit der Option -d im Detached Mode
• Vergibt den Containernamen coreflux
• Gibt die benötigten Ports für MQTT und die Weboberfläche frei
• Verwendet das aktuelle Coreflux-Image

Prüfe, ob der MQTT-Broker läuft:

docker ps

Du solltest nun einen laufenden Container sehen.

Bereitstellung des MQTT-Brokers mit Standardverbindungswerten validieren

Du kannst über einen MQTT-Client wie MQTT Explorer auf den MQTT-Broker zugreifen, um den Brokerzugriff zu validieren. Dies funktioniert unabhängig davon, welche Bereitstellungsmethode du gewählt hast.

Firewall-Regeln für sichere IoT-Kommunikation optional konfigurieren

Für produktive IoT-Automatisierungsumgebungen solltest du Firewall-Regeln konfigurieren, um den Zugriff einzuschränken.

1. Wechsle in den Bereich für Netzwerk oder Firewall.
2. Klicke auf die Option zum Erstellen einer Firewall.

Konfiguriere eingehende Regeln für die Sicherheit des MQTT-Brokers:

• SSH: Port 22 von deiner IP-Adresse
• MQTT: Port 1883 von deinen IoT-Anwendungsquellen
• MQTT mit TLS: Port 1884 für sicheres MQTT mit TLS
• WebSocket: Port 5000 für MQTT über WebSocket
• WebSocket mit TLS: Port 443 für MQTT über WebSocket mit TLS

Wende die Firewall auf deine virtuelle Maschine an.

IoT-Datenintegration mit Coreflux Language of Things einrichten

LoT Notebook Extension installieren

Die LoT Notebook Extension, also die Language of Things Notebook Extension, stellt in Visual Studio Code eine integrierte Low-Code-Entwicklungsumgebung für MQTT-Broker-Programmierung und IoT-Automatisierung bereit.

1. Öffne Visual Studio Code.
2. Wechsle mit Ctrl+Shift+X in den Erweiterungsbereich.
3. Suche nach „LoT Notebooks“.
4. Installiere die LoT VSCode Notebooks Extension von Coreflux.

Verbindung zum MQTT-Broker herstellen

Konfiguriere die Verbindung zu deinem Coreflux MQTT Broker mit den Standardzugangsdaten, sobald du in der oberen Leiste dazu aufgefordert wirst oder indem du unten links in der Statusleiste auf die MQTT-Schaltfläche klickst.

• Benutzer: root
• Passwort: coreflux

Wenn keine Fehler auftreten, wird der MQTT-Verbindungsstatus zum Broker unten links in der Statusleiste angezeigt.

Daten im MQTT-Broker mit Actions erzeugen

In diesem Anwendungsfall erstellst du eine Integration, die Rohdaten aufnimmt, sie durch eine Transformationspipeline verarbeitet und anschließend in einer Datenbank speichert. Da in dieser Demo keine MQTT-Geräte angebunden sind, nutzt du IoT-Funktionen und erstellst eine Action zur Simulation von Gerätedaten.

In LoT ist eine Action ausführbare Logik, die durch bestimmte Ereignisse ausgelöst wird. Dazu gehören Zeitintervalle, Topic-Updates, explizite Aufrufe durch andere Actions oder Systemkomponenten. Actions ermöglichen eine dynamische Interaktion mit MQTT-Topics, internen Variablen und Payloads und bilden damit die Grundlage für komplexere IoT-Automatisierungsabläufe.

Du kannst daher eine Action verwenden, die in definierten Zeitabständen Daten in bestimmte Topics schreibt. Diese Daten können anschließend von der später konfigurierten Pipeline weiterverarbeitet werden.

Simulierte IoT-Daten erzeugen

Erstelle eine Action, um simulierte Sensordaten über die Low-Code-LoT-Oberfläche zu erzeugen:

DEFINE ACTION RANDOMIZEMachineData
ON EVERY 10 SECONDS DO
    PUBLISH TOPIC "raw_data/machine1" WITH RANDOM BETWEEN 0 AND 10
    PUBLISH TOPIC "raw_data/station2" WITH RANDOM BETWEEN 0 AND 60

Im bereitgestellten Notebook ist außerdem eine Action enthalten, die alternativ zur oben gezeigten Action einen inkrementellen Zähler zur Datensimulation nutzt.

Wenn du diese Action ausführst, passiert Folgendes:

• Sie wird automatisch auf dem MQTT-Broker bereitgestellt
• Sie erzeugt alle zehn Sekunden simulierte IoT-Sensordaten
• Sie veröffentlicht Echtzeitdaten in bestimmten MQTT-Topics
• Sie zeigt den Synchronisierungsstatus in der LoT Notebook Oberfläche an
• Sie zeigt an, ob sich der Code im LoT Notebook vom Code auf dem Broker unterscheidet oder ob er dort vollständig fehlt

Datentransformationsmodelle für Echtzeitverarbeitung erstellen

Datenmodelle mit Language of Things definieren

Modelle in Coreflux werden verwendet, um Werte aus eingehenden MQTT-Topics zu transformieren, zu aggregieren und zu berechnen, bevor die Ergebnisse in neue Topics veröffentlicht werden. Sie bilden die Grundlage für den Aufbau eines Unified Namespace deines Systems und können über verschiedene Datenquellen hinweg eingesetzt werden.

Ein Model legt fest, wie rohe Language-of-Things-Daten strukturiert und umgewandelt werden sollen. Das kann für ein einzelnes Gerät oder mithilfe des Wildcards + gleichzeitig für mehrere Geräte erfolgen. Außerdem dient ein Model als wichtiges Datenschema für die skalierbare Speicherung in der verwalteten Datenbank.

DEFINE MODEL MachineData WITH TOPIC "Simulator/Machine/+/Data"
    ADD "energy" WITH TOPIC "raw_data/+" AS TRIGGER
    ADD "energy_wh" WITH (energy * 1000)
    ADD "production_status" WITH (IF energy > 5 THEN "active" ELSE "inactive")
    ADD "production_count" WITH (IF production_status EQUALS "active" THEN (production_count + 1) ELSE 0)
    ADD "stoppage" WITH (IF production_status EQUALS "inactive" THEN 1 ELSE 0)
    ADD "maintenance_alert" WITH (IF energy > 50 THEN TRUE ELSE FALSE)
    ADD "timestamp" WITH TIMESTAMP "UTC"

Dieses Low-Code-Model:

• Verwendet den Wildcard +, um automatisch auf alle Maschinen angewendet zu werden
• Wandelt Energiewerte in Wattstunden, also energy_wh, um, indem sie mit 1000 multipliziert werden
• Bestimmt den Produktionsstatus anhand definierter Energieschwellenwerte
• Erfasst Produktionszähler und Stillstandsereignisse
• Fügt allen Echtzeit-Datenpunkten Zeitstempel hinzu
• Extrahiert die Maschinen-ID aus der Topic-Struktur
• Veröffentlicht strukturierte Daten in den Topics Simulator/Machine/+/Data, wobei der + durch jedes Topic ersetzt wird, das zum Trigger- oder Quelldatenformat passt

Da mit der Action zwei simulierte Sensoren beziehungsweise Maschinen erzeugt wurden, wird die Model-Struktur automatisch auf beide angewendet. Dadurch entstehen sowohl ein JSON-Objekt als auch einzelne Topics.

Datenbankintegration für skalierbare Speicherung einrichten

Datenbankroute erstellen

Routes definieren, wie verarbeitete Echtzeitdaten an externe Systeme wie verwaltete Datenbanken übertragen werden. Sie verwenden das folgende Low-Code-Format:

DEFINE ROUTE mongo_route WITH TYPE MONGODB
    ADD MONGODB_CONFIG
        WITH CONNECTION_STRING "mongodb+srv://:@/?tls=true&authSource=admin&replicaSet="
        WITH DATABASE "admin"

Ersetze die Platzhalter durch die MongoDB-Verbindungsdetails deiner verwalteten Datenbankplattform und führe die Route in deinem IoT Notebook aus.

Model für die Datenbankspeicherung aktualisieren

Passe dein LoT-Model so an, dass es die Datenbankroute für skalierbare Speicherung verwendet. Ergänze dafür die folgenden Zeilen am Ende des Models:

STORE IN "mongo_route"
    WITH TABLE "MachineProductionData"

Füge zusätzlich einen Parameter mit dem Topic hinzu, damit jeder Eintrag in deiner verwalteten Datenbank eine eindeutige Kennung erhält.

DEFINE MODEL MachineData WITH TOPIC "Simulator/Machine/+/Data"
    ADD "energy" WITH TOPIC "raw_data/+" AS TRIGGER
    ADD "device_name" WITH REPLACE "+" WITH TOPIC POSITION 2 IN "+"
    ADD "energy_wh" WITH (energy * 1000)
    ADD "production_status" WITH (IF energy > 5 THEN "active" ELSE "inactive")
    ADD "production_count" WITH (IF production_status EQUALS "active" THEN (production_count + 1) ELSE 0)
    ADD "stoppage" WITH (IF production_status EQUALS "inactive" THEN 1 ELSE 0)
    ADD "maintenance_alert" WITH (IF energy > 50 THEN TRUE ELSE FALSE)
    ADD "timestamp" WITH TIMESTAMP "UTC"
    STORE IN "mongo_route"
        WITH TABLE "MachineProductionData"

Nachdem du diese aktualisierte Action bereitgestellt hast, sollten alle aktualisierten Daten automatisch in der Datenbank gespeichert werden.

Vollständige IoT-Automatisierungspipeline überprüfen

Echtzeit-Datenfluss überwachen

MQTT Explorer: Verwende einen MQTT-Client, um die Veröffentlichung von Echtzeitdaten zu bestätigen.

MongoDB Compass: Stelle eine Verbindung zur Datenbank her, um zu prüfen, ob die Daten gespeichert werden.

Datenbankspeicherung prüfen

Verbinde dich mit MongoDB Compass mit deiner verwalteten MongoDB-Datenbank, um die skalierbare Speicherung zu überprüfen:

• Verwende den Connection String deiner verwalteten Datenbank.
• Öffne die Datenbank coreflux-broker-data oder den von dir gewählten Datenbanknamen.
• Prüfe die Collection MachineProductionData auf gespeicherte Dokumente.

Du solltest Echtzeit-Datendokumente mit einer ähnlichen Struktur sehen:

{
  "_id": {
    "$oid": "68626dc3e8385cbe9a1666c3"
  },
  "energy": 36,
  "energy_wh": 36000,
  "production_status": "active",
  "production_count": 31,
  "stoppage": 0,
  "maintenance_alert": false,
  "timestamp": "2025-06-30 10:58:11",
  "device_name": "station2"
}

Wie zuvor gezeigt, bleiben alle Daten weiterhin im MQTT-Broker für weitere Anwendungsfälle und Integrationen verfügbar.

Anwendungsfall und Integrationen erweitern

Funktionen von Language of Things testen

Beispieldaten veröffentlichen: Verwende MQTT Explorer, um Beispieldatensätze an deinen Coreflux Broker zu senden. Teste verschiedene Payload-Strukturen sowie unterschiedliche Models oder Actions, um zu sehen, wie sie verarbeitet und in MongoDB gespeichert werden.

Datenvalidierung: Stelle sicher, dass die Daten in MongoDB mit den von dir veröffentlichten Payloads übereinstimmen. Prüfe Konsistenz und Genauigkeit mit MongoDB Compass, um sicherzugehen, dass deine IoT-Automatisierungsintegration wie erwartet funktioniert. Vergleiche Zeitstempel, Feldtransformationen und Datentypen, um deine Echtzeit-Datenpipeline zu validieren.

Echtzeit-Monitoring: Richte einen kontinuierlichen Echtzeit-Datenfeed über eine weitere MQTT-Datenquelle ein, etwa über einen einfachen Sensor mit MQTT-Konnektivität. Beobachte, wie Coreflux und MongoDB eingehende IoT-Datenströme verarbeiten, und untersuche die Antwortzeiten für Datenabrufe und Abfragen.

Analysen und Visualisierungen aufbauen

Dashboards erstellen: Binde Visualisierungstools wie Grafana ein, um dynamische Dashboards zu erstellen, die deine IoT-Daten anzeigen. Die Daten können entweder live aus dem MQTT-Broker oder aus der Datenbank stammen. Verfolge Kennzahlen wie Geräteverfügbarkeit, Sensorwerte, Produktionszähler oder Wartungsalarme aus deinen Automatisierungssystemen. Für die Einrichtung von Monitoring kannst du Anleitungen zur Nutzung von Prometheus und Grafana mit verwalteten Datenbanken heranziehen.

Trendanalyse: Nutze das Aggregation Framework von MongoDB, um Entwicklungen über einen Zeitraum hinweg zu analysieren. Suche nach Mustern, Spitzen oder Anomalien in deinen Echtzeitdaten, die auf Systemprobleme oder Optimierungsmöglichkeiten hinweisen können.

Multi-Datenbank-Integration: Prüfe Integrationen mit zusätzlichen verwalteten Datenbanken wie PostgreSQL für relationale Daten, MySQL für strukturierte Abfragen oder OpenSearch für erweiterte Analyse- und Suchfunktionen. Mit Coreflux Routes kannst du Daten gleichzeitig an mehrere Ziele senden.

IoT-Infrastruktur optimieren und skalieren

Lasttests: Simuliere hohen Datenverkehr, indem du mit LoT Notebook oder automatisierten Skripten viele Nachrichten gleichzeitig veröffentlichst. Beobachte, wie dein Coreflux MQTT Broker und dein MongoDB-Cluster mit der Last umgehen, und identifiziere mögliche Engpässe in deiner Datenpipeline.

Skalierung: Cloud-Plattformen bieten in der Regel vertikale und horizontale Skalierungsoptionen. Erhöhe die Ressourcen deiner virtuellen Maschine, etwa CPU, RAM oder Speicher, wenn deine IoT-Datenanforderungen wachsen. Skaliere deinen verwalteten Datenbankcluster für größere Datenmengen und richte Auto-Scaling-Benachrichtigungen ein, damit du informiert wirst, wenn Ressourcengrenzen erreicht werden.

Häufig gestellte Fragen

Wie integriere ich einen MQTT-Broker mit MongoDB?

Um einen MQTT-Broker mit MongoDB zu verbinden, richtest du eine Coreflux-Datenbankroute ein, die auf deine MongoDB-Instanz verweist. Diese Route nutzt eine authentifizierte Connection String und schreibt MQTT-Payloads automatisch in MongoDB-Collections. Coreflux übernimmt die Verbindungsschicht, sodass du dich auf die Transformation der Daten mit der Language-of-Things-Syntax konzentrieren kannst.

Kann ich MQTT-Daten ohne eigenen Code direkt in MongoDB speichern?

Ja. Coreflux unterstützt dies über die MongoDB-Route-Funktion. Du konfigurierst die Route mit deiner MongoDB-Connection-String und verwendest eine STORE IN-Direktive in deinen Datenmodellen. Verarbeitete MQTT-Nachrichten werden anschließend automatisch in MongoDB geschrieben – ohne eigenen Datenbankintegrationscode. Connection Pooling, Retries und Fehlerbehandlung werden von der Route verwaltet.

Welche Vorteile bietet MongoDB mit MQTT für IoT-Anwendungen?

MongoDB eignet sich gut für IoT-Szenarien, da das Dokumentenmodell wechselnde Sensorstrukturen und unterschiedliche Geräteformate verarbeiten kann. Anders als relationale Datenbanken erfordert MongoDB keine fest definierten Tabellen im Voraus. Zusammen mit dem leichtgewichtigen Messaging-Ansatz von MQTT entsteht so eine praktische Pipeline für Echtzeit-IoT-Daten in großem Maßstab. Managed-MongoDB-Dienste können außerdem den Betrieb durch Backups, Skalierung und Monitoring vereinfachen.

Wie sicher ist die Verbindung zwischen Coreflux und MongoDB?

In Cloud-Deployments kann private Vernetzung, etwa über eine VPC, die Kommunikation zwischen Coreflux und MongoDB vom öffentlichen Internet fernhalten. TLS kann verwendet werden, um Datenbankverbindungen zu verschlüsseln. Zusätzlich helfen dedizierte Datenbanknutzer mit eingeschränkten Berechtigungen dabei, das Prinzip der geringsten Rechte umzusetzen.

Kann ich dieses Setup für produktive IoT-Deployments verwenden?

Ja. Diese Architektur kann produktiv eingesetzt werden, wenn sie korrekt konfiguriert ist. Managed-Datenbanken bieten Funktionen wie Backups, Verfügbarkeitsoptionen und Monitoring, während Coreflux für höheren Nachrichtendurchsatz horizontal skaliert werden kann. Für den Produktionseinsatz solltest du Firewall-Regeln konfigurieren, starke Zugangsdaten verwenden, TLS für MQTT-Traffic aktivieren, Monitoring-Alarme einrichten und die Ressourcen passend zum erwarteten Nachrichtenvolumen dimensionieren.

Fazit

Die Verbindung eines Coreflux-MQTT-Brokers mit einem Managed-MongoDB-Dienst bietet eine skalierbare Lösung für die Verarbeitung und Speicherung von IoT-Daten in Echtzeit. In diesem Tutorial hast du eine Automatisierungspipeline aufgebaut, die IoT-Daten effizient erfasst, verarbeitet und speichert, wobei Low-Code-Entwicklungsmethoden zum Einsatz kommen.

Coreflux stellt die skalierbare Messaging-Schicht bereit, während MongoDB eine flexible dokumentenbasierte Speicherung für große Mengen an Live-Daten ermöglicht. Dieses Setup eignet sich für Anwendungsfälle wie industrielles Monitoring, Umwelt- und Sensorsysteme oder Smart-City-Infrastrukturen und hilft Teams dabei, eingehende IoT-Daten in verwertbare Erkenntnisse umzuwandeln.

Durch die Kombination des Language-of-Things-Notebook-Ansatzes mit Managed-Cloud-Services verfügst du nun über eine IoT- und DevOps-fähige Grundlage, die mit deinen Anforderungen wachsen kann. Die MQTT-Broker-Bereitstellung ist für produktive Workloads vorbereitet und kann später um PostgreSQL, MySQL, OpenSearch oder weitere Datenbanktechnologien erweitert werden.