Veröffentlicht in opensource.

Sichere, DSGVO-konforme Videokonferenzen mit OpenTalk

am 01.04.2026.

Sichere, DSGVO-konforme Videokonferenzen selbst hosten? OpenTalk ist eine moderne Alternative zu Jitsi oder Zoom. In diesem Guide zeigen wir Schritt für Schritt die Installation auf einem Ubuntu Server inkl. Docker Compose, Nginx Reverse Proxy und kostenlosen Let's Encrypt TLS-Zertifikaten.

Was ist OpenTalk?

Der Einsatzzweck von OpenTalk ist die Bereitstellung einer sicheren, datenschutzkonformen und quelloffenen (Open-Source) Plattform für Videokonferenzen und digitale Zusammenarbeit.

Es wurde in Deutschland (von der Heinlein Support GmbH, den Machern von mailbox.org) entwickelt, primär als europäische, datenschutzfreundliche Alternative zu großen US-amerikanischen Anbietern wie Zoom, Microsoft Teams oder Google Meet.

Wer bereits ein E-Mail Postfach bei mailbox.org hat, kann ab dem Standard Tarif OpenTalk nutzen. Alternativ kann man OpenTalk als SaaS Lösung direkt bei OpenTalk mieten. Da OpenTalk eine Open-Source Lösung ist, zeigen wir in unserer Anleitung wie man OpenTalk auf der eigenen Infrastruktur betreiben kann. So behält man die volle Kontrolle über seine Videokonferenzen.

Unterschiede zu Zoom und Microsoft Teams

OpenTalk, Zoom und Microsoft Teams bieten auf den ersten Blick alle das Gleiche an: Videotelefonie. Jedoch unterscheiden sich die drei Lösungen in der Anwendung, Architektur und im Umgang mit den Daten.

Während Zoom und Microsoft Teams auf maximale Integration und Bequemlichkeit (oft auf Kosten des Datenschutzes) setzen, ist OpenTalk auf Sicherheit, Unabhängigkeit und strukturierte Moderation fokussiert.

OpenTalk ist eine rein Browser basierte Lösung, die keine Installation von Software benötigt. Zoom und Microsoft Teams setzen voranging auf die jeweilige App.

Folgende Tabelle gibt einen guten Überblick über den Vergleich:

Eigenschaft	Zoom	Microsoft Teams	OpenTalk
Hauptzweck	Schnelle, globale Video-Meetings	Alles in einem Kollaborations Hub	Sichere, souveräne & moderierte Meetings
Datenschutz	Kritisch (US-Bezug)	Kritisch (US-Bezug)	Hervorragend (EU/DE)
Quellcode	Geschlossen	Geschlossen	Open Source
Eigenes Hosting	Nein	Nein	Ja
Stärken	Sehr einfach, viele Gimmicks	Sehr einfach, viele Gimmicks	Sicherheit, Rednerlisten, Abstimmungen

Funktionsumfang und Zielgruppe

OpenTalk bietet alle klassischen Video- und Kollaborationswerkzeuge. Es bietet dafür die typischen Werkzeuge und punktet mit zusätzlichen Funktionen für moderierte Videocalls:

Bildschirmfreigabe
Chat
Handheben
Talking Stick / Speaker Funktion
Whiteboard
Umfrage
Pause
Breakout Rooms
geplante Meetings (auch wiederkehrend)
Ad-hoc Meetings
Outlook Add-In
Aufzeichnungen der Besprechung

Sein Funktionsumfang glänzt aber vor allem dann, wenn es nicht nur um einen lockeren Plausch geht, sondern wenn Entscheidungen getroffen, Protokolle geführt, Wahlen abgehalten oder hierarchische Strukturen (Lehrer/Schüler, Vorsitzender/Gremium) digital abgebildet werden müssen.

Die Zielgruppe von OpenTalk sind alle Organisationen, die aufgrund rechtlicher Vorgaben (DSGVO), zum Schutz von Geschäftsgeheimnissen oder aus Überzeugung (Open-Source-Philosophie) keine Kompromisse bei der Sicherheit ihrer Videokommunikation eingehen dürfen oder wollen.

Fazit

Wenn ein Unternehmen tief im Microsoft-Universum steckt und Datenschutzverordnungen eher nachrangig behandelt werden, ist Teams oft gesetzt. Wer einfach nur unkompliziert mit Leuten weltweit telefonieren will, nutzt Zoom. Wer aber Wert darauf legt, dass niemand (kein Staat, kein Tech-Konzern) die Gespräche mithören oder Metadaten abgreifen kann, wer strukturierte Meetings leitet und die Kontrolle über seine IT behalten will, für den ist OpenTalk die richtige Wahl.

Installation unter Ubuntu 24.04 LTS mit Docker-Compose (OpenTalk 25.3.0)

Leider gibt es nur wenige und teilweise veraltete Informationen zur Installation von OpenTalk. Wir haben uns hauptsächlich an dem OpenTalk Setup Template, dem Migration Guide OpenTalk und einer Anleitung auf howtoforge.de orientiert.

Im Gegensatz zur offiziellen Anleitung haben wir auch das Whiteboard, Meeting Notizen, Recorder und E-Mail versandt eingerichtet.

DNS-Records anlegen

Du benötigst eine eigene Domain und musst im Vorfeld 6 x A-Records auf die IP-Adresse deines Servers konfigurieren:

talk.example.com → <DEINE-VPS-IP>
accounts.talk.example.com → <DEINE-VPS-IP>
controller.talk.example.com → <DEINE-VPS-IP>
livekit.talk.example.com → <DEINE-VPS-IP>
pad.talk.example.com → <DEINE-VPS-IP>
whiteboard.talk.example.com → <DEINE-VPS-IP>

⚠️ Achtung: Stelle sicher, dass das DNS vollständig propagiert ist. Das kann einige Minuten oder Stunden dauern, bevor du die Zertifikate mit Let's Encrypt erstellen kannst.

System aktualisieren & Pakete installieren

Verbinde dich per SSH auf deinen Server und bringe das System auf den neuesten Stand. Anschließend installieren wir die benötigten Basis-Pakete:

sudo apt-get update && sudo apt-get upgrade -y
sudo apt-get install -y pwgen git certbot ca-certificates curl gnupg apt-transport-https

Firewall (UFW) konfigurieren

Für OpenTalk müssen folgende Ports von außen erreichbar sein:

80/tcp
443/tcp
20000:40000/udp

Per UFW können wir die Ports wie folgt öffnen:

ufw allow http
ufw allow https
ufw allow 20000:40000/udp

SSL Zertifikate generieren

certbot certonly --standalone -d talk.example.com
certbot certonly --standalone -d accounts.talk.example.com
certbot certonly --standalone -d controller.talk.example.com
certbot certonly --standalone -d livekit.talk.example.com
certbot certonly --standalone -d pad.talk.example.com
certbot certonly --standalone -d whiteboard.talk.example.com

(Ersetze example.com natürlich durch deine Domain).
Die Zertifikate liegen nun im Verzeichnis /etc/letsencrypt/live/.

Docker & Docker Compose installieren

Wir nutzen das offizielle Docker-Repository für die aktuellsten Versionen:

apt install docker-compose-v2 && apt-get install docker.io -y && systemctl enable docker && systemctl start docker

OpenTalk Repository klonen

Nun laden wir das offizielle Setup-Skript herunter.

💡 Tipp: Prüfe auf GitLab, ob es eine neuere Version gibt, und passe den Branch (v25.3.0) ggf. an.

git clone --branch v25.3.0 https://gitlab.opencode.de/opentalk/ot-setup.git /opt/opentalk

Environment konfigurieren (.env)

OpenTalk speichert die Secrets und Grundeinstellungen in einer .env Datei. Glücklicherweise gibt es ein Skript, das für uns sichere Secrets Keys generiert.

Dazu wechseln wir in das OpenTalk Verzeichnis und kopieren die .env Sample Datei.

cd /opt/opentalk && cp env.sample .env

Und führen das Script zum generieren der Secrets Keys aus. Die generierten Keys kopieren wir uns in eine Textdatei, da wir diese gleich in die .env einfügen müssen.

bash extras/gen-secrets.sh

Zusätzlich müssen wir uns für LIVEKIT_KEYS_API_KEY und MINIO_ROOT_PASSWORD einen Secret Key generieren. Den ersten Key nehmen wir für LIVEKIT_KEYS_API_KEY und den zweiten Key für MINIO_ROOT_PASSWORD und kopieren uns diese auch in die Textdatei.

pwgen -s 32 1 && pwgen -s 32 1

Ganz wichtig: Kopiere die vom Skript erstellten Passwörter in die jeweiligen Felder (ohne Leerzeichen).

Nun öffnen wir die .env Datei und passe sie an.

nano .env

COMPOSE_PROFILES="core, whiteboard, pad, controller, smtp-mailer"

# Deine Haupt-Domain
OT_DOMAIN="talk.example.com"

# Secrets aus dem gen-secrets.sh Skript einfügen:
POSTGRES_PASSWORD=<dein-passwort>
KEYCLOAK_ADMIN_PASSWORD=<dein-passwort>
KEYCLOAK_CLIENT_SECRET_CONTROLLER=<dein-passwort>
LIVEKIT_KEYS_API_SECRET=<dein-passwort>
SPACEDECK_API_TOKEN=<dein-passwort>
ETHERPAD_API_KEY=<dein-passwort>

# MinIO (S3-kompatibel für Uploads/Recordings)
MINIO_ROOT_USER=opentalk
MINIO_ROOT_PASSWORD=<dein-passwort>

In die .env kopieren wir ganz ans Ende folgende Zeile:

LIVEKIT_KEYS_API_KEY="<DEIN_LIVEKIT_KEYS_API_KEY>"

Folgende Zeilen müssen in der .env auch geändert werden:

COMPOSE_PROFILES="core, whiteboard, pad, controller, smtp-mailer"
OT_DOMAIN="talk.example.com"

Controller-Konfiguration (controller.toml)

Anschließend müssen wir die Controller-Konfiguration bearbeiten. Diese finden wir im Ordner /config/controller.tom. Dafür müssen wir zunächst das Sample der controller.toml in den Ordner kopieren:

cp extras/opentalk-samples/controller.toml.sample config/controller.toml

Mit folgenden Befehlen können wir die eben generierten Secret Keys in die controller.toml einfügen:

source .env; sed -i "s/postgrespw/$POSTGRES_PASSWORD/g" config/controller.toml
source .env; sed -i "s/keycloakclientsecretforcontroller/$KEYCLOAK_CLIENT_SECRET_CONTROLLER/g" config/controller.toml
source .env; sed -i "s/livekitapisecret/$LIVEKIT_KEYS_API_SECRET/g" config/controller.toml
source .env; sed -i "s/spacedeckapitoken/$SPACEDECK_API_TOKEN/g" config/controller.toml
source .env; sed -i "s/etherpadapikey/$ETHERPAD_API_KEY/g" config/controller.toml
source .env; sed -i "s/example.com/$OT_DOMAIN/g" config/controller.toml

Das eben mittels pwgen generierte Passwort für LIVEKIT_KEYS_API_KEY müssen wir auch in die controller.toml in den Bereich [livekit] unter api_key eintragen. Dazu öffnen wir die controller.toml Datei:

nano config/controller.toml

[livekit]
api_key = "DEIN_LIVEKIT_KEYS_API_KEY"
api_secret = "<DEIN_LIVEKIT_KEYS_API_SECRET>"
public_url  = "https://livekit.talk.example.com"
service_url = "http://127.0.0.1:7880"

Recorder-Konfiguration (recorder.toml)

Für die Funktion Recorder müssen wir uns auch die Sample Konfigurationen in den Ordner /config/ kopieren:

cp extras/opentalk-samples/recorder.toml.sample config/recorder.toml

Wir generieren uns wieder einen Key für das client_secret:

pwgen -s 32 1

Dann öffnen wir die Konfigurationsdatei recorder.toml:

nano /config/recorder.toml

und ändern folgende Zeilen:

domain = "controller.talk.tech-support.cologne"
issuer = "https://accounts.talk.example.com/auth/realms/opentalk"
client_secret = "<dein-passwort>"

Wichtig: das realm muss auf opentalk geändert werden!

SMTP-MAILER-Konfiguration (smtp-mailer.toml)

Auch diese Konfigurationsdatei müssen wir aus den Samples kopieren:

cp extras/opentalk-samples/smtp-mailer.toml.sample config/smtp-mailer.toml

und anschließend öffnen:

nano /config/smtp-mailer.toml

Folgende Zeilen müssen geändert werden:

[smtp]
# SMTP Cleartext: smtp://foo:bar@my-mailserver:1234/?disable_starttls=true
# SMTP with StartTLS: smtp://foo:bar@my-mailserver:1234/
# SMTP with implicit TLS: smtps://foo:bar@my-mailserver:1234/
# smtp_server = "smtp://localhost:1025?disable_starttls=true"

smtp_server = "smtp://<deine-email-adresse>:<dein-passwort>@<dein-e-mail-server>:587/"

# Set the From email address according to the requirements of your SMTP server.
#from_name = "OpenTalk"
from_email = "<deine-email-adresse>"

Keycloak vorbereiten:

Dazu müssen wir den Keycloak realm importieren:

cp extras/keycloak-example-export.json ./data/kc_data/import

Nginx installieren & konfigurieren

sudo apt-get install -y nginx
sudo systemctl enable nginx
sudo rm -f /etc/nginx/sites-enabled/default

Damit SSL besonders sicher ist, generieren wir Diffie-Hellman-Parameter:

sudo openssl dhparam -out /etc/ssl/dhparam.pem 4096

Nginx Konfigurationen anlegen

Wir müssen nun 7 Nginx Konfigurationsdateien anlegen. Diese kopieren wir uns aus dem Ordner /opt/opentalk/extras/nginx-samples/

cp /opt/opentalk/extras/nginx-samples/snippets/sslsettings.conf.sample /etc/nginx/snippets/sslsettings.conf
cp /opt/opentalk/extras/nginx-samples/controller.conf.sample /etc/nginx/sites-available/controller.conf
cp /opt/opentalk/extras/nginx-samples/keycloak.conf.sample /etc/nginx/sites-available/keycloak.conf
cp /opt/opentalk/extras/nginx-samples/frontend.conf.sample /etc/nginx/sites-available/frontend.conf
cp /opt/opentalk/extras/nginx-samples/livekit.conf.sample /etc/nginx/sites-available/livekit.conf
cp /opt/opentalk/extras/nginx-samples/pad.conf.sample /etc/nginx/sites-available/pad.conf
cp /opt/opentalk/extras/nginx-samples/whiteboard.conf.sample /etc/nginx/sites-available/whiteboard.conf

Mit folgendem Befehl kann man in den nxingx Konfigurationsdateien die example.com austauschen:

Dabei muss in dem Befehl example.com durch die eigene Domain ersetzt werden! Das erste example bleibt stehen!

Bsp: sed -i "s/example\.com/meine-domain.de/g" /etc/nginx/sites-available/frontend.conf

sed -i "s/example\.com/example.com/g" /etc/nginx/sites-available/frontend.conf
sed -i "s/example\.com/example.com/g" /etc/nginx/sites-available/controller.conf
sed -i "s/example\.com/example.com/g" /etc/nginx/sites-available/keycloak.conf
sed -i "s/example\.com/example.com/g" /etc/nginx/sites-available/livekit.conf
sed -i "s/example\.com/example.com/g" /etc/nginx/sites-available/pad.conf
sed -i "s/example\.com/example.com/g" /etc/nginx/sites-available/whiteboard.conf

Nginx Konfiguration Dateien

Wir müssen nun jede der 6 Konfigurationsdateien öffnen und prüfen, ob folgende Zeilen durch unsere Domain korrekt ersetzt wurden:

server_name talk.example.com; (ist 2 x vorhanden)
ssl_certificate /etc/letsencrypt/live/talk.example.com/fullchain.pem;

Das machen wir hier nur exemplarisch an der frontend.conf:

nano /etc/nginx/sites-available/frontend.conf

server {
    listen 80;
    server_name talk.example.com;
    return 301 https://$host$request_uri;
}
server {
    listen 443 ssl;
    server_name talk.example.com;
    ssl_certificate     /etc/letsencrypt/live/talk.example.com/fullchain.pem; # Oder der Pfad zu deinem Single-Cert
    ssl_certificate_key /etc/letsencrypt/live/talk.example.com/privkey.pem;
    include snippets/ssl-params.conf;
    
    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Sites Konfigurationen aktivieren

Da wir die Nginx Konfiguration in sites-available hinterlegt haben, müssen wir diese per Systemlink noch in sites-enable aktivieren:

sudo ln -s /etc/nginx/sites-available/frontend.conf /etc/nginx/sites-enabled/
sudo ln -s /etc/nginx/sites-available/keycloak.conf /etc/nginx/sites-enabled/
sudo ln -s /etc/nginx/sites-available/controller.conf /etc/nginx/sites-enabled/
sudo ln -s /etc/nginx/sites-available/livekit.conf /etc/nginx/sites-enabled/
sudo ln -s /etc/nginx/sites-available/pad.conf /etc/nginx/sites-enabled/
sudo ln -s /etc/nginx/sites-available/whiteboard.conf /etc/nginx/sites-enabled/

Nun können wir die Konfiguration testen:

sudo nginx -t

wenn nginx keine Fehler findet, sollten wir folgendes sehen:

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok

und wir können nginx neustarten:

sudo systemctl restart nginx

OpenTalk starten

cd /opt/opentalk
docker compose up -d

Prüfe mit docker compose ps, ob alle Container "Up" sind. Das kann 1-2 Minuten dauern.

Den ersten Benutzer anlegen (Keycloak)

Öffne im Browser: https://accounts.talk.example.com/auth/
Logge dich mit dem User admin und dem KEYCLOAK_ADMIN_PASSWORD (aus deiner .env) ein.
Wähle oben links im Dropdown den Realm opentalk aus.
Klicke im linken Menü auf Users → Add user.
Vergib einen Benutzernamen und klicke auf Create.
Wechsle in den Reiter Credentials, vergib ein Passwort und schalte "Temporary" auf OFF.
Prüfe im Reiter Role mapping, ob die Rolle default-roles-opentalk zugewiesen ist (meist automatisch der Fall).

Wichtig! Alle Nutzer müssen einen Vor- Nachnamen, Email und Passwort haben, da es sonst einen Fehler in OpenTalk gibt.

Öffne nun https://talk.example.com und melde dich mit dem soeben in Keycloak erstellten Benutzer an.

Zertifikate automatisch erneuern (Auto-Renewal)

Damit du dich nicht alle 90 Tage um das Let's Encrypt Zertifikat kümmern musst, legen wir einen Cronjob an:

sudo crontab -e

Füge ganz unten diese Zeile ein (Prüfung täglich um 03:00 Uhr nachts):

0 3 * * * certbot renew --quiet && systemctl reload nginx

Gerne beraten wir Sie zum Einsatz, Installation und Betrieb von OpenTalk in Ihrer OnPrem Umgebung oder betreiben für Sie Ihre eigene Cloud Instanz. Nutzen Sie gerne unser Kontaktformular für eine unverbindliche Anfrage.