Erste Erfahrungen mit der Bedienung von RabbitMQ in Python (1)

Da ich Python verwenden wollte, um ein verteiltes System zur Verwaltung und Überwachung des Inhalts und des Betriebsstatus des CDN zu implementieren, bin ich zufällig auf RabbitMQ gestoßen. Viele Leute haben es empfohlen, wie zum Beispiel Yu Fengs „Warum sollte ich RabbitMQ wählen?“. " und so weiter .

Als das Wort MQ in Sicht kam, habe ich mehrere Stunden damit verbracht, darüber zu lesen, was MQ ist, also Message Queue (Nachrichtenwarteschlange). Wie der Name schon sagt, ist Nachrichtenwarteschlange eine mit Nachrichten gefüllte Warteschlange, Warteschlange, Datenstruktursubstantiv, eine Datenstruktur mit First-In-First-Out-Eigenschaften. Die Nachrichtenwarteschlange wird lediglich zur Übermittlung von Nachrichten verwendet. Welche Bedeutung hat sie, welche Anwendungsszenarien gibt es, welche Funktionen bietet sie, welche einzigartigen Vorteile bietet sie und warum sollte sie verwendet werden? meiner Meinung nach.

Nach vielen Suchen kam ich schließlich zu einem oberflächlichen Verständnis, dass die Nachrichtenwarteschlange eine Kommunikationsmethode für die Informationsübertragung von Anwendung zu Anwendung ist. Wenn Sie beispielsweise die Protokolle mehrerer Server analysieren müssen, können Sie einen Prozess auf jedem Server verwenden, um Daten, also die erforderlichen Informationen, in eine Tabelle in einer MySQL-Datenbank zu schreiben, und dann mehrere Prozesse schreiben, um die Daten zu lesen in der Tabelle und verarbeiten die Daten nicht sehr gut, aber bald wurde die Hässlichkeit dieses Entwurfs deutlich ... Möchten Sie, dass mehrere Programme Daten aus einer Warteschlange zur Verarbeitung abrufen? Kein Problem, wir haben die Anzahl der Programme fest codiert ... was? Erlauben Sie dem Programm auch, den Druck dynamisch zu verteilen, während er dynamisch zunimmt und abnimmt? Dies ist ein Beispiel aus der sehr beliebten „RabbitMQ+Python Introduction to Classic Rabbit and Rabbit Nest“. Denken Sie darüber nach, wenn mein CDN viele Daten, Datenverteilung und -verarbeitung überträgt, wird alles ein Problem sein. Aber ich verstehe immer noch nicht, wie Rabbit diese Dinge umsetzt.

Konzeptionell ist RabbitMQ die Standardimplementierung von AMPQ (Advanced Message Protocol Queuing). Es wird gesagt, dass diejenigen, die mit AMQP nicht vertraut sind, die RabbitMQ-Dokumentation nicht verstehen werden. Aber wir können nur ein tiefes Verständnis der Schlüsselkonzepte aufbauen. Das gesamte RabbitMQ-Implementierungsprinzip ist in der folgenden Abbildung dargestellt. Es handelt sich tatsächlich um ein Produzenten- und Verbrauchermodell mit einer Routing-Aufgabenverteilungswarteschlange. Wie in der Abbildung gezeigt, erzeugt der Produzent entsprechende Informationen und sendet sie an den Router. Der Router verteilt die Informationen basierend auf den Schlüsselinformationen in den Informationen, und dann liest der Verbraucher die Daten in verschiedenen Nachrichtenwarteschlangen.

Broker: Einfach ausgedrückt handelt es sich um die Nachrichtenwarteschlangenservereinheit.
Austausch: Nachrichtenaustausch, der die Regeln angibt, nach denen Nachrichten an welche Warteschlange weitergeleitet werden.
Warteschlange: Träger der Nachrichtenwarteschlange. Jede Nachricht wird in eine oder mehrere Warteschlangen gestellt.
Bindung: Bindung, ihre Funktion besteht darin, Austausch und Warteschlange gemäß Routing-Regeln zu binden.
Routing-Schlüssel: Routing-Schlüsselwort, Exchange stellt Nachrichten basierend auf diesem Schlüsselwort zu.
vhost: virtueller Host. In einem Broker können mehrere vhosts geöffnet werden, um die Berechtigungen verschiedener Benutzer zu trennen.
Produzent: Der Nachrichtenproduzent ist das Programm, das Nachrichten übermittelt.
Consumer: Ein Nachrichtenkonsument ist ein Programm, das Nachrichten akzeptiert.
Kanal: Nachrichtenkanal In jeder Verbindung des Clients können mehrere Kanäle eingerichtet werden, wobei jeder Kanal eine Sitzungsaufgabe darstellt.

Der Prozess der Verwendung der Nachrichtenwarteschlange ist ungefähr wie folgt:

(1) Der Client stellt eine Verbindung zum Nachrichtenwarteschlangenserver her und öffnet einen Kanal.
(2) Der Client deklariert einen Austausch und legt zugehörige Attribute fest.
(3) Der Client deklariert eine Warteschlange und legt zugehörige Attribute fest.
(4) Der Client verwendet den Routing-Schlüssel, um eine verbindliche Beziehung zwischen Vermittlungsstelle und Warteschlange herzustellen.
(5) Der Kunde übermittelt die Nachricht zum Austausch.

Nachdem ich den allgemeinen Prozess und die Vorteile von RabbitMQ verstanden hatte, begann ich, RabbitMQ auf meinem eigenen Fedora zu testen.

Laut der offiziellen Website von RabbitMQ muss die Installation von hier heruntergeladen werden

http://www.rabbitmq.com/download.html

Klicken Sie, um jede Version des Binärpakets herunterzuladen. Ich habe Rabbitmq-Server-3.3.0-1.noarch.rpm heruntergeladen

Geben Sie die ein Downloadpfad, /home/ sun5495/Downloads/

[sun5495@localhost Downloads]# sudo chmod 777 Rabbitmq-server-3.3.0-1.noarch.rpm

Ändern Sie die Berechtigungen für ausführbare Dateien und Ausführungsberechtigungen erhöhen.

Führen Sie dann ./rabbitmq-server-3.3.0-1.noarch.rpm aus. Beim Ausführen wird ein Fehler gemeldet, der nicht installiert werden kann.

Es stellt sich heraus, dass Sie Erlang jetzt installieren müssen. Probieren Sie diesen Befehl yum install erlang aus, um es zu erledigen.

Dann verwenden Sie den Root-Benutzer zum Ausführen

rpm --import http://www.rabbitmq.com/rabbitmq-signing-key-public.asc yum install rabbitmq-server-3.3.0-1.noarch.rpm

Die Installation ist erfolgreich.

Um RBMQ beim Start einzurichten, verwenden Sie das Administratorkonto, um den Befehl

chkconfig rabbitmq-server on

zum Öffnen und Schließen des Servers auszuführen.

/sbin/service rabbitmq-server stop/start

Das Ergebnis ist Der folgende Fehler beim Öffnen
Rabbitmq-Server wird gestartet (über systemctl): Der Job für Rabbitmq-Server.service ist fehlgeschlagen. Weitere Informationen finden Sie unter „systemctl status Rabbitmq-server.service“ und „Journalctl -xn“. 🎜>

使用journalctl -xn命令打开日志，查看了下貌似是Erlang的某个文件拒绝访问，然后还提出了一大堆建议。

尝试一下

grep beam.smp /var/log/audit/audit.log | audit2allow -M mypolsemodule -i mypol.pp/sbin/service rabbitmq-server start

既然RabbitMQ安装也运行成功了，那么我就来尝尝RabbitMQ的鲜吧。就从官网上的例子一步一笔来做好了。

由于我使用的是Python，那么就需要安装一些支持RabbitMQ的库来进行操作，其中包括

py-amqplib,txAMQP,pika这几种，按照官网的tutorial，我也安装了pika。

pip install pika

从最简单的收发消息开始。即一端发送消息，一端接收消息。

发送方即生产者，首先要创建与RabbitMQ服务器的连接，

#!/usr/bin/env pythonimport pikaconnection = pika.BlockingConnection(pika.ConnectionParameters(              
 'localhost'))channel = connection.channel()

此处服务器连接本地localhost，也可以指定ip或者主机名。

其次发送方需要声明一个队列，比如命名为sayhello

channel.queue_declare(queue='sayhello')

此时我们就可以发送消息了。由于第一个小案例比较简单，没有经过路由器，因此发送消息时，指定路由为空即可。

channel.basic_publish(exchange='',                        
routing_key='hello',                                    
body='hello world')print "Sent ‘hello world'"

最后关闭连接即可。

connection.close()

接收方即消费者，需要从队列上获取数据，因此也需要绑定一个队列

channel.queue_declare(queue='hello')

同时，由于接收方的工作方式是基于队列的消息执行一个回调函数，当收到消息时，Pika就会执行相应的回调函数，因此我们需要定义此函数。

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()

OK执行成功。

接下来就逐步的深入体验RabbitMQ的独特魅力。

以上就是Python操作RabbitMQ初体验（一）的内容，更多相关内容请关注PHP中文网（www.php.cn）！