Mosquitto Docker: So richtest du den Eclipse Mosquitto MQTT Broker mit Docker und Docker Compose ein

Einen MQTT-Broker von Grund auf einzurichten, sollte nicht stundenlange Konfigurations- und Fehlerbehebungsarbeiten erfordern.

Eclipse Mosquitto ist ein Open-Source-MQTT-Broker, der die Protokolle MQTT v5, 3.1.1 und 3.1 unterstützt. Damit ist er super für IoT-Geräte, Hausautomationssysteme, Cloud-Anwendungen und jede Art von nachrichtengesteuerter Architektur. Aber Mosquitto direkt auf deinem System zu installieren und einzurichten, führt oft zu Abhängigkeitskonflikten, Berechtigungsproblemen und plattformspezifischen Schwierigkeiten, die deine Entwicklungszeit auffressen. Am Ende verbringst du mehr Zeit damit, dich mit der Einrichtung herumzuschlagen, als deine eigentliche Anwendung zu entwickeln.

Docker macht Schluss mit diesen Problemen, indem es eine einheitliche, isolierte Umgebung für die Ausführung von Mosquitto auf jeder Plattform bietet. Du kannst innerhalb von Minuten einen voll funktionsfähigen MQTT-Broker einrichten, komplett mit benutzerdefinierten Konfigurationen, Authentifizierung und Persistenz.

In dieser Anleitung zeige ich dir, wie du Eclipse Mosquitto mit Docker und Docker Compose einrichtest, die Authentifizierung und Protokollierung konfigurierst, die Datenpersistenz einrichtest und deinen Broker mit echten MQTT-Clients testest.

Bist du komplett neu bei Docker? Ich empfehle, mit unserer Einführung in Docker, um die Grundlagen zu verstehen.

Was ist Mosquitto und warum sollte man es in Docker nutzen?

Du brauchst kein kompliziertes Messaging-System, wenn du nur schnelle und zuverlässige Kommunikation zwischen Geräten willst.

MQTT ist ein leichtes Publish-Subscribe-Protokoll, das für Situationen entwickelt wurde, in denen die Bandbreite begrenzt ist und Zuverlässigkeit wichtig ist. Denk mal an IoT-Sensoren, mobile Apps oder jedes Szenario, in dem Geräte schnell kleine Nachrichten austauschen müssen, ohne ständig abgefragt zu werden.

Mosquitto ist sozusagen der Mittelsmann – der Broker – zwischen den Verfassern und den Abonnenten. 

Die Verlage schicken Nachrichten zu bestimmten Themen. Die Abonnenten hören sich diese Themen an. Mosquitto kümmert sich um das Routing und sorgt dafür, dass die Nachrichten an die richtigen Stellen kommen, ohne dass Publisher und Subscriber voneinander wissen müssen.

Hier ist der Grund, warum Docker die Mosquitto-Docker-Setups noch besser macht:

• Einheitliche Einrichtung auf allen Plattformen: Windows, macOS oder Linux – der Docker-Container läuft überall gleich. Du musst nicht nach plattformspezifischen Installationsprogrammen suchen oder dich mit Abhängigkeitskonflikten rumschlagen.
• Einfaches Versionsmanagement: Du kannst bestimmte Mosquitto-Versionen mit Image-Tags fixieren, bei Problemen zurücksetzen und neue Versionen testen, ohne dein Host-System anzufassen.
• Echte Mobilität: Die gleiche Docker-Mosquitto-Konfiguration funktioniert in der Entwicklung, im Staging und in der Produktion. Deine lokale Umgebung passt zu dem, was auf deinen Servern läuft.

Mosquitto gibt's in zwei Versionen: die Open-Source-Version (die die meisten Anwendungsfälle abdeckt) und die kommerzielle Pro Edition von Cedalo mit erweiterten Funktionen wie Clustering und verbesserter Sicherheit. Bei den meisten Projekten reicht die Open-Source-Version völlig aus.

Als Nächstes werde ich die Voraussetzungen durchgehen, und dann fangen wir mit der Installation von Mosquitto an.

Was du brauchen solltest

Du musst Docker auf deinem System installiert haben, bevor du Mosquitto einsetzen kannst.

Docker Desktop ist für Windows- und macOS-Nutzer am besten geeignet, weil es alles, was du brauchst, in einem Paket hat. Linux-Nutzer können dieDocker-CLI „ “ direkt über ihren Paketmanager oder aus dem offiziellen Repository von Docker installieren.

Docker Compose ist nicht unbedingt nötig, macht aber das Verwalten von Setups mit mehreren Containern echt einfacher. Die meisten Docker Desktop-Installationen haben Compose standardmäßig dabei. Wenn du Linux benutzt, musst du es vielleicht separat installieren.

Du brauchst auch ein paar Grundkenntnisse in der Befehlszeile. Nichts Besonderes, nur die Möglichkeit, Befehle auszuführen, durch Verzeichnisse zu navigieren und Textdateien zu bearbeiten.

Schritt-für-Schritt-Einrichtung

Um Mosquitto Docker zum Laufen zu bringen, musst du drei Schritte machen: Verzeichnisse erstellen, den Container starten und optional Docker Compose einrichten, um die Verwaltung zu vereinfachen.

Erstellen der benötigten Verzeichnisse

Mosquitto braucht einen ordentlichen Speicherplatz für seine Konfiguration, Daten und Protokolle.

Erstell sie, um loszulegen:

mkdir mosquitto-docker
cd mosquitto-docker
mkdir config data logs

Damit hast du ordentliche Ordner für die Konfigurationsdateien von Mosquitto, persistente Daten und die Protokollausgabe.

Hier ist, was jedes Verzeichnis macht:

• /mosquitto/config Speichert mosquitto.conf und alle anderen Konfigurationsdateien.
• /mosquitto/data speichert dauerhafte Nachrichtendaten und Abonnementinfos
• /mosquitto/log enthält die Log-Dateien von Mosquitto zum Debuggen und Überwachen

Diese Verzeichnisse werden als Volumes im Docker-Container eingebunden, sodass deine Einstellungen und Daten auch nach einem Neustart des Containers erhalten bleiben.

Mosquitto mit Docker ausführen

Der grundlegende Docker-Befehl sorgt dafür, dass Mosquitto mit der richtigen Portzuordnung und Volume-Einbindung läuft.

docker run -d \
  --name mosquitto \
  -p 1883:1883 \
  -v $(pwd)/mosquitto/config:/mosquitto/config \
  -v $(pwd)/mosquitto/data:/mosquitto/data \
  -v $(pwd)/mosquitto/log:/mosquitto/log \
  eclipse-mosquitto:latest

Bild 1 – Mosquitto mit Docker ausführen

Lass mich diese Flaggen mal genauer anschauen:

• -d läuft der Container im Hintergrund (getrennter Modus)
• --name mosquitto gibt dem Container einen coolen Namen, damit man ihn leicht wiederfindet
• -p 1883:1883 Port 1883 auf deinem Host wird auf Port 1883 im Container weitergeleitet.
• -v hängt lokale Verzeichnisse als Volumes im Container ein

Mosquitto 2.0+ läuft standardmäßig im lokalen Modus. Das heißt, es werden nur Verbindungen vom lokalen Host akzeptiert, es sei denn, du stellst es anders ein. Du musst eine Konfigurationsdatei erstellen, um externe Verbindungen zuzulassen.

Docker Compose verwenden

Mosquitto Docker Compose macht die Verwaltung der Installation viel einfacher, vor allem wenn du mehrere Dienste betreibst.

Mach eine Datei namens „ docker-compose.yml “ und füge den folgenden Inhalt ein:

services:
  mosquitto:
    image: eclipse-mosquitto:latest
    container_name: mosquitto
    restart: unless-stopped
    ports:
      - "1883:1883"    # MQTT
      - "8883:8883"    # MQTTS (secure)
      - "9001:9001"    # WebSockets
    volumes:
      - ./mosquitto/config:/mosquitto/config
      - ./mosquitto/data:/mosquitto/data
      - ./mosquitto/log:/mosquitto/log

Mach's so:

docker-compose up -d

Bild 2 – Mosquitto mit Docker Compose ausführen

Die Volume-Zuordnungen funktionieren genauso wie der Docker-Befehl, aber Compose kümmert sich um die ganzen komplizierten Sachen. Die Portkonfiguration deckt alle gängigen MQTT-Protokolle ab: Standard-MQTT (1883), sicheres MQTTS (8883) und WebSocket-Verbindungen (9001).

Compose ist echt super bei Multi-Service-Setups. Wenn du zum Beispiel Home Assistant, Node-RED oder andere IoT-Tools zusammen mit Mosquitto nutzt, kannst du alles in einer Datei festlegen und alle Dienste gleichzeitig starten.

Schauen wir uns als Nächstes die Konfiguration genauer an.

Findest du die fortgeschritteneren Docker-Konzepte verwirrend? Unser Docker- Kurs für Fortgeschrittene geht weit über die Grundlagen hinaus.

Mosquitto einrichten

Mosquitto akzeptiert standardmäßig keine externen Verbindungen. Dafür brauchst du eine Konfigurationsdatei.

Grundkonfiguration (mosquitto.conf)

Mach eine Datei namens „ mosquitto.conf “ in deinem Verzeichnis „ mosquitto/config “ und füge Folgendes hinzu:

# Basic listener configuration
listener 1883
allow_anonymous true

# WebSocket listener
listener 9001
protocol websockets
allow_anonymous true

# Persistence
persistence true
persistence_location /mosquitto/data/

# Logging
log_dest file /mosquitto/log/mosquitto.log
log_type error
log_type warning
log_type notice
log_type information

Mit der Einstellung „ allow_anonymous true “ können sich Clients ohne Anmeldedaten verbinden. Das klappt super für Entwicklungs- oder interne Netzwerke, aber in Produktionsumgebungen solltest du es lieber deaktivieren. Wenn du „ allow_anonymous false “ einstellst, muss sich jeder Client mit einem Benutzernamen und einem Passwort anmelden.

Der WebSocket-Listener auf Port 9001 macht browserbasierte MQTT-Clients möglich. Web-Apps können über JavaScript-Bibliotheken wie Paho MQTT direkt mit deinem Broker verbunden werden.

Einrichten der Authentifizierung

Für die Authentifizierung musst du eine Passwortdatei erstellen und deine Konfiguration anpassen.

Mach eine Passwortdatei im Container:

docker exec -it mosquitto mosquitto_passwd -c /mosquitto/config/passwd username

Bild 3 – Mosquitto-Authentifizierung

Dadurch wird eine neue Passwortdatei erstellt und du wirst aufgefordert, ein Passwort einzugeben. Für weitere Benutzer musst du das Flag „ -c “ entfernen:

docker exec -it mosquitto mosquitto_passwd /mosquitto/config/passwd another_user

Jetzt musst du deine Datei „ mosquitto.conf “ aktualisieren, um die Authentifizierung zu erzwingen:

# Disable anonymous access
allow_anonymous false

# Point to password file
password_file /mosquitto/config/passwd

# Basic MQTT listener
listener 1883

# WebSocket listener
listener 9001
protocol websockets

# Persistence
persistence true
persistence_location /mosquitto/data/

# Logging
log_dest file /mosquitto/log/mosquitto.log
log_type error
log_type warning
log_type notice
log_type information

Die Passwortdatei wird in deinem gemounteten Konfigurationsvolume gespeichert, sodass sie auch nach einem Neustart des Containers erhalten bleibt.

TLS/SSL aktivieren

TLS-Verschlüsselung schützt deinen MQTT-Datenverkehr vor Abhören und Manipulation.

Füge diese Zeilen zu deiner Datei „ mosquitto.conf “ hinzu:

# Secure MQTT listener
listener 8883
cafile /mosquitto/config/ca.crt
certfile /mosquitto/config/server.crt
keyfile /mosquitto/config/server.key

# Secure WebSocket listener
listener 9002
protocol websockets
cafile /mosquitto/config/ca.crt
certfile /mosquitto/config/server.crt
keyfile /mosquitto/config/server.key

Du musst SSL-Zertifikate für deine Domain besorgen. Let's Encrypt bietet kostenlose Zertifikate an, oder du kannst Reverse-Proxys wie Caddy Server nutzen, die die Zertifikatserstellung automatisch übernehmen. Leg deine Zertifikatsdateien im Verzeichnis „ mosquitto/config “ ab, damit sie im Container verfügbar sind.

Persistenz und Protokollierung

Persistenz speichert Nachrichten und Abonnements auf der Festplatte, während ordnungsgemäße Protokollierung dir beim Debuggen von Verbindungsproblemen hilft.

Du kannst die Persistenz in „ mosquitto.conf “ so einstellen:

# Enable persistence
persistence true
persistence_location /mosquitto/data/

# Save to disk every 300 seconds
autosave_interval 300

# Keep messages for offline clients
persistent_client_expiration 1d

Was die Protokollierung angeht, kannst du detaillierte Protokolle so einrichten:

# Log to file and stdout
log_dest file /mosquitto/log/mosquitto.log
log_dest stdout

# Choose what to log
log_type error
log_type warning
log_type notice
log_type information
log_type debug

# Log connection details
connection_messages true
log_timestamp true

Mit den Optionen „ log_type “ kannst du filtern, was protokolliert wird:

• error und warning für die Produktionsüberwachung
• notice und information für allgemeine Einblicke in den Betrieb
• debug zur Fehlerbehebung bei Verbindungsproblemen

Deine Volume-Mounts sorgen dafür, dass sowohl persistente Daten als auch Protokolle nach einem Neustart des Containers erhalten bleiben. Im Datenverzeichnis werden alle dauerhaften Nachrichten und Abonnementinfos gespeichert, während das Protokollverzeichnis deine Debugging-Infos vom Hostsystem zugänglich hält.

Mit Konfigurationsdateien kannst du das Verhalten von Mosquitto komplett steuern, ohne Container neu erstellen zu müssen.

Das Setup testen

Dein Broker ist erst dann nützlich, wenn du sicherstellst, dass Kunden eine Verbindung herstellen und Nachrichten austauschen können.

Mit mosquitto_pub und mosquitto_sub

Die Befehlszeilentools „ mosquitto_pub “ und „ mosquitto_sub “ sind der schnellste Weg, um deinen Broker zu testen.

Fang damit an, Mosquitto zu installieren, je nachdem, welche Plattform du hast:

• Linux (Ubuntu/Debian): sudo apt-get install mosquitto-clients
• macOS: brew install mosquitto
• Windows: Lade es von der offiziellen Eclipse Mosquitto-Website runter oder nutze WSL.

Probieren wir es mal ohne Authentifizierung aus. Du brauchst zwei Terminalfenster oder Registerkarten. Führ diese Befehle in separaten Sitzungen aus:

# Subscribe to a topic (run this first)
mosquitto_sub -h localhost -p 1883 -t test/topic

# Publish a message (run in another terminal)
mosquitto_pub -h localhost -p 1883 -t test/topic -m "Hello MQTT"

Auf der Registerkarte „Veröffentlichen“ siehst du Folgendes:

Bild 4 – Eine Nachricht posten

Und auf der Registerkarte „Abonnieren“ siehst du sofort die Meldung:

Bild 5 – Ein Mosquitto-Thema abonnieren

Wenn du eine Authentifizierung brauchst, sind die Befehle ziemlich ähnlich – du musst nur deinen Benutzernamen und dein Passwort angeben:

# Subscribe with username and password
mosquitto_sub -h localhost -p 1883 -t test/topic -u username -P password

# Publish with credentials
mosquitto_pub -h localhost -p 1883 -t test/topic -m "Authenticated message" -u username -P password

Wenn du die Mosquitto-Clients nicht lokal installieren willst, kannst du sie in deinem Docker-Container ausführen:

# Subscribe using the container
docker exec -it mosquitto mosquitto_sub -h localhost -t test/topic

# Publish using the container
docker exec -it mosquitto mosquitto_pub -h localhost -t test/topic -m "Container message"

Du siehst das im Reiter „Veröffentlichen“:

Bild 6 – Eine Nachricht ohne Authentifizierung posten

Und auf der Registerkarte „Abonnieren“ siehst du die Meldung:

Bild 7 – Ein Mosquitto-Thema ohne Authentifizierung abonnieren

Testen mit MQTT-Clients

GUI-Clients machen es einfacher, komplizierte Szenarien zu testen und den laufenden Nachrichtenverkehr zu überwachen.

MQTT Explorer hat eine übersichtliche Oberfläche zum Durchsuchen von Themen und zum Senden von Nachrichten. Geh auf localhost:1883 und du siehst eine Baumansicht aller aktiven Themen. Es ist super, um den Nachrichtenfluss zu checken und deine Themenstruktur zu verstehen.

Bild 8 – MQTT Explorer App

MQTTX hat noch mehr coole Funktionen wie Skripting und das Versenden von vielen Nachrichten auf einmal. Beide Clients unterstützen Authentifizierung, TLS-Verbindungen und WebSocket-Protokolle.

Home Assistant-Nutzer können die MQTT-Integration direkt über die Entwicklertools ausprobieren. Füge deine Broker-Details zur MQTT-Integration hinzu und nutze die eingebaute Publish/Subscribe-Schnittstelle.

Für programmatische Tests eignet sich der Paho MQTT Python-Client gut:

import paho.mqtt.client as mqtt

def on_connect(client, userdata, flags, rc):
    print(f"Connected with result code {rc}")
    client.subscribe("test/topic")

def on_message(client, userdata, msg):
    print(f"Received: {msg.payload.decode()}")

client = mqtt.Client()
# client.username_pw_set("username", "password")  # If using auth
client.on_connect = on_connect
client.on_message = on_message

client.connect("localhost", 1883, 60)
client.loop_forever()

Führ dieses Skript in einem Terminal aus und veröffentliche dann Nachrichten von einem anderen Terminal oder GUI-Client aus. Das Skript zeigt alle Nachrichten an, die es bekommt, und bestätigt damit, dass dein Broker den Datenverkehr richtig weiterleitet.

Hier ist, was du machen musst, um eine Nachricht zu posten:

Bild 9 – Eine Nachricht für das Python-Beispiel veröffentlichen

Und du wirst das in der Terminal-Sitzung sehen, in der das Python-Skript läuft:

Bild 10 – Eine Nachricht für das Python-Beispiel bekommen

Wenn die Publish- und Subscribe-Operationen funktionieren, ist dein Mosquitto-Docker-Setup bereit für echte Anwendungen.

Mosquitto Docker mit Home Assistant verbinden

Wenn du Mosquitto zusammen mit Home Assistant in Docker laufen lässt, hast du einen kompletten IoT-Messaging-Hub, ohne dich um die Netzwerkkonfiguration kümmern zu müssen.

Docker Compose macht das echt einfach. Beide Dienste können über das interne Netzwerk von Docker kommunizieren, ohne dass zusätzliche Ports freigegeben oder IP-Adressen verwaltet werden müssen.

Hier ist ein kompletter „ docker-compose.yml ”, der beide Dienste ausführt:

services:
  mosquitto:
    image: eclipse-mosquitto:latest
    container_name: mosquitto
    restart: unless-stopped
    ports:
      - "1883:1883"
      - "9001:9001"
    volumes:
      - ./mosquitto/config:/mosquitto/config
      - ./mosquitto/data:/mosquitto/data
      - ./mosquitto/log:/mosquitto/log
    networks:
      - homeassistant

  homeassistant:
    image: ghcr.io/home-assistant/home-assistant:stable
    container_name: homeassistant
    restart: unless-stopped
    ports:
      - "8123:8123"
    volumes:
      - ./homeassistant:/config
      - /etc/localtime:/etc/localtime:ro
    networks:
      - homeassistant
    depends_on:
      - mosquitto

networks:
  homeassistant:
    driver: bridge

Der Abschnitt „ networks “ macht ein gemeinsames Netzwerk, wo beide Container sich über ihren Namen erreichen können. Home Assistant kann sich mit mosquitto:1883 verbinden, anstatt localhost oder IP-Adressen zu verwenden.

Starte beide Dienste mit:

docker-compose up -d

Als Nächstes richtest du die MQTT-Integration über die Weboberfläche von Home Assistant ein. Geh zu „Einstellungen“ > „Geräte und Dienste“ > „Integration hinzufügen“ und such dann nach „MQTT“.

Gib diese Verbindungsdaten ein:

• Broker: mosquitto (der Name des Containers)
• Port: 1883
• Benutzername/Passwort: Deine Anmeldedaten, wenn die Authentifizierung aktiviert ist
• Behalte die anderen Einstellungen wie sie sind.

Klick auf „Senden“ und Home Assistant checkt die Verbindung. Wenn alles geklappt hat, siehst du MQTT in deiner Integrationsliste.

Bild 11 – Mosquitto-Konfiguration mit Homelab

Du kannst jetzt MQTT-Geräte hinzufügen, Automatisierungen erstellen, die Nachrichten veröffentlichen, und Sensordaten über Themen überwachen. Die MQTT-Integration von Home Assistant kümmert sich automatisch um die Erkennung kompatibler Geräte.

Fehlerbehebung bei häufigen Problemen

Die meisten Probleme mit Docker Mosquitto hängen mit Berechtigungen, Ports oder Konfigurationsfehlern zusammen, die Verbindungen blockieren.

Berechtigungsfehler bei gemounteten Volumes 

Das passiert, wenn der Container nicht in deine Host-Verzeichnisse schreiben kann. In den Protokollen siehst du Fehlermeldungen wie „Zugriff verweigert“ oder „Verzeichnis kann nicht erstellt werden“.

Behebe das Problem, indem du die richtigen Eigentumsrechte für deine Verzeichnisse festlegst:

sudo chown -R 1883:1883 mosquitto/

Der Mosquitto-Container läuft mit der Benutzer-ID 1883, also müssen deine Host-Verzeichnisse passen. Auf manchen Systemen musst du vielleicht erst den Benutzer anlegen:

sudo useradd -u 1883 mosquitto
sudo chown -R mosquitto:mosquitto mosquitto/

Port-Konflikte

Das passiert, wenn ein anderes Programm den Port 1883 benutzt. Schau mal, was auf diesem Port läuft:

# Linux/macOS
sudo lsof -i :1883

# Windows
netstat -an | findstr :1883

Wenn ein anderer Dienst den Port benutzt, schalt ihn entweder aus oder ordne Mosquitto einem anderen Port zu:

docker run -p 1884:1883 eclipse-mosquitto:latest

Der Modus „Nur lokal“ verhindert externe Verbindungen.

Das passiert auch, wenn dein Container läuft. Mosquitto 2.0+ akzeptiert standardmäßig nur Verbindungen vom lokalen Host, es sei denn, du stellst es anders ein.

Mach mal 'ne einfache Datei namens „ mosquitto.conf “, um externe Verbindungen zuzulassen:

listener 1883
allow_anonymous true

Leg diese Datei in deinem Verzeichnis „ mosquitto/config ” ab und starte den Container neu.

Leere Verzeichnisse beim Start

Das heißt, deine Lautstärkeregler funktionieren nicht richtig. Überprüfe, ob deine Pfade absolut sind und die Verzeichnisse existieren:

# Wrong - relative path might not work
-v ./mosquitto/config:/mosquitto/config

# Better - absolute path
-v $(pwd)/mosquitto/config:/mosquitto/config

Mach die Verzeichnisse fertig, bevor du den Container startest:

mkdir -p mosquitto/{config,data,log}

Konflikt zwischen UIDs/GIDs von Host und Container

Das führt zu dauerhaften Berechtigungsproblemen. Der Container sollte eigentlich als Benutzer 1883 laufen, aber dein Host-System hat vielleicht andere Anforderungen an die Eigentumsrechte.

Lass den Container als dein Benutzer laufen:

docker run --user $(id -u):$(id -g) eclipse-mosquitto:latest

Oder passe die Berechtigungen deines Host-Verzeichnisses an die Anforderungen des Containers an. Der Container-Ansatz eignet sich besser für die Entwicklung, während die Korrektur der Host-Berechtigungen besser für Produktionsbereitstellungen funktioniert.

Schau dir die Containerprotokolle an, wenn was nicht klappt – da steht meistens genau, was los ist.

Fortgeschritten: Funktionen der Mosquitto Pro Edition

Die Open-Source-Version von Mosquitto deckt die meisten Anwendungsfälle ab, aber in Unternehmensumgebungen braucht man Funktionen, die nur die Pro Edition bietet.

Mit dem rollenbasierten Benutzerverwaltungs kannst du detaillierte Berechtigungen für verschiedene Benutzergruppen festlegen. Anstatt den Zugriff einzelner Benutzer zu verwalten, legst du Rollen wie „Sensor-Lesegeräte”, „Aktuator-Steuerungen” oder „Admin-Benutzer” an und gibst den ganzen Rollen Berechtigungen. Benutzer bekommen die Berechtigungen ihrer Rollen, was die Verwaltung des Zugriffs auf Hunderte oder Tausende von Geräten einfacher macht.

Du kannst den Zugriff nach Themenmustern, IP-Bereichen oder Zeitfenstern einschränken. Das ist viel besser, als ACL-Dateien manuell zu konfigurieren, wenn du komplexe IoT-Bereitstellungen mit unterschiedlichen Sicherheitsanforderungen verwaltest.

Die erweiterten Authentifizierungsoptionen bieten mehr als nur einfache Kombinationen aus Benutzername und Passwort. Die JWT-Token-Authentifizierung lässt sich mit bestehenden Identitätsanbietern wie Auth0, Okta oder dem SSO-System deines Unternehmens verbinden. Die LDAP-Integration verbindet sich direkt mit Active Directory oder anderen Unternehmensverzeichnisdiensten.

Mit dem Deep Inspection and Monitoring-, kannst du in Echtzeit sehen, wie Nachrichten fließen, wie Verbindungen laufen und wie gut der Broker arbeitet. Die Pro Edition hat eingebaute Dashboards, die zeigen, welche Kunden die meiste Bandbreite verbrauchen, welche Themen die meisten Nachrichten haben und wo sich Engpässe bilden.

Du bekommst detaillierte Infos zu Nachrichtenverzögerungen, Warteschlangentiefen und Verhaltensmustern der Kunden. Mit diesen Infos kannst du Themenstrukturen optimieren und problematische Kunden erkennen, bevor sie das ganze System beeinträchtigen.

Die Datenbank- und Cloud-Service-Integrationen v, machen spezielle Brückenanwendungen überflüssig. Die Pro Edition kann Nachrichten automatisch an PostgreSQL, MongoDB, InfluxDB, AWS IoT Core, Azure IoT Hub oder Google Cloud IoT weiterleiten. Du legst Routing-Regeln fest, die bestimmen, welche Nachrichten wohin gehen, basierend auf Themenmustern, Nachrichteninhalten oder Client-Metadaten.

Persistente Warteschlangen sind für Szenarien mit hohem Volumen gedacht, wo die Standard-Persistenz von Mosquitto nicht ausreicht. Die Pro Edition kann Millionen von Nachrichten für Offline-Clients zwischenspeichern und die Last auf mehrere Broker-Instanzen verteilen. Es hat ein automatisches Warteschlangenmanagement, das verhindert, dass der Speicher voll wird, und dafür sorgt, dass die Reihenfolge der Nachrichten immer stimmt.

Mit Clustering-Unterstützung kannst du mehrere Broker-Instanzen laufen lassen, die sich die Nachrichtenlast teilen und Failover-Schutz bieten. Wenn ein Broker ausfällt, verbinden sich die Kunden automatisch mit funktionierenden Instanzen, ohne dass Nachrichten oder Abonnements verloren gehen.

Die Pro Edition ist genau das Richtige für dich, wenn du zuverlässige Funktionen für Unternehmen und Verwaltungsfunktionen brauchst, deren Entwicklung selbst Monate dauern würde.

Vor- und Nachteile von Mosquitto in Docker

Docker macht die Bereitstellung einfacher, aber es ist nicht für jedes Szenario die perfekte Lösung.

Vorteile

• Die plattformübergreifende Konsistenz von macht Schluss mit den Problemen bei betriebssystemspezifischen Installationen. Der gleiche Docker-Befehl funktioniert unter Windows, macOS und Linux, ohne dass man verschiedene Paketmanager suchen oder sich mit Abhängigkeitskonflikten herumschlagen muss. Deine Entwicklungsumgebung ist genau wie die Produktionsumgebung, was bedeutet, dass du beim Deployment weniger Überraschungen erlebst.
• Einfache Versions-Upgrades machst du, indem du die Bild-Tags änderst. Anstatt die alte Version zu deinstallieren und zu hoffen, dass das Upgrade deine Konfiguration nicht kaputt macht, holst du dir einfach ein neues Image und startest den Container neu. Wenn was schiefgeht, dauert das Zurücksetzen nur ein paar Sekunden.
• Einfaches Backup und Migration, weil du Volumes für deine Daten nutzt. Kopier das Verzeichnis „ mosquitto ” auf einen anderen Rechner, führ denselben Docker-Befehl aus, und schon bist du wieder online. Der Wechsel zwischen Cloud-Anbietern oder das Upgrade von Hardware wird zu einer einfachen Dateiübertragung.

Nachteile

Docker hat nicht nur Vorteile.

• Probleme mit den Berechtigungen für Volumes treten bei bestimmten Betriebssystemen auf, vor allem beim Wechsel zwischen Windows- und Linux-Hosts. Du wirst Zeit damit verbringen, Probleme mit den Eigentumsrechten zu beheben und dich mit UID/GID-Inkompatibilitäten herumzuschlagen, die bei einer nativen Installation nicht auftreten würden.
• Da für ein produktionsreifes Sicherheits zusätzliche Konfigurationen nötig sind, macht Docker die Sache eher komplizierter, statt sie zu vereinfachen. Du musst Netzwerkrichtlinien, Containersicherheitskontexte und Volumeverschlüsselung zusätzlich zu den Sicherheitsfunktionen von Mosquitto verwalten. Mit nativen Installationen kannst du die vorhandenen Sicherheitsframeworks deines Betriebssystems direkt nutzen.
• In Szenarien mit hohem Durchsatz, wo jede Mikrosekunde zählt, kann es zu Leistungseinbußen kommen, wenn die Daten. Die Container-Netzwerkschicht und die Volume-Mounts verursachen einen Mehraufwand, den native Installationen vermeiden. Für die meisten IoT-Anwendungen ist dieser Unterschied nicht so wichtig, aber bei Echtzeit-Industriesystemen könnte die Latenzzeit auffallen.

Docker ist die beste Wahl, wenn du einheitliche Bereitstellungen und eine einfache Verwaltung in verschiedenen Umgebungen brauchst.

Fazit

Wenn du Mosquitto in Docker laufen lässt, hast du einen zuverlässigen MQTT-Broker, der in allen Umgebungen gleich gut funktioniert. Egal, ob du Prototypen für IoT-Geräte entwickelst, Hausautomatisierungssysteme aufbaust oder Sensoren in der Entwicklung verbindest – Docker macht die Einrichtung einfach und lässt dich dich voll auf dein Projekt konzentrieren.

Wenn du Mosquitto in der Produktion einsetzen willst, denk daran:

• Mach deinen Broker sicher, bevor du ihn ins Internet stellst.
• Aktiviere die Authentifizierung mit mosquitto_passwd und richte die TLS-Verschlüsselung mit den richtigen Zertifikaten ein.
• Beschränk den Zugriff nur auf die Kunden, die ihn brauchen.

Ein ungeschützter MQTT-Broker ist für Angreifer ein leichtes Ziel, um die Kommunikation von Geräten zu überwachen oder bösartige Befehle einzuschleusen.

Für Unternehmen, die erweiterte Funktionen wie rollenbasierte Zugriffskontrolle, Clustering oder LDAP-Integration brauchen, bietet Mosquitto Pro Edition Management-Tools und Skalierbarkeit, die über die Open-Source-Version hinausgehen.

Bist du bereit, deine Docker- und Kubernetes-Kenntnisse zu verbessern? Mach bei unserem Kurs mit Kurs „Containerisierung und Virtualisierung mit Docker und Kubernetes” Lernpfad, um die richtigen Fähigkeiten zu lernen und einen Job zu finden.