Ce guide est obsolète. Utilisez la nouvelle version sur le Help Desk Biapy:

Installer le gestionnaire de projet Redmine sur Debian

Ce guide a été testé sur les distributions suivantes :

• Debian 5.0 Lenny
• Debian 6.0 Squeeze

Pré-requis

Ce guide nécessite un serveur MySQL disposant du script mysql-tools disponible dans le guide Installer et configurer MySQL sur Debian.

Ce guide nécessite un serveur HTTP disposant au choix d'un des scripts suivant :

• Le script a2tools disponible dans mon guide Installer Apache 2 sur Debian.
  
• Le script lighty-tools disponible dans mon guide Installer Lighttpd et PHP 5 sur Debian.

Ayant eu des problèmes de consommation mémoire excessive avec l'utilisation de FastCGI dans LigHTTPd, je vous recommande de choisir Apache 2 pour serveur.

Paramètres

DOMAIN="projets.domaine-exemple.fr"

Renseignez le nom d'hôte de votre serveur MySQL (si vous ne savez pas de quoi il s'agit, ne modifiez pas cette valeur) :

MYSQL_HOST="localhost"

Si votre serveur MySQL n'est pas local, ce guide effectuera une connexion SSH pour y créer la base de données.

Installation

Installation des logiciels nécessaires

Installez les dépendances Ruby de Redmine :

command apt-get install ruby rake librmagick-ruby ca-certificates \
    subversion libmysql-ruby mysql-client rdoc libopenssl-ruby1.8

Installez "manuellement" une version récente de l'outil rubygems :

command wget "http://production.cf.rubygems.org/rubygems/rubygems-1.3.7.tgz" \
    --output-document="/tmp/rubygems.tgz"
command tar --directory="/tmp" -xzf "/tmp/rubygems.tgz"
command cd /tmp/rubygems-*
command ruby setup.rb

Installez Ruby on Rails et Rack à l'aide de rubygems :

command gem1.8 install rails -v=2.3.11
command gem1.8 install rack -v=1.1.1

Installez la version adéquate de i18n :

command gem1.8 install i18n -v=0.4.2

Et installez l'extension tzinfo de ruby :

command gem1.8 install tzinfo

Configurez logrotate pour gérer la rotation des journaux Redmine :

echo '# Logrotate configuration file for Redmine

"/var/log/redmine/*/*.log" {
    weekly
    missingok
    rotate 12
    copytruncate
    compress                                                      
    delaycompress
    create 644 www-data www-data
}
' > /etc/logrotate.d/redmine

Installation

if [ "${MYSQL_HOST}" = "localhost" ]; then
  MYSQL_PARAMS=$(command mysql-tools create-domain-db "${DOMAIN}")
else
  command echo "Saisissez le mot de passe de l'utilisateur root MySQL :"
  command read PASSWORD
  MYSQL_PARAMS=$(command ssh "root@${MYSQL_HOST}" "command mysql-tools create-domain-db '${DOMAIN}' '$(command cat /etc/mailname)' '${PASSWORD}'")
fi

Récupérez les paramètres de la nouvelle base de données :

MYSQL_DB="$(echo "${MYSQL_PARAMS}" | command grep -e "^MYSQL_DB" \
    | cut --delimiter="=" --fields="2-")"
MYSQL_USER="$(echo "${MYSQL_PARAMS}" | command grep -e "^MYSQL_USER" \
    | cut --delimiter="=" --fields="2-")"
MYSQL_PASSWORD="$(echo "${MYSQL_PARAMS}" | command grep -e "^MYSQL_PASSWORD" \
    | cut --delimiter="=" --fields="2-")"
echo "${MYSQL_PARAMS}"

Récupérez l'URL de la dernière version de l'application :

SOURCE_URL="$(command wget --quiet --output-document=- "http://rubyforge.org/frs/?group_id=1850" \
        | command grep --max-count=1 -e "redmine-.*.tar.gz" \
        | command sed -e 's|^.*href="\([^"]*\)".*$|http://rubyforge.org\1|')"

Récupérez la version à partir de l'URL :

VERSION="$(echo "${SOURCE_URL}" | command sed -e 's|.*redmine-\(.*\)\.tar\.gz|\1|')"

Téléchargez les sources de ce logiciel :

command wget "${SOURCE_URL}" \
    --output-document="/tmp/redmine.tar.gz"

Décompressez l'archive obtenue dans le dossier temporaire :

command tar --directory "/tmp" -xzf "/tmp/redmine.tar.gz"

Déterminez les chemins d'installation de l'application :

INSTALL_PATH="/opt/${DOMAIN}"
DATA_PATH="/var/lib/redmine/${DOMAIN}"
LOG_PATH="/var/log/redmine/${DOMAIN}"
CACHE_PATH="/var/cache/redmine/${DOMAIN}"

Déplacez le dossier créé à partir de l'archive vers l'emplacement final de votre installation :

command mv "/tmp/redmine-${VERSION}" "${INSTALL_PATH}"

Supprimez le fichier téléchargé :

command rm "/tmp/redmine.tar.gz"

Mettez à jour les permissions par défaut de l'installation Redmine afin d'améliorer quelque peu la sécurité :

command chown -R root:root "${INSTALL_PATH}"
command chmod -R go-w "${INSTALL_PATH}"

Améliorer la conformité de votre installation avec les règles de la LSB :

command mkdir --parent "/opt/${DOMAIN}/public/plugin_assets"
command mkdir --parent "${DATA_PATH}"
command mkdir --parent "/var/log/redmine"
command mkdir --parent "/var/cache/redmine"
command mv "${INSTALL_PATH}/log" "${LOG_PATH}"
command mv "${INSTALL_PATH}/tmp" "${CACHE_PATH}"
command mv "${INSTALL_PATH}/files" "${DATA_PATH}/files"
command mv "${INSTALL_PATH}/public/plugin_assets" "${DATA_PATH}/plugin_assets"
command ln -s "${LOG_PATH}" "${INSTALL_PATH}/log"
command ln -s "${CACHE_PATH}" "${INSTALL_PATH}/tmp"
command ln -s "${DATA_PATH}/files" "${INSTALL_PATH}/files"
command ln -s "${DATA_PATH}/plugin_assets" "${INSTALL_PATH}/public/plugin_assets"

Configurez Redmine pour utilisez la base de données qui lui est destinée :

command echo "# MySQL database configuration
production:
  adapter: mysql
  database: ${MYSQL_DB}
  host: ${MYSQL_HOST}
  username: ${MYSQL_USER}
  password: ${MYSQL_PASSWORD}" > "${INSTALL_PATH}/config/database.yml"

Placez-vous dans le dossier de votre instance Redmine :

command cd "${INSTALL_PATH}"

Initialisez le chiffrement du stockage des sessions :

command rake generate_session_store

Initialisez votre base de données :

RAILS_ENV="production" command rake db:migrate

Et initialisez votre environnement de production :

RAILS_ENV="production" command rake redmine:load_default_data

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

Assurez-vous que les permissions adéquates sont appliquées :

command chown -R www-data:www-data "${LOG_PATH}"
command chown -R www-data:www-data "${CACHE_PATH}"
command chown -R www-data:www-data "${DATA_PATH}"

Configuration de l'envoi d'email

Afin que Redmine puisse envoyer des notifications par e-mail, nous mettons en place une configuration basique utilisant le serveur SMTP local :

echo "# === Simple SMTP server at localhost

production:
  delivery_method: :sendmail
" > "${INSTALL_PATH}/config/email.yml"

Remarque : La méthode utilisée est sendmail et non smtp car il y a une incompatibilité entre Exim 4 et Redmine sous Debian.

Surveillance des dépôts logiciels

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 toutes les heures, suivez les instructions suivantes :

Récupérez les paramètres de connexion à la base de données :

MYSQL_HOST=$(command grep -e "host[ \t]*:" "${INSTALL_PATH}/config/database.yml" \
    | command sed -e 's/.*:[ \t]*\(.*\)[ \t]*$/\1/')
MYSQL_DB=$(command grep -e "database[ \t]*:" "${INSTALL_PATH}/config/database.yml" \
    | command sed -e 's/.*:[ \t]*\(.*\)[ \t]*$/\1/')
MYSQL_USER=$(command grep -e "username[ \t]*:" "${INSTALL_PATH}/config/database.yml" \
    | command sed -e 's/.*:[ \t]*\(.*\)[ \t]*$/\1/')
MYSQL_PASSWORD=$(command grep -e "password[ \t]*:" "${INSTALL_PATH}/config/database.yml" \
    | command sed -e 's/.*:[ \t]*\(.*\)[ \t]*$/\1/')

Désactivez la récupération automatique des commits :

command echo "DELETE FROM settings WHERE name = 'autofetch_changesets';
INSERT INTO settings (name, value, updated_on) VALUES ('autofetch_changesets', '0', NOW())" \
    | command mysql --user="${MYSQL_USER}" --password="${MYSQL_PASSWORD}" \
      --host="${MYSQL_HOST}" "${MYSQL_DB}"

Et créez le script Cron nécessaire avec la ligne de commande suivante :

command echo "# Redmine on ${DOMAIN} changesets autofetch :
0 * * * * www-data [ -f '${INSTALL_PATH}/Rakefile' -a -x '/usr/bin/rake' ] && RAILS_ENV="production" command rake -f '${INSTALL_PATH}/Rakefile' redmine:fetch_changesets" \
  > "/etc/cron.d/redmine-${DOMAIN}"
/etc/init.d/cron reload

Configuration du serveur HTTP

Afin de pouvoir accéder à votre instance Redmine, dans le cas ou vous souhaitez utiliser LigHTTPd comme serveur HTTP, configurez-le pour gérer les applications rails :

if [ -x '/usr/sbin/lighty-enable-mod' ]; then
  command apt-get -y install libfcgi-ruby1.8
 SITE_CONF=$(command echo "${DOMAIN}" | command tr '.' '-')
echo '## DOMAIN Redmine instance virtual hosting

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

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

  alias.url = ()

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

  fastcgi.server =  (
    ".fcgi.example" => (
      "redmine" => (
        "bin-path" => "/usr/bin/ruby INSTALL_PATH/public/dispatch.fcgi.example",
        "socket" => "/tmp/redmine-DOMAIN.socket",
        "min-procs" => 1,
        "max-procs" => 4,
        "idle-timeout" => 120,
        "check-local" => "disable",
        "bin-environment" => ( "RAILS_ENV" => "production" ),
      )
    )
  )
}' | sed -e "s/DOMAIN/${DOMAIN}/g" -e "s|INSTALL_PATH|${INSTALL_PATH}|g" > "/etc/lighttpd/conf-available/20-${SITE_CONF}.conf"
  command lighty-enable-mod "${SITE_CONF}"
  /etc/init.d/lighttpd force-reload
fi

Si vous souhaitez utiliser Apache 2 comme serveur HTTP, installez le module "passenger" et créez la configuration adaptée à votre application :

if [ -x '/usr/sbin/a2ensite' ]; then
  if [ ! -e '/etc/apache2/mods-available/passenger.load' ]; then
    if [ -z "$(command apt-cache search libapache2-mod-passenger)" ]; then
      command apt-get -y install ruby1.8-dev build-essential make \
          apache2-prefork-dev libcurl4-openssl-dev libssl-dev zlib1g-dev \
          libapr1-dev libaprutil1-dev
      command gem1.8 install passenger
      command passenger-install-apache2-module
      PASSENGER_ROOT=$(find /usr/lib/ruby/gems/1.8/gems/ -type d -name "passenger-*" \
          | command sort | command tail -n 1)
      echo "LoadModule passenger_module ${PASSENGER_ROOT}/ext/apache2/mod_passenger.so" \
          > "/etc/apache2/mods-available/passenger.load"
      echo "PassengerRoot ${PASSENGER_ROOT}
PassengerRuby /usr/bin/ruby1.8
PassengerDefaultUser www-data" > "/etc/apache2/mods-available/passenger.conf"
      command a2enmod passenger
    else
      command apt-get -y install libapache2-mod-passenger
      echo "PassengerDefaultUser www-data" > "/etc/apache2/mods-available/passenger-user.load"
      command a2enmod passenger-user
    fi
  fi
  command a2tools add-vhost "${DOMAIN}" "${INSTALL_PATH}/public" "FileInfo Options=All,Multiviews"
  echo "# Passenger module specific options.
Options -MultiViews" > "/opt/${DOMAIN}/public/.htaccess"
  /etc/init.d/apache2 force-reload
fi

Vous pouvez maintenant accéder à votre instance Redmine via l'URL fournie par la commande :

echo "http://${DOMAIN}/"

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

• Identifiant : admin
• Mot de passe : admin

Important : Une fois connecté, rendez-vous le menu "Administration -> Configuration", onglet "Général", et adaptez les valeurs "Nom d'hôte et chemin" et "Protocole" à votre configuration.

Sauvegardes

Pour sauvegarder votre installation, je vous propose d'utiliser Backup Manager. Pour l'installer, vous pouvez suivre mon guide:

Installer et configurer Backup Manager sur Debian

Une fois Backup Manager installé, configurer la sauvegarde des fichiers de l'application :

command update-bm-folders add "${INSTALL_PATH}"
command update-bm-folders add "${DATA_PATH}"

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.

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 propose d'en créer un en suivant mon guide Installer un serveur Subversion et USVN (UserFriendly SVN) sur Debian.

Mises à jour

Mise à jour automatisée

J'ai créé un script automatisant la mise à jour d'une instance Redmine. Pour utiliser cet outil, téléchargez-le sur votre serveur :

command wget 'http://howto.landure.fr/gnu-linux/debian-4-0-etch/installer-le-gestionnaire-de-projet-redmine-sur-debian-4-0-etch/update-redmine' \
    --output-document='/usr/bin/update-redmine'
command chmod +x '/usr/bin/update-redmine'

L'utilisation de cet outil est simple. Il suffit de lui donner en argument le chemin de l'instance Redmine que vous souhaitez mettre à jour :

command update-redmine "/opt/projets.domaine-exemple.fr"

Mise à jour manuelle

Important : Sauvegardez votre base de données et vos fichiers avant chaque mise à jour !

Renseignez le nom de domaine où est disponible l'application :

DOMAIN="projets.domaine-exemple.fr"

Déterminez les chemins d'installation de l'application :

INSTALL_PATH="/opt/${DOMAIN}"

Récupérez l'URL de la dernière version de l'application :

SOURCE_URL="$(command wget --quiet --output-document=- "http://rubyforge.org/frs/?group_id=1850" \
        | command grep --max-count=1 -e "redmine-.*.tar.gz" \
        | command sed -e 's|^.*href="\([^"]*\)".*$|http://rubyforge.org\1|')"

Récupérez la version à partir de l'URL :

VERSION="$(echo "${SOURCE_URL}" | command sed -e 's|.*redmine-\(.*\)\.tar\.gz|\1|')"

Téléchargez les sources de ce logiciel :

command wget "${SOURCE_URL}" \
    --output-document="/tmp/redmine.tar.gz"

Décompressez l'archive obtenue dans le dossier temporaire :

command tar --directory "/tmp" -xzf "/tmp/redmine.tar.gz"

Mettez à jour les permissions par défaut de la nouvelle version de Redmine afin d'améliorer quelque peu la sécurité :

command chown -R root:root "/tmp/redmine-${VERSION}/"
command chmod -R go-w "/tmp/redmine-${VERSION}/"

Nettoyez le contenu du dossier :

command rm -r "/tmp/redmine-${VERSION}/tmp"
command rm -r "/tmp/redmine-${VERSION}/log"
command rm -r "/tmp/redmine-${VERSION}/files"
if [ -e "/tmp/redmine-${VERSION}/public/plugin_assets" ]; then
  command rm -r "/tmp/redmine-${VERSION}/public/plugin_assets"
fi

Copiez les versions actuelles de ces fichiers dans la nouvelle version :

command cp -a "${INSTALL_PATH}/config/database.yml" "/tmp/redmine-${VERSION}/config/database.yml"
command cp -a "${INSTALL_PATH}/config/email.yml" "/tmp/redmine-${VERSION}/config/email.yml"
command cp -a "${INSTALL_PATH}/tmp" "/tmp/redmine-${VERSION}/tmp"
command cp -a "${INSTALL_PATH}/log" "/tmp/redmine-${VERSION}/log"
command cp -a "${INSTALL_PATH}/files" "/tmp/redmine-${VERSION}/files"
command cp -a "${INSTALL_PATH}/public/plugin_assets" "/tmp/redmine-${VERSION}/public/plugin_assets"
if [ -e "${INSTALL_PATH}/public/.htaccess" ]; then
  command cp -a "${INSTALL_PATH}/public/.htaccess" "/tmp/redmine-${VERSION}/public/.htaccess"
fi

Effacez une éventuelle sauvegarde de l'installation précédente :

if [ -d "${INSTALL_PATH}.back" ]; then
  command rm -r "${INSTALL_PATH}.back"
fi

Déplacez la version actuelle de Redmine dans le dossier de sauvegarde :

command mv "${INSTALL_PATH}" "${INSTALL_PATH}.back"

Déplacez le dossier créé à partir de l'archive vers l'emplacement final de votre installation :

command mv "/tmp/redmine-${VERSION}" "${INSTALL_PATH}"

Placez-vous dans le nouveau dossier :

command cd "${INSTALL_PATH}"

Générez une nouvelle clef de chiffrement pour le stockage des sessions :

command rake generate_session_store

Mettez à jour votre base de données :

command rake db:migrate RAILS_ENV=production

Et mettez à jour les plugins si nécessaire :

command rake db:migrate:upgrade_plugin_migrations RAILS_ENV=production
command rake db:migrate_plugins RAILS_ENV=production

Effacez le cache :

command rake tmp:cache:clear
command rake tmp:sessions:clear

Redémarrez votre serveur HTTP :

command test -x "/etc/init.d/lighttpd" && /etc/init.d/lighttpd force-reload
command test -x "/etc/init.d/apache2" && /etc/init.d/apache2 force-reload

Connectez-vous à l'administration de Redmine et dans "Administration -> Rôles et permissions", affectez les éventuelles nouvelles permissions mises en place par la nouvelle version.

Remerciements

• Merci aux développeurs de Redmine.
• Merci aux développeurs de Phusion Passenger.
  
• 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.
• Merci à Simon Josefsson pour son article Redmine on Debian Lenny using Lighttpd.
• Merci à Mathias Bynens pour son article Apache’s AllowOverride All doesn’t do what you think it does.
• Merci à Be Fio pour sa réponse à ActionController::RoutingError (No route matches "/stylesheets/application.css" with {:method=>:get}):.