Rocket.Chat ist eine selbst gehostete Alternative zu Slack und Microsoft Teams. Die Plattform bietet Channels, Direktnachrichten, Videoanrufe über Jitsi oder BigBlueButton, Ende-zu-Ende-Verschlüsselung, App-Marktplatz und Omnichannel-Support. Diese Anleitung installiert Rocket.Chat per Docker Compose auf einem Linux-Host.

Voraussetzungen

Linux-Host, VM oder NAS mit Docker Engine ≥ 24.x und dem Compose-Plugin v2 (docker compose). Wie Sie Docker auf Ubuntu oder Debian installieren, erklärt die Anleitung Docker und Docker Compose auf Linux installieren.
Mindestens 2 CPU-Kerne und 2 GB RAM (empfohlen 4 GB); bei weniger als 2 GB drohen OOM-Kills.
CPU mit AVX auf x86-64: MongoDB setzt ab Version 5.0 den Befehlssatz AVX voraus, das Beispiel verwendet MongoDB 8.2. Ältere oder sparsame CPUs (etwa manche Celeron, Pentium, Atom) und VMs mit CPU-Typ „kvm64“ bieten kein AVX. Prüfen Sie vorab: grep -o -m1 -w avx /proc/cpuinfo muss avx ausgeben. Auf ARM64 gilt diese Anforderung nicht.
Linux-Kernel passend zu MongoDB 8.2: Laut Release Notes zu MongoDB 8.2 ist MongoDB mit Linux-Kernel 6.19 bis 7.0.13 inkompatibel, ab Kernel 7.0.14 ist das behoben. Prüfen Sie mit uname -r: Unter 6.19 oder ab 7.0.14 läuft das Beispiel. Eine korrigierte 8.2.x-Version gibt es nicht: Die Startfreigabe für Kernel ab 7.0.14 (SERVER-125742) erschien nur in MongoDB 8.0.30 und 8.3.9, und MongoDB 8.2 hat laut Lebenszyklus-Seite von MongoDB seit 31.07.2026 keinen Support mehr (letzte Version 8.2.12). Rocket.Chat 8.9.0 nennt in seinen Release Notes MongoDB 8.0 als Engine-Version.
Mindestens 10 GB freier Speicherplatz (empfohlen 20 GB).
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.

Eckdaten auf einen Blick

Parameter	Wert
Image (Rocket.Chat)	`registry.rocket.chat/rocketchat/rocket.chat:8.9.0`
Aktuelle stabile Version	8.9.0 LTS (05.10.2026, Support bis 31.10.2027); das offizielle Beispiel pinnt im Compose-Standardwert 8.0.1, Version in `.env` 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)
CPU	x86-64 mit AVX oder ARM64

Schritt 1: Projektordner anlegen

Legen Sie einen Ordner für das Projekt an und wechseln Sie hinein:

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

Verifizieren:

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

Schritt 2: Umgebungsvariablen in der .env konfigurieren

Alle variablen Werte gehören in die .env-Datei. Passen Sie mindestens ROOT_URL an Ihre tatsächliche URL an, bevor Sie den Stack starten. Ein falscher 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.9.0

# 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: Pflicht-Keys vorhanden:

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 Repository rocketchat-compose verteilt den Stack auf mehrere Compose-Dateien. Die folgende compose.yaml fasst Rocket.Chat, MongoDB mit Init-Containern und NATS in einer Datei zusammen.

MongoDB muss als Replica Set laufen, 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 führt rs.initiate() aus. Rocket.Chat wartet per nc, 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 vor dem Start prüfen:

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). Die Init-Container laufen einmalig durch und beenden sich danach, das ist so vorgesehen.

cd /opt/rocketchat
docker compose up -d

Verfolgen Sie den Start 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

Öffnen Sie http://<SERVER-IP>:3000 im Browser. Der Setup-Wizard führt durch folgende Schritte:

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

Aktivieren Sie danach unter Administration → Konto → Sicherheit die Zwei-Faktor-Authentifizierung für das Admin-Konto.

Verifizieren: Nach dem Wizard sehen Sie die Oberfläche mit dem Channel „general“. Der Admin-Login funktioniert.

Schritt 6: HTTPS mit Reverse Proxy einrichten (Produktion)

Für den Produktivbetrieb ist HTTPS Pflicht, auch weil Browser Kamera und Mikrofon für Videoanrufe nur über HTTPS freigeben. Geeignet sind Traefik oder Caddy als Reverse Proxy.

Traefik mit Let’s Encrypt beschreibt die Anleitung Traefik als Docker-Reverse-Proxy mit automatischem HTTPS. Passen Sie danach in der .env ROOT_URL auf die HTTPS-URL an und starten Sie Rocket.Chat 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: https://chat.beispiel.de öffnet sich mit gültigem Zertifikat, unter Administration → Allgemein zeigt Site URL die HTTPS-Adresse.

Schritt 7: Updates und Backups

Erstellen Sie vor jedem Update ein Backup, denn Datenbankmigrationen lassen sich nicht rückgängig machen.

Update durchführen

cd /opt/rocketchat

# 1. Neue Version in .env setzen:
#    RELEASE=8.9.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"

Rocket.Chat 8.9.0 ist eine LTS-Version mit zwölf Monaten Support bis 31.10.2027. Laut Release Notes läuft sie auf Node.js 24.15.0 und Meteor 3.5.2, das offizielle Image basiert auf Alpine 3.23. Die Deno-Laufzeit für Apps entfällt; installierte Marketplace- und private Apps laufen ohne Änderung unter Node.js weiter. Mehrere Realtime-API-Methoden sowie die Gravatar-Integration sind als veraltet markiert und entfallen mit 9.0.0; prüfen Sie eigene Integrationen auf Hinweise im Log. LDAP, SAML und Custom OAuth funktionieren in 8.x weiter, verlangen laut Release Notes ab 9.0.0 aber eine passende Lizenz. Wer noch die frühere LTS-Version 7.10 betreibt (Support endete am 30.09.2026), liest vor dem Sprung auf 8.9 die Breaking Changes zwischen 7.10 und 8.9 im Upgrade-Guide.

Verifizieren: Im Test lief ein Bestand mit 8.0.1, angelegtem Admin-Konto und einer Nachricht in #general nach RELEASE=8.9.0, docker compose pull und docker compose up -d ohne weitere Schritte wieder an. Das Startbanner meldete Rocket.Chat Version: 8.9.0, NodeJS Version: 24.15.0 und MongoDB Version: 8.2.12, die Anmeldung per REST-API funktionierte, die Nachricht war erhalten, ein falsches Passwort wurde abgelehnt.

Backup der MongoDB-Daten

Die Daten liegen im Volume mongodb_data. Ein Backup erstellen Sie mit mongodump 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
mkdir -p /opt/rocketchat/backups
docker cp \
  $(docker compose ps -q mongodb):/data/db/backup-$(date +%Y%m%d) \
  /opt/rocketchat/backups/

Für automatisierte Backups mit Rotation eignet sich die Anleitung MySQL & PostgreSQL Backup automatisieren mit cron; das Prinzip gilt für MongoDB analog.

Verifizieren: Das Backup 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 – Prüfen Sie die Logs von mongodb-fix-permission-container und mongodb-init-container. Bei einer frischen Installation ohne Daten hilft docker compose down -v && docker compose up -d; -v löscht alle Chat-Daten.
„Permission denied“ beim MongoDB-Start – mongodb-fix-permission-container muss mit Exited (0) abgeschlossen sein (docker compose ps -a).
MongoDB beendet sich sofort, Log oder docker compose ps zeigt „Illegal instruction“ bzw. Exit-Code 132 – Die CPU unterstützt kein AVX. grep -o -m1 -w avx /proc/cpuinfo bleibt leer. Lösung: Host mit AVX-fähiger CPU verwenden oder bei einer VM den CPU-Typ „host“ durchreichen. Ältere MongoDB-Versionen ohne AVX-Pflicht sind nicht mehr unterstützt und für Rocket.Chat 8 keine Option.
OOM-Kill / Container startet ständig neu – Zu wenig RAM. Prüfen Sie mit docker stats; stellen Sie mindestens 4 GB RAM bereit.
ROOT_URL falsch gesetzt – E-Mail-Links führen ins Leere, OAuth scheitert. ROOT_URL auf die erreichbare URL setzen, dann docker compose up -d rocketchat.
„DEPRECATED_COMPOSE“-Fehler beim Start – Sie nutzen 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“ – MongoDB ist nicht bereit. Logs prüfen (docker compose logs mongodb), auf langsamen Systemen start_period auf 60s erhöhen.
Kein E-Mail-Versand – SMTP unter Administration → E-Mail → SMTP einrichten.

Häufige Fragen

Kann ich Rocket.Chat ohne NATS betreiben?

Technisch ja, aber nicht empfohlen. Im Monolith-Modus (TRANSPORTER=monolith+nats://nats:4222) dient NATS als interner Message-Broker, für mehrere Instanzen ist er Pflicht. Das offizielle Setup sieht keinen Betrieb ohne NATS vor.

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. Vorher ein Backup per mongodump erstellen.

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

Im Admin-Panel unter Administration → E2E Encryption aktivieren. Nutzer richten danach unter Konto → Sicherheit ihren E2E-Schlüssel ein und sichern ihn. E2E-Verschlüsselung gilt pro Kanal oder Direktnachricht, nicht global.

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

Das hängt von der Hardware ab. Bis etwa 50 Nutzer reichen 2 CPU-Kerne, 4 GB RAM und 20 GB SSD. Ab etwa 200 gleichzeitigen Nutzern betreiben Sie MongoDB besser auf eigener Hardware und binden sie über MONGO_URL ein.

Wie sichere ich den MongoDB-Port ab?

Mit MONGODB_BIND_IP=127.0.0.1 ist MongoDB von außen nicht erreichbar. Ändern Sie das nicht auf 0.0.0.0, 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?

Per mongodump sichern, neue Instanz starten, mit mongorestore importieren, ROOT_URL und DNS anpassen. Über mehrere Major-Versionen aktualisieren Sie schrittweise.

Fazit

Rocket.Chat eignet sich für Teams und KMU, die ihre Chat-Daten selbst kontrollieren wollen. Kritisch sind das MongoDB Replica Set, ein korrekter ROOT_URL und eine CPU mit AVX.

Eine schlankere Alternative ohne MongoDB (und damit ohne AVX-Pflicht) ist Mattermost als Slack-Alternative auf PostgreSQL-Basis. Für eigenständige Videokonferenzen eignet sich Jitsi Meet mit Docker.

Weiterführende Anleitungen und Quellen

Offizielle Quellen: MongoDB Production Notes (AVX-Anforderung) | Release Notes MongoDB 8.2 (Kernel-Hinweis) | MongoDB SERVER-125742: Kernel-Kompatibilität | MongoDB Software Lifecycle | Rocket.Chat Docs – Deploy with Docker Compose | RocketChat/rocketchat-compose auf GitHub