Avant tout, mettons à jour notre système Ubuntu :

sudo apt-get update
sudo apt-get upgrade

Installons ensuite les outils qui seront utilisés par notre Redmine :

sudo apt-get install apache2 sqlite3 git curl

Si nous détaillons un peu plus :

• Apache2 sera notre serveur Web
• sqlite3 sera le moteur de base de données
• git est un outil de gestion de conf (parmi d'autres comme mercurial, svn, cvs,…)
• curl sera utilisé lors de l'installation pour transférer des données depuis internet

Redmine est basé sur Ruby On Rails qui est un framework Web. Ruby On Rails a également un certain nombre de dépendances qu'il faut combler mais que nous ne détaillerons pas ici :

sudo apt-get install gawk libreadline6-dev zlib1g-dev libssl-dev libyaml-dev libsqlite3-dev \
autoconf libgdbm-dev libncurses5-dev automake libtool bison pkg-config libffi-dev libmagickwand-dev

Apache, le serveur Web, a besoin d'un module pour exécuter des applications Ruby On Rails comme Redmine. Il faut donc aussi installer les dépendances de ce module :

sudo apt-get install libcurl4-gnutls-dev apache2-threaded-dev libapr1-dev libaprutil1-dev

Il faut ajouter un utilisateur qui exécutera le serveur Redmine et dont le répertoire personnel contiendra l'ensemble de son arborescence. Pour plus de simplicité nous nommerons cet utilisateur redmine dans la suite de cet article.

sudo adduser \
  --system \
  --shell /bin/bash \
  --gecos 'redmine' \
  --gid `grep "sudo" /etc/group|cut -d: -f3`\
  --home /opt/redmine \
  redmine

Une fois cet utilisateur créé, identifiez vous avec son compte :

sudo su - redmine

Nous allons installer Ruby via RVM (Ruby Version Manager). Récupérons et installons d'abord RVM :

curl -L https://get.rvm.io | bash -s stable
echo '[[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm" # Load RVM function' >> ~/.bashrc
. ~/.bashrc

Nous n'aurons pas besoin de générer la documentation des composants Ruby donc désactivons cette génération par défaut :

echo "gem: --no-rdoc --no-ri" >> ~/.gemrc

Installons maintenant Ruby et Rails à leur dernière version stable :

rvm get stable --ruby --rails

Une fois installé, Ruby nous fournit un outil permettant de gérer ses composants à la manière de package appelés Gems. Cet outil nommé RubyGems est utilisé via la commande gem. Installons donc notre première Gem, bundler, qui va permettre de rechercher et d'installer les Gems nécessaires à un projet :

gem install bundler

Sur cette page, vous trouverez le lien de la dernière version de Redmine (en l'occurence la 2.5.2). Il ne reste plus quà la télécharger et extraire l'archive :

wget http://www.redmine.org/releases/redmine-2.5.2.tar.gz
tar xzf redmine-2.5.2.tar.gz
ln -s redmine-2.5.2 redmine

Rentrons dans le répertoire fraîchement extrait et préparons la configuration de la base de données en nous basant sur le fichier d'exemple fourni.

cd redmine/
cp config/database.yml.example config/database.yml

Sachant que nous utilisons sqlite3 comme moteur de base de données, celle-ci sera réprésentée par un simple fichier que nous nommerons dans le fichier config/database.yml :

production:
  adapter: sqlite3
  database: db/redmineGeonobot.sqlite3

Nous avons installé bundler précédemment, il est maintenant temps de l'utiliser pour installer toutes les Gems requises par notre Redmine :

bundle install --without development test postgresql mysql

Pour sécuriser les données de session, nous allons générer une clé de cryptage :

rake generate_secret_token

Il ne reste plus à qu'à initialiser la base de données de Redmine. Rails pouvant définir plusieurs environnements (production, development, test), nous spécifions ici que nous voulons l'environnement de production.

RAILS_ENV=production rake db:migrate
RAILS_ENV=production rake redmine:load_default_data

Comme évoqué au début de cet article, Passenger est le module Apache qui va nous permettre d'exécuter des applications Ruby On Rails sur le serveur web. Passenger étant une Gem, nous allons l'installer et créer le module pour notre utilisateur redmine :

gem install passenger
passenger-install-apache2-module

Nous avons terminé l'installation à effectuer par notre utilisateur redmine. C'est à l'administrateur de la machine de prendre le relais :

exit

Il faut maintenant dire à Apache où trouver le module Passenger que nous avons installé précédemment :

<IfModule mod_passenger.c>
   PassengerRoot /opt/redmine/.rvm/gems/ruby-2.0.0-p481/gems/passenger-4.0.45
   PassengerDefaultRuby /opt/redmine/.rvm/wrappers/ruby-2.0.0-p481/ruby
</IfModule>

Il faut également lui demander de charger ce module en éditant le fichier /etc/apache2/mods-available/passenger.load :

LoadModule passenger_module /opt/redmine/.rvm/gems/ruby-2.0.0-p481/gems/passenger-4.0.45/buildout/apache2/mod_passenger.so

Il reste à configurer notre Redmine dans Apache via le fichier /etc/apache2/sites-available/redmine.conf. Vous noterez que nous forçons l'utilisation du HTTPS pour sécuriser les connexions :

<VirtualHost *:80>
 ServerName redmineServer
 DocumentRoot /opt/redmine/redmine/public

 RewriteEngine on
 RewriteCond %{SERVER_PORT} !^443$
 RewriteRule ^.*$ https://%{SERVER_NAME}%{REQUEST_URI} [L,R=permanent]
 <Directory /opt/redmine/redmine/public>
   Require all granted
   Options -MultiViews
 </Directory>
</VirtualHost>

<VirtualHost *:443>
 ServerName redmineServer
 DocumentRoot /opt/redmine/redmine/public

 SSLEngine on
 SSLCertificateFile /etc/apache2/ssl/redmine.crt
 SSLCertificateKeyFile /etc/apache2/ssl/redmine.key

 <Directory /opt/redmine/redmine/public>
   Require all granted
   Options -MultiViews
 </Directory>
</VirtualHost>

Comme nous utilisons HTTPS il faut générer les certificats SSL permettant d'encrypter les communications avec le serveur :

sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout /etc/apache2/ssl/redmine.key -out /etc/apache2/ssl/redmine.crt

Il ne reste plus qu'à désactiver le site par défaut fourni avec Apache et le remplacer par notre Redmine :

sudo a2dissite 000-default
sudo a2ensite redmine

Sans oublier d'activer le module Passenger que nous avons configuré précédemment, ainsi que le module ssl pour la connexion sécurisée et le module rewrite pour la redirection d'url HTTP vers HTTPS :

sudo a2enmod passenger rewrite ssl

La configuration d'Apache étant terminée, rechargeons le pour appliquer les changements :

sudo service apache2 restart

Notre serveur Redmine est désormais installé et devrait être accessible en HTTP. En imaginant que notre serveur se nomme myredmineserver.home, vous devriez y accéder via l'URL http://myredmineserver.home qui vous redirigera vers https://myredmineserver.home