Jacques Foucry bio photo

Jacques Foucry

IT, râleur et faiseur de pain

Email Twitter



Où l’on va installer un serveur http et l’outil de gestion ticket Redmine.

J’ai besoin d’installer l’outil de gestion de ticket Redmine. Et il est nécessaire d’avoir également un serveur http. En lieu et place du célèbre Apache, je préfère utilise nginx. Plus rapide que son prédécesseur, il n’est pas étendu par l’adjonction de module, mais par la compilation des éléments désirés. Ainsi, nous aurons besoin de la connexion à notre serveur LDAP et de Phusion Passenger pour Redmine. D’autres éléments sont nécessaires.

Nous devons donc compiler nginx pour nos besoins spécifiques.

Installation de nginx, redmine et leurs dépendances

La solution la plus simple serait d’utiliser les ports de FreeBSD ( dans /usr/ports). Nous allons plutôt mettre en place poudriere. Il s’agit d’une méthode pour créer des paquets utilisables avec la commande pkg, mais compilée comme nous le désirons. La mise à jour se fera en utilisant nos options de compilation propres.

Je vous laisse lire FreeBSD-InstallPoudriere et revenir pour continuer l’installation et le configuration de nos produits.

Installation avec la poudriere

Voilà, notre poudriere est en place, nginx est déjà compilé selon nos désirs, il ne nous reste plus qu’à l’installer.

1
$ pkg install nginx

Nous allons avoir besoin de mysql (pour redmine). Je vous laisse l’ajouter dans votre poudriere.

1
$ pkg install mysql-server

Installons aussi redmine en créant un dataset ZFS specifique :

1
2
# zfs create -o mountpoint=/usr/local/www/owncloud zroot/usr/local/www/owncloud
# pkg install redmine

Configuration de nginx

Nous avons besoin de configurer nginx pour que celui-ci utilise passenger. La configuration principale se fait dans /usr/local/etc/nginx/nginx.conf. Dans la section http (mais hors de la section server), ajoutons ces lignes :

1
2
3
4
5
# Passenger for redmine
passenger_root /usr/local/lib/ruby/gems/2.1/gems/passenger-5.0.6;
passenger_ruby /usr/local/bin/ruby21;
passenger_user redmine;
passenger_group redmine;

Plus loin, toujours dans la section http nous allons ajouter une directive pour inclure les fichiers de configuration de nos hôtes virtuels :

1
include sites-enabled/*.conf;

Pour connaître le chemin vers passenger_root, utilisez la commande :

1
2
# passenger-config --root
/usr/local/lib/ruby/gems/2.1/gems/passenger-5.0.6

Et pour connaître le chemin vers ruby :

1
2
3
4
# which ruby
/usr/local/bin/ruby
# ls -al /usr/local/bin/ruby
lrwxr-xr-x  1 root  wheel  6 Apr 24 00:21 /usr/local/bin/ruby -> ruby21

Nous devons ajouter aussi une configuration spécifique pour redmine. Nous allons la placer dans le répertoire /usr/local/etc/nginx/sites-available. Lorsque notre fichier de configuration sera prêt, nous ferrons un lien vers le répertoire /usr/local/etc/nginx/sites-enabled.

Le fichier de configuration pour redmine

Créons le fichier /usr/local/etc/nginx/sites-available/redmine.conf avec ce contenu :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
server {
   listen 80;
   server_name support.example.com support.example.com;
    
   charset utf-8;
    
   server_name support.tamanoir.foucry.net support.foucry.net;
   access_log /var/log/nginx/support-access.log main;
   error_log /var/log/nginx/support-error.local;

   location / {
       root /usr/local/www/redmine/public;
       passenger_enabled on;
       passenger_friendly_error_pages on;
   }
}

Note : nous verrons plus tard comment passer en https.

Mise en place et vérification de la configuration

Notre fichier est prêt, nous allons maintenant faire le lien vers le répertoire /usr/local/etc/nginx/sites-enabled/ :

1
# ln -s /usr/local/etc/nginx/sites-available/redmine.conf /usr/local/etc/nginx/sites-enabled/redmine.conf

Et nous pouvons ensuite vérifier la configuration de nginx (simplement la syntaxe des fichiers de configuration, mais c’est déjà une aide précisieuse) :

1
2
3
# nginx -t
nginx: the configuration file /usr/local/etc/nginx/nginx.conf syntax is ok
nginx: configuration file /usr/local/etc/nginx/nginx.conf test is successful

Et le firewall ?

Avant de lancer nginx, nous devons autoriser le firewall à accepter les entrées sur le port 80 (le port http par défaut).

Il faut, souvenez-vous, éditer le fichier /etc/pf.conf. Nous allons ouvrir également le port 443 (https) pour ne plus avoir à nous en soucier quand nous passerons notre site en https.

1
2
3
4
# allow http/https
pass in quick on $if proto tcp from any to any port = 80 flags S/SA keep state
pass in quick on $if proto tcp from any to any port = 8080 flags S/SA keep state
pass in quick on $if proto tcp from any to any port = 443 flags S/SA keep state

Et on n’oublie pas de recharger les règles du firewall :

1
# pfctl -F all ; pfctl -f /etc/pf.conf

Démarrage provisoire de nginx

Nous allons démarrer provisoirement nginx afin de vérifier que nous pouvons accéder au site que nous avons configuré.

1
# service nginx onestart

Tant que nous n’avons pas ajouté le démarrage automatique de nginx dans le fichier /etc/rc.conf, nous devons le démarrer avec la directive onestart. L’arrêt se fait avec onestop et vous l’aurez deviné, le redémarrage avec onerestart.

Test de la connexion

Sur notre machine locale, celle qui sert tous les jours (et qui n’est certainement pas le serveur que nous sommes en train de configurer), nous allons faire en sorte d’accéder à notre serveur redmine.

Nous devons modifier le fichier /etc/hosts.

Attention, cela doit se faire en étant root sur la machine locale. En général, sur une machine unix on passe par la commande sudo

1
<adresse_ip_serveur>   support.tamanoir.example.com

Cela permet d’associer l’adresse IP du serveur au nom que vous voulez lui donner, exactement commne le fait le DNS. Ici ne le faisons dans ce fichier pour gagner du temps.

Il ne nous reste plus qu’a tenter le connexion avec notre navigateur préféré. Elle devrait échouer, l’installation de Redmine n’étant pas terminée. Toutefois, c’est votre serveur qui doit vous répondre, et ça c’est plutôt un bon point.

Suite de la configuration de Redmine

Pour continuer la configuration de Redmine, nous avons besoin d’autres éléments. Le premier est une base de données. J’ai choisi MySQL, parce que c’est connu et que je n’ai pas eu le courage de passer à MariaBD1.

J’explique ici [FreeBSD-install6] l’installation de MySQL.

Configuration de l’accès à la base de données

Nous allons compléter le fichier de configuration /usr/local/www/redmine/config/database.yml. Copions tout d’abord le fichier d’exemple pour être certain d’avoir le bon modèle :

1
2
# cd /usr/local/www/redmine/config
# cp database.yml.example database.yml

Il va nous falloir un mot de passe, que je vous propose de le générer comme d’habitude (et de le conserver à l’abri des regards indiscrets) :

1
2
# openssl rand 9 -base 64
7SZkgeBelGTI

Enfin, éditions le fichier databases.yml :

1
2
3
4
5
6
7
production:
  adapter: mysql2
  database: redmine
  host: localhost
  username: redmine
  password: "7SZkgeBelGTI"
  encoding: utf8

Seule la section production nous intéresse.

Création de la base de données et de l’utilisateur de celle-ci

Nous avons notre moteur de base de données, MySQL, il nous faut maintenant y créer une base spécifique pour que redmine puisse y stocker ses données.

1
2
3
4
5
6
# mysql -u root -p <mot de passe de root de _MySQL_>
mysql> CREATE DATABASE redmine CHARACTER SET utf8;
mysql> CREATE USER 'redmine'@'localhost' IDENTIFIED BY '7SZkgeBelGTI';
mysql> GRANT ALL PRIVILEGES ON redmine.* TO 'redmine'@'localhost';
mysql> exit
Bye

Et aussitôt, nous allons vérifier que nous pouvons nous connecter avec notre nouvel utilisateur et utiliser la base de données spécifiée :

1
2
3
4
5
# mysql -u redmine -p
Enter password:
mysql> use redmine
Database changed
mysql> exit

Il semble que ce soit tout bon.

Installation des gem

Les modules additionnels de Ruby s’appellent des gems. Et Redmine a besoin de beaucoup de gems. Nous n’allons pas les installer à la main, mais utiliser le fichier fourni par l’installation de Redmine qui se nomme /usr/local/www/redmine/Gemfile. Nous allons utiliser un autre gem, normalement déjà installé, bundler. Celui-ci va lire le fichier Gemfile et installer (ou mettre à jour) les gems décrits dedans.

Il est nécessaire que le fichier /usr/local/www/redmine/Gemfile.lock soit accessible en lecture et écriture pour tout le monde.

1
$ bundle 

Génération d’une clef aléatoire

Pour gérer les sessions des utilisateurs, redmine utilise les cookies. Et pour s’assurer de l’unicité des ces cookies, il est nécessaire d’utiliser une clef générée aléatoirement. Une fois de plus, tout est prévu et nous n’avons qu’à lancer un script ruby :

1
# bundle exec rake generate_secret_token

Mise en place du schéma de base de données et des données de test

Redmine dispose maintenant d’une base de données qui lui est propre, mais elle est entièrement vide. Nous devons y créer toutes les tables que le produit va utiliser. On appelle cela le schéma de la base de données.

C’est un script ruby qui va faire cette mise en place pour nous.

1
# RAILS_ENV=production bundle exec rake db:migrate

Nous allons également ensuite ajouter des données de base.

1
# RAILS_ENV=production bundle exec rake redmine:load_default_data

Nouveau test de connexion

Nous pouvons maintenant, depuis notre machine locale, tenter une nouvelle connexion à redmine, avec notre navigateur :

Écran de connexion à Redmine

Vous pouvez vous connecter avec le *login admin et le mot le de passe admin2 et admirer le résultat :

Redmine une fois connecté, dans la partie Administration
  1. MariaDB est un projet dérivé de MySQL initié au moment du rachat de ce dernier par Oracle

  2. nous devrons changer ce mot de passe très rapidement. 


Article suivant :

Laisser un commentaire

Les commentaires sont soumis à modération.