Behandle Rabbimq mit Python
Einführung
Mit RabbitMq können Sie Nachrichten zwischen Software und Warteschlangennachrichten (AMQP) austauschen. Es gibt viele Websites, auf denen die Verwendung beschrieben wird, aber es gibt nur wenige, auf denen die Verwaltung von Nachrichten beschrieben wird. Daher habe ich alles zusammengefasst, von der Vorbereitung von Rabbit Mq und Python Pika bis zur Überprüfung von Nachrichten.
Umgebung
- python:3.6.5
- Bild: Kaninchen: 3-Management
Was Sie brauchen, um Rabbit Mq zu verwenden
- RabbitMq-Server: Was empfängt und sendet Nachrichten (wo Nachrichten gespeichert werden)
- Produzent: Derjenige, der die Nachricht sendet (Client)
- Verbraucher: Derjenige, der die Nachricht empfängt (Host)
1. Herstellung von Kaninchen Mq
Holen Sie sich das Rabbit Mq-Bild von Docker
Es gibt zwei RabbitMq-Images, das Standard-Image und das Image mit aktiviertem Management-Plug-In. Dieses Mal möchte ich den Status der Warteschlange sehen, also ziehe ich den des Verwaltungssteckers. Ein Container wird mit dem Namen rabbitmq versehen, ziehen Sie also das Bild.
docker pull rabbitmq:3-management
Für normales Rabbitmq ziehen Sie "Rabbitmq" anstelle von "Rabbitmq: 3-Management".
Starten Sie Rabbit Mq
Starten Sie RabbitMq. Dieses Mal habe ich die Option `-d hinzugefügt, weil ich möchte, dass sie im Hintergrund weiterläuft. Da ich den Verwaltungsbildschirm für den Port sehen möchte, verknüpfe ich 15672 im Container mit 8080 auf dem Host und den Port, der tatsächlich Warteschlangen mit 5672 im Container und 5672 auf dem Host austauscht. Zusätzlich wird der Name `` --hostname`` `verwendet, um die Warteschlange zu identifizieren.
docker run -d --hostname my-rabbit --name some-rabbit -p 5672:5672 -p 8080:15672 rabbitmq:3-management
Führen Sie für normales rabbitmq `rabbitmq anstelle von rabbitmq: 3-management`` aus und Sie benötigen nicht einmal -p 8080: 15672`` `.
Bestätigung des Starts von Rabbit Mq
Dieses Mal habe ich einen Container mit aktiviertem Verwaltungs-Plug-In gestartet, sodass ich über den Browser auf `localhost: 8080 zugreifen und mir den Inhalt ansehen kann. Wenn Sie darauf zugreifen, werden Sie zum Anmeldebildschirm weitergeleitet. Geben Sie daher den Standardwert "Gast" ein. Sie können den aktuellen Status sehen. Knoten enthält den Namen, den Sie zuvor mit `` --hostname`` `angegeben haben.
2. Produzent: Bereiten Sie denjenigen vor, der die Nachricht senden soll (Client)
Um einen Produzenten zu erstellen, tauscht Python Warteschlangen aus. Daher verwenden wir eine Bibliothek namens pika, um auf rabbitmq zuzugreifen.
Installieren Sie Pika
Die Installation von Pika erfolgt normalerweise mit Pip.
pip install pika
Implementierung des Produzenten
Die folgenden Schritte sind erforderlich, um eine Nachricht zu senden. Alle diese Schritte werden für rabbitmq ausgeführt, sodass kein Verbraucher benötigt wird.
- Stellen Sie eine Verbindung her
- Kanalerstellung / -erfassung --Cue Erstellung / Erwerb --Nachricht senden
Verbindung herstellen
Stellen Sie eine Verbindung von Python zu Rabbit Mq her. Geben Sie den zu erstellenden Parametern Einstellungen wie Hostname (IP-Adresse), Portnummer und Zeitüberschreitung an. Da der RabbitMq-Container an Port 5672 des Hosts gebunden ist, habe ich localhost als Parameter angegeben und nicht angegeben, da der Port der Standard-5672 bleibt. Geben Sie danach Parameter an, um eine Verbindung herzustellen und die Verbindung herzustellen.
client_main.py
import pika
pika_param = pika.ConnectionParameters('localhost')
connection = pika.BlockingConnection(pika_param)
Kanalerstellung / -erfassung
Sobald die Verbindung hergestellt ist, besteht der nächste Schritt darin, den Kanal zu erstellen. Ein Kanal ist wie eine Straße zum Rabbit Mq. Produzenten und Konsumenten mit demselben Kanal sind die Ziele des Nachrichtenaustauschs.
client_main.py
import pika
pika_param = pika.ConnectionParameters('localhost')
connection = pika.BlockingConnection(pika_param)
channel = connection.channel()
Es wurde nur die letzte Zeile hinzugefügt. Geben Sie bei Bedarf die Kanalidentifikationsnummer in dieses Argument ein.
Warteschlangenerstellung / -erfassung
Erstellen Sie nach dem Erstellen des Kanals die Warteschlange. Diese Warteschlange ist wie ein Ort zum Speichern von Nachrichten. Daher können Nachrichten nur ausgetauscht werden, wenn die Warteschlangennamen identisch sind. Im Gegensatz zum Kanal müssen Sie ihn angeben.
client_main.py
import pika
pika_param = pika.ConnectionParameters('localhost')
connection = pika.BlockingConnection(pika_param)
channel = connection.channel()
channel.queue_declare(queue='hello')
Es wurde nur die letzte Zeile hinzugefügt. Geben Sie bei Bedarf die Warteschlangeneinstellungen in dieses Argument ein.
Nachricht senden
Jetzt, da wir bereit sind, senden wir Ihnen eine Nachricht. Geben Sie den Namen der Warteschlange in `routing_key von basic_publish () an und geben Sie die Nachricht an, die Sie an body` senden möchten.
client_main.py
import pika
pika_param = pika.ConnectionParameters('localhost')
connection = pika.BlockingConnection(pika_param)
channel = connection.channel()
channel.queue_declare(queue='hello')
channel.basic_publish(exchange='', routing_key='hello', body='Hello World!')
connection.close()
Schließen Sie zum Schluss die Verbindung, wenn die Übertragung abgeschlossen ist.
Ich werde es tatsächlich senden
Nachdem wir eine Quelle zum Senden an RabbitMq haben, lassen Sie es uns ausführen. Der Befehl wird bald zurückkommen.
PS C:\Users\xxxx\program\python\pika> python .\client_main.py
Ich werde es auch auf dem Verwaltungsbildschirm von Rabbit Mq überprüfen. Wenn Sie sich die Registerkarte Warteschlangen ansehen, sehen Sie, dass die Nachricht bereit ist: 1.
3. Verbraucher: Bereiten Sie denjenigen (Host) vor, der die Nachricht empfangen soll
Verbraucher verwenden auch eine Bibliothek namens pika, um auf RabbitMq zuzugreifen und Warteschlangen mit Python auszutauschen.
Implementierung des Verbrauchers
Die folgenden Schritte sind erforderlich, um eine Nachricht zu senden. Alle diese Schritte werden für Rabbit Mq ausgeführt, sodass Sie keinen Produzenten benötigen, um es zu starten. Von der Verbindungserstellung bis zur Warteschlangenerstellung ist dasselbe wie beim Produzenten.
- Stellen Sie eine Verbindung her
- Kanalerstellung / -erfassung --Cue Erstellung / Erwerb
- Rückruf erstellen (Verarbeitung beim Empfang) --Starten Sie das Akzeptieren von Warteschlangennachrichten
Rückruf erstellen (Verarbeitung beim Empfang)
Beschreiben Sie die Funktion, die Sie beim Empfang einer Nachricht verarbeiten möchten. Geben Sie die Antwortfunktion `basic_ack ()` an, um die Nachricht aus der Warteschlange zu entfernen, da sie am Ende der Funktion empfangen wurde. Dieses Mal wird als Beispiel die Funktion "Rückruf" beschrieben, die die empfangene Nachricht anzeigt.
host_main.py
import pika
pika_param = pika.ConnectionParameters(host='localhost')
connection = pika.BlockingConnection(pika_param)
channel = connection.channel()
channel.queue_declare(queue='hello')
def callback(ch, method, properties, body):
print("{} Received".format(body))
ch.basic_ack(delivery_tag = method.delivery_tag)
Akzeptieren Sie Warteschlangennachrichten
Geben Sie den Warteschlangennamen und die Rückruffunktion in `basic_consume ()` des erstellten Kanals an. Beginnen Sie dann mit dem Empfang der Nachricht mit der Funktion `start_consuming ()`. Wenn diese Funktion gestartet wird, wartet sie endlos auf eine Nachricht in der Funktion. Wenn sie beendet wird, muss in der Rückruffunktion ein Auslöser für die erzwungene Beendigung oder Beendigung gesetzt werden.
host_main.py
import pika
pika_param = pika.ConnectionParameters(host='localhost')
connection = pika.BlockingConnection(pika_param)
channel = connection.channel()
channel.queue_declare(queue='hello')
def callback(ch, method, properties, body):
print("{} Received".format(body))
ch.basic_ack(delivery_tag = method.delivery_tag)
channel.basic_consume(
queue='hello', on_message_callback=callback)
channel.start_consuming()
Eigentlich erhalten
Nachdem wir eine Quelle für den Empfang von RabbitMq haben, können wir sie ausführen.
PS C:\Users\xxxx\program\python\pika> python .\host_main.py
b'Hello World!' Received
Sie können bestätigen, dass die vom Hersteller gesendete Nachricht standardmäßig empfangen und ausgegeben werden kann.
Ich werde es auch auf dem Verwaltungsbildschirm von Rabbit Mq überprüfen. Wenn Sie sich die Registerkarte Warteschlangen ansehen, sehen Sie, dass Nachricht bereit ist: 0.
abschließend
Ich habe zusammengefasst, wie man mit RabbitMq Nachrichten mit Python austauscht. Es ist jedoch fast das gleiche wie der offizielle Inhalt. Auf diese Weise scheint es möglich zu sein, eine asynchrone Verarbeitung und Verarbeitung in Bezug auf Warteschlangen einfach durchzuführen.
Recommended Posts