RabbitMQ : middleware de messagerie puissant pour une messagerie fiable

 Les middlewares de messagerie jouent un rôle clé dans les systèmes distribués modernes, ils fournissent une méthode fiable et efficace pour la communication asynchrone et le découplage. Dans ce blog, nous nous concentrerons sur RabbitMQ, un middleware de messagerie open source largement utilisé. Nous allons plonger dans les fonctionnalités de RabbitMQ, son fonctionnement et comment vous pouvez l'utiliser dans vos applications pour une messagerie fiable.

1. Introduction à RabbitMQ

RabbitMQ est un middleware de messagerie open source basé sur AMQP (Advanced Message Queuing Protocol). Il fournit un mécanisme de messagerie fiable, flexible et extensible qui est largement utilisé dans diverses industries. L'idée centrale de RabbitMQ est que le producteur envoie le message au commutateur, le commutateur transmet le message à la file d'attente conformément aux règles de routage, puis le consommateur reçoit et traite le message de la file d'attente.

2. Notions connexes

RabbitMQ est un middleware de messagerie open source écrit en Erlang et implémente le protocole Advanced Message Queuing Protocol (AMQP). En tant que système de messagerie fiable, flexible et évolutif, RabbitMQ fournit un mécanisme fiable pour transférer des données entre les applications.

Voici une explication détaillée de certaines fonctionnalités et concepts clés de RabbitMQ :

1. Files d'attente de messages : RabbitMQ utilise des files d'attente de messages pour stocker et livrer des messages. Une file d'attente de messages est une structure de données premier entré, premier sorti (FIFO) qui y stocke temporairement des messages jusqu'à ce qu'un consommateur soit prêt à les recevoir et à les traiter.

2. Producteur et consommateur : l'expéditeur du message est appelé le producteur et le destinataire du message est appelé le consommateur. Les producteurs envoient des messages aux files d'attente et les consommateurs reçoivent les messages des files d'attente et les traitent.

3. File d'attente : La file d'attente est la partie centrale de RabbitMQ, qui est le support de stockage et de livraison des messages. Les producteurs envoient des messages à la file d'attente et les consommateurs reçoivent des messages de la file d'attente. Les files d'attente peuvent être persistantes, ce qui signifie que même si le serveur RabbitMQ est en panne, les messages ne seront pas perdus.

4. Échange (Exchange): L'échange est le routeur du message, qui envoie le message du producteur à la file d'attente. Il achemine les messages vers une ou plusieurs files d'attente selon des règles spécifiques. RabbitMQ fournit différents types de commutateurs, notamment des commutateurs directs, des commutateurs de sujet, des commutateurs de diffusion, etc.

5. Liaison : la liaison associe les échanges et les files d'attente pour définir les règles de routage des messages entre les échanges et les files d'attente. Les liaisons spécifient comment les messages doivent être acheminés des échanges vers les files d'attente.

6. Clé de routage : une clé de routage est un attribut qu'un producteur spécifie avec un message lorsqu'il l'envoie. L'échange utilise la clé de routage pour déterminer vers quelle file d'attente acheminer le message.

7. Persistance : Lorsque les files d'attente ou les messages sont marqués comme persistants, ils sont conservés sur le disque pour éviter la perte de données après le redémarrage de RabbitMQ.

8. Mode publication-abonnement : RabbitMQ prend en charge le mode publication-abonnement, dans lequel un producteur envoie un message au commutateur, et le commutateur diffuse le message à toutes les files d'attente qui lui sont liées, puis les consommateurs de chaque file d'attente peuvent recevoir et traiter le message.

9. Mécanisme ACK : les consommateurs peuvent utiliser le mécanisme ACK pour informer RabbitMQ que le message a été reçu et traité avec succès. RabbitMQ supprimera le message de la file d'attente uniquement après que le consommateur l'aura explicitement reconnu.

10. Accusé de réception et persistance des messages : RabbitMQ permet aux producteurs de demander un accusé de réception lors de l'envoi de messages. Si un message ne peut pas être acheminé avec succès vers une file d'attente, ou si une erreur se produit lors de l'acheminement, RabbitMQ en informera le producteur. De plus, la persistance des messages et des files d'attente garantit l'absence de perte de données même après le redémarrage de RabbitMQ.

En bref, RabbitMQ est un middleware de messagerie fiable et flexible. Il prend la file d'attente de messages comme cœur et utilise des concepts tels que les commutateurs, les files d'attente et les liaisons pour acheminer et livrer les messages. Il fournit un mécanisme de messagerie hautement fiable et des fonctionnalités riches, et est largement utilisé dans les systèmes distribués, les architectures de microservices, les files d'attente de tâches et d'autres scénarios pour aider les applications à réaliser le découplage, la communication asynchrone et l'assurance de la fiabilité.

3. Comment fonctionne RabbitMQ

Le principe de fonctionnement de RabbitMQ peut être simplement résumé comme suit :

1. Le producteur envoie un message à l'échange :

Les producteurs se connectent à RabbitMQ et envoient des messages à des échanges prédéfinis. Les messages peuvent contenir toutes les données structurées telles que JSON, XML, etc.

String message = "Hello, RabbitMQ!";
channel.basicPublish(exchangeName, routingKey, null, message.getBytes());

2. Le commutateur achemine le message vers la file d'attente :

Un échange achemine les messages vers une ou plusieurs files d'attente qui lui sont liées selon des règles de routage prédéfinies. Les règles de routage peuvent être basées sur une correspondance exacte, une correspondance de modèle, etc.

channel.queueBind(queueName, exchangeName, routingKey);

3. Le consommateur reçoit le message de la file d'attente :

Les consommateurs se connectent à RabbitMQ et s'abonnent aux files d'attente qui les intéressent. Une fois qu'un message arrive dans la file d'attente, RabbitMQ envoie immédiatement le message aux consommateurs abonnés pour traitement.

channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        String message = new String(body, "UTF-8");
        System.out.println("Received message: " + message);
    }
});

4. Le consommateur traite le message et envoie une confirmation :

Une fois que les consommateurs ont reçu le message, ils peuvent effectuer le traitement de logique métier correspondant. Une fois le message traité avec succès, le consommateur enverra un accusé de réception à RabbitMQ indiquant que le message a été consommé et RabbitMQ peut supprimer le message en toute sécurité.

Un producteur envoie des messages à un échange nommé "my_exchange" et achemine les messages vers une file d'attente nommée "my_queue" avec la clé de routage "my_routing_key". Le consommateur s'abonne à la file d'attente "my_queue" et appelle la fonction de rappel pour traiter le message lorsqu'il le reçoit.

4. Caractéristiques de RabbitMQ

RabbitMQ fournit de nombreuses fonctionnalités puissantes qui en font un middleware de messagerie largement utilisé :

• Persistance : RabbitMQ peut conserver les messages et les files d'attente sur le disque, et les messages ne seront pas perdus même après le redémarrage du serveur.
• Règles de routage flexibles : en utilisant différents types de commutateurs et de clés de routage, des stratégies précises de routage des messages peuvent être réalisées.
• Fiabilité et récupérabilité : RabbitMQ fournit une variété de mécanismes pour assurer une livraison fiable des messages, tels que l'accusé de réception du message, la transaction, la confirmation de l'éditeur, etc.
• Évolutivité : RabbitMQ prend en charge le déploiement distribué et le mode cluster, ce qui permet d'atteindre un débit élevé et une haute disponibilité.
• Client multilingue : RabbitMQ fournit une variété de bibliothèques client officiellement prises en charge, telles que Java, Python, Ruby, etc., pour faciliter l'utilisation des développeurs dans différents environnements linguistiques.

5. Scénarios d'application de RabbitMQ dans des applications pratiques

Article de référence :

【RabbitMQ】Qu'est-ce que RabbitMQ ? A quoi sert RabbitMQ ? Quels sont les scénarios d'application ? _Blog de Luyao Yezi - Blog CSDN

RabbitMQ a une large gamme d'applications dans divers scénarios, y compris, mais sans s'y limiter :

• Traitement des tâches asynchrones : envoyez des tâches longues à RabbitMQ et exécutez-les de manière asynchrone par les consommateurs pour améliorer les performances de réponse et l'évolutivité du système.
• Architecture pilotée par les événements : en utilisant RabbitMQ pour implémenter la publication et l'abonnement aux événements, différents composants peuvent être découplés en s'abonnant aux événements d'intérêt.
• Découplage des applications et contrôle de flux : en introduisant un middleware de messagerie, différentes applications peuvent être découplées et des mécanismes tels que le contrôle de flux et la dégradation de service peuvent être mis en œuvre.
• Collecte et analyse des journaux : utilisez RabbitMQ pour envoyer des messages de journal dans le système distribué au serveur de journal central pour une gestion et une analyse centralisées.

 5.1 Découplage entre services

Commandes des utilisateurs, traitement des stocks. [Découplage entre services]

Avant d'utiliser MQ :

Lorsque le système est normal, l'utilisateur passe une commande et le système de commande appelle le système d'inventaire pour effectuer une opération de suppression. Si l'opération réussit, il renverra un message pour rappeler que la commande a été passée avec succès. Lorsque le système est anormal, le système d'inventaire sera inaccessible, ce qui entraînera l'impossibilité d'exécuter l'opération de suppression de la commande, et conduira finalement à l'échec de la passation de la commande.

Après avoir utilisé MQ :

Le système de commande et le système d'inventaire n'interagissent plus les uns avec les autres et fonctionnent indépendamment, atteignant l'objectif de découplage des applications. Le système de commande n'a qu'à écrire le message de commande dans MQ, puis il peut directement exécuter l'étape suivante. À ce stade, même si le système d'inventaire est anormal, cela n'affectera pas le fonctionnement du système de commande et l'enregistrement de suppression d'inventaire de la commande sera enregistré de manière permanente dans MQ jusqu'à ce que le système d'inventaire revienne à la normale et souscrive à la commande. message de MQ pour consommation jusqu'à ce qu'il réussisse.

Avant d'utiliser MQ :

Après avoir utilisé MQ :

5.2  Réaliser une communication asynchrone

Enregistrement de l'utilisateur, envoi de SMS, e-mails . [Réaliser une communication asynchrone]

Avant d'utiliser MQ :

L'ensemble du processus d'opération est terminé dans le fil principal. Cliquez sur Enregistrement de l'utilisateur--"Ajouter un utilisateur dans le stockage--"Envoyer un e-mail--"Envoyer un SMS. Chaque étape doit attendre la fin de l'étape précédente avant de pouvoir s'exécuter. De plus, le temps de réponse de chaque étape de l'opération n'est pas fixe. S'il y a trop de requêtes, il faudra beaucoup de temps pour demander le thread principal, ralentir la réponse et même provoquer un plantage, ce qui affecte sérieusement l'expérience utilisateur.

Après avoir utilisé MQ :

Le thread principal n'a besoin que de traiter les opérations d'entreposage les moins chronophages, puis d'écrire les messages à traiter dans la file d'attente de messages MQ, puis de s'abonner aux messages de la file d'attente de messages pour qu'ils soient consommés par différents systèmes de messagerie indépendants et systèmes SMS à le même temps. De cette manière, la file d'attente de messages est utilisée comme intermédiaire pour stocker et délivrer des messages, ce qui non seulement prend du temps et consomme très peu de ressources, mais également un seul serveur peut supporter plus de demandes simultanées.

 

5.3  Écrêtage des pics de débit

Ventes flash et snap-ups de produits de base. 【Écrêtage des pics de débit】

L'écrêtage des pics de trafic est un scénario courant dans les files d'attente de messages et est généralement utilisé dans les ventes flash ou les activités d'achat groupé.

Avant d'utiliser MQ : Pour les ventes flash et les activités d'achat de panique, le trafic généré par l'accès des utilisateurs sera très important, et même des dizaines de millions de demandes apparaîtront dans la même période. Cette augmentation instantanée du trafic, la configuration de notre système d'application est insupportable , entraînera directement le plantage du système.

Par exemple : le système A demande généralement 100 requêtes par seconde, et le système fonctionne de manière stable ; cependant, il y a un pic d'activité à 20 h 00, et le nombre de requêtes passe à 10 000 par seconde, et le système peut traiter un maximum de 1 000 requêtes par seconde, provoquant le plantage du système. 

Après avoir utilisé MQ : lorsqu'un grand nombre d'utilisateurs effectuent des demandes de pointe, nous rejetons cette énorme demande de trafic au niveau de la couche supérieure du traitement métier du système et la transférons vers MQ au lieu de la déverser directement dans notre interface. Ici, la file d'attente de messages MQ agit comme un cache.

Par exemple : 1 million d'utilisateurs demandent 5 000 requêtes par seconde pendant la période de pointe. L'écriture de ces 5 000 requêtes dans le système MQ ne peut traiter que 2 000 requêtes par seconde, car MySQL ne peut traiter que 2 000 requêtes ; le système extrait 2 000 requêtes par seconde. Plus de vous pouvez gérer.

Avant d'utiliser MQ :

 Après avoir utilisé MQ :

5.4 Autres scénarios d'application :

1. Système de traitement des commandes :

Dans une plateforme de commerce électronique, RabbitMQ peut être utilisé pour traiter les commandes. Lorsqu'un utilisateur passe une commande, les informations de commande sont publiées sur le commutateur RabbitMQ, puis les consommateurs associés reçoivent le message de commande de la file d'attente et le traitent, comme la vérification de la commande, la gestion des stocks, le paiement, etc.

2. Collecte et distribution des journaux :

Supposons que vous disposiez de plusieurs applications qui génèrent des journaux et que vous souhaitiez les traiter et les stocker de manière centralisée. Chaque application peut publier des messages de journal sur un échange appelé "log_exchange", puis différents consommateurs s'abonnent à l'échange et écrivent les messages de journal dans la base de données ou les envoient au système d'analyse de journal.

3. Transmission de données en temps réel :

S'il existe un système de surveillance en temps réel, les données du capteur doivent être transmises à la plate-forme de surveillance en temps réel pour le traitement et l'affichage visuel. Le capteur publie les données sur le commutateur RabbitMQ, et le consommateur de la plate-forme de surveillance s'abonne au commutateur et traite les données, afin de réaliser des fonctions de surveillance et d'alarme en temps réel.

4. Traitement des tâches asynchrones :

Supposons qu'il existe une application qui doit gérer de nombreuses tâches chronophages, telles que le traitement d'images, la conversion PDF, etc. L'application publie des tâches dans la file d'attente RabbitMQ, puis plusieurs nœuds de travail agissent en tant que consommateurs pour obtenir des tâches de la file d'attente et les traiter pour obtenir un traitement parallèle des tâches et réduire la pression sur l'application principale.

5. Système de notification des messages :

 Supposons que dans un système d'abonnement, les utilisateurs puissent s'abonner à différents sujets ou événements. Lorsqu'un nouveau message est publié, RabbitMQ acheminera le message vers la file d'attente correspondante, puis les utilisateurs qui s'abonnent à la file d'attente recevront les notifications correspondantes. Cette méthode peut être utilisée pour implémenter l'abonnement par e-mail, la diffusion d'actualités et d'autres fonctions.

6. Architecture des microservices :

Dans une architecture de microservices, la messagerie et la collaboration peuvent être nécessaires entre différents services. L'utilisation de RabbitMQ peut réaliser le découplage et la communication asynchrone entre les services, et chaque service peut envoyer et recevoir des messages via des commutateurs et des files d'attente, réalisant ainsi un couplage lâche entre les microservices.

6. Installation de RabbitMQ

Adresse du site officiel :

RabbitMQ : messagerie et streaming faciles à utiliser et flexibles — RabbitMQ

6.1 installation de brassage

brew update #更新一下homebrew
brew install rabbitmq   #安装rabbitMQ 

Résultat de l'installation :

==> Mises en garde
==>
Plugin de gestion rabbitmq activé par défaut sur http://localhost:15672

Pour redémarrer rabbitmq après une mise à jour :
  brew services restart rabbitmq
Ou, si vous ne voulez/n'avez pas besoin d'un service en arrière-plan, vous pouvez simplement exécuter :
  CONF_ENV_FILE="/opt/homebrew/etc/rabbitmq/rabbitmq-env.conf" /opt/ homebrew/opt/rabbitmq/sbin/rabbitmq-server

 Le chemin d'installation de rabbitmq :

/opt/homebrew/opt/rabbitmq

6.2, configurer les variables d'environnement

1,

vi ~/.bash_profile

2、 

export RABBIT_HOME=${PATH}:/opt/homebrew/opt/rabbitmq
export PATH=${PATH}:$RABBIT_HOME/sbin

3、 

source ~/.bash_profile

6.3, démarrer RabbitMQ

1. Exécutez
rabbitmq-server au premier plan

2. Exécutez
rabbitmq-server-dependent en arrière-plan

3. Afficher l'état d'exécution
rabbitmqctl status

4. Démarrez le plugin web
rabbitmq-plugins enable rabbitmq_management

5. Redémarrez
rabbitmq-server restart

5. Fermez
l'arrêt rabbitmqctl

6.4. Accéder à MQ

1. Adresse du navigateur

http://localhost:15672/
Le nom d'utilisateur et le mot de passe par défaut sont guest

Ajouter un utilisateur
rabbitmqctl add_user miaojiang 123

Définir l'utilisateur en tant qu'administrateur
rabbitmqctl set_user_tags administrateur miaojiang

Configurez les utilisateurs pour qu'ils se connectent à distance à
rabbitmqctl set_permissions -p "/" miaojaing ".*" ".*" ".*"

Afficher les comptes nouvellement ajoutés

lapinmqctl list_users

Afficher les permissions utilisées
rabbitmqctl list_permissions -p /

Sept, application de projet Spring Boot RabbitMQ

7.1. Ajouter une dépendance Maven :

Ajoutez la dépendance de la bibliothèque cliente RabbitMQ au fichier pom.xml de votre projet

<!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

7.2. Configurer la connexion RabbitMQ :

Ajoutez les informations de connexion RabbitMQ dans le fichier de configuration Spring Boot (application.properties ou application.yml).

application.properties :

spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

Configurez les paramètres mq dans application.yml :

spring:
  rabbitmq:
    #设置RabbitMQ的IP地址
    host: localhost
    #设置rabbitmq服务器用户名
    username: guest
    #设置rabbitmq服务器密码
    password: guest
    #设置rabbitmq服务器连接端口
    port: 5672

7.3 Créer un commutateur

nom de commutateur personnalisé

Créer un échange appelé "myExchange"

package com.example.usermanagement.mq;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {
    /*
    使用 @Configuration 注解创建一个配置类，并通过 @Bean 注解创建了一个名为 declareExchange 的方法，用于声明创建交换机。请根据实际情况修改交换机名称、类型和持久化设置。
     */

    public static final String EXCHANGE_NAME = "myExchange";

    @Bean
    public Exchange declareExchange() {
        return ExchangeBuilder.directExchange(EXCHANGE_NAME)
                .durable(true)
                .build();
    }
}

7.4 Créer un expéditeur de message

Créer un expéditeur de message : créer une classe d'expéditeur de message pour envoyer des messages à RabbitMQ

package com.example.usermanagement.mq;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MessageSender{

    private final AmqpTemplate amqpTemplate;
    private final String exchangeName = "myExchange"; // 自定义交换机名称

    @Autowired
    public MessageSender(AmqpTemplate amqpTemplate) {
        this.amqpTemplate = amqpTemplate;
    }

    public void sendMessage(Object message) {
        amqpTemplate.convertAndSend(exchangeName, "", message); // 发送消息到默认交换机和空路由键
    }
}

Avis:

 Le type sendMessage utilise le type Object

7.5 Arrière-plan de gestion RabbitMQ pour ajouter des colonnes

étape:

1. Ouvrez un navigateur et entrez l'URL de l'arrière-plan de gestion RabbitMQ. Par défaut, l'URL est http://localhost:15672/. Veuillez vous assurer que votre serveur RabbitMQ est en cours d'exécution et sur le bon numéro de port.

2. Entrez le nom d'utilisateur et le mot de passe pour vous connecter à l'arrière-plan de gestion RabbitMQ. Par défaut, le nom d'utilisateur est guest, et le mot de passe est également guest. Si vous avez changé votre nom d'utilisateur et votre mot de passe, veuillez vous connecter avec vos identifiants personnalisés.

3. Après vous être connecté avec succès, vous verrez l'interface principale de l'arrière-plan de gestion RabbitMQ. Dans la barre de navigation supérieure, choisissez QueuesOnglets.

4. Sur Queuesla page, vous verrez une liste des files d'attente existantes. Si vous souhaitez créer une nouvelle file d'attente, cliquez sur Add a new queuele bouton.

5. Sur la page pour ajouter une file d'attente, renseignez les informations suivantes :

   • Name: Le nom de la file d'attente. Donnez un nom unique à la file d'attente. (comme myQueue)
   • Durability: Persistance de la file d'attente. Sélectionnez Oui ou Non pour spécifier si la file d'attente doit persister lors des redémarrages du service RabbitMQ.
   • Auto delete: Suppression automatique de la file d'attente. Sélectionnez Oui ou Non pour indiquer s'il faut supprimer la file d'attente lorsque le dernier consommateur se déconnecte.
   • Arguments: Paramètres supplémentaires pour la file d'attente. Ceci est facultatif, vous pouvez définir certains paramètres spécifiques pour la file d'attente.

6. Après avoir rempli les informations de file d'attente, cliquez sur Add queuele bouton pour créer la file d'attente.

7. Une fois la création réussie, vous Queuesverrez la file d'attente nouvellement ajoutée sur la page. Vous pouvez afficher les détails de la file d'attente sur cette page, y compris le nombre de messages, le nombre de consommateurs, etc.

http://localhost:15672/#/files d'attente

Ajoutez simplement le nom de la file d'attente 

7.6 Appel du producteur

1. MessageSenderExemple d'injection

@Autowired
private MessageSender messageSender;

2. Appelez la méthode où le message doit être envoyé messageSender.sendMessage. Selon votre logique métier, vous pouvez appeler cette méthode à un emplacement approprié. Par exemple, une fois la commande créée avec succès, vous pouvez ajouter le code suivant :

messageSender.sendMessage("订单已创建：" + order.getOrderId());

7.7 Créer un destinataire de message

Créer un récepteur de message : créez une classe de récepteur de message pour traiter les messages RabbitMQ reçus.

Ici, nous écrivons directement la logique de traitement des messages RabbitMQ.

package com.example.usermanagement.mq;

import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class MessageReceiver {

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue("your_queue_name"),
            exchange = @Exchange(value = RabbitMQConfig.EXCHANGE_NAME)
//            key = "your_routing_key"
    ))
    public void receiveMessage(Object message) {
        System.out.println("Received message: " + message);
        // 处理消息逻辑
    }
}

Avis:

 Le type sendMessage utilise le type Object

your_queue_nameRemplacez par le nom de la file d'attente que vous souhaitez écouter (comme myQueue)

Remplacer your_routing_keypar la clé de routage appropriée (si utilisée)

Huit, introduction de l'interface MQ

Vue d'ensemble : Fournit un rapport de vue d'ensemble comprenant des informations sur le serveur et le cluster, l'état du nœud, les résumés de file d'attente et de connexion et les entrées de journal associées récentes.
Connexions : affiche les applications clientes actuellement connectées au serveur RabbitMQ, y compris le nom de la connexion, le protocole, l'hôte virtuel et d'autres informations.
Canaux : affiche les canaux actifs sur chaque connexion et certaines mesures liées à chaque canal, telles que le nombre de consommateurs, le nombre de messages non reconnus, etc.
Échanges : répertorie tous les échanges, y compris le nom, le type, les files d'attente liées et la quantité liée.
Files d'attente (file d'attente) : affiche toutes les files d'attente, y compris des informations telles que le nom, le nombre de messages, le nombre de consommateurs, etc. Vous pouvez également effectuer certaines opérations via la file d'attente, telles que créer, supprimer, vider, etc.
Admin (administrateur) : Fournit certaines fonctions de gestion avancées, telles que la gestion des utilisateurs et des autorités, la gestion de l'hôte virtuel, la gestion des plug-ins, etc.

8.1 Aperçu

Vue d'ensemble : Fournit un rapport de vue d'ensemble comprenant des informations sur le serveur et le cluster, l'état du nœud, les résumés de file d'attente et de connexion et les entrées de journal associées récentes.

​

8.2 Connexions

Connexions : affiche les applications clientes actuellement connectées au serveur RabbitMQ, y compris le nom de la connexion, le protocole, l'hôte virtuel et d'autres informations.

8.3 Canaux

Canaux : affiche les canaux actifs sur chaque connexion et certaines mesures liées à chaque canal, telles que le nombre de consommateurs, le nombre de messages non reconnus, etc.

8.3.1 prélecture (prélecture)

Dans Message Queue (Message Queue), la prélecture (prefetch) est un concept important, qui est utilisé pour contrôler la vitesse à laquelle les consommateurs reçoivent les messages de la file d'attente de messages.

La prélecture fait référence à l'obtention d'un certain nombre de messages dans le cache local avant que le consommateur ne reçoive le message de la file d'attente de messages pour un traitement rapide par le consommateur. De cette manière, le débit et l'efficacité du système peuvent être améliorés, et la charge de transmission du réseau peut être réduite.

Plus précisément, la prélecture peut aider à éviter les situations suivantes :

1. Répartition équitable : lorsque plusieurs consommateurs traitent des messages en parallèle, s'il n'y a pas de limite de prélecture, un consommateur peut recevoir trop de messages à la fois, ce qui réduit les opportunités pour les autres consommateurs. En définissant la prélecture, vous pouvez vous assurer que chaque consommateur ne peut recevoir qu'un certain nombre de messages pour obtenir une distribution plus équitable des messages.

2. Équilibrage de la charge des consommateurs : lorsqu'il y a un grand nombre de messages en attente dans la file d'attente des messages, les consommateurs peuvent retarder les messages en raison de la lenteur de la vitesse de traitement. En définissant une valeur de prélecture appropriée, vous pouvez limiter le nombre de messages que les consommateurs reçoivent à chaque fois, afin que les messages puissent être distribués uniformément à plusieurs consommateurs, réalisant ainsi l'équilibrage de charge.

Dans RabbitMQ, les paramètres de prélecture peuvent basic.qosêtre configurés via la méthode. Par exemple, le code suivant définira le nombre de prélectures sur 10 :

channel.basic_qos(prefetch_count=10)

Veuillez noter que les paramètres de prélecture doivent être réglés en fonction de scénarios d'application spécifiques et des conditions de charge du système. Un réglage correct de la prélecture peut améliorer les performances et la stabilité du système.

8.4 Échanges (commutateurs)

Échanges : répertorie tous les échanges, y compris le nom, le type, les files d'attente liées et la quantité liée.

8.5 Files d'attente (file d'attente)

Files d'attente (file d'attente) : affiche toutes les files d'attente, y compris des informations telles que le nom, le nombre de messages, le nombre de consommateurs, etc. Vous pouvez également effectuer certaines opérations via la file d'attente, telles que créer, supprimer, vider, etc.

8.6 Admin (administrateur)

Admin (administrateur) : Fournit certaines fonctions de gestion avancées, telles que la gestion des utilisateurs et des autorités, la gestion de l'hôte virtuel, la gestion des plug-ins, etc.