Eigener Jitsi-Server mit Hetzner vCloud - Tutorial

Jitsi Meet: mit eigenem Server zur daten­schutz­freundlichen Lösung für Video­kon­ferenzen [Tutorial]

 

von | 12.01.2021 | Tutorials

Hetzner + Jitsi-Meet = In 30 Minuten zur eigenen Video-Konferenz-Software

Spätestens seit Covid-19 sind Software-Lösungen für Videocalls und Videokonferenzen in aller Munde. Dabei sind speziell die großen Anbieter entsprechender Software beim Thema Datenschutz nicht immer die erste Wahl – entsprechend groß ist das Bohei seitens Anbieter und Aufsichtsbehörden. (siehe dazu: www.br.de / www.heise.de / www.computerbase.de / www.datenschutz-berlin.de)

Eine Alternative muss also her. Im Zusammenhang zwischen Videokonferenz und Datenschutz fällt oft “Jitsi” als Alternative. Jitsi ist eine quelloffene Open-Source Lösung, die neben einer Nutzung als Software as a Service (SaaS) auch die Möglichkeit anbietet, auf einem eigenen Server gehostet zu werden.

Während man sich bei der SaaS-Lösung auf den Anbieter verlassen muss, bietet die Installation auf einer eigenen Infrastruktur die Kontrolle über das Datengeschehen – klar, dass uns als Datenschutzhelden das schmeckt.

Darum haben wir uns die Installation eines eigenen Jitsi-Servers einmal im Detail angesehen und für dich ein entsprechendes Tutorial zusammengestellt. Teaser: so schlimm, wie man am Anfang denkt, ist die Installation eines eigenen Jitsi-Servers gar nicht. Mit überschaubarem Verständnis für Hosting, Server und Befehlen per Konsole lässt sich der eigene Jitsi-Server in einer knappen Stunde einrichten und in Betrieb nehmen.

Übersicht: das benötigst du für deinen eigenen Jitsi-Server

Die Anforderungen an deinen eigenen Jitsi-Server sind überschaubar. Wir haben für dich eine “Mindestkonfiguration” zusammengestellt, die neben einem stabilen Betrieb auch die wichtigsten Komfort-Funktionen mitbringt.

1. Hosting:

Du benötigst eine Server-Plattform, auf der du deinen Jitsi-Server installieren kannst. Wir haben uns dabei für die vCloud-Lösung von Hetzner entschieden. Neben Standort in der EU, einem deutschen Unternehmen als Dienstleister gib es noch ein paar Gründe, die uns die Entscheidung einfach gemacht haben: kostengünstig (ein Server für bis zu 10 Teilnehmer kostet gerade einmal knappe 3€ pro Monat) und außerdem kannst du für größere Konferenzen deinen Server mit wenigen Klicks mit mehr Leistung ausstatten und nach der Konferenz wieder “downgraden” – und zahlst dabei stundengenau lediglich die Mehrleistung.

2. Domain bzw. Subdomain

Dein Hetzner-Server ist über eine Feste IP-Adresse (z.B. 12.242.XX.XXX) erreichbar. Da dies aber recht unkomfortabel ist, empfiehlt es sich, eine Sudomain einzurichten (z.B. videocall.meine-website-xyz.de). Du solltest also Zugriff auf eine Domain haben, für die du auch Subdomains einrichten und den DNS-Eintrag anpassen kannst. In unserem Fall liegen unsere Domains bei all-inkl.com (Sponsored Link), dort lassen sich sowohl Subdamains als auch DNS-Einträge anpassen.

3. Software

Für die gesamte Installation und Anpassungen benötigst du nur zwei Programme. Ein FTP-Programm (z.B. WinSCP oder FileZilla) sowie einen Clienten für den SSH-Zugriff auf deinen Server (z.B. Putty). Am besten lädst du bereits jetzt beide Programme herunter und installierst sie auf deinem PC.

Schritt 1: Hetzner vCloud konfigurieren

Für unser Beispiel gehen wir davon aus, dass dir noch kein Server zur Verfügung steht. Darum führen wir dich kurz durch die Server-Konfiguration bei Hetzner. Hast du dort noch keinen Account, richtest du zunächst dein Benutzerkonto ein. Tipp: die Auftragsverarbeitung mit Hetzner kannst du in deinem Benutzerkonto unter “Administration” direkt online anpassen und abschließen.

Nach der Erstellung deines Accounts kannst du bereits mit der Konfiguration deines Servers beginnen. Du wählst das Podukt “Cloud” und klickst auf “Neues Projekt” – das Projekt kannst du z.B. “Jitsi” nennen. Nach einem Klick auf dein Projekt bekommst du die Meldung “Sie haben noch keine Server angelegt – Server hinzufügen”.

Server-Konfiguration im Detail:

Folgende Konfiguration reicht für kleine Jitsi-Konferenzen bis ~ 10 Teilnehmer aus.

  • Standort: “Nürnberg” “Falkenstein” “Helsinki” – hier legst du den Server-Standort fest. Unsere Empfehlung: Nürnberg oder Falkenstein.
  • Image: hier wird definiert, welches Software auf deinem Server als Betriebssystem dient. Hier wählst du “Ubuntu” in der aktuellen Version (zum Tutorial-Zeitpunkt ist das der Release 20.04.)
  • Typ: hier reicht “Standard” mit der Option “Speichertyp: Lokal” und die kleinste Hardware-Konfiguration
  • die Punkte “Volume”, “Netzwerk”, “Zusätzliche Features” und “SSH” kannst du leer lassen.
  • Hinweis SSH-Key: per SSH-Key kannst du die Verbindung zu deinem Server zusätzlich absichern. Informationen zum Erstellen und Exportieren von SSH-Keys findest du z.B. bei gridpane.com
  • Name: Last but not least musst du deinem Server unter “Name” noch einen Servernamen geben

Nach einem Klick auf “Kostenpflichtig erstellen” steht dein Server auch schon zur Verfügung. Deine Konfiguration sollte wie im folgenden Screenshot abgebildet aussehen.

Hetzner vCloud Konfiguration, Jitsi-Server

Konfiguration deines Hetzner vCloud Servers. Screenshot: hetzner.com

Schritt 2: Subdomain einrichten

Nach dem Erstellen deines Servers erhältst du eine Email von Hetzner mit deinem temporären Passwort sowie der IP-Adresse deines Servers. Um in Zukunft deinen Jitsi-Server per Domain statt per IP erreichen zu können, richten wir jetzt deine Subdomain dafür ein – wir erklären dir das am Beispiel von All-Inkl. Bei den meisten Webhostern findest du ähnliche Optionen.

Subdomain einrichten

In deiner Hosting-Administration findest du den Punkt “Subdomain”. Dort klickst du auf “Neue Subdomain anlegen”. Definiere den Namen deiner Subdomain (in unserem Beispiel “videocall”) – es ergibt sich die Adresse videocall.deine-website-xyz.de. Alle anderen Einstellungen kannst du so stehen lassen, da sie keine weitere Rolle spielen.

All-Inkl.com Subdomain einrichten

Subdomain einrichten bei All-Inkl. Screenshot: all-inkl.com

DNS-Eintrag einrichten

Damit dein Server bei Hetzner über deine Subdomain erreichbar wird, musst du einen sogenannten “DNS-Eintrag” einrichten. Klingt kompliziert – aber keine Angst, auch das ist einfach. Bei All-Inkl findest du die Option unter “Tools” – “DNS-Einstellungen”. Dort klickst du neben deiner Domain (deine-website-xyz.de) auf “Bearbeiten” und wählst dann “neuen DNS-Eintrag erstellen”.

Die Felder füllst du wie folgt aus:

  • Name: videocall
  • Typ/Prio.: A
  • Data: hier trägst du die IP-Adresse deines Servers aus der Bestätigungsmail von Hetzner ein (also z.B. 94.XXX.XXX.XXX)

Wenn du alle Angaben eingetragen hast, speicherst du deinen DNS-Eintrag und bist damit bei All-Inkl fertig.

All-Inkl.com DNS Eintrag für Jitsi einrichten

DNS-Eintrag bei All-Inkl.com für Jitsi-Server einrichten. Screenshot: all-inkl.com

Schritt 3: Mit deinem Server verbinden

So. Ran an das Eingemachte. Als nächstes musst du deinen Server für die Installation von Jitsi vorbereiten. Dazu verbindest du dich zunächst mit dem Programm Putty mit deinem Server.

  • Putty starten
  • im Feld “Hostname” trägst du die IP-Adresse deines Servers aus der Hetzner-Mail ein
  • “Open” anklicken

Die Sicherheitsmeldung von Putty bestätigst du mit “Ja”.
Jetzt öffnet sich ein Konsolenfenster mit der Abfrage “login as:”

Als Login verwendest du den Benutzer “root”. Danach möchte der Server dein Passwort haben – dieses ist in der Hetzner-Mail aufgeführt.

Geheimtipp: du kannst auch in Putty Copy-Paste verwenden. Dazu kopierst du den entsprechenden Befehl oder in diesem Fall das Passwort und klickst dann im Putty Fenster einfach Rechts. Mit Enter bestätigst du die Eingabe. Ungewohnt: der eingefügte Text wird bei Passwörtern gar nicht angezeigt – funktioniert aber wunderbar.

Nach dem Login möchte der Server als erstes, das du dein passwort änderst. Dazu gibst du nochmal das Passwort aus der Hetzner Mail ein, danach dein Neues, das du nochmal mit einer zweiten Eingabe bestätigst.

Ab jetzt hast du vollen Zugriff auf deinen Server.

Verbindung mit Putty zu deinem Hetzner-Server

Sicherheit geht vor! Erstmal Passwort ändern.

Schritt 4: Server vorbereiten & Jitsi installieren

Software-Basis etablieren

Zunächst sorgen wir dafür, dass dein Server up-to-date ist und installieren für den Betrieb von Jitsi notwendige Packages nach. Das funktioniert schnell und einfach mit folgenden Befehlen, die du jeweils nacheinander eingibst und mit “Enter” bestätigst:

sudo apt update
sudo apt upgrade
sudo apt install apt-transport-https
sudo apt-add-repository universe

Erklärung: was passiert hier? Mit dem Befehl “sudo apt update” weißt du den Server an, das installierte Software-Verzeichnis auf Aktualisierungen zu prüfen. Mit “sudo apt upgrade” führt dein Server alle vorhandenen Aktualisierungen aus. Hier erfolgt wahrscheinlich eine Info-Abfrage, dass die Installation zusätzlichen Speicher benötigt. Diese bestätigst du mit “Y” – also Ja. “Sudo apt install apt-transport-https” stellt sicher, dass alle Verbindungen per HTTPS ausgeführt werden. “Sudo apt-add-repository universe” wird geprüft, ob Ubuntu’s Universe repository zur Verfügung steht.

Als nächstes stellen wir sicher, dass OpenJDK, eine Java Plattform, die für den Betrieb von Jitsi notwendig ist, verfügbar ist. Dazu führst du folgenden Befehl aus:

sudo apt install openjdk-8-jdk

Auch hier bestätigst du die Meldung, dass zusätzlicher Speicher benötigt wird mit “Y”.

Hostname definieren

Damit dein Server weiß, “wie er heißt”, müssen wir ihm jetzt seinen Namen mitteilen. Das stellt sicher, dass dein Server unter der Subdomain, die du unter Schritt 2 definiert hast, auch erreichbar ist. Dazu verwendest du folgenden Befehl:

sudo hostnamectl set-hostname videocall.meine-website-xyz.de

Statt “videocall.meine-website-xyz.de” verwendest du natürlich die von dir definierte Subdomain ohne “www.” oder “https://”. Um zu prüfen, ob der Hostname erfolgreich gesetzt wurde, kannst du folgenden Befehl verwenden:

hostname

Zusätzlich müssen wir den Hostnamen auch in der entsprechenden Konfigurationsdatei deines Servers definieren. Dazu startest du dein FTP-Programm, wir verwenden hier WinSCP. Im Feld “Serveradresse” gibst du die IP deines Servers ein und klickst auf “Anmelden”. Die Warnung zum Rechnerschlüssel bestätigst du mit “Ja”.
Du wirst nach einem Benutzernamen gefragt (root) und anschließend nach dem zugehörigen Passwort, das du unter Schritt 3 ja geändert hast. Jetzt hast du ein Verzeichnis aller Ordner und Dateien auf deinem Server ähnlich wie im Windows-Explorer. Navigiere in den Ordner /root/etc/ und scrolle dann nach unten bis zur Datei hosts. Mit einem Doppelklick öffnet sich die Datei und du kannst sie direkt über WinSCP bearbeiten.

In der Datei “hosts” suchst du nach der Stelle, die mit 127.0.1.1 beginnt und ergänzt sie um folgende Angaben:

127.0.1.1 name-deines-servers
127.0.0.1 localhost
159.XX.XX.XXX videocall.meine-website-xyz.de

Dabei steht “159.XX.XX.XX” natürlich für die IP-Adresse deines Servers und “videocall.meine-website-xyz.de” für die Subdomain und Domain, die du eingerichtet hast. Mit einem Klick auf das “Disketten-Symbol” speicherst du deine Änderungen und kannst die Datei schließen.

Server optimieren (Zulässige Prozesse und Firewall)

Server optimieren

Damit Jitsi geschmeidig läuft, müssen ein paar Einstellungen am System optimiert werden. Dazu navigierst du per WinSCP in den Ordner /etc/systemd/ und doppelklickst die Datei system.conf.

Hier suchst du nach den drei Einträgen “DefaultLimitNOFILE”, “DefaultLimitNPROC” sowie “DefaultTasksMax” und änderst den Wert jeweils auf “65000”. Dabei entfernst du auch das “#”-Symbol vor dem jeweiligen Wert.

DefaultLimitNOFILE=65000    
DefaultLimitNPROC=65000    
DefaultTasksMax=65000

Datei speichern und schließen. Anschließend startest du die zugehörigen Prozesse mit dem Befehl “systemctl daemon-reload” neu und kannst mit folgenden Abfragen dann prüfen, ob deine Werte korrekt gesetzt wurden.

sudo systemctl daemon-reload
systemctl show --property DefaultLimitNPROC
systemctl show --property DefaultLimitNOFILE
systemctl show --property DefaultTasksMax

Firewall konfigurieren

Im nächsten Schritt bringen wir die Firewall deines Servers an den Start und konfigurieren sie für den Betrieb von Jitsi. Folgende Befehle kommen dabei zum Einsatz, die den jeweiligen Port deiner Firewall freigeben. Mit “sudo ufw enable” wird die Firewall gestartet:

sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 10000/udp
sudo ufw allow 22/tcp
sudo ufw allow 3478/udp
sudo ufw allow 5349/tcp
sudo ufw enable

Die Meldung, dass die Verbindungen unterbrochen werden (nach Eingabe des letzten Befehls), bestätigst du wieder mit “Y”. Den Status deiner Firewall kannst du mit diesem Befehl abschließend prüfen:

sudo ufw status verbose

Jitsi installieren [1]

Dein Server ist vorbereitet. Wir können jetzt mit der Installation von Jitsi starten. Dazu infomieren wir deinen Server zunächst darüber, welche Quellen ihm zur Verfügung stehen, um die Installationsdateien von Jitsi zu finden. Folgende Befehle sind dazu notwendig:

curl https://download.jitsi.org/jitsi-key.gpg.key | sh -c 'gpg --dearmor > /usr/share/keyrings/jitsi-keyring.gpg'

sowie

echo 'deb [signed-by=/usr/share/keyrings/jitsi-keyring.gpg] https://download.jitsi.org stable/' | tee /etc/apt/sources.list.d/jitsi-stable.list > /dev/null

Danach kannst du mit dem bereits bekannten Befehl “sudo apt update” prüfen, ob die Download-Quelle für Jitsi erfolgreich mitaufgenommen worden ist. Das Ergebnis sollte ähnlich wie folgt aussehen:

Jitsi Videokonferenzen auf eigenem Server

Erfolgreich den Installationsquellen hinzugefügt – Jitsi.

Jitsi installieren [2]

So. Wir sind kurz vor dem magischen Moment. Mit dem Befehl

sudo apt -y install jitsi-meet

gibst du dem Server die Info, dass er jetzt Jitsi installieren soll. Ein paar Sekunden später überrascht uns Jitsi mit seiner ersten Interaktion und möchte den Hostnamen der aktuellen Installation wissen. Dieser lautet natürlich “videocall.meine-website-xyz.de” bzw. die Adresse, die du für deinen Jitsi-Server eingerichtet hast. Wichtig: auch hier wieder ohne “www” bzw. “https”.

Jitsi Hostnamen definieren

Jetzt brauchen wir den Hostnamen deiner Jitsi-Installation

Als nächstes möchte Jitsi wissen, ob ein SSL-Zertifikat konfiguriert werden soll. Du bestätigst hier einfach die Vorauswahl “Generate a new…” mit “Ok”, da wir gleich ein kostenloses SSL-Zertifikat über Let’s Encrypt einbinden werden.

Jitsi SSL Zertifikat einbinden

Das kostenloses SSL-Zertifikat beziehen wir gleich im nächsten Schritt über Let’s Encrypt.

SSL-Zertifikat installieren

Um deinen Jitsi-Server unter einer sicheren Verbindung (also mit https) erreichbar zu machen, installieren wir als Nächstes über Let’s Encrypt ein SSL-Zertifikat. Das erledigst du (fast) vollautomatisch mit folgendem Befehl:

/usr/share/jitsi-meet/scripts/install-letsencrypt-cert.sh

Über diesen Befehl wird ein Script von Jitsi angestoßen, dass die Einrichtung deines SSL-Zertifikates startet. Um die Registrierung deines Zertifikats abzuschließen, musst du lediglich eine Email-Adresse angeben. An diese Adresse werden Infos verschickt, falls es Probleme mit dem Zertifikat geben sollte.

Nach einem kurzen Moment ist die Einbindung des Zertifikats abgeschlossen und du kannst die “Rohkonfiguration” deines Jitsi-Servers unter der von dir angegeben Adresse bewundern.

Wichtig! Wir sind noch nicht ganz fertig! In den nächsten Schritten werden wir deinen Jitsi-Server absichern! Also auf keinen Fall hier mit der Einrichtung stoppen!

Erster Blick auf den eigenen Jitsi-Server

Es lebt! Erster Blick auf deinen eigenen Jitsi-Server!

Schritt 5: Secure Domain / Authentifizierung einrichten

So, wie dein Jitsi-Server jetzt konfiguriert ist, kann jeder, der die Adresse deines Servers kennt, eine Videokonferenz eröffnen. Das wollen wir natürlich nicht so stehen lassen. Um das zu ermöglichen, richten wir jetzt einen Authentifizierungsmechanismus ein. Dann kann nur derjenige, der einen Benutzernamen und ein Passwort hat, einen Konferenzraum erstellen.

Weiterhin können natürlich Gäste an der durch einen authentifizierten Benutzer erstellten Konferenz teilnehmen. Diesen Schritt würden wir dir in jedem Fall empfehlen – außer, du hast die Absicht, deinen Jitsi-Server öffentlich für jeden zugänglich zu machen.

Prosody konfigurieren

Zunächst müssen wir dazu einen Bestandteil deines Servers, den XMPP Communication Server Prosody anpassen. Über WinSCP öffnest du die Datei videocall.meine-website-xyz.de.cfg.lua im Verzeichnis

/etc/prosody/conf.avail/

In dieser Datei änderst du im Abschnitt “VirtualHost “videocall.meine-website-xyz.de” den Wert “anonymous” zu “internal_hashed”.

Wichtig: damit sich deine Gäste anmelden können, fehlen die Angaben zur anonymen Domain, diese fügst du mit folgenden Infos hinzu:

VirtualHost "guest.videocall.meine-website-xyz.de"
    authentication = "anonymous"
    c2s_require_encryption = false
    modules_enabled = {
	"bosh";
	"pubsub";
	"turncredentials";
	"muc_lobby_rooms";
    }
    lobby_muc = "lobby.videocall.meine-website-xyz.de"
    main_muc = "conference.videocall.meine-website-xyz.de" 

Deine .cfg.lua – Datei sollte sich jetzt wie folgt lesen:

plugin_paths = { "/usr/share/jitsi-meet/prosody-plugins/" }

-- domain mapper options, must at least have domain base set to use the mapper
muc_mapper_domain_base = "videocall.meine-website-xyz.de";

turncredentials_secret = "XXXXXXXXXXXXXXXXXXXXXXX";

turncredentials = {
  { type = "stun", host = "videocall.videocall.meine-website-xyz.de", port = "3478" },
  { type = "turn", host = "videocall.videocall.meine-website-xyz.de", port = "3478", transport = "udp" },
  { type = "turns", host = "videocall.videocall.meine-website-xyz.de", port = "5349", transport = "tcp" }
};

cross_domain_bosh = false;
consider_bosh_secure = true;
-- https_ports = { }; -- Remove this line to prevent listening on port 5284

-- https://ssl-config.mozilla.org/#server=haproxy&version=2.1&config=intermediate&openssl=1.1.0g&guideline=5.4
ssl = {
  protocol = "tlsv1_2+";
  ciphers = "XXXXXXXXXXXXXXXXXXXXXXX"
}

VirtualHost "videocall.videocall.meine-website-xyz.de"
        -- enabled = false -- Remove this line to enable this host
        authentication = "internal_hashed"
        -- Properties below are modified by jitsi-meet-tokens package config
        -- and authentication above is switched to "token"
        --app_id="example_app_id"
        --app_secret="example_app_secret"
        -- Assign this host a certificate for TLS, otherwise it would use the one
        -- set in the global section (if any).
        -- Note that old-style SSL on port 5223 only supports one certificate, and will always
        -- use the global one.
        ssl = {
                key = "/etc/prosody/certs/videocall.meine-website-xyz.de.key";
                certificate = "/etc/prosody/certs/videocall.meine-website-xyz.de.crt";
        }
        speakerstats_component = "speakerstats.videocall.meine-website-xyz.de"
        conference_duration_component = "conferenceduration.videocall.meine-website-xyz.de"
        -- we need bosh
        modules_enabled = {
            "bosh";
            "pubsub";
            "ping"; -- Enable mod_ping
            "speakerstats";
            "turncredentials";
            "conference_duration";
            "muc_lobby_rooms";
        }
        c2s_require_encryption = false
        lobby_muc = "lobby.videocall.meine-website-xyz.de"
        main_muc = "conference.videocall.meine-website-xyz.de"
        -- muc_lobby_whitelist = { "recorder.videocall.meine-website-xyz.de" } -- Here we can whitelist jibri to enter lobby enabled rooms

VirtualHost "guest.videocall.meine-website-xyz.de"
    authentication = "anonymous"
    c2s_require_encryption = false
    modules_enabled = {
	"bosh";
	"pubsub";
	"turncredentials";
	"muc_lobby_rooms";
    }
    lobby_muc = "lobby.videocall.meine-website-xyz.de"
    main_muc = "conference.videocall.meine-website-xyz.de" 

Component "conference.videocall.meine-website-xyz.de" "muc"
    storage = "memory"
    modules_enabled = {
        "muc_meeting_id";
        "muc_domain_mapper";
        -- "token_verification";
    }
    admins = { "focus@auth.videocall.meine-website-xyz.de" }
    muc_room_locking = false
    muc_room_default_public_jids = true

-- internal muc component
Component "internal.auth.videocall.meine-website-xyz.de" "muc"
    storage = "memory"
    modules_enabled = {
      "ping";
    }
    admins = { "focus@auth.videocall.meine-website-xyz.de", "jvb@auth.videocall.meine-website-xyz.de" }
    muc_room_locking = false
    muc_room_default_public_jids = true

VirtualHost "auth.videocall.meine-website-xyz.de"
    ssl = {
        key = "/etc/prosody/certs/auth.videocall.meine-website-xyz.de.key";
        certificate = "/etc/prosody/certs/auth.videocall.meine-website-xyz.de.crt";
    }
    authentication = "internal_plain"

Component "focus.videocall.meine-website-xyz.de"
    component_secret = "XXXXXXXXX"

Component "speakerstats.videocall.meine-website-xyz.de" "speakerstats_component"
    muc_component = "conference.videocall.meine-website-xyz.de"

Component "conferenceduration.videocall.meine-website-xyz.de" "conference_duration_component"
    muc_component = "conference.videocall.meine-website-xyz.de"

Component "lobby.videocall.meine-website-xyz.de" "muc"
    storage = "memory"
    restrict_room_creation = true
    muc_room_locking = false
    muc_room_default_public_jids = true

Damit Jitsi versteht, was hier los ist, müssen wir auch das in der Konfiguration noch kurz festhalten. Dazu öffnest du wieder mit WinSCP die Datei “videocall.meine-website-xyz.de-config.js” im Verzeichnis “/etc/jitsi/meet/

Hier können wir auch gleich noch einige Optimierungen vornehmen.

Optimierungen

In der Datei videocall.meine-website-xyz.de-config.js musst du als erstes deine Besucher-Domain ergänzen. Dazu fügst du direkt nach “domain: ‘videocall.meine-website-xyz.de’ folgende Angaben hinzu:

anonymousdomain: 'guest.videocall.meine-website-xyz.de',

Deine Datei liest sich jetzt folgendermaßen:

/* eslint-disable no-unused-vars, no-var */

var config = {
    // Connection
    //

    hosts: {
        // XMPP domain.
        domain: 'videocall.meine-website-xyz.de',
	anonymousdomain: 'guest.videocall.meine-website-xyz.de',

        // When using authentication, domain for guest users.
        // anonymousdomain: 'guest.example.com',

        // Domain for authenticated users. Defaults to .
        // authdomain: 'videocall.meine-website-xyz.de',

        // Call control component (Jigasi).
        // call_control: 'callcontrol.videocall.meine-website-xyz.de',

        // Focus component domain. Defaults to focus..
        // focus: 'focus.videocall.meine-website-xyz.de',

        // XMPP MUC domain. FIXME: use XEP-0030 to discover it.
        muc: 'conference.<!--# echo var="subdomain" default="" -->videocall.meine-website-xyz.de'
    },

Außerdem würde ich dir empfehlen, folgende Einstellungen in dieser Datei vorzunehmen:

Testing – End to End Encryption: die beiden “//” entfernen um die End to End Encryption Funktion zu aktivieren

disableE2EE: false,

DisabelAudioLevels: die beiden “//” entfernen und den Wert auf “true” setzen. Das deaktiviert kleine blaue Punkte über dem Sprechervideo, die anzeigen, dass er gerade spricht. Hintergrund: das kostet viel Leistung, ist aber eher ein überflüssiges Feature. Die Angabe sieht jetzt so aus:

disableAudioLevels: true,

DesktopSharingFrameRate: hier kannst du wieder die “//” entfernen und den Wert “max” auf 15 erhöhen. Das sorgt für eine etwas glattere Wiedergabe geteilter Inhalte. Dein Wert sieht jetzt so aus:

// Optional desktop sharing frame rate options. Default value: min:5, max:5.
desktopSharingFrameRate: {
min: 5,
max: 15
},

Hides Lobby Button: diesem Wert nehmen wir zur Sicherheit ebenfalls seine “//”. Grundsätzlich hast du hier die Möglichkeit, den Lobby-Button in der Oberfläche von Jitsi zu deaktivieren.

Require Users to always specify a display name: diesen Wert stellen wir auf “true” (damit werden Teilnehmer aufgefordert, sich einen Namen zu geben, was gerade bei größeren Konferenzen Verwirrung vorbeugt).

enableWelcomePage sowie enableClosePage stellen wir ebenfalls auf “true”, außerdem kannst du die Systemsprache mit der Angabe “de” von Englisch auf Deutsch umstellen. Mit enableWelcomePage und enableClosePage wird den Teilnehmern vor Beginnn und nach der Videokonferenz jeweils eine allgemeine Jitsi-Seite angezeigt.

Deine Einstellungen sollten jetzt wie folgt aussehen:

 // Hides lobby button
    hideLobbyButton: false,

    // Require users to always specify a display name.
    requireDisplayName: true,

    // Whether to use a welcome page or not. In case it's false a random room
    // will be joined when no room is specified.
    enableWelcomePage: true,

    // Enabling the close page will ignore the welcome page redirection when
    // a call is hangup.
    enableClosePage: false,

    // Disable hiding of remote thumbnails when in a 1-on-1 conference call.
    // disable1On1Mode: false,

    // Default language for the user interface.
    defaultLanguage: 'de',

prejoinPageEnabled: auch bei dieser Option entfernst du die “//” und stellst den Wert auf “true”. Diese Funktion wird unter anderem dafür benötigt, dass die Namenseingabe des Besuchers sowie die Lobby-Funktion fehlerfrei funktionieren.

    // When 'true', it shows an intermediate page before joining, where the user can configure their devices.
    prejoinPageEnabled: false,

Unter dem Punkt “Privacy” haben wir noch die Möglichkeit, den Datenschutz deines Jitsi-Servers zu erhöhen:

disableThirdPartyRequests: auch bei diesem Wert entfernen wir die “//” und stellen den Wert auf “true”. Damit unterbinden wir, dass Jitsi an anderen Stellen Abrufe tätigt, wie z.B. die Abfrage eines Gravatars.

    // If third party requests are disabled, no other server will be contacted.
    // This means avatars will be locally generated and callstats integration
    // will not function.
    disableThirdPartyRequests: true,

Jicofo konfigurieren

Bei Jicofo handelt es sich um den Jitsi Conference Focus, einer Komponente von Jitsi. Dieser müssen wir noch kurz mitteilen, dass Anfragen zur Erstellung von Konferenzen nur für registrierte Nutzer zur Verfügung stehen. Dazu öffnest du wieder mit WinSCP die Datei “sip-communicator.properties” in folgendem Verzeichnis “/etc/jitsi/jicofo/“:

org.jitsi.jicofo.auth.URL=XMPP:videocall.meine-website-xyz.de

Deine Datei sieht jetzt so aus – passt alles? Dann speichern und schließen.

org.jitsi.jicofo.BRIDGE_MUC=JvbBrewery@internal.auth.videocall.meine-website-xyz.de
org.jitsi.jicofo.auth.URL=XMPP:videocall.meine-website-xyz.de

Neustart!

Mit folgendem Befehl startest du alle Jitsi-Dienste auf deinem Server neu und lädst die neue Konfiguration:

service prosody restart && service jicofo restart && service jitsi-videobridge2 restart && service nginx restart

Schritt 6: Jitsi testen

An dieser Stelle empfiehlt es sich, deine aktuelle Konfiguration zu testen. Das kannst du ganz einfach, indem du die Adresse deines Jitsi-Servers aufrufst und versuchst, eine Videokonferenz zu erstellen. Nach einem Klick auf “Neues Meeting starten” sollte jetzt eine Infobox “Warten auf den Organisator” erscheinen. Nach einem Klick auf “Ich bin der Organisator” wirst du aufgefordert, Benutzername und Passwort einzugeben. Aber… aber… Benutzername und Passwort hast du ja noch gar nicht? Richtig. Keine Panik – darum kümmern wir uns im nächsten Schritt.

Schritt 7: Jitsi-Nutzer anlegen

In Prosody können wir jetzt Nutzer anlegen und Ihnen ein Passwort zuordnen. Dazu benötigen wir wieder Putty und folgenden Befehl:

sudo prosodyctl register benutzername videocall.meine-website-xyz.de passwort

Statt “Benutername” nimmst du natürlich den zukünftigen Benutzernamen (also z.B. wernerschmid), als Passwort bitte ein sicheres Passwort. Den Befehl wiederholst du einfach für jeden Benutzer.

In 30 Minuten zum eigenen Jitsi-Server

Ab sofort steht dir dein eigener Jitsi-Server zur Verfügung. Du profitierst nicht nur von relativ günstigen Kosten (ab etwa 3€ im Monat), sondern brauchst dir auch keine Sorgen mehr um den Datenschutz bei Drittanbietern machen.

Du hast Anmerkungen zu unserem Tutorial, Verbesserungsvorschläge oder einen Fehler gefunden? Dann schreib uns gerne unter ehrensache@datenschutzhelden.eu.

Noch mehr Infos rund um Jitsi:

Weitere Infos zu Jitsi findest du unter anderem unter folgenden Links, vor allem die Beiträge Tobias Scheible (scheible.it) können wir dir ans Herz legen:

Werner Schmid, Datenschutzhelden, Regensburg

Autor

Werner Schmid arbeitet seit mehr als 10 Jahren im Bereich Online-Marketing, Consulting, Video, Web und Social Media. Seit 2020 ist er Datenschutzbeauftragter (DSB-TÜV SÜD) und Datenschutzauditor (DSA-TÜV SÜD). Neben seiner Liebe zu Marketing und Datenschutz hat er auch einen gewissen, selbst-destruktiven Hang dazu, sich bis ins Detail mit Software und Computern auseinander zu setzen. Entweder solange, bis alles so funktioniert, wie er es gerne hätte, oder solange, bis nichts mehr funktioniert.