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 ;
- 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.
Installation
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.
Créer un utilisateur spécifique
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
Créer les répertoires nécessaires au fonctionnement de redmine
sudo mkdir -p /usr/share/redmine/tmp /usr/share/redmine/public/plugin_assets /usr/share/redmine/log /usr/share/redmine/files
Définition des droits
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
sudo chown -R redmine:users /etc/redmine
.
Installation depuis les sources
Pré-requis
Pour installer Redmine vous aurez besoin de Ruby, son framework Ruby on Rails et un système de base de données.
Ruby
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.
Ruby on Rails et sources 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
Base de données
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.
MySQL
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
Créer la base de données de Redmine
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
PostgreSQL
Pour PostgreSQL, installez les paquets libpq-dev.
Installez l'adaptateur PostgreSQL pour Ruby avec :
sudo gem install postgres
Création d'un utilisateur spécifique et de la base de données
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.
Installation
Vous devez vous trouver dans le répertoire des sources de Redmine pour la suite des opérations :
cd ~/redmine-1.3.0
Configuration de Redmine
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
Créer un ''session store''
Depuis la version 0.8.7 de Redmine, cette commande est nécessaire :
rake generate_session_store
Créer la structure de la base
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
Il vous suffit de lancer la commande :
rake config/initializers/session_store.rb
puis de créer la structure de la base. (ref: http://www.redmine.org/issues/4848 )
Insérer les données par défaut
RAILS_ENV=production rake redmine:load_default_data
La langue sera demandée, indiquez donc fr
pour du français.
Finir l'installation proprement
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.
Copie vers /opt/
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
Définition des droits
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
Nettoyage
Redmine étant proprement installé, on peut maintenant supprimer les sources du dossier personnel :
rm -rf ~/redmine-1.3.0*
Automatiser le lancement de Redmine
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/
Servir Redmine via Apache
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.
Méthode 1 : Dans un dossier
Pré-requis
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.
Installation de Passenger
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.
Configuration d'Apache
É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
/var/lib/gems/1.8/gems/passenger-3.0.11
, mais dans /usr/lib/gems/1.8/gems/passenger-3.0.11
par exemple, suivant la distribution. Dans ce cas, adaptez simplement les chemins précédents.
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
Le serveur Web Mongrel n'a plus d'intérêt à tourner sur votre machine, vous pouvez donc supprimer le paquet mongrel
.
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>'
Cela peut provenir du fait que bundler n'est pas installé. La correction est simple et rapide : l'installer et relancer Apache.
sudo gem install bundler sudo service apache2 restart
source : https://www.redmine.org/boards/2/topics/42399?r=42428#message-42428
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.
Solution :
sudo chown -R redmine:users /var/log/redmine/ sudo chmod 666 /var/log/redmine/default/* sudo service apache2 restart
Les messages d'erreur de Redmine sont de retour dans /var/log/redmine/default/production.log.
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.
et que l'on trouve un message de ce type dans /var/log/redmine/default/production.log
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'
Dans ce cas, il s'agit de mauvais droits d'accès au répertoire /var/cache/redmine/ (voir le chemin indiqué dans le message).
Solution :
sudo chown -R redmine:redmine /var/cache/redmine/ sudo service apache2 restart
Et recharger la page web.
Solution moche (sécurité) mais qui marche :
sudo chmod go+rw -R /var/lib/redmine/ sudo service apache2 restart
On donne les droits de lecture/écriture à tout le monde et on redémarre le serveur.
Méthode 2 : via un domaine
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
Par :
Order allow,deny Allow from all
et rechargez la config d'Apache :
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.
Création du VirtualHost
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>
Fichiers de log
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
Activation du site
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.
Désactivation
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
Notifications par courriel
Gmail
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.
Utilisation
Lancer Redmine
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.
Pour l'utilisation en production de Redmine, préférez soit :
- utiliser Mongrel et automatiser le lancement de Redmine. Voir la section Configuration;
- utiliser Apache pour servir Redmine. Voir la section Servir Redmine via Apache.
- Identifiant : admin
- Mot de passe : admin
Redémarrer Redmine
Si installé avec mongrel
Relancer le daemon:
sudo /etc/init.d/redmine restart
Si installé avec Apache
Modifiez (ou créez) le fichier /opt/redmine/tmp/restart.txt
sudo touch /opt/redmine/tmp/restart.txt
Lier un dépôt à un projet
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.
Gitolite
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.
Désinstallation
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.
Liens
- (fr, en) Site officiel du projet Redmine
- (fr, en) Le guide officiel de Redmine : installation, mise à jour, utilisation, etc.
Contributeurs : v0n, Rohja, Respawner. yquenechdu