MQTT Client-Bibliotheken: Die richtige Wahl für jede Programmiersprache

Die Wahl zwischen MQTT Client-Bibliotheken ist die erste echte Engineering-Entscheidung in jedem MQTT-Projekt, und eine falsche Wahl rächt sich später in Form von Reconnect-Bugs, fehlenden MQTT-5-Funktionen oder einer blockierten Event-Loop. Dieser Leitfaden vergleicht die gepflegten Optionen für Python, JavaScript, Go, Java, C#, Rust, C, Mikrocontroller und Mobile und liefert für jede ein minimales Snippet, das sich mit dem kostenlosen Broker broker.connectmq.com verbindet. Am Ende wissen Sie, welche Bibliothek zu Ihrem Stack passt und was Sie prüfen sollten, bevor Sie sich festlegen.

Was eine MQTT Client-Bibliothek tatsächlich leistet

Eine MQTT Client-Bibliothek verbirgt das Binärprotokoll hinter wenigen Aufrufen: connect, subscribe, publish, disconnect. Unter der Haube erledigt sie jedoch deutlich mehr, und genau bei diesen verborgenen Aufgaben unterscheiden sich Bibliotheken:

• Kodierung und Dekodierung von Paketen für MQTT 3.1.1 und, in besseren Bibliotheken, für MQTT-5.0-Properties wie Reason Codes, Message Expiry und User Properties.
• Keep-Alive-Pings, damit der Broker weiß, dass die Verbindung intakt ist.
• QoS-Zustandsautomaten, die laufende QoS-1- und QoS-2-Nachrichten speichern und nach einem Reconnect erneut senden.
• Reconnect-Logik mit Backoff sowie erneutes Abonnieren, wenn die Session nicht persistiert wurde.
• Transport-Handling für TCP, TLS und WebSocket.
• Threading- oder Async-Integration in Ihre Laufzeitumgebung: ein Hintergrund-Thread, eine Event-Loop, Goroutinen oder Callbacks.

Eine Bibliothek, die die Protokollkodierung beherrscht, Reconnects aber schlecht handhabt, besteht jede Demo und scheitert im Feld. Behalten Sie das beim Lesen des folgenden Vergleichs im Hinterkopf. Wenn die Broker-Seite noch unklar ist, lesen Sie zuerst, was ein MQTT Broker leistet; jede Bibliothek hier ist lediglich ein Client eines solchen.

So bewerten Sie MQTT Client-Bibliotheken

Nutzen Sie diese Checkliste, bevor Sie eine Bibliothek einsetzen, unabhängig von der Sprache:

1. Wartung. Achten Sie auf aktuelle Releases und darauf, wie mit Issues umgegangen wird. MQTT selbst ist stabil, aber TLS-Stacks, Laufzeitumgebungen und Plattformen entwickeln sich ständig weiter.
2. Protokollversion. Brauchen Sie MQTT 5? Shared Subscriptions, Message Expiry, Request/Response und detaillierte Reason Codes gibt es nur dort.
3. Transporte. Browser benötigen WebSocket; abgeschottete Firmennetzwerke erfordern oft WSS auf Ports im Stil von 443; Geräte nutzen meist TLS auf 8883.
4. Nebenläufigkeitsmodell. Callback-basiert, Thread-basiert oder async/await. Wählen Sie, was zum Rest Ihrer Codebasis passt, nicht was im README am kürzesten aussieht.
5. Reconnect und Offline-Pufferung. Verbindet sich die Bibliothek automatisch neu? Puffert sie Publishes während der Offline-Phase, und ist dieser Puffer begrenzt?
6. Persistenz laufender Nachrichten. Nur im Speicher oder dateibasiert? Das ist für QoS 1 und 2 über Prozessneustarts hinweg relevant.
7. Ressourcenbedarf. Auf Mikrocontrollern entscheiden RAM und Flash alles; auf Servern spielen sie selten eine Rolle.
8. Lizenz. Die meisten populären Bibliotheken verwenden EPL/EDL, MIT oder Apache 2.0, prüfen Sie dies aber, bevor Sie ein kommerzielles Produkt ausliefern.

MQTT Client-Bibliotheken im Überblick

Die Tabelle gibt die dokumentierten Fähigkeiten der Bibliotheken zum Zeitpunkt des Schreibens wieder. Prüfen Sie stets die aktuellen Release Notes des jeweiligen Projekts, denn insbesondere die MQTT-5-Unterstützung kam schrittweise hinzu. Die Eclipse-Paho-Projektseite unter eclipse.dev/paho ist ein guter Ausgangspunkt für die Paho-Familie.

Python: paho-mqtt und aiomqtt

paho-mqtt ist die Standardwahl für Python und funktioniert nahezu überall, vom Raspberry Pi bis zum Container. Version 2.x brachte eine inkompatible Änderung: Sie müssen eine Callback-API-Version übergeben, und die v2-Callbacks erhalten Reason Codes und Properties. Die meisten „Es funktioniert nicht“-Meldungen entstehen, weil 1.x-Beispiele in eine 2.x-Installation kopiert werden. Das wird ausführlich in der Lösung für paho-mqtt 2.0 CallbackAPIVersion behandelt.

import uuid
import paho.mqtt.client as mqtt

TOPIC = "connectmq/demo/k3x8p1/libs/python"

def on_connect(client, userdata, flags, reason_code, properties):
    print("Connected:", reason_code)
    client.subscribe(TOPIC, qos=1)
    client.publish(TOPIC, "hello from paho-mqtt", qos=1)

def on_message(client, userdata, msg):
    print(msg.topic, msg.payload.decode())

client = mqtt.Client(
    mqtt.CallbackAPIVersion.VERSION2,
    client_id=f"libs-py-{uuid.uuid4().hex[:8]}",
    protocol=mqtt.MQTTv5,
)
client.on_connect = on_connect
client.on_message = on_message
client.tls_set()
client.connect("broker.connectmq.com", 8883, keepalive=30)
client.loop_forever()

aiomqtt kapselt paho in einer idiomatischen asyncio-API mit async with und async for. Wenn Ihr Service bereits eine Event-Loop betreibt, verwenden Sie diese Bibliothek, statt Threads und Coroutinen zu mischen. Die vollständigen Anleitungen finden Sie in unserem paho-mqtt Python Tutorial und im aiomqtt-asyncio-Leitfaden.

JavaScript und TypeScript: MQTT.js

MQTT.js ist die De-facto-Bibliothek für Node.js und den Browser, bringt TypeScript-Typen mit und unterstützt MQTT 5. In Node.js verbindet sie sich über TCP oder TLS; im Browser nutzt sie WebSocket, sodass sich lediglich das URL-Schema ändert.

import mqtt from "mqtt";

const clientId = "libs-js-" + Math.random().toString(16).slice(2, 10);
const topic = "connectmq/demo/k3x8p1/libs/javascript";

// Node.js: mqtts://broker.connectmq.com:8883
// Browser: wss://broker.connectmq.com:8084/mqtt
const client = mqtt.connect("mqtts://broker.connectmq.com:8883", {
  clientId,
  protocolVersion: 5,
});

client.on("connect", async () => {
  await client.subscribeAsync(topic, { qos: 1 });
  await client.publishAsync(topic, "hello from MQTT.js", { qos: 1 });
});

client.on("message", (t, payload) => console.log(t, payload.toString()));
client.on("error", (err) => console.error(err.message));

MQTT.js verbindet sich standardmäßig automatisch neu (reconnectPeriod steuert die Verzögerung). Denken Sie im Browser daran, dass eine HTTPS-Seite nur wss://-Verbindungen öffnen kann. Framework-spezifische Muster finden Sie in MQTT.js mit Node.js und MQTT im Browser mit JavaScript.

Go: Eclipse Paho

Für Go gibt es zwei Eclipse-Projekte. paho.mqtt.golang ist der seit Langem etablierte MQTT-3.1.1-Client, der in sehr vielen produktiven Services läuft. paho.golang ist die neuere MQTT-5-Implementierung mit einem autopaho-Paket, das die Wiederverbindung für Sie übernimmt. Für ein neues MQTT-5-Projekt starten Sie mit paho.golang; für breite 3.1.1-Kompatibilität und die größte Menge an Beispielen bleibt der klassische Client eine solide Wahl.

package main

import (
	"crypto/tls"
	"fmt"
	"math/rand"
	"time"

	mqtt "github.com/eclipse/paho.mqtt.golang"
)

func main() {
	topic := "connectmq/demo/k3x8p1/libs/go"
	opts := mqtt.NewClientOptions().
		AddBroker("tls://broker.connectmq.com:8883").
		SetClientID(fmt.Sprintf("libs-go-%06d", rand.Intn(1000000))).
		SetTLSConfig(&tls.Config{MinVersion: tls.VersionTLS12}).
		SetAutoReconnect(true)

	client := mqtt.NewClient(opts)
	if token := client.Connect(); token.Wait() && token.Error() != nil {
		panic(token.Error())
	}

	client.Subscribe(topic, 1, func(_ mqtt.Client, m mqtt.Message) {
		fmt.Printf("%s %s\n", m.Topic(), m.Payload())
	}).Wait()

	client.Publish(topic, 1, false, "hello from Go").Wait()
	time.Sleep(2 * time.Second)
	client.Disconnect(250)
}

Unter einen Go MQTT Client bauen finden Sie Graceful Shutdown und strukturierte Payloads.

Java und Kotlin: Paho und HiveMQ Client

Eclipse Paho Java liefert zwei Pakete: org.eclipse.paho.client.mqttv3 für MQTT 3.1.1 und org.eclipse.paho.mqttv5.client für MQTT 5. Der HiveMQ MQTT Client ist eine Alternative mit blockierenden, asynchronen und reaktiven APIs, die gut zu Reactor- oder RxJava-Codebasen passt. Beide laufen auch auf Android, weshalb Kotlin-Apps sie häufig direkt verwenden.

import org.eclipse.paho.client.mqttv3.*;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
import java.util.UUID;

public class LibsJava {
    public static void main(String[] args) throws Exception {
        String topic = "connectmq/demo/k3x8p1/libs/java";
        String clientId = "libs-java-" + UUID.randomUUID().toString().substring(0, 8);

        MqttClient client = new MqttClient("ssl://broker.connectmq.com:8883",
                clientId, new MemoryPersistence());
        MqttConnectOptions options = new MqttConnectOptions();
        options.setAutomaticReconnect(true);
        options.setCleanSession(true);
        client.connect(options);

        client.subscribe(topic, 1, (t, msg) ->
                System.out.println(t + " " + new String(msg.getPayload())));
        client.publish(topic, "hello from Paho Java".getBytes(), 1, false);

        Thread.sleep(2000);
        client.disconnect();
        client.close();
    }
}

Spring-Boot-Nutzer kapseln dies meist in Spring Integration; die Muster finden Sie in unserem Leitfaden zum Java MQTT Client und im Tutorial zu Android MQTT mit Kotlin.

C# und .NET: MQTTnet

MQTTnet ist die Standardbibliothek für .NET und unterstützt MQTT 5, TLS und WebSocket. Sie ist vollständig asynchron und passt zu ASP.NET Core Hosted Services, .NET-MAUI-Apps und Unity. In vielen Fertigungsbetrieben ist sie zudem die naheliegende Wahl, wenn bestehende MES- oder Leitstandsanwendungen auf .NET basieren. Beachten Sie, dass sich die Hauptversionen unterscheiden: Version 5 hat die Factory in MqttClientFactory umbenannt, während Version 4 MqttFactory verwendet. Das Snippet zielt auf Version 5.

using MQTTnet;
using MQTTnet.Formatter;

var topic = "connectmq/demo/k3x8p1/libs/csharp";
var factory = new MqttClientFactory();
using var client = factory.CreateMqttClient();

client.ApplicationMessageReceivedAsync += e =>
{
    Console.WriteLine($"{e.ApplicationMessage.Topic} {e.ApplicationMessage.ConvertPayloadToString()}");
    return Task.CompletedTask;
};

var options = new MqttClientOptionsBuilder()
    .WithTcpServer("broker.connectmq.com", 8883)
    .WithClientId($"libs-cs-{Guid.NewGuid():N}"[..16])
    .WithProtocolVersion(MqttProtocolVersion.V500)
    .WithTlsOptions(o => o.UseTls())
    .Build();

await client.ConnectAsync(options);
await client.SubscribeAsync(factory.CreateSubscribeOptionsBuilder()
    .WithTopicFilter(topic).Build());

await client.PublishAsync(new MqttApplicationMessageBuilder()
    .WithTopic(topic).WithPayload("hello from MQTTnet").Build());

await Task.Delay(2000);
await client.DisconnectAsync();

Der Low-Level-Client von MQTTnet verbindet sich nicht von selbst neu, kapseln Sie die Verbindung daher in eine Schleife oder einen Background Service. Das MQTTnet Tutorial zeigt ein robustes Hosted-Service-Muster.

Rust: rumqttc

rumqttc ist der am weitesten verbreitete Rust-Client. Er trennt das Client-Handle von einer Event-Loop, die Sie pollen, und gibt Ihnen so explizite Kontrolle über Back-Pressure. Es gibt Module für MQTT 3.1.1 und MQTT 5.

use rumqttc::{AsyncClient, Event, MqttOptions, Packet, QoS};
use std::time::Duration;

#[tokio::main]
async fn main() {
    let topic = "connectmq/demo/k3x8p1/libs/rust";
    let mut opts = MqttOptions::new("libs-rust-k3x8p1", "broker.connectmq.com", 1883);
    opts.set_keep_alive(Duration::from_secs(30));

    let (client, mut eventloop) = AsyncClient::new(opts, 10);
    client.subscribe(topic, QoS::AtLeastOnce).await.unwrap();
    client.publish(topic, QoS::AtLeastOnce, false, "hello from rumqttc").await.unwrap();

    loop {
        match eventloop.poll().await {
            Ok(Event::Incoming(Packet::Publish(p))) => {
                println!("{} {}", p.topic, String::from_utf8_lossy(&p.payload));
            }
            Ok(_) => {}
            Err(e) => {
                eprintln!("connection error: {e}");
                tokio::time::sleep(Duration::from_secs(2)).await;
            }
        }
    }
}

Das erneute Pollen der Event-Loop nach einem Fehler ist die Art, wie rumqttc sich neu verbindet. Für TLS benötigen Sie eines der TLS-Feature-Flags; der rumqttc-Leitfaden beschreibt dieses Setup.

C und Embedded: Paho C, libmosquitto, PubSubClient, esp-mqtt

Für native Linux-Anwendungen, etwa auf Industrie-PCs und Edge-Gateways neben der SPS, bietet Eclipse Paho C synchrone und asynchrone APIs mit MQTT-5-Unterstützung, und libmosquitto ist eine kleine, praxiserprobte Alternative aus dem Mosquitto-Projekt.

#include <stdio.h>
#include <string.h>
#include "MQTTClient.h"

int main(void) {
    MQTTClient client;
    MQTTClient_connectOptions opts = MQTTClient_connectOptions_initializer;
    MQTTClient_message msg = MQTTClient_message_initializer;
    MQTTClient_deliveryToken token;
    const char *topic = "connectmq/demo/k3x8p1/libs/c";
    char payload[] = "hello from Paho C";

    MQTTClient_create(&client, "tcp://broker.connectmq.com:1883", "libs-c-k3x8p1",
                      MQTTCLIENT_PERSISTENCE_NONE, NULL);
    opts.keepAliveInterval = 30;
    opts.cleansession = 1;

    if (MQTTClient_connect(client, &opts) != MQTTCLIENT_SUCCESS) {
        fprintf(stderr, "connect failed\n");
        return 1;
    }

    msg.payload = payload;
    msg.payloadlen = (int)strlen(payload);
    msg.qos = 1;
    msg.retained = 0;
    MQTTClient_publishMessage(client, topic, &msg, &token);
    MQTTClient_waitForCompletion(client, token, 10000L);

    MQTTClient_disconnect(client, 10000);
    MQTTClient_destroy(&client);
    return 0;
}

Auf Mikrocontrollern verschieben sich die Abwägungen. PubSubClient ist winzig und einfach, unterstützt aber nur MQTT 3.1.1, veröffentlicht mit QoS 0 und hat einen Standard-Paketpuffer von 256 Bytes, den Sie für JSON-Payloads mit setBufferSize() vergrößern müssen. AsyncMqttClient ergänzt Publishing mit QoS 1 und 2 in einem nicht blockierenden Design. Für produktive ESP32-Firmware unterstützt die esp-mqtt-Komponente von Espressif in ESP-IDF MQTT 5, TLS und WebSocket und wird vom Chiphersteller gepflegt. Beginnen Sie mit dem ESP32 MQTT Tutorial für funktionierenden Arduino-Code und mit Paho MQTT C für Linux-Geräte.

Mobile: Swift, Kotlin, Flutter und React Native

Mobile Clients unterliegen einer Einschränkung, die Server nicht kennen: Das Betriebssystem pausiert Hintergrund-Apps und beendet inaktive Sockets. Welche Bibliothek Sie auch wählen: Planen Sie häufige Reconnects ein, nutzen Sie Persistent Sessions oder Retained Messages, um verpasste Daten nachzuholen, und setzen Sie Push-Benachrichtigungen für alles ein, was ein schlafendes Smartphone erreichen muss.

• iOS / macOS: CocoaMQTT unterstützt MQTT 5, TLS und WebSocket. Siehe MQTT auf iOS mit Swift.
• Android: Paho Java oder der HiveMQ Client aus Kotlin, idealerweise innerhalb einer Lifecycle-bewussten Komponente.
• Flutter: mqtt_client deckt Server- und Browser-Ziele aus einer einzigen Dart-Codebasis ab. Siehe das Flutter MQTT Tutorial.
• React Native: MQTT.js über WebSocket ist der übliche Weg, mit einigen Polyfills. Siehe React Native MQTT.

Stolperfallen, die wie Bibliotheksfehler aussehen

Die meisten Probleme, die einer Bibliothek angelastet werden, sind in Wahrheit Konfigurations- oder Designfehler. Prüfen Sie zuerst Folgendes:

Das Reconnect-Handling verdient in Python besondere Aufmerksamkeit; der Leitfaden zum paho-mqtt Reconnect erklärt die Backoff-Einstellungen. Für einen systematischen Ansatz, einen Client vor der Auslieferung zu prüfen, lesen Sie MQTT-Clients testen, und halten Sie Beispiele für mosquitto_pub und mosquitto_sub als unabhängigen zweiten Client beim Debugging griffbereit.

Vom öffentlichen MQTT-Broker zum eigenen Broker

Alle obigen Snippets nutzen den anonymen öffentlichen MQTT-Broker, der sich perfekt eignet, um Bibliotheken direkt zu vergleichen: Starten Sie den Python-Subscriber, veröffentlichen Sie aus Go und sehen Sie zu, wie die Nachricht ankommt. Der Öffentliche MQTT-Broker ist allerdings für Tests und Prototypen gedacht, wird geteilt und ist für jeden lesbar, daher brauchen produktive Clients Zugangsdaten und einen isolierten Broker.

ConnectMQ ist ein verwalteter MQTT-Broker, der mit jeder Bibliothek in diesem Leitfaden funktioniert, weil er Standard-MQTT 3.1.1 und 5.0 über TCP 1883, TLS 8883, WebSocket 8083 und Secure WebSocket 8084 (Pfad /mqtt) spricht. Wenn Sie im Portal einen Broker erstellen, erhalten Sie einen Benutzernamen, ein Passwort und eine Client ID. Die Umstellung eines der obigen Snippets ist eine Änderung von drei Zeilen, hier für paho-mqtt gezeigt:

client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="YOUR_CLIENT_ID", protocol=mqtt.MQTTv5)
client.username_pw_set("YOUR_USERNAME", "YOUR_PASSWORD")
client.tls_set()

ConnectMQ bindet Client IDs an die ausgegebenen Zugangsdaten, verwenden Sie die generierte ID also exakt wie angegeben. Wenn Sie noch überlegen, wie Sie Ihren Broker hosten, vergleicht unser Leitfaden zum Markt für Cloud-MQTT-Broker Serverless-, Dedicated- und Bring-your-own-Cloud-Optionen.

Jede MQTT-Bibliothek mit ConnectMQ verbinden

Wählen Sie die Bibliothek, die zu Ihrem Stack passt, führen Sie ihr Snippet gegen broker.connectmq.com aus, und wenn es Zeit für private Topics ist, erstellen Sie einen kostenlosen Broker unter app.connectmq.com. Der kostenlose Serverless-Plan benötigt keine Kreditkarte und bietet bis zu 25 Verbindungen, QoS bis 1 und Nachrichten bis 256 KB, mehr als genug, um Clients in mehreren Sprachen gleichzeitig zu entwickeln und zu testen.

Häufig gestellte Fragen

Welche MQTT Client-Bibliothek ist die beste?

Die eine beste gibt es nicht; die richtige Wahl ist die gepflegte Bibliothek, die zu Ihrer Sprache und Ihrem Nebenläufigkeitsmodell passt. paho-mqtt für Python, MQTT.js für JavaScript, MQTTnet für .NET sowie Paho oder rumqttc für Go und Rust sind die gängigen, gut unterstützten Standardoptionen.

Unterstützen alle MQTT Client-Bibliotheken MQTT 5?

Nein. Mehrere populäre Bibliotheken, darunter PubSubClient für Arduino und der klassische Paho-Go-Client, implementieren nur MQTT 3.1.1. Wenn Sie Shared Subscriptions, Message Expiry oder Reason Codes benötigen, prüfen Sie die MQTT-5-Unterstützung, bevor Sie eine Bibliothek einsetzen.

Können Clients in verschiedenen Sprachen miteinander kommunizieren?

Ja. Der Broker leitet Bytes weiter, keine Sprachobjekte, daher arbeiten ein Python-Publisher und ein C#-Subscriber problemlos zusammen, solange sie sich auf Topics und Payload-Format einigen. JSON ist das einfachste gemeinsame Format für den Einstieg. In Industrie-4.0-Projekten übernimmt diese Rolle oft ein Unified Namespace (UNS) mit einer Topic-Struktur nach ISA-95, an der sich Clients in jeder Sprache orientieren.

Welche Bibliothek sollte ich im Browser verwenden?

MQTT.js über Secure WebSocket ist die Standardwahl. Verbinden Sie sich mit wss://broker.connectmq.com:8084/mqtt, denn Browser können keine rohen TCP-Sockets öffnen, und HTTPS-Seiten blockieren unsichere WebSocket-Verbindungen.

Warum funktioniert mein Client auf dem öffentlichen MQTT-Broker, aber nicht auf einem privaten?

Meist fehlen Zugangsdaten, die Client ID stimmt nicht mit der ausgegebenen überein, oder TLS ist nicht aktiviert. Prüfen Sie den CONNACK-Reason-Code, den Ihre Bibliothek meldet; er zeigt Ihnen genau, welcher dieser Punkte falsch ist.