RabbitMQ - Versionsgeschichte

PhilKa: /* Funktionsweise */

2025-11-04T13:16:30Z

Funktionsweise

← Nächstältere Version		Version vom 4. November 2025, 15:16 Uhr
Zeile 26:		Zeile 26:

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

	<~~code~~>		RabbitMQ arbeitet nach dem Prinzip des asynchronen Nachrichtenaustauschs zwischen Produzenten und Konsumenten.
			Nachrichten werden dabei über sogenannte ''Exchanges'' an ''Queues'' verteilt, aus denen die ''Consumer'' sie abrufen und verarbeiten.

			=== Ablauf ===
			# Der '''Producer''' sendet eine Nachricht an einen '''Exchange'''.
			# Der '''Exchange''' entscheidet anhand von '''Bindings''' und '''Routing Keys''', in welche '''Queues''' die Nachricht geleitet wird.
			# Ein oder mehrere '''Consumer''' lesen die Nachrichten aus den Queues und verarbeiten sie.
			# Nach erfolgreicher Verarbeitung sendet der Consumer eine '''Bestätigung (Ack)''' an RabbitMQ, um die Zustellung zu bestätigen.

			=== Grafische Darstellung ===
			<pre>
	+-------------------+		+-------------------+
	\| Producer \|		\| Producer \|
Zeile 56:		Zeile 62:
	\| (verarbeitet)\| \| (verarbeitet)\|		\| (verarbeitet)\| \| (verarbeitet)\|
	+-----------+ +-----------+		+-----------+ +-----------+
	</~~code~~>		</pre>

			Diese Architektur ermöglicht eine zuverlässige, skalierbare und lose gekoppelte Kommunikation zwischen unabhängigen Systemkomponenten.

	== Zuverlässigkeit und Persistenz ==		== Zuverlässigkeit und Persistenz ==

PhilKa: /* Funktionsweise */

2025-11-04T13:14:06Z

Funktionsweise

@@ Zeile 30: / Zeile 30: @@
 # Der Consumer abonniert eine oder mehrere Queues und verarbeitet die empfangenen Nachrichten.
 # Nach erfolgreicher Verarbeitung bestätigt der Consumer den Empfang (Acknowledgement).
 == Zuverlässigkeit und Persistenz ==

PhilKa: /* Funktionsweise */

2025-11-04T13:09:57Z

Funktionsweise

← Nächstältere Version		Version vom 4. November 2025, 15:09 Uhr
Zeile 26:		Zeile 26:

	== Funktionsweise ==		== Funktionsweise ==
	1. Der Producer erstellt eine Nachricht und sendet sie an einen Exchange.		# 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.		# 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.		# Der Consumer abonniert eine oder mehrere Queues und verarbeitet die empfangenen Nachrichten.
	4. Nach erfolgreicher Verarbeitung bestätigt der Consumer den Empfang (Acknowledgement).		# Nach erfolgreicher Verarbeitung bestätigt der Consumer den Empfang (Acknowledgement).

	== Zuverlässigkeit und Persistenz ==		== Zuverlässigkeit und Persistenz ==

PhilKa: Die Seite wurde neu angelegt: „= 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…“

2025-11-04T12:09:54Z

Die Seite wurde neu angelegt: „= 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…“

Neue Seite

= 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]