Outils personnels
Vous êtes ici : Accueil GNU / Linux Debian Installer le gestionnaire de projet Redmine sur Debian
Actions sur le document
  • Send this page to somebody
  • Print this page
  • Add Bookmarklet

Installer le gestionnaire de projet Redmine sur Debian

Par Pierre-Yves Landuré - Dernière modification 10/12/2011 09:50

Redmine est un gestionnaire de projet écrit en Ruby (en utilisant le désormais fameux framework Ruby on Rails). Ayant déjà essayé Trac, et tenté d'utiliser Bugzilla, j'ai immédiatement été séduit par la simplicité et surtout les nombreuses fonctionnalités de ce logiciel. Redmine est un outil de gestion de projets performant apportant entre autre, suivi des bugs, forums, Wiki, gestion de l'avancement, diagramme de Gantt, et quelques autres fonctionnalités.

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 :

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

Renseignez le nom de domaine où sera disponible l'application :
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

Créez la base de données :
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

Attachements

Lien incorrect

Posté par Stéphane le 26/11/2008 22:15
Bonjour,
Le lien "Je vous invite à lire le guide de Redmine (anglais)." est mal formé
Il ressemble à ceci : http://http//www.redmine.org/wiki/redmine/Guide

merci pour l'information

Posté par Pierre-Yves Landuré le 26/11/2008 22:30
je viens de corriger le lien :)

Merci aussi pour l'astuce concernant vsFTPd, je viens d'être confronté au problème. Ca m'évite de chercher une solution par moi même :)

accès extérieur

Posté par Arthur le 24/01/2009 22:40
Bonjour et merci pour le tuto.

Je découvre et j'aimerai utilsier lighttpd, mais en suivant le tuto je n'arrive pas à accéder à redmine depuis l'extérieur. En local j'arrive à afficher la page d'accueil de redmine avec links.
J'ai tenté le alias.url = ("/redmine/" => "/var/redmine/public/" ) mais je tombe toujours sur un 404 (celui de lighttpd, pas celui de redmine)

Extraits de log
depuis ip de lan en essayent le ip/redmine et ip/redmine/
"GET /redmine HTTP/1.1" 404 345 "-" "Mozilla/5.0 (X11; U; Linux i686; fr; rv:1.9.0.5) Gecko/2008122011 Iceweasel/3.0.5 (Debian-3.0.5-1)"
"GET /redmine/ HTTP/1.1" 404 345 "-" "Mozilla/5.0 (X11; U; Linux i686; fr; rv:1.9.0.5) Gecko/2008122011 Iceweasel/3.0.5 (Debian-3.0.5-1)"

et avec links2 en local (ça semble bien marcher):
127.0.0.1 redmine - [24/Jan/2009:21:43:53 +0100] "GET / HTTP/1.1" 200 2792 "-" "Links (2.1pre26; Linux 2.6.18-6-686 i686; 86x55)"
127.0.0.1 redmine - [24/Jan/2009:21:43:53 +0100] "GET / HTTP/1.0" 200 2792 "-" "Links (2.1pre26; Linux 2.6.18-6-686 i686; 86x55)"
127.0.0.1 redmine - [24/Jan/2009:21:43:53 +0100] "GET /javascripts/effects.js?1230631846 HTTP/1.0" 200 38916 "-" "Links (2.1pre26; Linux 2.6.18-6-686 i686; 86x55)"
127.0.0.1 redmine - [24/Jan/2009:21:43:53 +0100] "GET /javascripts/dragdrop.js?1230631846 HTTP/1.0" 200 31534 "-" "Links (2.1pre26; Linux 2.6.18-6-686 i686; 86x55)"
127.0.0.1 redmine - [24/Jan/2009:21:43:53 +0100] "GET /javascripts/controls.js?1230631846 HTTP/1.0" 200 34797 "-" "Links (2.1pre26; Linux 2.6.18-6-686 i686; 86x55)"
127.0.0.1 redmine - [24/Jan/2009:21:43:53 +0100] "GET /javascripts/application.js?1230631770 HTTP/1.0" 200 4151 "-" "Links (2.1pre26; Linux 2.6.18-6-686 i686; 86x55)"
127.0.0.1 redmine - [24/Jan/2009:21:43:53 +0100] "GET /javascripts/prototype.js?1230631846 HTTP/1.0" 200 125605 "-" "Links (2.1pre26; Linux 2.6.18-6-686 i686; 86x55)"

Donc comme ça marche en partie je ne pense que c'est une histoire de droit. je précise que l'hôte est une Etch r6 toute fraîche.
En attendant je vais essayer avec apache que je maîtrise mieux mais j'aimerai bien savoir pourquoi ça ne marche pas !

Merci encore pour le quasi-seul tuto de redmine+Lighttpd du net !


install via aptitude

Posté par Pierro le 12/07/2011 19:35
bonjour,

pensez-vous qu'il soit possible d'installer redmine via les dépots officiels debian (1.0.1), puis d'effectuer la mise de redmine via l'interface ?

Maj

Posté par Lone Wolf le 12/07/2011 20:08
Bonjour,

ce n'est vraiment pas recommandé.

Cordialement
Lone Wolf

Bravo

Posté par Nicolas le 12/09/2011 00:04
Bonjour,

Je suis juste subjugué.
C'est d'une limpidité... Je galère depuis ce matin sur l'installation de redmine (surtout une version > 1.1 et donc pas disponible sur APT) et ce tutorial est tout simplement bluffant. Bravo et encore merci.

Nicolas

Félicitation

Posté par Alex le 29/09/2011 20:04
Ce tuto est excellent, de loin le meilleur du net.

Je n'aurais qu'un mot

Posté par Georges@Bitbol le 18/10/2011 18:18
BRAVO !!

BlogBang
Navigation
 

Réalisé avec Plone

Ce site respecte les normes suivantes :

Wikio