Installare Mattermost su Ubuntu 16.04 con PostgreSQL e Nginx

Mattermost è una soluzione open source per chat di team che puoi ospitare autonomamente. Questa guida mostra come installare Mattermost su Ubuntu 16.04, usare PostgreSQL come database e configurare Nginx come reverse proxy con TLS self-signed per test. Seguendo i passaggi avrai un server Mattermost funzionante, servizio systemd e suggerimenti per sicurezza e troubleshooting.

Important: usa password sicure per il database e considera certificati TLS validi (Let’s Encrypt) per produzione.

Sommario rapido

• Requisiti e account utente
• Installare e configurare PostgreSQL
• Installare Mattermost come utente non-root
• Creare il servizio systemd per avviare Mattermost automaticamente
• Configurare Nginx come reverse proxy HTTPS
• Test, sicurezza, backup e risoluzione problemi

Introduzione

Mattermost è un sistema di messaggistica open source scritto in Golang e React. Fornisce un’alternativa self-hosted a Slack o HipChat e mette la comunicazione del team in un unico posto accessibile da desktop e dispositivi mobili. In questa guida pratichiamo un’installazione su Ubuntu 16.04 (64 bit) usando PostgreSQL come backend dati e Nginx come reverse proxy.

Definizione rapida: reverse proxy = server che riceve le richieste esterne e le inoltra al servizio applicativo locale (qui Mattermost).

Requisiti

• Ubuntu 16.04 64 bit
• Accesso SSH con privilegi sudo/root
• Nome di dominio configurato su DNS (consigliato per TLS)
• Porte: 80/443 aperte sul firewall per accesso esterno

Criteri di accettazione

• Il servizio systemd avvia Mattermost automaticamente dopo reboot
• L’interfaccia web è raggiungibile via HTTPS
• Le credenziali del DB sono state create e non sono visibili in chiaro a utenti non autorizzati

Step 1 - Installare e configurare PostgreSQL

Mattermost supporta MySQL e PostgreSQL; in questa guida useremo PostgreSQL.

Connettiti al server via SSH e aggiorna i repository:

ssh [email protected]
sudo apt-get update

Installa PostgreSQL:

sudo apt-get install postgresql postgresql-contrib

Dopo l’installazione, passa all’utente postgres e apri la shell psql:

su - postgres
psql

Cambia la password dell’utente postgres (scegli una password robusta):

\password postgres
Enter new password:

Crea il database e l’utente per Mattermost (sostituisci le password con valori sicuri):

CREATE DATABASE mattermostdb;
CREATE USER matteruser WITH PASSWORD 'matterpassword';
GRANT ALL PRIVILEGES ON DATABASE mattermostdb TO matteruser;
\q

Note:

• “matteruser” = nome utente PostgreSQL
• “matterpassword” = password scelta
• “mattermostdb” = nome del database

Backup rapido del DB (consiglio): esegui pg_dump regolarmente e archivia in luogo sicuro.

Step 2 - Installare e configurare Mattermost

Esegui Mattermost come utente non-root per motivi di sicurezza. Creiamo un utente linux dedicato chiamato “matter”.

useradd -m -s /bin/bash matter
passwd matter

Accedi come utente matter e scarica l’archivio Mattermost. Nell’esempio si usa la versione 3.4.0; verifica la pagina ufficiale per versioni aggiornate.

su - matter
wget https://releases.mattermost.com/3.4.0/mattermost-3.4.0-linux-amd64.tar.gz

Estrai l’archivio e entra nella cartella:

tar -xzvf mattermost-3.4.0-linux-amd64.tar.gz
cd mattermost/

Crea la directory per i file utente e modifica il file di configurazione:

mkdir data/
vim config/config.json

Modifiche consigliate nel file config/config.json:

• In ServiceSettings imposta Mattermost per ascoltare solo su localhost (così Nginx gestirà il traffico esterno):

"ListenAddress": "127.0.0.1:8065",

• In SqlSettings imposta il driver PostgreSQL e la stringa di connessione (sostituisci user/password/database):

"DriverName": "postgres",
"DataSource": "postgres://matteruser:[email protected]:5432/mattermostdb?sslmode=disable&connect_timeout=10",

Note importanti:

• Usa 127.0.0.1 se PostgreSQL è locale; per DB remoto inserisci l’IP/hostname del DB.
• In produzione valuta sslmode=require se il DB remoto supporta TLS.

Avvia Mattermost dalla cartella bin per un test manuale:

cd bin/
./platform

Premi Ctrl+C per terminare il processo di test.

Step 3 - Creare il servizio systemd per Mattermost

Crea un file di unità in /etc/systemd/system/mattermost.service per avviare Mattermost come servizio:

cd /etc/systemd/system/
vim mattermost.service

Incolla il seguente contenuto (verifica i percorsi se l’utente o la home differiscono):

[Unit]
Description=Mattermost is an open source, self-hosted Slack-alternative
After=syslog.target network.target

[Service]
Type=simple
User=matter
Group=matter
ExecStart=/home/matter/mattermost/bin/platform
PrivateTmp=yes
WorkingDirectory=/home/matter/mattermost
Restart=always
RestartSec=30
LimitNOFILE=49152

[Install]
WantedBy=multi-user.target

Ricarica systemd e avvia il servizio:

systemctl daemon-reload
systemctl start mattermost
systemctl enable mattermost

Controlla lo stato e le porte in ascolto:

netstat -plntu
systemctl status mattermost

Suggerimento: controlla i log di Mattermost in ./logs e i log di systemd con journalctl -u mattermost se qualcosa non parte.

Step 4 - Installare e configurare Nginx come reverse proxy

Nginx fungerà da proxy HTTPS verso Mattermost in ascolto su 127.0.0.1:8065.

Installa Nginx:

sudo apt-get install nginx

Crea la directory SSL e genera un certificato self-signed per test:

cd /etc/nginx/
mkdir ssl/; cd ssl/
openssl req -new -x509 -days 365 -nodes -out /etc/nginx/ssl/mattermost.crt -keyout /etc/nginx/ssl/mattermost.key
chmod 400 mattermost.key

Crea il virtual host:

cd /etc/nginx/sites-available/
vim mattermost

Config di esempio (sostituisci mattermost.mydomain.com con il tuo dominio):

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

server {
   listen 443 ssl;
   server_name mattermost.mydomain.com;

   ssl on;
   ssl_certificate /etc/nginx/ssl/mattermost.crt;
   ssl_certificate_key /etc/nginx/ssl/mattermost.key;
   ssl_session_timeout 5m;
   ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
   ssl_ciphers 'EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH';
   ssl_prefer_server_ciphers on;
   ssl_session_cache shared:SSL:10m;

   location / {
      gzip off;
      proxy_set_header X-Forwarded-Ssl on;
      client_max_body_size 50M;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection "upgrade";
      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_pass http://127.0.0.1:8065;
   }
}

Attiva il sito:

ln -s /etc/nginx/sites-available/mattermost /etc/nginx/sites-enabled/
nginx -t
systemctl restart nginx

Note di produzione:

• Sostituisci il certificato self-signed con uno valido (Let’s Encrypt) prima della messa in produzione.
• Abilita HTTP/2 e disabilita protocolli obsoleti se il client/server lo supportano.

Step 5 - Testare l’installazione

Apri il browser e visita il dominio configurato, ad esempio:

https://mattermost.mydomain.com

Dovresti essere reindirizzato in HTTPS. Crea un account cliccando su “Create Account” e procedi alla creazione del team o all’accesso alla System Console.

Risultato: Mattermost con PostgreSQL e Nginx su Ubuntu 16.04 è installato e raggiungibile via HTTPS.

Sicurezza e hardening (consigli)

• Usa certificati validi (Let’s Encrypt) in produzione.
• Non usare certificati self-signed per servizi pubblici.
• Esegui Mattermost come utente non-root e limita i permessi dei file.
• Aggiorna regolarmente Mattermost e PostgreSQL.
• Configura backup automatizzati del DB (pg_dump o replica) e dei file in ./data.
• Proteggi la porta di amministrazione con firewall e IP allowlist quando possibile.

Backup e ripristino

• Backup DB: pg_dump -U matteruser -h 127.0.0.1 -F c mattermostdb > mattermostdb.dump
• Ripristino: pg_restore -U matteruser -d mattermostdb mattermostdb.dump
• Backup dei file: tar o rsync della cartella /home/matter/mattermost/data

Monitoraggio e metriche consigliate

• Controlla latenza delle richieste e uso CPU/RAM del processo platform
• Log da monitorare: logs/mattermost.log e systemd journal
• Imposta alert per availability e spazio su disco

Checklist per ruoli

• Sysadmin

  • Creare utente Linux ‘matter’
  • Installare PostgreSQL e creare DB/utente
  • Configurare systemd, Nginx e TLS
  • Impostare backup e monitoraggio

• Admin applicazione

  • Creare team e utenti
  • Configurare policy di password e autenticazione (LDAP/SAML se necessario)
  • Verificare integrazioni e plugin

• Security officer

  • Valutare TLS e CORS
  • Abilitare MFA per account admin
  • Eseguire scansioni di vulnerabilità periodiche

Troubleshooting comune

• Errore connessione DB: verificare DataSource in config.json e che PostgreSQL accetti connessioni locali.
• Mattermost non parte: controllare ownership dei file, permessi e log in /home/matter/mattermost/logs.
• Nginx ritorna 502: verificare che Mattermost sia attivo su 127.0.0.1:8065 e che systemd lo abbia avviato.

Esempi di comandi utili:

systemctl status mattermost
journalctl -u mattermost -f
tail -n 200 /home/matter/mattermost/logs/mattermost.log
ss -plnt | grep 8065
nginx -t

Alternative e quando valutarle

• Slack: servizio SaaS, elimina manutenzione ma ha costi ricorrenti e dipendenza dal vendor.
• Rocket.Chat: altra soluzione open source con funzionalità simili, scelta quando si preferisce stack Node.js.
• Mattermost Cloud: offerta managed ufficiale se non vuoi gestire infrastruttura.

Quando Mattermost può non essere la scelta migliore:

• Se non vuoi gestire aggiornamenti, backup e sicurezza della tua infrastruttura.
• Se servono feature specifiche non presenti nella versione open source.

Mini-metodologia di rollout (consigli di processo)

1. Ambiente di test: installa e convalida su VM separata.
2. Configurazione e hardening: TLS, firewall, backup.
3. Test di carico leggero: simulare utenti e file upload.
4. Pianificare finestra di cutover e DNS.
5. Monitorare produzione e mantenere runbook di rollback.

Esempio di runbook di rollback (breve)

• Se l’aggiornamento causa malfunzionamenti: fermare nginx, ripristinare backup DB e cartelle, riavviare systemd.
• Tenere snapshot VM prima di aggiornamenti critici.

Criteri di accettazione

• Accesso web via HTTPS funzionante per utenti di test
• Creazione di team e messaggi senza errori
• Backup automatico del DB eseguito con successo almeno una volta

FAQ

Posso usare MySQL invece di PostgreSQL?

Sì. Mattermost supporta MySQL; la procedura cambia nella parte SqlSettings e nella creazione del database.

Posso usare Let’s Encrypt per i certificati?

Sì, è fortemente consigliato per ambienti pubblici. Usa certbot per ottenere e rinnovare automaticamente i certificati.

Qual è la porta predefinita di Mattermost?

Default è 8065 (ascolto interno); Nginx gestisce 80/443 esterni.

Riferimenti

• https://docs.mattermost.com/install/prod-ubuntu.html
• https://docs.mattermost.com/install/prod-debian.html

Box dei numeri chiave

• Porta Mattermost: 8065 (locale)
• Porte pubbliche: 80, 443
• Backup consigliato: minimo giornaliero per DB e file utente

Fine.