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.