---
title: Wie man RabbitMQ als Message Queue für TYPO3 mit DDEV einrichtet
url: "https://b13.com/de/wissen/bessere-skalierbarkeit-mit-entkoppelten-queues-so-richtest-du-rabbitmq-mit-typo3-ein"
description: Wenn integrierte Nachrichtentransporte an ihre Grenzen stoßen, kann RabbitMQ TYPO3 mit einer skalierbaren, robusten Message Queue versorgen.
image: "https://b13.com/fileadmin/_processed_/7/3/csm_QueuesDDEV_Sharing_ca74d06702.png"
date: 2024-03-27
modified: 2026-08-19
lastUpdated: 2026-08-19
---
# Wie man RabbitMQ als Message Queue für TYPO3 mit DDEV einrichtet
[ DDEV ](https://b13.com/de/wissen/ddev) [ TYPO3 ](https://b13.com/de/wissen/typo3)
Bessere Skalierbarkeit mit entkoppelten Queues: So richtest du RabbitMQ mit TYPO3 ein
=======================================================================================
Jochen Roth
10. April 2024 | Aktualisiert 04. Mai 2026
[ RSS Feed ](https://b13.com/de/rss.xml)
TYPO3 [v12](https://typo3.org/article/typo3-v12-lts-here-to-save-the-day) unterstützt [Symfony Messenger](https://symfony.com/doc/current/messenger.html), einen flexiblen Message Bus mit der Möglichkeit, Nachrichten innerhalb der Anwendung zur sofortigen Bearbeitung oder über externe Message Transport Services zur asynchronen Bearbeitung zu senden.
In diesem Artikel werden die Schritte zum Hinzufügen eines externen Transports, [RabbitMQ](https://www.rabbitmq.com/), zu einer TYPO3-Instanz erläutert.
Externe Messaging-Dienste verstehen
-------------------------------------
[Symfony Messenger](https://symfony.com/doc/current/messenger.html) unterstützt eine Reihe von verschiedenen Transporttypen, darunter:
- In-Memory
- Doctrine
- Redis
- AMQP
- und andere.
In der Regel wirst du mit den einfachsten Optionen beginnen wollen. Der In-Memory-Transport ist vielleicht die einfachste Variante, wird aber hauptsächlich zu Testzwecken verwendet.
Der Doctrine-Transport verwendet die vorhandene Datenbank zum Speichern von Nachrichten. Er ist oft die erste Wahl, weil er einfach einzurichten ist und keine externen Abhängigkeiten erfordert.
Doctrine sollte jedoch nicht Ihre endgültige Lösung sein, da die Verwendung einer Datenbank als Nachrichtenwarteschlange nicht gut skalierbar ist. Irgendwann wirst du ein externes Message-Queue-System wie RabbitMQ oder Redis verwenden wollen — Vermittler, die deinen Anwendungen, Microservices und Softwarekomponenten eine gemeinsame Plattform zum Austausch von Nachrichten bieten.
In diesem Artikel konzentrieren wir uns auf [RabbitMQ](https://www.rabbitmq.com/), einen sehr beliebten und ausgereiften Open-Source Messaging Broker.
Abgesehen von dem in TYPO3 integrierten Doctrine-Transport hat ein System wie RabbitMQ mehrere Vorteile:
- **Es ist gut skalierbar**. RabbitMQ kann eine große Anzahl von Nachrichtenanbietern und -verbrauchern bedienen. Anwendungen können miteinander verbunden werden, als Komponenten einer größeren Anwendung, oder mit Benutzergeräten und Daten. Die Arbeitslast kann auf mehrere Prozesse verteilt werden.
- **Unterstützung für verteilte Systeme.** RabbitMQ kann Nachrichten-Broker auf mehreren Knoten ausführen, um die Arbeitslast auf ein Netzwerk von Diensten zu verteilen und Nachrichten zwischen Produzenten und Konsumenten weiterzuleiten.
- **Fehlertoleranz durch Design.** Nachrichten werden in einer Warteschlange gespeichert, bis sie verbraucht werden. Die Warteschlange kann Lastspitzen auffangen und Nachrichten speichern, falls ein oder mehrere Verbraucher vorübergehend nicht verfügbar sind.
Diese Vorteile machen es lohnenswert, die Zeit zu investieren, um einen externen Nachrichtentransport für TYPO3 einzurichten. Wenn du RabbitMQ ausprobieren willst, lies weiter, um zu sehen, wie man ein DDEV-basiertes Nachrichtenwarteschlangen-Projekt erstellt.
Einrichten von RabbitMQ in TYPO3 mit DDEV
-------------------------------------------
Beginnen wir mit einem leeren Blatt Papier. Für diese Übung verwenden wir [Docker](https://www.docker.com/) und [DDEV](https://ddev.com/) sowie das [GitLab TYPO3-Site-Paket](https://gitlab.com/gitlab-org/project-templates/typo3-distribution), du benötigst also ein GitLab-Konto. Das GitLab TYPO3-Site-Paket ist eine Projektvorlage für die Erstellung eines [Site-Pakets](https://docs.typo3.org/m/typo3/tutorial-sitepackage/12.4/en-us/Index.html#start) auf der Grundlage einer sauberen TYPO3-Installation.
### Docker und DDEV installieren
DDEV verwaltet containerisierte PHP-Entwicklungsumgebungen und ermöglicht es Ihnen, ein Projekt in Sekundenschnelle einzurichten.
Folge den [DDEV-Installationsanweisungen](https://ddev.com/get-started/), um sowohl Docker als auch DDEV zu installieren.
Für die Einrichtung siehe auch die [Dokumentation zu DDEV.](https://ddev.readthedocs.io/en/stable/users/extend/customizing-images/#adding-extra-debian-packages-with-web[…]a_packages-and-dbimage_extra_packages)
### Einrichten einer TYPO3-Site
Mit der TYPO3-Distributionsvorlage in GitLab kannst du auf einfache Weise eine TYPO3-Site einschließlich eines leeren Site-Pakets einrichten.
1\. Anmelden bei GitLab
2\. Klicke in der oberen linken Ecke auf das Pluszeichen + und wählen Sie **New project/Repository**.
3\. Wähle „**Create from template**„.
4\. Blätter in der Liste der Vorlagen nach unten zu „TYPO3 Distribution“ und klicke auf „**Use template**„.
5\. Gib im Vorlagenformular den Namen „TYPO3 and RabbitMQ“ ein. Wähle eine Gruppe oder einen Namespace und klicke dann auf „**Create project**„.
6\. Wenn das Projekt erstellt ist, öffne eine lokale Shell auf Ihrem System und klone das Repository in einen lokalen Ordner.
7\. Wechsel in das Verzeichnis des Projekts und initialisiere TYPO3.
```
1
2
3
```
```
cd typo3-and-rabbitmq
ddev typo3-init
```
Mit diesem Befehl wird das anfängliche Projekt erstellt und Docker-Container mit einem Webserver und einer Datenbank darin gestartet.
Nach Beendigung des Befehls werden die Anmeldedaten in das Terminal ausgegeben und die Anmeldeseite im Browser geöffnet.
8\. Melde dich an, um zu testen, ob TYPO3 einwandfrei läuft. Wenn sich die Anmeldeseite nicht automatisch öffnet, öffne sie unter dem Pfad /TYPO3. Basierend auf den GitLab-Details aus Schritt 5 lautet die Login-URL „https://typo3-and-rabbitmq.ddev.site/typo3“.
### RabbitMQ installieren
Jetzt kannst du RabbitMQ über DDEV installieren.
1\. Führe in der Shell folgenden Befehl aus:
```
1
```
```
ddev get b13/ddev-rabbitmq
```
2\. Füge diese Zeilen zu deinem **.ddev/config.yaml** hinzu:
```
1
```
```
webimage_extra_packages: ["php${DDEV_PHP_VERSION}-amqp"]
```
AMQP ist das Nachrichtenprotokoll, das RabbitMQ verwendet. Das Paket webimage\_extra\_packages stellt sicher, dass das Paket amqp installiert ist.
3\. Starte nun deine Container neu, um die Änderung zu übernehmen:
```
1
```
```
ddev restart
```
Dies kann ein paar Sekunden dauern.
4\. Führe ddev describe aus, um zu sehen, ob RabbitMQ installiert ist. Der Befehl zeigt die URL des RabbitMQ-Dienstes an.
AMQP-Unterstützung für den Symfony Messenger installieren
Da RabbitMQ das AMPQ-Protokoll verwendet, werden wir nun AMQP für den Symfony Messenger einrichten.
1\. Installiere das Paket symfony/messenger:
```
1
```
```
ddev composer req symfony/amqp-messenger:^6.4
```
2\. TYPO3 muss wissen, wie man mit dem RabbitMQ-Dienst kommuniziert. Um dies zu erreichen, bearbeite die Datei in **packages/site-distribution/Configuration/Services.yaml** wie folgt (achte darauf, dass du die Einrückung beibehältst):
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
```
```
services:
_defaults:
autowire: true
autoconfigure: true
public: true
Site\Distribution\:
resource: "../Classes/*"
exclude: "../Classes/Domain/Model/*"
Site\Distribution\Queue\Handler\MyHandler:
tags:
- name: "messenger.message_handler"
Site\Distribution\Queue\Message\MyMessage:
arguments:
$content: 'Default content'
# RabbitMQ
Symfony\Component\Messenger\Bridge\Amqp\Transport\AmqpTransportFactory:
public: true
Symfony\Component\Messenger\Bridge\Amqp\Transport\AmqpTransport:
factory:
[
'@Symfony\Component\Messenger\Bridge\Amqp\Transport\AmqpTransportFactory',
"createTransport",
]
arguments:
$dsn: "amqp://rabbitmq:rabbitmq@rabbitmq:5672/
$options: {}
tags:
- name: "messenger.sender"
identifier: "amqp"
- name: "messenger.receiver"
identifier: "amqp"
```
Beachte das Argument $dsn, das die Verbindungszeichenfolge enthält. Beim Einsatz in der Produktion musst du die Parameter entsprechend anpassen. Dies ist die kanonische Form des AMQP-DSN:
```
1
```
```
amqp://<username>:<password>@rabbitmq:5672/<virtual host>/<queue name>
```
### Erstellen einer Nachrichtenklasse
Um eine Nachricht zu versenden und zu verarbeiten, benötigt man eine Nachrichtenklasse. Eine sehr einfache Version einer Nachrichtenklasse ist die folgende, die du in Classes/Queue/Message/MyMessage.php erstellen kannst:
```
1
2
3
4
5
6
7
8
9
10
11
12
13
```
```
declare(strict_types=1);
namespace Site\Distribution\Queue\Message;
final class MyMessage
{
public function __construct(
public readonly string $content
) {
}
}
```
3\. Die Klasse MyMessage muss für den asynchronen Transport über AMQP konfiguriert werden. Bearbeite die Datei **packages/site-distribution/ext\_localconf.php** entsprechend:
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
```
```
declare(strict_types=1);
use Site\Distribution\Queue\Message\MyMessage;
use TYPO3\CMS\Core\Messaging\WebhookMessageInterface;
defined('TYPO3') or die();
$GLOBALS['TYPO3_CONF_VARS']['EXTENSIONS']['vite_asset_collector']['defaultManifest'] = 'EXT:site-distribution/Resources/Public/Vite/.vite/manifest.json';
$GLOBALS['TYPO3_CONF_VARS']['RTE']['Presets']['default'] = 'EXT:site-distribution/Configuration/RTE/RteDefaultPreset.yaml';
unset($GLOBALS['TYPO3_CONF_VARS']['SYS']['messenger']['routing']['*']);
foreach ([WebhookMessageInterface::class, MyMessage::class] as $className) {
$GLOBALS['TYPO3_CONF_VARS']['SYS']['messenger']['routing'][$className] = 'amqp';
}
$GLOBALS['TYPO3_CONF_VARS']['SYS']['messenger']['config']['amqp'] = [
'dsn' => 'amqp://rabbitmq:rabbitmq@rabbitmq:5672/%2f/messages',
];
```
### Einrichten einer Message-Handler-Klasse
Ein Message-Handler empfängt und verarbeitet Nachrichten vom RabbitMQ-Broker. Er wendet sich nicht aktiv an den Broker, sondern verlässt sich auf einen Consumer-Prozess, der jede Nachricht liest und sie an den Message-Handler weitergibt.
Hier ist eine einfache Version eines Message-Handlers, die Sie in **packages/site-distribution/Classes/Queue/Handler/MyHandler.php** erstellen können:
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
```
```
declare(strict_types=1);
use Site\Distribution\Queue\Message\MyMessage;
use TYPO3\CMS\Core\Messaging\WebhookMessageInterface;
defined('TYPO3') or die();
$GLOBALS['TYPO3_CONF_VARS']['EXTENSIONS']['vite_asset_collector']['defaultManifest'] = 'EXT:site-distribution/Resources/Public/Vite/.vite/manifest.json';
$GLOBALS['TYPO3_CONF_VARS']['RTE']['Presets']['default'] = 'EXT:site-distribution/Configuration/RTE/RteDefaultPreset.yaml';
unset($GLOBALS['TYPO3_CONF_VARS']['SYS']['messenger']['routing']['*']);
foreach ([WebhookMessageInterface::class, MyMessage::class] as $className) {
$GLOBALS['TYPO3_CONF_VARS']['SYS']['messenger']['routing'][$className] = 'amqp';
}
$GLOBALS['TYPO3_CONF_VARS']['SYS']['messenger']['config']['amqp'] = [
'dsn' => 'amqp://rabbitmq:rabbitmq@rabbitmq:5672/%2f/messages',
];
```
Teste die Message Queue
Nun ist es an der Zeit, die Queue zu testen. Eine einfache Möglichkeit, Nachrichten in die Warteschlange einzuspeisen, besteht darin, eine Middleware einzurichten, die bei jedem Laden einer Seite ausgelöst wird.
1\. Füge eine Klasse „RunTheRabbit“, die das MiddlewareInterface implementiert, zu **packages/site-distribution/Classes/Middleware/RunTheRabbit.php** hinzu:
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
```
```
declare(strict_types=1);
namespace Site\Distribution\Middleware;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Site\Distribution\Queue\Message\MyMessage;
use Symfony\Component\Messenger\MessageBusInterface;
class RunTheRabbit implements MiddlewareInterface
{
public function __construct(private readonly MessageBusInterface $bus)
{
}
public function process(
ServerRequestInterface $request,
RequestHandlerInterface $handler
): ResponseInterface {
$content = 'Some important content';
$this->bus->dispatch(new MyMessage($content));
return $handler->handle($request);
}
}
```
2\. Um die Middleware zu registrieren, erstelle die Datei **packages/site-distribution/Configuration/RequestMiddlewares.php** und füge den folgenden Code hinzu:
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
```
```
return [
'frontend' => [
'site-rabbit' => [
'target' => \Site\Distribution\Middleware\RunTheRabbit::class,
'after' => [
'TYPO3/cms-frontend/authentication',
],
'before' => [
'TYPO3/cms-frontend/base-redirect-resolver',
],
],
],
];
```
3\. Es ist Zeit zum Testen! Starte TYPO3 neu, um alle Änderungen zu übernehmen:
```
1
```
```
ddev restart
```
4\. Überprüfe, ob alle Dienste verfügbar sind:
```
1
```
```
ddev describe
```
Du solltest ein „OK“ für die Web-, db- und rabbitmq-Dienste sehen.
5\. Du musst einen Consumer starten, um die Nachrichten zu lesen, die RunTheRabbit an die Warteschlange sendet. Um das Testen zu erleichtern, kannst du diesen Einzeiler verwenden:
```
1
```
```
ddev TYPO3 messenger:consume -vv amqp
```
Das Flag -vv veranlasst den Verbraucher, seine Aktionen auf dem Terminal zu protokollieren.
6\. Öffne nun das TYPO3-Frontend. Jedes Mal, wenn du eine Seite im Frontend öffnest oder neu lädst, wirst du diese Meldung im Terminal sehen:
```
1
```
```
[info] Site\Distribution\Queue\Message\MyMessage was handled successfully (acknowledging to transport).
```
Herzlichen Glückwunsch! Du hast erfolgreich RabbitMQ Messaging mit TYPO3 eingerichtet.
Schlussfolgerung: Message Queues und TYPO3 sind ein gutes Team
--------------------------------------------------------------
Das Einrichten von Nachrichten-Warteschlangen mit TYPO3 ist in v12 viel einfacher geworden. Mit wenigen Schritten ist es möglich, RabbitMQ mit TYPO3 einzurichten und zu integrieren. Jetzt gibt es keinen Grund mehr, sich über wachsende Besucherzahlen auf deiner Website Sorgen zu machen. Wenn bestimmte beliebte Dienste wie die PDF-Erzeugung oder das Zippen von Dateien für den Download zu viel CPU-Leistung verbrauchen, kannst du diese Aufgaben dank der neuen Message Queue-Integration an asynchrone Worker auf verschiedenen Nodes auslagern.
Wenn du Hilfe oder Unterstützung bei der Implementierung von Nachrichtenwarteschlangen brauchst, kontaktiere uns!
[ Meld dich bei uns. ](https://b13.com/de/kontakt)
### Geschrieben von:
Jochen ist ein TYPO3-Entwickler mit Liebe zur Community. Er erstellt schöne Websites und liebt sauber geschriebenen Code. Sein unverzichtbares Werkzeug: TYPO3.
Jochen Roth Development
[ mehr von Jochen Roth ](https://b13.com/de/team/jochen-roth)
Ähnliche Artikel
------------------
- 
### T3ppy gibt TYPO3 ein freundliches Gesicht
06. August 2026 | Florian “Flix” Keitgen
TYPO3 ist leistungsstark — muss sich aber nicht unpersönlich anfühlen. Das ist T3ppy, unser freundlicher Begleiter fürs Backend.
[ weiterlesen: T3ppy gibt TYPO3 ein freundliches Gesicht ](https://b13.com/de/wissen/t3ppy-design-kit)
- 
### KI-Inhalte in TYPO3: Transparenz braucht Verantwortung
02. August 2026 | Benni Mack
Der EU AI Act rückt die Herkunft KI-generierter Inhalte in den Fokus. AI Label kennzeichnet KI-generierte und KI-bearbeitete Inhalte in TYPO3 und dokumentiert, wer den…
[ weiterlesen: KI-Inhalte in TYPO3: Transparenz braucht Verantwortung ](https://b13.com/de/wissen/ai-content-in-typo3-labelling-needs-accountability)
- 
### Gestatten, T3ppy! Ein neues Zeitalter für die Redaktionsarbeit in TYPO3
01. April 2026 | Florian “Flix” Keitgen
Entdecke T3ppy und AiM — Deine KI-Assistenz im TYPO3 Backend für bessere Inhalte, klare Strukturen und volle Kontrolle über Redaktions-Prozesse.
[ weiterlesen: Gestatten, T3ppy! Ein neues Zeitalter für die Redaktionsarbeit in TYPO3 ](https://b13.com/de/wissen/gestatten-t3ppy-ein-neues-zeitalter-fuer-die-redaktionsarbeit-in-typo3)
- 
### Warum TYPO3 einen Marketplace für Produkte braucht
25. März 2026 | Florian “Flix” Keitgen
Ein Marketplace würde TYPO3-Produkte sichtbarer machen, den Vergleich erleichtern und Agenturen sowie Kunden gleichermaßen profitieren lassen.
[ weiterlesen: Warum TYPO3 einen Marketplace für Produkte braucht ](https://b13.com/de/wissen/warum-typo3-einen-marketplace-fuer-produkte-braucht)
- 
### Ein echter Geheimtipp in TYPO3: Die Backend User Section (Doktype 6)
05. März 2026 | David Steeb
Entdecke den oft unterschätzten Doktype 6 (Backend User Section) in TYPO3 für sichere interne Vorschauen, Redaktionstrainings und Prototyping. Erfahre praxisnahe Anwendungsfälle,…
[ weiterlesen: Ein echter Geheimtipp in TYPO3: Die Backend User Section (Doktype 6) ](https://b13.com/de/wissen/ein-echter-geheimtipp-in-typo3-die-backend-user-section-doktype-6)
- 
### Backend-Content-Previews mit System — warum wir EXT:backendpreviews entwickelt haben
09. Februar 2026 | David Steeb
EXT:backendpreviews sorgt für konsistente Content-Previews im TYPO3-Backend mit Fluid Templates, Layouts und Partials.
[ weiterlesen: Backend-Content-Previews mit System — warum wir EXT:backendpreviews entwickelt haben ](https://b13.com/de/wissen/backend-content-previews-mit-system-warum-wir-extbackendpreviews-entwickelt-haben)
- 
### Das Internet ist nicht mehr nur für Menschen — KI-Bots lieben Markdown
28. Januar 2026 | Benni Mack
Discover why most web traffic is now automated and how TYPO3’s structured content model prepares websites for humans, editors, and AI systems.
[ weiterlesen: Das Internet ist nicht mehr nur für Menschen — KI-Bots lieben Markdown ](https://b13.com/de/wissen/das-internet-ist-nicht-mehr-nur-fuer-menschen-ki-bots-lieben-markdown)
- 
### Camino—The Need for a Default Theme in TYPO3 Is Real
27. Januar 2026 | Benni Mack
With TYPO3 v14, Camino introduces a default theme that removes friction from first installs. Why this matters—and how TYPO3 laid the groundwork.
- 
### T3CON25 — der Zukunft des Content Managements einen Schritt näher
10. Dezember 2025 | Franzi Töpler
Die T3CON25 zeigte die Zukunft von TYPO3 mit Einblicken in TYPO3 v14, KI, digitale Souveränität und Open-Source-Lösungen für moderne, sichere Webauftritte.
[ weiterlesen: T3CON25 — der Zukunft des Content Managements einen Schritt näher ](https://b13.com/de/wissen/t3con25-der-zukunft-des-content-managements-einen-schritt-naeher)
- 
### Code, Collaboration und Community: Meine Woche beim TYPO3 v14 Feature Sprint in Genf
05. November 2025 | Oliver Bartsch
Fünf Tage, 14 Contributors, unzählige Ideen — und 55 Patches erstellt!
Unser Team von b13 war beim TYPO3 v14 Feature Sprint in Genf dabei, um wichtige Verbesserungen für…
[ weiterlesen: Code, Collaboration und Community: Meine Woche beim TYPO3 v14 Feature Sprint in Genf ](https://b13.com/de/wissen/code-collaboration-und-community-meine-woche-beim-typo3-v14-feature-sprint-in-genf)