Redmine

Redmine est un système Open Source de gestion de projet en mode web. Il est développé en ruby grâce au framework ruby on rails.

Les fonctionnalités :

• gestion multi-projets ;
• gestion fine des droits utilisateurs définis par des rôles ;
• rapports de bogues, demandes d'évolutions ;
• Wiki multi-projets ;
• forums multi-projets ;
• news accessibles par RSS / ATOM ;
• notifications par courriel ;
• gestion de feuilles de route, GANTT, calendrier ;
• historique ;
• intégration avec divers suivis de versions : SVN, CVS, Mercurial, Git, Bazaar & Darcs ;
• identification possible via LDAP ;
• multilingue (25 langues disponibles pour la 0.7.0) ;
• prise en charge de plusieurs bases de données : MySQL, PostgreSQL ou SQLite.

Pour installer ce logiciel, il suffit d'installer le paquet redmine.

Selon la base de données utilisée, on installera :

• redmine-sqlite pour SQLite ;
• redmine-pgsql pour PostgreSQL ;
• redmine-mysql pour MySQL.

Pour des raisons de sécurité, il est préfèrable de créer un utilisateur spécifique à Redmine pour utiliser la base :

sudo addgroup redmine
sudo adduser redmine --no-create-home --ingroup redmine

sudo mkdir -p /usr/share/redmine/tmp /usr/share/redmine/public/plugin_assets /usr/share/redmine/log /usr/share/redmine/files

cd  /usr/share/redmine
sudo chown -R redmine:redmine files log tmp public/plugin_assets
sudo chmod -R 755 files log tmp public/plugin_assets

Pour installer Redmine vous aurez besoin de Ruby, son framework Ruby on Rails et un système de base de données.

Redmine nécessite Ruby. Installez les paquets build-essential ruby-dev rubygems rake.

L'installation de Rails est précisée ci-dessous, car la version à installer est importante suivant la version de Redmine.

La dernière version stable de Redmine à ce jour est la version 1.3.0 (2011-12-10). Elle nécessite la version 2.3.14 de Rails et la version 1.1.x de Rack.

Installez donc ces dépendances à l'aide des commandes :

sudo gem install rack -v=1.1.3
sudo gem install rails -v=2.3.14

Télécharger les sources de Redmine dans votre répertoire personnel :

cd ~
wget http://rubyforge.org/frs/download.php/75597/redmine-1.3.0.tar.gz

Extrayez les sources :

tar zxf redmine-1.3.0.tar.gz

Plusieurs types de base de données sont supportés par Redmine. Dans les plus communs, on note MySQL, PostgreSQL ou SQLite. Utilisez celui que vous préferez.

Pour MySQL, installez les paquets mysql-server libmysqlclient-dev.

Durant l'installation de MySQL, il sera demandé un mot de passe pour le compte d'administration de MySQL ("root").

Installez l'adaptateur MySQL pour Ruby avec :

sudo gem install mysql

mysql -u root -p

Entrez le mot de passe pour le compte d'administration de MySQL (demandé à l'installation).

Tapez les requêtes SQL correspondantes :

CREATE DATABASE redmine DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

GRANT ALL PRIVILEGES ON redmine.* TO 'redmine'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;

La base de données de redmine est créée. Sortez avec :

exit

Pour PostgreSQL, installez les paquets libpq-dev.

Installez l'adaptateur PostgreSQL pour Ruby avec :

sudo gem install postgres

Pour des raisons de sécurité, il est préfèrable de créer un utilisateur spécifique à Redmine pour utiliser la base :

su postgres
createuser redmine --no-superuser --no-createdb --no-createrole --login --pwprompt --encrypted
createdb --owner=redmine --encoding=utf-8 redmine
exit

Un mot de passe sera demandé pour l'utilisateur redmine.

Vous devez vous trouver dans le répertoire des sources de Redmine pour la suite des opérations :

cd ~/redmine-1.3.0

Copier le fichier de configuration :

cp config/database.yml.example config/database.yml

Puis éditez le fichier config/database.yml pour adapter la partie production suivant la base de données à utiliser (ici, MySQL ou PostgreSQL) :

• Fichier d'accès à la base pour MySQL :

production:
  adapter: mysql
  socket: /var/run/mysqld/mysqld.sock 
  database: redmine
  host: localhost
  username: redmine
  password: password
  encoding: utf8

• Fichier d'accès à la base pour PostgreSQL :

production:
  adapter: postgresql
  database: redmine
  host: localhost
  username: redmine
  password: password
  encoding: utf8
  schema_search_path: public
  

Depuis la version 0.8.7 de Redmine, cette commande est nécessaire :

rake generate_session_store

RAILS_ENV=production rake db:migrate

A key is required to write a cookie containing the session data. Use config.action_controller.session = { :key => "_myapp_session", :secret => "some secret phrase" } in config/environment.rb

rake config/initializers/session_store.rb 

RAILS_ENV=production rake redmine:load_default_data

La langue sera demandée, indiquez donc fr pour du français.

L'installation consiste grossièrement à télécharger les sources dans votre dossier personnel.

Afin de respecter la philosophie GNU/Linux sur l'installation des logiciels (au niveau arborescence), vous ne devez pas laisser un simple dossier de sources dans votre dossier personnel.

Le principe est de déplacer ce dossier dans /opt/. D'autres parts, ceci rendra le logiciel installé pour tous les utilisateurs du système et non seulement pour vous.

Créer le dossier /opt/redmine :

sudo mkdir /opt/redmine

Copier les sources vers ce répertoire :

sudo cp -r ~/redmine-1.3.0/* /opt/redmine

Un dossier tmp et public/plugin_assets doit être présent par convention dans les sources (si ce n'est pas déjà le cas) :

sudo mkdir -p /opt/redmine/tmp /opt/redmine/public/plugin_assets

Un dossier pids doit être présent également pour permettre à mongrel de démarrer.

sudo mkdir /opt/redmine/tmp/pids

L'utilisateur qui lance Redmine doit avoir les droits d'écriture sur les dossiers files, log, tmp et public/plugin_assets des sources. Nous allons prendre ici l'utilisateur redmine précédement créé :

cd /opt/redmine
sudo chown -R redmine:redmine files log tmp public/plugin_assets
sudo chmod -R 755 files log tmp public/plugin_assets

Redmine étant proprement installé, on peut maintenant supprimer les sources du dossier personnel :

rm -rf ~/redmine-1.3.0*

Pour pouvoir démarrer, redémarrer, arrêter facilement Redmine et l'ajouter au démarrage de la machine, nous devons :

• Installer le paquet mongrel ;

Mongrel est un serveur HTTP écrit en Ruby et en C. Il a été conçu pour être léger, rapide et sécurisé. C'est ce serveur qui sera désormais utilisé pour exécuter Redmine.

• Puis il faut créer un script exécutable /etc/init.d/redmine contenant :

#!/bin/sh
 
set -e
 
REDMINE_PATH=/opt/redmine/
REDMINE_PID=/tmp/mongrel.pid
REDMINE_PORT=3000
REDMINE_INTERFACE=127.0.0.1
 
if [ -x /usr/bin/mongrel_rails ] ; then
        HAVE_MONGREL=1
else
        echo "Mongrel not installed."
        exit 0
fi
 
. /lib/lsb/init-functions
 
case "$1" in
  start)
        log_action_begin_msg "Starting Redmine server"
        mongrel_rails start -c $REDMINE_PATH -d -e production -p $REDMINE_PORT -P $REDMINE_PID -a $REDMINE_INTERFACE
        log_action_end_msg $?
        ;;
  stop)
        log_action_begin_msg "Stopping Redmine server"
        mongrel_rails stop -c $REDMINE_PATH -P $REDMINE_PID
        log_action_end_msg $?
        ;;
  force-reload|restart)
        $0 stop
        $0 start
        ;;
  *)
        echo "Usage: /etc/init.d/redmine {start|stop|restart|force-reload}"
        exit 1
        ;;
esac
 
exit 0

• Ne pas oublier de rendre le script exécutable :

sudo chmod +x /etc/init.d/redmine

À ce point vous pouvez respectivement démarrer, redémarrer et arrêter Redmine à l'aide des commandes :

sudo /etc/init.d/redmine start
sudo /etc/init.d/redmine restart
sudo /etc/init.d/redmine stop

• Pour ajouter Redmine au démarrage de la machine :

sudo update-rc.d redmine defaults

Redmine sera désormais lancé à chaque démarrage de la machine.

Vous pouvez y accédez à présent via l'adresse : http://localhost:3000/

On a deux manières de configurer Apache :

• vous pouvez placer Redmine dans un dossier, aussi appelé sub-URI, d'un site déjà créé (par exemple : http://localhost/redmine ou http://monsite.com/redmine). Voir la méthode 1;
• vous pouvez attribuer un domaine à Redmine (comme http://monsite-redmine.com, http://redmine.monsite.com, …) consistant à créer un VirtualHost. Voir la méthode 2.

Si ce n'est pas le cas, mettez à jour votre système.

Vous devez disposer des paquets de construction essentiels, de développement Apache, nécessaires au déploiement.

Installez donc les paquets : apache2-prefork-dev libapr1-dev libaprutil1-dev.

Il faut à présent installer Passenger (alias mod_rails), le module d'Apache permettant de faire tourner une application Ruby on Rails sur Apache.

sudo gem install passenger

Lancer le script d'installation du module (commande à adapter suivant la version de Passenger bien sur) :

sudo ruby passenger-install-apache2-module

/var/lib/gems/1.8/gems/passenger-3.0.11/bin/passenger-install-apache2-module

Ce script vous guidera dans le déploiement d'une application Rails (détaillée ci-dessous). Suivez ses instructions.

Éditez les configurations comme indiqué dans l'installation de Passenger, à commencer par le module.

Créez (ou éditez) le fichier /etc/apache2/mods-available/passenger.load, pour y indiquer le chemin du module comme suit :

LoadModule passenger_module /var/lib/gems/1.8/gems/passenger-3.0.11/ext/apache2/mod_passenger.so

Créez (ou éditez) ensuite le fichier /etc/apache2/mods-available/passenger.conf pour y adapter le chemin de Passenger et Ruby comme suit :

PassengerRoot /var/lib/gems/1.8/gems/passenger-3.0.11
PassengerRuby /usr/bin/ruby1.8

Activez les modules d'Apache nécessaires :

sudo a2enmod passenger
sudo a2enmod rewrite

Il faut à présent configurer l'URI.

Faites une copie de votre fichier de configuration (par soucis de sauvegarde) :

sudo cp /etc/apache2/sites-available/default /etc/apache2/sites-available/default.bak

Puis éditez /etc/apache2/sites-available/default pour y mettre le contenu suivant (vous pouvez adapter ou tout remplacer) :

<VirtualHost *:80>
	ServerAdmin webmaster@localhost
	ServerName localhost

	DocumentRoot /var/www
	RailsEnv production
	RailsBaseURI /redmine
	
	<Directory /var/www/redmine>
		Options FollowSymLinks
		AllowOverride None
		Order deny,allow
		Allow from all
                RailsBaseURI /redmine
		PassengerResolveSymlinksInDocumentRoot on
	</Directory>

	ErrorLog /var/log/apache2/error.log
	LogLevel warn
	CustomLog /var/log/apache2/access.log combined
</VirtualHost>

Faites un lien vers les sources de Redmine (plus précisément de son dossier public/) dans la racine de votre serveur Web :

sudo ln -s /opt/redmine/public /var/www/redmine

Définissez l'utilisateur de Redmine comme propriétaire des sources de l'application :

sudo chown -R redmine:users /opt/redmine

sudo usermod -d /var/www/redmine redmine

sudo update-rc.d -f redmine remove
sudo rm /etc/init.d/redmine

Redémarrez Apache :

sudo /etc/init.d/apache2 restart

Votre application est désormais accessible depuis http://localhost/redmine !

Web application could not be started

cannot load such file -- bundler/setup (LoadError)
  /usr/lib/ruby/1.9.1/rubygems/custom_require.rb:36:in `require'
  /usr/lib/ruby/1.9.1/rubygems/custom_require.rb:36:in `require'
  /usr/lib/ruby/vendor_ruby/phusion_passenger/loader_shared_helpers.rb:245:in `block in run_load_path_setup_code'
  /usr/lib/ruby/vendor_ruby/phusion_passenger/loader_shared_helpers.rb:348:in `running_bundler'
  /usr/lib/ruby/vendor_ruby/phusion_passenger/loader_shared_helpers.rb:243:in `run_load_path_setup_code'
  /usr/share/passenger/helper-scripts/rack-preloader.rb:100:in `preload_app'
  /usr/share/passenger/helper-scripts/rack-preloader.rb:158:in `<module:App>'
  /usr/share/passenger/helper-scripts/rack-preloader.rb:29:in `<module:PhusionPassenger>'
  /usr/share/passenger/helper-scripts/rack-preloader.rb:28:in `<main>'

sudo gem install bundler
sudo service apache2 restart

Rails Error: Unable to access log file. Please ensure that /var/log/redmine/default/production.log exists and is chmod 0666. The log level has been raised to WARN and the output directed to STDERR until the problem is fixed.

sudo chown -R redmine:users /var/log/redmine/
sudo chmod 666 /var/log/redmine/default/*
sudo service apache2 restart

Internal error

An error occurred on the page you were trying to access.
If you continue to experience problems please contact your Redmine administrator for assistance.

If you are the Redmine administrator, check your log files for details about the error.

ActionView::Template::Error (Permission denied - /var/cache/redmine/default/cache/900):
    16:   <p><%= f.text_field :firstname, :required => true %></p>
    17:   <p><%= f.text_field :lastname, :required => true %></p>
    18:   <p><%= f.text_field :mail, :required => true %></p>
    19:   <p><%= f.select :language, lang_options_for_select %></p>
    20:   <% if Setting.openid? %>
    21:   <p><%= f.text_field :identity_url  %></p>
    22:   <% end %>
  lib/redmine/i18n.rb:95:in `languages_options'
  app/helpers/application_helper.rb:962:in `lang_options_for_select'
  app/views/my/account.html.erb:19:in `block in _app_views_my_account_html_erb__1203571593285091717_37874920'
  app/helpers/application_helper.rb:977:in `labelled_form_for'
  app/views/my/account.html.erb:9:in `_app_views_my_account_html_erb__1203571593285091717_37874920'

sudo chown -R redmine:redmine  /var/cache/redmine/
sudo service apache2 restart

sudo chmod go+rw -R /var/lib/redmine/
sudo service apache2 restart

Par souci de centralisation ou de simplicité, on peut vouloir utiliser Apache pour servir Redmine. Cela se fait très simplement à l'aide des fonctions de Proxy fournies par Apache.

On commence donc par activer les modules Apache pour le proxy si ce n'est déjà fait. Il s'agit des modules proxy et proxy_http que l'on active à l'aide de a2enmod :

sudo a2enmod proxy
sudo a2enmod proxy_http

Order deny,allow
Deny from all

Order allow,deny
Allow from all

sudo /etc/init.d/apache2 reload

Si vous voulez utiliser un domaine spécifique pour Redmine, la méthode la plus simple consiste à créer un VirtualHost. Dans l'exemple, on utilisera le domaine local redmine.lan. Consultez la page sur bind9 pour configurer un serveur DNS en local.

On donc créer un nouveau site dans Apache en créant le fichier /etc/apache2/sites-available/redmine.lan.

Il s'agit d'un fichier de configuration, donc veillez à utiliser les droits d'administration (sudo) :

<VirtualHost *:80>
  ServerName redmine.lan   # On indique à Apache que le domaine du site est "redmine.lan"
  
  # On paramètre le proxy pour transmettre les requêtes adresées à tracker.lan soient transmises à
  # Redmine (Mongrel est installé en local sur le port 3000)
  ProxyPreserveHost Off
  ProxyPass        /  http://127.0.0.1:3000/
  ProxypassReverse /  http://127.0.0.1:3000/
  
  # On définit les fichiers de log
  ErrorLog /opt/redmine/log/apache-error.log
  CustomLog /opt/redmine/log/apache-access.log combined
</VirtualHost>

On va créer les fichiers de log pour y stocker les accès et les erreurs propres au VirtualHost, afin de bien les dissocier des autres domaines :

$ sudo touch /opt/redmine/log/apache-error.log
$ sudo touch /opt/redmine/log/apache-access.log

Pour que Apache puisse y accéder, on va les faire appartenir à celui-ci :

$ sudo chown www-data:www-data /opt/redmine/log/apache-error.log
$ sudo chown www-data:www-data /opt/redmine/log/apache-access.log

Il ne reste plus qu'à activer le site dans Apache. Cela se fait simplement avec la commande a2ensite suivie du nom du fichier que l'on a créé.

$ sudo a2ensite redmine.lan

On recharge la configuration de Apache :

$ sudo /etc/init.d/apache2 reload

Vous pouvez dorénavant accéder à Redmine en tapant http://redmine.lan/ dans votre navigateur.

Si, pour une raison ou pour une autre, vous souhaitiez désactiver le site, utilisez a2dissite :

$ sudo a2dissite redmine.lan

Il en va de même pour les modules de proxy avec la commande a2dismod :

$ sudo a2dismod proxy_http
$ sudo a2dismod proxy

Ensuite, on recharge la config d'Apache, et tout est désactivé :

$ sudo /etc/init.d/apache2 reload

Placez-vous dans le dossier des sources de Redmine :

cd /opt/redmine

Gmail a besoin de TLS pour envoyer des e-mails. Installez donc le plugin pour Redmine avec :

sudo ruby script/plugin install git://github.com/collectiveidea/action_mailer_optional_tls.git

Copiez l'exemple de configuration de Redmine :

sudo cp config/email.yml.example config/email.yml

Éditez le fichier config/email.yml pour l'adapter comme suit :

production:
  delivery_method: :smtp
  smtp_settings:
    tls: true
    enable_starttls_auto: true
    address: "smtp.gmail.com"
    port: '587'
    domain: "smtp.gmail.com"
    authentication: :plain
    user_name: "votre_login@gmail.com"
    password: "votre_mot_de_passe"

Redémarrez à présent Redmine selon votre configuration (Par exemple, si vous servez Redmine via Apache, utilisez donc sudo /etc/init.d/apache2 restart).

Redmine est prêt à envoyer les notifications par courrier électronique. Pour la configuration de vos notifications, rendez-vous dans Redmine > Administration > Configuration > Notifications par mails.

Pour lancer Redmine, vous pouvez exécuter le script ruby des sources :

sudo ruby /opt/redmine/script/server -e production

L'option -d permet de le lancer en démon :

sudo ruby /opt/redmine/script/server -d -e production

Par défaut, Redmine écoute sur le port 3000 et utilise WEBrick. WEBrick est un serveur web libre intégré à Ruby depuis la version 1.8 et utilisé par Ruby on Rails.

Une fois Redmine lancé, vous pouvez y accéder via http://adresse_de_votre_serveur:3000/. Vous devez à présent voir la page d'accueil de l'application.

Relancer le daemon:

sudo /etc/init.d/redmine restart

Modifiez (ou créez) le fichier /opt/redmine/tmp/restart.txt

sudo touch /opt/redmine/tmp/restart.txt

Pour lier un dépôt (Subversion ou autre) il suffit, dans l'interface de Redmine, de se rendre dans votre projet (en étant administrateur bien entendu), puis dans Configuration > Onglet Dépôt :

ajoutez un nouveau dépôt en précisant le type, son adresse et un identifiant et mot de passe si l'authentification est requise.

Redmine interprètera ainsi les logs et reportera sur l'interface de votre projet toutes les modifications effectuées sur les sources.

Concernant les dépôts GIT, si ces derniers sont sur un autre serveur *nix, il est possible de les exploiter directement via un simple partage nfs et de paramétrer votre projet en lui donnant le chemin de montage (ex.: /mnt/depots/monProjet.git), simple et efficace

Si vous utilisez Gitolite pour gérer vos dépôts Git et que vous voulez permettre à Redmine de parcourir vos dépôts, l'utilisateur de Redmine doit avoir le droit de lecture sur ces fichiers.

Par défaut, Gitolite ne permet qu'à l'utilisateur git de lire la plupart des fichiers. La solution la plus propre consiste à ajouter l'utilisateur de Redmine dans le groupe git et d'attribuer le droit de lecture au groupe sur le dépôt.

Commencez par changer le masque de permissions des dépôts de Gitolite.

Ajouter l'utilisateur de Redmine au groupe git :

sudo usermod -G git redmine

Redémarrez à présent Redmine selon votre configuration (Par exemple, si vous servez Redmine via Apache, utilisez donc sudo /etc/init.d/apache2 restart), et ajouter votre dépôt Git à votre projet comme décrit plus haut.

La désinstallation de Redmine consisterait à supprimer les sources de Redmine (/opt/redmine), la base de données MySQL redmine, le script de démarrage de Redmine (/etc/init.d/redmine, s'il existe) ainsi que l'utilisateur et le groupe redmine. Il faut aussi supprimer l'éventuelle configuration d'Apache.

• (fr, en) Site officiel du projet Redmine
• (fr, en) Le guide officiel de Redmine : installation, mise à jour, utilisation, etc.
• (en) Démo en ligne de Redmine
• (fr) Une fiche descriptive de Redmine

Contributeurs : v0n, Rohja, Respawner. yquenechdu