So installierst du die Flarum Community Software unter Debian 12
Flarum ist eine Open-Source-Community-Software, mit der du ganz einfach Online-Foren erstellen und verwalten kannst. Mit seiner schlanken, modernen Oberfläche bietet Flarum ein optimiertes Benutzererlebnis, das auf Leistung und Einfachheit ausgelegt ist. Die Software ist durch ein robustes Erweiterungssystem in hohem Maße anpassbar und ermöglicht es Administratoren, ihre Foren an die jeweiligen Bedürfnisse und Vorlieben anzupassen. Flarum unterstützt responsives Design, das die Kompatibilität mit verschiedenen Geräten und Funktionen wie Echtzeit-Benachrichtigungen, Rich-Media-Einbettung und nahtlose Moderationswerkzeuge gewährleistet. Durch die Verwendung von PHP und MySQL ist Flarum für eine Vielzahl von Webhosting-Umgebungen geeignet und eignet sich sowohl für kleine Gemeinschaften als auch für große Organisationen, die eine effiziente Plattform für Online-Diskussionen suchen.
In diesem Lernprogramm lernen wir, wie man die Flarum Community Software auf einem Server mit Debian 12 installiert.
Voraussetzungen
- Ein Server, auf dem Debian 12 läuft.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Ein Fully Qualified Domain Name (FQDN) wie
flarum.example.com, der auf deinen Server zeigt. - Vergewissere dich, dass dein Server über einen aktivierten Swap-Speicher verfügt, wenn du einen Server mit 1 GB RAM verwendest.
- Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo apt update && sudo apt upgrade
- TFlarum benötigt ein paar wichtige Pakete, um zu funktionieren. Einige davon befinden sich bereits auf deinem Server.
$ sudo apt install curl wget nano software-properties-common dirmngr apt-transport-https ca-certificates lsb-release debian-archive-keyring gnupg2 ufw unzip -y
Schritt 1 – Firewall konfigurieren
Der erste Schritt besteht darin, die Firewall zu konfigurieren. Debian wird standardmäßig mit ufw (Uncomplicated Firewall) ausgeliefert.
Überprüfe, ob die Firewall aktiv ist.
$ sudo ufw status
Du wirst die folgende Ausgabe erhalten.
Status: inactive
Erlaube den SSH-Port, damit die Firewall die aktuelle Verbindung nicht unterbricht, wenn du sie aktivierst.
$ sudo ufw allow OpenSSH
Lasse auch HTTP- und HTTPS-Ports zu.
$ sudo ufw allow http $ sudo ufw allow https
Aktiviere die Firewall
$ sudo ufw enable Command may disrupt existing ssh connections. Proceed with operation (y|n)? y Firewall is active and enabled on system startup
Überprüfe den Status der Firewall erneut.
$ sudo ufw status
Du solltest eine ähnliche Ausgabe sehen.
Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 80/tcp ALLOW Anywhere 443 ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) 80/tcp (v6) ALLOW Anywhere (v6) 443 (v6) ALLOW Anywhere (v6)
Schritt 2 – Nginx installieren
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. Auf Debian-Systemen funktioniert der folgende Befehl nur mit sudo.
$ sudo nginx -v nginx version: nginx/1.24.0
Starten Sie 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 Thu 2023-11-09 12:08:18 UTC; 1s ago
Docs: https://nginx.org/en/docs/
Process: 1957 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 1958 (nginx)
Tasks: 2 (limit: 1107)
Memory: 1.7M
CPU: 6ms
CGroup: /system.slice/nginx.service
??1958 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??1959 "nginx: worker process"
Öffne die IP-Adresse deines Servers in deinem Webbrowser. Du solltest die folgende Seite sehen, d.h. dein Server ist in Betrieb.
Schritt 3 – Installiere PHP
Debian 12 wird standardmäßig mit PHP 8.2 ausgeliefert. Du kannst es installieren, indem du den folgenden Befehl ausführst.
$ sudo apt install php-cli php-fpm php-mysql php-xml php-gd php-json php-mbstring php-zip php-curl -y
Wenn du immer die neueste Version von PHP verwenden oder mehrere Versionen installieren willst, füge Ondrejs PHP-Repository hinzu.
Importiere zunächst den PHP-GPG-Schlüssel aus Surys Repository.
$ sudo curl -sSLo /usr/share/keyrings/deb.sury.org-php.gpg https://packages.sury.org/php/apt.gpg
Füge das PHP-Repository von Ondrej Sury hinzu.
$ sudo sh -c 'echo "deb [signed-by=/usr/share/keyrings/deb.sury.org-php.gpg] https://packages.sury.org/php/ $(lsb_release -sc) main" > /etc/apt/sources.list.d/php.list'
Aktualisiere die Liste der System-Repositorys.
$ sudo apt update
Als Nächstes installierst du PHP und die von Flarum benötigten Erweiterungen.
$ sudo apt install php-cli php-fpm php-mysql php-xml php-gd php-json php-mbstring php-zip php-curl -y
Prüfe, ob PHP richtig funktioniert.
$ php --version
Du solltest eine ähnliche Ausgabe sehen.
PHP 8.2.12 (cli) (built: Oct 27 2023 13:00:10) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.2.12, Copyright (c) Zend Technologies
with Zend OPcache v8.2.12, Copyright (c), by Zend Technologies
Schritt 4 – Installiere Composer
Composer ist ein Abhängigkeitsmanager für PHP. Flarum braucht Composer, um verschiedene Komponenten zu installieren und auszuführen.
Führe die folgenden Befehle aus, um Composer zu installieren. Zuerst holen wir uns den Installer, überprüfen den Hash, um ihn zu verifizieren, und führen den Installer dann über die PHP-Befehlszeile aus. Dann verschieben wir die Binärdatei in das Verzeichnis /usr/local/bin.
$ php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
$ php -r "if (hash_file('sha384', 'composer-setup.php') === 'e21205b207c3ff031906575712edab6f13eb0b361f2085f1f1237b7126d785e826a450292b6cfd1d64d92e6563bbde02') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
$ php composer-setup.php
$ php -r "unlink('composer-setup.php');"
$ sudo mv composer.phar /usr/local/bin/composer
Überprüfe, ob der Composer richtig installiert ist.
$ composer --version Composer version 2.6.5 2023-10-06 10:11:52
Schritt 5 – MariaDB installieren
MariaDB ist ein Drop-in-Ersatz für MySQL. Das bedeutet, dass die Befehle zum Ausführen und Betreiben von MariaDB die gleichen sind wie die für MySQL.
Debian 12 wird standardmäßig mit MariaDB 10.11.4 ausgeliefert, das ein wenig veraltet ist. Du musst das offizielle Repository verwenden, um die neueste stabile Version von MariaDB zu erhalten.
Importiere den GPG-Schlüssel von MariaDB.
$ sudo curl -o /usr/share/keyrings/mariadb-keyring.pgp 'https://mariadb.org/mariadb_release_signing_key.pgp'
Erstelle die Repository-Datei von MariaDB.
$ echo "deb [signed-by=/usr/share/keyrings/mariadb-keyring.pgp] https://deb.mariadb.org/10.11/debian `lsb_release -cs` main" | sudo tee /etc/apt/sources.list.d/mariadb-server.list
Aktualisiere die Liste der System-Repositorys.
$ sudo apt update
Gib den folgenden Befehl ein, um den MariaDB-Server zu installieren.
$ sudo apt install mariadb-server -y
Überprüfe, ob MariaDB korrekt installiert wurde.
$ mysql --version
Du solltest die folgende Ausgabe sehen.
mysql Ver 15.1 Distrib 10.11.6-MariaDB, for debian-linux-gnu (x86_64) using EditLine wrapper
Du kannst auch mariadb --version verwenden, um die Version zu überprüfen.
Der MariaDB-Dienst ist bereits aktiviert und läuft. Überprüfe seinen Status mit dem folgenden Befehl.
$ sudo systemctl status mariadb
? mariadb.service - MariaDB 10.11.6 database server
Loaded: loaded (/lib/systemd/system/mariadb.service; enabled; preset: enabled)
Drop-In: /etc/systemd/system/mariadb.service.d
??migrated-from-my.cnf-settings.conf
Active: active (running) since Tue 2023-11-14 08:42:03 UTC; 4min 1s ago
Docs: man:mariadbd(8)
https://mariadb.com/kb/en/library/systemd/
Process: 74903 ExecStartPre=/usr/bin/install -m 755 -o mysql -g root -d /var/run/mysqld (code=exited, status=0/SUCCESS)
Process: 74904 ExecStartPre=/bin/sh -c systemctl unset-environment _WSREP_START_POSITION (code=exited, status=0/SUCCESS)
Process: 74906 ExecStartPre=/bin/sh -c [ ! -e /usr/bin/galera_recovery ] && VAR= || VAR=`cd /usr/bin/..; /usr/bin/galera_recovery`; [ $? -eq 0 ] && systemctl set-environment _WSREP_START_POSITION=$VAR>
Process: 74946 ExecStartPost=/bin/sh -c systemctl unset-environment _WSREP_START_POSITION (code=exited, status=0/SUCCESS)
Process: 74948 ExecStartPost=/etc/mysql/debian-start (code=exited, status=0/SUCCESS)
Main PID: 74935 (mariadbd)
Status: "Taking your SQL requests now..."
Tasks: 9 (limit: 1107)
Memory: 214.9M
CPU: 627ms
CGroup: /system.slice/mariadb.service
??74935 /usr/sbin/mariadbd
Führe den folgenden Befehl aus, um die Standardkonfiguration durchzuführen, z. B. ein Root-Passwort zu vergeben, anonyme Benutzer zu entfernen, den Root-Login aus der Ferne zu verbieten und Testtabellen zu löschen.
$ sudo mariadb-secure-installation
Du wirst nach deinem Root-Passwort gefragt. Da wir kein Root-Passwort festgelegt haben, drückst du die Eingabetaste, um fortzufahren.
NOTE: RUNNING ALL PARTS OF THIS SCRIPT IS RECOMMENDED FOR ALL MariaDB
SERVERS IN PRODUCTION USE! PLEASE READ EACH STEP CAREFULLY!
In order to log into MariaDB to secure it, we'll need the current
password for the root user. If you've just installed MariaDB, and
haven't set the root password yet, you should just press enter here.
Enter current password for root (enter for none): [PRESS ENTER]
OK, successfully used password, moving on...
Als Nächstes wirst du gefragt, ob du zum Plugin unix_socket wechseln möchtest. Das unix_socket Plugin ermöglicht es dir, dich mit deinen Linux-Benutzerdaten bei MariaDB anzumelden. Wähle n, um den Wechsel zu überspringen, da du bereits ein geschütztes root Konto hast.
Setting the root password or using the unix_socket ensures that nobody can log into the MariaDB root user without the proper authorisation. You already have your root account protected, so you can safely answer 'n'. Switch to unix_socket authentication [Y/n] n ... skipping.
Als nächstes wirst du gefragt, ob du dein Root-Passwort ändern möchtest. Unter Debian 12 ist das Root-Konto für MariaDB eng mit der automatischen Systemwartung verknüpft, daher solltest du die konfigurierten Authentifizierungsmethoden für das Konto nicht ändern. Andernfalls könnte eine Paketaktualisierung das Datenbanksystem zerstören, indem der Zugriff auf das administrative Konto entfernt wird. Gib n ein, um fortzufahren.
You already have your root account protected, so you can safely answer 'n'. Change the root password? [Y/n] n ... skipping.
Drücke von nun an y und dann Enter, um die Standardeinstellungen für alle folgenden Fragen zu akzeptieren. Dadurch wird der Zugang für anonyme Benutzer entfernt, die Datenbanken werden getestet, die Remote-Root-Anmeldung wird deaktiviert und die Änderungen werden geladen.
By default, a MariaDB installation has an anonymous user, allowing anyone to log into MariaDB without having to have a user account created for them. This is intended only for testing, and to make the installation go a bit smoother. You should remove them before moving into a production environment. Remove anonymous users? [Y/n] y ... Success! Normally, root should only be allowed to connect from 'localhost'. This ensures that someone cannot guess at the root password from the network. Disallow root login remotely? [Y/n] y ... Success! By default, MariaDB comes with a database named 'test' that anyone can access. This is also intended only for testing, and should be removed before moving into a production environment. Remove test database and access to it? [Y/n] y - Dropping test database... ... Success! - Removing privileges on test database... ... Success! Reloading the privilege tables will ensure that all changes made so far will take effect immediately. Reload privilege tables now? [Y/n] y ... Success! Cleaning up... All done! If you've completed all of the above steps, your MariaDB installation should now be secure. Thanks for using MariaDB!
Das war’s schon. Wenn du dich das nächste Mal bei der MariaDB-Shell anmelden willst, verwende den folgenden Befehl.
$ sudo mysql
Gib dein Linux-Root-Passwort ein, wenn du dazu aufgefordert wirst.
Welcome to the MariaDB monitor. Commands end with ; or \g. Your MariaDB connection id is 39 Server version: 10.11.6-MariaDB-1:10.11.6+maria~deb12 mariadb.org binary distribution Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others. Type 'help;' or '\h' for help. Type '\c' to clear the current input statement. MariaDB [(none)]>
Drücke exit, um die MariaDB-Shell zu schließen.
Schritt 6 – MariaDB konfigurieren
Melde dich in der MariaDB-Shell an.
$ sudo mysql
Erstelle eine neue MySQL-Datenbank, einen Datenbankbenutzer und ein Passwort für deine Flarum-Installation.
MariaDB> CREATE DATABASE flarum; MariaDB> CREATE USER 'flarumuser'@'localhost' IDENTIFIED BY 'yourpassword'; MariaDB> GRANT ALL PRIVILEGES ON flarum.* TO 'flarumuser'@'localhost';
Ersetze flarum, flarumuser und yourpassword durch die Anmeldedaten deiner Wahl. Wähle ein sicheres Passwort.
Erstelle außerdem einen administrativen Benutzer mit denselben Fähigkeiten wie das root-Konto.
MariaDB> GRANT ALL ON *.* TO 'admin'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;
Flush die Berechtigungen, um sicherzustellen, dass sie in der aktuellen Sitzung gespeichert werden.
MariaDB> FLUSH PRIVILEGES;
Beende die MariaDB-Shell.
MariaDB> exit
Schritt 7 – Installiere Flarum
Erstelle ein Verzeichnis, in dem Flarum installiert werden soll.
$ sudo mkdir /var/www/flarum -p
Mit der Direktive -p werden übergeordnete Verzeichnisse erstellt, die vorher nicht existierten.
Ändere die Eigentumsrechte für das Flarum-Verzeichnis auf den aktuell angemeldeten Linux-Benutzer, damit du Befehle ausführen kannst, ohne sudo zu verwenden.
$ sudo chown -R $USER:$USER /var/www/flarum
Navigiere zu dem Installationsordner.
$ cd /var/www/flarum
Lade Flarum mit Composer herunter und installiere es.
$ composer create-project flarum/flarum .
Ändere die Eigentumsrechte für das Flarum-Verzeichnis auf nginx für den Nginx-Server.
$ sudo chown -R nginx:nginx /var/www/flarum
Erlaube den Schreibzugriff auf das Verzeichnis.
$ sudo chmod 775 -R /var/www/flarum
Von nun an benötigt Composer sudo-Berechtigungen, was nicht empfohlen wird. Du kannst auch die Gruppenrechte für das Verzeichnis auf deinen Linux-Benutzer ändern und sie wieder auf nginx zurücksetzen, wenn du mit Composer fertig bist. Das ist keine ideale Lösung, da du die gleichen Befehle immer wieder ausführen musst. Eine dauerhaftere Lösung ist es, deinen Benutzernamen zur nginx-Gruppe hinzuzufügen. Führe den folgenden Befehl aus, um deinen derzeit angemeldeten Linux-Benutzer zur nginx-Gruppe hinzuzufügen.
$ sudo usermod -a -G nginx $USER
Um die neue Gruppenzugehörigkeit zu übernehmen, melde dich vom Server ab und melde dich wieder an oder gib den folgenden Befehl ein.
su - ${USER}
Schritt 8 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. 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. Installiere das Snapd-Paket.
$ sudo apt install snapd
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
Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link zum Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Überprüfe, ob Certbot korrekt funktioniert.
$ certbot --version certbot 2.7.4
Erstelle das SSL-Zertifikat.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d flarum.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/flarum.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 --------------------------------------------------------------------------------------------------------------------------- Tue 2023-11-14 15:39:00 UTC 24min left Tue 2023-11-14 15:09:02 UTC 5min ago phpsessionclean.timer phpsessionclean.service Tue 2023-11-14 17:33:00 UTC 2h 18min left - - snap.certbot.renew.timer snap.certbot.renew.service Tue 2023-11-14 19:03:30 UTC 3h 49min left Tue 2023-11-14 15:12:10 UTC 1min 58s ago apt-daily.timer apt-daily.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 9 – PHP-FPM konfigurieren
Öffne die Datei /etc/php/8.2/fpm/pool.d/www.conf.
$ sudo nano /etc/php/8.2/fpm/pool.d/www.conf
Wir müssen den Unix-Benutzer/die Unix-Gruppe der PHP-Prozesse auf nginx setzen. Finde die Zeilen user=www-data und group=www-data in der Datei und ändere sie in nginx.
; Unix user/group of the child processes. This can be used only if the master ; process running user is root. It is set after the child process is created. ; The user and group can be specified either by their name or by their numeric ; IDs. ; Note: If the user is root, the executable needs to be started with ; --allow-to-run-as-root option to work. ; Default Values: The user is set to master process running user by default. ; If the group is not set, the user's group is used. user = nginx group = nginx ...
Finde die Zeilen listen.owner = www-data und listen.group = www-data in der Datei und ändere sie in nginx.
; Set permissions for unix socket, if one is used. In Linux, read/write ; permissions must be set in order to allow connections from a web server. Many ; BSD-derived systems allow connections regardless of permissions. The owner ; and group can be specified either by name or by their numeric IDs. ; Default Values: Owner is set to the master process running user. If the group ; is not set, the owner's group is used. Mode is set to 0660. listen.owner = nginx listen.group = nginx
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Erhöhe die Größe der hochzuladenden Datei auf 8 MB.
$ sudo sed -i 's/upload_max_filesize = 2M/upload_max_filesize = 8M/' /etc/php/8.2/fpm/php.ini
Starte den PHP-FPM-Dienst neu.
$ sudo systemctl restart php8.2-fpm
Ändere die Gruppe des PHP-Sessions-Verzeichnisses auf Nginx.
$ sudo chgrp -R nginx /var/lib/php/sessions
Schritt 10 – Nginx konfigurieren
Führe den folgenden Befehl aus, um eine Konfigurationsdatei für deine Website hinzuzufügen.
$ sudo nano /etc/nginx/conf.d/flarum.conf
Füge den folgenden Code in den Editor ein.
server {
listen [::]:80;
listen 80;
server_name flarum.example.com;
# redirect http to https
return 301 https://flarum.example.com$request_uri;
}
server {
listen [::]:443 ssl http2;
listen 443 ssl http2;
server_name flarum.example.com;
access_log /var/log/nginx/flarum.access.log;
error_log /var/log/nginx/flarum.error.log;
root /var/www/flarum/public;
index index.php;
include /var/www/flarum/.nginx.conf;
client_max_body_size 8M;
if ($host != "flarum.example.com") {
return 301 $scheme://flarum.example.com$request_uri;
}
# SSL code
ssl_certificate /etc/letsencrypt/live/flarum.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/flarum.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/flarum.example.com/chain.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_prefer_server_ciphers off;
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;
types_hash_max_size 2048;
location ~ \.php$ {
fastcgi_pass unix:/run/php/php-fpm.sock;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_index index.php;
include fastcgi_params;
}
}
Diese Datei geht davon aus, dass wir example.com in dem Verzeichnis /var/www/flarum/public hosten werden. Flarum wird mit einigen Nginx-Standardeinstellungen in der Datei /var/www/flarum/.nginx.conf ausgeliefert, die wir in unsere Nginx-Konfiguration aufgenommen haben.
Wenn du fertig bist, drücke Strg + X, um den Editor zu schließen, und drücke Y, wenn du zum Speichern der Datei aufgefordert wirst.
Ö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. Teste die Nginx-Konfiguration.
$ sudo nginx -t
Du solltest die folgende Ausgabe sehen, die anzeigt, dass deine Konfiguration korrekt ist.
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok nginx: configuration file /etc/nginx/nginx.conf test is successful
Lade den Nginx-Dienst neu.
$ sudo systemctl reload nginx
Schritt 11 – Zugriff und Abschluss der Flarum-Installation
Öffne http://example.com in deinem Browser, um die Installation abzuschließen.
Fülle die erforderlichen Datenbankwerte ein, die wir oben erstellt haben. Du kannst den Eintrag Tabellenpräfix leer lassen, damit Flarum den Standardpräfix verwendet, oder du kannst einen beliebigen Präfix wie fla_ eingeben. Wähle einen Benutzernamen, ein sicheres Passwort und eine E-Mail-ID, um Flarum zu installieren.
Klicke auf die Schaltfläche Flarum installieren, um die Installation abzuschließen.
Nach der Installation solltest du mit der Standard-Homepage von Flarum begrüßt werden.
Dein Forum ist nun installiert und einsatzbereit.
Aktiviere 2FA
Die Zwei-Faktor-Authentifizierung ist eine wichtige Funktion für jedes öffentliche Forum. Flarum wird nicht mit dieser Funktion ausgeliefert, aber du kannst sie aktivieren, indem du eine Erweiterung dafür installierst. Die Erweiterung dafür ist über Extiverse erhältlich. Extiverse ist ein inoffizielles Repository für Flarum Themes und Plugins.
Um das Plugin zu installieren, wechselst du zunächst in das Flarum-Verzeichnis.
$ cd /var/www/flarum
Installiere das Plugin mit dem Composer.
$ composer require ianm/twofactor:"*"
Im nächsten Schritt musst du das Plugin im Flarum-Administrationsbereich aktivieren. Klicke oben rechts auf der Homepage auf deinen Namen und klicke im Dropdown-Menü auf den Link Verwaltung.
Du gelangst dann zum Administrations-Dashboard. Wähle die 2FA-Funktion aus dem linken Menü aus und schalte sie ein. Du brauchst nichts zu ändern, da die Standardeinstellungen ausreichen sollten.
Wenn du möchtest, dass die Moderatoren des Forums 2FA aktiviert haben, klicke auf die Schaltfläche Mods und aktiviere die Einstellung 2FA erforderlich. Klicke zum Abschluss auf die Schaltfläche Änderungen speichern.
Um 2FA für deinen Account zu aktivieren, öffne deine Einstellungsseite im Menü oben rechts auf der Startseite des Forums. Öffne die Seite Sicherheit, indem du sie in der linken Seitenleiste auswählst.
Klicke auf die Schaltfläche 2FA aktivieren und das folgende Popup wird geöffnet.
Scanne den QR-Code oder wähle die manuelle Option mit deiner 2FA-App und gib den generierten Code in das Feld ein. Klicke auf die Schaltfläche Verifizieren, wenn du fertig bist. Es werden dir Sicherungscodes angezeigt. Speichere sie und klicke auf die Schaltfläche, um fortzufahren.
Du wirst erneut um eine Bestätigung gebeten. Klicke auf die Schaltfläche Ok, um fortzufahren. Der Vorgang ist nun abgeschlossen.
E-Mail-Einstellungen konfigurieren
Du musst auch die E-Mail-Einstellungen im Verwaltungsbereich konfigurieren. Flarum unterstützt den Mailgun SMTP-Dienst von Haus aus oder du kannst einen externen SMTP-Anbieter verwenden.
Wir verwenden den Amazon SES Service, für den wir smtp aus dem Dropdown-Menü des E-Mail-Treibers auf der E-Mail-Seite ausgewählt haben. Klicke auf die Schaltfläche Änderungen speichern und dann auf die Schaltfläche Senden, um eine Test-E-Mail zu versenden. Die Seite meldet, ob die E-Mail erfolgreich versendet wurde. Du solltest die folgende E-Mail erhalten.
Wenn du Mailgun verwenden möchtest, wähle Mailgun aus dem Dropdown-Menü. Fülle die erforderlichen Felder aus und speichere die Einstellungen.
Bevor du eine Testmail versendest, musst du ein Composer-Paket installieren, damit es funktioniert. Wechsle in das Flarum-Verzeichnis auf dem Server.
$ cd /var/www/flarum
Installiere das Composer-Paket.
$ composer require guzzlehttp/guzzle:^7.0
Sende eine Testmail, um die Funktion zu überprüfen.
Fazit
Damit ist unsere Anleitung zur Installation der Flarum Community Forumssoftware auf einem Debian 12 Server abgeschlossen. Wenn du Fragen oder Anregungen hast, schreibe sie unten in die Kommentare.