Zum Inhalt springen
Serverküche
Suche

Die Suche wird geladen …

Anwendungen Schwierigkeit: Profi

Jitsi Meet: eigene Videokonferenzen ohne Zoom

Jitsi Meet mit vier Containern hinter Traefik: Moderator-Login statt offener Räume, der UDP-Port, an dem es scheitert, und was die Bilder wirklich kostet.

· 14 Min. Lesezeit ·Dauer: ca. 75 Minuten
Inhaltsverzeichnis

Eine Videokonferenz auf dem eigenen Server ist der Punkt, an dem Selfhosting aufhört, bequem zu sein: Vier Container, ein UDP-Port und eine Handvoll Fallstricke, die alle erst auffallen, wenn sich der erste Gast nicht hört.

Was bauen wir?

Wir betreiben Jitsi Meet stable-11248-3 als vier Container hinter Traefik: Web-Oberfläche, XMPP-Server, Konferenz-Steuerung und die Videobrücke. Am Ende öffnest du einen Raum im Browser, und niemand außer dir kann eine Konferenz starten. Gäste kommen erst herein, wenn du als Moderator da bist.

Bewusst weggelassen: Telefoneinwahl (Jigasi), Aufzeichnung (Jibri) und Etherpad. Jedes davon ist ein eigener Dienst mit eigenen Anforderungen; wer sie dazunimmt, baut auf dem hier aufgesetzten Stack auf.

Ein Port, der nicht durch den Proxy geht

Traefik kümmert sich nur um die Weboberfläche. Ton und Bild laufen an ihm vorbei, direkt auf UDP 10000 zum Server. Ist dieser Port zu, lädt Jitsi einwandfrei, alle sehen die Teilnehmerliste, und niemand hört jemanden. Das ist der mit Abstand häufigste Grund, warum eine eigene Jitsi-Instanz „nicht funktioniert".

Voraussetzungen

🍳 Empfehlung Anzeige

VPS 2000 G12.5

8 vCore · 16 GB RAM · 256 GB SSD

ab 26,92 €/Monat

Im Leerlauf belegt der Stack knapp 400 MB. Der Bedarf steigt aber mit jedem Teilnehmer – und zwar bei der CPU, nicht beim Speicher.

Zu netcup →

💶 1 Monat gratis:

Einmal einlösbar, gilt für VPS 2000 G12.5. Im Warenkorb einlösen →

💶 5,95 € Gutschein für netcup-Neukunden: immer gültig · nicht für Domains und VPS Lite

Alle netcup-Gutscheine →

Schritt für Schritt

Schritt 1: Warum es vier Container sind

Jitsi ist ein Verbund aus mehreren Diensten. Vier Teile, vier Aufgaben:

Ausgabe
web      nginx + die Weboberfläche        HTTP  – hinter Traefik
prosody  XMPP-Server, Konten und Räume    intern
jicofo   Konferenz-Steuerung, verteilt    intern
jvb      Videobridge – Ton und Bild       UDP 10000 – direkt am Server

prosody hält die Benutzerkonten und die Signalisierung; dein Browser redet darüber per WebSocket. jicofo entscheidet, wer Moderator ist und welche Brücke eine Konferenz bekommt. jvb ist die Videobrücke: Sie nimmt die Bild- und Tonströme aller Teilnehmer entgegen und verteilt sie weiter.

Der wichtigste Punkt daran ist die letzte Zeile. Die Videobrücke steht nicht hinter Traefik. WebRTC braucht UDP mit niedriger Latenz; ein HTTP-Proxy hat dort nichts zu suchen. Traefik liefert die Weboberfläche über 443 aus, und parallel dazu schickt dein Browser Ton und Bild auf UDP 10000 an dieselbe Adresse.

Schritt 2: Die Images kommen nicht mehr von Docker Hub

Wer eine Anleitung mit den Docker-Hub-Images kopiert, holt sich eine Version von vor mehreren Monaten:

Terminal
# Auf Docker Hub ist bei jitsi/web Schluss – der letzte stable-Tag stammt vom Juni
# Aktuell gepflegt wird ausschließlich die GitHub-Registry:
docker pull ghcr.io/jitsi/web:stable-11248-3

Jitsi veröffentlicht seine Images inzwischen unter ghcr.io/jitsi. Auf Docker Hub endet die Reihe im Juni 2026 bei stable-11031; seitdem sind stable-11146 (August) und stable-11248 (September) erschienen, beide nur noch auf GitHub. Korrekturen innerhalb einer Version bekommen ein Anhängsel: stable-11248-3 ist die dritte Nachbesserung von stable-11248. Die Version steht nicht im Image-Namen, sondern im Tag, und der ist bei allen vier Containern derselbe. Misch niemals Versionen: jicofo und jvb sprechen ein Protokoll, das sich zwischen Releases ändert.

Schritt 3: Die Konfiguration

Jitsi wird vollständig über Umgebungsvariablen eingestellt. Leg den Ordner an und erzeuge zuerst die drei Geheimnisse:

Terminal
mkdir -p /opt/jitsi && cd /opt/jitsi
openssl rand -hex 16   # dreimal ausführen – für JICOFO_AUTH_PASSWORD,
                       # JVB_AUTH_PASSWORD und JICOFO_COMPONENT_SECRET

Diese drei Werte sind die internen Passwörter, mit denen sich jicofo und jvb bei prosody anmelden. Sie kommen in die .env:

INI
# /opt/jitsi/.env
PUBLIC_URL=https://DEINE_DOMAIN
TZ=Europe/Berlin

XMPP_DOMAIN=meet.jitsi
XMPP_AUTH_DOMAIN=auth.meet.jitsi
XMPP_GUEST_DOMAIN=guest.meet.jitsi
XMPP_MUC_DOMAIN=muc.meet.jitsi
XMPP_INTERNAL_MUC_DOMAIN=internal-muc.meet.jitsi
XMPP_SERVER=xmpp.meet.jitsi
XMPP_BOSH_URL_BASE=http://xmpp.meet.jitsi:5280

JVB_BREWERY_MUC=jvbbrewery
JICOFO_AUTH_USER=focus
JVB_AUTH_USER=jvb
JVB_PORT=10000
JVB_ADVERTISE_IPS=DEINE_SERVER_IP

JICOFO_AUTH_PASSWORD=DEIN_ERSTES_GEHEIMNIS
JVB_AUTH_PASSWORD=DEIN_ZWEITES_GEHEIMNIS
JICOFO_COMPONENT_SECRET=DEIN_DRITTES_GEHEIMNIS

ENABLE_AUTH=1
ENABLE_GUESTS=1
AUTH_TYPE=internal

Zwei Blöcke verdienen eine Erklärung.

Die meet.jitsi-Domänen sind rein intern und haben mit deiner echten Domain nichts zu tun. Sie existieren nur zwischen den Containern; du musst dafür nichts im DNS eintragen. Lass sie unverändert. Die Standardwerte sind über alle Jitsi-Anleitungen hinweg gleich, und das hilft beim Suchen, wenn etwas klemmt.

JVB_ADVERTISE_IPS ist die öffentliche IPv4-Adresse deines Servers, und sie ist Pflicht. Die Videobrücke sieht von sich aus nur ihre Container-Adresse (172.x.x.x) und würde genau die an alle Browser melden, also an eine Adresse, die im Internet niemand erreicht. Jitsi versucht zwar, die echte Adresse über einen STUN-Dienst herauszufinden, aber darauf ist kein Verlass: Im Protokoll der Brücke steht nach dem Start stunDiscoveryFailed=true. Ob die Variable greift, zeigt eine andere Zeile, auf die du in Schritt 6 schaust.

Die .env ist die Sicherung

Die drei Geheimnisse stehen nur hier. Geht die .env verloren, kommen jicofo und jvb nicht mehr an prosody vorbei, und der einzige Weg zurück ist, alle drei neu zu setzen und die Container neu zu erzeugen. Setz die Datei auf chmod 600 und nimm sie ins Backup.

Schritt 4: Der Stack

YAML
# /opt/jitsi/compose.yaml
services:
  web:
    image: ghcr.io/jitsi/web:stable-11248-3
    container_name: jitsi-web
    restart: unless-stopped
    volumes:
      - ./config/web:/config:Z
    environment:
      - PUBLIC_URL
      - TZ
      - ENABLE_AUTH
      - ENABLE_GUESTS
      - XMPP_DOMAIN
      - XMPP_AUTH_DOMAIN
      - XMPP_MUC_DOMAIN
      - XMPP_INTERNAL_MUC_DOMAIN
      - XMPP_BOSH_URL_BASE
      - DISABLE_HTTPS=1
      - ENABLE_HTTP_REDIRECT=0
      - ENABLE_LETSENCRYPT=0
    networks:
      meet.jitsi:
      proxy:
    labels:
      - traefik.enable=true
      - traefik.docker.network=proxy
      - traefik.http.routers.jitsi.rule=Host(`DEINE_DOMAIN`)
      - traefik.http.routers.jitsi.entrypoints=websecure
      - traefik.http.routers.jitsi.tls.certresolver=le
      - traefik.http.services.jitsi.loadbalancer.server.port=8000

  prosody:
    image: ghcr.io/jitsi/prosody:stable-11248-3
    container_name: jitsi-prosody
    restart: unless-stopped
    expose: ['5222', '5347', '5280']
    volumes:
      - ./config/prosody/config:/config:Z
      - ./config/prosody/prosody-plugins-custom:/prosody-plugins-custom:Z
      - ./config/prosody/data:/var/lib/prosody:Z
    environment:
      - PUBLIC_URL
      - TZ
      - ENABLE_AUTH
      - ENABLE_GUESTS
      - AUTH_TYPE
      - XMPP_DOMAIN
      - XMPP_AUTH_DOMAIN
      - XMPP_GUEST_DOMAIN
      - XMPP_MUC_DOMAIN
      - XMPP_INTERNAL_MUC_DOMAIN
      - JICOFO_AUTH_USER
      - JICOFO_AUTH_PASSWORD
      - JICOFO_COMPONENT_SECRET
      - JVB_AUTH_USER
      - JVB_AUTH_PASSWORD
    networks:
      meet.jitsi:
        aliases:
          - xmpp.meet.jitsi

  jicofo:
    image: ghcr.io/jitsi/jicofo:stable-11248-3
    container_name: jitsi-jicofo
    restart: unless-stopped
    depends_on: [prosody]
    volumes:
      - ./config/jicofo:/config:Z
    environment:
      - TZ
      - ENABLE_AUTH
      - AUTH_TYPE
      - XMPP_DOMAIN
      - XMPP_AUTH_DOMAIN
      - XMPP_INTERNAL_MUC_DOMAIN
      - XMPP_MUC_DOMAIN
      - XMPP_SERVER
      - JICOFO_AUTH_USER
      - JICOFO_AUTH_PASSWORD
      - JICOFO_COMPONENT_SECRET
      - JVB_BREWERY_MUC
    networks:
      meet.jitsi:

  jvb:
    image: ghcr.io/jitsi/jvb:stable-11248-3
    container_name: jitsi-jvb
    restart: unless-stopped
    depends_on: [prosody]
    ports:
      - '10000:10000/udp'
    volumes:
      - ./config/jvb:/config:Z
    environment:
      - TZ
      - PUBLIC_URL
      - XMPP_AUTH_DOMAIN
      - XMPP_INTERNAL_MUC_DOMAIN
      - XMPP_SERVER
      - JVB_AUTH_USER
      - JVB_AUTH_PASSWORD
      - JVB_BREWERY_MUC
      - JVB_PORT
      - JVB_ADVERTISE_IPS
    networks:
      meet.jitsi:

networks:
  meet.jitsi:
  proxy:
    external: true

Drei Zeilen verdienen eine Erklärung:

  • loadbalancer.server.port=8000: Der nginx im web-Container läuft unprivilegiert und lauscht deshalb auf 8000, nicht auf 80. Trägst du 80 ein, antwortet Traefik mit 502 Bad Gateway, obwohl alle vier Container laufen.
  • DISABLE_HTTPS=1 und ENABLE_LETSENCRYPT=0: Jitsi bringt eine eigene Zertifikatsverwaltung mit, die wir nicht wollen. TLS macht Traefik.
  • ./config/prosody/data:/var/lib/prosody: Hier liegen die Benutzerkonten. Die offizielle Vorlage hängt das Verzeichnis unter config/storage/prosody ein; wer die Compose-Datei selbst zusammenstellt, vergisst es leicht. Dann ist dein Moderatorkonto nach dem nächsten docker compose down verschwunden.

Schritt 5: Verzeichnisse für den richtigen Benutzer anlegen

Die Container laufen als Benutzer s6 mit UID 1000, nicht als root. Sie schreiben ihre erzeugten Konfigurationen in die gemounteten Ordner, und das geht nur, wenn diese ihnen gehören:

Terminal
mkdir -p /opt/jitsi/config/{web,prosody/config,prosody/prosody-plugins-custom,prosody/data,jicofo,jvb}
chown -R 1000:1000 /opt/jitsi/config

Lässt du das chown weg, startet der Web-Container zwar, bleibt aber leer:

Ausgabe
cp: cannot stat '/config/.': Permission denied

In den offiziellen Beispielen fehlt der Schritt, weil dort niemand als root arbeitet: Wer die Ordner unter seinem eigenen Konto anlegt, hat die UID 1000 ohnehin. Auf einem Server, auf dem du als root in /opt arbeitest, musst du es selbst tun.

Schritt 6: Starten und prüfen

Terminal
cd /opt/jitsi
docker compose up -d
docker compose ps --format '{{ .Name }}\t{{ .Status }}'
Ausgabe
jitsi-jicofo    Up 45 seconds
jitsi-jvb       Up 45 seconds
jitsi-prosody   Up 45 seconds
jitsi-web       Up 45 seconds

Vier laufende Container heißen noch nicht, dass sie sich gefunden haben. Der Beweis dafür steht im Protokoll von jicofo, dort muss die Videobrücke auftauchen:

Terminal
docker compose logs jicofo | grep "Added new videobridge"
Ausgabe
BridgeSelector.addJvbAddress#99: Added new videobridge:
  Bridge[jid=jvbbrewery@internal-muc.meet.jitsi/07751be8e24f, version=2.3.318-gbf271b11f, ...]

Fehlt diese Zeile, reden jvb und jicofo aneinander vorbei. Meistens liegt das daran, dass die Passwörter in der .env nach dem ersten Start geändert wurden. Ob die Brücke ihre öffentliche Adresse kennt, zeigt ihr eigenes Protokoll:

Terminal
docker compose logs jvb | grep "static mapping"
Ausgabe
MappingCandidateHarvesters.initialize: Adding a static mapping:
  StaticMapping(localAddress=172.19.0.4, publicAddress=DEINE_SERVER_IP, …)

Steht dort deine öffentliche IPv4, ist JVB_ADVERTISE_IPS angekommen. Das stunDiscoveryFailed=true ein paar Zeilen darunter kannst du dann ignorieren. Anschließend prüfst du von außen die Weboberfläche und den Signalisierungspfad:

Terminal
curl -s -o /dev/null -w "%{http_code}\n" https://DEINE_DOMAIN/
curl -s -o /dev/null -w "%{http_code}\n" https://DEINE_DOMAIN/http-bind
Ausgabe
200
200

Der zweite Aufruf ist der wichtigere: /http-bind ist der Weg, über den dein Browser mit prosody spricht. Kommt hier ein 404, hat Traefik zwar die Seite, aber nicht die API durchgereicht.

Schritt 7: Das Moderatorkonto

Mit ENABLE_AUTH=1 und ENABLE_GUESTS=1 gilt: Räume eröffnen darf nur, wer sich anmeldet; mitmachen darf danach jeder mit dem Link. Ohne diese Einstellung ist deine Instanz für jeden offen, der die Adresse kennt, inklusive der Bandbreite, die dabei verbraucht wird.

Das Konto legst du direkt in prosody an:

Terminal
docker exec jitsi-prosody prosodyctl --config /run/prosody/config/prosody.cfg.lua \
  register DEIN_BENUTZERNAME meet.jitsi 'DEIN_PASSWORT'
Ausgabe
usermanager  info  User account created: DEIN_BENUTZERNAME@meet.jitsi

Beachte den Pfad: Die Konfiguration liegt zur Laufzeit unter /run/prosody/config/, nicht unter /config. Mit dem naheliegenden --config /config/prosody.cfg.lua meldet Prosody stattdessen „Prosody was unable to find the configuration file".

Die Domäne ist meet.jitsi, also die interne aus der .env und nicht deine echte. Angemeldet wird sich später trotzdem nur mit dem Benutzernamen ohne Domäne.

Schritt 8: Der erste Termin

Ruf deine Domain auf. Du landest auf der Startseite, die einen zufälligen Raumnamen vorschlägt:

Die Jitsi-Meet-Startseite mit Eingabefeld für den Raumnamen und der Schaltfläche Start meeting
Die Startseite schlägt einen zufälligen Raumnamen vor, du kannst ihn überschreiben

Der Raumname wird Teil der URL (https://DEINE_DOMAIN/Kochabend), und wer die URL kennt, kommt in den Raum. Nimm deshalb nichts Erratbares wie test oder besprechung. Nach dem Klick landest du im Vorraum, wo Jitsi Kamera und Mikrofon prüft:

Der Jitsi-Vorraum mit Namensfeld, Geräteschaltflächen und dem Hinweis Your devices are working properly
Im Vorraum trägst du deinen Namen ein (die Kamera ist hier zum Fotografieren abgeschaltet)

Jetzt kommt der Teil, der ohne Anmeldung anders aussähe. Weil noch kein Moderator im Raum ist, bleibt die Konferenz zu:

Der Dialog Waiting for a moderator mit den Schaltflächen Cancel und Log-in
Ohne Moderator startet keine Konferenz: Gäste warten, du meldest dich an

Über „Log-in" gibst du Benutzernamen und Passwort aus Schritt 7 ein. Danach bist du im Raum, mit einem „M" am eigenen Namen für „Moderator":

Ein laufender Jitsi-Raum mit Titelzeile, Zeitzähler, Teilnehmerkachel mit Moderator-Kennzeichen und der Werkzeugleiste
Im Raum: oben Name und Laufzeit, rechts die eigene Kachel mit dem M für Moderator

Ab jetzt kommen Gäste über denselben Link herein, ohne Konto. Verlässt du den Raum als letzter Moderator, ist die Konferenz beendet.

Schritt 9: Der UDP-Port

Die Weboberfläche funktioniert längst, bevor der Medienpfad steht. Deshalb fällt ein geschlossener UDP-Port erst auf, wenn mehrere Leute drin sind. Prüf, dass der Server auf 10000 lauscht:

Terminal
ss -lunp | grep 10000
Ausgabe
UNCONN 0 0 0.0.0.0:10000 0.0.0.0:* users:(("docker-proxy",pid=173295,fd=8))
UNCONN 0 0    [::]:10000    [::]:* users:(("docker-proxy",pid=173302,fd=8))

Dann öffnest du ihn, und zwar in beiden Firewalls. Auf dem Server:

Terminal
ufw allow 10000/udp comment 'Jitsi Videobridge'

Zu zweit testest du den Port gar nicht

Bei genau zwei Teilnehmern baut Jitsi eine direkte Verbindung zwischen den Browsern auf (P2P) und lässt die Videobrücke ganz außen vor. Der komplette Medienstrom eines Zweiergesprächs läuft dann über ein direktes Kandidatenpaar: Kein einziges Byte geht über UDP 10000. Erst ab dem dritten Teilnehmer übernimmt die Brücke.

Wer seine frische Instanz zu zweit ausprobiert, prüft also genau den Weg nicht, der später kaputt ist. Nimm für den Test eine dritte Person dazu oder schalte P2P vorübergehend ab. Dafür reicht ENABLE_P2P=0 in der .env nicht: Compose reicht nur die Variablen weiter, die beim Dienst unter environment stehen. Ergänz beim web-Dienst die Zeile - ENABLE_P2P, setz ENABLE_P2P=0 in die .env und starte mit docker compose up -d web neu; dann geht auch das Zweiergespräch über die Brücke. Ob es greift, zeigt curl -s https://DEINE_DOMAIN/config.js | grep -A1 "config.p2p". Dort muss enabled: false stehen.

Und im netcup SCP eine eigene Policy. Das ist der Schritt, der am häufigsten fehlt, weil Jitsi ohne ihn völlig normal aussieht: Die Weboberfläche kommt über 443 herein und ist von deiner Web-Policy längst abgedeckt, der Raum öffnet sich, die Teilnehmerliste füllt sich, und erst beim Sprechen merkt jemand, dass nichts ankommt.

Leg unter „Firewall Policys → Firewall Policy erstellen" ein Template Jitsi mit genau einer Regel an und weise es dem Server zusätzlich zu deinen bestehenden Templates zu:

Ausgabe
Richtung     EINGEHEND
Aktion       ACCEPT
Protokoll    UDP
Quell-Port   –
Ziel-Port    10000

Warum das nicht von allein geht: Die netcup-Firewall arbeitet bei UDP zustandslos. Sie merkt sich nicht, dass dein Server gerade Medien verschickt, und lässt die Antworten deshalb nicht automatisch herein. Dieser Weg braucht eine ausdrückliche Eingangs-Regel. Das Vorgehen und die Zuweisung der Templates stehen in netcup-Firewall im SCP einrichten.

Eine Firewall reicht nicht

UFW läuft auf dem Server, die netcup-Firewall davor. Die eine sieht von der anderen nichts. Wer nur eine von beiden öffnet, hat eine Videokonferenz, in der sich alle sehen können, aber niemand gehört wird, und sucht den Fehler stundenlang in der Jitsi-Konfiguration.

Wenn es nicht funktioniert

Traefik antwortet mit 502 Bad Gateway, obwohl alle vier Container laufen. Der nginx im Web-Container lauscht auf Port 8000, nicht auf 80, weil er unprivilegiert läuft. Setz traefik.http.services.jitsi.loadbalancer.server.port=8000. Nachsehen kannst du mit docker exec jitsi-web ss -lnt, dort steht der tatsächlich belegte Port. Derselbe Fehler entsteht, wenn traefik.docker.network=proxy fehlt und Traefik die Container-Adresse aus dem internen meet.jitsi-Netz erwischt, das es selbst nicht erreicht.

Der Web-Container startet, meldet aber cp: cannot stat '/config/.': Permission denied und liefert nichts aus. Die gemounteten Ordner unter /opt/jitsi/config gehören root, die Container laufen als UID 1000. Ein chown -R 1000:1000 /opt/jitsi/config und ein Neustart lösen das. Auf gehärteten Servern mit umask 027 trifft es dich garantiert, weil neu angelegte Ordner dann 0750 bekommen.

Zu zweit läuft alles, ab dem dritten Teilnehmer hört und sieht niemand mehr etwas. Das ist das typische Bild eines geschlossenen UDP-Ports. Es fällt erst jetzt auf, weil Jitsi Zweiergespräche direkt zwischen den Browsern führt und die Videobrücke erst ab drei Teilnehmern benutzt. Prüf ss -lunp | grep 10000 auf dem Server und die eingehende ACCEPT-Regel für UDP 10000 in beiden Firewalls. In den Protokollen der Brücke siehst du es ebenfalls: docker compose logs jvb | grep -i 'ICE state' zeigt dann Übergänge nach Terminated, ohne dass je eine Verbindung zustande kam.

Alle sind im Raum, aber niemand hört oder sieht jemanden. Das ist fast immer der Medienpfad, nicht die Konferenz. Prüf zuerst docker compose logs jvb | grep "static mapping". Steht dort keine Zeile mit deiner öffentlichen Adresse, fehlt JVB_ADVERTISE_IPS in der .env, und die Videobrücke meldet den Browsern ihre Container-Adresse. Stimmt die Adresse, ist der nächste Verdächtige UDP 10000 in der Firewall, und zwar in beiden (auf dem Server und beim Anbieter). Im netcup SCP ist das eine eigene Policy mit einer eingehenden ACCEPT-Regel auf UDP 10000; ein Web-Template mit 80/443 deckt das nicht mit ab.

Nach docker compose down ist das Moderatorkonto verschwunden. Prosody legt Konten unter /var/lib/prosody ab, und dieses Verzeichnis ist in der offiziellen Vorlage nicht gemountet: Mit dem Container verschwinden auch die Konten. Der Mount ./config/prosody/data:/var/lib/prosody:Z behebt das; die Konten liegen danach auf dem Host unter config/prosody/data/data/meet%2ejitsi/accounts/. Ein bereits verlorenes Konto legst du einfach neu an.

Der Dialog „Waiting for a moderator" bleibt auch nach dem Anmelden stehen. Dann existiert das Konto nicht in der Domäne, in der Jitsi es sucht. Registriert wird gegen meet.jitsi, die interne Domäne aus der .env, nicht deine echte. Prüf mit docker exec jitsi-prosody prosodyctl --config /run/prosody/config/prosody.cfg.lua register NAME meet.jitsi PASSWORT: Meldet der Befehl „User already exists", stimmt die Domäne und das Passwort ist falsch.

Dein Problem ist nicht dabei? Alle Fehlermeldungen durchsuchen →

Wartung & Backups

Updates kommen als Gesamtpaket. Jitsi gibt alle paar Wochen einen neuen stable-Tag heraus, und alle vier Images tragen denselben:

Terminal
cd /opt/jitsi
sed -i 's/stable-11248-3/stable-NEUE_VERSION/g' compose.yaml
docker compose pull && docker compose up -d
docker compose logs jicofo | grep "Added new videobridge"

Der letzte Befehl ist die Abnahme: Erscheint die Zeile nicht, hat sich beim Update etwas zwischen Steuerung und Brücke verschoben. Den aktuellen Tag findest du bei den Releases von docker-jitsi-meet, nicht auf Docker Hub; der Stand dort hinkt Monate hinterher.

Sichern musst du wenig, aber das Wenige zählt:

Ausgabe
/opt/jitsi/.env                 # die drei Geheimnisse
/opt/jitsi/config/prosody/data  # die Moderatorkonten

Alles andere unter config/ wird bei jedem Start aus den Umgebungsvariablen neu erzeugt. Eigene Änderungen an diesen Dateien sind nach dem nächsten Neustart weg. Wer wirklich etwas an der Oberfläche ändern will, legt dafür eine custom-config.js an; alles andere gehört in die .env. Beide Pfade zusammen sind ein paar Kilobyte und passen in jedes Restic-Backup.

Der Ressourcenbedarf ist zunächst unauffällig. Im Leerlauf belegt der Stack knapp 400 MB:

Ausgabe
jitsi-web       14 MB
jitsi-prosody   22 MB
jitsi-jicofo   146 MB
jitsi-jvb      191 MB

Das bleibt auch unter Last ähnlich; was wächst, ist die CPU-Last und die Bandbreite der Videobrücke. Sie leitet die Ströme weiter, ohne sie neu zu kodieren, aber jeder zusätzliche Teilnehmer bedeutet mehr Pakete. Für eine Handvoll Leute reicht ein kleiner VPS; ab etwa einem Dutzend gleichzeitiger Kameras wird die Anbindung zum Thema, nicht der Arbeitsspeicher.

Realistisch gerechnet ist es einmal im Monat der Blick auf einen neuen stable-Tag und ein Update, das zehn Minuten kostet. Dazwischen passiert nichts: Jitsi hat keine Datenbank, die wächst, und keine Medien, die sich ansammeln. Der einzige Termin, den du dir setzen solltest, ist ein kurzer Testanruf nach jedem Update, bevor der erste echte Termin ansteht.

Feedback per E-Mail: feedback@serverkueche.de

Das könnte dir auch schmecken