Wie man RabbitMQ installiert, konfiguriert und verwendet

Message Broker sind Zwischenanwendungen, die in verschiedenen Softwarearchitekturen wie Microservices eingesetzt werden. Sie übertragen Informationen in Form von Nachrichten von einem Dienst zu einem anderen.

Ein häufiges Konzept im Zusammenhang mit Message Brokern ist das „Publisher-Subscriber“-Muster, bei dem Ereignisse von sogenannten „Publishers“ (Produzenten) an „Subscribers“ (Konsumenten) gesendet werden.

Normalerweise nimmt eine Zwischenkomponente – ein Message Broker – an der Implementierung dieses Musters teil.

Zur Vereinfachung verwenden wir eine Analogie: Denken Sie an YouTube – es gibt Kanäle, die Sie abonnieren können, um Benachrichtigungen zu erhalten. Wenn ein neues Video veröffentlicht wird (ein Ereignis), werden Sie benachrichtigt, weil Sie den Kanal abonniert haben.

Wie Anwendungen mit Message Brokern arbeiten

Drei Hauptbegriffe sind hier relevant: Exchange, Queue und Binding.

• Exchange. Hierhin werden Nachrichtenereignisse gesendet. Die Exchange entscheidet anhand der Verbindungen – den sogenannten Bindings –, welche Ereignisse an welche Queue gehen. Auf diese Bindings gehen wir gleich noch ein.

• Queue. Die Queue ist eine Datenstruktur, die nach dem FIFO-Prinzip („First In, First Out“) arbeitet. Sie speichert Daten auf der Festplatte oder im Arbeitsspeicher und stellt die eigentlichen Nachrichten dar. Die Queue stellt den Konsumenten Kopien dieser Nachrichten bereit.

• Binding. Binding bezieht sich auf die Menge von Regeln, die der Exchange mitteilen, an welche Queues Nachrichten weitergeleitet werden sollen. Zwischen einer Exchange und einer Queue können mehrere Bindings mit unterschiedlichen Parametern existieren.

Weitere wichtige Begriffe sind:

• Producer ist ein Dienst, der Nachrichten generiert und an den Broker sendet.
• Consumer ist ein anderer Dienst, der mit der Verarbeitung beginnt, sobald er eine Nachricht erhält. In unserer YouTube-Analogie ist der „Publisher“ YouTube selbst, und der „Consumer“ ist Ihr Smartphone, das Push-Benachrichtigungen empfängt.

Hier ist eine Schritt-für-Schritt-Erklärung, wie der Prozess funktioniert:

1. Der Producer sendet eine Nachricht, die an die Exchange weitergeleitet wird.

2. Die Queue speichert diese Nachricht, beispielsweise auf der Festplatte.

3. Wenn ein Consumer bereit ist, eine Nachricht zu empfangen (entweder weil die vorherige Verarbeitung abgeschlossen ist oder die Ereignisanwendung gestartet wurde), sendet der Server eine Kopie der Daten aus der Queue an den Consumer.

4. Der Consumer empfängt die Nachricht, verarbeitet sie und sendet anschließend eine Bestätigung (ACK) zurück an den Broker.

5. Nachdem der Broker die Bestätigung erhalten hat, wird die Nachricht gelöscht.

Was ist RabbitMQ?

RabbitMQ ist ein beliebter Open-Source-Message-Broker, der auf dem AMQP (Advanced Message Queuing Protocol) basiert – einem offenen Protokoll zur Übertragung von Ereignisnachrichten über einen dedizierten Broker. AMQP bietet eine Vielzahl von Funktionen und wird neben RabbitMQ auch von anderen Systemen wie Apache Qpid implementiert.

RabbitMQ ist in der Programmiersprache Erlang geschrieben. Zu seinen Hauptvorteilen zählen die hohe Verarbeitungsgeschwindigkeit (Throughput) und maximale Flexibilität bei der Nachrichtenweiterleitung (Routing). RabbitMQ bietet zahlreiche Konfigurationsoptionen, um Regeln festzulegen, welche Nachrichten wohin zur Verarbeitung gesendet werden.

Verbindungen zu RabbitMQ werden über das TCP-Protokoll hergestellt: Der Client initiiert eine Verbindung zur Hostadresse und hält diese Verbindung so lange offen, wie die Interaktion mit RabbitMQ erforderlich ist. RabbitMQ unterstützt zudem Authentifizierung, z. B. über Benutzername und Passwort, um sicheren Zugriff zu gewährleisten.

Installation auf verschiedenen Betriebssystemen

RabbitMQ besteht aus dem Server und der WebUI (Administrationsoberfläche). Die WebUI ermöglicht es, den Zustand des Brokers zu überwachen – beispielsweise zu prüfen, ob die Knoten im Cluster aktiv sind, wie viele Nachrichten verarbeitet werden und mehr. Sehen wir uns an, wie man RabbitMQ auf verschiedenen Betriebssystemen installiert.

Bevor wir beginnen, müssen wir den Server-Hostnamen aktualisieren. Führen Sie den folgenden Befehl aus:

sudo hostnamectl set-hostname <neuer Hostname>

Zum Beispiel verwenden wir rabbitmq als Hostnamen für diesen Server.

sudo hostnamectl set-hostname rabbitmq

Installieren Sie nano:

sudo apt install nano

Und fügen Sie Ihren neuen Hostnamen in die Datei /etc/hosts ein:

sudo nano /etc/hosts

Damit sie folgendermaßen aussieht:

127.0.0.1 <neuer Hostname>

In unserem Beispiel:

127.0.0.1 rabbitmq

Ubuntu / Debian

Wir werden RabbitMQ auf Ubuntu 22.04 installieren. Für andere Ubuntu-/Debian-Distributionen finden Sie die Anleitung auf der offiziellen Website.

1. Aktualisieren Sie die Paketliste und installieren Sie die Abhängigkeiten:

sudo apt-get update -y
sudo apt-get install curl gnupg -y
sudo apt-get install apt-transport-https

2. Fügen Sie die Repository-Signaturschlüssel hinzu:

curl -1sLf "https://keys.openpgp.org/vks/v1/by-fingerprint/0A9AF2115F4687BD29803A206B73A36E6026DFCA" | sudo gpg --dearmor | sudo tee /usr/share/keyrings/com.rabbitmq.team.gpg > /dev/null
curl -1sLf https://github.com/rabbitmq/signing-keys/releases/download/3.0/cloudsmith.rabbitmq-erlang.E495BB49CC4BBE5B.key | sudo gpg --dearmor | sudo tee /usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg > /dev/null
curl -1sLf https://github.com/rabbitmq/signing-keys/releases/download/3.0/cloudsmith.rabbitmq-server.9F4587F226208342.key | sudo gpg --dearmor | sudo tee /usr/share/keyrings/rabbitmq.9F4587F226208342.gpg > /dev/null

3. Erstellen Sie eine Repository-Datei (Apt Source List):

sudo tee /etc/apt/sources.list.d/rabbitmq.list <<EOF
deb [arch=amd64 signed-by=/usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg] https://ppa1.rabbitmq.com/rabbitmq/rabbitmq-erlang/deb/ubuntu jammy main
deb-src [signed-by=/usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg] https://ppa1.rabbitmq.com/rabbitmq/rabbitmq-erlang/deb/ubuntu jammy main
deb [arch=amd64 signed-by=/usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg] https://ppa2.rabbitmq.com/rabbitmq/rabbitmq-erlang/deb/ubuntu jammy main
deb-src [signed-by=/usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg] https://ppa2.rabbitmq.com/rabbitmq/rabbitmq-erlang/deb/ubuntu jammy main
deb [arch=amd64 signed-by=/usr/share/keyrings/rabbitmq.9F4587F226208342.gpg] https://ppa1.rabbitmq.com/rabbitmq/rabbitmq-server/deb/ubuntu jammy main
deb-src [signed-by=/usr/share/keyrings/rabbitmq.9F4587F226208342.gpg] https://ppa1.rabbitmq.com/rabbitmq/rabbitmq-server/deb/ubuntu jammy main
deb [arch=amd64 signed-by=/usr/share/keyrings/rabbitmq.9F4587F226208342.gpg] https://ppa2.rabbitmq.com/rabbitmq/rabbitmq-server/deb/ubuntu jammy main
deb-src [signed-by=/usr/share/keyrings/rabbitmq.9F4587F226208342.gpg] https://ppa2.rabbitmq.com/rabbitmq/rabbitmq-server/deb/ubuntu jammy main
EOF

4. Aktualisieren Sie die Paketliste erneut:

sudo apt-get update -y

5. Installieren Sie Erlang:

sudo apt-get install -y erlang-base \
                       erlang-asn1 erlang-crypto erlang-eldap erlang-ftp erlang-inets \
                       erlang-mnesia erlang-os-mon erlang-parsetools erlang-public-key \
                       erlang-runtime-tools erlang-snmp erlang-ssl \
                       erlang-syntax-tools erlang-tftp erlang-tools erlang-xmerl

6. Installieren Sie schließlich RabbitMQ:

sudo apt-get install rabbitmq-server -y --fix-missing

Nach der Installation können Sie überprüfen, ob der RabbitMQ-Server läuft:

systemctl status rabbitmq-server

Erstellen Sie einen eigenen Benutzer:

sudo rabbitmqctl add_user <Ihr Benutzername> <Ihr Passwort>

Vergeben Sie die erforderlichen Berechtigungen:

sudo rabbitmqctl set_user_tags  <Ihr Benutzername> administrator
sudo rabbitmqctl set_permissions -p /  <Ihr Benutzername> ".*" ".*" ".*"

Aktivieren Sie nun die RabbitMQ Management Console:

sudo rabbitmq-plugins enable rabbitmq_management

Und besuchen Sie [Ihre Server-IP]:15672. Geben Sie Ihren Benutzernamen und Ihr Passwort ein, um auf die RabbitMQ-Weboberfläche zuzugreifen.

Windows

Die Installationsanleitung finden Sie auf der RabbitMQ-Website. Grundsätzlich können Sie entweder Chocolatey oder den klassischen Installer verwenden.

Bevor RabbitMQ installiert wird, muss zunächst Erlang/OTP von der offiziellen Erlang-Website installiert werden.

Führen Sie die heruntergeladene Datei aus und folgen Sie dem Installationsprozess.

Nachdem Erlang installiert wurde, können Sie RabbitMQ installieren, beispielsweise mit dem Installer von der offiziellen Website.

Aktivieren Sie anschließend die WebUI:

cd 'C:\Program Files\RabbitMQ Server\rabbitmq_server-3.13.0\sbin'
./rabbitmq-plugins.bat enable rabbitmq_management

Nun können Sie localhost:15672 aufrufen und über den Standardbenutzernamen und das Standardpasswort guest:guest auf die RabbitMQ-Weboberfläche zugreifen.

Docker

Die Installation über Docker ist wahrscheinlich die einfachste und bequemste Methode, RabbitMQ zu installieren.

Wir können RabbitMQ mit dem folgenden docker run-Befehl installieren:

docker run --rm -p 15672:15672 rabbitmq:3.13.7-management

Die Admin-Oberfläche ist anschließend auf Port 15672 verfügbar, wo Sie sich mit dem Standardbenutzernamen und -passwort guest:guest anmelden können.

Diese Methode ist jedoch nicht für Produktionsumgebungen geeignet. Docker weist dem Container einen Servernamen zu, und der Message Broker speichert seinen Zustand in einem Ordner mit diesem Namen. Bei jedem neuen Container-Build verliert RabbitMQ diese Zustandsinformationen.

Mit docker-compose können wir alle erforderlichen Dienstparameter bequem definieren, z. B. das Ändern des Standard-Logins und -Passworts oder das Einhängen eines Ordners zur Zustandsbeibehaltung. Hier ist ein Beispiel, wie die Datei docker-compose.yml aussehen könnte (sie kann auf Ihrem Server, auf dem Docker installiert ist, oder auf Ihrer lokalen Maschine erstellt werden):

version: "3.3"
services:
  rabbit:
    image: rabbitmq:3.13.7-management
    environment:
      - RABBITMQ_DEFAULT_USER=admin #enter your username
      - RABBITMQ_DEFAULT_PASS=password #enter your password
    volumes:
      - ./rabbit:/var/lib/rabbitmq # mounting folder for state persistence
    ports:
      - 15672:15672 # expose port for the admin interface

Führen Sie aus:

docker compose up -d

Die RabbitMQ-Weboberfläche ist nun verfügbar.

Überblick über RabbitMQ Management

Sehen wir uns nun die wichtigsten Funktionen der RabbitMQ-Management-Oberfläche an. Auf der Hauptseite können Sie allgemeine Informationen wie Knoten, deren Status, die Gesamtanzahl der Nachrichten und vieles mehr einsehen.

• Connections ist die Liste der Verbindungen zum Cluster.

• Channels ist die Liste der Kanäle. Innerhalb einer einzelnen Verbindung können mehrere Kanäle erstellt werden, über die Nachrichten gesendet werden. Dies wird getan, um die Erstellung mehrerer TCP-Verbindungen zu vermeiden.

Exchanges

Werfen wir einen genaueren Blick auf die Exchanges.

Es gibt verschiedene Arten von Exchanges, jede mit ihrem eigenen Nachrichtenfiltermechanismus. Auf der Grundlage dieser Regeln werden Ereignisse an bestimmte Queues weitergeleitet.

Direct Exchange

Jede Nachricht hat einen Schlüssel, der Routing Key genannt wird. Diese Nachrichten werden an Queues weitergeleitet, bei denen das Binding zur Exchange denselben Schlüssel angibt.

Topic Exchange

Das Routing erfolgt auf Basis eines Musterschlüssels. Beim Erstellen des Musters können Sie 0 oder mehr Wörter (lateinische Buchstaben in verschiedenen Schreibweisen und Zahlen) verwenden, die durch Punkte getrennt sind (z. B. „key.event“) sowie die Symbole # und *.

Fanout Exchange

Hier werden keine Filterregeln angewendet. Jede Nachricht, die an eine Fanout Exchange gesendet wird, wird an alle Queues weitergeleitet.

Headers Exchange

Verwendet Nachrichten-Header und Binding-Header und vergleicht Schlüssel-Wert-Paare in diesen Headern.

Queues

Wenn Sie eine bestimmte Queue anzeigen, sehen Sie ein Diagramm, das zeigt, wie viele Nachrichten sich in der Queue befinden, sowie Statistiken über Lieferzeiten und Annahmezeiten von Nachrichten.

Nachrichten können zwei Status haben:

• Ready – wartet auf Verarbeitung.
• Unacked – wird gerade vom Consumer verarbeitet.

Publisher-Subscriber in Python implementieren

Sehen wir uns an, wie man RabbitMQ verwendet, um das Pub-Sub-Muster in Python zu implementieren. Auf Ihrem System sollte Python installiert sein. In diesem Tutorial wird Version 3.11.5 verwendet. Wir nutzen die Pika-Bibliothek.

1. Erstellen oder wählen Sie einen Ordner, in dem sich der Anwendungscode befindet. Zum Beispiel:

mkdir rabbitmq-article

2. Öffnen Sie diesen Ordner in Ihrer IDE. Das kann Visual Studio Code, PyCharm oder eine andere Entwicklungsumgebung sein.

3. Installieren Sie die Pika-Bibliothek, indem Sie im Terminal den folgenden Befehl ausführen:

pip install pika

4. Nun erstellen wir zwei Dateien: sender.py und receiver.py.

sender.py code

from pika import BlockingConnection, ConnectionParameters
from pika.exchange_type import ExchangeType

# Verbindung erstellen, Parameter im ConnectionParameters-Objekt angeben
connection = BlockingConnection(ConnectionParameters(host='localhost'))

# Kanal erstellen
channel = connection.channel()

# Exchange deklarieren
channel.exchange_declare('new_exchange', ExchangeType.direct)

# Queue deklarieren
queue = channel.queue_declare(queue='new_queue')

# Queue mit der Exchange verbinden (Binding)
channel.queue_bind(exchange='new_exchange', queue='new_queue', routing_key='key')

# Nachricht veröffentlichen
channel.basic_publish(exchange='new_exchange', routing_key='key', body='Hello World!')

print("Message 'Hello World!' sent")
connection.close()

In dem oben gezeigten sender.py-Code:

• Wir stellen eine Verbindung zu RabbitMQ auf localhost her.

• Wir deklarieren eine Direct Exchange namens new_exchange.

• Wir deklarieren eine Queue namens new_queue.

• Wir binden die Queue mit dem Routing Key key an die Exchange.

• Schließlich veröffentlichen wir die Nachricht 'Hello World!' auf der Exchange mit dem angegebenen Routing Key.

Als Nächstes implementieren wir receiver.py, um die Nachricht zu konsumieren.

receiver.py code

from pika import BlockingConnection, ConnectionParameters
from pika.exchange_type import ExchangeType
import sys, os

def main():
    # Verbindung erstellen
    connection = BlockingConnection(ConnectionParameters(host='localhost'))
    # Kanal erstellen
    channel = connection.channel()

    # Exchange deklarieren
    channel.exchange_declare('new_exchange', ExchangeType.direct)

    # Queue deklarieren
    queue = channel.queue_declare(queue='new_queue')

    # Queue mit der Exchange verbinden (Binding)
    channel.queue_bind(exchange='new_exchange', queue='new_queue', routing_key='key')

    # Funktion zur Verarbeitung eingehender Nachrichten
    def handle(ch, method, properties, body):
        print(f"Received message: {body.decode()}")

    # Callback-Funktion und Queue verknüpfen
    channel.basic_consume(queue='new_queue', on_message_callback=handle, auto_ack=True)

    print('Waiting for messages. Press Ctrl+C to exit.')
    channel.start_consuming()

if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        try:
            sys.exit(0)
        except SystemExit:
            os._exit(0)

Im oben gezeigten receiver.py-Code:

• Wir erstellen wie beim Sender eine Verbindung und einen Kanal zu RabbitMQ.

• Wir deklarieren die Direct Exchange (new_exchange) und die Queue (new_queue).

• Die Queue wird mit dem Routing Key key an die Exchange gebunden.

• Die Funktion handle verarbeitet die Nachricht, indem sie sie beim Empfang ausgibt.

• basic_consume abonniert die Callback-Funktion für die Queue.

• Mit start_consuming bleibt der Prozess unbegrenzt auf eingehende Nachrichten wartend.

Code ausführen

Starten Sie zuerst den Empfänger. Öffnen Sie ein Terminal und führen Sie receiver.py aus:

python receiver.py

Sie sollten die Ausgabe sehen:

Waiting for messages. Press Ctrl+C to exit.

Starten Sie nun den Sender. Öffnen Sie ein zweites Terminal und führen Sie sender.py aus:

python sender.py

Sie sollten die Ausgabe sehen:

Message 'Hello World!' sent

Im Terminal, in dem der Empfänger läuft, sehen Sie anschließend:

Received message: Hello World!

In RabbitMQ Management können Sie zur erstellten Exchange (new_exchange) wechseln und sehen, dass sie mit der Queue (new_queue) über den Routing Key (key) verbunden ist.

Fazit

In diesem Artikel haben wir erläutert, was Message Broker sind, wie Anwendungen mit ihnen interagieren und wie man RabbitMQ als Message Broker installiert und verwendet. Wir haben das Publisher-Subscriber-Muster erfolgreich mit Python, RabbitMQ und der Pika-Bibliothek implementiert, wobei der Sender Nachrichten an eine Exchange veröffentlicht und der Empfänger sie konsumiert.