Redmine su CentOS 8: guida completa

Questa guida mostra come installare e configurare Redmine su CentOS 8 usando MariaDB, Ruby/Passenger, e Nginx come reverse proxy. Copre prerequisiti, comandi dettagliati, un servizio systemd, suggerimenti di sicurezza, risoluzione dei problemi e una checklist operativa per mettere in produzione Redmine.

Importante: sostituisci password ed hostname d’esempio con valori sicuri prima di esporre il sistema in rete.

Che cos’è Redmine

Redmine è un sistema di gestione progetti open source basato su Ruby on Rails. Supporta database come MariaDB/PostgreSQL, plugin di terze parti, controllo accessi per ruolo, wiki, forum e notifiche email.

Varianti di intento (SEO)

installare Redmine CentOS 8
Redmine con Nginx e MariaDB
guida Redmine on-premise
Redmine Ruby Passenger CentOS
deploy Redmine production

Prerequisiti

Un server con CentOS 8 aggiornato.
Accesso root o un account con sudo.
Un nome host o dominio valido (es. redmine.example.com) e i record DNS impostati.

Nota: questa guida usa MariaDB come backend; è possibile adattarla a PostgreSQL modificando adapter e pacchetti.

Installare le dipendenze richieste

Installa gli strumenti di sviluppo e le librerie necessarie:

dnf group install "Development Tools"
dnf install zlib-devel curl-devel openssl-devel -y

Una volta completato, passa al database.

Installare e configurare MariaDB

Installa MariaDB:

dnf install mariadb-server mariadb-devel -y

Avvia e abilita il servizio:

systemctl start mariadb
systemctl enable mariadb

Esegui il prompt mysql e crea database e utente Redmine (sostituisci “password” con una password forte):

mysql

Nel prompt MariaDB:

CREATE DATABASE redmine CHARACTER SET utf8mb4;
GRANT ALL PRIVILEGES ON redmine.* TO 'redmine'@'localhost' IDENTIFIED BY 'password';
FLUSH PRIVILEGES;
EXIT;

Importante: considera di usare autenticazione socket o un utente con privilegi ridotti in ambienti di produzione.

Installare Ruby e Passenger

Abilita EPEL e installa Passenger e Ruby:

dnf install epel-release -y
dnf config-manager --enable epel -y

dnf install mod_passenger passenger passenger-devel ruby ruby-devel -y

Nota: in ambienti production spesso si preferisce Passenger + Nginx o Puma + systemd. Questa guida usa Passenger per semplicità.

Installare Redmine

Crea un utente di sistema per Redmine:

useradd -m -U -r -d /opt/redmine redmine

Passa all’utente redmine e scarica Redmine (sostituisci la versione se necessario):

su - redmine
wget --no-check-certificate https://www.redmine.org/releases/redmine-4.2.1.zip
unzip redmine-4.2.1.zip
mv redmine-4.2.1 redmine
cd redmine

Copia il file di configurazione di esempio e modificalo:

cp config/database.yml.example config/database.yml
nano config/database.yml

Modifica la sezione production come segue (usa la password creata in MariaDB):

production:
  adapter: mysql2
  database: redmine
  host: localhost
  username: redmine
  password: "password"
  encoding: utf8mb4

Salva e chiudi.

Installa Bundler e le gemme dipendenti:

gem install bundler --no-rdoc --no-ri
bundle install --without development test postgresql sqlite --path vendor/bundle

Genera il token segreto e applica le migrazioni del database:

bundle exec rake generate_secret_token
RAILS_ENV=production bundle exec rake db:migrate

Avvia temporaneamente l’applicazione per testare (WEBrick) e poi fermala con CTRL+C:

bundle exec rails server webrick -e production

Output atteso (parziale):

=> Booting WEBrick
=> Rails 5.2.5 application starting in production on http://0.0.0.0:3000
[2021-06-24 00:40:15] INFO  WEBrick 1.4.2
[2021-06-24 00:40:15] INFO  ruby 2.5.5 (2019-03-15) [x86_64-linux]

Esci dall’utente redmine:

exit

Importante: WEBrick non è indicato per produzione. Useremo systemd + Passenger/Nginx per il deployment.

Creare un servizio systemd per Redmine

Crea il file di servizio:

nano /usr/lib/systemd/system/redmine.service

Incolla:

[Unit]
Description=Redmine server
After=syslog.target
After=network.target

[Service]
Type=simple
User=redmine
Group=redmine
ExecStart=/bin/ruby /opt/redmine/redmine/bin/rails server webrick -e production

# Give a reasonable amount of time for the server to start up/shut down
TimeoutSec=300

[Install]
WantedBy=multi-user.target

Ricarica systemd e abilita il servizio:

systemctl daemon-reload
systemctl start redmine
systemctl enable redmine
systemctl status redmine

Verifica che Redmine ascolti sulla porta 3000:

ss -antpl | grep 3000

Nota: questo esempio avvia Redmine con WEBrick tramite systemd. In produzione si raccomanda Passenger o Puma dietro Nginx per maggiore stabilità e performance.

Configurare Nginx come reverse proxy

Installa Nginx:

dnf install nginx -y

Crea il file di configurazione virtual host:

nano /etc/nginx/conf.d/redmine.conf

Contenuto di esempio (aggiorna server_name):

upstream backend {
  server 127.0.0.1:3000;
}

server {
    listen 80;
    server_name redmine.example.com;
    access_log /var/log/nginx/redmine.example.com-access.log;
    error_log /var/log/nginx/redmine.example.com-error.log;

    location / {
        proxy_pass http://backend/;
        proxy_http_version 1.1;
        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-Forward-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forward-Proto http;
        proxy_set_header X-Nginx-Proxy true;
        proxy_redirect off;
    }
}

Verifica la sintassi e avvia Nginx:

nginx -t
systemctl start nginx
systemctl enable nginx
systemctl status nginx

Importante: dopo aver verificato l’accesso via HTTP, abilita HTTPS con Let’s Encrypt o un certificato commerciale.

Accedere a Redmine

Apri nel browser: http://redmine.example.com

Pagina iniziale di Redmine con il banner e i link principali

Clicca su Sign in e usa l’account predefinito admin / admin (cambia immediatamente la password).

Schermata di login di Redmine che richiede credenziali

Schermata per cambiare la password amministratore dopo il primo accesso

Sicurezza e best practice

Usa HTTPS obbligatorio (redirect 80 → 443) e certificati gestiti (Let’s Encrypt o enterprise CA).
Non lasciare credenziali predefinite (admin/admin). Forza password complesse.
Configura backup automatici del database e del file store (almeno giornalieri).
Applica aggiornamenti Ruby, Gem e Redmine in ambienti di staging prima di produrre.
Log e monitoraggio: invia log a syslog/ELK e configura alert su errori 5xx.
Permessi filesystem: la directory Redmine dovrebbe appartenere a utente/group redmine e non essere scrivibile da altri.

Alternative e approcci diversi

Docker: esistono immagini ufficiali e community per Redmine; utili per ambienti containerizzati e CI/CD.
PostgreSQL: alternativa più robusta per grandi installazioni; modifica adapter in database.yml e installa pacchetti libpq-devel.
Puma + systemd: sostituisce Passenger/WEBrick con Puma come application server, miglior scalabilità.
Passenger + Nginx integrato: Passenger può essere caricato come modulo Nginx per gestire le app Ruby direttamente.

Risoluzione dei problemi comuni

Errore gem/mancata installazione: assicurati di avere ruby-devel e build tools; riesegui bundle install come utente redmine.
Porta 3000 occupata: usa ss -antpl per individuare il processo e correggerlo.
Accesso DB rifiutato: verifica credenziali in config/database.yml e che MariaDB accetti connessioni da localhost.
Errori di encoding: usa utf8mb4 per charset e controlla la collation del database.

Playbook operativo rapido (SOP)

Preparazione server e DNS.
Installare dipendenze e DB.
Creare utente redmine e scaricare release.
Configurare database.yml e applicare migrazioni.
Installare e configurare Nginx + Passenger/Puma.
Abilitare HTTPS e controlli di sicurezza.
Testare con account admin e creare backup.

Criteri di accettazione

L’istanza risponde su HTTPS con certificato valido.
Login amministratore funziona e la password è cambiata.
Eseguendo operazioni CRUD sui progetti non si generano errori 500.
Backup DB pianificato e testato con restore su istanza di staging.

Checklist ruolo-based (amministratore / sviluppatore / operatore)

Amministratore: configurare SSL, creare utenti, impostare policy password.
Sviluppatore: testare plugin in staging, eseguire migration test.
Operatore: monitorare servizi (systemd, nginx, mariadb), verificare backup.

Test di accettazione essenziali

Accedi con admin, crea progetto, assegna ticket, allega file e verifica che sia salvato.
Simula caduta del servizio Redmine e verifica che systemd lo riavvii.
Ripristina DB da backup su macchina di test.

Glossario in una riga

Redmine: piattaforma open source per gestione progetti e ticket basata su Ruby on Rails.
Passenger: application server per eseguire applicazioni Ruby/Python/Node dietro Nginx/Apache.
WEBrick: server HTTP Ruby usato per test o sviluppo (non consigliato in produzione).

Considerazioni finali

Hai ora una guida completa per installare Redmine su CentOS 8 con MariaDB e Nginx. Ricorda di rivedere le configurazioni di sicurezza, automatizzare backup e testare gli aggiornamenti in un ambiente di staging prima di applicarli in produzione.

Riepilogo rapido:

Usa HTTPS e password sicure.
Preferisci Passenger o Puma per la produzione.
Automatizza backup e monitor.

Grazie per aver seguito la guida. Buon lavoro con Redmine!

Installare Redmine su CentOS 8 con Nginx