Installer Redmine 4.2.3 sur Rocky Linux avec PostgreSQL et Apache

Ce guide explique pas à pas l’installation de Redmine 4.2.3 sur Rocky Linux 8.4 en production, avec PostgreSQL comme base de données et Apache/httpd + Passenger comme serveur d’applications. Il couvre les dépendances, l’installation de RVM/Ruby 2.7, la configuration PostgreSQL, Passenger, la configuration de vhost Apache (HTTP/HTTPS) et la vérification finale.

Important. Termes en une ligne:

• Redmine: application web de gestion de projet et suivi d’incidents.
• RVM: gestionnaire de versions Ruby qui installe Ruby par utilisateur ou système.
• Passenger: serveur d’applications pour déployer des apps Ruby/Rails derrière Apache ou Nginx.

Contexte et objectif

Ce guide cible les administrateurs système souhaitant déployer Redmine dans un environnement Rocky Linux 8.4 (Green Obsidian) avec PostgreSQL et Apache. Il est écrit pour un déploiement de production simple, extensible et maintenable.

Environnement d’exemple utilisé dans ce guide:

• Système d’exploitation: Rocky Linux 8.4 (Green Obsidian)
• Adresse IP de l’exemple: 192.168.1.10
• Privilèges: utilisateur avec droits root
• Nom de domaine d’exemple: redmine.example.com

Objectifs pratiques couvertes:

• Installer Ruby 2.7 via RVM
• Préparer et créer la base PostgreSQL pour Redmine
• Installer Passenger et intégrer à Apache/httpd
• Configurer les hôtes virtuels Apache pour HTTP et HTTPS
• Installer et configurer Redmine 4.2.3

Note: il est recommandé d’avoir PostgreSQL installé et configuré avant de commencer ce guide. Si PostgreSQL n’est pas encore installé, installez-le d’abord sur Rocky Linux.

Aperçu des principales fonctionnalités de Redmine

• Support multi-projets
• Wiki et forums par projet
• Gestion de documents et fichiers
• Flux d’actualité et notifications par e-mail
• Suivi du temps
• Support de multiples SCM (SVN, Git, CVS, Mercurial, Bazaar)
• Traductions pour de nombreuses langues
• Authentification LDAP

Prérequis et dépendances

Avant d’installer Redmine, installez les paquets système requis. Exécutez ces commandes en root ou avec sudo.

1. Ajouter le dépôt EPEL

sudo dnf install epel-release -y

2. Installer les dépendances système pour la compilation et les bibliothèques Ruby/PostgreSQL

sudo dnf install curl gpg gnupg2 gcc gcc-c++ make patch autoconf automake bison ImageMagick libffi-devel libtool patch redhat-rpm-config readline-devel postgresql-devel zlib-devel openssl-devel -y

3. Installer les paquets nécessaires pour construire le module Apache/HTTPD + Passenger

sudo dnf install libcurl-devel httpd-devel httpd apr-devel apr-util-devel -y

Démarrer et activer le service httpd

sudo systemctl enable --now httpd
sudo systemctl status httpd

Quand ces paquets sont installés, passez à l’installation de RVM et Ruby.

Installer RVM et Ruby 2.7

Redmine 4.2.x nécessite Ruby 2.7. Nous installons Ruby 2.7 via RVM (Ruby Version Manager). Les commandes suivantes sont à exécuter en tant qu’utilisateur root ou via sudo quand indiqué.

1. Importer les clés GPG des développeurs RVM

curl -sSL https://rvm.io/mpapis.asc | gpg2 --import -
curl -sSL https://rvm.io/pkuczynski.asc | gpg2 --import -

2. Installer RVM et charger l’environnement RVM

curl -L get.rvm.io | bash -s stable
source /etc/profile.d/rvm.sh

Recharger et installer les dépendances système pour RVM

rvm reload
rvm requirements run

3. Installer Ruby 2.7 avec RVM

rvm install 2.7

L’installation peut durer plusieurs minutes selon la machine.

Vérifier l’installation

rvm list
ruby --version

Une fois Ruby installé et activé, passez à la préparation de PostgreSQL.

Préparer PostgreSQL pour Redmine

Avant de continuer, assurez-vous que PostgreSQL est installé et fonctionnel sur le serveur. Créez une base et un utilisateur dédiés à Redmine.

1. Ouvrir le shell PostgreSQL en tant que superutilisateur postgres

sudo -u postgres psql

2. Créer un rôle et une base de données pour Redmine (remplacez le mot de passe par un mot de passe fort)

CREATE ROLE redmine LOGIN ENCRYPTED PASSWORD 'StrongPasswordRedmine' NOINHERIT VALID UNTIL 'infinity';
CREATE DATABASE redminedb WITH ENCODING='UTF8' OWNER=redmine;

Puis quitter psql avec

\q

Gardez les identifiants redmine/redminedb et le mot de passe en lieu sûr. Vous en aurez besoin pour la configuration de Redmine.

Télécharger et installer Redmine 4.2.3

Nous installons Redmine sous /var/www/redmine.

1. Télécharger et extraire Redmine

cd /var/www/
wget https://www.redmine.org/releases/redmine-4.2.3.tar.gz

tar -xzvf redmine-4.2.3.tar.gz
mv redmine-*/ redmine

2. Configurer la connexion base de données

export REDMINE=/var/www/redmine
cd $REDMINE
nano config/database.yml

Contenu exemple pour production – remplacez les valeurs par les vôtres

production:
  adapter: postgresql
  database: redminedb
  host: localhost
  username: redmine
  password: 'StrongPasswordRedmine'
  encoding: utf8

Enregistrez le fichier et quittez l’éditeur.

3. Installer Bundler et dépendances Ruby

Installer bundler

gem install bundler

Configurer bundle pour l’installation locale des gems

bundle config set --local path 'vendor/bundle'
bundle config set --local without 'development test'

Installer les gems

bundle install

4. Générer la clé secrète et migrer la base

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

5. Ajuster la propriété des fichiers

Attribuez les fichiers à l’utilisateur apache pour permettre à httpd/Passenger d’accéder aux fichiers

sudo chown -R apache:apache $REDMINE

À ce stade, l’installation de Redmine est prête. Poursuivons avec Passenger.

Installer et configurer Phusion Passenger

Passenger sert d’interface entre Apache et l’application Rails.

1. Installer Passenger via gem

gem install passenger

2. Construire et installer le module Apache pour Passenger

passenger-install-apache2-module

Le programme d’installation guide l’utilisateur. Sélectionnez ‘Ruby’ comme type d’application si demandé.

Le programme demande d’ajouter une configuration à Apache. Créez /etc/httpd/conf.d/passenger.conf

nano /etc/httpd/conf.d/passenger.conf

Exemple de configuration à adapter selon la version Ruby/Passenger installée

LoadModule passenger_module /usr/local/rvm/gems/ruby-2.7.2/gems/passenger-6.0.12/buildout/apache2/mod_passenger.so

  PassengerRoot /usr/local/rvm/gems/ruby-2.7.2/gems/passenger-6.0.12
  PassengerDefaultRuby /usr/local/rvm/gems/ruby-2.7.2/wrappers/ruby

Redémarrez httpd pour appliquer la configuration

sudo systemctl restart httpd

Si le script d’installation ne renvoie pas d’erreur, Passenger est correctement installé.

Configurer httpd (Apache) pour Redmine

Créez un fichier de configuration virtual host pour Redmine

nano /etc/httpd/conf.d/redmine.conf

Exemple pour HTTP (sans SSL)

PassengerRuby /usr/local/rvm/gems/ruby-2.7.2/wrappers/ruby


  ServerName redmine.example.io
  DocumentRoot '/var/www/redmine/public'

  ErrorLog logs/redmine_error_log
  LogLevel warn

  
    Options Indexes ExecCGI FollowSymLinks
    Require all granted
    AllowOverride all
  

Exemple pour HTTP + HTTPS (Let’s Encrypt) – adaptez les chemins de certificats

PassengerRuby /usr/local/rvm/gems/ruby-2.7.2/wrappers/ruby


  ServerName redmine.example.io
  Redirect permanent / https://redmine.example.io/



  ServerName redmine.example.io

  Protocols h2 http/1.1

  
    Redirect permanent / https://redmine.example.io/
  

  DocumentRoot '/var/www/redmine/public'

  ErrorLog /var/log/httpd/redmine.example.io-error.log
  CustomLog /var/log/httpd/redmine.example.io-access.log combined

  SSLEngine On
  SSLCertificateFile /etc/letsencrypt/live/redmine.example.io/fullchain.pem
  SSLCertificateKeyFile /etc/letsencrypt/live/redmine.example.io/privkey.pem

  
    Options Indexes ExecCGI FollowSymLinks
    Require all granted
    AllowOverride all
  

Enfin, tester la configuration Apache et redémarrer

apachectl configtest
sudo systemctl restart httpd

Vérifier l’installation Redmine

Ouvrez votre navigateur et allez sur

https://redmine.example.io/login

1. Identifiants par défaut: utilisateur admin / mot de passe admin. Connectez-vous et changez immédiatement le mot de passe.

2. Réinitialisez le mot de passe admin

3. Vérifiez les détails du compte et l’interface admin

4. Chargez la configuration de langue par défaut si demandé et vérifiez la section Utilisateurs, Informations et Administration

À ce stade Redmine 4.2.3 est opérationnel avec Ruby 2.7 et PostgreSQL en production.

Checklist d’acceptation rapide

• Redmine accessible sur le domaine configuré (HTTP/HTTPS selon configuration)
• Connexion possible avec l’utilisateur admin et changement de mot de passe effectué
• Les migrations de la base se sont exécutées sans erreur
• Passenger module chargé et actif dans Apache
• Les logs Apache ne montrent pas d’erreurs critiques au démarrage

Bonnes pratiques et sécurité (hardening)

• Exiger HTTPS: toujours déployer avec TLS valide (Let’s Encrypt ou CA interne).
• Restreindre l’accès SSH et utiliser des clés à passphrase.
• Restreindre l’accès à l’interface d’administration Redmine par IP si possible.
• Sauvegardes régulières: dump PostgreSQL + copies des répertoires files et config (inclure config/secrets).
• Droits fichiers: l’utilisateur web doit avoir uniquement les permissions nécessaires. Eviter d’exposer des fichiers sensibles.
• SELinux: tester et appliquer des politiques SELinux ou annoter les contextes si SELinux est Enforcing.
• Firewall: ouvrir uniquement les ports 80/443 et les ports d’administration nécessaires.

Confidentialité et conformité (notes GDPR)

• Redmine stocke données utilisateurs, tickets et éventuellement pièces jointes. Documentez où sont stockées les données (serveur, sauvegardes).
• Chiffrez les sauvegardes et restreignez l’accès aux dumps de base.
• Préparez une procédure de suppression des données personnelles pour répondre aux demandes RGPD.

Maturité et alternatives

• Petit projet: Redmine peut être suffisant en configuration simple.
• Projet plus mature: envisager haute disponibilité, réplication PostgreSQL, sauvegardes hors site, monitoring (Prometheus/Alertmanager).
• Alternatives: GitLab (si gestion Git + CI), Jira (si besoin d’intégrations enterprise), Taiga (si méthode agile plus simple).

Dépannage commun

Symptôme: page blanche 500

• Vérifier les logs Apache (/var/log/httpd/*) et les logs de production Redmine (log/production.log).
• S’assurer que bundle install a réussi et que toutes les gems sont présentes.
• Tester le démarrage en mode console: rails c -e production depuis /var/www/redmine pour repérer les erreurs de chargement.

Symptôme: erreurs de connexion à la DB

• Vérifier config/database.yml et tester une connexion psql avec l’utilisateur redmine.
• Vérifier que PostgreSQL écoute sur localhost et que le rôle/password sont corrects.

Redémarrage de secours

sudo systemctl restart httpd
sudo systemctl status httpd

Rollback minimal

• Restaurer le dump PostgreSQL
• Restaurer le répertoire /var/www/redmine depuis la sauvegarde
• Redémarrer Apache

Exemples de tests d’acceptation (test cases)

• TC-01: Accès page de login via HTTPS renvoie 200 OK
• TC-02: Connexion admin avec mot de passe initial puis changement de mot de passe possible
• TC-03: Création d’un nouveau projet, puis création d’un nouvel issue et attachement d’un fichier
• TC-04: Export et import d’un dump PostgreSQL fonctionnel

Fiches rôle: tâches clés

• Administrateur système

  • Installer dépendances et sécurité système
  • Gérer certificats TLS et sauvegardes
  • Mettre en place monitoring et alerte

• Administrateur Redmine

  • Gérer utilisateurs, rôles et permissions
  • Installer et valider plugins
  • Surveiller les notifications et charges

• Développeur/Intégrateur

  • Déployer plugins et tests QA
  • Valider compatibilité Ruby/gem

Conseils de migration et compatibilité

• Redmine 4.2.x fonctionne avec Ruby 2.7; vérifiez la compatibilité des plugins lors de la mise à jour de Redmine ou Ruby.
• Faire une copie de test (staging) avant toute mise à jour de production.
• Si vous migrez depuis MySQL vers PostgreSQL, testez intégralement les données utilisateurs et pièces jointes.

Snippets et commandes utiles (cheat sheet)

Afficher l’état d’Apache

systemctl status httpd

Tester configuration Apache

apachectl configtest

Générer clé secrète et migrer base

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

Sauvegarde basique PostgreSQL

sudo -u postgres pg_dump -Fc redminedb > /var/backups/redminedb-$(date +%F).dump

Restauration basique

sudo -u postgres pg_restore -d redminedb /var/backups/redminedb-YYYY-MM-DD.dump

Boîte à faits (fact box)

• Version dans ce guide: Redmine 4.2.3, Ruby 2.7, Passenger 6.x
• Répertoire d’installation: /var/www/redmine
• Base de données d’exemple: redminedb avec utilisateur redmine

Flux de décision (choisir SSL ou non)

flowchart TD
  A[Déploiement Redmine] --> B{Avez-vous un certificat TLS?}
  B -- oui --> C[Configurer HTTPS et redirection 80->443]
  B -- non --> D{Souhaitez-vous Let's Encrypt?}
  D -- oui --> E[Installer certbot; automatiser renouvellement]
  D -- non --> F[Ne pas exposer en production sans TLS]
  C --> G[Déployer et vérifier]
  E --> G
  F --> G

Conclusion

Félicitations. Vous avez installé Redmine 4.2.3 sur Rocky Linux avec PostgreSQL et Apache + Passenger. Vous pouvez maintenant ajouter des plugins, configurer SMTP pour les notifications, et préparer un plan de sauvegarde et monitoring pour la production.

Rappel des prochaines étapes recommandées:

• Mettre en place sauvegardes automatisées et tests de restauration
• Mettre en place un certificat TLS et tester le renouvellement automatique
• Valider et installer les plugins nécessaires en environnement de test

Résumé rapide

• Redmine installé en /var/www/redmine et accessible via Apache + Passenger
• Base PostgreSQL dédiée et migrations appliquées
• Vérifier sécurité, sauvegardes et monitoring pour la production