So installierst du das Discourse Forum mit Nginx und kostenlosem Let’s Encrypt SSL unter Debian 11
Discourse ist eine Open-Source-Community-Diskussionsplattform, die auf der Sprache Ruby basiert. Sie kann als Forum, Chat-Software oder Mailingliste genutzt werden. Sie lässt sich leicht mit anderen Plattformen integrieren und ihre Funktionen können mit Plugins erweitert werden.
In diesem Lernprogramm lernst du, wie du Discourse Forum mit dem Nginx-Server auf einem Debian 11 basierten Server installierst.
Voraussetzungen
- Ein Server mit Debian 11 und mindestens 1 GB RAM und 1 Core CPU. Das Discourse-Setup erstellt automatisch eine Swap-Partition auf Systemen mit 1 GB oder weniger RAM. Daher wird empfohlen, ihn auf einem System mit mindestens 2 GB RAM zu installieren.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Einen Domainnamen (
discourse.example.com), der auf den Server zeigt. - Alles ist auf dem neuesten Stand.
$ sudo apt update && sudo apt upgrade
- Einige wenige Pakete, die dein System benötigt.
$ sudo apt install nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release debian-archive-keyring -y
Einige dieser Pakete sind vielleicht schon auf deinem System installiert.
Schritt 1 – Firewall konfigurieren
Der erste Schritt besteht darin, die Firewall zu konfigurieren. Debian wird mit ufw (Uncomplicated Firewall) ausgeliefert.
Überprüfe, ob die Firewall läuft.
$ sudo ufw status
Du solltest 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 80/tcp $ sudo ufw allow 443/tcp
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/tcp ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) 80/tcp (v6) ALLOW Anywhere (v6) 443/tcp (v6) ALLOW Anywhere (v6)
Schritt 2 – Git installieren
Installiere Git mit dem Standard-Appstream.
$ sudo dnf install git
Bestätige die Installation.
$ git --version git version 2.30.2
Führe die folgenden Befehle aus, um die Git-Installation zu konfigurieren.
$ git config --global user.name "Your Name" $ git config --global user.email "youremail@example.com"
Schritt 3 – Installiere Docker
Um die neueste Version von Docker zu installieren, füge den offiziellen GPG-Schlüssel von Docker hinzu.
$ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
Installiere das offizielle Docker-Repository.
$ echo \ "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian \ $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
Aktualisiere die Debian-Systemrepositorien.
$ sudo apt update
Installiere die neuste Version von Docker.
$ sudo apt install docker-ce docker-ce-cli containerd.io
Überprüfe, ob Docker läuft.
$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
Active: active (running) since Sat 2022-02-05 13:32:54 UTC; 1h ago
TriggeredBy: ? docker.socket
Docs: https://docs.docker.com
Main PID: 5818 (dockerd)
Tasks: 26
Memory: 1.4G
CPU: 5min 34.561s
CGroup: /system.slice/docker.service
?? 5818 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
??12162 /usr/bin/docker-proxy -proto tcp -host-ip 0.0.0.0 -host-port 8080 -container-ip 172.17.0.2 -contai>
??12169 /usr/bin/docker-proxy -proto tcp -host-ip :: -host-port 8080 -container-ip 172.17.0.2 -container-p>
Standardmäßig benötigt Docker Root-Rechte. Wenn du vermeiden möchtest, dass du jedes Mal sudo verwendest, wenn du den Befehl docker ausführst, füge deinen Benutzernamen der Gruppe docker hinzu.
$ sudo usermod -aG docker $(whoami)
Um diese Änderung zu aktivieren, musst du dich vom Server abmelden und als derselbe Benutzer wieder anmelden.
Schritt 4 – Discourse herunterladen
Erstelle das Stammverzeichnis für Discourse.
$ sudo mkdir /var/discourse
Klone das offizielle Discourse Docker Repository auf Github.
$ sudo git clone https://github.com/discourse/discourse_docker.git /var/discourse
Schritt 5 – Discourse konfigurieren
Erstelle die Konfigurationsdatei app.yml, indem du die Beispieldatei standalone.yml kopierst.
$ sudo cp samples/standalone.yml containers/app.yml
Öffne die app.yml zur Bearbeitung.
$ sudo nano containers/app.yml
Domain festlegen
Setze die Variable DISCOURSE_HOSTNAME auf den Domainnamen, den du für dein Forum gewählt hast. Wenn du keinen Domainnamen hast, kannst du hier auch eine IP-Adresse verwenden.
DISCOURSE_HOSTNAME: 'discourse.example.com'
Exponierte Ports konfigurieren
Ändere die Zeile "80:80 in "8080:80". Dadurch wird der externe HTTP-Port für Discourse auf 8080 geändert, da wir Nginx auf Port 80 verwenden werden. Kommentiere die Zeile "443:443" aus, da wir SSL extern installieren werden.
expose: - "8080:80" # http #- "443:443" # https
SMTP-Einstellungen konfigurieren
Fülle die folgenden Variablen aus, je nachdem, welchen Transaktions-E-Mail-Dienst du verwendest. Lege die E-Mail für dein Administratorkonto mit der Variable DISCOURSE_DEVELOPER_EMAILS fest. Dieser Schritt ist obligatorisch, da dein Forum sonst nicht hochgefahren werden kann.
.. DISCOURSE_DEVELOPER_EMAILS: 'name@example.com' .. DISCOURSE_SMTP_ADDRESS: smtp.example.com DISCOURSE_SMTP_PORT: 587 DISCOURSE_SMTP_USER_NAME: user@example.com DISCOURSE_SMTP_PASSWORD: your_smtp_password #DISCOURSE_SMTP_ENABLE_START_TLS: true # (optional, default true) #DISCOURSE_SMTP_DOMAIN: discourse.example.com # (required by some providers) DISCOURSE_NOTIFICATION_EMAIL: noreply@discourse.example.com # (address to send notifications from)
Speichereinstellungen (optional)
Wenn dein Server über wenig Arbeitsspeicher verfügt, kannst du die folgenden Variablen entsprechend konfigurieren, um den Speicherbedarf von Discourse zu verringern.
db_shared_buffers: '128MB' UNICORN_WORKERS: 2
Die Variable db_shared_buffers wird normalerweise auf 25% des verfügbaren Speichers gesetzt.
GeoLite2-Einstellungen (Optional)
Wenn du die IP-Lookup-Funktion in Discourse nutzen willst, melde dich für den kostenlosen Maxmind Geolite2 Account an und erhalte einen Lizenzschlüssel. Füge diesen Lizenzschlüssel als Wert in die folgende Variable ein.
DISCOURSE_MAXMIND_LICENSE_KEY: your_maxmind_license_key
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Schritt 6 – Installiere Discourse
Führe den folgenden Befehl aus, um deinen Discourse-Container zu booten.
$ sudo ./launcher bootstrap app
Starte die Discourse-Anwendung.
$ sudo ./launcher start app
Du kannst auf das Forum zugreifen, indem du die URLs http://yourserver_IP:8080 oder http://discourse.example.com:8080 in deinem Browser aufrufst. Du wirst den folgenden Bildschirm sehen.
Klicke auf die Schaltfläche Registrieren, um fortzufahren. Die E-Mail-ID, die du in der Datei app.yml angegeben hast, wird für dich vorausgefüllt.
Klicke auf die Schaltfläche “ Registrieren“, um das Administratorkonto zu registrieren. Du gelangst zum E-Mail-Bestätigungsbildschirm.
Wenn deine SMTP-Einstellungen korrekt sind, erhältst du eine E-Mail zur Aktivierung des Kontos. Klicke auf den Link in deiner E-Mail, um die Einrichtung des Kontos abzuschließen.
Klicke auf die Schaltfläche Aktivieren, um die Installation abzuschließen.
Du gelangst zum Bildschirm des Einrichtungsassistenten von Discourse. Du kannst ihn entweder überspringen und direkt mit dem Forum fortfahren oder den gesamten Assistenten durchlaufen.
Dein Discourse-Forum ist fertig. Der nächste Schritt ist die Installation von SSL und das Einrichten des Forums hinter dem Nginx-Server.
Schritt 7 – SSL installieren
Um ein SSL-Zertifikat mit Let’s Encrypt zu installieren, müssen wir das Tool Certbot installieren.
Dazu verwenden wir den Snapd-Paketinstaller. Da die meisten Debian-Server nicht mit diesem Paket ausgeliefert werden, installiere den Snapd-Installer.
$ sudo apt install snapd
Vergewissere dich, 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 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 Installation.
$ certbot --version certbot 1.22.0
Erstelle das SSL-Zertifikat.
$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d discourse.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/discourse.example.com auf deinem Server heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048
Erstelle ein Challenge-Webroot-Verzeichnis für die automatische Erneuerung von Let’s Encrypt.
$ sudo mkdir -p /var/lib/letsencrypt
Erstelle einen Cron Job zur Erneuerung des SSL-Zertifikats. Er wird jeden Tag ausgeführt, um das Zertifikat zu überprüfen und bei Bedarf zu erneuern. Erstelle dazu zunächst die Datei /etc/cron.daily/certbot-renew und öffne sie zur Bearbeitung.
$ sudo nano /etc/cron.daily/certbot-renew
Füge den folgenden Code ein.
#!/bin/sh certbot renew --cert-name discourse.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Ändere die Berechtigungen für die Aufgabendatei, um sie ausführbar zu machen.
$ sudo chmod +x /etc/cron.daily/certbot-renew
Schritt 8 – Nginx installieren und konfigurieren
Debian wird mit einer älteren Version von Nginx ausgeliefert. Du musst das offizielle Nginx-Repository herunterladen, um die neueste Version zu installieren.
Importiere den offiziellen Nginx-Signierschlüssel.
$ 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 arch=amd64] \
http://nginx.org/packages/debian `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list
Aktualisiere die Debian-Repositories.
$ sudo apt update
Installiere Nginx.
$ sudo apt install nginx
Überprüfe die Installation. Achte darauf, dass du jedes Mal sudo verwendest, wenn du den Nginx-Befehl unter Debian ausführst. Sonst wird es nicht funktionieren.
$ sudo nginx -v nginx version: nginx/1.20.2
Erstelle und öffne die Datei /etc/nginx/conf.d/discourse.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/discourse.conf
Füge den folgenden Code in die Datei ein.
# enforce HTTPS
server {
listen 80;
listen [::]:80;
server_name discourse.example.com;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name discourse.example.com;
access_log /var/log/nginx/discourse.access.log;
error_log /var/log/nginx/discourse.error.log;
# SSL
ssl_certificate /etc/letsencrypt/live/discourse.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/discourse.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/discourse.example.com/chain.pem;
ssl_session_timeout 5m;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers on;
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;
ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
resolver 8.8.8.8;
client_max_body_size 100m;
location / {
proxy_pass http://discourse.example.com:8080/;
proxy_set_header Host $http_host;
proxy_http_version 1.1;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Real-IP $remote_addr;
}
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du danach gefragt wirst.
Öffne die Datei /etc/nginx/nginx.conf zur Bearbeitung.
$ 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.
Ü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, um die neue Konfiguration zu aktivieren.
$ sudo systemctl start nginx
Schritt 9 – Discourse-Befehle
Aktiviere den Discourse Administrator über die Kommandozeile
Wenn du die Aktivierungs-E-Mail nicht erhältst, kannst du den Administrator-Account auch über die Kommandozeile aktivieren.
Wechsle in das Discourse-Verzeichnis.
$ cd /var/discourse
Gib die Discourse Container Shell ein.
$ sudo ./launcher enter app
Gib den Befehl rails c ein, um die Rails-Eingabeaufforderung aufzurufen.
root@discourse-app:/var/www/discourse# rails c
Du wirst die folgende Eingabeaufforderung sehen.
[1] pry(main)>
Gib den Befehl ein, um das Administratorkonto zu finden.
[1] pry(main)> User.find_by_email("name@example.com")
=> #<User:0x00005564492032a0
id: 1,
username: "username",
created_at: Sun, 06 Feb 2022 14:46:58.451302000 UTC +00:00,
updated_at: Sun, 06 Feb 2022 14:54:17.079564000 UTC +00:00,
name: nil,
seen_notification_id: 4,
last_posted_at: nil,
password_hash: "[FILTERED]",
salt: "20d6012d3c98da70896dcfc27bc9d264",
active: true,
username_lower: "username",
last_seen_at: Mon, 07 Feb 2022 08:34:12.435844000 UTC +00:00,
admin: true,
last_emailed_at: Sun, 06 Feb 2022 14:47:00.694121000 UTC +00:00,
trust_level: 1,
approved: false,
approved_by_id: nil,
approved_at: nil,
previous_visit_at: Sun, 06 Feb 2022 15:40:35.804941000 UTC +00:00,
suspended_at: nil,
suspended_till: nil,
date_of_birth: nil,
views: 0,
flag_level: 0,
ip_address: #<IPAddr: IPv4:69.28.90.35/255.255.255.255>,
moderator: false,
title: nil,
uploaded_avatar_id: 3,
:
Gib q ein, um zur Eingabeaufforderung zurückzukehren und gib die folgenden Befehle nacheinander ein.
[2] pry(main)> user.approved = true [3] pry(main)> user.save [4] pry(main)> EmailToken.confirm(user.email_tokens.first.token)
Gib zweimal exit ein, um zur Shell zurückzukehren. Dein Administratorkonto ist nun aktiviert und einsatzbereit.
Diskurs aktualisieren
Um das Forum zu aktualisieren, kannst du eine von zwei Möglichkeiten nutzen. Die erste Möglichkeit ist, das Upgrade über das Administrator-Dashboard durchzuführen. Die zweite Methode ist die Verwendung einer Kommandozeile.
Wechsle in das Discourse-Verzeichnis.
$ cd /var/discourse
Aktualisiere die Discourse-Installation, indem du dir die neuesten Dateien von Github holst.
$ git pull
Erstelle Discourse neu.
$ sudo ./launcher rebuild app
Jedes Mal, wenn du Änderungen an der Datei app.yml vornimmst, musst du Discourse neu erstellen. Nachdem du die Änderungen vorgenommen hast, führe den obigen Befehl aus. Er zerstört den alten Container, bootet einen neuen und startet ihn.
Discourse stoppen
$ sudo ./launcher stop
Discourse Logs ansehen
$ sudo ./launcher logs
Fazit
Damit ist der Lehrgang abgeschlossen. Du hast das Discourse-Forum mit Docker hinter dem Nginx-Webserver auf einem Debian 11-Server installiert. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.