So installierst du die Flarum Community Software auf Ubuntu 24.04
Flarum ist eine Open-Source-Diskussionssoftware, die der kombinierte Nachfolger von esoTalk- und FluxBB-Boards ist. Sie ist in PHP geschrieben und ihre Oberfläche basiert auf Mithril, einem JavaScript-Framework mit geringem Platzbedarf. Sie ist reaktionsschnell, schnell und unterstützt Erweiterungen über eine leistungsstarke Extension API. Außerdem ist sie leichtgewichtig, so dass sie auf einem relativ billigen Server laufen kann.
In diesem Lernprogramm lernen wir, wie man die Flarum Community Software auf einem Server mit Ubuntu 24.04 installiert.
Voraussetzungen
- Ein Server, auf dem Ubuntu 24.04 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 auf deinem Server Auslagerungsspeicher aktiviert ist, wenn du einen Server mit 1 GB RAM verwendest.
- Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo apt update && sudo apt upgrade
- Einige wichtige Pakete werden benötigt, damit der Lehrgang und Flarum funktionieren. Einige davon befinden sich bereits auf deinem Server.
$ sudo apt install wget curl nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release ubuntu-keyring 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
Ubuntu 24.04 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/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list
Richte ein Repository-Pinning ein, um das offizielle Repository gegenüber den Ubuntu-Paketen zu bevorzugen.
echo -e "Package: *\nPin: origin nginx.org\nPin: release o=nginx\nPin-Priority: 900\n" \
| sudo tee /etc/apt/preferences.d/99nginx
Aktualisiere die System-Repositories.
$ sudo apt update
Installiere Nginx.
$ sudo apt install nginx
Überprüfe die Installation.
$ nginx -v nginx version: nginx/1.26.1
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 (/usr/lib/systemd/system/nginx.service; enabled; preset: enabled)
Active: active (running) since Mon 2024-06-03 10:41:52 UTC; 2s ago
Docs: https://nginx.org/en/docs/
Process: 1817 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 1818 (nginx)
Tasks: 3 (limit: 4543)
Memory: 2.9M (peak: 3.1M)
CPU: 15ms
CGroup: /system.slice/nginx.service
??1818 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??1819 "nginx: worker process"
??1820 "nginx: worker process"
Jun 03 10:41:52 flarum systemd[1]: Starting nginx.service - nginx - high performance web server...
Jun 03 10:41:52 flarum systemd[1]: Started nginx.service - nginx - high performance web server.
Ö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
Ubuntu 24.04 wird standardmäßig mit PHP 8.3 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 haben möchtest oder mehrere Versionen installieren willst, füge Ondrejs PHP-Repository hinzu.
Füge das PHP-Repository von Ondrej Sury hinzu.
$ sudo add-apt-repository ppa:ondrej/php
Aktualisiere die Liste der System-Repositorys.
$ sudo apt update
Die folgende Fehlermeldung kannst du ignorieren. Launchpad unterstützt nicht den stärkeren Verschlüsselungsalgorithmus, der von Ubuntu 24.04 verlangt wird. Die Meldung sollte bald verschwinden.
Als Nächstes installierst du PHP und die von Flarum benötigten Erweiterungen.
$ sudo apt install php8.3-cli php8.3-fpm php8.3-mysql php8.3-xml php8.3-gd php8.3-mbstring php8.3-zip php8.3-curl -y
Überprüfe, ob PHP richtig funktioniert.
$ php --version
Du solltest eine ähnliche Ausgabe sehen.
PHP 8.3.7 (cli) (built: May 23 2024 12:36:54) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.3.7, Copyright (c) Zend Technologies
with Zend OPcache v8.3.7, Copyright (c), by Zend Technologies
Schritt 4 – Installiere Composer
Composer ist ein Abhängigkeitsmanager für PHP. Composer wird von Flarum benötigt, um verschiedene Komponenten zu installieren, die es zum Installieren und Ausführen benötigt.
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') === 'dac665fdc30fdd8ec78b38b9800061b4150413ff2e3b6f88543c636f7cd84f6db9189d43a81e5503cda447da73c7e5b6') { 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.7.6 2024-05-04 23:03:15 PHP version 8.3.7 (/usr/bin/php8.3) Run the "diagnose" command to get more detailed diagnostics output.
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.
Ubuntu 24.04 wird standardmäßig mit MariaDB 10.11.7 ausgeliefert, das ein wenig veraltet ist. Um die neueste stabile Version von MariaDB zu erhalten, musst du das offizielle Repository nutzen. Das offizielle Repository für Ubuntu 24.04 ist auf der MariaDB-Downloadseite nicht aufgeführt, aber es funktionierte, als diese Anleitung geschrieben wurde.
Importiere den GPG-Schlüssel von MariaDB.
$ sudo curl -o /etc/apt/keyrings/mariadb-keyring.pgp 'https://mariadb.org/mariadb_release_signing_key.pgp'
Erstelle die Repository-Datei von MariaDB.
$ echo "deb [signed-by=/etc/apt/keyrings/mariadb-keyring.pgp] https://deb.mariadb.org/10.11/ubuntu `lsb_release -cs` main" | sudo tee /etc/apt/sources.list.d/mariadb-server.list
Aktualisiere die Repository-Liste des Systems.
$ 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 ist.
$ mysql --version
Du solltest die folgende Ausgabe sehen.
mysql Ver 15.1 Distrib 10.11.8-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.8 database server
Loaded: loaded (/usr/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 Mon 2024-06-03 11:31:09 UTC; 27s ago
Docs: man:mariadbd(8)
https://mariadb.com/kb/en/library/systemd/
Process: 14981 ExecStartPre=/usr/bin/install -m 755 -o mysql -g root -d /var/run/mysqld (code=exited, status=0/SUCCESS)
Process: 14983 ExecStartPre=/bin/sh -c systemctl unset-environment _WSREP_START_POSITION (code=exited, status=0/SUCCESS)
Process: 14985 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: 15029 ExecStartPost=/bin/sh -c systemctl unset-environment _WSREP_START_POSITION (code=exited, status=0/SUCCESS)
Process: 15032 ExecStartPost=/etc/mysql/debian-start (code=exited, status=0/SUCCESS)
Main PID: 15015 (mariadbd)
Status: "Taking your SQL requests now..."
Tasks: 14 (limit: 29985)
Memory: 78.9M (peak: 81.8M)
CPU: 559ms
CGroup: /system.slice/mariadb.service
??15015 /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 noch 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 Ubuntu 24.04 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 aufgehoben 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 37 Server version: 10.11.8-MariaDB-ubu2404 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
Erlaube den Schreibzugriff auf das Verzeichnis.
$ sudo chmod 775 -R /var/www/flarum
Navigiere zum Installationsordner.
$ cd /var/www/flarum
Lade Flarum mit Composer herunter und installiere es.
$ composer create-project flarum/flarum .
Ändere die Eigentümerschaft des Flarum-Verzeichnisses auf nginx für den Nginx-Server.
$ sudo chown -R nginx:nginx /var/www/flarum
Von nun an benötigt Composer sudo-Berechtigungen, was nicht empfohlen wird. Du kannst auch die Gruppenberechtigungen des Verzeichnisses auf deinen Linux-Benutzer ändern und sie nach der Fertigstellung von Composer wieder auf nginx ändern. 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 Ubuntu 24.04 ist Snapd bereits installiert.
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, ob Certbot korrekt funktioniert.
$ certbot --version certbot 2.10.0
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 --------------------------------------------------------------------------------------------------------------------------------- Mon 2024-06-03 11:39:00 UTC 36s Mon 2024-06-03 11:09:06 UTC 29min ago phpsessionclean.timer phpsessionclean.service Mon 2024-06-03 13:09:56 UTC 1h 31min Mon 2024-06-03 10:34:09 UTC - motd-news.timer motd-news.service Mon 2024-06-03 21:58:00 UTC 10h - - snap.certbot.renew.timer snap.certbot.renew.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.3/fpm/pool.d/www.conf.
$ sudo nano /etc/php/8.3/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.3/fpm/php.ini
Starte den PHP-FPM-Dienst neu.
$ sudo systemctl restart php8.3-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;
listen 443 ssl;
http2 on;
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/php8.3-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 Standard-Nginx-Einstellungen in der Datei /var/www/flarum/.nginx.conf ausgeliefert, die wir mit der folgenden Direktive in unsere Nginx-Konfiguration aufgenommen haben.
include /var/www/flarum/.nginx.conf;
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 auf GitHub verfügbar.
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.
Bevor du eine Test-E-Mail 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
Kehre zur Seite mit den E-Mail-Einstellungen zurück und klicke auf die Schaltfläche Senden, um eine Test-E-Mail zu versenden. Die Seite wird dich benachrichtigen, wenn die E-Mail erfolgreich gesendet wurde. Du solltest die folgende 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.
Schritt 12 – Flarum aktualisieren
Du brauchst die Extension Manager-Erweiterung, um Flarum vom Administrations-Dashboard aus aktualisieren zu können. Installiere den Extension Manager mit dem folgenden Befehl.
$ cd /var/www/flarum $ composer require flarum/extension-manager:*
Öffne das Administrator-Dashboard und aktiviere die Extension Manager-Erweiterung, indem du die deaktivierte Schaltfläche nach rechts schiebst.
Wenn du die Erweiterung aktivierst, sollte sie wie folgt aussehen.
Bevor du das Forum aktualisieren kannst, musst du den Wartungsmodus für das Forum aktivieren. Die Konfiguration dafür ist nicht über das Administrations-Dashboard verfügbar. Einige der Einstellungen sind über die Datei config.php im Stammverzeichnis von Flarum verfügbar. Wechsle zum Terminal und öffne die Datei config.php zum Bearbeiten.
$ nano /var/www/flarum/config.php
Suche die Zeile 'debug' => false, und füge die folgende Zeile danach ein, so dass sie wie folgt aussieht.
'debug' => false, 'offline' => true,
Wenn du fertig bist, drücke Strg + X, um den Editor zu schließen und drücke Y, wenn du aufgefordert wirst, die Datei zu speichern.
Wechsle zurück zum Dashboard und klicke auf die Schaltfläche Nach Updates suchen auf der unteren Seite des Erweiterungsmanagers, um die Flarum-Software zu aktualisieren. Wie du den Erweiterungsmanager zur Verwaltung von Erweiterungsaktualisierungen verwendest, findest du in der Dokumentation zum Erweiterungsmanager.
Schritt 12 – Flarum sichern und wiederherstellen
Der einfachste Weg, Flarum zu sichern, ist die Sicherung der MariaDB-Datenbank. Verwende dazu das Tool mysqldump mit dem folgenden Befehl.
$ sudo mysqldump flarum > flarumbackup.sql
Um die Datenbank auf dem neueren Server wiederherzustellen, wiederholst du alle Befehle aus Schritt 6 zur Konfiguration von MariaDB. Dadurch werden eine leere Datenbank (flarum) und ein Datenbankbenutzer mit Zugriff auf diese Datenbank erstellt.
Als Nächstes führst du den folgenden Befehl aus, um das Forum wiederherzustellen.
$ sudo mysql flarum < backup.sql
Um die Dateien zu sichern, kopiere den gesamten Ordner /var/www/flarum und stelle ihn auf dem neuen Server wieder her. Wenn du die URL änderst, ändere den Wert für die Variable url in der Datei config.php und konfiguriere Nginx neu, um das Forum zu bedienen.
Fazit
Damit ist unsere Anleitung zur Installation der Flarum Community Forumssoftware auf einem Ubuntu 24.04 Server abgeschlossen. Wenn du Fragen oder Feedback hast, schreibe sie in die Kommentare unten.