Implementierung von Python Client mit Paho MQTT

Text geknüpft

Einleitung

Python ist heute eine am weitesten verbreitete Sprache und läuft auf den meisten Betriebssystemen. Micro Python hat wurde für Low-End-Prozessoren entwickelt. Diese Anleitung verdeutlicht den Schritt für Schritt-Prozess zum AufbauPython !Verwendung derEclipse Paho Bibliothek. Es bietet auch weitere Informationen über alle MQTT Handshakes und die Nachrichtentransaktionen, die zwischen dem MQTT-Client und demPython ausziehbar MQTT Broker. Die Paho-Bibliothek ist eine Open Source Client mit einer kostenlosen Lizenzierung Politik.

Voraussetzungen für paho MQTT Python

Bevor Sie beginnen, stellen Sie sicher, dass Sie die folgenden:

  • Python- Stellen Sie sicher, dass Python 3.6 oder später installiert ist auf Ihrem System, oder laden Sie die notwendige Version von der offiziellen Python Website herunter.
  • Paho MQ Bibliothek- Ja. Folgende Abhängigkeitsanlage Abschnitt die notwendigen Schritte zur Installation der Abhängigkeiten der python MQTT Client Library zur Verfügung stellen.

Dependance Installation

pip install paho-mqtt==1.6.0

python -m venv myenv
Quelle myenv/bin/aktivieren # Unter Windows `myenv\Scripts\aktivieren `

Schließen Sie die Python MQTT Client

Dieser Abschnitt hat Code-Snippets von verschiedenen Möglichkeiten, um mit dem Broker zu verbinden. Stellen Sie sicher, dass die MQTT Application unterstützt den Verbindungstyp, den Sie verwenden möchten. Auch erhalten die entsprechenden Verbindungsparameter derGehostet von Cloud MQTT Server(Adresse, Port, Benutzername/Passwort, CA-Zertifikat) oder jede andere lokal installierte Instanz.

MQT Über TCP

Verwenden Sie den folgenden Code, um den Client über TCP zu verbinden.

Definieren Sie den Macro ADDRESS mit MQTT Connection Parameter.

MQ3.1.1

def on_connect(client, userdata, flags, rc):
Print('\n{} Connected'.format(client._client_id.decode()))
random_chars = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
client_id = 'kristallmq_'+random_chars
Client = paho.mqtt.client.Client(client_id)
client.on_connect = on_connect
client.connect('public-mqtt-broker.bevywise.com', 1883)
Client.loop_start()

MQ3.1.1

Client erstellen
def on_connect(client, Benutzerdaten, Flaggen, Grund Code, Eigenschaften=None):
Druck('\n{} Mit Grundcode verbunden: {}'.format(client._client_id.decode(), whyCode))

# Erstellen einer zufälligen Client-ID
random_chars = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
client_id = 'kristallmq_' + random_chars

# Initialize MQTT Client mit MQTTv5
Client = mqt.Client(client_id, Protocol=paho.mqt.client. MQTTv5)
client.on_connect = on_connect
client.connect('public-mqtt-broker.bevywise.com', 1883)

MQTT über TLS / SSL

Der folgende Code hilft, sicher mit dem Broker zu verbinden über TLS. Definieren Sie den Macro ADDRESS mit MQTT-Verbindung Parameter.

# MQTT Verbindungsparameter
ADDRESS = 'public-mqtt-broker.bevywise.com' # Replace with your
Adresse des Maklers
PORT = 8883 # MQTT Server TLS port
CLIENT_ID = 'kristallmq_' + ''.join(random.choices(string.ascii_letters +
string.digits, k=10))

# Rückruffunktion für MQTT-Verbindung
def on_connect(client, userdata, flags, rc):
Druck('\n{} Mit Ergebniscode verbunden:
{}'.format(client._client_id.decode(), mqtt.connack_string(rc)))
# Erstellen einer zufälligen Client-ID
client_id = 'kristallmq_' + ''.join(random.choices(string.ascii_letters +
string.digits, k=10))
# Initialize MQTT Client
Client = mqtt.Client(client_id)client.on_connect = on_connect
# TLS-Verbindung aktivieren
Client.tls_set(
ca_certs=None, # Pfad zu Ihrer CA-Zertifikatdatei für Server
Überprüfung
certfile=None, # Pfad zu Ihrer Client-Zertifikat-Datei für gegenseitig
Authentifizierung (falls zutreffend)
keyfile=None, # Pfad zu Ihrer privaten Schlüsseldatei (falls zutreffend)
cert_reqs=sl.CERT_REQUIRED,
tls_version=sl. PROTOKOL_TLS,
Ciphers=None
)
# Verbindung zum Broker
client.connect (ADDRESS, PORT)

MQTT TLS Zertifikatund in der Verbindungsparameter zur Sicherung der MQTT-Verbindung. Setzen Sie TLS-Parameter vor dem Aufruf der MQTTClient_connect an den Client mit demOnline Cloud MQTT Serversicher über TLS.

# MQTT Verbindungsparameter
ADDRESS = 'public-mqtt-broker.bevywise.com' # Replace with your Adresse des Maklers
PORT = 8883 # MQTT TLS port
CLIENT_ID = 'kristallmq_' + ''.join(random.choices(string.ascii_letters + string.digits, k=10))

# Rückruffunktion für MQTT-Verbindung
def on_connect(client, userdata, flags, rc):
Druck('\n{} Mit Ergebniscode verbunden: {}'.format(client._client_id.decode(), mqtt.connack_string(rc)))

# Erstellen einer zufälligen Client-ID
client_id = 'kristallmq_' + ''.join(random.choices(string.ascii_letters + string.digits, k=10))

# Initialize MQTT Client
Client = mqtt.Client(client_id)
client.on_connect = on_connect

# TLS-Verbindung aktivieren ohne Serververifikation
client.tls_set(cert_reqs=ssl.CERT_NONE)

# Verbinden mit dem Middleware (Broker)
client.connect (ADDRESS, PORT)

Wenn die Messaging-Plattform (Broker) Serverzertifikat ausgestellt hat von Trusted CA, dann kann das Server-Zertifikat mit:

# MQTT Verbindungsparameter
ADDRESS = 'public-mqtt-broker.bevywise.com' # Replace with your Adresse des Maklers
PORT = 8883 # Broker's TLS port
CLIENT_ID = 'kristallmq_' + ''.join(random.choices(string.ascii_letters + string.digits, k=10))
# Rückruffunktion für MQTT-Verbindung
def on_connect(client, userdata, flags, rc):
Druck('\n{} Mit Ergebniscode verbunden: {}'.format(client._client_id.decode(), mqtt.connack_string(rc)))

# Erstellen einer zufälligen Client-ID
client_id = 'kristallmq_' + ''.join(random.choices(string.ascii_letters + string.digits, k=10))

# Initialize MQTT Client
Client = mqtt.Client(client_id)
client.on_connect = on_connect

# Pfad zur CA-Zertifikatdatei
ca_cert = '/path/to/your/ca_certificate.pem '

# TLS-Verbindung mit Serverzertifikatsverifikation aktivieren
client.tls_set(ca_certs=ca_cert, cert_reqs=ssl.CERT_REQUIRED)

# Verbindung zum Broker
client.connect (ADDRESS, PORT)

Hat der MQTT Server ein selbstsigniertes Serverzertifikat dann kann das Server-Zertifikat mit dem Root-Zertifikat aus der Broker:

Import random, string, paho.mqt.client, ssl
ssl.match_hostname = lambda cert, hostname: Stimmt.

def on_connect(client, userdata, flags, rc):
Print('\n{} Connected'.format(client._client_id.decode()))
random_chars = ''.join(random.choices(string.ascii_letters +
string.digits, k=10))
client_id = 'kristallmq_'+random_chars
Client = paho.mqtt.client.Client(client_id)
root_cert_path = '/path/to/root.crt '
client.tls_set(ca_certs=root_cert_path,
cert_reqs=ssl.CERT_REQUIRED,tls_version=ssl.PROTOCOL_TLSv1_2,
Ciphers=None)
client.tls_insecure_set(True)
client.on_connect = on_connect
client.connect('public-mqtt-broker.bevywise.com', 8883)
Client.loop_start()

MQTT über WebSocket

Definieren Sie die Adresse des Brokers wie diese, um die Client über WebSocket.

# MQTT-Verbindungsparameter für WebSocket (ohne TLS)
ADDRESS_WS = 'ws://public-mqtt-broker.bevywise.com:8083/mqtt' # Ersetzen mit der WebSocket Adresse Ihrer Messaging Middleware
CLIENT_ID = 'kristallmq_' + ''.join(random.choices(string.ascii_letters + string.digits, k=10))

# Rückruffunktion für MQTT-Verbindung
def on_connect(client, userdata, flags, rc):
Druck('\n{} Mit Ergebniscode verbunden: {}'.format(client._client_id.decode(), mqtt.connack_string(rc)))

# Erstellen einer zufälligen Client-ID
client_id = 'kristallmq_' + ''.join(random.choices(string.ascii_letters + string.digits, k=10))

# MQTT-Client für WebSocket (ohne TLS) initialisieren
Client = mqtt.Client(client_id)
client.on_connect = on_connect

# Verbinden mit dem Server über WebSocket (ohne TLS)
client.connect (ADDRESS_WS)

MQTT über Secure WebSocket

Verwenden Sie den folgenden Code, um den Client über Secure zu verbinden WebSocket.

Set TLS Optionen wie in MQTT über TLS Abschnitt angegeben.

Definieren Sie den Macro ADDRESS mit Brokers Verbindung Parameter.

# Verbindungsparameter für WebSocket (mit TLS)
ADDRESS_WSS = 'wss://public-mqtt-broker.bevywise.com:8084/mqtt' #
Ersetzen Sie mit der sicheren WebSocket Adresse Ihres Brokers
CLIENT_ID = 'kristallmq_' + ''.join(random.choices(string.ascii_letters +
string.digits, k=10))

# Rückruffunktion für MQTT-Verbindung
def on_connect(client, userdata, flags, rc):
Druck('\n{} Mit Ergebniscode verbunden:
{}'.format(client._client_id.decode(), mqtt.connack_string(rc)))

# Erstellen einer zufälligen Client-ID
client_id = 'kristallmq_' + ''.join(random.choices(string.ascii_letters +
string.digits, k=10))

# MQTT Client für WebSocket initialisieren (mit TLS)
Client = mqtt.Client(client_id)
client.on_connect = on_connect

# Pfad zur CA-Zertifikatsdatei (falls Server-Zertifikatsprüfung) ist
erforderlich
ca_cert = '/path/to/your/ca_certificate.pem '

# TLS-Verbindung für WebSocket aktivieren
client.tls_set(ca_certs=ca_cert, cert_reqs=ssl.CERT_REQUIRED)

# Verbinden Sie mit dem Nachrichten-Hub über WebSocket mit TLS
Client.connect (ADDRESS_WSS)

MQTT konfigurieren Authentifizierung

Um den Python MQTT Client zu verbinden, benötigen wir MQTT Username und MQTT Passwort für die Authentifizierung, Benutzername und Passwort zu den Verbindungsoptionen hinzufügen wie folgt:

# MQTT Anschlussparameter für TCP (ohne TLS)
ADDRESS_TCP = 'public-mqtt-broker.bevywise.com' # Replace with your
Broker TCP Adresse
PORT = 1883 # MQTT's TCP Port
USERNAME = 'your_mqt_username' # Ersetzen Sie mit Ihrem MQTT-Benutzernamen
PASSWORD = 'your_mqt_password' # Ersetzen Sie mit Ihrem MQTT-Passwort
CLIENT_ID = 'kristallmq_' + ''.join(random.choices(string.ascii_letters +
string.digits, k=10))

# Rückruffunktion für MQTT-Verbindung
def on_connect(client, userdata, flags, rc):
Druck('\n{} Mit Ergebniscode verbunden:
{}'.format(client._client_id.decode(), mqtt.connack_string(rc)))

# Erstellen einer zufälligen Client-ID
client_id = 'kristallmq_' + ''.join(random.choices(string.ascii_letters +
string.digits, k=10))

# MQTT-Client für TCP (ohne TLS) initialisieren
Client = mqtt.Client(client_id)
client.username_pw_set(username=USERNAME, passwort=PASSWORD)
client.on_connect = on_connect

# Verbinden Sie mit der Messaging-Plattform über TCP (ohne TLS) mit Authentisierung
client.connect (ADDRESS_TCP, PORT)

Erweiterte Funktionen

Das letzte Testament einrichten

Konfigurieren derLetzter Wille und TestamentFunktion eine Nachricht angeben, die der Broker veröffentlichen wird, wenn der Client unerwartet trennt. Dies hilft, andere Abonnenten des abgeschalteten Clients zu informieren Status.

Verwenden Sie den folgenden Code, um Last Will in der Verbindung zu setzen Optionen:

random_chars = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
client_id = 'kristallmq_'+random_chars
Client = paho.mqtt.client.Client(client_id)
client.will_set("willtopic", payload="Good bye CrystalMQ", qos=0, Zurück zur Übersicht
client.connect('public-mqtt-broker.bevywise.com', 1883)

Adjusting Keep Alive

MQTT unterhält Client-Broker-Verbindungen mit einem sparsamer Mechanismus. Einstellen derIch bin nicht da.Intervall zu steuern, wie häufig der Client sendet PINGREQ-Nachrichten.

Ändern Sie den untenstehenden Code entsprechend Ihren Anforderungen:

client.connect(hostip, port, keepalive=40)

Sitzungspersistenz konfigurieren

Sitzungsdaten eines MQTT-Clients umfassen die Abschriften des Kunden und alle Daten, die der Kunde mit QoS>0. Der Client kann die Messaging-Plattform erhalten, um seine Sitzungsdaten über Verbindungen zu speichern.

MQTT 3.1.1 Clients können Clean Session = 0 festlegen, um den MQTT Server zu bitten, um zu halten die über Verbindungen gespeicherten Sitzungsinformationen.

MQ3.1.1

random_chars = ''.join(random.choices(string.ascii_letters +
string.digits, k=10))
client_id = 'kristallmq_'+random_chars
Client = paho.mqtt.client.Client(client_id,clean_session=False)

MQT 5 Clients können Clean Start = 0 und Session Expiry festlegen Interval = 'N', um den Server zu bitten, seine Sitzungsinformationen gespeichert zu halten über Verbindungen für 'N' Sekunden.

MQTT 5

random_chars = ''.join(random.choices(string.ascii_letters +
string.digits, k=10))
client_id = 'kristallmq_' + random_chars

# MQTT Client für MQTTv5 mit clean_session=False initialisieren
Client = mqt.Client(client_id, clean_session= Falsch.
Protokoll=mqtt. MQTTv5)

# Rückruffunktion für MQTT-Verbindung
def on_connect(client, userdata, flags, rc, properties=None):
Druck('\n{} Mit Ergebniscode verbunden:
{}'.format(client._client_id.decode(), mqtt.connack_string(rc)))

wenn Eigenschaften:
print("Received Connection Properties:")
für Prop, val in properties.items():
Druck (f"{prop}: {val}")

# Setzen Sie die on_connect Callback Funktion
client.on_connect = on_connect

# Verbindungsdetails (ersetzt mit Ihrem) Makler
Adresse und Port
broker_address = 'public-mqtt-broker.bevywise.com '
Broker_port = 1883 # Ersetzen mit dem Hafen Ihres Maklers

# Connect to MQTT Server
client.connect(broker_address, broker_port)

Maximal Packungsgröße

MQTT5 Client kann die Middleware (Broker) anfordern, nur Daten zu senden Pakete weniger als eine bestimmte Größe, indem sie so eingestellt werden:

von paho.mqt.properties import Eigenschaften
aus paho.mqt.packettypes import PacketTypes

def on_connect(client, userdata, flags, rc, properties=None):
Print('\n{} Connected'.format(client._client_id.decode()))
Client = paho.mqtt.client.Client(client_id=client_id), Protokoll=paho.mqt.client. MQTTv5)
client.on_connect = on_connect
connect_properties = Eigenschaften(PacketTypes.CONNECT)
connect_properties.MaximumPacketSize=256
client.connect('public-mqtt-broker.bevywise.com', 1883, Eigenschaften=connect_properties)
Client.loop_start()

Sicherung des MQTT Broker

IoT-Geräte werden global eingesetzt und verbinden sich mitPressemitteilungen MQTT-Serverüber verschiedene Kommunikationsmethoden wie Wi-Fi, GSM und mehr, sie anfällig für Angriffe zu machen. Um Ihre IoT-Implementierung zu sichern,MQTT Broker-Einsatzist sehr wichtig. Dies kann erreicht, MQTT Authentication ermöglicht und TLS/SSL implementiert wird Verschlüsselung für beide MQTT über TCP- und WebSocket-Verbindungen. EinrichtungMQTT-Sicherheitrechts vom MQTT Connect Sie sorgen für ein tampersicheres, robustes IoT-Ökosystem, das Daten und Geräte von unberechtigtem Zugriff.

MQTT veröffentlichen Nachricht

Daten senden

Daten effizient an mehrere Teilnehmer verteilen Veröffentlichung zu bestimmten Themen mit dem folgenden Code snippet:

MQ3.1.1

Import zufällig, String, paho.mqt.client, Zeit
def on_publish(client, userdata, mid):
Print('\n{} SENT PktID:{}'.format(client._client_id.decode(),mid))

random_chars = ''.join(random.choices(string.ascii_letters + string.digits, k=10)
client_id = 'kristallmq_'+random_chars
Client = paho.mqtt.client.Client(client_id)
client.on_connect = on_publish
client.connect('public-mqtt-broker.bevywise.com', 1883)
Client.loop_start()

während True:
client.publish('testtopic','Hello CrytalMQ!', qos=1, keep=False)
Zeit.sleep(40)

MQTT 5

# Callback-Funktion für MQTT veröffentlichen Quittung (on_publish)
def on_publish(client, userdata, mid):
Druck('\n{} SENT PktID:{}'.format(client._client_id.decode(), Mitte))

# Erstellen einer zufälligen Client-ID
random_chars = ''.join(random.choices(string.ascii_letters + String. Ziffern,
k=10)
client_id = 'kristallmq_' + random_chars

# Initialize MQTT Client für MQTTv5
Client = mqtt.Client(client_id, Protokoll=mqt. MQTTv5)

# Setzen Sie die on_publish Callback Funktion
client.on_publish = on_publish

# Verbindungsdetails (ersetzt mit dem Server) Anschrift
und Hafen
broker_address = 'public-mqtt-broker.bevywise.com '
Broker_port = 1883 # Ersetzen mit dem Hafen Ihres Maklers

# Verbindung zum Server
client.connect(broker_address, broker_port)

# Starten Sie einen Hintergrundfaden für die MQTT-Kommunikation
Client.loop_start()

Festhaltene Nachrichten einstellen

Ermöglichen Sie die Flagge bei der Veröffentlichung einer Nachricht, um sicherzustellen, dass Broker speichert die letzte Nachricht jedes Themas. Dies garantiert neue Abonnenten die jüngste Nachricht beim Verbinden erhalten.

Um dies zu implementieren, verwenden Sie den folgenden Code snippet:

client.publish('testtopic','Hello, CrystalMQ!',qos=0,retain=True)

QoS Levels angeben

Das Protokoll bietetDrei Ebenen von MQTT QoS Levelfür die Nachricht Lieferung:

  • QoS 0 (am meisten einmal)
  • QoS 1 (zumindest einmal)
  • QoS 2 (genau einmal)

Geben Sie beim Veröffentlichen von MQTT-Nachrichten den erforderlichen QoS-Level an dieser Code:

MQTT 5

pub_properties = Properties(PacketTypes.PUBLISH)
pub_properties.MessageExpiryInterval = 60
client.publish("testtopic", "Hello CrysqlMQ!", qos=1, Eigenschaften=publish_properties)

Nachricht abbrechen Intervall

Die Eigenschaft 'Message Ablaufintervall' setzt die Lebensdauer einer Nachricht in Sekunden; wenn undelivered innerhalb dieser Zeit, der Broker verworfen es.MQTT5unterstützt diese Funktion. MQTT5 Clients können dies während der Veröffentlichung von Daten festlegen.

Für MQTT 5:

pub_properties = Properties(PacketTypes.PUBLISH)
pub_properties.MessageExpiryInterval = 60
client.publish("testtopic", "Hello CrysqlMQ!", qos=1, Eigenschaften=publish_properties)

Thema Alias

Die Eigenschaft 'Topic Alias' ermöglicht es Kunden, ein kurzes Alias zu verwenden anstatt eines vollständigen Themennamens, die Reduzierung der Nachrichtenpaketgröße und die Verbesserung des Netzwerks Effizienz.

connect_properties = Eigenschaften(PacketTypes.CONNECT)
connect_properties.TopicAliasMaximum = 10
client.connect('public-mqtt-broker.bevywise.com', 1883, Eigenschaften=connect_properties)

Eigenschaften, die mit MQTT PUBLISH verbunden sind, verbessern die Nachrichtenbehandlung, Bereitstellung von Kontext oder Anweisungen für Broker und Kunden. Diese Eigenschaften, einschließlich Nachrichten Ablaufintervalle und Thema Alias, optimieren Nachrichtenversand und Netzwerk Bandbreite.

Anmeldung zu einem MQTT Thema

Anmeldung zum Thema Filter

Um von anderen Clients veröffentlichte Daten zu erhalten, muss dieser Client abonnierenMQT Themenwie folgt:

def on_subscribe(client, userdata, mid, permit_qos):
Druck('\n{} SUBSCRIBED mit QoS:{}'.format(client._client_id.decode(),granted_qos))
def on_message(client, userdata, message):
print('\n{} RCVD Topic:{}, Nachricht:{}, QoS:{} PktId:{}'.format(client._client_id.decode(),message.topic,message.payload,message.qos,message.mid))

random_chars = ''.join(random.choices(string.ascii_letters + string.digits, k=10)
client_id = 'kristallmq_'+random_chars
Client = paho.mqtt.client.Client(client_id)
client.on_message = on_message
client.on_subscribe = on_subscribe
client.connect('public-mqtt-broker.bevywise.com', 1883)
Client.loop_start()
client.subscribe('testtopic', qos=1)

Dieses Thema Filter kann mit einem genauen Thema übereinstimmen oder es kann Wildcards wie # und +

Datenerfassung

Um Daten für die Abonnements zu erhalten, eine Callback-Funktion muss so definiert werden:

# Rückruffunktion für MQTT-Verbindung
def on_connect(client, userdata, flags, rc, properties=None):
Print('\n{} Connected'.format(client._client_id.decode()))
# Thema abonnieren, wenn verbunden
client.subscribe('testtopic', qos=0)

Anmeldung von Themen

Um zu verhindern, dass Updates von einem Thema abgemeldet werden, verwenden Sie den angegebenen Code unten:

def on_unsubscribe(client, userdata, mid):
Print('\n{} UNSUBSCRIBED'.format(client._client_id.decode()))
client.unsubscribe("testtopic")

Den python MQTT Client deaktivieren

Stellen Sie sicher, dass die Verbindung Ihres Kunden mit dem Broker, um Probleme und Ressourcenlecks auf beiden Seiten zu vermeiden, wodurch System beibehalten Stabilität.

Verwenden Sie den folgenden Code, um den Client vom Broker zu trennen:

def on_disconnect(client, userdata, rc):
Druck('\n{} DISCONNECTED with rc:{}'.format(client._client_id.decode(),rc))
Client.loop_stop()

Client.disconnect()

Bauen Sie Ihre Business Logic

Sie haben die Möglichkeit, sich selbst zu entwickeln und anzupassen komplizierte Business-Logik in dieser Umgebung, passgenau auf Ihre spezifischen Bedürfnisse und Ziele.

Best Practices - Python MQTT Kunde

Identifizierung des Kunden Strategie

Zuweisen Sie jedem Gerät eindeutige Client-IDs zur genauen Identifizierung. In privaten Einrichtungen, Allocate deutlich IDs an einzelne Kunden; in gemeinsamen Umgebungen, fügen Sie eine zufällige zu jeder Client-ID, um Einzigartigkeit zu erhalten.

Datenarchitektur Design

Strategisch planen Sie Ihre Datenstruktur im Voraus. Ob der Umgang mit Klartext, JSON-Formate oder numerische Daten sorgen dafür, dass das Design auf die spezifischen Anforderungen Ihrer Anwendung.

Robuste Fehlerbehandlung

Implementieren Sie eine starke Fehlerverwaltung mit MQTT-Verbindung Fehler, Abonnementprobleme und Nachrichtenveröffentlichungsfehler effektiv.

Sicherung von Anmeldeinformationen

Schutz sensibler Informationen wie Benutzernamen, Passwörter und Client-IDs, indem Sie sie nicht in Ihrem Quellcode festcodieren. Umweltvariablen verwenden oder sichere Konfigurationsdateien statt.

Regelmäßige Prüfung und Überwachung

Kontinuierlich testen Sie MQTT-Kommunikation und überwachen Sie Client Metriken wie als Verbindungsstatus, Nachrichtendurchsatz und Fehlerraten schnell identifizieren und beheben Probleme.

Optimierung des Sitzungsmanagements

Wählen Sie zwischen sauber undDas ist ein Tag.(`clean: true` oder `clean: false`) basierend auf Ihrer Notwendigkeit, Abonnements und gelöschte Nachrichten über Kundenverbindungen.

Reconnect auf Disconnect

Code hinzufügen, um zu versuchen, die Verbindung zumMQTT Brokerwenn es unerwartete Trennung. Dies wird sicherstellen, dass Ihr Kunde verbunden bleibt und nicht alle Daten verlieren.

Python MQTT Client herunterladen

Den vollständigen Code für den Client herunterladen, der Python MQTT Client verwendet Bibliothek, um mit unserer Messaging-Plattform oder einem Broker Ihrer Wahl zu verbinden.

MQ3.1.1

Import paho.mqt.client als mqtt
Import sys
Einfuhrzeit
Import zufällig, String
Import json, signal, os
# from paho.mqtt.properties import Eigenschaften
# from paho.mqt.packettypes import PacketTypes

def on_connect(client, userdata, flags, rc):
Print('\n{} Connected'.format(client._client_id.decode()))

def on_message(client, userdata, message):
print('\n{} RCVD Topic:{}, Nachricht:{}, QoS:{} PktId:{}'.format(client._client_id.decode(),message.topic,message.payload,message.qos,message.mid))

def on_publish(client, userdata, mid):
Print('\n{} SENT PktID:{}'.format(client._client_id.decode(),mid))

def on_subscribe(client, userdata, mid, permit_qos):
Druck('\n{} SUBSCRIBED mit QoS:{}'.format(client._client_id.decode(),granted_qos))

def on_unsubscribe(client, userdata, mid):
Print('\n{} UNSUBSCRIBED'.format(client._client_id.decode()))
def on_disconnect(client, userdata, rc):
Druck('\n{} DISCONNECTED with rc:{}'.format(client._client_id.decode(),rc))
Client.loop_stop()

random_chars = ''.join(random.choices(string.ascii_letters + string.digits, k=10)
client_id = 'kristallmq_'+random_chars
Client = mqtt.Client(client_id)
# client.username_pw_set("some username", "some password")
- Client. will_set("willtopic", payload="Good bye CrystalMQ", qos=0, Zurück zur Übersicht
# client.tls_set(ca_certs='/path/to/root.crt',certfile='/path/to/client.crt', keyfile='/path/to/client.key', cert_reqs=sl.CERT_REQUIRED,tls_version=ssl. PROTOCOL_TLSv1_2, ciphers=None)
client.on_connect = on_connect
client.connect('public-mqtt-broker.bevywise.com', 1883, keepalive=40)

# connect_properties = Properties(PacketTypes.CONNECT)
# connect_properties.SessionExpiryInterval = 60
# connect_properties.MaximumPacketSize=256
# connect_properties.TopicAliasMaximum = 10
# client.connect('public-mqt-broker.bevywise.com', 1883,properties=connect_properties)

Client.loop_start()
client.subscribe('testtopic',0)

während True:
# pub_properties = Properties(PacketTypes.PUBLISH)
# pub_properties.MessageExpiryInterval = 60
- Client. veröffentlichen("testtopic", "Hello CrysqlMQ!", qos=1, Eigenschaften=publish_properties)

client.publish('testtopic','Hello CrytalMQ!', 0)
Zeit.sleep(30)
Reisepass

# client.disconnect()

MQTT 5

Import paho.mqtt.client
Import sys
Einfuhrzeit
Import zufällig
Import string
Import json
Importsignal
Einfuhr

def on_connect(client, userdata, flags, rc, properties=None):
Print('\n{} Connected'.format(client._client_id.decode()))

def on_message(client, userdata, message, properties=None):
print('\n{} RCVD Topic:{}, Nachricht:{}, QoS:{} PktId:{}'.format(client._client_id.decode(), message.topic, message.payload.decode(), message.qos, message.mid)

def on_publish(client, userdata, mid, properties=None):
Druck('\n{} SENT PktID:{}'.format(client._client_id.decode(), Mitte))

def on_subscribe(client, userdata, mid, qos, properties=None):
Druck('\n{} SUBSCRIBED with QoS:{}'.format(client._client_id.decode(), qos)

def on_unsubscribe(client, userdata, mid, properties=None):
Print('\n{} UNSUBSCRIBED'.format(client._client_id.decode()))

def on_disconnect(client, userdata, rc, properties=None):
Druck('\n{} DISCONNECTED with rc:{}'.format(client._client_id.decode(), rc)
Client.loop_stop()

random_chars = ''.join(random.choices(string.ascii_letters + string.digits, k=10)
client_id = 'kristallmq_' + random_chars

Client = paho.mqt.client.Client(client_id), Protokoll=paho.mqt.client. MQTTv5)

client.on_connect = on_connect
client.on_message = on_message
client.on_publish = on_publish
client.on_subscribe = on_subscribe
client.on_unsubscribe = on_unsubscribe
client.on_disconnect = on_disconnect

# Optional: Authentifizierung und andere Optionen festlegen
# client.username_pw_set("some username", "some password")
- Client. will_set("willtopic", payload="Good bye CrystalMQ", qos=0, Zurück zur Übersicht
client.connect('public-mqtt-broker.bevywise.com', 1883, keepalive=40)

# Optional: MQTTv5-Eigenschaften für Anschluss einstellen
# connect_properties = paho.mqt.properties.Properties(paho.mqt.packettypes.PacketTypes.CONNECT)
# connect_properties.SessionExpiryInterval = 60
# connect_properties.MaximumPacketSize = 256
# connect_properties.TopicAliasMaximum = 10
# client.connect('public-mqtt-broker.bevywise.com', 1883, Eigenschaften=connect_properties)

Client.loop_start()
client.subscribe('testtopic', qos=0)
während True:
# Optional: MQTTv5-Eigenschaften für das Verlagswesen
# pub_properties = paho.mqt.properties.Properties(paho.mqt.packettypes.PacketTypes.PUBLISH)
# pub_properties.MessageExpiryInterval = 60
- Client. veröffentlichen("testtopic", "Hello CrysqlMQ!", qos=1, Eigenschaften=publish_properties)

client.publish('testtopic', 'Hello CrystalMQ!', qos=0)
Zeit.sleep(30)

~ Clean up ~
Client.disconnect()
Client.loop_stop()
print("Programm beendet. MQTT-Client getrennt.")

Binary Bundle erstellen

Mit pyinstaller

PyInstaller ist ein beliebtes Tool, das Python Anwendungen bündeln kann in eigenständige Ausführungsvarianten für Windows, macOS und Linux. Hier ist, wie Sie verwenden können pyinstaller, um Ihr Python Skript in ein ausführbares zu konvertieren:

  • Installieren Sie das Sie pyinstaller:Wenn Sie nicht installiert haben pyinstaller noch, Sie können es mit dem folgenden Befehl installieren:

    • pip install pyinstaller

  • Navigieren Sie zu Ihrem Script’s Directory:Terminal öffnen oder Eingabeaufforderung und Änderung des Verzeichnisses (cd) an das Python-Skript (your_script.py) befindet sich.
  • Run pyinstaller:Führen Sie den pyinstaller mit folgenden Befehl:

    • Pyinstaller --onefile your_script.py

  • --onefile:Diese Option sagt pyinstaller zu Paket alles in eine einzige ausführbare Datei.
  • Ihr_script.py:Ersetzen Sie dies mit dem eigentlichen Namen Ihr Python-Skript.
  • Warten Sie auf Verpackung:PyInstaller analysiert Ihre Skript und seine Abhängigkeiten, dann paketieren Sie sie in eine ausführbare Datei. Dieser Prozess kann nehmen Sie eine Weile, abhängig von der Komplexität Ihres Skripts und seiner Abhängigkeiten.
  • Aus:Sobald pyinstaller abgeschlossen ist, es wird ein Dist-Verzeichnis in Ihrem Skriptverzeichnis erstellen. Im Innenbereich finden Sie die ausführbare Datei mit dem gleichen Namen wie Ihr Skript (your_script.exe unter Windows, Ihr_script auf macOS/Linux).
  • : Sie die ausgerichtete:Sie können jetzt die generierten ausführen direkt ausführbar. Doppelklicken (auf Windows) oder Ausführen aus dem Terminal (auf macOS/Linux) wird Ihr Python-Skript als ausführbar ausführen.

Ich hoffe, Sie konnten dieMQTT Clientmit dieser Tutorial. Als Experte in Python, wählen Sie eineMQT Broker mit Python Plugins, so dass Sie ein komplettes IoT-Anwendungsende mit dem python zu Ende zu bauen.

Auf der Suche nach Hilfe bei der IoT-Implementierung? Kontaktieren Sie unsMQTT-Unterstützung.