Quelltext der Seite RabbitMQ

= RabbitMQ =

'''RabbitMQ''' ist ein quelloffener Message Broker, der den Nachrichtenaustausch zwischen verteilten Systemkomponenten ermöglicht. Er implementiert das '''Advanced Message Queuing Protocol (AMQP)''' und dient als Vermittler, um Daten zuverlässig und asynchron zwischen Produzenten (Sendern) und Konsumenten (Empfängern) zu übertragen.

== Grundlagen ==
RabbitMQ arbeitet nach dem Prinzip der Nachrichtenvermittlung. Anwendungen kommunizieren nicht direkt miteinander, sondern tauschen Nachrichten über Queues (Warteschlangen) aus. Dadurch werden Systeme entkoppelt, was Skalierbarkeit, Fehlertoleranz und Lastverteilung verbessert.

== Architektur ==
Die Architektur von RabbitMQ basiert auf mehreren zentralen Komponenten:

* '''Producer''': Erzeugt und sendet Nachrichten an den Broker.
* '''Exchange''': Nimmt Nachrichten vom Producer entgegen und leitet sie anhand bestimmter Regeln (Bindings) an die entsprechenden Queues weiter.
* '''Queue''': Speicherung der Nachrichten, bis ein Consumer sie abruft.
* '''Binding''': Definiert, welche Nachrichten von einem Exchange in eine bestimmte Queue geleitet werden.
* '''Consumer''': Empfängt und verarbeitet Nachrichten aus einer Queue.

Die Kommunikation erfolgt typischerweise über das AMQP-Protokoll (Standardport: 5672).

== Exchange-Typen ==
RabbitMQ unterstützt verschiedene Typen von Exchanges, die bestimmen, wie Nachrichten verteilt werden:

* '''Direct Exchange''': Leitet Nachrichten an Queues weiter, die exakt den Routing-Key der Nachricht abonniert haben.
* '''Fanout Exchange''': Sendet jede Nachricht an alle verbundenen Queues (Broadcast).
* '''Topic Exchange''': Ermöglicht Nachrichtenrouting anhand von Mustervergleichen im Routing-Key (z. B. „log.*“).
* '''Headers Exchange''': Nutzt Header-Attribute der Nachricht zum Routing anstatt des Routing-Keys.

== Funktionsweise ==
1. Der Producer erstellt eine Nachricht und sendet sie an einen Exchange.  
2. Der Exchange prüft anhand der Bindings, in welche Queues die Nachricht gelegt wird.  
3. Der Consumer abonniert eine oder mehrere Queues und verarbeitet die empfangenen Nachrichten.  
4. Nach erfolgreicher Verarbeitung bestätigt der Consumer den Empfang (Acknowledgement).

== Zuverlässigkeit und Persistenz ==
RabbitMQ bietet verschiedene Mechanismen zur Sicherstellung der Nachrichtenintegrität:

* '''Durable Queues''': Bleiben nach einem Neustart des Brokers erhalten.  
* '''Persistent Messages''': Nachrichten werden auf die Festplatte geschrieben, um Datenverlust zu vermeiden.  
* '''Acknowledgements''': Nachrichten gelten erst als verarbeitet, wenn der Consumer sie explizit bestätigt hat.  
* '''Dead Letter Queues''': Speichern Nachrichten, die nicht erfolgreich zugestellt werden konnten.

== Management und Monitoring ==
RabbitMQ bietet ein webbasiertes Management-Interface, über das Administratoren:
* Queues, Exchanges und Bindings verwalten,  
* Statistiken zu Nachrichtenflüssen einsehen,  
* Verbindungen und Kanäle überwachen,  
* Benutzerrechte und Zugriffskontrolle konfigurieren können.

Das Management-Plugin ist standardmäßig über Port 15672 erreichbar.

== Cluster und Hochverfügbarkeit ==
RabbitMQ unterstützt Clustering und Spiegelung von Queues, um Hochverfügbarkeit zu gewährleisten:
* '''Cluster''': Mehrere RabbitMQ-Knoten arbeiten zusammen und teilen Metadaten.  
* '''Mirrored Queues (HA Queues)''': Nachrichten werden auf mehrere Knoten repliziert, um Ausfallsicherheit zu erhöhen.

== Sicherheit ==
RabbitMQ unterstützt mehrere Sicherheitsmechanismen:
* Authentifizierung (z. B. Benutzername/Passwort, LDAP, TLS-Zertifikate)
* Zugriffskontrollen (Virtual Hosts und Berechtigungen)
* Verschlüsselte Kommunikation (TLS/SSL)

== Verwendung und Integration ==
RabbitMQ wird in zahlreichen Programmiersprachen unterstützt, z. B.:
* Python (pika)
* Java (Spring AMQP)
* JavaScript (amqplib)
* PHP (php-amqplib)
* C# (.NET RabbitMQ Client)

Typische Anwendungsfälle:
* Asynchrone Aufgabenverarbeitung (z. B. Hintergrundjobs)
* Event-basierte Architekturen
* Microservices-Kommunikation
* Lastverteilung und Caching

== Beispiel ==
=== Python Producer ===
<syntaxhighlight lang="python">
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='test_queue')

channel.basic_publish(exchange='',
                      routing_key='test_queue',
                      body='Hallo RabbitMQ!')
print("Nachricht gesendet")
connection.close()
</syntaxhighlight>

=== Python Consumer ===
<syntaxhighlight lang="python">
import pika

def callback(ch, method, properties, body):
    print(f"Nachricht empfangen: {body}")

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='test_queue')

channel.basic_consume(queue='test_queue',
                      on_message_callback=callback,
                      auto_ack=True)

print('Warten auf Nachrichten...')
channel.start_consuming()
</syntaxhighlight>

== Vorteile ==
* Entkopplung von Komponenten  
* Hohe Zuverlässigkeit  
* Plattformunabhängigkeit  
* Umfangreiche Client-Bibliotheken  
* Skalierbar und erweiterbar  

== Nachteile ==
* Zusätzliche Komplexität durch Broker-Infrastruktur  
* Konfigurationsaufwand bei Clustern  
* Performance-Overhead bei Persistenz und Bestätigungen  

== Siehe auch ==
* [[AMQP]]
* [[Kafka]]
* [[Message Queue]]
* [[Microservices-Architektur]]

== Weblinks ==
* [https://www.rabbitmq.com Offizielle RabbitMQ-Webseite]
* [https://www.rabbitmq.com/tutorials.html Offizielle Tutorials]
* [https://www.rabbitmq.com/management.html RabbitMQ Management Plugin]