Wer seinen Team-Chat nicht in fremde Hände geben möchte, hat mit Rocket.Chat eine ausgereifte Alternative zu Slack und Microsoft Teams. Die Plattform (45.400 GitHub-Stars, über 1.200 Releases, primär in TypeScript geschrieben) bietet Channels, Direktnachrichten, Videoanrufe über Jitsi oder BigBlueButton, Ende-zu-Ende-Verschlüsselung, einen App-Marktplatz mit Bots und Integrationen sowie Omnichannel-Kundensupport – und läuft vollständig auf deiner eigenen Infrastruktur. Diese Anleitung führt dich Schritt für Schritt durch die Installation per Docker Compose auf einem beliebigen Linux-Host: von der .env-Datei über das modulare Compose-Setup bis zum laufenden Setup-Wizard im Browser.

Voraussetzungen

Linux-Host, VM oder NAS mit Docker Engine ≥ 24.x und dem Compose-Plugin v2 (docker compose, nicht das veraltete docker-compose v1). Wie du Docker auf Ubuntu oder Debian installierst, erklärt die Anleitung Docker und Docker Compose auf Linux installieren.
Mindestens 2 GB RAM (empfohlen 4 GB) – Rocket.Chat, MongoDB als Replica Set und NATS zusammen sind speicherhungrig; bei weniger als 2 GB drohen OOM-Kills.
Mindestens 10 GB freier Speicherplatz (empfohlen 20 GB).
Internetverbindung für den Image-Pull von registry.rocket.chat und docker.io.
Für den Produktivbetrieb: eine öffentliche Domain und ein Reverse Proxy für HTTPS (z. B. Traefik als Docker-Reverse-Proxy oder Caddy).
Optional: SMTP-Zugangsdaten für E-Mail-Benachrichtigungen und Passwort-Reset-Mails.

Eckdaten auf einen Blick

Parameter	Wert
Image (Rocket.Chat)	`registry.rocket.chat/rocketchat/rocket.chat:8.0.1`
Aktuelle stabile Version	8.5.0 (Juni 2026) – in `.env` auf gewünschte Version setzen
Image (MongoDB)	`docker.io/mongodb/mongodb-community-server:8.2-ubi8`
Image (NATS)	`docker.io/nats:2.11-alpine`
Web-UI / API Port	3000 (HTTP, anpassbar über `HOST_PORT`)
MongoDB Port	27017 (standardmäßig nur auf 127.0.0.1 – nicht öffentlich exponieren!)
NATS Port	4222 (standardmäßig nur auf 127.0.0.1)
Prometheus-Metriken	9458 (intern, nur im Container)
Volume (MongoDB-Daten)	`mongodb_data:/data/db`
Mindest-RAM	2 GB (empfohlen 4 GB)

Schritt 1: Projektordner anlegen

Lege einen Ordner für das Projekt an und wechsle hinein. Alle folgenden Dateien kommen in diesen Ordner:

sudo mkdir -p /opt/rocketchat
sudo chown $USER:$USER /opt/rocketchat
cd /opt/rocketchat

Verifizieren: Das Verzeichnis existiert und ist beschreibbar:

ls -la /opt/rocketchat
# Erwartete Ausgabe: Ordner existiert, Eigentümer ist dein Benutzer

Schritt 2: Umgebungsvariablen in der .env konfigurieren

Alle variablen Werte gehören in die .env-Datei – so bleibt compose.yaml versionierbar und die Secrets sind an einem Ort. Passe mindestens ROOT_URL auf deine tatsächliche URL an, bevor du den Stack startest – ein falsch gesetzter ROOT_URL bricht OAuth-Links, E-Mail-Nachrichten und Push-Benachrichtigungen.

# /opt/rocketchat/.env
# ── Rocket.Chat ──────────────────────────────────────────────────
# Feste Version angeben – niemals "latest" in Produktion!
RELEASE=8.0.1

# Vollständige URL inkl. Protokoll und Port (Pflicht)
ROOT_URL=http://localhost:3000

# Für Produktion mit HTTPS und Domain:
# ROOT_URL=https://chat.beispiel.de
DOMAIN=localhost

# Interner App-Port (Standard 3000)
PORT=3000
HOST_PORT=3000
BIND_IP=0.0.0.0

# Cloud-Token leer lassen für rein lokalen Betrieb
REG_TOKEN=

# ── MongoDB ──────────────────────────────────────────────────────
MONGODB_VERSION=8.2
# WICHTIG: replicaSet-Parameter ist zwingend erforderlich
MONGO_URL=mongodb://mongodb:27017/rocketchat?replicaSet=rs0
MONGODB_REPLICA_SET_NAME=rs0
MONGODB_ADVERTISED_HOSTNAME=mongodb
MONGODB_PORT_NUMBER=27017
# Nur auf localhost binden – nicht auf 0.0.0.0 ändern ohne Firewall!
MONGODB_BIND_IP=127.0.0.1
ALLOW_EMPTY_PASSWORD=yes

# ── NATS ─────────────────────────────────────────────────────────
NATS_VERSION=2.11-alpine
NATS_PORT_NUMBER=4222
NATS_BIND_IP=127.0.0.1
NATS_URL=monolith+nats://nats:4222

# ── Monitoring (optional, nur mit compose.monitoring.yml) ────────
GRAFANA_ADMIN_PASSWORD=sicher-aendern

Verifizieren: Die Datei ist vorhanden und enthält alle Pflicht-Keys:

grep -E "^(RELEASE|ROOT_URL|MONGO_URL|MONGODB_REPLICA_SET_NAME)=" /opt/rocketchat/.env
# Erwartete Ausgabe: alle vier Zeilen mit Werten

Schritt 3: compose.yaml anlegen

Das offizielle Compose-Repository (github.com/RocketChat/rocketchat-compose) arbeitet mit einem modularen System aus mehreren Compose-Dateien. Die folgende compose.yaml fasst die wesentlichen Services – Rocket.Chat, MongoDB mit Init-Container-Pattern und NATS – in einer Datei zusammen, die direkt ohne Zusatzdateien funktioniert.

Wichtig zu verstehen: MongoDB wird zwingend als Replica Set benötigt, auch auf einem einzelnen Knoten. Das erledigen zwei Init-Container: mongodb-fix-permission-container setzt die richtigen Datei-Eigentümer auf dem Volume, mongodb-init-container initialisiert das Replica Set (rs.initiate()). Rocket.Chat wartet per eingebautem nc-Polling, bis MongoDB erreichbar ist.

---
# Rocket.Chat + MongoDB (Replica Set) + NATS
# Quelle: https://github.com/RocketChat/rocketchat-compose
# Start: docker compose up -d
# UI:    http://<HOST>:${HOST_PORT:-3000}

services:

  rocketchat:
    image: registry.rocket.chat/rocketchat/rocket.chat:${RELEASE:-8.0.1}
    restart: always
    labels:
      prometheus.io/scrape: "true"
      prometheus.io/port: "9458"
    environment:
      ROOT_URL: ${ROOT_URL:-http://localhost:3000}
      PORT: ${PORT:-3000}
      DEPLOY_METHOD: docker
      DEPLOY_PLATFORM: compose
      REG_TOKEN: ${REG_TOKEN:-}
      MONGO_URL: ${MONGO_URL:-mongodb://mongodb:27017/rocketchat?replicaSet=rs0}
      TRANSPORTER: "${NATS_URL:-monolith+nats://nats:4222}"
    entrypoint: sh
    command:
      - -c
      - |
        echo "Waiting for MongoDB...";
        for i in $(seq 1 60); do
          if nc -z mongodb 27017 >/dev/null 2>&1; then
            echo "MongoDB is up - starting Rocket.Chat";
            exec node main.js;
          fi;
          echo "MongoDB not ready, retrying in 5s...";
          sleep 5;
        done;
        echo "Giving up after 5 minutes"; exit 1
    expose:
      - "${PORT:-3000}"
      - "9458"
    ports:
      - "${BIND_IP:-0.0.0.0}:${HOST_PORT:-3000}:${PORT:-3000}"
    depends_on:
      mongodb:
        condition: service_healthy
    logging:
      driver: "json-file"

  nats:
    image: docker.io/nats:${NATS_VERSION:-2.11-alpine}
    restart: always
    command: --http_port 8222
    expose:
      - "4222"
      - "8222"
      - "6222"
    ports:
      - "${NATS_BIND_IP:-127.0.0.1}:${NATS_PORT_NUMBER:-4222}:4222"
    logging:
      driver: "json-file"

  mongodb-fix-permission-container:
    image: docker.io/mongodb/mongodb-community-server:${MONGODB_VERSION:-8.2}-ubi8
    restart: on-failure
    user: "0"
    volumes:
      - mongodb_data:/data/db:rw
    environment:
      MONGODB_USER_ID: ${MONGODB_USER_ID:-1001}
    entrypoint: |
      sh -xc '
        owner="$$(stat -c %u /data/db)";
        if [ "$$owner" != "$$MONGODB_USER_ID" ]; then
          echo "Fixing ownership to uid $$MONGODB_USER_ID";
          chown -R "$$MONGODB_USER_ID" /data/db;
        else echo "Nothing to do"; fi;
      '

  mongodb-init-container:
    image: docker.io/mongodb/mongodb-community-server:${MONGODB_VERSION:-8.2}-ubi8
    restart: on-failure
    user: "0"
    environment:
      MONGODB_REPLICA_SET_NAME: ${MONGODB_REPLICA_SET_NAME:-rs0}
      MONGODB_PORT_NUMBER: ${MONGODB_PORT_NUMBER:-27017}
      MONGODB_URI: ${MONGODB_URI:-mongodb://mongodb:27017/?directConnection=true}
      MONGODB_ADVERTISED_HOSTNAME: ${MONGODB_ADVERTISED_HOSTNAME:-mongodb}
    volumes:
      - mongodb_data:/data/db:rw
    entrypoint: |
      sh -xc '
        echo "Waiting for MongoDB to be healthy...";
        until mongosh "$$MONGODB_URI" --eval "db.adminCommand(\"ping\")" >/dev/null 2>&1; do
          echo "MongoDB not ready, retrying in 5s..."; sleep 5;
        done;
        echo "Initiating ReplSet $$MONGODB_REPLICA_SET_NAME...";
        mongosh "$$MONGODB_URI" --eval "rs.initiate({_id: \"$$MONGODB_REPLICA_SET_NAME\", members: [{ _id: 0, host: \"$$MONGODB_ADVERTISED_HOSTNAME:$$MONGODB_PORT_NUMBER\" }]})";
        echo "ReplSet init done.";
      '
    logging:
      driver: "json-file"

  mongodb:
    image: docker.io/mongodb/mongodb-community-server:${MONGODB_VERSION:-8.2}-ubi8
    restart: always
    volumes:
      - mongodb_data:/data/db:rw
    user: "${MONGODB_USER_ID:-1001}"
    entrypoint:
      - sh
      - -ec
      - |
        echo "Waiting for /data/db ownership by uid $$MONGODB_USER_ID...";
        for i in $$(seq 1 60); do
          owner="$$(stat -c %u /data/db 2>/dev/null || true)";
          if [ "$$owner" = "$$MONGODB_USER_ID" ]; then
            echo "/data/db OK - starting MongoDB";
            exec mongod --replSet "$$MONGODB_REPLICA_SET_NAME" --bind_ip_all;
          fi;
          echo "Owner is '$$owner' (expected $$MONGODB_USER_ID), retry in 5s...";
          sleep 5;
        done;
        echo "Giving up after 5 minutes"; exit 1
    environment:
      MONGODB_USER_ID: ${MONGODB_USER_ID:-1001}
      MONGODB_REPLICA_SET_NAME: ${MONGODB_REPLICA_SET_NAME:-rs0}
      MONGODB_PORT_NUMBER: ${MONGODB_PORT_NUMBER:-27017}
      MONGODB_ADVERTISED_HOSTNAME: ${MONGODB_ADVERTISED_HOSTNAME:-mongodb}
      ALLOW_EMPTY_PASSWORD: ${ALLOW_EMPTY_PASSWORD:-yes}
    healthcheck:
      test:
        - CMD
        - mongosh
        - "mongodb://mongodb:27017/?directConnection=true"
        - --eval
        - "db.adminCommand('ping')"
      interval: 30s
      timeout: 10s
      retries: 10
      start_period: 30s
    ports:
      - "${MONGODB_BIND_IP:-127.0.0.1}:${MONGODB_PORT_NUMBER:-27017}:${MONGODB_PORT_NUMBER:-27017}"
    logging:
      driver: "json-file"

volumes:
  mongodb_data:
    driver: local

Verifizieren: YAML-Syntax prüfen, bevor du den Stack startest:

docker compose -f /opt/rocketchat/compose.yaml config --quiet
# Keine Ausgabe = kein Syntaxfehler

Schritt 4: Stack starten

Der erste Start lädt alle Images (ca. 1–2 GB) und startet die Container in der richtigen Reihenfolge. Die Init-Container laufen einmalig durch und beenden sich danach selbst – das ist so vorgesehen.

cd /opt/rocketchat
docker compose up -d

Verfolge den Start live in den Logs:

# MongoDB-Status beobachten
docker compose logs -f mongodb

# Init-Container – Replica Set initialisiert?
docker compose logs mongodb-init-container

# Rocket.Chat – wartet auf MongoDB, dann Start
docker compose logs -f rocketchat

Verifizieren: Nach 2–3 Minuten müssen rocketchat, mongodb und nats laufen:

docker compose ps
# Erwartete Ausgabe (Auszug):
# NAME                              STATUS
# rocketchat-rocketchat-1           Up (healthy)  oder  Up X minutes
# rocketchat-mongodb-1              Up (healthy)
# rocketchat-nats-1                 Up
# rocketchat-mongodb-init-container-1   Exited (0)   ← normal, einmalig
# rocketchat-mongodb-fix-permission-container-1  Exited (0)  ← normal

curl -I http://localhost:3000
# Erwartete Antwort: HTTP/1.1 200 OK  (oder 302 Found)

Schritt 5: Setup-Wizard im Browser abschließen

Öffne http://<SERVER-IP>:3000 im Browser. Beim ersten Aufruf erscheint der Rocket.Chat Setup-Wizard, der dich durch folgende Schritte führt:

Admin-Konto anlegen – Name, E-Mail-Adresse und sicheres Passwort wählen.
Workspace-Info – Name deiner Organisation und Nutzungszweck (privat/Team/Unternehmen).
Server-Registrierung – du kannst „Registrierung überspringen" wählen für rein lokalen Betrieb ohne Cloud-Anbindung (dann bleibt REG_TOKEN leer).

Nach dem Wizard gelangst du direkt in den Workspace. Als Erstes solltest du unter Administration → Konto → Sicherheit die Zwei-Faktor-Authentifizierung für den Admin aktivieren – das dauert zwei Minuten und schützt den privilegiertesten Account.

Verifizieren: Der Setup-Wizard wurde abgeschlossen und du siehst die Rocket.Chat-Oberfläche mit dem „Allgemein"-Channel. Ein Login mit den angelegten Admin-Daten muss funktionieren.

Schritt 6: HTTPS mit Reverse Proxy einrichten (Produktion)

Für den Produktivbetrieb ist HTTPS Pflicht – nicht nur für die Sicherheit, sondern auch weil Rocket.Chat Push-Benachrichtigungen und bestimmte Browser-APIs (Kamera/Mikrofon für Videoanrufe) nur über HTTPS freigeben. Empfohlen sind Traefik oder Caddy als vorgelagerter Reverse Proxy.

Für Traefik mit automatischem Let's-Encrypt-Zertifikat findest du die vollständige Einrichtung in der Anleitung Traefik als Docker-Reverse-Proxy mit automatischem HTTPS. Danach passe in der .env unbedingt ROOT_URL auf die HTTPS-URL an und starte den Stack neu:

ROOT_URL=https://chat.beispiel.de
DOMAIN=chat.beispiel.de
cd /opt/rocketchat
docker compose up -d rocketchat
# Nur den Rocket.Chat-Container neu starten, MongoDB bleibt laufen

Verifizieren: Die URL https://chat.beispiel.de ist per Browser erreichbar, das Zertifikat ist gültig, und in den Rocket.Chat-Admin-Einstellungen unter Administration → Allgemein zeigt Site URL die HTTPS-Adresse.

Schritt 7: Updates und Backups

Rocket.Chat veröffentlicht regelmäßig neue Versionen. Das Update-Verfahren ist denkbar einfach – aber ein Backup vorher ist Pflicht, denn Datenbankmigrationen lassen sich nicht rückgängig machen.

Update durchführen

cd /opt/rocketchat

# 1. Neue Version in .env setzen:
#    RELEASE=8.5.0
nano .env

# 2. Neues Image ziehen und Container neu starten:
docker compose pull
docker compose up -d

# 3. Laufende Version prüfen:
docker compose logs rocketchat | grep "version"

Backup der MongoDB-Daten

Alle persistenten Daten liegen im mongodb_data-Volume. Ein konsistentes Backup erstellst du mit mongodump direkt im laufenden Container:

# Dump in lokales Verzeichnis sichern
docker compose exec mongodb mongodump \
  --uri="mongodb://mongodb:27017/rocketchat?replicaSet=rs0" \
  --out=/data/db/backup-$(date +%Y%m%d)

# Dump auf den Host kopieren
docker cp \
  $(docker compose ps -q mongodb):/data/db/backup-$(date +%Y%m%d) \
  /opt/rocketchat/backups/

Für eine automatisierte Backup-Strategie mit Rotation und optionalem Cloud-Sync empfiehlt sich die Anleitung MySQL & PostgreSQL Backup automatisieren mit cron – das Prinzip ist für MongoDB analog anwendbar.

Verifizieren: Das Backup-Verzeichnis ist vorhanden und enthält BSON-Dateien:

ls -lh /opt/rocketchat/backups/
# Erwartete Ausgabe: Unterordner mit rocketchat/*.bson-Dateien

Troubleshooting / Typische Fehler

„MongoServerError: not master and slaveOk=false" – MONGO_URL fehlt der Parameter ?replicaSet=rs0. In der .env korrigieren und docker compose up -d rocketchat neu starten.
Rocket.Chat hängt im „Waiting for MongoDB"-Loop – Ursachen prüfen: a) mongodb-fix-permission-container lief noch nicht durch (docker compose logs mongodb-fix-permission-container), b) Volume-Berechtigungsfehler, c) Replica-Set-Init schlug fehl (docker compose logs mongodb-init-container). Im Zweifel den Stack komplett stoppen und Volume löschen: docker compose down -v && docker compose up -d.
„Permission denied" beim MongoDB-Start – Der mongodb-fix-permission-container muss vollständig abgeschlossen sein, bevor MongoDB startet. Prüfen mit docker compose logs mongodb-fix-permission-container; Status muss Exited (0) sein.
OOM-Kill / Container startet ständig neu – Zu wenig RAM. MongoDB als Replica Set benötigt allein 1–1,5 GB. Mit docker stats den Speicherverbrauch prüfen; Empfehlung: mindestens 4 GB RAM für den Host bereitstellen.
ROOT_URL falsch gesetzt – Symptome: E-Mail-Links führen auf falsche Adresse, OAuth-Login schlägt fehl, Push-Benachrichtigungen kommen nicht an. ROOT_URL in .env auf die tatsächlich erreichbare URL (inkl. Protokoll und Port) setzen, dann docker compose up -d rocketchat.
„DEPRECATED_COMPOSE"-Fehler beim Start – Du nutzt noch das alte Docker.Official.Image-Repo. Auf das neue Repo unter github.com/RocketChat/rocketchat-compose wechseln bzw. die compose.yaml aus dieser Anleitung verwenden.
„MongoNetworkError: connect ECONNREFUSED" – depends_on mit condition: service_healthy fehlt oder der MongoDB-Healthcheck schlägt fehl. Logs prüfen: docker compose logs mongodb. Auf langsamen Systemen ggf. start_period im Healthcheck auf 60s erhöhen.
Kein E-Mail-Versand – Kein Fehler beim Start, aber Registrierungs- und Reset-Mails kommen nicht an. SMTP-Einstellungen unter Administration → E-Mail → SMTP konfigurieren.

Häufige Fragen

Kann ich Rocket.Chat ohne NATS betreiben?

Ja – NATS ist für Single-Node-Setups technisch nicht zwingend, aber im Standard-Compose enthalten. Im Monolith-Modus (TRANSPORTER=monolith+nats://nats:4222) nutzt Rocket.Chat NATS als internen Message-Broker, der im selben Container-Netzwerk läuft. Für horizontale Skalierung auf mehrere Rocket.Chat-Instanzen ist NATS hingegen Pflicht. Wer NATS komplett abschalten möchte, muss den Service aus der compose.yaml entfernen und TRANSPORTER auf TCP umstellen – das ist aber kein unterstützter Anwendungsfall laut offizieller Doku.

Wie aktualisiere ich Rocket.Chat auf eine neue Version?

In der .env RELEASE=neue.version setzen (z. B. 8.5.0), dann docker compose pull && docker compose up -d. MongoDB-Daten bleiben im Volume erhalten. Vor jedem größeren Update ein Backup per mongodump erstellen – Datenbankmigrationen sind nicht rückgängig zu machen.

Wie richte ich Ende-zu-Ende-Verschlüsselung ein?

Im Admin-Panel unter Administration → E2E Encryption aktivieren. Nutzer müssen anschließend in ihrem Profil (Konto → Sicherheit → E2E-Schlüssel) ihren persönlichen E2E-Schlüssel einrichten und sichern. E2E-Verschlüsselung gilt pro Kanal oder Direktnachricht und muss vom Nutzer aktiv aktiviert werden – sie ist kein globaler Schalter.

Wie viele Nutzer kann eine Rocket.Chat-Instanz bedienen?

Das hängt stark von der Hardware ab. Für kleine Teams (bis 50 Nutzer) reicht ein VPS mit 2 CPU-Kernen, 4 GB RAM und 20 GB SSD. Für 200+ gleichzeitige Nutzer empfiehlt Rocket.Chat, MongoDB auf separater Hardware (bare metal oder VM außerhalb von Docker) zu betreiben und über MONGO_URL einzubinden. Für sehr große Deployments kommt horizontale Skalierung mit mehreren Rocket.Chat-Instanzen und NATS ins Spiel.

Wie sichere ich den MongoDB-Port ab?

Standardmäßig ist MONGODB_BIND_IP=127.0.0.1 gesetzt – MongoDB antwortet nur auf dem Loopback-Interface und ist von außen nicht erreichbar. Diese Einstellung nicht auf 0.0.0.0 ändern, ohne gleichzeitig eine Firewall-Regel zu setzen, da ALLOW_EMPTY_PASSWORD=yes im Standard aktiv ist und die Datenbank sonst ohne Authentifizierung erreichbar wäre.

Wie migriere ich von einem alten Rocket.Chat-Setup?

Ein mongodump des alten Systems erstellen, die neue Instanz starten, dann mit mongorestore in den laufenden MongoDB-Container importieren. Den ROOT_URL auf die neue Adresse anpassen und ggf. die DNS-Einträge umstellen. Bei einem Versionssprung über mehrere Major-Versionen empfiehlt sich ein schrittweises Upgrade.

Fazit

Rocket.Chat ist die reifste selbstgehostete Slack-Alternative am Markt: 45.000 GitHub-Stars, über acht Jahre Entwicklung, aktive Community und Enterprise-taugliche Features wie E2E-Verschlüsselung, App-Marktplatz und Omnichannel-Support – alles auf deiner eigenen Infrastruktur. Der Einstieg per Docker Compose ist dank des modularen rocketchat-compose-Repos überschaubar, erfordert aber Aufmerksamkeit für den MongoDB Replica Set und korrekte ROOT_URL-Konfiguration. Für Teams und KMUs, die vollständige Datenkontrolle und Anpassbarkeit einem SaaS-Abo vorziehen, ist Rocket.Chat eine solide, langfristig tragfähige Entscheidung.

Wer nach einer schlankeren Alternative ohne MongoDB sucht, sollte einen Blick auf Mattermost als Slack-Alternative werfen – PostgreSQL-basiert und etwas weniger ressourcenhungrig. Für Browser-basierte Videokonferenzen als eigenständige Lösung bietet sich außerdem Jitsi Meet mit Docker an.

Weiterführende Anleitungen und Quellen

Offizielle Quellen: Rocket.Chat Docs – Deploy with Docker Compose | RocketChat/rocketchat-compose auf GitHub