So installierst und erstellst du einen Chat-Server mit Matrix Synapse und Element auf Rocky Linux 9
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 ohne Probleme fortsetzen. Du kannst einen Matrix Homeserver verwenden, der von jemand anderem gehostet wird, oder deinen eigenen hosten, um die Kontrolle über deine Daten zu behalten.
In diesem Lernprogramm erfährst du, wie du einen Chatserver mit Synapse, einer Heimserver-Implementierung von Matrix, installierst und einrichtest. 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 verwenden. Wir werden auch den Coturn-Server installieren, um Sprach- und Videoanrufe zu ermöglichen. Der Coturn-Dienst ist optional, wenn 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. - Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo dnf update
- Ein paar Pakete, die dein System braucht.
$ sudo dnf install wget curl nano unzip yum-utils policycoreutils-python-utils -y
Einige dieser Pakete sind vielleicht schon auf deinem System installiert.
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. Rocky Linux verwendet die Firewalld Firewall. Überprüfe den Status der Firewall.
$ sudo firewall-cmd --state running
Die Firewall arbeitet mit verschiedenen Zonen, wobei die öffentliche Zone die Standardzone ist, die wir verwenden werden. Liste alle Dienste und Ports auf, die auf der Firewall aktiv sind.
$ sudo firewall-cmd --zone=public --list-all
Es sollte die folgende Ausgabe angezeigt werden.
public target: default icmp-block-inversion: no interfaces: enp1s0 sources: services: cockpit dhcpv6-client ssh ports: protocols: forward: yes masquerade: no forward-ports: source-ports: icmp-blocks: rich rules:
Öffne die HTTP-, HTTPS- und Synapse-Ports in der Firewall.
$ sudo firewall-cmd --zone=public --add-port=8448/tcp $ sudo firewall-cmd --zone=public --add-service=http $ sudo firewall-cmd --zone=public --add-service=https
Überprüfe erneut den Status der Firewall.
$ sudo firewall-cmd --zone=public --list-all
Du solltest eine ähnliche Ausgabe sehen.
public target: default icmp-block-inversion: no interfaces: enp1s0 sources: services: cockpit dhcpv6-client http https ssh ports: 8448/tcp protocols: forward: yes masquerade: no forward-ports: source-ports: icmp-blocks: rich rules:
Setze alle Änderungen dauerhaft um und lade die Firewall neu, um die Änderungen zu aktivieren.
$ sudo firewall-cmd --runtime-to-permanent $ sudo firewall-cmd --reload
Schritt 2 – PostgreSQL installieren und konfigurieren
Rocky Linux 9 wird standardmäßig mit PostgreSQL 13 ausgeliefert. Wir werden PostgreSQL 16 aus dem offiziellen Repository verwenden.
Installiere das PostgreSQL RPM-Repository.
$ sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm
Deaktiviere das integrierte PostgreSQL-Modul.
$ sudo dnf -qy module disable postgresql
Jetzt kannst du PostgreSQL mit dem folgenden Befehl installieren.
$ sudo dnf install -y postgresql16-server postgresql16-contrib postgresql16-devel
sudo dnf install postgresql16-devel
export PATH=$PATH:/usr/pgsql-16/bin
Das Paket postgresql-contrib enthält einige zusätzliche Hilfsprogramme.
Überprüfe die Version.
$ psql --version psql (PostgreSQL) 16.1
Initialisiere die PostgreSQL-Datenbank.
$ sudo /usr/pgsql-16/bin/postgresql-16-setup initdb Initializing database ... OK
Aktiviere den PostgreSQL-Dienst.
$ sudo systemctl enable postgresql-16
Starte den PostgreSQL-Dienst.
$ sudo systemctl start postgresql-16
Überprüfe den Status des PostgreSQL-Dienstes.
$ sudo systemctl status postgresql-16
? postgresql-16.service - PostgreSQL 16 database server
Loaded: loaded (/usr/lib/systemd/system/postgresql-16.service; enabled; preset: disabled)
Active: active (running) since Tue 2024-01-30 11:55:26 UTC; 10s ago
Docs: https://www.postgresql.org/docs/16/static/
Process: 9610 ExecStartPre=/usr/pgsql-16/bin/postgresql-16-check-db-dir ${PGDATA} (code=exited, status=0/SUCCESS)
Main PID: 9615 (postgres)
Tasks: 7 (limit: 12225)
Memory: 17.4M
CPU: 98ms
CGroup: /system.slice/postgresql-16.service
??9615 /usr/pgsql-16/bin/postgres -D /var/lib/pgsql/16/data/
??9616 "postgres: logger "
??9617 "postgres: checkpointer "
??9618 "postgres: background writer "
??9620 "postgres: walwriter "
??9621 "postgres: autovacuum launcher "
??9622 "postgres: logical replication launcher "
Jan 30 11:55:26 matrix.example.com systemd[1]: Starting PostgreSQL 16 database server...
Jan 30 11:55:26 matrix.example.com postgres[9615]: 2024-01-30 11:55:26.482 UTC [9615] LOG: redirecting log output to logging collector process
Jan 30 11:55:26 matrix.example.com postgres[9615]: 2024-01-30 11:55:26.482 UTC [9615] HINT: Future log output will appear in directory "log".
Jan 30 11:55:26 matrix.example.com systemd[1]: Started PostgreSQL 16 database server.
Du kannst sehen, dass der Dienst standardmäßig aktiviert ist und läuft.
Melde dich mit dem Systemkonto postgres an.
$ sudo -su postgres
Erstelle einen neuen Datenbankbenutzer und eine Datenbank für PostgreSQL. Beim Anlegen des Benutzers wirst du zur Eingabe eines Passworts aufgefordert.
$ createuser --pwprompt synapse $ createdb --encoding=UTF8 --locale=C --template=template0 --owner=synapse synapsedb
Beende das postgres Konto.
$ exit
Schritt 3 – Installiere Matrix Synapse
Für Matrix Synapse gibt es kein vorgefertigtes Paket für CentOS-basierte Distributionen wie Rocky Linux. Daher werden wir es als Python-Modul von PyPI installieren.
Der erste Schritt besteht darin, die Voraussetzungen zu installieren, die erforderlich sind, damit Synapse funktioniert. Außerdem benötigen wir das EPEL-Repository, das das Paket python3-virtualenv enthält.
$ sudo dnf install epel-release
$ sudo dnf install --enablerepo=crb libtiff-devel libjpeg-devel libzip-devel \
freetype-devel libwebp-devel libxml2-devel libxslt-devel \
libpq-devel python3-virtualenv libffi-devel openssl-devel \
python3-devel libicu-devel
$ sudo dnf groupinstall "Development Tools"
$ sudo dnf install postgresql16-devel
Erstelle ein Verzeichnis für Synapse.
$ mkdir -p ~/synapse
Erstelle eine virtuelle Python-Umgebung in dem besagten Verzeichnis.
$ virtualenv -p python3 ~/synapse/env
Aktiviere die virtuelle Umgebung.
$ source ~/synapse/env/bin/activate
Stelle sicher, dass du die neuesten Versionen von pip und setuptools hast.
(env) $ pip install --upgrade pip (env) $ pip install --upgrade setuptools
Installiere Matrix Synapse.
(env) $ pip install "matrix-synapse[postgres]"
Dadurch wird Synapse von PyPI heruntergeladen und zusammen mit den Python-Bibliotheken, die es verwendet, in einer virtuellen Umgebung unter dem Ordner ~/synapse/env installiert. Außerdem wird die PostgreSQL-Python-Bibliothek installiert, die Synapse für die Verbindung mit dem PostgreSQL-Server benötigt. Der obige Befehl ist eine Kombination aus den Befehlen pip install matrix-synapse und pip install psycopg2.
Der nächste Schritt besteht darin, eine Konfigurationsdatei mit einigen Grundeinstellungen zu erstellen. Wechsle in das Synapse-Verzeichnis.
(env) $ cd ~/synapse
Führe den folgenden Befehl aus, um die Konfigurationsdatei zu erstellen.
(env) $ python -m synapse.app.homeserver \
--server-name matrix.example.com \
--config-path homeserver.yaml \
--generate-config \
--report-stats=[yes|no]
Der Wert der Variable --server-name bildet einen Teil deiner Matrix-ID. Gib als Wert deinen Matrix-Domänennamen ein. Dieser dient als deine Homeserver-Adresse.
Du kannst wählen, ob du anonymisierte Statistiken über deinen Homeserver über die Variable --report-stats an Matrix zurücksenden möchtest oder nicht. Wähle yes oder no, je nachdem, was du möchtest.
Du erhältst dann die folgende Ausgabe.
Generating config file homeserver.yaml Generating log config file /home/navjot/synapse/matrix.example.com.log.config which will log to /home/navjot/synapse/homeserver.log Generating signing key file /home/navjot/synapse/matrix.example.com.signing.key A config file has been generated in 'homeserver.yaml' for server name 'matrix.example.com'. Please review this file and customise it to your needs.
Du kannst diese Einstellungen später in der Datei ~/synapse/homeserver.yaml oder /home/<username>/synapse/homeserver.yaml ändern. Mit den Schlüsseln, die durch den obigen Befehl erzeugt werden, kann sich dein Homeserver bei anderen Homeservern identifizieren.
Nun ist es an der Zeit, den Matrix-Server zu starten. Stelle sicher, dass du dich im Synapse-Verzeichnis befindest und die virtuelle Umgebung aktiv ist.
Starte den Homeserver.
(env) $ synctl start
Du solltest eine ähnliche Ausgabe sehen.
This server is configured to use 'matrix.org' as its trusted key server via the 'trusted_key_servers' config option. 'matrix.org' is a good choice for a key server since it is long-lived, stable and trusted. However, some admins may wish to use another server for this purpose. To suppress this warning and continue using 'matrix.org', admins should set 'suppress_key_server_warning' to 'true' in homeserver.yaml. -------------------------------------------------------------------------------- started synapse.app.homeserver(homeserver.yaml)
Um den Server zu stoppen, führe den folgenden Befehl aus.
(env) $ synctl stop
Deaktiviere die virtuelle Umgebung.
(env) $ deactivate
Schritt 4 – Nginx installieren
Für die Produktionsumgebung wird empfohlen, den Synapse-Server mit einem Nginx-Proxy zu betreiben.
Rocky Linux 9 wird mit einer älteren Version von Nginx ausgeliefert. Du musst das offizielle Nginx-Repository verwenden, um die neueste Version zu installieren.
Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zum Bearbeiten.
$ sudo nano /etc/yum.repos.d/nginx.repo
Füge den folgenden Code in die Datei ein.
[nginx-stable] name=nginx stable repo baseurl=http://nginx.org/packages/centos/$releasever/$basearch/ gpgcheck=1 enabled=1 gpgkey=https://nginx.org/keys/nginx_signing.key module_hotfixes=true [nginx-mainline] name=nginx mainline repo baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/ gpgcheck=1 enabled=0 gpgkey=https://nginx.org/keys/nginx_signing.key module_hotfixes=true
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Wir werden Nginx Mainline installieren, also aktiviere das Paket für Nginx.
$ sudo dnf config-manager --enable nginx-mainline
Installiere Nginx.
$ sudo dnf install nginx -y
Überprüfe die Installation.
$ nginx -v nginx version: nginx/1.25.3
Aktiviere und starte den Nginx-Serverdienst.
$ sudo systemctl enable nginx --now
Überprüfe den Status des Dienstes.
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; preset: disabled)
Active: active (running) since Tue 2024-01-30 12:50:34 UTC; 4s ago
Docs: http://nginx.org/en/docs/
Process: 10810 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 10811 (nginx)
Tasks: 3 (limit: 12225)
Memory: 3.1M
CPU: 24ms
CGroup: /system.slice/nginx.service
??10811 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??10812 "nginx: worker process"
??10813 "nginx: worker process"
Schritt 5 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Dazu verwenden wir den Snapd-Paketinstaller. Da Rocky Linux nicht mit diesem Paket ausgeliefert wird, installierst du den Snapd-Installer. Er benötigt das EPEL (Extra Packages for Enterprise Linux) Repository, um zu funktionieren. Da wir es aber bereits in Schritt 3 installiert haben, können wir direkt fortfahren.
Installiere das Snapd-Paket.
$ sudo dnf install snapd -y
Aktiviere und starte den Snap-Dienst.
$ sudo systemctl enable snapd --now
Installiere das Snap-Kernpaket und vergewissere dich, dass deine Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core $ sudo snap refresh core
Erstelle die notwendigen Links, damit Snapd funktioniert.
$ sudo ln -s /var/lib/snapd/snap /snap $ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh
Installiere Certbot.
$ sudo snap install --classic certbot
Stelle mit dem folgenden 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.8.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.
$ 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 ---------------------------------------------------------------------------------------------------------------------------------- Tue 2024-01-30 14:37:50 UTC 29min left Tue 2024-01-30 13:05:13 UTC 1h 3min ago dnf-makecache.timer dnf-makecache.service Tue 2024-01-30 15:13:00 UTC 1h 4min left - - snap.certbot.renew.timer snap.certbot.renew.service Wed 2024-01-31 00:00:00 UTC 9h left Tue 2024-01-30 06:35:44 UTC 7h ago logrotate.timer logrotate.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 – SELinux konfigurieren
SELinux verhindert, dass du einen Systemdienst ausführst, dessen Binärdatei sich im Heimatverzeichnis eines Benutzers befindet. Wenn wir also eine Dienstdatei für Synapse erstellen, wird sie von SELinux blockiert. Um dieses Problem zu umgehen, müssen wir den folgenden Befehl ausführen, damit das Python-Binary als Systemdienst ausgeführt werden kann.
$ sudo chcon -R -t bin_t /home/username/synapse/env/bin/python
Wende die Richtlinie an, um Verbindungen zu externen Hosts zuzulassen.
$ sudo setsebool -P httpd_can_network_connect 1
Wende die Richtlinie an, um Nginx den Zugriff auf PostgreSQL zu erlauben.
$ sudo setsebool -P httpd_can_network_connect_db 1
Schritt 7 – Matrix Systemd Service erstellen
Der Status des Synapse-Dienstes wird bei einem Neustart nicht gespeichert, d.h. wenn du den Server neu startest, musst du ihn manuell starten. Um dieses Problem zu umgehen, müssen wir die Systemd-Datei für den Dienst erstellen.
Vergewissere dich zunächst, dass der Synapse-Dienst gestoppt ist.
$ cd ~/synapse $ source env/bin/activate (env) $ synctl stop (env) $ deactivate
Erstelle und öffne die Datei matrix-synapse.service im Verzeichnis /etc/systemd/system/ und bearbeite sie.
$ sudo nano /etc/systemd/system/matrix-synapse.service
Füge den folgenden Code in die Datei ein. Ersetze die Variable username durch deinen Linux-Systembenutzer, unter dem du Synapse installiert hast.
# This assumes that Synapse has been installed by a user named username. # This assumes that Synapse has been installed in a virtualenv in # the user's home directory: `/home/username/synapse/env`. [Unit] Description=Synapse Matrix homeserver After=postgresql-16.service [Service] Type=notify NotifyAccess=main ExecReload=/bin/kill -HUP $MAINPID Restart=on-abort WorkingDirectory=/home/username/synapse ExecStart=/home/username/synapse/env/bin/python -m synapse.app.homeserver --config-path=/home/username/synapse/homeserver.yaml SyslogIdentifier=matrix-synapse # adjust the cache factor if necessary # Environment=SYNAPSE_CACHE_FACTOR=2.0 [Install] WantedBy=multi-user.target
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Lade den Service-Daemon neu.
$ sudo systemctl daemon-reload
Aktiviere den Matrix Synapse-Dienst.
$ sudo systemctl enable matrix-synapse
Starte den Matrix Synapse-Dienst.
$ sudo systemctl start matrix-synapse
Überprüfe den Status des Dienstes.
$ sudo systemctl status matrix-synapse
Du solltest die folgende Ausgabe sehen.
? matrix-synapse.service - Synapse Matrix homeserver
Loaded: loaded (/etc/systemd/system/matrix-synapse.service; enabled; preset: disabled)
Active: active (running) since Tue 2024-01-30 14:20:20 UTC; 5s ago
Main PID: 14687 (python)
Tasks: 8 (limit: 12225)
Memory: 77.6M
CPU: 3.527s
CGroup: /system.slice/matrix-synapse.service
??14687 /home/navjot/synapse/env/bin/python -m synapse.app.homeserver --config-path=/home/navjot/synapse/homeserver.yaml
Jan 30 14:20:16 matrix.example.com systemd[1]: Starting Synapse Matrix homeserver...
Jan 30 14:20:19 matrix.example.com matrix-synapse[14687]: This server is configured to use 'matrix.org' as its trusted key server via the
Jan 30 14:20:19 matrix.example.com matrix-synapse[14687]: 'trusted_key_servers' config option. 'matrix.org' is a good choice for a key
Jan 30 14:20:19 matrix.example.com matrix-synapse[14687]: server since it is long-lived, stable and trusted. However, some admins may
Jan 30 14:20:19 matrix.example.com matrix-synapse[14687]: wish to use another server for this purpose.
Jan 30 14:20:19 matrix.example.com matrix-synapse[14687]: To suppress this warning and continue using 'matrix.org', admins should set
Jan 30 14:20:19 matrix.example.com matrix-synapse[14687]: 'suppress_key_server_warning' to 'true' in homeserver.yaml.
Jan 30 14:20:19 matrix.example.com matrix-synapse[14687]: --------------------------------------------------------------------------------
Jan 30 14:20:20 matrix.example.com systemd[1]: Started Synapse Matrix homeserver.
Schritt 8 – Matrix Synapse konfigurieren
Bevor du fortfährst, solltest du zunächst einen geheimen Registrierungsschlüssel erstellen. 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)'" registration_shared_secret: '1y75ja0RUxvbWcS6SdZhakenukUwHHEjOXWC9Mu3FpO0QenOnpKRsc6NBZSxuzPcHYsOEuIQziwVjSZcP87dlWK4ZkIGYniurMqNsCYL4xg5xXs4bJDuTJH2CUXab4U9liv399lmkIZFaMpJCLxV9lVWB9mKHILYsjeLgGY5wAARv1SiK07bFsQOwKJGFqIvsUXmxymx5QCNDzTHw8R4ShqZ7elnnZrbdYk4r2f7qogERNHvQaRV7IEYUIOtMhVP'
Kopiere die Ausgabe in der obigen Zeile und speichere sie.
Du kannst den Matrix-Server über die Datei /home/username/synapse/homeserver.yaml konfigurieren. Öffne sie zur Bearbeitung.
$ nano ~/synapse/homeserver.yaml
Füge die Ausgabe des Befehls Registrierungsschlüssel am Ende der Datei ein.
Standardmäßig ist Synapse so konfiguriert, dass es die SQLite-Datenbank verwendet. Wir müssen die Datei bearbeiten, um PostgreSQL-Anmeldedaten hinzuzufügen.
Suche den folgenden Abschnitt in der Datei und kommentiere ihn wie gezeigt aus.
#database: # name: sqlite3 # args: # database: /home/navjot/synapse/homeserver.db
Füge den folgenden Abschnitt darunter 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
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. Füge die folgende Zeile am Ende ein.
presence: enabled: false
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
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. Um den Benutzer anzulegen, musst du die virtuelle Umgebung aktivieren.
$ cd ~/synapse $ source env/bin/activate (env) $ register_new_matrix_user -c homeserver.yaml http://localhost:8008 New user localpart [navjot]: navjot Password: Confirm password: Make admin [no]: yes Sending registration request... Success! (env) $ deactivate
Du siehst, dass wir im obigen Befehl den Port 8008 verwendet haben. Das liegt daran, dass dies der Standardport ist, auf dem Matrix Synapse lauscht.
Standardmäßig ist die Registrierung neuer Benutzer deaktiviert, was bedeutet, dass du jeden Benutzer wie oben beschrieben manuell registrieren musst. Wenn du die öffentlichen Registrierungen öffnen willst, kannst du das tun, indem du die Datei homeserver.yaml bearbeitest.
Öffne sie erneut zur Bearbeitung.
$ nano ~/synapse/homeserver.yaml
Füge die folgende Zeile am Ende ein.
enable_registration: true
In der Standardeinstellung lässt Synapse keine Anmeldungen 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
Wenn du fertig bist, 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 9 – 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;
listen [::]:443 ssl;
http2 on;
# Federation port
listen 8448 ssl default_server;
listen [::]:8448 ssl 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 10 – Coturn installieren
Um Sprach- und Videoanrufe zu ermöglichen, musst du einen Traversal Using Relays around the NAT (TURN) Server installieren. Zu diesem Zweck installieren wir das Paket Coturn. Wenn du diese Funktion nicht brauchst, kannst du diesen Schritt überspringen.
Installiere Coturn.
$ sudo dnf install coturn
Öffne die TURN- und UDP-Ports.
$ sudo firewall-cmd --zone=public --add-port=3478/{tcp,udp}
$ sudo firewall-cmd --zone=public --add-port=5349/{tcp,udp}
$ sudo firewall-cmd --zone=public --add-port=49152-65535/udp
$ sudo firewall-cmd --runtime-to-permanent
$ sudo firewall-cmd --reload
Erstelle ein SSL-Zertifikat für Turn (coturn.example.com).
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d coturn.example.com
Erstelle ein Authentifizierungsgeheimnis für Coturn.
$ echo "static-auth-secret=$(cat /dev/urandom | tr -cd '[:alnum:]' | fold -w 256 | head -n 1)" static-auth-secret=u3ksgJ9X876sFMO00A8KabXwZvzVwCmV30wWvZ7DzGiepRwNRYSCTYzf2E8olNzdDHu7oO3XpT3l5bv5mVdhXEQ3pnoTWBquSVPFFBJtyD6y9gBxiMaD2TYTD2WohQLE9s7OKJVpkDeKTnZQnkmjrFadE3M9DRxPL1W5Lgdg6XLLKABgb5XGkutRgkJOV0JRH4sBYsot63fWq9mcGTm6nAMdIycvDVDOs7vhoeqRzcTbMF0wsfAHVJNhXpGGFDyZ
Öffne die Konfigurationsdatei zum Bearbeiten.
$ sudo nano /etc/coturn/turnserver.conf
Wir werden die Datei durchgehen und die Einstellungen aktivieren, die wir brauchen. Als erstes aktivieren wir die Authentifizierungsmethode, indem wir die Zeile use-auth-secret auskommentieren.
# Be aware that use-auth-secret overrides some parts of lt-cred-mech. # The use-auth-secret feature depends internally on lt-cred-mech, so if you set # this option then it automatically enables lt-cred-mech internally # as if you had enabled both. # # Note that you can use only one auth mechanism at the same time! This is because, # both mechanisms conduct username and password validation in different ways. # # Use either lt-cred-mech or use-auth-secret in the conf # to avoid any confusion. # use-auth-secret
Als nächstes konfigurieren wir die Variable static-auth-secret mit dem Wert, den wir oben erstellt haben. Dieses Geheimnis benötigen wir später auch für die Konfiguration von Synapse.
# 'Static' authentication secret value (a string) for TURN REST API only. # If not set, then the turn server # will try to use the 'dynamic' value in the turn_secret table # in the user database (if present). The database-stored value can be changed on-the-fly # by a separate program, so this is why that mode is considered 'dynamic'. # static-auth-secret=u3ksgJ9X876sFMO00A8KabXwZvzVwCmV30wWvZ7DzGiepRwNRYSCTYzf2E8olNzdDHu7oO3XpT3l5bv5mVdhXEQ3pnoTWBquSVPFFBJtyD6y9gBxiMaD2TYTD2WohQLE9s7OKJVpkDeKTnZQnkmjrFadE3M9DRxPL1W5Lgdg6XLLKABgb5XGkutRgkJOV0JRH4sBYsot63fWq9mcGTm6nAMdIycvDVDOs7vhoeqRzcTbMF0wsfAHVJNhXpGGFDyZ
Der nächste Wert, den wir ändern müssen, ist realm. Er bezieht sich auf die Domain, die wir für Coturn ausgewählt haben.
# The default realm to be used for the users when no explicit # origin/realm relationship is found in the database, or if the TURN # server is not using any database (just the commands-line settings # and the userdb file). Must be used with long-term credentials # mechanism or with TURN REST API. # # Note: If the default realm is not specified, then realm falls back to the host domain name. # If the domain name string is empty, or set to '(None)', then it is initialized as an empty string. # realm=coturn.example.com
Als Nächstes legst du die Anzahl der Sitzungen und der Sitzungen pro Benutzer fest. Wähle einen Wert, der für deinen Server geeignet ist.
# Per-user allocation quota. # default value is 0 (no quota, unlimited number of sessions per user). # This option can also be set through the database, for a particular realm. # user-quota=12 # Total allocation quota. # default value is 0 (no quota). # This option can also be set through the database, for a particular realm. # total-quota=1200
Als nächstes müssen wir TCP deaktivieren, da VOIP über UDP läuft.
# Uncomment if no TCP relay endpoints are allowed. # By default TCP relay endpoints are enabled (like in RFC 6062). # no-tcp-relay
Außerdem müssen wir den Speicherort für die Zertifikate konfigurieren, die wir für Coturn erstellt haben.
# Certificate file. # Use an absolute path or path relative to the # configuration file. # Use PEM file format. # cert=/etc/letsencrypt/live/coturn.example.com/fullchain.pem # Private key file. # Use an absolute path or path relative to the # configuration file. # Use PEM file format. # pkey=/etc/letsencrypt/live/coturn.example.com/privkey.pem
Als Nächstes müssen wir den Verkehr zu privaten IP-Bereichen deaktivieren und Peers auf Multicast-Adressen verbieten, um die Sicherheit zu erhöhen.
# Flag that can be used to disallow peers on well-known broadcast addresses (224.0.0.0 and above, and FFXX:*). # This is an extra security measure. # no-multicast-peers ............... # Option to allow or ban specific ip addresses or ranges of ip addresses. # If an ip address is specified as both allowed and denied, then the ip address is # considered to be allowed. This is useful when you wish to ban a range of ip # addresses, except for a few specific ips within that range. # # This can be used when you do not want users of the turn server to be able to access # machines reachable by the turn server, but would otherwise be unreachable from the # internet (e.g. when the turn server is sitting behind a NAT) # # Examples: # denied-peer-ip=83.166.64.0-83.166.95.255 # allowed-peer-ip=83.166.68.45 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
Wenn du fertig bist, 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
Öffne die Synapse-Konfigurationsdatei (homeserver.yaml), um Coturn-Einstellungen hinzuzufügen.
$ nano ~/synapse/homeserver.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\coturn\turnserver.conf.
turn_uris: [ "turn:coturn.example.com?transport=udp", "turn:coturn.example.com?transport=tcp" ] turn_shared_secret: 'static-auth-secret' turn_user_lifetime: 86400000 turn_allow_guests: True # vim:ft=yaml
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 11 – 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.
Gib den Benutzernamen und das Passwort ein, die du in Schritt 8 bei der Konfiguration von Synapse erstellt hast. 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 Gruppen-Chatraum mit dem Namen HowtoForge erstellt, indem wir auf der Homepage auf die Schaltfläche Gruppen-Chat 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 12 – Element installieren
Erstelle ein Verzeichnis für Element.
$ sudo mkdir -p /var/www/html/element
Erstelle eine neue Datei, um die neueste Element-Version zu holen.
$ sudo nano /var/www/html/element/update.sh
Füge ihr die folgenden Zeilen hinzu.
#!/bin/sh
set -e
install_location="/var/www/html/element"
latest="$(curl -I https://github.com/element-hq/element-web/releases/latest | awk -F '/' '/^location/ {print substr($NF, 1, length($NF)-1)}')"
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/element-hq/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/html/element/update.sh
Führe das Skript aus, um Element herunterzuladen.
$ sudo /var/www/html/element/update.sh
Schritt 13 – Element konfigurieren
Kopiere die gleiche Element-Konfigurationsdatei.
$ sudo cp /var/www/html/element/current/config.sample.json /var/www/html/element/config.json
Öffne die Konfigurationsdatei zur Bearbeitung.
$ sudo nano /var/www/html/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;
listen [::]:443 ssl;
http2 on;
server_name element.example.com;
root /var/www/html/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
Bevor wir auf Element zugreifen können, müssen wir die SELinux-Einstellungen konfigurieren. Führe die folgenden Befehle aus, um die Ausführung von Element zu ermöglichen.
$ sudo semanage fcontext -a -t httpd_sys_rw_content_t "/var/www/html/element(/.*)?" $ sudo restorecon -Rv /var/www/html/element/
Du kannst den Element-Client über die URL https://element.example.com in deinem Browser aufrufen. Melde dich an und du gelangst zum Dashboard der App. Du wirst aufgefordert, die App zuerst mit der https://app.element.io zu verifizieren. Stelle sicher, dass du in der ursprünglichen Element-App angemeldet bist, und du wirst aufgefordert, die Emoji-Zeichen abzugleichen. 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.