Matrix Synapse Server auf einem Raspberry Pi4B 4GB installieren

Mit dieser Anleitung kann man auf einem Raspberry-Pi-4-Modell-B-4GB den Server Synapse von Matrix installieren

Ich übernehme keine Verantwortung für die Richtigkeit dieser Anleitung, sie ist nur eine Mitschrift der Installation meines eigenen Matrix Servers. Die Verwendung dieser Anleitung ist deshalb auf eigene Gefahr.

Hardware
PC mit Linux (in diesem Beispiel Linux Mint)
rPI4B (4 GB)
16 GB SD Karte
Adapter von SD Micro auf SD
Ein USB Medium für die Daten (muss nicht unbedingt sein)

Diese Konstellation sollte bis zu 20 Accounts verkraften können.

Was braucht man sonst noch
Eine Domain bei einem Anbieter, der DynDNS kann.
Einen Router, der DynDNS kann.
Was ist Dynamic DNS? Wofür brauche ich DynDNS?
Alternativer Link ohne Tracker

Definitionen
User: username (durch den eigenen Linux User ersetzen)
Domain: meinedomain.de (durch die eigene Domain ersetzen)

Folgende Ports müssen für die interne IP des rPI4 offen sein
HTTPS-Server: 8448
HTTPS-Server: 443

FRITZBox Portfreigaben. Was sind Portweiterleitungen?
Alternativer Link ohne Tracker

Aktuell gibt es noch ein Problem mit großen Räumen, deshalb solltet ihr euren Usern mitteilen, dass sie mit ihrem Account erst mal nicht versuchen, Mitglied in großen öffentlichen Räumen zu werden.

Warum ARCH Linux?
Ihr solltet Synapse unbedingt mit einem Paketmanager unter Linux installieren, da nur so sichergestellt ist, dass zukünftig alle Updates auch sicher und sauber installiert werden. Nach meinem Wissen bietet aktuell nur ArchLinux so ein Paket für ARM Computer an.

Diese Version von ArchLinux werden wir installieren:
https://archlinuxarm.org/platforms/armv8/broadcom/raspberry-pi-4

Hier stehen die offiziellen Anleitungen von Matrix zu Synapse https://matrix.org/docs/guides/installing-synapse

Ich empfehle direkt ein 256 GB USB Medium zu verwenden, da man mit Synapse aktuell keine alten Daten löschen kann, der Server wird also über kurz oder lang stark anwachsen.

Installation von ARCH Linux

fdisk -lu (alle Partitionen anzeigen lassen)

So heißt die SD Karte bei mir unter Ubuntu bzw. Linux Mint
mmcblk0: Das ist der Name der Karte selbst
mmcblk0p1: p1 ist de Name der ersten Partition

Im ersten Schritt muss die SD Karte vorbereitet werden (im Beispiel eine 16 GB Karte). Hierzu öffnen wir in Linux das Terminal [STRG]-[ALT]-[T] und geben folgenden Befehle ein:
sudo -s (danach muss man das Passwort vom root User eingeben)

Starten von fdsk zum Partitionieren der SD Karte
fdisk /dev/mmcblk0

At the fdisk prompt, delete old partitions and create a new one:

  1. Type o. This will clear out any partitions on the drive.
  2. Type p to list partitions. There should be no partitions left.
  3. Type n, then p for primary, 1 for the first partition on the drive, press ENTER to accept the default first sector, then type +100M for the last sector.
  4. Type t, then c to set the first partition to type W95 FAT32 (LBA).
  5. Type n, then p for primary, 2 for the second partition on the drive, and then press ENTER twice to accept the default first and last sector.
  6. Write the partition table and exit by typing w.

Prüfen wo man ist, damit man nicht das lokale System überschreibt

Create and mount the FAT filesystem:
mkfs.vfat /dev/mmcblk0p1
mkdir boot
mount /dev/mmcblk0p1 boot

Create and mount the ext4 filesystem:
mkfs.ext4 /dev/mmcblk0p2
mkdir root
mount /dev/mmcblk0p2 root

Download and extract the root filesystem (as root, not via sudo):
wget http://os.archlinuxarm.org/os/ArchLinuxARM-rpi-4-latest.tar.gz
apt install libarchive-tools
bsdtar -xpf ArchLinuxARM-rpi-4-latest.tar.gz -C root
sync

Move boot files to the first partition:
mv root/boot/* boot

Unmount the two partitions:
umount boot root

Jetzt die SD Karte in den rPI4 stecken, das LAN Kabel anschließen und den rPI4 starten (Netzteil anschließen).

Dann meldet ihr euch im Terminal von Linux mit dem alarm User bei dem Raspberry an. Hierzu müsst ihr euch über euren Router die IP Adresse heraussuchen, die dem Raspberry zugewiesen wurde. Falls euer Router die Möglichkeit hat, die IP für immer fest zuzuordnen, dann solltet ihr das dabei gleich mit machen.
ssh alarm@IP-des-Raspi

Erst mal erstellen wir ein neues Passwort, der Default ist alarm.
passwd (danach das neue Passwort von alarm eingeben)

Jetzt machen wir uns zum Admin (User root) und erstellen wieder ein neues Passwort (Default ist root).
su
passwd (danach das neue Passwort von root eingeben)

Jetzt müsste euer User [root@alarmpi alarm] heißen.

Danach muss der Paketdienst von ARCH Linux initialisiert werden, mit dem man Programme installieren kann. Das machen wir, damit wir erst mal alles auf den neuesten Stand bringen können.
pacman-key --init
pacman-key --populate archlinuxarm

Das System aktualisieren
pacman -Syu

USB Medium einrichten
Das USB Medium einstecken (wenn es ein USB3 Meddium ist, dann in die blauen Buchsen).
fdisk -lu (alle Partitionen anzeigen lassen). Bei mir heißt der Medium sda. fdisk /dev/sda
o (alle Partationen löschen)
p (anzeigen ob alle Partitionen weg sind)
n (neue Partition anlegen)
p (Primäre Partition auswählen)
1 (1. Partition auswählen)
Enter (Anfang übernehmen)
Enter (Ende übernehmen)
Y (Sigantur entfernen)
W (ausführen)

mkfs.ext4 /dev/sda1
mkdir /mnt/matrix
mount /dev/sda1 /mnt/matrix

Das USB Medium muss bei jedem Systemstart automatisch gemountet werden, deshalb müssen wir sie in die Datei fstab eintragen

blkid (UUID der USB Platte suchen).
nano /etc/fstab
folgende Zeile einfügen
UUID=a8c61cae-035d-499f-a13c-796c15fe8006 /mnt/matrix auto rw,nouser 0 0
mount -a (ausführen)

Jetzt erstellen wir die Verzeichnisse auf dem USB Medium
cd /mnt/matrix
mkdir synapse
cd synapse
mkdir media_store
mkdir uploads

ls (zum prüfen was passiert ist)

Zugriff auf die neuen Ordner freigeben (maximal: alle Programme dürfen zugreifen):
chmod 777 /mnt/matrix/synapse
chmod 777 /mnt/matrix/synapse/media_store
chmod 777 /mnt/matrix/synapse/uploads

Oder so, mit minimalem Zugriff auf die neuen Ordner
chown root:root /mnt/matrix
chmod 755 /mnt/matrix
chown -R synapse:root /mnt/matrix/synapse
find /mnt/matrix/synapse -type d -exec chmod 750 {} ;
find /mnt/matrix/synapse -type f -exec chmod 640 {} ;

Es ist empfehlenswert, das USB Medium vollständig per dm-crypt zu verschlüsseln.

Zertifikate besorgen
Wir besorgen uns Zertifikate bei Let’s Encrypt, hierzu müssen wir Certbot installieren.
pacman -S certbot

Jetzt müsst ihr für den rPI die beiden Ports 80 und 443 öffnen. Wenn die beiden Ports offen sind, könnt ihr mit dem nachfolgenden Befehl ein Zertifikat erstellen.

certbot certonly --rsa-key-size 4096 --standalone --agree-tos --no-eff-email --email deine.mail@domain.de -d meinedomain.de

In dem Verzeichnis /etc/letsencrypt/live/meinedomain.de wurden folgende Dateien erstellt:
@cert.pem
@chain.pem
@fullchain.pem
@privkey.pem

Danach kann der Port 80 wieder geschlossen werden.

Jetzt installieren wir den Webserver nginx
pacman -S nginx

Folgende Konfiguration in die Datei /etc/nginx/nginx.conf einfügen
nano /etc/nginx/nginx.conf

worker_processes  1;
events {worker_connections  1024;}
http {
    include       mime.types;
    default_type  application/octet-stream;
    # Diese Zeile schaltet das Accesslog aus
    access_log /dev/null;
    sendfile        on;
    keepalive_timeout  65;
    client_max_body_size 100M;
server {
    listen 443 ssl;
    listen [::]:443 ssl;
    server_name meinedomain.de;
    client_max_body_size 100m;
ssl_certificate      /etc/letsencrypt/live/meinedomain.de/fullchain.pem;
ssl_certificate_key  /etc/letsencrypt/live/meinedomain.de/privkey.pem;
ssl_session_cache    shared:SSL:1m;
ssl_session_timeout  5m;
ssl_ciphers  HIGH:!aNULL:!MD5;
ssl_prefer_server_ciphers  on;
    location /_matrix {
        proxy_pass http://localhost:8008;
        proxy_set_header X-Forwarded-For $remote_addr;
        client_max_body_size 100m;
    }
}
server {
    listen 8448 ssl default_server;
    listen [::]:8448 ssl default_server;
    server_name meinedomain.de;
    client_max_body_size 100m;
ssl_certificate      /etc/letsencrypt/live/meinedomain.de/fullchain.pem;
ssl_certificate_key  /etc/letsencrypt/live/meinedomain.de/privkey.pem;
ssl_session_cache    shared:SSL:1m;
ssl_session_timeout  5m;
ssl_ciphers  HIGH:!aNULL:!MD5;
ssl_prefer_server_ciphers  on;
    location / {
        proxy_pass http://localhost:8008;
        proxy_set_header X-Forwarded-For $remote_addr;
        client_max_body_size 100m;
    }
}
}

systemctl start nginx.service
systemctl enable nginx.service

Nachschauen ob der Server geht
systemctl status nginx

PS: Mit STRG-C kommt man wieder raus.

Hinweis zum Thema Sicherheit
Wenn ihr den Webserver noch sicherer machen wollt, dann könnt ihr zusätzlich folgenden Befehl einfügen
ssl_protocols TLSv1.3 TLSv1.2;
Ab die Konfiguation noch konsistent ist, kann man mit nginx -t prüfen
Danach können aber vielleicht älter Anwenungen nicht mehr auf den Server zugreifen.
Hier noch ein passender Artikel dazu https://tecadmin.net/enable-tls-with-nginx/

Jetzt installieren wir den Server von Matrix

pacman -S matrix-synapse
pacman -S sudo
cd /var/lib/synapse
sudo -u synapse python /usr/lib/python3.7/site-packages/synapse/app/homeserver.py --server-name meinedomain.de --config-path /etc/synapse/homeserver.yaml --generate-config --report-stats=no

Eine Kopie der erzeugten Datei /etc/synapse/homeserver.yaml erstellen.
Folgende Konfiguration in die Datei /etc/synapse/homeserver.yaml einfügen.
Danach an den Stellen wo ~~~~~~~~~~~~~~~ steht, die Werte / Schlüssel aus eurer Originaldatei einsetzen.

registration_shared_secret: "~~~~~~~~~~~~~~~"
macaroon_secret_key: "~~~~~~~~~~~~~~~"
form_secret: "~~~~~~~~~~~~~~~"

Hinweis: Diese Konfiguration bezieht sich auf die Version 1.4 von Matrix-Synapse.

nano /etc/synapse/homeserver.yaml

server_name: "meinedomain.de"
pid_file: /var/lib/synapse/homeserver.pid
federation_ip_range_blacklist:
  - '127.0.0.0/8'
  - '10.0.0.0/8'
  - '172.16.0.0/12'
  - '192.168.0.0/16'
  - '100.64.0.0/10'
  - '169.254.0.0/16'
  - '::1/128'
  - 'fe80::/64'
  - 'fc00::/7'
listeners:
  - port: 8008
    tls: false
    bind_addresses: ['::1', '127.0.0.1']
    type: http
    x_forwarded: true
    resources:
      - names: [client, federation]
        compress: false
acme:
database:
  name: "sqlite3"
  args:
    database: "/mnt/matrix/synapse/homeserver.db"
log_config: "/etc/synapse/meinedomain.de.log.config"
media_store_path: "/mnt/matrix/synapse/media_store"
uploads_path: "/mnt/matrix/synapse/uploads"
max_upload_size: 100M
max_image_pixels: 32M
max_spider_size: 100M
enable_registration: false
registration_shared_secret: "~~~~~~~~~~~~~~~"
report_stats: true
macaroon_secret_key: "~~~~~~~~~~~~~~~"
form_secret: "~~~~~~~~~~~~~~~"
signing_key_path: "/etc/synapse/meinedomain.de.signing.key"
password_config:
opentracing:

trusted_key_servers:
- server_name: "matrix.org"
suppress_key_server_warning: true

systemctl start synapse

Prüfen ob der Server läuft
systemctl status synapse

Für den späteren Autostart noch folgendes eingeben
systemctl enable synapse

Um zu sehen, ob alles geht, legt ihr jetzt den ersten User an und meldet auch damit an.
Am besten gleich den ADMIN User anlegen, den braucht man später immer mal wieder.
register_new_matrix_user -c /etc/synapse/homeserver.yaml http://localhost:8008

Jetzt müsst ihr auch nur noch den Riot.im Client installieren (geht auch direkt im Browser), um euch dann mit dem neuen User dort anmelden zu können. Hierzu muss bei der Anmelung der Server matrix.org durch meinedomain.de ersetzt werden.

Ich habe noch die Größe der Logdatei auf 10 MByte begrenzt, so kann man später besser die einzelnen Dateien löschen und hat nicht ein so riesiges Logfile.
sudo nano /etc/synapse/meinedomain.de.log.config
maxBytes: 10000000

Backup erstellen

Ein komplettes Image von der SD Karte erstellen und das dann auf eine andere SD Karte zurückspielen.
Dann mit der kopierten Karte den Server neu starten.
Als root anmelden
systemctl stop synapse
systemctl stop nginx
shutdown

Die SD Karte auf die Festplatte kopieren (nicht auf dem rPI, sondern unter Linux im Terminal)
dd if=/dev/mmcblk0 of=rPI4.img

Das Image auf die neue Karte übertragen
dd if=rPI4.img of=/dev/mmcblk0

Jetzt die neu SD Karte in der rPI stecken und starten.

Zusätzlich müsst ihr natürlich noch die Daten auf dem USB Medium sichern, am besten macht ihr das mindesten einmal pro Woche.

Cash der Medienhistorie löschen, die älter als einen Monat ist
curl -k -v -d '' "https://meinedomain.de/_matrix/client/r0/admin/purge_media_cache?before_ts=$(date -d-1month +%s000)&access_token="

Sinnvolle Software für den Matrix Server

Midnight Commander
pacman -S mc

Netdata: Monitoring Service
pacman -S netdata
systemctl start netdata.service
systemctl enable netdata.service
Aufrufen kann man die Anzeige mit http://ID-des-rPI:19999
Die Temperatur Anzeige lm_sensors kann leider den Sensor nicht erkennen.

Temperatur messen
pacman -S raspberrypi-firmware
/opt/vc/bin/vcgencmd measure_temp

Ein paar Befehle für später
chown -R synapse /var/lib/synapse
chown -R synapse /etc/synapse
pacman -S wget
journalctl -feu synapse

Datenbankverzeichniss /mnt/matrix/synapse/
Konfigurationsverzeichniss /etc/synapse

Hier noch eine paar Links zu anderen Anleitungen und Artikeln (allerdings nicht für einen Minirechner)
Eigener verschluesselter Chat-Server mit Matrix-Synapse
Erkenntnisse und Erfahrungen rund um Matrix
Eigener Matrix Server
Wie man Matrix-Synapse auf Ubuntu installiert
Matrix – Das XMPP für Hobby-Admins?
Leichte Installation, einfache Bedienung

Rückmeldungen könnt ihr mir unter folgenden Adressen zukommen lassen:
Mastodon: @favstarmafia@social.anoxinon.de
Matrix: @favstarmafia:bau-ha.us

Außerdem empfehle ich euch noch den Matrix Raum:
#synapse-admins:bau-ha.us
Da sind ganz viele nette Admins unterwegs, die einem mal bei einem Problem helfen können.