So installierst und erstellst du einen Chat-Server mit Matrix Synapse und Element unter Debian 12
Matrix ist ein offener Standard für dezentrale und Ende-zu-Ende-verschlüsselte Kommunikation. Es ist eine Sammlung von Servern und Diensten, die über eine standardisierte API miteinander kommunizieren und sich in Echtzeit synchronisieren. Es verwendet Homeserver, um Kontoinformationen und Chatverläufe zu speichern. Wenn ein Homeserver ausfällt, können die anderen Server aufgrund der Dezentralisierung die Kommunikation problemlos fortsetzen. Du kannst entweder einen Matrix-Homeserver nutzen, der von einem anderen Anbieter gehostet wird, oder deinen eigenen hosten, um die Kontrolle über deine Daten zu behalten.
In diesem Lernprogramm lernst du, wie du einen Chatserver mit Synapse, einer Homeserver-Implementierung von Matrix, installierst und erstellst. Element ist ein Matrix-Webclient, der mit dem Matrix React SDK erstellt wurde. Damit kannst du den Matrix-Chat im Web anbieten. Du kannst den Server auch mit jedem anderen Matrix-Client deiner Wahl nutzen. Wir werden auch den Coturn-Server installieren, um Sprach- und Videoanrufe zu ermöglichen. Der Coturn-Dienst ist optional, falls du ihn nicht nutzen möchtest.
Voraussetzungen
- Ein Server, auf dem Debian 12 läuft.
- Ein Nicht-Sudo-Benutzer mit Root-Rechten.
- Die Unkomplizierte Firewall (UFW) ist aktiviert und läuft.
- Fully Qualified Domain Names(FQDN) für Matrix, Element und Coturn, die auf deinen Server zeigen. Wir werden
matrix.example.com,element.example.comundcoturn.example.comfür die drei Dienste verwenden. - Vergewissere dich, dass alles auf dem neuesten Stand ist.
$ sudo apt update && sudo apt upgrade
Schritt 1 – Firewall konfigurieren
Bevor du die Pakete installierst, musst du als erstes die Firewall so konfigurieren, dass sie die Ports für HTTP, HTTPS und Synapse öffnet.
Überprüfe den Status der Firewall.
$ sudo ufw status
Du solltest etwas wie das Folgende sehen.
Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6)
Öffne die HTTP-, HTTPS- und Synapse-Ports in der Firewall.
$ sudo ufw allow 8448 $ sudo ufw allow http $ sudo ufw allow https
Überprüfe den Status zur Bestätigung erneut.
$ sudo ufw status Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 80/tcp ALLOW Anywhere 443 ALLOW Anywhere 8448 ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) 80/tcp (v6) ALLOW Anywhere (v6) 443 (v6) ALLOW Anywhere (v6) 8448 (v6) ALLOW Anywhere (v6)
Schritt 2 – Installiere Matrix Synapse
Füge den Matrix GPG-Schlüssel hinzu.
$ sudo wget -O /usr/share/keyrings/matrix-org-archive-keyring.gpg https://packages.matrix.org/debian/matrix-org-archive-keyring.gpg
Füge das Matrix APT-Repository hinzu.
$ echo "deb [signed-by=/usr/share/keyrings/matrix-org-archive-keyring.gpg] https://packages.matrix.org/debian/ $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/matrix-org.list
Aktualisiere die Liste der System-Repositorys.
$ sudo apt update
Installiere Matrix Synapse.
$ sudo apt install matrix-synapse-py3
Während der Installation wirst du nach dem Servernamen gefragt, der Teil deiner Matrix ID ist. Gib an seiner Stelle deinen Matrix-Domänennamen ein. Dieser dient als deine Homeserver-Adresse.
Du wirst auch gefragt, ob du anonymisierte Statistiken über deinen Homeserver an Matrix senden möchtest. Gib N ein, um dies abzulehnen.
Du kannst diese Einstellungen später in der Datei /etc/matrix-synapse/conf.d/server_name.yaml ändern.
Der Dienst von Matrix Synapse wird während der Installation aktiviert und gestartet. Überprüfe den Status des Dienstes.
$ sudo systemctl status matrix-synapse
? matrix-synapse.service - Synapse Matrix homeserver
Loaded: loaded (/lib/systemd/system/matrix-synapse.service; enabled; preset: enabled)
Active: active (running) since Mon 2023-10-02 07:47:43 UTC; 1min 33s ago
Process: 1558 ExecStartPre=/opt/venvs/matrix-synapse/bin/python -m synapse.app.homeserver --config-path=/etc/matrix-synapse/homeserver.yaml --config-path=/etc/matrix-synapse/conf.d/ --generate-keys (code=>
Main PID: 1563 (python)
Tasks: 8 (limit: 2315)
Memory: 102.7M
CPU: 3.609s
CGroup: /system.slice/matrix-synapse.service
??1563 /opt/venvs/matrix-synapse/bin/python -m synapse.app.homeserver --config-path=/etc/matrix-synapse/homeserver.yaml --config-path=/etc/matrix-synapse/conf.d/
Oct 02 07:47:41 lomp matrix-synapse[1558]: Generating signing key file /etc/matrix-synapse/homeserver.signing.key
Oct 02 07:47:43 lomp matrix-synapse[1563]: This server is configured to use 'matrix.org' as its trusted key server via the
Oct 02 07:47:43 lomp matrix-synapse[1563]: 'trusted_key_servers' config option. 'matrix.org' is a good choice for a key
Oct 02 07:47:43 lomp matrix-synapse[1563]: server since it is long-lived, stable and trusted. However, some admins may
Oct 02 07:47:43 lomp matrix-synapse[1563]: wish to use another server for this purpose.
Oct 02 07:47:43 lomp matrix-synapse[1563]: To suppress this warning and continue using 'matrix.org', admins should set
Oct 02 07:47:43 lomp matrix-synapse[1563]: 'suppress_key_server_warning' to 'true' in homeserver.yaml.
Oct 02 07:47:43 lomp matrix-synapse[1563]: --------------------------------------------------------------------------------
Oct 02 07:47:43 lomp matrix-synapse[1563]: Config is missing macaroon_secret_key
Oct 02 07:47:43 lomp systemd[1]: Started matrix-synapse.service - Synapse Matrix homeserver.
Schritt 3 – PostgreSQL installieren und konfigurieren
Wir werden das offizielle APT-Repository von PostgreSQL verwenden, um die neueste Version von PostgreSQL zu installieren. Führe den folgenden Befehl aus, um den PostgreSQL GPG-Schlüssel hinzuzufügen.
$ curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /usr/share/keyrings/postgresql-key.gpg >/dev/null
Füge das APT-Repository zu deiner Quellenliste hinzu.
$ sudo sh -c 'echo "deb [signed-by=/usr/share/keyrings/postgresql-key.gpg arch=amd64] http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
Aktualisiere das System-Repository.
$ sudo apt update
Jetzt kannst du PostgreSQL mit dem folgenden Befehl installieren.
$ sudo apt install postgresql postgresql-contrib
Zum Zeitpunkt der Erstellung dieses Tutorials ist PostgreSQL 16 die neueste Version. Wenn du eine andere Version installieren möchtest, ändere den Befehl wie folgt ab und installiere stattdessen PostgreSQL 14.
$ sudo apt install postgresql-14 postgresql-contrib-14
Überprüfe den Status des PostgreSQL-Dienstes.
$ sudo systemctl status postgresql
? postgresql.service - PostgreSQL RDBMS
Loaded: loaded (/lib/systemd/system/postgresql.service; enabled; preset: enabled)
Active: active (exited) since Mon 2023-10-02 07:51:10 UTC; 13s ago
Main PID: 4001 (code=exited, status=0/SUCCESS)
CPU: 1ms
Oct 02 07:51:10 lomp systemd[1]: Starting postgresql.service - PostgreSQL RDBMS...
Oct 02 07:51:10 lomp systemd[1]: Finished postgresql.service - PostgreSQL RDBMS.
Du kannst sehen, dass der Dienst aktiviert ist und standardmäßig läuft.
Melde dich mit dem Systemkonto postgres an.
$ sudo -su postgres
Erstelle einen neuen Datenbankbenutzer und eine Datenbank für PostgreSQL.
$ createuser --pwprompt synapse $ createdb --encoding=UTF8 --locale=C --template=template0 --owner=synapse synapsedb
Beende das postgres Konto.
$ exit
Schritt 4 – Nginx installieren
Für die Produktionsumgebung wird empfohlen, den Synapse-Server mit einem Nginx-Proxy zu betreiben.
Debian 12 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.
Importiere den Signierschlüssel von Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \ | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Füge das Repository für die stabile Version von Nginx hinzu.
$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] \
http://nginx.org/packages/debian `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list
Aktualisiere die System-Repositories.
$ sudo apt update
Installiere Nginx.
$ sudo apt install nginx
Überprüfe die Installation. Da wir Debian verwenden, muss der folgende Befehl mit der Berechtigung sudo ausgeführt werden.
$ sudo nginx -v nginx version: nginx/1.24.0
Starte den Nginx-Server.
$ sudo systemctl start nginx
Überprüfe den Status des Dienstes.
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
Loaded: loaded (/lib/systemd/system/nginx.service; enabled; preset: enabled)
Active: active (running) since Mon 2023-10-02 07:59:12 UTC; 1s ago
Docs: https://nginx.org/en/docs/
Process: 5767 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 5768 (nginx)
Tasks: 2 (limit: 2315)
Memory: 1.7M
CPU: 7ms
CGroup: /system.slice/nginx.service
??5768 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??5769 "nginx: worker process"
Schritt 5 – SSL installieren
Wir müssen Certbot installieren, um kostenlose SSL-Zertifikate zu generieren, die von Let’s Encrypt angeboten werden. Du kannst Certbot entweder über das Repository von Debian installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.
Bei Debian 12 ist Snapd noch nicht installiert. Gib den folgenden Befehl ein, um Snapd zu installieren.
$ sudo apt install snapd -y
Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core $ sudo snap refresh core
Installiere Certbot.
$ sudo snap install --classic certbot
Stelle mit folgendem Befehl sicher, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link auf das Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Überprüfe die Certbot-Version.
$ certbot --version certbot 2.6.0
Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d matrix.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/matrix.example.com auf deinem Server heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Überprüfe den Certbot-Erneuerungszeitplanungsdienst.
$ sudo systemctl list-timers
Du findest snap.certbot.renew.service als einen der Dienste, die für die Ausführung vorgesehen sind.
NEXT LEFT LAST PASSED UNIT ACTIVATES ..... Mon 2023-10-02 16:33:00 UTC 8h left - - snap.certbot.renew.timer snap.certbot.renew.service Tue 2023-10-03 00:00:00 UTC 15h left - - dpkg-db-backup.timer dpkg-db-backup.service Tue 2023-10-03 00:00:00 UTC 15h left Mon 2023-10-02 07:38:16 UTC 26min ago exim4-base.timer exim4-base.service
Führe einen Probelauf des Prozesses durch, um zu prüfen, ob die SSL-Erneuerung einwandfrei funktioniert.
$ sudo certbot renew --dry-run
Wenn du keine Fehler siehst, bist du bereit. Dein Zertifikat wird automatisch erneuert.
Schritt 6 – Matrix Synapse konfigurieren
Du kannst den Matrix-Server über die Datei /etc/matrix-synapse/homeserver.yaml konfigurieren, aber das ist nicht empfehlenswert, da sie nach jedem Upgrade überschrieben wird. Für den produktiven Einsatz solltest du die Konfigurationsdateien in den Ordner /etc/matrix-synapse/conf.d legen.
Bei der Installation von Synapse wurden zwei Konfigurationsdateien im Ordner /etc/matrix-synapse/conf.d erstellt.
$ ls /etc/matrix-synapse/conf.d report_stats.yaml server_name.yaml
Erstelle eine neue Konfigurationsdatei für die Datenbank und öffne sie zur Bearbeitung.
$ sudo nano /etc/matrix-synapse/conf.d/database.yaml
Füge die folgenden Zeilen in den Editor ein. Ersetze das Feld your-password durch das PostgreSQL-Benutzerpasswort, das du in Schritt 3 erstellt hast. Ersetze localhost durch die IP-Adresse deines Servers, wenn du die Datenbank woanders hostest.
database:
name: psycopg2
args:
user: synapse
password: 'your-password'
database: synapsedb
host: localhost
cp_min: 5
cp_max: 10
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Erstelle einen geheimen Registrierungsschlüssel. Der Schlüssel sollte sicher sein, da er es jedem ermöglicht, einen neuen Benutzer zu registrieren, auch wenn die Registrierung deaktiviert ist.
$ echo "registration_shared_secret: '$(cat /dev/urandom | tr -cd '[:alnum:]' | fold -w 256 | head -n 1)'" | sudo tee /etc/matrix-synapse/conf.d/registration_shared_secret.yaml registration_shared_secret: 'vgd73p26ZDaFExpX4OPv45DsA2ZMAxiVZR7um9fBoBoFESmg5MSs68xAMUhwQ8Zn3NqcZMRSqxLeIFatppfne7xD2RHL16YfuIKmNeJ1FClQszO1SZknUVwOPyDiPe5gCCWgD9cHfa3dLTdZND5Y0SdH7GBkwYqKjibAe0JoQc8mKty3HWd6uIga3QewhtXr3b3Hpk8sr6zYpXvaBtWRHwaSWcLooqbWF8LPbSyrC0BVAKzXObUwqRGyDpkrnMiY'
Standardmäßig aktiviert Synapse Präsenzanzeigen, die anzeigen, ob eine Person online ist. Das kann zu einer hohen CPU-Belastung führen, deshalb kannst du es deaktivieren. Erstelle eine neue Konfigurationsdatei für diese Funktion.
$ sudo nano /etc/matrix-synapse/conf.d/presence.yaml
Füge die folgende Zeile in den Editor ein.
presence: enabled: false
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte den Synapse-Dienst neu, um die Änderungen zu übernehmen.
$ sudo systemctl restart matrix-synapse
Erstelle einen neuen Matrix-Benutzer. Du wirst nach deinem Benutzernamen und deinem Passwort gefragt. Da dies der erste Benutzer ist, den wir anlegen, gib yes ein, wenn du gefragt wirst, ob der Benutzer ein Administrator sein soll.
$ register_new_matrix_user -c /etc/matrix-synapse/conf.d/registration_shared_secret.yaml http://localhost:8008 New user localpart [navjot]: navjot Password: Confirm password: Make admin [no]: yes Sending registration request... Success!
Wenn du die öffentliche Registrierung öffnen willst, erstelle eine neue Konfigurationsdatei.
$ sudo nano /etc/matrix-synapse/conf.d/registration.yaml
Füge die folgenden Zeilen in diese Datei ein.
enable_registration: true
In der Standardeinstellung lässt Synapse keine Registrierungen ohne E-Mail-Verifizierung zu. Um die E-Mail-Überprüfung zu aktivieren, füge die folgenden Zeilen ein.
registrations_require_3pid: - email email: smtp_host: mail.example.com smtp_port: 587 # If mail server has no authentication, skip these 2 lines smtp_user: 'noreply@example.com' smtp_pass: 'password' # Optional, require encryption with STARTTLS require_transport_security: true app_name: 'HowtoForge Example Chat' # defines value for %(app)s in notif_from and email subject notif_from: "%(app)s <noreply@example.com>"
Um die E-Mail-Überprüfung zu deaktivieren, füge stattdessen die folgende Zeile ein.
enable_registration_without_verification: true
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte Synapse neu, um die Konfiguration zu übernehmen.
$ sudo systemctl restart matrix-synapse
Schritt 7 – Nginx konfigurieren
Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.
$ sudo nano /etc/nginx/nginx.conf
Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.
server_names_hash_bucket_size 64;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Erstelle und öffne die Datei /etc/nginx/conf.d/synapse.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/synapse.conf
Füge den folgenden Code in die Datei ein.
# enforce HTTPS
server {
# Client port
listen 80;
listen [::]:80;
server_name matrix.example.com;
return 301 https://$host$request_uri;
}
server {
server_name matrix.example.com;
# Client port
listen 443 ssl http2;
listen [::]:443 ssl http2;
# Federation port
listen 8448 ssl http2 default_server;
listen [::]:8448 ssl http2 default_server;
access_log /var/log/nginx/synapse.access.log;
error_log /var/log/nginx/synapse.error.log;
# TLS configuration
ssl_certificate /etc/letsencrypt/live/matrix.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/matrix.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/matrix.example.com/chain.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_prefer_server_ciphers on;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
resolver 1.1.1.1 1.0.0.1 [2606:4700:4700::1111] [2606:4700:4700::1001] 8.8.8.8 8.8.4.4 [2001:4860:4860::8888] [2001:4860:4860::8844] valid=60s;
resolver_timeout 2s;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
tcp_nopush on;
gzip on;
location ~ ^(/_matrix|/_synapse/client) {
proxy_pass http://localhost:8008;
proxy_http_version 1.1;
proxy_set_header X-Forwarded-For $remote_addr;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header Host $host;
# Nginx by default only allows file uploads up to 1M in size
# Increase client_max_body_size to match max_upload_size defined in homeserver.yaml
client_max_body_size 50M;
}
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Bei der obigen Konfiguration wird davon ausgegangen, dass die IP-Adressen der Domänen example.com und matrix.example.com auf denselben Server verweisen. Wenn das nicht der Fall ist, musst du die folgende Konfigurationsdatei für den Server example.com verwenden.
server {
server_name example.com;
listen 443 ssl http2;
listen [::]:443 ssl http2;
# TLS configuration
ssl_certificate /etc/letsencrypt/live/matrix.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/matrix.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/matrix.example.com/chain.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_prefer_server_ciphers on;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
resolver 1.1.1.1 1.0.0.1 [2606:4700:4700::1111] [2606:4700:4700::1001] 8.8.8.8 8.8.4.4 [2001:4860:4860::8888] [2001:4860:4860::8844] valid=60s;
resolver_timeout 2s;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
# Redirect
location ~ ^(/_matrix|/_synapse/client) {
return 301 "https://matrix.example.com$request_uri";
}
# Client homeserver autodiscovery
location /.well-known/matrix/client {
default_type application/json;
add_header Access-Control-Allow-Origin *;
return 200 '{ "m.homeserver": { "base_url": "https://matrix.example.com" } }';
}
# Domain delegation
location /.well-known/matrix/server {
default_type application/json;
add_header Access-Control-Allow-Origin *;
return 200 '{ "m.server": "matrix.example.com" }';
}
}
Überprüfe die Syntax der Nginx-Konfigurationsdatei.
$ sudo nginx -t nginx: the configuration file /etc/nginx/nginx.conf syntax is ok nginx: configuration file /etc/nginx/nginx.conf test is successful
Starte den Nginx-Dienst neu.
$ sudo systemctl restart nginx
Schritt 8 – Coturn installieren
Du musst einen Traversal Using Relays around the NAT (TURN) Server installieren, um Sprach- und Videoanrufe zu ermöglichen. Zu diesem Zweck installieren wir das Paket Coturn. Wenn du diese Funktion nicht brauchst, kannst du diesen Schritt überspringen.
Installiere Coturn.
$ sudo apt install coturn
Öffne die TURN- und UDP-Ports.
$ sudo ufw allow 3478 $ sudo ufw allow 5349 $ sudo ufw allow 49152:65535/udp
Erstelle ein SSL-Zertifikat für Turn (turn.example.com).
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d turn.example.com
Erstelle ein Authentifizierungsgeheimnis und speichere es in der Konfigurationsdatei.
$ echo "static-auth-secret=$(cat /dev/urandom | tr -cd '[:alnum:]' | fold -w 256 | head -n 1)" | sudo tee /etc/turnserver.conf static-auth-secret=OcKBLuwpE6IyMoi9mPccjVFaL7PwJRFUuKh5EvGBVcvB7tunevQ3cpP74we8cF4XSN8lFNrgqxJeyItKOcoOABwjdTNChmJeB4WMrsLV2JNsPs3U61s9rRijj3OxBpZux0CGft8CiyNDweVLqqxNaYphNesoAT4y51RxLVdAP2ros9S3jRR7IYRccJVRMpqTa8USBuBqAkzRRPLbFOHsC6QHur2oiySuW6sqs4YkH65N8kReSzgi7Fq2Zll3RO5e
Öffne die Konfigurationsdatei zum Bearbeiten.
$ sudo nano /etc/turnserver.conf
Füge die folgenden Zeilen unter dem Authentifizierungsgeheimnis in die Datei ein.
use-auth-secret realm=turn.example.com cert=/etc/letsencrypt/live/turn.example.com/fullchain.pem pkey=/etc/letsencrypt/live/turn.example.com/privkey.pem # VoIP is UDP, no need for TCP no-tcp-relay # Do not allow traffic to private IP ranges no-multicast-peers denied-peer-ip=0.0.0.0-0.255.255.255 denied-peer-ip=10.0.0.0-10.255.255.255 denied-peer-ip=100.64.0.0-100.127.255.255 denied-peer-ip=127.0.0.0-127.255.255.255 denied-peer-ip=169.254.0.0-169.254.255.255 denied-peer-ip=172.16.0.0-172.31.255.255 denied-peer-ip=192.0.0.0-192.0.0.255 denied-peer-ip=192.0.2.0-192.0.2.255 denied-peer-ip=192.88.99.0-192.88.99.255 denied-peer-ip=192.168.0.0-192.168.255.255 denied-peer-ip=198.18.0.0-198.19.255.255 denied-peer-ip=198.51.100.0-198.51.100.255 denied-peer-ip=203.0.113.0-203.0.113.255 denied-peer-ip=240.0.0.0-255.255.255.255 denied-peer-ip=::1 denied-peer-ip=64:ff9b::-64:ff9b::ffff:ffff denied-peer-ip=::ffff:0.0.0.0-::ffff:255.255.255.255 denied-peer-ip=100::-100::ffff:ffff:ffff:ffff denied-peer-ip=2001::-2001:1ff:ffff:ffff:ffff:ffff:ffff:ffff denied-peer-ip=2002::-2002:ffff:ffff:ffff:ffff:ffff:ffff:ffff denied-peer-ip=fc00::-fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff denied-peer-ip=fe80::-febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff # Limit number of sessions per user user-quota=12 # Limit total number of sessions total-quota=1200
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte Coturn neu, um die Konfiguration zu übernehmen.
$ sudo systemctl restart coturn
Erstelle eine neue Synapse-Konfigurationsdatei für Coturn.
$ sudo nano /etc/matrix-synapse/conf.d/turn.yaml
Füge die folgenden Zeilen in die Datei ein. Ersetze den Wert von turn_shared_secret durch den Wert von static-auth-secret aus der Datei \etc\turnserver.conf.
turn_uris: [ "turn:turn.example.com?transport=udp", "turn:turn.example.com?transport=tcp" ] turn_shared_secret: 'static-auth-secret' turn_user_lifetime: 86400000 turn_allow_guests: True
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte Synapse neu, um die Änderungen zu übernehmen.
$ sudo systemctl restart matrix-synapse
Schritt 9 – Zugriff auf Matrix
Du kannst auf den Matrix-Chat über den Web-Client von Element unter https://app.element.io zugreifen. Klicke auf die Schaltfläche Anmelden, um fortzufahren.
Klicke auf den Link Bearbeiten unter Homeserver. Gib matrix.example.com als deinen Homeserver ein.
Wenn der Client deinen Homeserver richtig erkennt, werden die Begrenzung und der Text grün, andernfalls wird er rot angezeigt. Klicke auf Weiter, um fortzufahren.
Klicke auf die Schaltfläche Anmelden, um dich einzuloggen. Du wirst aufgefordert, ein sicheres und verschlüsseltes Backup zu erstellen.
Wähle die Option Sicherheitsphrase eingeben, um eine Sicherheitsphrase zu erstellen, die bei jeder Anmeldung verlangt wird. Klicke auf Weiter, um fortzufahren.
Gib eine Sicherheitsphrase ein und klicke auf “ Weiter „, um fortzufahren. Auf dem nächsten Bildschirm wirst du erneut aufgefordert, die Eingabe zu bestätigen.
Gib die Phrase erneut ein und klicke auf Weiter, um fortzufahren.
Du erhältst eine Reihe von Sicherheitsschlüsseln, die du verwenden kannst, wenn du deine Sicherheitsphrase vergessen hast. Klicke auf die Schaltfläche Herunterladen, um sie zu speichern.
Klicke auf die Schaltfläche Weiter, um fortzufahren.
Du wirst nach dem Passwort für dein Konto gefragt. Gib das Passwort ein und klicke auf die Schaltfläche Weiter, um die verschlüsselte Datensicherung einzurichten.
Wir haben einen Gruppenchatraum mit dem Namen HowtoForge eingerichtet, indem wir auf der Homepage auf die Schaltfläche Gruppenchat erstellen geklickt haben. Wenn du auf die Schaltfläche klickst, wird das folgende Popup-Fenster angezeigt.
Du kannst die Mitglieder auf die Domäne beschränken, indem du das erweiterte Menü erweiterst und die Option auswählst. Beende die Erstellung des Raums, indem du auf die Schaltfläche Raum erstellen klickst.
Schritt 10 – Element installieren
Installiere das Paket jq, um den JSON-Textprozessor zu installieren. Wir werden es benutzen, um die neueste Version von Element aus dem GitHub-Repository zu holen, so dass du die Versionsnummern nicht manuell hinzufügen musst und es mit einem einzigen Befehl aktualisieren kannst.
$ sudo apt install jq
Erstelle ein Verzeichnis für Element.
$ sudo mkdir -p /var/www/element
Erstelle eine neue Datei zum Abrufen der neuesten Element-Version.
$ sudo nano /var/www/element/update.sh
Füge die folgenden Zeilen hinzu.
#!/bin/sh
set -e
install_location="/var/www/element"
latest="$(curl -s https://api.github.com/repos/vector-im/element-web/releases/latest | jq -r .tag_name)"
cd "$install_location"
[ ! -d "archive" ] && mkdir -p "archive"
[ -d "archive/element-${latest}" ] && rm -r "archive/element-${latest}"
[ -f "archive/element-${latest}.tar.gz" ] && rm "archive/element-${latest}.tar.gz"
wget "https://github.com/vector-im/element-web/releases/download/${latest}/element-${latest}.tar.gz" -P "archive"
tar xf "archive/element-${latest}.tar.gz" -C "archive"
[ -L "${install_location}/current" ] && rm "${install_location}/current"
ln -sf "${install_location}/archive/element-${latest}" "${install_location}/current"
ln -sf "${install_location}/config.json" "${install_location}/current/config.json"
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Mache die Datei ausführbar.
$ sudo chmod +x /var/www/element/update.sh
Führe das Skript aus, um Element herunterzuladen.
$ sudo /var/www/element/update.sh
Schritt 11 – Element konfigurieren
Kopiere die gleiche Element-Konfigurationsdatei.
$ sudo cp /var/www/element/current/config.sample.json /var/www/element/config.json
Öffne die Konfigurationsdatei zur Bearbeitung.
$ sudo nano /var/www/element/config.json
Suche die folgenden Zeilen.
"m.homeserver": {
"base_url": "https://matrix-client.matrix.org",
"server_name": "matrix.org"
},
Ändere die Standardadresse des Matrix Homeservers in deinen Homeserver und entferne die Variable server_name.
"m.homeserver": {
"base_url": "https://matrix.example.com",
"server_name": "example.com"
},
Wenn du deinen Namen anstelle von Element im Titel der Website verwenden willst, ändere den Markennamen.
"brand": "HowtoForge Example Chat",
Setze die Variable disable_guests auf true, um zu verhindern, dass Gäste Element benutzen.
"disable_guests": true,
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Erstelle ein SSL-Zertifikat für den Element-Client.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d element.example.com
Erstelle und öffne die Datei /etc/nginx/conf.d/element.conf zur Bearbeitung.
$ sudo nano /etc/nginx/conf.d/element.conf
Füge die folgenden Zeilen in die Datei ein.
server {
listen 80;
listen [::]:80;
server_name element.example.com;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name element.example.com;
root /var/www/element/current;
index index.html;
access_log /var/log/nginx/element.access.log;
error_log /var/log/nginx/element.error.log;
add_header Referrer-Policy "strict-origin" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-Frame-Options "SAMEORIGIN" always;
# TLS configuration
ssl_certificate /etc/letsencrypt/live/element.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/element.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/element.example.com/chain.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_prefer_server_ciphers on;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
resolver 1.1.1.1 1.0.0.1 [2606:4700:4700::1111] [2606:4700:4700::1001] 8.8.8.8 8.8.4.4 [2001:4860:4860::8888] [2001:4860:4860::8844] valid=60s;
resolver_timeout 2s;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Überprüfe die Syntax der Nginx-Konfigurationsdatei.
$ sudo nginx -t nginx: the configuration file /etc/nginx/nginx.conf syntax is ok nginx: configuration file /etc/nginx/nginx.conf test is successful
Starte den Nginx-Dienst neu.
$ sudo systemctl restart nginx
Du kannst den Element-Client über die URL https://element.example.com in deinem Browser aufrufen. Logge dich ein und du gelangst zum Dashboard der App. Du wirst aufgefordert, die App zunächst mit der https://app.element.io zu verifizieren. Vergewissere dich, dass du in der Original-Element-App angemeldet bist, und du wirst aufgefordert, die Emoji-Zeichen zuzuordnen. Sobald du verifiziert bist, erhältst du das folgende Dashboard.
Fazit
Damit ist unsere Anleitung zur Installation des Matrix Synapse Chat-Servers zusammen mit Coturn und dem Element Web-Client unter Verwendung von Nginx als Proxy-Server auf einem Debian 12 Rechner abgeschlossen. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.