Rabbit MQ Tutorial 1 https://www.rabbitmq.com/tutorials/tutorial-one-python.html Es ist eine Übersetzung von. Wir freuen uns darauf, auf Übersetzungsfehler hinzuweisen.
In diesem Lernprogramm wird davon ausgegangen, dass RabbitMQ auf dem Standardport (5672) auf dem lokalen Host installiert ist und ausgeführt wird. Wenn Sie einen anderen Host, Port oder Anmeldeinformationen verwenden möchten, müssen Sie Ihre Verbindungseinstellungen anpassen.
Wenn Sie in diesem Tutorial auf Probleme stoßen, können Sie uns über die Mailingliste kontaktieren.
RabbitMQ ist ein Nachrichtenbroker. Die Hauptidee ist sehr einfach: Nachrichten annehmen und zustellen. Sie können sich das als Post vorstellen: Wenn Sie einen Brief an eine Post schreiben, können Sie sicher sein, dass der Postbote ihn schließlich an den Empfänger liefert. Nach dieser Metapher ist RabbitMQ ein Post, ein Postamt und ein Postbote.
Der große Unterschied zwischen RabbitMQ und der Post besteht darin, dass kein Papier verarbeitet wird, sondern binäre Blobs von Datennachrichten akzeptiert, gespeichert und zugestellt werden.
RabbitMQ und Messaging verwenden üblicherweise mehrere Fachbegriffe.
"Produktion" ist das Getriebe selbst. Das Programm, das die Nachricht sendet, ist der "Produzent". Wir zeichnen es mit einem "P" wie folgt:
"Warteschlange" ist der Name des Postfachs. Es befindet sich im Rabbit MQ. Die Nachricht fließt durch RabbitMQ und die Anwendung, wird jedoch nur in der "Warteschlange" gespeichert. Eine "Warteschlange" ist an keine Einschränkungen gebunden. Sie kann so viele Nachrichten speichern, wie Sie möchten. Sie ist ein im Wesentlichen unendlicher Puffer. Viele "Produzenten" können Nachrichten an eine "Warteschlange" senden und viele "Konsumenten" können versuchen, Daten von einer "Warteschlange" zu empfangen. Die "Warteschlange" hat ihren Namen oben und wird wie folgt gezeichnet:
"Verbrauchen" hat die gleiche Bedeutung wie "Empfangen". Ein "Verbraucher" ist ein Programm, das hauptsächlich auf den Empfang einer Nachricht wartet. Wir zeichnen es mit "C":
Beachten Sie, dass Hersteller, Verbraucher und Makler nicht an derselben Maschine sitzen müssen. Tatsächlich ist dies bei den meisten Anwendungen nicht der Fall.
Hello World!
Unsere "Hallo Welt" ist nicht zu kompliziert. Senden wir eine Nachricht, empfangen sie und drucken sie auf dem Bildschirm aus. Dazu benötigen Sie zwei Programme, eines zum Senden einer Nachricht und das andere zum Empfangen und Ausgeben.
Das Gesamtdesign sieht folgendermaßen aus:
Der Produzent sendet eine Nachricht an die Warteschlange „Hallo“. Der Verbraucher erhält eine Nachricht aus dieser Warteschlange.
Rabbit MQ Bibliothek
RabbitMQ verwendet mehrere Protokolle. Die in diesem Tutorial behandelte Version heißt AMQP 0-9-1. Um RabbitMQ verwenden zu können, benötigen Sie eine Bibliothek, die dasselbe Protokoll wie RabbitMQ versteht. Eine Auswahl an Bibliotheken für nahezu jede Programmiersprache ist verfügbar. Sie können in Python auch aus mehreren Bibliotheken auswählen. * pika * py-amqp * py-amqplib In einer Reihe von Tutorials wird Pika verwendet, die vom Rabbit MQ-Team empfohlene Bibliothek. Sie können das Pip-Paketverwaltungstool für die Installation verwenden.
$ sudo pip install pika==0.9.8
Diese Installation hängt von den Pip- und Git-Core-Paketen ab. Sie müssen sie zuerst installieren.
Für Ubuntu:
$ sudo apt-get install python-pip git-core
Für Debian:
$ sudo apt-get install python-setuptools git-core
$ sudo easy_install pip
Für Windows: Um easy_install zu installieren, führen Sie das Windows-Installationsprogramm für setuptools aus.
> easy_install pip
> PIP install pika==0.9.8
Das erste Programm, send.py, sendet eine einzelne Nachricht an die Warteschlange. 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()
Wir stellen jetzt eine Verbindung zu einem Broker auf unserem lokalen Computer ("localhost") her. Wenn Sie eine Verbindung zu einem Broker auf einem anderen Computer herstellen möchten, geben Sie hier einfach den Computernamen oder die IP-Adresse an.
Als Nächstes müssen Sie sicherstellen, dass die Warteschlange des Empfängers vorhanden ist, bevor Sie sie senden können. Wenn Sie eine Nachricht an einen nicht vorhandenen Speicherort senden, verwirft RabbitMQ die Nachricht einfach. Erstellen Sie eine Warteschlange, um die Nachricht zuzustellen, und nennen Sie sie "Hallo":
channel.queue_declare(queue='hello')
Jetzt können Sie die Nachricht senden. Unsere erste Nachricht enthält die Zeichenfolge "* Hello World! *" Und sendet sie an die * Hallo * -Warteschlange.
RabbitMQ sendet keine Nachrichten direkt an die Warteschlange, sondern muss immer * exchange * durchlaufen. Aber lassen Sie uns hier nicht auf die Details eingehen. Weitere Informationen zu * exchange * finden Sie in Teil 3 dieses Tutorials. Jetzt müssen Sie nur noch wissen, wie Sie den Standard-* Austausch * verwenden, der durch eine leere Zeichenfolge gekennzeichnet ist. Dieser * Austausch * ist etwas Besonderes. Sie können genau angeben, in welche Warteschlange die Nachricht gestellt werden soll. Sie müssen den Warteschlangennamen im Parameter routing_key angeben:
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 ist, um sicherzustellen, dass die Nachricht tatsächlich an RabbitMQ übermittelt wird. Sie können dies tun, indem Sie die Verbindung Gentleman schließen.
connection.close()
Senden funktioniert nicht!
Das zweite Programm, receive.py, empfängt die Nachricht aus der Warteschlange und gibt sie auf dem Bildschirm aus.
Auch hier müssen Sie zuerst eine Verbindung zum Rabbit MQ-Server herstellen. Der Code für die Verbindung mit Rabbit MQ ist der gleiche wie zuvor.
Der nächste Schritt besteht darin, sicherzustellen, dass die Warteschlange wie zuvor vorhanden ist. Das Erstellen einer Warteschlange mit queue_declare ist eine Schande. Sie können diesen Befehl so oft ausführen, wie Sie möchten, und es wird nur einer erstellt.
channel.queue_declare(queue='hello')
Sie fragen sich möglicherweise, warum Sie die Warteschlange erneut deklarieren. Sie haben sie bereits im vorherigen Code deklariert. Sie können dies vermeiden, wenn Sie sicher sind, dass die Warteschlange bereits vorhanden ist. Zum Beispiel, wenn das Programm send.py bereits ausgeführt wurde. Wir wissen aber immer noch nicht, welches Programm zuerst ausgeführt wird. In solchen Fällen wird empfohlen, dass beide Programme die Warteschlange wiederholt deklarieren.
Liste der Warteschlangen
Sie können sehen, welche Warteschlange sich in RabbitMQ befindet und wie viele Nachrichten es gibt. Sie können dies (als privilegierter Benutzer) mit dem Tool rabbitmqctl tun:
$ sudo rabbitmqctl list_queues
Listing queues ...
hello 0
...done.
(Sudo unter Windows weggelassen)
Das Empfangen einer Nachricht aus einer Warteschlange ist komplizierter. Dies funktioniert durch Registrieren einer Rückruffunktion in der Warteschlange. Diese Rückruffunktion wird von der Pika-Bibliothek jedes Mal aufgerufen, wenn eine Nachricht empfangen wird. In diesem Lernprogramm druckt diese Funktion den Inhalt der Nachricht auf dem Bildschirm.
def callback(ch, method, properties, body):
print " [x] Received %r" % (body,)
Als nächstes müssen Sie RabbitMQ mitteilen, dass diese Rückruffunktion eine Nachricht aus der Warteschlange "Hallo" erhalten soll.
channel.basic_consume(callback,
queue='hello',
no_ack=True)
Die Abonnementwarteschlange muss vorhanden sein, damit dieser Befehl erfolgreich ausgeführt werden kann. Zum Glück habe ich gerade eine Warteschlange mit queue_declare erstellt.
Der Parameter no_ack wird später beschrieben.
Und schließlich geht es in eine Endlosschleife, die auf Daten wartet und bei Bedarf Rückrufe ausführt.
print ' [*] Waiting for messages. To exit press CTRL+C'
channel.start_consuming()
Vollständiger Code für send.py:
1 #!/usr/bin/env python
2 import pika
3
4 connection = pika.BlockingConnection(pika.ConnectionParameters(
5 host='localhost'))
6 channel = connection.channel()
7
8 channel.queue_declare(queue='hello')
9
10 channel.basic_publish(exchange='',
11 routing_key='hello',
12 body='Hello World!')
13 print " [x] Sent 'Hello World!'"
14 connection.close()
Vollständiger Code für receive.py:
1 #!/usr/bin/env python
2 import pika
3
4 connection = pika.BlockingConnection(pika.ConnectionParameters(
5 host='localhost'))
6 channel = connection.channel()
7
8 channel.queue_declare(queue='hello')
9
10 print ' [*] Waiting for messages. To exit press CTRL+C'
11
12 def callback(ch, method, properties, body):
13 print " [x] Received %r" % (body,)
14
15 channel.basic_consume(callback,
16 queue='hello',
17 no_ack=True)
18
19 channel.start_consuming()
Sie können das Programm jetzt im Terminal ausprobieren. Senden wir zunächst eine Nachricht mit dem Programm send.py:
$ python send.py
[x] Sent 'Hello World!'
Das Produzentenprogramm send.py stoppt nach allen Läufen. Lassen Sie es uns erhalten:
$ python receive.py
[*] Waiting for messages. To exit press CTRL+C
[x] Received 'Hello World!'
Banzai! Ich konnte die erste Nachricht über RabbitMQ senden. Wie Sie vielleicht bemerkt haben, wird das Programm receive.py nicht beendet. Sie können sich auf den Empfang weiterer Nachrichten vorbereiten und mit Strg-C unterbrechen.
Versuchen Sie erneut, send.py in einem neuen Terminal auszuführen.
Sie haben gelernt, wie Sie Nachrichten aus benannten Warteschlangen senden und empfangen. Fahren wir mit Teil 2 fort und erstellen eine einfache Arbeitswarteschlange.
Recommended Posts