Advanced Message Queuing Protocol (AMQP)

Advanced Message Queuing Protocol (AMQP)

Das Advanced Message Queuing Protocol (AMQP) ist ein offener, standardisierter Netzwerkprotokollstandard für die Kommunikation zwischen Nachrichten-orientierten Systemen. Es definiert, wie Nachrichten zuverlässig, sicher und plattformunabhängig zwischen Sendern (Producern) und Empfängern (Consumern) ausgetauscht werden.

AMQP wird häufig in Messaging-Systemen wie RabbitMQ, Apache Qpid oder Azure Service Bus eingesetzt.

Überblick

AMQP wurde entwickelt, um eine zuverlässige, interoperable und transaktionsfähige Nachrichtenzustellung zwischen heterogenen Systemen zu ermöglichen. Es bietet Funktionen für:

• Sichere und geordnete Übertragung von Nachrichten
• Zuverlässige Zustellung (Delivery Guarantees)
• Routings, Queues und Exchanges
• Transaktionen und Bestätigungen (Acks/Nacks)
• Flow Control und Priorisierung

AMQP ist unabhängig von der Programmiersprache und Plattform, was es ideal für die Integration verteilter Systeme macht.

Geschichte

AMQP wurde ursprünglich 2003 von John O’Hara bei JPMorgan Chase initiiert, um die Kommunikation zwischen Finanzsystemen zu standardisieren. Seit 2012 ist es ein offizieller OASIS-Standard (Open Advanced Message Queuing Protocol Version 1.0).

Aktuelle Versionen:

• AMQP 0-9-1 – weit verbreitet, z. B. bei RabbitMQ
• AMQP 1.0 – offizielle Standardversion (OASIS), mit erweiterten Routing- und Transportfähigkeiten

Architektur und Komponenten

AMQP definiert die Struktur eines Message-Broker-Systems, das aus folgenden Hauptkomponenten besteht:

• Producer: Anwendung, die Nachrichten erstellt und an den Broker sendet.
• Exchange: Vermittelt Nachrichten basierend auf Routing-Regeln an Queues.
• Queue: Speicherort, an dem Nachrichten warten, bis sie von einem Consumer verarbeitet werden.
• Binding: Verknüpfung zwischen Exchange und Queue mit Routing-Kriterien.
• Consumer: Anwendung, die Nachrichten aus einer Queue empfängt und verarbeitet.

Die Kommunikation erfolgt über sogenannte Channels innerhalb einer TCP-Verbindung.

Funktionsweise

1. Producer sendet Nachricht an einen Exchange.
2. Exchange entscheidet anhand von Bindings, in welche Queues die Nachricht geleitet wird.
3. Consumer empfängt Nachricht aus der Queue.
4. Nach erfolgreicher Verarbeitung sendet der Consumer eine Acknowledge (Ack) an den Broker.

Grafische Darstellung

        +-------------------+
        |     Producer      |
        | (sendet Nachricht)|
        +---------+---------+
                  |
                  v
        +-------------------+
        |     Exchange      |
        | (Routing-Logik)   |
        +---------+---------+
                  |
     +------------+------------+
     |                         |
     v                         v
+------------+          +------------+
|   Queue A  |          |   Queue B  |
| (Speichert)|          | (Speichert)|
+-----+------+          +------+-----+
      |                        |
      v                        v
+-----------+          +-----------+
| Consumer 1|          | Consumer 2|
| (verarbeitet)|       | (verarbeitet)|
+-----------+          +-----------+

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

Exchange-Typen

AMQP unterstützt verschiedene Exchange-Typen, die das Routing von Nachrichten bestimmen:

• Direct Exchange: Nachrichten werden anhand eines exakten Routing-Keys an passende Queues gesendet.
• Fanout Exchange: Nachrichten werden an alle gebundenen Queues gesendet (Broadcast).
• Topic Exchange: Nachrichten werden anhand von Mustervergleichen im Routing-Key verteilt (z. B. „log.info“).
• Headers Exchange: Routing basiert auf Header-Attributen anstelle von Routing-Keys.

Zustellungsgarantien

AMQP bietet verschiedene Delivery Guarantees:

• At most once: Nachricht wird höchstens einmal zugestellt (keine Wiederholung bei Fehlern).
• At least once: Nachricht wird mindestens einmal zugestellt (Wiederholungen möglich).
• Exactly once: Nachricht wird exakt einmal zugestellt (Transaktionen notwendig).

Diese Optionen ermöglichen die Anpassung des Systems an Zuverlässigkeits- und Performanceanforderungen.

Nachrichtenaufbau

Eine AMQP-Nachricht besteht aus:

• Header: Enthält Metadaten (z. B. Priorität, Ablaufzeit, Routing-Informationen)
• Properties: Benutzerdefinierte Eigenschaften (z. B. Content-Type, Message-ID)
• Body: Nutzdaten (z. B. JSON, XML, Binärdaten)

Kommunikationsebene

AMQP nutzt typischerweise TCP als Transportprotokoll (Standardport: 5672). Für verschlüsselte Verbindungen wird AMQPS über TLS/SSL (Port 5671) verwendet.

Die Kommunikation ist zustandsbehaftet und unterstützt:

• Mehrere logische Channels pro Verbindung
• Heartbeats zur Verbindungskontrolle
• Flow-Control-Mechanismen zur Laststeuerung

Beispiel einer typischen AMQP-Nachrichtenübertragung

Producer --> Exchange --> Queue --> Consumer

Ein einfaches Routing könnte so aussehen:

Exchange type: direct
Routing key: "task_queue"
Queue name: "task_queue"

Beispiel in Python (pika)

Producer

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='task_queue')

channel.basic_publish(exchange='',
                      routing_key='task_queue',
                      body='Nachricht über AMQP')
print("Nachricht gesendet")
connection.close()

Consumer

import pika

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

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

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

print("Warten auf Nachrichten...")
channel.start_consuming()

Vorteile

• Plattform- und sprachunabhängig
• Zuverlässige Nachrichtenübermittlung
• Asynchrone Kommunikation und Entkopplung
• Unterstützung für Transaktionen und Priorisierung
• Hohe Interoperabilität zwischen verschiedenen Systemen

Nachteile

• Höherer Initialaufwand für Setup und Verständnis
• Komplexität bei Routing und Fehlerbehandlung
• Performance-Overhead durch Persistenz und Acknowledgements

Anwendungen

AMQP wird häufig eingesetzt in:

• Microservices-Architekturen
• Event-Driven Systems
• Enterprise Messaging
• IoT- und Cloud-Kommunikation
• Finanz- und Handelssystemen

Vergleich mit anderen Protokollen

Protokoll	Hauptmerkmal	Verwendung
AMQP	Standardisiertes, zuverlässiges Message-Queue-Protokoll	Enterprise Messaging, RabbitMQ
MQTT	Leichtgewichtiges Publish/Subscribe-Protokoll	IoT, Telemetrie
STOMP	Textbasiertes Protokoll für einfache Integration	WebSockets, einfache Broker
Kafka-Protokoll	Hochperformanter Datenstrom (Log-basiert)	Streaming, Big Data

Sicherheit

AMQP unterstützt verschiedene Sicherheitsmechanismen:

• TLS/SSL-Verschlüsselung
• Benutzerauthentifizierung (z. B. SASL, Username/Password)
• Zugriffskontrolllisten (ACLs)
• Virtuelle Hosts (vHosts) zur Trennung von Anwendungen

Implementierungen

Bekannte Broker-Implementierungen:

• RabbitMQ
• Apache Qpid
• ActiveMQ Artemis (AMQP 1.0)
• Azure Service Bus
• Red Hat AMQ

Client-Bibliotheken existieren für viele Sprachen:

• Python (pika)
• Java (Spring AMQP, Qpid JMS)
• C# (.NET RabbitMQ Client)
• JavaScript (amqplib)
• C++ (SimpleAmqpClient)

Siehe auch

• RabbitMQ
• Message Queue
• Microservices-Architektur
• Publish-Subscribe-Modell
• Remote Procedure Calls (RPC)

Weblinks

• Offizielle AMQP-Webseite
• OASIS AMQP Standardisierung
• RabbitMQ – AMQP Konzepte
• Apache Qpid Projektseite