Vous êtes ici : Accueil / Debian GNU/Linux / Applications Web / Gestion de projets / Installer Redmine sur Debian

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 :

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