Comment installer redmine sur RHEL 8 / CentOS 8 Linux

Redmine est une application Web de gestion de projet open source populaire. Il prend en charge les principales bases de données comme MySQL et PostgreSQL en tant que backend, et vous pouvez également changer l'interface en Apache à partir du serveur Web WEBrick (recommandé pour une utilisation en production) livré avec l'installation. Dans cet article, nous installerons le dernier Redmine sur RHEL 8 / CentOS 8, en utilisant PostgreSQL comme backend, mais nous laisserons WEBrick par défaut comme frontend, ce qui servira parfaitement nos tests.

Ne vous attendez pas à ce que ce processus soit facile, ni sans erreur. Même en suivant ces étapes à la lettre, certaines erreurs se produiront sûrement, la configuration semble gérer sudo étapes quelque peu incohérentes - mais les solutions sont également incluses qui guideront à travers ces erreurs.

Dans ce didacticiel, vous apprendrez :

Comment installer les packages de système d'exploitation requis
Comment configurer la base de données
Comment installer l'application Redmine
Comment démarrer et se connecter à l'application

Page de configuration de Redmine sur RHEL 8.

Configuration logicielle requise et conventions utilisées

Configuration logicielle requise et conventions de ligne de commande Linux
Catégorie	Exigences, conventions ou version du logiciel utilisée
Système	RHEL 8/CentOS 8
Logiciel	Redmine 4.0.3, PostgreSQL 10.5
Autre	Accès privilégié à votre système Linux en tant que root ou via le `sudo` commande.
Conventions	# - nécessite que les commandes linux données soient exécutées avec les privilèges root soit directement en tant qu'utilisateur root, soit en utilisant `sudo` commande $ – nécessite que les commandes linux données soient exécutées en tant qu'utilisateur normal non privilégié

Comment installer redmine sur Redhat 8 instructions étape par étape

Redmine est une application Ruby. Pour l'installation, nous devrons utiliser rubygems et bundler , et compiler beaucoup de dépendances, cela prendra donc un certain temps. Nous utiliserons les référentiels Red Hat disponibles après avoir activé la gestion des abonnements pour résoudre les dépendances du système d'exploitation. Vous pouvez vous référer au guide d'installation de PostgreSQL sur RHEL8 pour la configuration détaillée de la base de données en général, dans cet article nous ne couvrirons que les étapes nécessaires pour Redmine. Si la configuration de la base de données est nouvelle, n'oubliez pas de compléter le initdb étape dans le guide mentionné, sinon le démarrage de la base de données échouera.

Nous allons créer un utilisateur qui sera le propriétaire de l'application, et nous lui donnerons temporairement sudo accéder. Nous pouvons révoquer cet accès une fois l'installation terminée.
```
# useradd redmine
```
Nous devons définir un mot de passe pour le nouvel utilisateur, que nous utiliserons lors de l'utilisation de sudo :
```
# passwd redmine
```
Sur les distributions basées sur RHEL, il y a une wheel groupe d'utilisateurs, qui est autorisé à utiliser sudo pour exécuter des commandes privilégiées. Pour vérifier que ce groupe est configuré en tant que sudoer , nous pouvons grep le /etc/sudoers fichier :
```
# grep "%wheel" /etc/sudoers
%wheel  ALL=(ALL)       ALL
# %wheel        ALL=(ALL)       NOPASSWD: ALL
```
La deuxième ligne avec l'option NOPASSWD est commentée, ce qui répondra à nos besoins. Avec la configuration ci-dessus en place, tout ce que nous avons à faire est d'ajouter le redmine utilisateur à la wheel groupe :
```
# usermod -a -G wheel redmine
```
Pour installer les packages fournis par le système d'exploitation, nous utiliserons dnf :
```
# dnf install kernel-devel kernel-headers gcc postgresql-devel ruby ruby-devel rubygems
```
Pour obtenir l'application, visitez le site de téléchargement officiel (qui fonctionne sur Redmine). De là, nous pouvons télécharger l'tarball compressé avec wget au système cible :
```
# wget https://www.redmine.org/releases/redmine-4.0.3.tar.gz -O /opt/redmine-4.0.3.tar.gz
```
Comme le suggère la commande ci-dessus, nous allons installer l'application sous le /opt annuaire. Nous allons basculer vers ce répertoire et extraire l'archive :
```
# cd /opt
# tar -xzf redmine-4.0.3.tar.gz
```
En option, nous pouvons également créer un symlink pour un accès plus facile - de cette façon, nous n'avons pas besoin de nous souvenir de la version exacte :
```
# ln -s /opt/redmine-4.0.3 /opt/redmine
```
Maintenant, nous pouvons définir le redmine utilisateur en tant que propriétaire de la hiérarchie de répertoires extraite, de manière récursive :
```
# chown -R redmine:redmine /opt/redmine*
```
Pour configurer la base de données pour la connexion de l'application, nous devons la démarrer si elle n'est pas déjà en cours d'exécution :
```
# systemctl start postgresql
```
Nous devrons créer une base de données vide dans laquelle l'application stockera ses données. Pour ce faire, nous allons passer au postgres utilisateur du système d'exploitation créé par défaut lors de l'installation de la base de données :
```
# su - postgres
```
Nous allons nous connecter à psql en tant que superutilisateur de la base de données :
```
$ psql
psql (10.5)
Type "help" for help.

postgres=#
```
Nous allons créer un rôle qui sera utilisé par l'application (notez le nom d'utilisateur et le mot de passe) :
```
postgres=# CREATE ROLE redmine LOGIN ENCRYPTED PASSWORD 'R3DM1N3' NOINHERIT VALID UNTIL 'infinity';
```
Nous créons également une nouvelle base de données avec le propriétaire créé ci-dessus :
```
postgres=# CREATE DATABASE rmdb WITH ENCODING='UTF8' OWNER=redmine;
```
Nous aurons besoin du nom d'utilisateur, du mot de passe, de l'encodage et du nom de la base de données lors d'une étape ultérieure.
Maintenant que l'utilisateur est configuré, nous devons autoriser sa connexion sur le serveur de base de données. L'utilisateur redmine se connectera localement, nous ajoutons donc la ligne suivante au pg_hba.conf fichier, situé par défaut dans /var/lib/pgsql/data par défaut sur les distributions basées sur RHEL :
```
host    rmdb        redmine             127.0.0.1/32          md5
```
Vérifiez votre fichier de configuration pour les éléments suivants :
```
# IPv4 local connections:
host    all             all             127.0.0.1/32            ident
```
Si vous avez une telle ligne, commentez-la, elle entrera en conflit avec la connexion que nous prévoyons de configurer.
Avec cela en place, nous devons redémarrer la base de données pour que les paramètres prennent effet :
```
# systemctl restart postgresql
```
Nous avons maintenant toutes les informations nécessaires pour dire à l'application où et comment trouvera-t-elle la base de données. Il existe un exemple de fichier de configuration de connexion à la base de données avec toutes les bases de données prises en charge dans le config sous-répertoire de l'archive extraite. Nous pouvons faire une copie de ce fichier (en utilisant le redmine utilisateur):
```
$ cp config/database.yml.example config/database.yml
```
Nous pouvons supprimer ou commenter tous les exemples de paramètres en plus de ceux liés à PostgreSQL, ou simplement créer un fichier vide avec la configuration nécessaire (moins de fichiers indésirables resteront dans le fichier de cette façon). A la fin, le /opt/redmine/config/database.yml doit contenir les éléments suivants :
```
# PostgreSQL configuration
production:
  adapter: postgresql
  database: rmdb
  host: 127.0.0.1
  username: redmine
  password: "R3DM1N3"
```
Notez que nous avons utilisé les informations de connexion à la base de données que nous avons configurées lors des deux dernières étapes.
Pour réduire le nombre de problèmes possibles, nous testerons que nous pouvons nous connecter au rmdb base de données avec les informations d'identification fournies dans le fichier de configuration. Il est plus facile de déboguer les problèmes de connexion avec l'ensemble d'outils PostgreSQL qu'avec n'importe quel autre :
```
$ psql -d rmdb -U redmine -W
Password for user redmine: 
psql (10.5)
Type "help" for help.

rmdb=>
```
C'est là que se termine la partie facile. Nous allons maintenant installer divers packages Ruby dont Redmine dépend. Certains d'entre eux ont besoin de root accès, certains s'installeront au nom de la redmine utilisateur, et plus tard certains auront probablement besoin d'une réparation. Sans blague. Tout d'abord, nous aurons besoin de bundler :
```
# gem install bundler
Fetching: bundler-2.0.1.gem (100%)
Successfully installed bundler-2.0.1
1 gem installed
```
Nous utiliserons bundler avec le redmine utilisateur, mais nous aurons également besoin de root pour installer ou réparer des Ruby gems , donc je suggère d'ouvrir un autre terminal, passez à redmine utilisateur, et accédez au /opt/redmine répertoire, tout en gardant la console racine ouverte.
Comme redmine utilisateur, nous commençons l'installation dans le /opt/redmine répertoire :
```
$ bundle install --without development test rmagick
```
De nombreuses dépendances seront installées, et pour certaines le programme d'installation demande le sudo mot de passe – qui est le mot de passe du redmine utilisateur. Il semble que cette fonctionnalité sudo soit en quelque sorte un peu cassée et puisse gérer certaines des installations de packages privilégiés root et ne puisse pas s'entendre avec les autres. Ceux qui échouent peuvent être installés sur la console racine, et le bundle ci-dessus La commande peut être exécutée à nouveau sur la console de l'utilisateur Redmine. Ce qui devait être installé dans mon cas avec root sont les suivants :
```
# gem install nokogiri -v '1.10.2' --source 'https://rubygems.org/'
# gem install pg -v '1.1.4' --source 'https://rubygems.org/'
```
Certains packages peuvent également se casser lors de l'installation. Ceux-ci peuvent également être réparés sur la console racine. Comme pour les étapes d'installation du package ayant échoué ci-dessus, la sortie du bundler La commande indiquera quel paquet a rencontré des problèmes et comment le résoudre. Dans mon cas, les packages suivants nécessitaient une réparation :
```
# gem pristine nio4r --version 2.3.1
# gem pristine redcarpet --version 3.4.0
# gem pristine websocket-driver --version 0.7.0
```
Veuillez noter que si vous installez une autre version de Redmine, les numéros de version des packages seront probablement différents. Après avoir réparé tous les packages cassés et manquants, le bundle La commande doit se terminer sans erreur, avec la fin suivante de la sortie :
```
[...]
Installing roadie-rails 1.3.0
Fetching rouge 3.3.0
Installing rouge 3.3.0
Bundle complete! 26 Gemfile dependencies, 57 gems now installed.
Gems in the groups development, test and rmagick were not installed.
Use `bundle info [gemname]` to see where a bundled gem is installed.
```
Une fois la partie délicate terminée, nous devons générer un jeton qui sera utilisé pour encoder les cookies de session :
```
$ bundle exec rake generate_secret_token
```

Ensuite, nous générons les objets de base de données nécessaires à l'application :

$ RAILS_ENV=production bundle exec rake db:migrate

Outre la création des objets de base de données nécessaires, cette étape générera beaucoup de sortie en enregistrant toutes les étapes sur la console. Nous verrons beaucoup d'entrées ressembler à ce qui suit :

[...]

== 20180913072918 AddVerifyPeerToAuthSources: migrating =======================
-- change_table(:auth_sources)
   -> 0.0082s
== 20180913072918 AddVerifyPeerToAuthSources: migrated (0.0083s) ==============

== 20180923082945 ChangeSqliteBooleansTo0And1: migrating ======================
== 20180923082945 ChangeSqliteBooleansTo0And1: migrated (0.0000s) =============

Ce processus devrait se terminer en quelques secondes.

Nous pouvons vérifier la base de données remplie avec psql :

rmdb=> \dt
                       List of relations
 Schema |                Name                 | Type  |  Owner  
--------+-------------------------------------+-------+---------
 public | ar_internal_metadata                | table | redmine
 public | attachments                         | table | redmine
 public | auth_sources                        | table | redmine
 public | boards                              | table | redmine
 public | changes                             | table | redmine
[...]

La dernière étape de l'installation consiste à charger les données par défaut dans la base de données. En fournissant le REDMINE_LANG paramètre nous pouvons nous épargner de toute question lors du chargement initial.
```
$ RAILS_ENV=production REDMINE_LANG=en bundle exec rake redmine:load_default_data
Default configuration data loaded.
```

L'installation est terminée. Nous pouvons démarrer l'application :

$ bundle exec rails server webrick -e production
=> Booting WEBrick
=> Rails 5.2.2.1 application starting in production on http://0.0.0.0:3000
=> Run `rails server -h` for more startup options
[2019-04-14 18:39:12] INFO  WEBrick 1.4.2
[2019-04-14 18:39:12] INFO  ruby 2.5.1 (2018-03-29) [x86_64-linux]
[2019-04-14 18:39:12] INFO  WEBrick::HTTPServer#start: pid=30062 port=3000

L'application est maintenant en cours d'exécution et est accessible avec un navigateur. D'après la sortie ci-dessus, nous pouvons deviner qu'il est accessible sur le port 3000 , donc si nous avons un pare-feu en cours d'exécution sur la machine cible, nous devons ouvrir ce port pour accéder au service à distance :
```
# firewall-cmd --zone=public --add-port=3000/tcp --permanent
# firewall-cmd --reload
```
En ouvrant un navigateur et en le pointant vers l'adresse et le port 3000 de la machine (http://192.168.1.14:3000 sur la capture d'écran ci-dessous), nous pouvons accéder à l'interface Web de notre nouvelle installation Redmine.
Page de connexion de Redmine.
Les identifiants par défaut sont admin pour le nom d'utilisateur, et aussi pour le mot de passe. Lors de la première connexion, l'application qui se comporte bien demandera un changement de mot de passe pour ce compte privilégié. À partir de là, il nous appartient de remplir, de configurer et d'apprécier le service.
Une fois l'installation terminée, nous pouvons supprimer le redmine utilisateur de la wheel groupe, éliminant le trou de sécurité nécessaire pendant le processus :
```
# gpasswd -d redmine wheel
Removing user redmine from group wheel
# id redmine
uid=1008(redmine) gid=1008(redmine) groups=1008(redmine)
```