Installer Redmine sur CentOS 8 avec MariaDB, Ruby, Passenger et Nginx

Vue d’ensemble

Redmine est une application libre et open source de gestion de projet et de suivi d’incidents écrite en Ruby on Rails. Elle fonctionne avec des bases de données comme MariaDB ou PostgreSQL et prend en charge les plugins tiers, les wikis et les forums. Ce guide cible une installation de Redmine en production légère sur CentOS 8, avec Nginx en frontal et MariaDB comme backend de données.

Important : ce tutoriel suit une installation basée sur WEBrick pour les tests et propose ensuite un service systemd. Pour une mise en production plus robuste, envisagez d’utiliser Passenger, Puma ou un serveur d’application dédié avec SSL.

Avant de commencer

• Un serveur exécutant CentOS 8 (64 bits recommandé).
• Accès root ou un compte avec sudo.
• Accès réseau pour installer des paquets et télécharger Redmine.

Notes : adaptez les noms d’hôte, les mots de passe et les chemins à votre environnement.

Intentions du guide

• Installer les dépendances système nécessaires.
• Configurer MariaDB et créer une base pour Redmine.
• Installer Ruby, Passenger et les gems requis.
• Déployer Redmine et créer un service systemd.
• Configurer Nginx comme reverse proxy et vérifier l’accès web.

1. Installer les dépendances système

Ouvrez un terminal en root puis installez les outils de compilation et les bibliothèques de développement :

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

Ces paquets sont nécessaires pour compiler certaines gems natives et pour supporter les connexions HTTPS.

2. Installer et configurer MariaDB

Installez MariaDB et ses en-têtes :

dnf install mariadb-server mariadb-devel -y

Démarrez et activez le service :

systemctl start mariadb
systemctl enable mariadb

Exécutez la configuration sécurisée :

mysql_secure_installation

Puis connectez-vous au shell MariaDB et créez la base et l’utilisateur Redmine (remplacez password par un mot de passe fort) :

mysql

Dans le shell :

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

Conseil : pour la production, limitez les droits réseau de l’utilisateur et considérez l’utilisation d’utilisateurs de base de données avec peu de privilèges.

3. Installer Ruby et Passenger

Activez EPEL, qui fournit des paquets supplémentaires :

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

Installez Passenger (module Apache/nginx) et Ruby :

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

Remarque : Passenger vous permet d’intégrer Ruby à Nginx ou Apache. Vous pouvez aussi installer Ruby via rbenv ou RVM si vous avez besoin d’une version spécifique.

4. Télécharger et installer Redmine

Créez un utilisateur système dédié à Redmine :

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

Passez à cet utilisateur et téléchargez la version fournie ici :

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

Décompressez et placez le dossier :

unzip redmine-4.2.1.zip
mv redmine-4.2.1 redmine
cd redmine
cp config/database.yml.example config/database.yml

Éditez le fichier de configuration de la base de données :

nano config/database.yml

Remplacez ou modifiez la section production pour pointer sur MariaDB :

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

Sauvegardez le fichier.

Installez Bundler et les gems nécessaires :

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

Générez le token secret et migrez la base de données :

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

Démarrez l’application pour tester (WEBrick) :

bundle exec rails server webrick -e production

Sortie attendue (extrait) :

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

Appuyez sur CTRL+C pour arrêter le serveur de test.

Important : WEBrick convient pour les tests. Pour la production, utilisez Passenger intégré à Nginx, Puma ou Unicorn.

5. Créer un service systemd pour Redmine

Créez le fichier de service :

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

Contenu recommandé :

[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

Rechargez systemd puis démarrez et activez le service :

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

Vérifiez que l’application écoute sur le port 3000 :

ss -antpl | grep 3000

Si vous voyez une ligne LISTEN avec ruby, l’application fonctionne.

Note : si vous préférez Passenger, adaptez ExecStart pour lancer Passenger ou configurez Passenger via le module Nginx fourni.

6. Configurer Nginx comme reverse proxy

Installez Nginx :

dnf install nginx -y

Créez la configuration :

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

Contenu exemple (corrigé pour les en-têtes corrects) :

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-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto http;
        proxy_set_header X-Nginx-Proxy true;
        proxy_redirect off;
    }
}

Vérifiez la configuration, démarrez et activez Nginx :

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

Conseil : remplacez redmine.example.com par votre nom de domaine réel et créez l’enregistrement DNS correspondant.

7. Accéder à Redmine

Ouvrez un navigateur et allez sur http://redmine.example.com. Vous devriez voir la page d’accueil de Redmine.

Cliquez sur Sign in pour afficher la page de connexion :

Identifiants par défaut : utilisateur admin, mot de passe admin. Après la première connexion, on vous demande de changer le mot de passe :

Changez immédiatement le mot de passe admin et sauvegardez.

8. Sécurité et bonnes pratiques

• Activez HTTPS : obtenez un certificat TLS (Let’s Encrypt via certbot) et redirigez tout le trafic HTTP vers HTTPS.
• Changez le mot de passe par défaut admin et créez des comptes avec rôles minimaux.
• Sauvegardez régulièrement la base de données :

mysqldump -u redmine -p redmine > /root/redmine-backup-$(date +%F).sql

• Corrigez les fins de ligne Windows si vous voyez l’avertissement “shebang line ending with \r may cause problems” en utilisant dos2unix sur les scripts Ruby :

dnf install dos2unix -y
dos2unix /opt/redmine/redmine/bin/*

• Configurez un pare-feu pour autoriser uniquement les ports nécessaires (80/443) et bloquez les accès non autorisés.
• Si SELinux est activé, vérifiez les booleans et contexts nécessaires pour Nginx et Passenger.

9. Dépannage courant

• Erreur lors de bundle install : installez les dépendances système manquantes (zlib-devel, libxml2-devel, etc.).
• Erreur de migration DB : vérifiez database.yml et les droits de l’utilisateur MariaDB.
• Application inaccessible sur le port 3000 : vérifiez que le service redmine est actif et que ss/netstat montre une écoute.
• Headers manquants dans Nginx : assurez-vous que proxy_set_header X-Forwarded-For est présent.

10. Sauvegarde et restauration rapides

Sauvegarde de la base :

mysqldump -u redmine -p redmine > /root/redmine-backup-YYYY-MM-DD.sql

Restauration :

mysql -u root -p redmine < /root/redmine-backup-YYYY-MM-DD.sql

Sauvegarde des fichiers attachés (dossiers public/files) :

tar czf /root/redmine-files-backup-YYYY-MM-DD.tgz /opt/redmine/redmine/files

11. Checklist par rôle

• Administrateur système : vérifier service systemd, logs, firewall, certificats TLS.
• Administrateur Redmine : créer projets, utilisateurs, rôles et plugins.
• Développeur : installer et tester plugins localement avant production.
• Utilisateur final : vérifier accès, projets assignés, notifications par e-mail.

12. Critères d’acceptation

• L’URL http://redmine.example.com affiche la page d’accueil.
• L’utilisateur admin peut se connecter et changer son mot de passe.
• La base MariaDB contient les tables Redmine après migration.
• Le service systemd redmine est actif et redémarre automatiquement au reboot.
• Nginx redirige correctement vers le backend sur le port 3000.

13. Glossaire en une ligne

• Redmine : application web de gestion de projets basée sur Ruby on Rails.
• WEBrick : serveur HTTP Ruby simple pour test.
• Passenger : module pour exécuter des applications Ruby dans Nginx/Apache.
• Bundler : gestionnaire de gems Ruby.

14. Alternatives et évolutions possibles

• Utiliser Passenger avec intégration Nginx pour de meilleures performances.
• Déployer avec Puma ou Unicorn pour un comportement multi-processus plus prévisible.
• Héberger Redmine dans des conteneurs Docker ou Kubernetes pour l’élasticité.

Conclusion

Vous avez installé Redmine sur CentOS 8, configuré MariaDB, déployé l’application, créé un service systemd et configuré Nginx comme reverse proxy. Pour la production, ajoutez HTTPS, durcissez les accès et planifiez des sauvegardes régulières.

Résumé des actions : installez les dépendances, configurez MariaDB, installez Ruby/Bundler, déployez Redmine, créez le service systemd, configurez Nginx et sécurisez l’accès.

Notes importantes : remplacez les mots de passe par défaut et adaptez les chemins et les versions à votre environnement avant de passer en production.