Come installare Mattermost Team Messaging System su Ubuntu 22.04

Questo tutorial esiste per queste versioni del sistema operativo

Ubuntu 22.04 (Jammy Jellyfish)
Ubuntu 20.04 (Focal Fossa)

Su questa pagina

Prerequisiti
Passaggio 1: configurazione del firewall
Passaggio 2 - Installa PostgreSQL
Passaggio 3 - Configurare PostgreSQL
Passaggio 4 - Scarica Mattermost
Passaggio 5: crea un utente di sistema per Mattermost e configura le autorizzazioni
Passaggio 6 - Crea un file di unità Systemd
Passaggio 7 - Installa Nginx
Passaggio 8 - Installa SSL
Passaggio 9 - Configura Nginx
Passaggio 10 - Accedi a Mattermost Server
Passaggio 11 - Configura Mattermost Server
1. Configura le notifiche e-mail
Mattermost è una piattaforma di messaggistica open source utilizzata per la chat, la condivisione di file, la gestione dei progetti e l'orchestrazione del flusso di lavoro. È scritto in lingua Go. Viene offerto sia come soluzione ospitata nel cloud che come server self-hosted. È un'alternativa a Slack e ad altre piattaforme professionali. La possibilità di ospitarlo sul tuo server ti consente di avere il controllo sulle tue comunicazioni e sui dati sensibili.
In questo tutorial imparerai come installare Mattermost Team Messaging System su un server Ubuntu 22.04.
Prerequisiti
- A server running Ubuntu 22.04 with a minimum of 2 GB of RAM for up to 1000 users.
- A non-root user with sudo privileges.
- The Uncomplicated Firewall(UFW) is enabled and running.
- A Fully Qualified domain name pointed to the server. For our tutorial, we will be using the domain mattermost.example.com.
- Everything is updated.
```
$ sudo apt update && sudo apt upgrade
```
Passaggio 1: configurare il firewall
Il primo passo prima di installare qualsiasi pacchetto è configurare il firewall per consentire le connessioni HTTP e HTTPS.
Controlla lo stato del firewall.
```
$ sudo ufw status
```
Dovresti vedere qualcosa di simile al seguente.
```
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
```
La porta 8065 è richiesta da Mattermost. Questa porta deve essere aperta solo temporaneamente per confermare l'installazione. Lo rimuoveremo in seguito.
```
$ sudo ufw allow 8065
```
Consenti porte HTTP e HTTPs.
```
$ sudo ufw allow http
$ sudo ufw allow https
```
Controlla di nuovo lo stato per confermare.
```
$ sudo ufw status
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
8065                       ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)
8065 (v6)                  ALLOW       Anywhere (v6)
```
Passaggio 2: installa PostgreSQL

Mattermost può funzionare con entrambi i server MySQL e PostgreSQL, ma PostgreSQL è la scelta consigliata.
Ubuntu 22.04 viene fornito con l'ultima versione stabile (v14) di PostgreSQL. Puoi installarlo con un singolo comando.
```
$ sudo apt install postgresql postgresql-contrib
```
Controlla la versione di MySQL.
```
$ psql --version
psql (PostgreSQL) 14.4 (Ubuntu 14.4-0ubuntu0.22.04.1)
```
Passaggio 3: configurare PostgreSQL
PostgreSQL crea un account utente Linux postgres durante l'installazione. È possibile accedere alla shell PostgreSQL utilizzando questo account.
Accedi alla shell PostgreSQL.
```
$ sudo -u postgres psql
```
Crea il database Mattermost.
```
postgres=# CREATE DATABASE mattermostdb;
```
Creare l'utente del database Mattermost. Sostituisci mmuser-password con una password più sicura di tua scelta.
```
postgres=# CREATE USER mmuser WITH PASSWORD 'mmuser-password';
```
Concedere tutti i privilegi sul database all'utente.
```
postgres=# GRANT ALL PRIVILEGES ON DATABASE mattermost to mmuser;
```
Esci dalla shell PostgreSQL inserendo \q nella shell.
```
postgres=# \q
```
Apri il file /etc/postgresql/{version}/main/pg_hba.conf per la modifica.
```
$ sudo nano /etc/postgresql/{version}/main/pg_hba.conf
```
Trova le seguenti righe.
```
# "local" is for Unix domain socket connections only
local   all             all                                     peer
# IPv4 local connections:
host    all             all             127.0.0.1/32            scram-sha-256
# IPv6 local connections:
host    all             all             ::1/128                 scram-sha-256
```
Cambia i valori peer e scram-sha-256 in trust nelle righe precedenti.
```
# "local" is for Unix domain socket connections only
local   all             all                                     trust
# IPv4 local connections:
host    all             all             127.0.0.1/32            trust
# IPv6 local connections:
host    all             all             ::1/128                 trust
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Riavvia il servizio PostgreSQL per abilitare la modifica.
```
$ sudo systemctl restart postgresql
```
Verifica di poterti connettere all'utente Mattermost SQL.
```
$ psql --dbname=mattermost --username=mmuser --password
```
Ti verrà richiesta la password. Inseriscilo e sarai connesso alla shell PostgreSQL. Immettere \q per uscire dalla shell.
```
Password:
psql (14.4 (Ubuntu 14.4-0ubuntu0.22.04.1))
Type "help" for help.

mattermost-> \q
```
Passaggio 4: scarica Mattermost
Scarica l'ultima versione del server Mattermost. Al momento della stesura di questo tutorial, l'ultima versione disponibile è la 7.0.1.
```
$ wget https://releases.mattermost.com/7.0.1/mattermost-7.0.1-linux-amd64.tar.gz
```
Estrai l'archivio.
```
$ tar -xvzf mattermost*.gz
```
Sposta i file estratti nella directory /opt.
```
$ sudo mv mattermost /opt
```
Crea la directory di archiviazione dei dati per il server Mattermost.
```
$ sudo mkdir /opt/mattermost/data
```
Passaggio 5: creare un utente di sistema per Mattermost e configurare le autorizzazioni
Apri il file di configurazione /opt/mattermost/config/config.json per la modifica.
```
$ sudo nano /opt/mattermost/config/config.json
```
Imposta la variabile SiteURL sul nome di dominio che desideri utilizzare per la tua installazione.
```
"SiteURL": "https://mattermost.example.com",
```
Trova la variabile DriverName sotto SqlSettings e cambia il suo valore in mysql.
```
"DriverName": "mysql",
```
Imposta la variabile DataSource sul seguente valore. Sostituisci mmuser con il nome utente SQL, YourPassword23! con la password SQL e mattermostdb con il nome del database , configurato nel passaggio 4.
```
"DataSource": "mmuser:(localhost:3306)/mattermostdb?charset=utf8mb4,utf8&writeTimeout=30s",
```
Ci sono molte altre impostazioni che puoi configurare a questo punto, ma sarebbe più semplice eseguirle dopo l'installazione. Per ora, solo queste due impostazioni sono essenziali.
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Crea un utente e un gruppo di sistema per il server Mattermost.
```
$ sudo useradd --system --user-group mattermost
```
Cambia la proprietà della directory Mattermost all'utente e al gruppo appena creati.
```
$ sudo chown -R mattermost:mattermost /opt/mattermost
```
Assegna i permessi di scrittura al gruppo mattermost nella directory.
```
$ sudo chmod -R g+w /opt/mattermost
```
Passa alla directory Mattermost.
```
$ cd /opt/mattermost
```
Avvia il server Mattermost come utente mattermost.
```
$ sudo -u mattermost ./bin/mattermost
```
Il server verrà avviato e genererà una serie di informazioni di registro. Attendi che appaia la riga Il server è in ascolto su [::]:8065. Visita l'URL http://:8065 nel tuo browser e vedrai la seguente pagina di accesso.
Premi Ctrl + C per fermare il server. Torneremo su questo in seguito per configurare l'installazione.
Passaggio 6: creare un file di unità Systemd
Il prossimo passo è creare un file di sistema per Mattermost.
Creare e aprire il file dell'unità per la modifica.
```
$ sudo nano /lib/systemd/system/mattermost.service
```
Incolla il seguente codice al suo interno.
```
[Unit]
Description=Mattermost
After=network.target
After=postgresql.service
BindsTo=postgresql.service

[Service]
Type=notify
ExecStart=/opt/mattermost/bin/mattermost
TimeoutStartSec=3600
KillMode=mixed
Restart=always
RestartSec=10
WorkingDirectory=/opt/mattermost
User=mattermost
Group=mattermost
LimitNOFILE=49152

[Install]
WantedBy=multi-user.target
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Ricarica il demone systemd per caricare il file di servizio.
```
$ sudo systemctl daemon-reload
```
Avvia il servizio Mattermost.
```
$ sudo systemctl start mattermost
```
Controlla lo stato del servizio.
```
? mattermost.service - Mattermost
     Loaded: loaded (/lib/systemd/system/mattermost.service; disabled; vendor preset: enabled)
     Active: active (running) since Mon 2022-07-11 01:24:46 UTC; 20s ago
   Main PID: 23628 (mattermost)
      Tasks: 48 (limit: 2241)
     Memory: 448.2M
        CPU: 14.929s
     CGroup: /system.slice/mattermost.service
             ??23628 /opt/mattermost/bin/mattermost
             ??23651 plugins/com.mattermost.plugin-channel-export/server/dist/plugin-linux-amd64
             ??23656 plugins/com.mattermost.nps/server/dist/plugin-linux-amd64
             ??23662 plugins/com.mattermost.calls/server/dist/plugin-linux-amd64
             ??23668 plugins/com.mattermost.apps/server/dist/plugin-linux-amd64
             ??23674 plugins/playbooks/server/dist/plugin-linux-amd64
             ??23683 plugins/focalboard/server/dist/plugin-linux-amd64
 ....
```
Abilita il servizio.
```
$ sudo systemctl enable mattermost
```
Passaggio 7: installa Nginx
Ubuntu 22.04 viene fornito con una versione precedente di Nginx. Per installare l'ultima versione, devi scaricare il repository Nginx ufficiale.
Importa la chiave di firma Nginxs.
```
$ 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/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list
```
Aggiorna i repository di sistema.
```
$ sudo apt update
```
Installa Nginx.
```
$ sudo apt install nginx
```
Verificare l'installazione.
```
$ nginx -v
nginx version: nginx/1.22.0
```
Passaggio 8: installa SSL
Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot usando il repository Ubuntus o prendere l'ultima versione usando lo strumento Snapd. Useremo la versione Snapd.
Ubuntu 22.04 viene fornito con Snapd installato per impostazione predefinita. Esegui i seguenti comandi per assicurarti che la tua versione di Snapd sia aggiornata.
```
$ sudo snap install 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
```
Eseguire il seguente comando per generare un certificato SSL.
```
$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m  -d mattermost.example.com
```
Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/mattermost.example.com sul tuo server.
Genera un certificato di gruppo Diffie-Hellman.
```
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
```
Apri il file /etc/letsencrypt/renewal/mattermost.example.com.conf per la modifica.
```
$ sudo nano /etc/letsencrypt/renewal/mattermost.example.com.conf
```
Incolla il seguente codice in fondo.
```
pre_hook = systemctl stop nginx
post_hook = systemctl start nginx
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Abbiamo generato il certificato SSL utilizzando l'opzione standalone di Certbot. Esegue il suo server Web per creare il certificato, il che significa che Nginx dovrebbe essere spento durante il rinnovo. I comandi pre_hook e post_hook vengono eseguiti prima e dopo il rinnovo per arrestare e riavviare automaticamente il server Nginx, quindi non richiedono alcun intervento manuale.
Per verificare se il rinnovo SSL funziona correttamente, eseguire un'esecuzione a secco del processo.
```
$ sudo certbot renew --dry-run
```
Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.
Passaggio 9: configurare Nginx
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.
Crea e apri il file /etc/nginx/conf.d/monica.conf per la modifica.
```
$ sudo nano /etc/nginx/conf.d/mattermost.conf
```
Incolla il seguente codice al suo interno. Sostituisci mattermost.example.com con il tuo nome di dominio. Assicurati che il valore di client_max_body_size sia impostato su 10 MB, che è la dimensione di caricamento predefinita dei file in Monica. È lo stesso valore che abbiamo configurato con PHP in precedenza.
```
upstream backend {
   server 127.0.0.1:8065;
   keepalive 32;
}

proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=mattermost_cache:10m max_size=3g inactive=120m use_temp_path=off;

server {
  listen 80 default_server;
  server_name   mattermost.example.com;
  return 301 https://$server_name$request_uri;
}

server {
   listen 443 ssl http2;
   server_name    mattermost.example.com;

   http2_push_preload on; # Enable HTTP/2 Server Push

   ssl_certificate /etc/letsencrypt/live/mattermost.example.com/fullchain.pem;
   ssl_certificate_key /etc/letsencrypt/live/mattermost.example.com/privkey.pem;
   ssl_trusted_certificate /etc/letsencrypt/live/mattermost.example.com/chain.pem;
   ssl_session_timeout 1d;

   # Enable TLS versions (TLSv1.3 is required upcoming HTTP/3 QUIC).
   ssl_protocols TLSv1.2 TLSv1.3;

   # Enable TLSv1.3's 0-RTT. Use $ssl_early_data when reverse proxying to
   # prevent replay attacks.
   #
   # @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
   ssl_early_data on;

   ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
   ssl_prefer_server_ciphers on;
   ssl_session_cache shared:SSL:50m;
   # HSTS (ngx_http_headers_module is required) (15768000 seconds = six months)
   add_header Strict-Transport-Security max-age=15768000;
   # OCSP Stapling ---
   # fetch OCSP records from URL in ssl_certificate and cache them
   ssl_stapling on;
   ssl_stapling_verify on;
   ssl_dhparam /etc/ssl/certs/dhparam.pem;

   add_header X-Early-Data $tls1_3_early_data;

   location ~ /api/v[0-9]+/(users/)?websocket$ {
       proxy_set_header Upgrade $http_upgrade;
       proxy_set_header Connection "upgrade";
       client_max_body_size 50M;
       proxy_set_header Host $http_host;
       proxy_set_header X-Real-IP $remote_addr;
       proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
       proxy_set_header X-Forwarded-Proto $scheme;
       proxy_set_header X-Frame-Options SAMEORIGIN;
       proxy_buffers 256 16k;
       proxy_buffer_size 16k;
       client_body_timeout 60;
       send_timeout 300;
       lingering_timeout 5;
       proxy_connect_timeout 90;
       proxy_send_timeout 300;
       proxy_read_timeout 90s;
       proxy_http_version 1.1;
       proxy_pass http://backend;
   }

   location / {
       client_max_body_size 50M;
       proxy_set_header Connection "";
       proxy_set_header Host $http_host;
       proxy_set_header X-Real-IP $remote_addr;
       proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
       proxy_set_header X-Forwarded-Proto $scheme;
       proxy_set_header X-Frame-Options SAMEORIGIN;
       proxy_buffers 256 16k;
       proxy_buffer_size 16k;
       proxy_read_timeout 600s;
       proxy_cache mattermost_cache;
       proxy_cache_revalidate on;
       proxy_cache_min_uses 2;
       proxy_cache_use_stale timeout;
       proxy_cache_lock on;
       proxy_http_version 1.1;
       proxy_pass http://backend;
   }
}

# This block is useful for debugging TLS v1.3. Please feel free to remove this
# and use the `$ssl_early_data` variable exposed by NGINX directly should you
# wish to do so.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Concedi a Nginx le autorizzazioni per la directory della cache.
```
$ sudo chown -R nginx:nginx /var/cache/nginx
```
Verifica la configurazione di Nginx.
```
$ sudo nginx -t
```
Riavvia il server Nginx.
```
$ sudo systemctl restart nginx
```
Passaggio 10: accedere al server Mattermost
Apri l'URL https://mattermost.example.com nel tuo browser e verrai accolto con la pagina di registrazione come mostrato nel passaggio 5. Inserisci i dettagli del tuo account e verrà impostato come l'amministratore di sistema.
Prima di procedere oltre, dobbiamo chiudere la porta 8065 poiché abbiamo configurato Mattermost in modo che sia accessibile tramite un URL pubblico. Pertanto, la porta aperta rappresenta un rischio per la sicurezza.
```
$ sudo ufw delete allow 8065
```
Successivamente, verrai indirizzato alla pagina di creazione del team.
Fai clic sul pulsante Crea una squadra per creare la tua prima squadra.
Successivamente, ti verrà chiesto di impostare un URL pubblico per il team.
Fare clic sul pulsante Fine per aprire la Dashboard Mattermost.
Passaggio 11: configurare il server Mattermost
Puoi configurare Mattermost utilizzando il file config.json o utilizzando la console di sistema dalla dashboard. Lo faremo tramite la dashboard poiché è molto più semplice in questo modo. Fare clic sul pulsante del prodotto nell'angolo in alto a sinistra, quindi selezionare l'opzione Console di sistema.
Verrai indirizzato alla dashboard della console di sistema da dove potrai configurare tutto ciò che riguarda il server.
Configura le notifiche e-mail
Una delle caratteristiche più importanti di un sistema di messaggistica sono le notifiche e-mail.
Il primo passo è abilitare le notifiche. Visita la Console di sistema >> Configurazione del sito >> menu Noficiations e imposta le seguenti opzioni.
- Imposta Abilita notifiche e-mail su true
- Imposta Nome visualizzato notifica su Nessuna risposta
- Imposta Notifica dall'indirizzo su qualcosa di simile a [email protetto].
- Imposta l'indirizzo email dell'assistenza su qualcosa di simile a [email protetta]
Il passaggio successivo consiste nell'abilitare SMTP. Visita il menu Console di sistema >> Ambiente >> SMTP e imposta le seguenti opzioni. Per il nostro tutorial, utilizziamo il mailer di Amazon SES.
- Imposta il server SMTP su {SMTP-server}
- Imposta la porta del server SMTP su 465
- Imposta Abilita autenticazione SMTP su true
- Imposta il nome utente del server SMTP su {SES-username}
- Imposta la password del server SMTP su {SES-Key}
- Imposta la sicurezza della connessione su TLS o STARTTLS, a seconda di cosa accetta il server SMTP
Fare clic sul pulsante Prova connessione per confermare le impostazioni SMTP.
Ci sono molte più impostazioni da configurare. Una volta terminato, è necessario riavviare il server dal terminale per applicare le modifiche.
```
$ sudo systemctl restart mattermost
```
Conclusione
Questo conclude il nostro tutorial sull'installazione e la configurazione del sistema Mattermost Team Messaging su un server Ubuntu 22.04. Se hai domande, pubblicale nei commenti qui sotto.

Come installare Mattermost Team Messaging System su Ubuntu 22.04

Questo tutorial esiste per queste versioni del sistema operativo

Su questa pagina

Prerequisiti

Passaggio 1: configurare il firewall

Passaggio 2: installa PostgreSQL

Passaggio 3: configurare PostgreSQL

Passaggio 4: scarica Mattermost

Passaggio 5: creare un utente di sistema per Mattermost e configurare le autorizzazioni

Passaggio 6: creare un file di unità Systemd

Passaggio 7: installa Nginx

Passaggio 8: installa SSL

Passaggio 9: configurare Nginx

Passaggio 10: accedere al server Mattermost

Passaggio 11: configurare il server Mattermost

Configura le notifiche e-mail

Conclusione