Geonobot Wiki

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Dépendances ======

Avant tout, mettons à jour notre système Ubuntu :
<code>sudo apt-get update
sudo apt-get upgrade</code>

Installons ensuite les outils qui seront utilisés par notre Redmine :
<code>sudo apt-get install apache2 sqlite3 git curl</code>

Si nous détaillons un peu plus :
  * Apache2 sera notre serveur Web
  * sqlite3 sera le moteur de base de données
  * git est un outil de gestion de conf (parmi d'autres comme mercurial, svn, cvs,...)
  * curl sera utilisé lors de l'installation pour transférer des données depuis internet

Redmine est basé sur Ruby On Rails qui est un framework Web. Ruby On Rails a également un certain nombre de dépendances qu'il faut combler mais que nous ne détaillerons pas ici :
<code>sudo apt-get install gawk libreadline6-dev zlib1g-dev libssl-dev libyaml-dev libsqlite3-dev \
autoconf libgdbm-dev libncurses5-dev automake libtool bison pkg-config libffi-dev libmagickwand-dev</code>

Apache, le serveur Web, a besoin d'un module pour exécuter des applications Ruby On Rails comme Redmine. Il faut donc aussi installer les dépendances de ce module :
<code>sudo apt-get install libcurl4-gnutls-dev apache2-threaded-dev libapr1-dev libaprutil1-dev</code>

====== Installation ======

Il faut ajouter un utilisateur qui exécutera le serveur Redmine et dont le répertoire personnel contiendra l'ensemble de son arborescence. Pour plus de simplicité nous nommerons cet utilisateur redmine dans la suite de cet article.
<code>sudo adduser \
  --system \
  --shell /bin/bash \
  --gecos 'redmine' \
  --gid `grep "sudo" /etc/group|cut -d: -f3`\
  --home /opt/redmine \
  redmine</code>
===== En tant qu'utilisateur redmine =====

Une fois cet utilisateur créé, identifiez vous avec son compte :
<code>sudo su - redmine</code>

==== Ruby On Rails ====

Nous allons installer Ruby via RVM (Ruby Version Manager). Récupérons et installons d'abord RVM :
<code>curl -L https://get.rvm.io | bash -s stable
echo '[[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm" # Load RVM function' >> ~/.bashrc
. ~/.bashrc</code>

Nous n'aurons pas besoin de générer la documentation des composants Ruby donc désactivons cette génération par défaut :
<code>echo "gem: --no-rdoc --no-ri" >> ~/.gemrc</code>

Installons maintenant Ruby et Rails à leur dernière version stable :
<code>rvm get stable --ruby --rails</code>

Une fois installé, Ruby nous fournit un outil permettant de gérer ses composants à la manière de package appelés Gems. Cet outil nommé RubyGems est utilisé via la commande gem. Installons donc notre première Gem, bundler, qui va permettre de rechercher et d'installer les Gems nécessaires à un projet :
<note important>Les Gems d'un projet sont spécifiées dans le fichier Gemfile du projet.</note>
<code>gem install bundler</code>
==== Redmine ====

Sur [[http://www.redmine.org/projects/redmine/wiki/Download|cette page]], vous trouverez le lien de la dernière version de Redmine (en l'occurence la 2.5.2). Il ne reste plus quà la télécharger et extraire l'archive :
<code>wget http://www.redmine.org/releases/redmine-2.5.2.tar.gz
tar xzf redmine-2.5.2.tar.gz
ln -s redmine-2.5.2 redmine</code>

Rentrons dans le répertoire fraîchement extrait et préparons la configuration de la base de données en nous basant sur le fichier d'exemple fourni.
<code>cd redmine/
cp config/database.yml.example config/database.yml</code>

Sachant que nous utilisons sqlite3 comme moteur de base de données, celle-ci sera réprésentée par un simple fichier que nous nommerons dans le fichier config/database.yml :
<code>production:
  adapter: sqlite3
  database: db/redmineGeonobot.sqlite3</code>

Nous avons installé bundler précédemment, il est maintenant temps de l'utiliser pour installer toutes les Gems requises par notre Redmine :
<note important>L'option --without permet d'enlever de la liste des Gems dont nous ne nous servirons pas.</note>
<code>bundle install --without development test postgresql mysql</code>

Pour sécuriser les données de session, nous allons générer une clé de cryptage :
<code>rake generate_secret_token</code>

Il ne reste plus à qu'à initialiser la base de données de Redmine. Rails pouvant définir plusieurs environnements (production, development, test), nous spécifions ici que nous voulons l'environnement de production.
<code>RAILS_ENV=production rake db:migrate
RAILS_ENV=production rake redmine:load_default_data</code>

==== Passenger ====

Comme évoqué au début de cet article, Passenger est le module Apache qui va nous permettre d'exécuter des applications Ruby On Rails sur le serveur web. Passenger étant une Gem, nous allons l'installer et créer le module pour notre utilisateur redmine :

<code>gem install passenger
passenger-install-apache2-module</code>

Nous avons terminé l'installation à effectuer par notre utilisateur redmine. C'est à l'administrateur de la machine de prendre le relais :
<code>exit</code>

===== En tant qu'administrateur =====

==== Apache =====

Il faut maintenant dire à Apache où trouver le module Passenger que nous avons installé précédemment :
<note important>Attention le chemin peut différer selon les versions de Passenger et de Ruby que vous avez installé.</note>
Contenu de **/etc/apache2/mods-available/passenger.conf** :
<code><IfModule mod_passenger.c>
   PassengerRoot /opt/redmine/.rvm/gems/ruby-2.0.0-p481/gems/passenger-4.0.45
   PassengerDefaultRuby /opt/redmine/.rvm/wrappers/ruby-2.0.0-p481/ruby
</IfModule></code>

Il faut également lui demander de charger ce module en éditant le fichier **/etc/apache2/mods-available/passenger.load** :
<code>LoadModule passenger_module /opt/redmine/.rvm/gems/ruby-2.0.0-p481/gems/passenger-4.0.45/buildout/apache2/mod_passenger.so</code>

Il reste à configurer notre Redmine dans Apache via le fichier **/etc/apache2/sites-available/redmine.conf**. Vous noterez que nous forçons l'utilisation du HTTPS pour sécuriser les connexions :
<code><VirtualHost *:80>
 ServerName redmineServer
 DocumentRoot /opt/redmine/redmine/public

 RewriteEngine on
 RewriteCond %{SERVER_PORT} !^443$
 RewriteRule ^.*$ https://%{SERVER_NAME}%{REQUEST_URI} [L,R=permanent]
 <Directory /opt/redmine/redmine/public>
   Require all granted
   Options -MultiViews
 </Directory>
</VirtualHost>

<VirtualHost *:443>
 ServerName redmineServer
 DocumentRoot /opt/redmine/redmine/public

 SSLEngine on
 SSLCertificateFile /etc/apache2/ssl/redmine.crt
 SSLCertificateKeyFile /etc/apache2/ssl/redmine.key

 <Directory /opt/redmine/redmine/public>
   Require all granted
   Options -MultiViews
 </Directory>
</VirtualHost></code>

Comme nous utilisons HTTPS il faut générer les certificats SSL permettant d'encrypter les communications avec le serveur :
<code>sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout /etc/apache2/ssl/redmine.key -out /etc/apache2/ssl/redmine.crt</code>

Il ne reste plus qu'à désactiver le site par défaut fourni avec Apache et le remplacer par notre Redmine :
<code>sudo a2dissite 000-default
sudo a2ensite redmine</code>

Sans oublier d'activer le module Passenger que nous avons configuré précédemment, ainsi que le module ssl pour la connexion sécurisée et le module rewrite pour la redirection d'url HTTP vers HTTPS :
<code>sudo a2enmod passenger rewrite ssl</code>

La configuration d'Apache étant terminée, rechargeons le pour appliquer les changements :
<code>sudo service apache2 restart</code>

Notre serveur Redmine est désormais installé et devrait être accessible en HTTP. En imaginant que notre serveur se nomme **myredmineserver.home**, vous devriez y accéder via l'URL [[http://myredmineserver.home]] qui vous redirigera vers [[https://myredmineserver.home]]
Geonobot Wiki

Outils pour utilisateurs

Outils du site

Outils de la page
