Avertissement

Ce guide utilise exclusivement LigHTTPd. J'ai fait ce choix à la fois pour des raisons de facilité de mise en place et de légèreté, mais aussi car je ne voulais pas employer le mod_proxy d'Apache 2.

Si vous souhaitez quand même utiliser Apache 2, je vous conseille de lire ce guide qui parle de Mongrel et du module proxy d'Apache : Mongrel : Apache best practice deployment. Une bonne partie de ce guide restera valide, mais il vous faudra réfléchir et comprendre ce que vous faites pour déterminer laquelle.

Pré-requis

Avant toute chose, vous devez installer les dépendances de Redmine :

/usr/bin/apt-get install ruby rake librmagick-ruby subversion libmysql-ruby mysql-client rubygems

/usr/bin/apt-get install lighttpd libfcgi-ruby1.8

La configuration nécessaire à LigHTTPd est créée plus loin dans ce guide, car elle dépend grandement de l'emplacement d'installation de Redmine.

Installation

En premier lieu, renseignez l'url de la version de Redmine que vous souhaitez installer (vous trouverez une liste des versions téléchargeables dans le RubyForge de Redmine):

SOURCE_URL=http://rubyforge.org/frs/download.php/39477/redmine-0.7.3.tar.gz

Et téléchargez les sources de ce logiciel :

/usr/bin/wget $SOURCE_URL \
    --output-document=/tmp/redmine.tar.gz

Décompressez le fichier ainsi téléchargé à l'emplacement adéquat :

/bin/tar --directory /tmp -xzf /tmp/redmine.tar.gz

Et renommé le dossier ainsi obtenu :

/bin/mv /tmp/redmine-* /opt/redmine

Vous pouvez maintenant supprimer le fichier téléchargé :

/bin/rm /tmp/redmine.tar.gz

Avant de passer à la configuration, vous devez créer une base de données MySQL.

Remarque: Si vous avez suivi le guide de création d'une base de données MySQL, vous pouvez passer à l'étape suivante. Dans le cas contraire, exécutez les lignes de commandes suivantes en les complétant avec les informations adéquates :

MYSQL_HOST=localhost
MYSQL_DB=REDMINE
MYSQL_USERNAME=redmine
MYSQL_USERPWD=mot_de_passe

Une fois la base de donnée créée, nous plaçons une valeur par défaut pour le nom d'hôte du serveur de la base de données:

if [ -z "$MYSQL_HOST" ]; then
  MYSQL_HOST=localhost
fi

Puis, configurez Redmine pour qu'il utilise cette base de données :

/bin/echo "# MySQL database configuration
production:
  adapter: mysql
  database: $MYSQL_DB
  host: $MYSQL_HOST
  username: $MYSQL_USERNAME
  password: $MYSQL_USERPWD" > /opt/redmine/config/database.yml

Une fois ceci fait, placez vous dans le dossier où vous avez installé redmine :

cd /opt/redmine

Initialisez votre base de données :

/usr/bin/rake db:migrate RAILS_ENV="production"

Et initialisez votre environnement de production :

/usr/bin/rake redmine:load_default_data RAILS_ENV="production"

Durant cette étape, il vous est demandé de choisir la langue de votre installation.

Nous nettoyons ensuite les permissions par défaut car elles sont vraiment trop permissives :

/bin/chmod -R go-w /opt/redmine

Nous créons un nouveau dossier pour Redmine dans /var/lib :

/bin/mkdir --parent /var/lib/redmine

Nous y déplaçons les dossiers concernés :

/bin/mv /opt/redmine/log /var/lib/redmine/log
/bin/mv /opt/redmine/tmp /var/lib/redmine/tmp
/bin/mv /opt/redmine/files /var/lib/redmine/files

Nous créons les liens symboliques de remplacement :

/bin/ln -s /var/lib/redmine/log /opt/redmine/log
/bin/ln -s /var/lib/redmine/tmp /opt/redmine/tmp
/bin/ln -s /var/lib/redmine/files /opt/redmine/files

Nous changeons ensuite les permissions de ces dossiers afin qu'ils soient inscriptibles par l'application :

/bin/chown -R www-data:www-data /var/lib/redmine

Configuration de l'envoi d'email

Redmine est capable d'envoyer des notifications par email pour un certain nombre d'évènements. Cependant, la configuration par défaut du serveur SMTP ne marche pas "out-of-the-box". Nous devons la simplifier quelque-peu pour qu'elle fonctionne dans un environnement standard (cela dépend quand même fortement de la configuration de votre serveur SMTP). Exécutez simplement la commande suivante :

/bin/sed -i \
    -e 's/\(.*domain\).*/\1 => "localhost",/' \
    -e 's/\(.*authentication\)/#\1/' \
    -e 's/\(.*user_name\)/#\1/' \
    -e 's/\(.*password\)/#\1/' \
    /opt/redmine/config/environment.rb

Le fichier environment.rb devrait maintenant contenir les lignes suivantes pour la configuration des emails:

        # SMTP server configuration
        config.action_mailer.smtp_settings = {
                :address => "127.0.0.1",
                :port => 25,
                :domain => "localhost",
#               :authentication => :login,
#               :user_name => "redmine@somenet.foo",
#               :password => "redmine",
        }

C'est à dire qu'il est configurer pour se connecter au serveur SMTP local sans utiliser de mot de passe.

Remarque : Si cette configuration ne fonctionne pas (vous pouvez la tester à partir de la page d'administration des notifications dans Redmine), je vous conseille d'éditer manuellement le fichier /opt/redmine/config/environment.rb pour remplacer le serveur SMTP par défaut par celui de votre fournisseur d'accès Internet.

Configuration du serveur HTTP

Maintenant que l'installation de Redmine est initialisé, il vous faut configurer votre serveur HTTP afin de pouvoir y accéder.

En premier lieu, créez la configuration FastCGI de Redmine :

/bin/cp /opt/redmine/public/dispatch.fcgi.example /opt/redmine/public/dispatch.fcgi

Configurez votre fichier hosts pour que redmine pointe vers 127.0.0.1 :

/bin/sed -i -e 's/\(127\.0\.0\.1.*\)/\1 redmine/' /etc/hosts

Créez la configuration Redmine de LigHTTPd :

echo '## Redmine virtual hosting

server.modules += ( "mod_simple_vhost" , "mod_rewrite" , "mod_fastcgi" )

$HTTP["host"] == "redmine" {
  server.document-root = "/opt/redmine/public/"
  server.follow-symlink = "enable"

  alias.url = ()

  server.indexfiles = ( "dispatch.fcgi" )
  server.error-handler-404 = "/dispatch.fcgi"
  url.rewrite-once = (
    "^/(.*\..+(?!html))$" => "$0",
    "^/(.*)\.(.*)"        => "$0",
  )

  fastcgi.server =  (
    ".fcgi" => (
      "redmine" => (
        "bin-path" => "/usr/bin/ruby /opt/redmine/public/dispatch.fcgi",
        "socket" => "/tmp/redmine.socket",
        "min-procs" => 1,
        "max-procs" => 4,
        "idle-timeout" => 120,
        "check-local" => "disable",
        "bin-environment" => ( "RAILS_ENV" => "production" ),
      )
    )
  )
}' > /etc/lighttpd/conf-available/10-redmine.conf

Et activez cette nouvelle configuration :

/usr/sbin/lighty-enable-mod redmine

Et nous rechargeons la configuration de LigHTTPd :

/etc/init.d/lighttpd force-reload

Fin de la configuration du serveur HTTP

Vous pouvez maintenant accéder à votre Redmine via l'URL :

• http://redmine/

Les identifiants de l'utilisateur d'administration sont par défaut:

• Identifiant : admin
• Mot de passe : admin
  

Surveillance des dépôts

Par défaut, Redmine ne télécharge les informations des nouvelles révisisions dans les dépôts que lorsque vous visitez l'onglet "Dépôt" de votre projet. Pour que ce téléchargement se fasse automatiquement, décochez l'option "Récupération auto. des commits" dans la configuration de Redmine, et créez le script Cron nécessaire avec la ligne de commande suivante :

/bin/echo '#!/bin/sh
#
# Cron script to update Redmine repositories informations.

/usr/bin/ruby /opt/redmine/script/runner "Repository.fetch_changesets" -e production' \
    | /usr/bin/tee /etc/cron.hourly/redmine-repositories
/bin/chmod +x /etc/cron.hourly/redmine-repositories

Gestion du changement d'heure

Dans la configuration de base, Redmine ne gère pas le changement d'heure. Pour que ce soit le cas, vous devez installer un plugin supplémentaire. Vous devez en premier lieu mettre à jour votre installation de RubyGems:

/usr/bin/wget http://rubyforge.org/frs/download.php/45904/rubygems-update-1.3.1.gem \
    --output-document=/tmp/rubygems-update-1.3.1.gem
/usr/bin/gem install /tmp/rubygems-update-1.3.1.gem
/usr/bin/update_rubygems
/usr/bin/apt-get -y remove rubygems
ln -s gem1.8 /usr/bin/gem

Puis installez tzinfo :

/usr/bin/gem install tzinfo --remote

Placez-vous à la racine de votre installation de Redmine:

cd /opt/redmine

Et installez le plugin :

/usr/bin/ruby script/plugin install tzinfo_timezone

Sauvegardes

Pour sauvegarder votre installation Redmine, élément très important puisque les données de gestion de projet sont des données sensibles, je vous conseille d'utiliser Backup Manager. Pour l'installer, vous pouvez suivre mon guide:

Installer et configurer Backup Manager sur Debian 4.0 Etch

Une fois Backup Manager installé, vous pouvez configurer la sauvegarde des fichiers de Redmine avec les commandes suivantes:

/usr/bin/update-bm-folders add /opt/redmine
/usr/bin/update-bm-folders add /var/lib/redmine/files

Important: Sauvegarder les fichiers ne suffit pas ! Il faut aussi sauvegarder la base de données. La procédure pour ce faire est disponible dans mon article MySQL sur Debian 4.0 Etch.

Pour aller plus loin

Je vous invite à lire le guide de Redmine (anglais).

Personnellement, je trouve l'ensemble suffisament bien conçu pour que vous puissiez vous y retrouver simplement en explorant les différents menus de configuration.

Si vous ne disposez pas d'un dépôt Subversion, je vous invite à vous renseigner pour en créer un... (au moment ou j'écris cette ligne, je suis trop flemmard pour faire une recherche Google à votre place :D)

Remerciements

• Merci aux développeurs de Redmine.
• Merci aux auteurs du guide Installing Redmine.
• Merci à NiLuJe pour son article Ruby on Rails et Typo sous Lighttpd.
• Merci à eMerzh pour son article Redmine, un gestionnaire de projet peu connu.