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

Su questa pagina

Prerequisiti
Passaggio 1: configurazione del firewall
Passaggio 2 - Installa Git
Passaggio 3 - Installa Docker
Passaggio 4 - Scarica Discorso
Passaggio 5: configurazione del discorso
1. Imposta dominio
2. Configura le porte esposte
3. Configura impostazioni SMTP
4. Impostazioni memoria (opzionale)
5. Impostazioni GeoLite2 (opzionale)
1. Attiva Discourse Administrator dalla riga di comando
2. Aggiorna discorso
3. Ferma il discorso
4. Visualizza i registri dei discorsi
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 espanse con i plug-in.
In questo tutorial imparerai come installare Discourse Forum con il server Nginx su un server basato su Debian 11.
Prerequisiti
- A server running Debian 11 with a minimum of 1GB RAM and 1 Core CPU. Discourse setup will automatically create a swap partition on systems with 1GB or less RAM. Therefore, it is recommended to install it on a system with at least 2GB RAM.
- A non-root user with sudo privileges.
- A Domain name (discourse.example.com) pointing to the server.
- Everything is updated.
```
$ sudo apt update && sudo apt upgrade
```
- Few packages that your system needs.
```
$ sudo apt install nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release debian-archive-keyring -y
```
  Some of these packages may already be installed on your system.
Passaggio 1: configurare il 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 attivandola.
```
$ sudo ufw allow OpenSSH
```
Consenti anche 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
```
Controlla di nuovo 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
```
Eseguire i seguenti comandi per configurare l'installazione di Git.
```
$ git config --global user.name "Your Name"
$ git config --global user.email ""
```
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
```
Verificare 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 il comando docker, aggiungi il tuo nome utente alla docker gruppo.
```
$ sudo usermod -aG docker $(whoami)
```
Per abilitare questa modifica, sarà necessario disconnettersi dal server e riconnettersi con lo stesso utente.
Passaggio 4: scarica il discorso
Crea la directory principale per Discourse.
```
$ sudo mkdir /var/discourse
```
Clona il repository Github ufficiale di Discourse Docker.
```
$ sudo git clone https://github.com/discourse/discourse_docker.git /var/discourse
```
Passaggio 5: configurazione del discorso
Crea il file di configurazione app.yml copiando il file di esempio standalone.yml.
```
$ 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 hai un nome di dominio, puoi utilizzare un indirizzo IP qui.
```
DISCOURSE_HOSTNAME: 'discourse.example.com'
```
Configura le porte esposte
Cambia la riga \80:80 in \8080:80\. Questo cambierà la porta HTTP esterna per Discourse in 8080 poiché utilizzerà Nginx alla porta 80. Commenta la riga \443:443\ poiché installeremo SSL esternamente.
```
expose:
  - "8080:80"   # http
  #- "443:443" # https
```
Configura le impostazioni SMTP
Compila le seguenti variabili a seconda del servizio di posta elettronica transazionale che stai utilizzando. Imposta l'e-mail per il tuo account amministratore utilizzando la variabile DISCOURSE_DEVELOPER_EMAILS. Questo passaggio è obbligatorio altrimenti il tuo forum non verrà avviato.
```
..
DISCOURSE_DEVELOPER_EMAILS: ''
..
DISCOURSE_SMTP_ADDRESS: smtp.example.com
DISCOURSE_SMTP_PORT: 587
DISCOURSE_SMTP_USER_NAME: 
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:     # (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 Discourses.
```
db_shared_buffers: '128MB'
UNICORN_WORKERS: 2
```
La variabile db_shared_buffers è solitamente impostata 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 il discorso
Esegui il seguente comando per eseguire il bootstrap del 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 navigatore. Otterrai la seguente schermata.
Fare clic sul pulsante Registrati per procedere. L'ID email impostato nel file app.yml verrà precompilato per te.
Fare clic sul pulsante Registra per registrare l'account amministratore. Si procederà 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 e-mail per completare la configurazione dell'account.
Fare clic sul pulsante Attiva per completare l'installazione.
Verrà visualizzata la schermata di configurazione guidata dei discorsi. Puoi saltarlo per procedere direttamente al forum o eseguire l'intera procedura guidata.
Il tuo forum Discourse è pronto. Il prossimo passo è installare SSL e mettere il forum dietro il server Nginx.
Passaggio 7: installa SSL
Per installare un certificato SSL utilizzando Lets 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 di Snapd.
```
$ sudo apt install snapd
```
Assicurati che la tua versione di Snapd sia aggiornata.
```
$ sudo snap install core && sudo snap refresh core
```
Installa Cerbot.
```
$ sudo snap install --classic certbot
```
Utilizzare il seguente comando per assicurarsi che il comando Certbot possa essere eseguito creando un collegamento simbolico alla directory /usr/bin.
```
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
```
Verificare 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  -d discourse.example.com
```
Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/discourse.example.com sul tuo server.
Genera un certificato di gruppo Diffie-Hellman.
```
$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048
```
Crea una directory webroot di verifica per il rinnovo automatico di Lets 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, per prima cosa, crea il file /etc/cron.daily/certbot-renew e aprilo per modificarlo.
```
$ 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.
Modificare 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 Nginxs.
```
$ 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
```
Aggiungere 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.
Verificare la sintassi del file di configurazione di 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
```
Passaggio 9: comandi del discorso
Attiva Discourse Administrator dalla riga di comando
Se non ricevi l'e-mail di attivazione, puoi attivare l'account amministratore dalla riga di comando.
Passa alla directory Discorso.
```
$ cd /var/discourse
```
Entra nel contenitore del discorso Shell.
```
$ sudo ./launcher enter app
```
Immettere il comando rails c per accedere al prompt dei comandi di Rails.
```
:/var/www/discourse# rails c
```
Verrà visualizzato il seguente prompt.
```
[1] pry(main)> 
```
Immettere il comando per individuare l'account amministratore.
```
[1] pry(main)>  User.find_by_email("")
=> #<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,
:
```
Immettere 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.
Discorso sull'aggiornamento
Per aggiornare il forum, puoi utilizzare uno dei due modi. Il primo modo è aggiornarlo tramite la dashboard dell'amministratore. Il secondo metodo consiste nell'utilizzare una riga di comando.
Passa alla directory Discorso.
```
$ cd /var/discourse
```
Aggiorna l'installazione di Discourse recuperando i file più recenti da Github.
```
$ git pull
```
Ricostruisci il discorso.
```
$ sudo ./launcher rebuild app
```
Devi ricostruire Discourse ogni volta che apporti modifiche al file app.yml. Dopo aver apportato le modifiche, eseguire il comando sopra. Distrugge il vecchio contenitore, ne avvia uno nuovo e lo avvia.
Ferma il discorso
```
$ sudo ./launcher stop
```
Visualizza i registri dei discorsi
```
$ 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.

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

Su questa pagina

Prerequisiti

Passaggio 1: configurare il firewall

Passaggio 2: installa Git

Passaggio 3: installa Docker

Passaggio 4: scarica il discorso

Passaggio 5: configurazione del discorso

Imposta dominio

Configura le porte esposte

Configura le impostazioni SMTP

Impostazioni memoria (opzionale)

Impostazioni GeoLite2 (opzionale)

Passaggio 6: installa il discorso

Passaggio 7: installa SSL

Passaggio 8: installa e configura Nginx

Passaggio 9: comandi del discorso

Attiva Discourse Administrator dalla riga di comando

Discorso sull'aggiornamento

Ferma il discorso

Visualizza i registri dei discorsi

Conclusione