Première expérience d'exploitation de RabbitMQ en Python (1)

Parce que je voulais utiliser Python pour implémenter un système distribué pour gérer et surveiller le contenu et l'état de fonctionnement du CDN, j'ai connu RabbitMQ par accident. De nombreuses personnes l'ont recommandé, comme "Pourquoi devrais-je choisir RabbitMQ" de Yu Feng. " et ainsi de suite .

Lorsque le mot MQ est apparu, j'ai passé plusieurs heures à lire ce qu'est MQ, c'est-à-dire Message Queue (Message Queue). Comme son nom l'indique, la file d'attente de messages, une file d'attente remplie de messages, file d'attente, nom de structure de données, est une structure de données avec des caractéristiques de premier entré, premier sorti. La file d'attente de messages n'est rien d'autre que utilisée pour transmettre des messages, alors quelle est sa signification, quels sont ses scénarios d'application, quelles sont ses fonctionnalités, quels sont ses avantages uniques et pourquoi elle devrait être utilisée. Ce sont une série de questions qui se posent. à mon avis.

Après de nombreuses recherches, je suis finalement parvenu à comprendre superficiellement que la file d'attente de messages est une méthode de communication pour le transfert d'informations d'une application à l'autre. Par exemple, si vous devez analyser les journaux de plusieurs serveurs, vous pouvez utiliser un processus sur chaque serveur pour écrire des données, c'est-à-dire les informations requises, dans une table d'une base de données Mysql, puis écrire plusieurs processus pour lire les données. dans le tableau et traiter les données. L'analyse n'est pas très bonne, mais la laideur de cette conception est vite devenue apparente... Voulez-vous que plusieurs programmes récupèrent les données d'une file d'attente pour les traiter ? Pas de problème, nous avons codé en dur le nombre de programmes... quoi ? Permettre également au programme de répartir dynamiquement la pression à mesure qu'elle augmente et diminue dynamiquement ? Ceci est un exemple du populaire « RabbitMQ Python Introduction Classic Rabbit and Rabbit Nest ». Pensez-y, lorsque mon CDN transmettra beaucoup de données, de distribution de données, de traitement, tout sera problème. Mais je ne comprends toujours pas comment Rabbit implémente ces choses.

Conceptuellement parlant, RabbitMQ est l'implémentation standard d'AMPQ (Advanced Message Protocol Queuing). On dit que ceux qui ne sont pas familiers avec AMQP ne comprendront pas la documentation de RabbitMQ. Mais nous ne pouvons que développer une solide compréhension des concepts clés. L'ensemble du modèle de principe de mise en œuvre de RabbitMQ est présenté dans la figure ci-dessous. Il s'agit en fait d'un modèle producteur et consommateur avec une file d'attente de distribution des tâches de routage. Comme le montre la figure, le producteur produit les informations correspondantes et les envoie au routeur. Le routeur distribue les informations à différentes files d'attente de messages en fonction des informations clés contenues dans les informations, puis le consommateur lit les données dans différentes files d'attente de messages.

Courtier : En termes simples, il s'agit de l'entité du serveur de file d'attente de messages.
Exchange : échange de messages, qui précise les règles selon lesquelles les messages sont acheminés vers quelle file d'attente.
File d'attente : support de file d'attente de messages, chaque message sera placé dans une ou plusieurs files d'attente.
Liaison : Liaison, sa fonction est de lier l'échange et la file d'attente selon les règles de routage.
Clé de routage : mot-clé de routage, l'échange délivre des messages basés sur ce mot-clé.
vhost : hôte virtuel. Plusieurs vhosts peuvent être ouverts dans un courtier pour séparer les autorisations des différents utilisateurs.
Producteur : Le producteur de messages est le programme qui délivre des messages.
Consommateur : Un consommateur de messages est un programme qui accepte les messages.
Canal : canal de message. Dans chaque connexion du client, plusieurs canaux peuvent être établis, chaque canal représente une tâche de session.

Le processus d'utilisation de la file d'attente de messages est à peu près le suivant :

(1) Le client se connecte au serveur de file d'attente de messages et ouvre un canal.
(2) Le client déclare un échange et définit les attributs associés.
(3) Le client déclare une file d'attente et définit les attributs associés.
(4) Le client utilise la clé de routage pour établir une relation de liaison entre l'échange et la file d'attente.
(5) Le client délivre le message à échanger.

Après avoir compris le processus général et les avantages de RabbitMQ, j'ai commencé à tester RabbitMQ sur mon propre Fedora.

Selon le site officiel de RabbitMQ, l'installation doit être téléchargée à partir d'ici

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

Cliquez pour télécharger chaque version du package binaire. J'ai téléchargé Rabbitmq-server-3.3.0-1.noarch.rpm

Entrez le téléchargement. path, /home/ sun5495/Downloads/

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

Modifiez les autorisations du fichier exécutable et augmenter les autorisations d'exécution.

Exécutez ensuite ./rabbitmq-server-3.3.0-1.noarch.rpm, et une erreur sera signalée lors de l'exécution, impossible à installer.

Il s'avère que vous devez installer Erlang maintenant. Essayez cette commande yum install erlang pour le faire.

Utilisez ensuite l'utilisateur root pour exécuter

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

L'installation est réussie.

Afin de configurer RBMQ au démarrage, utilisez le compte administrateur pour exécuter la commande

chkconfig rabbitmq-server on

pour ouvrir et fermer le serveur

/sbin/service rabbitmq-server stop/start

Le résultat est l'erreur suivante lors de son ouverture
Démarrage de Rabbitmq-server (via systemctl) : Le travail pour Rabbitmq-server.service a échoué. Voir 'systemctl status Rabbitmq-server.service' et 'journalctl -xn' pour plus de détails. 🎜>

使用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）！