Installer Redmine sur Debian

Par Pierre-Yves Landuré — Dernière modification 07/11/2017 16:27

Redmine est un gestionnaire de projet simple, performant et intuitif développé en Ruby On Rails. Ce guide facilite son installation sur Debian.

Ce guide est testé sur:

Debian 6.0 Squeeze
Debian 7.0 Wheezy
Debian 8.0 Jessie

Ce guide est testé avec ces versions de Redmine:

2.1.4
2.3.0
2.5.1
3.3.2

Prérequis

Ce guide nécessite :

Ruby, comme décrit par Installer Ruby sur Debian.
a2tools, l'outil d'administration simplifiée d'Apache 2.
le module Passenger, comme décrit par Installer le module Phusion Passenger pour Apache 2 sur Debian.

un serveur MySQL, comme décrit par Installer et configurer MySQL sur Debian.
l'outil mysql-tools d'administration simplifiée de MySQL sur l'hôte local (et l'hôte du serveur MySQL, si différent).

Paramètres

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

domain="redmine.example.com"

Renseignez la langue dans laquelle vous souhaitez utiliser l'application:

redmineLang="fr"

Renseignez le nom d'hôte du serveur MySQL:

mysqlHost="localhost"

Si le serveur MySQL n'est pas local, l'outil mysql-tools essaiera de s'y connecter avec le client MySQL, ou, en cas d'échec de connexion, via une connexion SSH.

Renseignez le nom du certificat SSL à utiliser pour chiffrer l'application avec HTTPS (créé via la procédure Créer un certificat SSL / TLS sur Debian ou via Let's Encrypt) (optionnel, recommandé):

sslKeyName="auto"

Installation

Détectez le proxy de commande (command ou sudo):

cmdProxy='command'
command type -f 'sudo' &>'/dev/null' && cmdProxy='sudo'

Déterminez le chemin d'installation:

installPath="/opt/redmine/${domain}"

Déterminez le chemin des données:

dataPath="/var/lib/redmine/${domain}"

Déterminez le chemin du cache:

cachePath="/var/cache/redmine/${domain}"

Déterminez le chemin des journaux:

logPath="/var/log/redmine/${domain}"

Assurez-vous que les dossiers existent:

${cmdProxy} mkdir --parent "${installPath}"
${cmdProxy} mkdir --parent "${dataPath}"
${cmdProxy} mkdir --parent "$(command dirname "${cachePath}")"
${cmdProxy} mkdir --parent "$(command dirname "${logPath}")"

Préparation de l'environnement

Installez les dépendances Ruby de l'application:

${cmdProxy} apt-get install build-essential ca-certificates \
    subversion mysql-client libmysql++-dev libopenssl-ruby1.8 \
    libmagickcore-dev libmagickwand-dev ruby-dev ruby-json imagemagick

Installez l'outil bundler et la bibliothèque mysql2:

${cmdProxy} gem install mysql2

Mise en place de l'application

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

${cmdProxy} wget 'https://raw.github.com/biapy/howto.biapy.com/master/various/sf-downloader' \
    --quiet --no-check-certificate --output-document='/tmp/sf-downloader'
source="$(${cmdProxy} bash '/tmp/sf-downloader' \
    --generic="http://www.redmine.org/projects/redmine/wiki/Download" \
    --output-directory="${installPath}" \
    --tgz --strip-components=1 \
    'redmine' "redmine-VERSION.tar.gz")"

Ajustez les permissions des fichiers:

${cmdProxy} chown -R root:root "${installPath}"
${cmdProxy} chmod -R go-w "${installPath}"

Mise en conformité avec la LSB

Placez les dossiers de données selon les règles de la LSB:

${cmdProxy} mkdir --parent "${installPath}/public/plugin_assets"
${cmdProxy} mv "${installPath}/log" "${logPath}"
${cmdProxy} mv "${installPath}/tmp" "${cachePath}"
${cmdProxy} mv "${installPath}/files" "${dataPath}/files"
${cmdProxy} mv "${installPath}/public/plugin_assets" "${dataPath}/plugin_assets"
${cmdProxy} ln -s "${logPath}" "${installPath}/log"
${cmdProxy} ln -s "${cachePath}" "${installPath}/tmp"
${cmdProxy} ln -s "${dataPath}/files" "${installPath}/files"
${cmdProxy} ln -s "${dataPath}/plugin_assets" "${installPath}/public/plugin_assets"

Création de la base de données

Créez la base de données:

mysqlParams="$(command mysql-tools --server="${mysqlHost}" --with-ssh \
            --auto-hosts --db-prefix="redmine" --create "${domain}")"

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

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

Configuration

Configurez la connexion à la base de données:

command echo "# MySQL database configuration
production:
  adapter: mysql2
  database: ${mysqlDb}
  host: ${mysqlHost}
  username: ${mysqlUser}
  password: ${mysqlPassword}
  encoding: utf8" | ${cmdProxy} tee "${installPath}/config/database.yml"

Configurez l'outil pour utiliser le serveur SMTP local:

echo '# === Simple SMTP server at localhost
production:
  email_delivery:
    delivery_method: :smtp
    smtp_settings:
      address: "localhost"
      port: 25
' | ${cmdProxy} tee "${installPath}/config/configuration.yml"

Remarque: Pour configurer plus précisément le serveur SMTP, reportez-vous à la page Redmine Email Configuration.

Placez-vous dans le dossier de l'application:

command pushd "${installPath}"

Installez les dépendances de l'outil:

${cmdProxy} bundle install --without development test postgresql sqlite

Initialisez le chiffrement du stockage des sessions:

${cmdProxy} bundle exec rake generate_secret_token

Initialisez la base de données:

${cmdProxy} bundle exec rake db:migrate RAILS_ENV="production"

Initialisez le contenu de la base de données:

${cmdProxy} bundle exec rake redmine:load_default_data RAILS_ENV="production" REDMINE_LANG="${redmineLang}"

Remarque: La langue de l'application est choisie durant cette étape.

Quittez le dossier d'installation:

command popd

Ajustez les permissions des fichiers:

${cmdProxy} chown -R www-data:www-data "${installPath}/Gemfile.lock" \
    "${dataPath}" "${logPath}" "${cachePath}"

Configurez logrotate pour gérer la rotation des journaux:

echo "# Logrotate configuration file for Redmine

\"$(command dirname "${logPath}")/*/*.log\" {
    weekly
    missingok
    rotate 12
    copytruncate
    compress                                                      
    delaycompress
    create 644 www-data www-data
}
" | ${cmdProxy} tee '/etc/logrotate.d/redmine'

Surveillance automatisée des dépôts logiciels

Par défaut, l'application ne télécharge les informations des nouvelles révisisions dans les dépôts que lors d'une visite de l'onglet "Dépôt" d'un projet. Configurez le téléchargement horaire des nouvelles révisions.

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

mysqlHost=$(command grep -e "host[ \t]*:" "${installPath}/config/database.yml" \
    | command sed -e 's/.*:[ \t]*\(.*\)[ \t]*$/\1/')
mysqlDb=$(command grep -e "database[ \t]*:" "${installPath}/config/database.yml" \
    | command sed -e 's/.*:[ \t]*\(.*\)[ \t]*$/\1/')
mysqlUser=$(command grep -e "username[ \t]*:" "${installPath}/config/database.yml" \
    | command sed -e 's/.*:[ \t]*\(.*\)[ \t]*$/\1/')
mysqlPassword=$(command grep -e "password[ \t]*:" "${installPath}/config/database.yml" \
    | command sed -e 's/.*:[ \t]*\(.*\)[ \t]*$/\1/')

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

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

Créez le script Cron de récupération des révisions:

${cmdProxy} tee "/etc/cron.d/redmine-${domain//\./-}" <<< \
"# Redmine on ${domain} changesets autofetch :
*/5 * * * * www-data [ -f '${installPath}/Rakefile' -a -x '/usr/local/bin/rake' ] && RAILS_ENV=production command /usr/local/bin/rake -f '${installPath}/Rakefile' redmine:fetch_changesets"
${cmdProxy} service cron reload

Configuration du serveur HTTP

Créez la configuration Apache 2 de l'outil:

if [[ -n "${sslKeyName}" && ( -e "/etc/ssl/private/${sslKeyName}.key" || "${sslKeyName}" = 'auto' ) ]]; then
  ${cmdProxy} a2tools --ssl="${sslKeyName}" --without-multiviews "${domain}" "${installPath}/public"
else
  ${cmdProxy} a2tools --without-multiviews "${domain}" "${installPath}/public"
fi

Accédez à l'application via l'URL fournie:

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

Sauvegardez l'installation avec Backup Manager (voir Installer et configurer Backup Manager sur Debian):

${cmdProxy} backup-manager-tools add "${installPath}"
${cmdProxy} backup-manager-tools add "${dataPath}"

N'oubliez pas de sauvegarder la base de données (voir Installer et configurer MySQL sur Debian).

Pour aller plus loin

Initiez-vous à l'utilisation de Redmine en lisant le guide de Redmine (anglais). L'outil a une ergonomie bien conçue et est très facile à prendre en main.

Pour disposer d'un dépôt Subversion pour versionner le code source, suivez le guide Installer un serveur Subversion sur Debian.

Mise à jour

Renseignez le domaine de l'installation obsolète:

domain="redmine.domain.com"

Déterminez le chemin d'installation:

installPath="/opt/redmine/${domain}"

Détectez le proxy de commande (command ou sudo):

cmdProxy='command'
command type -f 'sudo' &>'/dev/null' && cmdProxy='sudo'

Nettoyez le chemin:

installPath="${installPath%/}"

Déterminez le chemin des données:

dataPath="/var/lib/redmine/${domain}"

Déterminez le chemin du cache:

cachePath="/var/cache/redmine/${domain}"

Déterminez le chemin des journaux:

logPath="/var/log/redmine/${domain}"

Sauvegardez l'installation mise à jour:

command test -e "${installPath}.old" && ${cmdProxy} rm -r "${installPath}.old"
${cmdProxy} cp -a "${installPath}" "${installPath}.old"

Récupérez la dernière version de l'application à l'aide de sf-downloader:

${cmdProxy} wget 'https://raw.github.com/biapy/howto.biapy.com/master/various/sf-downloader' \
    --quiet --no-check-certificate --output-document='/tmp/sf-downloader'
source="$(${cmdProxy} bash '/tmp/sf-downloader' \
    --generic="http://www.redmine.org/projects/redmine/wiki/Download" \
    --output-directory="${installPath}" \
    --tgz --strip-components=1 \
    'redmine' "redmine-VERSION.tar.gz")"

Recréez les liens symboliques écrasés par la décompression de l'archive:

${cmdProxy} rm -r "${installPath}/log" "${installPath}/tmp" \
     "${installPath}/files" "${installPath}/public/plugin_assets"
${cmdProxy} ln -s "${logPath}" "${installPath}/log"
${cmdProxy} ln -s "${cachePath}" "${installPath}/tmp"
${cmdProxy} ln -s "${dataPath}/files" "${installPath}/files"
${cmdProxy} ln -s "${dataPath}/plugin_assets" "${installPath}/public/plugin_assets"

Ajustez les permissions des fichiers:

${cmdProxy} chown -R root:root "${installPath}"
${cmdProxy} chmod -R go-w "${installPath}"
${cmdProxy} chown -R www-data:www-data "${dataPath}"
${cmdProxy} chown -R www-data:www-data "${cachePath}"
${cmdProxy} chown -R www-data:www-data "${logPath}"

Placez-vous dans le dossier de l'application:

command pushd "${installPath}"

Mettez à jour les rubygem installées:

${cmdProxy} bundle update

Installez les dépendances de la nouvelle version:

${cmdProxy} bundle install --without development test postgresql sqlite

Lancez les tâches de mise à jour de la base de données:

${cmdProxy} bundle exec rake generate_secret_token
${cmdProxy} bundle exec rake db:migrate RAILS_ENV=production
${cmdProxy} bundle exec rake redmine:plugins:migrate RAILS_ENV=production 
${cmdProxy} bundle exec rake tmp:cache:clear
${cmdProxy} bundle exec rake tmp:sessions:clear

Quittez le dossier de l'application:

command popd

Redémarrez le serveur Apache 2:

${cmdProxy} service apache2 force-reload

Vérifiez que tout fonctionne correctement, et effacez la sauvegarde:

${cmdProxy} rm -r "${installPath}.old"

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.
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}):.

Installer Redmine sur Debian

Prérequis

Paramètres

Installation

Préparation de l'environnement

Mise en place de l'application

Mise en conformité avec la LSB

Création de la base de données

Configuration

Surveillance automatisée des dépôts logiciels

Configuration du serveur HTTP

Sauvegardes

Pour aller plus loin

Mise à jour

Remerciements

Commentaires (0)