Come installare Discourse Forum con Nginx e Free Lets Encrypt SSL su Debian 11

Discourse è una piattaforma di discussione della community open source creata utilizzando il linguaggio Ruby. È progettato per funzionare come forum, software di chat o mailing list. Si integra facilmente con altre piattaforme e le sue funzionalità possono essere ampliate con i plugin.

In questo tutorial imparerai come installare Discourse Forum con il server Nginx su un server basato su Debian 11.

Prerequisiti

• Un server che esegue Debian 11 con un minimo di 1 GB di RAM e 1 Core CPU. L'impostazione del discorso creerà automaticamente una partizione di swap su sistemi con 1 GB o meno di RAM. Pertanto, si consiglia di installarlo su un sistema con almeno 2 GB di RAM.

• Un utente non root con privilegi sudo.

• Un nome di dominio (discourse.example.com ) che punta al server.

• Tutto è aggiornato.

  $ sudo apt update && sudo apt upgrade
  

• Pochi pacchetti di cui il tuo sistema ha bisogno.

  $ sudo apt install nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release debian-archive-keyring -y
  

  Alcuni di questi pacchetti potrebbero essere già installati sul tuo sistema.

Passaggio 1:configurazione del firewall

Il primo passo è configurare il firewall. Debian viene fornito con ufw (Uncomplicated Firewall).

Controlla se il firewall è in esecuzione.

$ sudo ufw status

Dovresti ottenere il seguente output.

Status: inactive

Consenti porta SSH in modo che il firewall non interrompa la connessione corrente quando lo si abilita.

$ sudo ufw allow OpenSSH

Consenti anche le porte HTTP e HTTPS.

$ sudo ufw allow 80/tcp
$ sudo ufw allow 443/tcp

Abilita il Firewall

$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Ricontrolla lo stato del firewall.

$ sudo ufw status

Dovresti vedere un output simile.

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)

Passaggio 2:installa Git

Installa Git utilizzando l'Appstream predefinito.

$ sudo dnf install git

Conferma l'installazione.

$ git --version
git version 2.30.2

Esegui i seguenti comandi per configurare l'installazione di Git.

$ git config --global user.name "Your Name"
$ git config --global user.email "[email protected]"

Passaggio 3 - Installa Docker

Per installare l'ultima versione di Docker, aggiungi la chiave GPG ufficiale di Docker.

$ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Installa il repository Docker ufficiale.

$ 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

Aggiorna i repository di sistema Debian.

$ sudo apt update

Installa l'ultima versione di Docker.

$ sudo apt install docker-ce docker-ce-cli containerd.io

Verifica che Docker sia in esecuzione.

$ 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>

Per impostazione predefinita, Docker richiede i privilegi di root. Se vuoi evitare di usare sudo ogni volta che esegui la docker comando, aggiungi il tuo nome utente alla docker gruppo.

$ sudo usermod -aG docker $(whoami)

Per abilitare questa modifica, dovrai disconnetterti dal server e riconnetterti con lo stesso utente.

Fase 4 - Scarica Discourse

Crea la directory principale per Discourse.

$ sudo mkdir /var/discourse

Clona il repository Github di Discourse Docker.

$ sudo git clone https://github.com/discourse/discourse_docker.git /var/discourse

Fase 5:configura il discorso

Crea il file di configurazione app.yml copiando l'esempio standalone.yml file.

$ sudo cp samples/standalone.yml containers/app.yml

Apri app.yml per la modifica.

$ sudo nano containers/app.yml

Imposta dominio

Imposta la variabile DISCOURSE_HOSTNAME al nome di dominio che hai scelto per il tuo forum. Se non disponi di un nome di dominio, puoi utilizzare un indirizzo IP qui.

DISCOURSE_HOSTNAME: 'discourse.example.com'

Configura le porte esposte

Modifica la riga "80:80 a "8080:80" . Questo cambierà la porta HTTP esterna per Discourse in 8080 poiché useremo Nginx alla porta 80. Commenta il "443:443" riga poiché installeremo SSL esternamente.

expose:
  - "8080:80"   # http
  #- "443:443" # https

Configura impostazioni SMTP

Compila le seguenti variabili a seconda del servizio di posta elettronica transazionale che stai utilizzando. Imposta l'email per il tuo account amministratore utilizzando la variabile DISCOURSE_DEVELOPER_EMAILS . Questo passaggio è obbligatorio, altrimenti il ​​tuo forum non verrà avviato.

..
DISCOURSE_DEVELOPER_EMAILS: '[email protected]'
..
DISCOURSE_SMTP_ADDRESS: smtp.example.com
DISCOURSE_SMTP_PORT: 587
DISCOURSE_SMTP_USER_NAME: [email protected]
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: [email protected]    # (address to send notifications from)

Impostazioni memoria (opzionale)

Se il tuo server ha poca RAM, puoi configurare le seguenti variabili di conseguenza per ridurre il footprint di memoria di Discourse.

db_shared_buffers: '128MB'
UNICORN_WORKERS: 2

La variabile db_shared_buffers è solitamente impostato al 25% della memoria disponibile.

Impostazioni GeoLite2 (opzionale)

Se desideri la funzione di ricerca IP su Discourse, registrati per l'account Maxmind Geolite2 gratuito e ottieni una chiave di licenza. Incolla la chiave di licenza come valore per la seguente variabile.

DISCOURSE_MAXMIND_LICENSE_KEY: your_maxmind_license_key

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Passaggio 6 - Installa Discourse

Esegui il comando seguente per avviare il tuo contenitore Discourse.

$ sudo ./launcher bootstrap app

Avvia l'applicazione Discorso.

$ sudo ./launcher start app

Puoi accedere al forum visitando gli URL http://yourserver_IP:8080 o http://discourse.example.com:8080 nel tuo browser. Otterrai la seguente schermata.

Fai clic su Registrati pulsante per procedere. L'ID email impostato in app.yml il file sarà precompilato per te.

Fai clic su Registrati pulsante per registrare l'account amministratore. Passerai alla schermata di conferma dell'e-mail.

Se le tue impostazioni SMTP sono corrette, riceverai una mail per attivare l'account. Fai clic sul link dalla tua email per completare la configurazione dell'account.

Fai clic su Attiva pulsante per terminare l'installazione.

Arriverai alla schermata della procedura guidata di configurazione del discorso. Puoi ignorarlo per procedere direttamente al forum o eseguire l'intera procedura guidata.

Il tuo forum sul discorso è pronto. Il prossimo passo è installare SSL e inserire il forum dietro il server Nginx.

Passaggio 7 - Installa SSL

Per installare un certificato SSL utilizzando Let's Encrypt, è necessario installare lo strumento Certbot.

Useremo il programma di installazione del pacchetto Snapd per questo. Poiché la maggior parte dei server Debian non viene fornita con esso, installa il programma di installazione Snapd.

$ sudo apt install snapd

Assicurati che la tua versione di Snapd sia aggiornata.

$ sudo snap install core && sudo snap refresh core

Installa Certbot.

$ sudo snap install --classic certbot

Utilizzare il comando seguente per assicurarsi che il comando Certbot possa essere eseguito creando un collegamento simbolico al /usr/bin directory.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Verifica l'installazione.

$ certbot --version
certbot 1.22.0

Genera il certificato SSL.

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d discourse.example.com

Il comando precedente scaricherà un certificato in /etc/letsencrypt/live/discourse.example.com directory sul tuo server.

Genera un gruppo Diffie-Hellman certificato.

$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048

Crea una directory webroot di sfida per il rinnovo automatico di Let's Encrypt.

$ sudo mkdir -p /var/lib/letsencrypt

Crea un Cron Job per rinnovare l'SSL. Verrà eseguito ogni giorno per controllare il certificato e rinnovarlo se necessario. Per questo, prima crea il file /etc/cron.daily/certbot-renew e aprilo per la modifica.

$ sudo nano /etc/cron.daily/certbot-renew

Incolla il seguente codice.

#!/bin/sh
certbot renew --cert-name discourse.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Modifica le autorizzazioni sul file dell'attività per renderlo eseguibile.

$ sudo chmod +x /etc/cron.daily/certbot-renew

Passaggio 8 - Installa e configura Nginx

Debian viene fornito con una versione precedente di Nginx. Devi scaricare il repository Nginx ufficiale per installare l'ultima versione.

Importa la chiave di firma Nginx ufficiale.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
	 | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Aggiungi il repository per la versione stabile di Nginx.

$ 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

Aggiorna i repository Debian.

$ sudo apt update

Installa Nginx.

$ sudo apt install nginx

Verificare l'installazione. Assicurati di utilizzare sudo ogni volta che esegui il comando Nginx su Debian. Altrimenti, non funzionerà.

$ sudo nginx -v
nginx version: nginx/1.20.2

Crea e apri il file /etc/nginx/conf.d/discourse.conf per la modifica.

$ sudo nano /etc/nginx/conf.d/discourse.conf

Incolla il seguente codice al suo interno.

# 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;
    }    
}

Salva il file premendo Ctrl + X e inserendo Y quando richiesto una volta terminato.

Apri il file /etc/nginx/nginx.conf per la modifica.

$ sudo nano /etc/nginx/nginx.conf

Aggiungi la riga seguente prima della riga include /etc/nginx/conf.d/*.conf; .

server_names_hash_bucket_size  64;

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Verifica la sintassi del file di configurazione Nginx.

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Avvia il servizio Nginx per abilitare la nuova configurazione.

$ sudo systemctl start nginx

Fase 9 - Comandi del discorso

Attiva Discourse Administrator dalla riga di comando

Se non ricevi l'email di attivazione, puoi attivare l'account amministratore dalla riga di comando.

Passa alla directory del discorso.

$ cd /var/discourse

Entra nella shell del contenitore del discorso.

$ sudo ./launcher enter app

Immettere il comando rails c per accedere al prompt dei comandi di Rails.

[email protected]:/var/www/discourse# rails c

Vedrai il seguente messaggio.

[1] pry(main)> 

Immettere il comando per individuare l'account amministratore.

[1] pry(main)>  User.find_by_email("[email protected]")
=> #<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,
:

Inserisci q per tornare al prompt e immettere i seguenti comandi in sequenza.

[2] pry(main)> user.approved = true
[3] pry(main)> user.save
[4] pry(main)> EmailToken.confirm(user.email_tokens.first.token)

Digita exit due volte per tornare alla shell. Il tuo account amministratore è attivato e pronto per l'uso.

Aggiorna discorso

Per aggiornare il forum, puoi utilizzare uno dei due modi. Il primo modo è aggiornarlo tramite la dashboard dell'amministratore. Il secondo metodo consiste nell'usare una riga di comando.

Passa alla directory del discorso.

$ cd /var/discourse

Aggiorna l'installazione di Discourse prendendo i file più recenti da Github.

$ git pull

Ricostruisci il discorso.

$ sudo ./launcher rebuild app

Devi ricostruire Discourse ogni volta che apporti modifiche a app.yml file. Dopo aver apportato le modifiche, eseguire il comando sopra. Distrugge il vecchio contenitore, ne avvia uno nuovo e lo avvia.

Interrompi il discorso

$ sudo ./launcher stop

Visualizza registri del discorso

$ sudo ./launcher logs

Conclusione

Questo conclude il tutorial. Hai installato il forum Discourse usando Docker dietro il server web Nginx su un server Debian 11. Se hai domande, pubblicale nei commenti qui sotto.