[PYTHON] Rabbit MQ Tutorial (1) - Von der Installation zu Hello World (offizielle Site-Übersetzung)
Ich lerne Rabbit MQ, ein Vertreter von Open Source MQ. Vorerst habe ich Tutorial auf der offiziellen Website ausprobiert und es nach meinem eigenen Verständnis übersetzt. Ich hoffe es hilft dir.
- Die offizielle Website unterstützt verschiedene Programmiersprachen, aber vorerst werden nur die Beispiele in Python übersetzt.
Vorbereitung
Dieses Kapitel befindet sich nicht im Tutorial auf der offiziellen Website, aber ich werde zuerst den Installationsvorgang schreiben.
Installieren Sie Rabbit MQ
Überprüfen Sie Dokumente auf der offiziellen Website. Das Folgende ist das Verfahren für Ubuntu.
- Fügen Sie den folgenden Eintrag zu /etc/apt/sources.list hinzu:
deb http://www.rabbitmq.com/debian/ testing main
- Registrieren Sie den öffentlichen Schlüssel
wget https://www.rabbitmq.com/rabbitmq-signing-key-public.asc
sudo apt-key add rabbitmq-signing-key-public.asc
- Aktualisieren Sie die Paketliste mit apt-get update
sudo apt-get update
--Installation
sudo apt-get install rabbitmq-server
Installieren Sie die Python-Bibliothek 'pika'
Sie können es mit pip installieren.
sudo pip install pika
Wenn Sie fertig sind, gehen wir zum Tutorial.
Tutorial 1: Hello World
- Das Folgende ist eine Übersetzung von Tutorial - Hallo Welt! (Python-Version) auf der offiziellen Website von Rabbit MQ. Bitte beachten Sie, dass einige Teile frei übersetzt werden.
Einführung
Rabbit MQ ist ein Nachrichtenbroker. Die Hauptidee ist sehr Fingerhut, "Nachrichten empfangen und weiterleiten". Stellen Sie sich das wie ein Postamt vor: Wenn Sie einen Brief an ein Postamt senden, sind Sie sicher, dass ein Postkurier den Brief schließlich an seinen Bestimmungsort liefern wird. Wenn man die Rolle von Rabbit MQ auf diese Analogie anwendet, spielt es die Rolle von Post, Post und Zusteller.
Der Unterschied zwischen RabbitMQ und der Post besteht darin, dass es sich eher um Datenblöcke handelt, dh um Meldungen als um Papier. Rabbit MQ empfängt es, speichert es und überträgt es.
RabbitMQ und gängige Messagingsysteme verwenden einige Fachbegriffe.
--_ Produzieren_ bedeutet Senden. Das Programm, das sendet, heißt Producer (im Folgenden in Katakana als "Produzent" bezeichnet). Wir werden die Abkürzung "P" in den Abbildungen der Programme verwenden, die in zukünftigen Tutorials erscheinen werden.
--_ queue_ ist wie ein Postfach, in dem Buchstaben gespeichert werden (im Folgenden als "Warteschlange" in einem Pseudonym bezeichnet). Es funktioniert in Rabbit MQ. Wenn Ihre Anwendung eine Nachricht über Rabbit MQ sendet, wird sie nur in die Warteschlange gestellt. Sie können beliebig viele Nachrichten in der Warteschlange speichern - im Wesentlichen einen unendlichen Puffer. Mehrere Produzenten können Nachrichten an eine Warteschlange senden, und mehrere Konsumenten können Nachrichten von einer Warteschlange empfangen. In den Abbildungen in zukünftigen Tutorials verwenden wir die folgende Abbildung mit dem oben hinzugefügten Warteschlangennamen.
--_ Konsumieren_ bedeutet kurz vor dem Empfang. Das Programm, das auf den Empfang einer Nachricht wartet, heißt Consumer (im Folgenden in Katakana als "Verbraucher" bezeichnet). In den Abbildungen im Tutorial verwenden wir die Abkürzung "C".
Beachten Sie, dass Hersteller, Verbraucher und Makler (RabbitMQ-Server) nicht auf demselben Computer zusammenleben müssen. Tatsächlich sind viele Anwendungen so konfiguriert, dass sie separat platziert werden.
Hello World!
Dieser Hello World-Programmstrahl ist nicht sehr kompliziert. Senden wir eine Nachricht und drucken sie auf dem Bildschirm aus. Um dies zu erreichen, benötigen Sie zwei Programme: eines, das die Nachricht sendet, und eines, das die Nachricht empfängt und ausgibt.
Das Gesamtdesign sieht folgendermaßen aus:
Der Produzent (P) sendet eine Nachricht an die Warteschlange "Hallo". Verbraucher (C) empfängt die Nachricht aus der Warteschlange.
__ Informationen zur RabbitMQ-Bibliothek: __ RabbitMQ verwendet AMQP 0.9.1, ein offenes und universelles Messaging-Protokoll für die Kommunikation. Rabbit MQ-kompatible Clients sind in verschiedenen Sprachen verfügbar. Der in diesem Tutorial verwendete Pika ist der vom Rabbit MQ-Team empfohlene Python-Client.
Senden
Erstellen Sie ein Sendeprogramm send.py. (vollständiger Code)
Als erstes müssen Sie eine Verbindung zum Rabbit MQ-Server herstellen:
#!/usr/bin/env python
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(
'localhost'))
channel = connection.channel()
In diesem Beispiel stellen wir eine Verbindung zu einem lokalen Host-Broker (RabbitMQ-Server) her. Wenn Sie eine Verbindung zu einem Broker auf einem externen Computer herstellen möchten, geben Sie einfach die IP-Adresse oder den Hostnamen im Teil "localhost" an.
Die Zielwarteschlange muss bereits beim Senden einer Nachricht vorhanden sein. Wenn Sie eine Nachricht an eine nicht vorhandene Warteschlange senden, löscht RabbitMQ die Nachricht. Dieses Mal erstellen wir diese Warteschlange, indem wir sie an eine Warteschlange mit dem Namen "Hallo" senden:
channel.queue_declare(queue='hello')
Jetzt können Sie eine Nachricht senden. Ich möchte eine Nachricht, die nur das Wort "Hallo Welt!" Enthält, an die "Hallo" -Warteschlange senden.
In RabbitMQ werden Nachrichten immer über eine Komponente namens Exchange gesendet, anstatt direkt an die Warteschlange gesendet zu werden. Ich werde mich jedoch im Moment nicht mit den Details befassen (siehe Tutorial 3). Lassen Sie uns zunächst lernen, wie Sie den Standardaustausch verwenden, indem Sie ein leeres Zeichen ('') angeben. Dieser Austausch ist etwas Besonderes und ermöglicht es Ihnen, direkt anzugeben, an welche Warteschlange die Nachricht gesendet werden soll. Der Name der Zielwarteschlange wird im Parameter "routing_key" angegeben:
channel.basic_publish(exchange='',
routing_key='hello',
body='Hello World!')
print(" [x] Sent 'Hello World!'")
Bevor Sie das Programm beenden, müssen Sie sicherstellen, dass der Netzwerkpuffer geleert und die Nachricht ordnungsgemäß an RabbitMQ gesendet wird. Sie können diese Dinge tun und die Verbindung mit dem folgenden Code schließen.
connection.close()
__ Senden funktioniert nicht __ Wenn Sie Rabbit MQ zum ersten Mal verwenden und Probleme beim Senden von Nachrichten haben, fragen Sie sich möglicherweise, was falsch ist. Möglicherweise wird der Broker (RabbitMQ-Server) ohne ausreichenden Speicherplatz gestartet (mindestens 1 GB Speicherplatz ist erforderlich). In diesem Fall akzeptiert Rabbit MQ die Nachricht nicht. Überprüfen Sie die Protokolldatei und senken Sie gegebenenfalls die Mindesteinstellung für den Speicherplatz (
disk_free_limit). Dokumentation zur Konfigurationsdatei beschreibt die Konfiguration.
Erhalten
Das zweite Programm, receive.py, empfängt die Nachricht aus der Warteschlange und gibt sie auf dem Bildschirm aus. (vollständiger Code)
Stellen Sie zunächst eine Verbindung zum Rabbit MQ-Server her. Dieser Code ähnelt send.py.
Rufen Sie dann "queue_declare" auf, um sicherzustellen, dass eine Warteschlange verwendet werden kann. Diese Methode garantiert die Gleichheit der Leistung und führt nichts aus, wenn die angegebene Warteschlange bereits vorhanden ist. Daher können Sie so oft anrufen, wie Sie möchten. (Es wird nur eine Warteschlange mit demselben Namen erstellt.)
channel.queue_declare(queue='hello')
Möglicherweise fragen Sie sich, warum Sie die Warteschlange im send.py-Code erneut deklarieren möchten. Der Grund ist, sicherzustellen, dass die Warteschlange nicht existiert. Wenn Sie send.py immer zuerst starten, gibt es kein Problem (wenn Sie die Warteschlange nur mit send.py deklarieren), aber wir haben entschieden, welche zuerst gestartet werden soll: send.py oder receive.py. nicht. In diesen Fällen empfiehlt es sich, in beiden Programmen eine Warteschlangendeklaration (queue_declare) zu schreiben.
__ Warteschlangenliste __ Vielleicht möchten Sie sehen, wie viele Warteschlangen RabbitMQ hat und wie viele Nachrichten es gibt. Führen Sie in diesem Fall das Tool "rabbitmqctl" als autorisierten Benutzer aus:
$ sudo rabbitmqctl list_queues Listing queues ... hello 0 ...done.
Das Empfangen von Nachrichten aus der Warteschlange ist etwas kompliziert. Sie können den Prozess verschieben, indem Sie die Rückruffunktion in der Warteschlange registrieren. Immer wenn eine Nachricht empfangen wird, wird die Rückruffunktion aus der Pika-Bibliothek aufgerufen. Dieses Mal druckt diese Funktion den Inhalt der Nachricht auf den Bildschirm.
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
Weisen Sie dann RabbitMQ an, diesen Rückruf aufzurufen, wenn eine Nachricht von "Hallo" empfangen wird:
channel.basic_consume(callback,
queue='hello',
no_ack=True)
Dieser Befehl ist nicht erfolgreich, wenn keine Warteschlange zum Registrieren vorhanden ist. Glücklicherweise haben wir zuvor "queue_declare" erwähnt, sodass wir sicher sein können, dass die Warteschlange vorhanden ist. Der Parameter "no_ack" wird in Tutorial 2 erläutert. Schließlich treten wir in eine Endlosschleife ein, die auf Daten wartet und Rückrufe steuert:
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()
Ganzer Code
send.py
#!/usr/bin/env python
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.queue_declare(queue='hello')
channel.basic_publish(exchange='',
routing_key='hello',
body='Hello World!')
print(" [x] Sent 'Hello World!'")
connection.close()
receive.py
#!/usr/bin/env python
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.queue_declare(queue='hello')
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
channel.basic_consume(callback,
queue='hello',
no_ack=True)
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()
Probieren Sie das Programm vom Terminal aus. Führen Sie zunächst send.py aus, um eine Nachricht zu senden:
$ python send.py
[x] Sent 'Hello World!'
Das Produzentenprogramm send.py wird beendet, sobald Sie es senden. Lassen Sie uns nun die Nachricht erhalten:
$ python receive.py
[*] Waiting for messages. To exit press CTRL+C
[x] Received 'Hello World!'
Hurra! Sie haben die erste Nachricht mit RabbitMQ erfolgreich gesendet und empfangen. Wie Sie vielleicht bemerkt haben, wird reveive.py nicht beendet, wenn eine Nachricht empfangen wird, und wartet auf die nächste Nachricht. Drücken Sie Strg-C, um den Vorgang zu beenden.
In diesem Tutorial haben wir gelernt, wie Sie Nachrichten mit benannten Warteschlangen senden und empfangen. In Tutorial 2 erstellen Sie eine einzelne Arbeitswarteschlange.
Recommended Posts