Installer Redmine sur Debian

De Analyse Développement Hacking
Sauter à la navigation Sauter à la recherche
Consulter le wiki : Accueil du wiki - Objectifs - Administrateur - Bureautique - Développeur - Intégrateur - Marketing - Multimédia - Objets numériques - Jeux - We make Hack
Consulter le site : Accueil du site - Annuaire - Blog - Forum - Outils - Utilisateur     Consulter le Redmine : Accueil du Redmine

Sommaire

Installer Redmine sur Debian

Présentation de redmine

Redmine est une application extensible bien bien plus aboutie que certaines applications commerciales.
Redmine est l'une des solutions recommandée pour la gestion des projets en ligne.
Ce logiciel Open Source est développé en ruby grâce au framework ruby on rails.
Un serveur web est requis pour pouvoir l'installer.
Redmine semble proposer deux versions stables, dernière mise à jour officielle le 10 juin 2018.
3.4.6 (2018-06-10)
3.3.8 (2018-06-10)

Fonctionnalités de redmine

Multi-projets : Plusieurs projets peuvent être créés en parallèle et gérés de façon indépendante.
Support de plusieurs bases de données MySQL, PostgreSQL ou SQLite.
Gestion fine des droits utilisateurs à l'aide de rôles aux droits spécifiques organisés par l'administrateur.
Graphique de Gantt et rapports personnalisés permettent de visualiser l'avancement des projets.
Historique des modifications, gestion documentaire et gestion de fichiers de suivi de projet.
Flux d'informations et notifications par mail.
Forum de discussion pour communiquer.
Gestion des savoirs via un wiki.
Suivi du temps et des activités.
Personnalisation des champs des demandes, des projets et des utilisateurs.
Technologies de suivis de versions, SVN, CVS, Git, Mercurial, Bazaar et Darcs.
Authentifications LDAP multiples.

Qui utilise Redmine

Ok.png Qui utilise Redmine ? http://www.redmine.org/projects/redmine/wiki/WeAreUsingRedmine

Note a consulter pour installer Redmine correctement - Utiliser RVM pour installer Redmine

Le tutoriel présenté sur cette page est cohérent et relativement complet pour installer Redmine sur une version stable de Debian.
Je rencontre tout de même des difficultés avec certains droits qui ne semblent pas rester, et, je n'arrive pas ( pas encore ) à installer de plugin.
Vous pouvez tester le tutoriel de cette page qui vous apprendra déjà beaucoup sur Redmine et son installation. 
Vous pouvez compléter ce tutoriel et le corriger, depuis l'onglet Discussion.
A tester :
Il est par exemple sûrement conseillé de créer l'utilisateur redmine de la même façon qu'il a été créé sur le tutoriel Installer Redmine sur Debian avec RVM.
Cela pourrait peut être éviter certains problèmes de droits en écriture lors de l'installation des plugins.
De préférence, utiliser le nouveau tutoriel pour Installer Redmine sur Debian avec RVM semble plus adapté et plus cohérent.
Des paquets Debian ne sont pas toujours disponibles lorsque de nouvelles mises à jour de Redmine sont disponibles, quand on administre une Debian testing ou instable.
RVM permet d'utiliser différentes versions de ruby et de profiter de toutes les gems sans devoir attendre la mise à disposition des paquets par Debian.
Pour ne pas être limité par les paquets de Debian, RVM semble donc être une bonne alternative pour installer et maintenir Redmine.
Installer Redmine sur Debian avec RVM.

Installer Redmine sur GNU/Linux

Testé sur Linux Mint 18.3 "Sylvia" - Xfce 64-bit
Testé sur Linux Mint 19 "Tara" - Xfce 64-bit
Testé sur Debian GNU/Linux 9.5 "Stretch" 32-bit et 64-bit avec le dépôt de paquets stables.
Testé sur Debian SID pour installer la dernière version de Redmine.

Installer et configurer le serveur web

$ sudo apt-get install apache2 libapache2-mod-passenger

Installer une base de données

Installer la base de données MariaDB :
$ sudo apt install mariadb-server mariadb-client
## Sinon, installer Mysql : sudo apt install mysql-server mysql-client
## Sinon, installer Postgresql : sudo apt install postgresql

Définir le mot de passe d'administration de la base de données

Le processus d'installation de MySQL devrait demander de définir un mot de passe pour l'accès "root" du serveur de base de données.
Sinon, lancer la procédure pour sécuriser MySQL et redéfinir le mot de passe root avec la commande mysql_secure_installation.

Installer Redmine

Rendre Apache2 propriétaire du dossier /var/www/ avant d'installer Redmine permet de ne pas avoir le message d'erreur suivant lors de l'installation :
`/var/www` is not writable. Bundler will use `/tmp/bundler/home/www-data' as your home directory temporarily.

# Le propriétaire et le groupe du dossier /var/www devient www-data.
sudo chown -R www-data:www-data /var/www
## Si nécessaire, ajouter le droit 755 en écriture avec la commande sudo chmod 755 -R /var/www
## Obtenir les noms des paquets disponibles pour Redmine : sudo apt-cache pkgnames | grep redmine
## Obtenir la description des paquets disponibles pour Redmine : sudo apt-cache search redmine

## bugwarrior - récupérer des tickets depuis des outils de suivi de bogues vers taskwarrior
## hashcat - World's fastest and most advanced password recovery utility
## python-redmine - Python library for the Redmine RESTful API (Python 2)
## python3-redmine - Python library for the Redmine RESTful API (Python 3)
## redmine - flexible project management web application
## redmine-mysql - metapackage providing MySQL dependencies for Redmine
## redmine-pgsql - metapackage providing PostgreSQL dependencies for Redmine
## redmine-sqlite - metapackage providing sqlite dependencies for Redmine
## redmine-plugin-custom-css - Redmine plugin to add custom CSS editable through web interface
## redmine-plugin-local-avatars - Redmine plugin to add local avatar support
## redmine-plugin-pretend - Redmine plugin to allow admins to log-in as users
# Lancer l'installation de Redmine et du paquet Redmine adapté à la base de données installée.
$ sudo apt-get install redmine redmine-mysql
Autoriser dbconfig-common à configurer la base de données lorsque vous y êtes invité, sélectionnez Oui dans l'invite du panneau ci-dessous.
L'installation est automatique pour la création de la base de données.
Uniquement si le programme d'installation le demande :
Indiquer au programme d'installation de Redmine que nous utilisons MySQL pour cette installation en mettant en évidence "mysql" dans la liste des choix de base de données.
Définir le mot de passe de l'utilisateur "redmine/instances" pour la base de données "redmine_default".
Ce n'est pas le même mot de passe que celui définit pour l'utilisateur root de la base de données.
Le programme d'installation de Redmine se termine avec succès.

Installer le paquet bundler

Redmine utilise Bundler pour gérer les dépendances gems.
$ sudo apt-get install bundler

Ajouter une ligne dans le fichier passenger.conf

$ sudo nano /etc/apache2/mods-available/passenger.conf
<IfModule mod_passenger.c>
 PassengerRoot /usr/lib/ruby/vendor_ruby/phusion_passenger/locations.ini
 PassengerDefaultRuby /usr/bin/ruby
</IfModule>
# Ajouter la ligne : PassengerDefaultUser www-data
<IfModule mod_passenger.c>
 PassengerDefaultUser www-data
# Par la suite, quand l'utilisateur et le groupe redmine seront créés, remplacer www-data par redmine.
<IfModule mod_passenger.c>
 PassengerDefaultUser redmine

Créer un lien symbolique pour connecter Redmine dans l'espace de document Web

Emplacement de Redmine sur la machine : /usr/share/redmine/public/
Emplacement de Redmine sur le serveur : /var/www/html/redmine
$ sudo ln -s /usr/share/redmine/public /var/www/html/redmine

Modifier la configuration du Vhost de Apache2

# Se placer dans le dossier de configuration des sites de Apache2.
cd /etc/apache2/sites-available/
# Ouvrir le fichier 000-default.conf créé et utilisé par défaut.
sudo nano 000-default.conf
# Configuration par défaut :
<VirtualHost *:80>
ServerAdmin mail@visionduweb.com
DocumentRoot /var/www/html
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
# Les configurations ci-dessous sont a imbriquer dans les balises <VirtualHost *:80> et </VirtualHost>.
# Ajouter les directives suivantes pour Redmine depuis le fichier de configuration.
<Directory /var/www/html/redmine>
RailsBaseURI /redmine
PassengerResolveSymlinksInDocumentRoot on
</Directory>
# La ligne <Location /redmine> indique le répertoire du site par rapport au documentroot /var/www/html défini dans Apache2.
# La ligne RackBaseURI /redmine indique l’url finale. Par exemple : http://localhost/redmine.
# Redmine semble fonctionner avec ou sans cet ajout dans la configuration du VirtualHost.
<Location /redmine>
RailsEnv production
RackBaseURI /redmine
Options -MultiViews
</Location>
# Relancer Apache2 pour appliquer la nouvelle configuration.
sudo /etc/init.d/apache2 restart
Consulter la configuration des fichiers VirtualHosts mis en place en production.

Créer un fichier Gemfile.lock

$ sudo touch /usr/share/redmine/Gemfile.lock
# Autoriser l'utilisateur de Apache2 a accéder à Gemfile.lock
$ sudo chown www-data:www-data /usr/share/redmine/Gemfile.lock
# Par la suite, une fois l'utilisateur redmine et le groupe redmine créé, on pourra sûrement donner ce fichier à redmine:redmine
# $ sudo chown redmine:redmine /usr/share/redmine/Gemfile.lock
## Facultatif ?
# Relancer Apache2 pour appliquer la nouvelle configuration.
sudo /etc/init.d/apache2 restart

Accéder à Redmine

$ firefox http://127.0.0.1/redmine
$ firefox http://localhost/redmine
Utilisateur par défaut : admin / admin

Créer des utilisateurs spécifiques pour utiliser Redmine

Créer un utilisateur MySQL aux droits restreints

Pour des raisons de sécurité, il est préférable de créer un utilisateur spécifique à Redmine pour utiliser la base de données.
# Durant l'installation, Redmine a déjà créé un utilisateur qui possède tous les droits.
# L'équivalent de la commande suivante a été effectuée de façon automatique.
sudo mysql -p
CREATE DATABASE redmine_default CHARACTER SET utf8;
CREATE USER 'redmine/instances'@'localhost' IDENTIFIED BY '';
GRANT ALL PRIVILEGES ON redmine_default.* TO 'redmine/instances'@'localhost';
# Optimiser la sécurité de la base de données en créant un utilisateur MySQL avec des droits restreints pour la connexion à la base de données de Redmine.
sudo mysql -p
Saisir de mot de passe de l'utilisateur root ou de l'utilisateur créé par Redmine.
# Créer un utilisateur aux droits restreints pour la base de données redmine_default
# CREATE USER 'Gestionnaire'@'localhost' IDENTIFIED BY PASSWORD 'Mot_de_passe'; # PASSWORD permet d'ajouter le hash du mot de passe pour ne pas le laisser en clair.
CREATE USER 'Gestionnaire'@'localhost' IDENTIFIED BY 'Mot_de_passe';
GRANT CREATE, SELECT, UPDATE ON redmine_default.* TO 'Gestionnaire'@'localhost';
EXIT;
# Il faudrait sûrement créer un utilisateur ayant tous les droits sur MySQL pour pouvoir alors interdire l'utilisation de l'utilisateur root, voir, de le supprimer (?).
### A ajouter ! ! !
### Active l'utilisation de LOCK TABLES sur les tables pour lesquelles vous avez le privilège SELECT
### Pour conserver l'intégrité, l'utilisateur doit avoir le droit SELECT et LOCK TABLES sur toutes les tables, dès lors, il verrouille le tout lors du SELECT, ce qui permet un dump qui sera complet.
### GRANT LOCK TABLES ON redmine_default.* TO Gestionnaire@localhost;
Retour sur les erreurs rencontrées avec l'utilisateur aux droits restreints et la base de données de Redmine.
# Récapitulatif de la commande complète pour créer l'utilisateur MySQL aux droits restreints :
sudo mysql -p
CREATE USER 'Gestionnaire'@'localhost' IDENTIFIED BY 'Mot_de_passe';
GRANT CREATE, INSERT, SELECT, UPDATE ON redmine_default.* TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.tokens TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.issue_relations TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.member_roles TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.members TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.workflows TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.custom_values TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.journal_details TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.journals TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.time_entries TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.watchers TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.changesets_issues TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.issues TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.enabled_modules TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.queries TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.issue_categories TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.wiki_redirects TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.wikis TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.custom_fields_projects TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.projects_trackers TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.projects TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.attachments TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.documents TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.comments TO 'Gestionnaire'@'localhost';
GRANT INDEX ON redmine_default.workflows TO 'Gestionnaire'@'localhost';
GRANT INDEX ON redmine_default.member_roles TO 'Gestionnaire'@'localhost';
GRANT INDEX ON redmine_default.changesets_issues TO 'Gestionnaire'@'localhost';
GRANT INDEX ON redmine_default.issues TO 'Gestionnaire'@'localhost';
GRANT ALTER ON redmine_default.issues TO 'Gestionnaire'@'localhost';
GRANT ALTER ON redmine_default.journal_details TO 'Gestionnaire'@'localhost';
GRANT ALTER ON redmine_default.journals TO 'Gestionnaire'@'localhost';
GRANT ALTER, INDEX ON redmine_default.attachments TO 'Gestionnaire'@'localhost';
GRANT ALTER ON redmine_default.projects TO 'Gestionnaire'@'localhost';
GRANT ALTER ON redmine_default.repositories TO 'Gestionnaire'@'localhost';
GRANT ALTER ON redmine_default.comments TO 'Gestionnaire'@'localhost';
GRANT ALTER ON redmine_default.auth_sources TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.wiki_content_versions TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.wiki_contents TO 'Gestionnaire'@'localhost';
GRANT DELETE ON redmine_default.wiki_pages TO 'Gestionnaire'@'localhost';
Exit;

Changer la configuration de Redmine pour l'accès à la base de données

Remplacer l'utilisateur MySQL par défaut de redmine par l'utilisateur Gestionnaire aux droits restreints créé précédemment.
cd /etc/redmine/default
sudo nano database.yml
production:
adapter: mysql2
database: redmine_default                                                # La base de données peut éventuellement être renommée.
host: localhost
port: 
username: Utilisateur_aux_droits_restreints_pour_la_base_de_données      # username: Utilisateur MySQL aux droits restreints.
password: Mot_de_passe_utilisateur_de_la_base_de_données                 # password: Le mot de passe de l'utilisateur MySQL aux droits restreints.
encoding: utf8
Ctrl + X pour sauvegarder le fichier de configuration qui permet la connexion à la base de données MySQL de Redmine.
Vérifier que l'utilisateur MySQL aux droits restreint se connecte à la bonne base de données qui est redmine_default.
Tester différentes actions une fois connecté à Redmine pour vérifier le bon fonctionnement de l'application avec le nouvel utilisateur de la base de données et ses limitations de droits.

Créer un utilisateur Linux nommé redmine et l'ajouter au groupe www-data

Droits du dossier /usr/share/redmine par défaut

Initialement le dossier /usr/share/redmine appartient à l'utilisateur et au groupe root.
cd /usr/share/
sudo chown -R root:root redmine

Droits du dossier /usr/share/redmine modifiés pour l'utilisateur et le groupe www-data

# Il est préférable d'optimiser la sécurité du service en utilisant l'utilisateur spécifique de Apache2.
Changer le propriétaire et le groupe du dossier /usr/share/redmine par www-data.
cd /usr/share/
sudo chown -R www-data:www-data redmine

Droits du dossier /usr/share/redmine modifiés pour l'utilisateur redmine et le groupe redmine

# Il est préférable d'optimiser d'avantage la sécurité du service avec un utilisateur spécifique nommé redmine pouvant utiliser Apache2.
# Créer le groupe et l'utilisateur system redmine.
sudo addgroup redmine
sudo adduser --system --no-create-home --ingroup www-data --disabled-password redmine
# Avant tout, on modifie les informations précédentes expliquées dans ce tutoriel qui ont été mises en place pour www-data:www-data.
sudo nano /etc/apache2/mods-available/passenger.conf
Remplacer www-data par redmine.

Changer le propriétaire et le groupe sur le fichier Gemfile.lock.
chown redmine:redmine /usr/share/redmine/Gemfile.lock
# Appliquer les changements de propriétaire et de groupe sur le dossier redmine.
# Ajouter le / à redmine/ permet de bien appliquer la commande de façon récursive.
cd /usr/share/
sudo chown -R redmine:redmine redmine/
## Normalement, tous les sous dossiers de /usr/share/redmine/ appartiennent maintenant à redmine:redmine. 
## Changer les droits du dossier public/plugin_assets/ et le rendre accessible en écriture.
## J'ai commenté les étapes suivantes qui semblent correctes par défaut lors de la dernière installation sous GNU/Linux Debian 9.5 64 bit.
# cd /usr/share/redmine
# sudo chown -R redmine:redmine public/plugin_assets/
# sudo chmod -R 755 public/plugin_assets/
# cd /var/cache/redmine/default
# sudo chown -R redmine:redmine plugin_assets/
# sudo chmod -R 755 plugin_assets/
## Changer les droits du dossier files/ et le rendre accessible en écriture.
# cd /var/lib/redmine/default/
# sudo chown -R redmine:redmine files/
# sudo chmod -R 755 files/
# Changer les droits des dossiers log, tmp et les rendre accessibles en écriture dans le dossier /usr/share/redmine et /usr/share/redmine/instances/default/
### Lors de la nouvelle installation sous GNU/Linux Mint, le dossier log et tmp se trouve dans /usr/share/redmine/instances/default/ uniquement.
### Cela est sûrement du au fait que le répertoire www n'avait pas initialement les droits correct lors de l'installation de Redmine ?
# cd /usr/share/redmine
# sudo chown -R redmine:redmine log/ tmp/
# sudo chmod -R 755 log/ tmp/
# Le dossier default et ses enfants sont restés avec le propriétaire et le groupe root:root.
# Appliquer redmine:redmine au dossier et ses enfants.
cd /usr/share/redmine/instances
sudo chown -R redmine:redmine default/
# et
# cd /usr/share/redmine/instances/default/
# sudo chown -R redmine:redmine log/ tmp/
# sudo chmod -R 755 log/ tmp/
# En cas d'erreur de droits sur le fichier de logs de Redmine, le message d'erreur dans les logs propose d'utiliser cette commande pour donner les bons droits au fichier de logs.
sudo chmod 0664 /usr/share/redmine/instances/default/log/production.log
# Changer les droits du dossier var/log/redmine/default pour redmine:redmine
cd /var/log/redmine
sudo chown -R redmine:redmine default/
# Redémarrer Apache2 pour prendre en compte les changements et permettre l'écriture des logs.
sudo /etc/init.d/apache2 restart
# Consulter les logs.
cd /var/log/redmine/default/
cat production.log
Retour sur l'utilisateur Redmine qui a été créé et placé dans le groupe www-data
# Il aurait peut être du être placé dans le groupe redmine, mais alors, comment faire pour que le groupe redmine puisse utiliser Apache2 ?
# Comment font t'ils sur d'autres tutoriels pour créer l'utilisateur redmine dans le groupe redmine.
# Cette proposition semble correspondre mais n'a pas été testée !
Apache Httpd tourne sous l'identité www-data
Redmine tourne sous l'identité redmine, le module Phusion Passenger fait le lien entre Redmine et Apache.
Pour que cela fonctionne, on ajoute les directives suivantes dans le fichier de configuration du VirtualHost d'Apache Httpd :
PassengerUserSwitching on
PassengerUser  redmine
PassengerGroup redmine
Cette configuration doit être bien placée dans le VHost, pour réduire la portée de l'utilisateur et du groupe redmine.
Ok-ko.png Forge Redmine sur Debian Jessie - Configurer l'hôte virtuel de Apache2 : https://wiki.dinot.net/admin:redmine

Vérifier que les informations nécessaires à Redmine soient au vert

Se connecter à Redmine depuis le navigateur avec l'adresse localhost et le login admin ainsi que le mot de passe admin.
Aller sur la page Administrations, Informations, de Redmine.
Normalement, les répertoires doivent être au vert.
Sinon, appliquer les modifications suivantes.
# Le "Répertoire de stockage des fichiers accessible en écriture" n'est pas au vert.
# Le répertoire de stockage est situé dans le dossier : /var/lib/redmine/default/
# Les droits de l'utilisateur et du groupe, par défaut à www-data:www-data, sont a remplacer par redmine:redmine.
# Le répertoire files sera immédiatement reconnu comme étant accessible en écriture.
# Les commandes précédentes semblent parfaitement fonctionner lors de la dernière installation. Cette étape ne devrait plus être nécessaire.
cd /var/lib/redmine/default/
sudo chown -R redmine:redmine files/
# sudo chmod -R 755 files/
# Le Répertoire public des plugins accessible en écriture n'est pas au vert.
# Pourtant, à la première connexion, l'affichage était au vert.
# Soit un nouveau cache est généré, soit, il faudrait appliquer les droits lors de l'installation pour ne pas avoir à revenir à cette étape.
cd /var/cache/
sudo chown -R redmine:redmine redmine/
# sudo chmod -R 755 plugin_assets/
# Si il manque le Binaire convert de ImageMagick dans les informations, installer imagemagick.
# Cette étape est nécessaire sur Debian si le paquet n'a jamais été installé.
sudo apt-get install imagemagick
# Tester que l'accès à la configuration de Redmine soit bien disponible depuis l'interface administrateur de Redmine.
Si la page ne s'affiche pas et fait apparaître une erreur, consulter les logs de Redmine.
J’ai rencontré l’erreur suivante :
ActionView::Template::Error (Permission denied @ dir_s_mkdir - /usr/share/redmine/instances/default/tmp/cache):
# Créer alors le dossier cache et lui donner les bons droits :
sudo mkdir /usr/share/redmine/instances/default/tmp/cache
cd /usr/share/redmine/instances/default/tmp
sudo chown -R redmine:redmine cache/
sudo chmod -R 755 cache/
# L'accès à la configuration est maintenant fonctionnelle.

Configurer les paramètres du mail

Depuis le lien : http://localhost/redmine/settings?tab=notifications voir le lien configuration et l'onglet Notifications par mail.
Il n’y a pas de configuration de mail par défaut.
L'envoi de mail n'est pas configuré, les notifications sont désactivées.
Utiliser le fichier de configuration depuis config/email.yml pour configurer les paramètres d’envoi de mails est déprécié.
Configurer le serveur SMTP dans /etc/redmine/<instance>/configuration.yml puis redémarrer l'application pour valider les changements de configuration.
# Créer un fichier de configuration /etc/redmine/default/configuration.yml
cd /etc/redmine/default
sudo touch configuration.yml
sudo nano configuration.yml
# Ajouter les paramètres de configuration SMTP pour envoyer des mails depuis Redmine.
production:
 delivery_method: :smtp
 smtp_settings:
   address: smtp.visionduweb.com
   port: 587
   domain: visionduweb.com
   authentication: :login
   user_name: mail@visionduweb.com
   password: mot_de_passe_du_compte_mail
   openssl_verify_mode: 'none'
# Après chaque modification, redémarrer Apache2 pour appliquer les changements.
sudo /etc/init.d/apache2 restart
Depuis le lien : http://localhost/redmine/settings?tab=notifications voir le lien configuration et l'onglet Notifications par mail.
Modifier les informations à utiliser pour envoyer les mails.
Tester l'envoie d'un mail :
Erreur lors de l'envoi de l'email avec authentication: :login sur le port 25 : (No route to host - connect(2) for "smtp.visionduweb.com" port 25)
Changer le port 25 pour le port 587 et ajouter la ligne openssl_verify_mode: 'none'.
Les mails peuvent alors être envoyés depuis Redmine.

Utiliser TLS pour chiffrer les mails envoyés

cd /etc/redmine/default/
sudo nano configuration.yml
En ajoutant la ligne enable_starttls_auto: true, toujours sur le port 587 et sans oublier la ligne openssl_verify_mode: 'none', les mails envoyés sont chiffrés avec TLS.
On peut utiliser tcpflow pour sniffer les données qui transitent sur le port 587 lors de l'envoie du mail de test pour vérifier que le mail est bien chiffré avec TLS.
tcpflow -i any -C -g port 587
Les deux lignes suivantes font partie d'une recherche qui semble obsolète aujourd'hui.
Utiliser un plugin pour chiffrer en TLS pour utiliser le SMTP de Gmail ne semble plus nécessaire.
Obsolète : Redmine - Plugin pour chiffrer en TLS.

Mails délivrés par Nerim

production:
 delivery_method: :smtp
 smtp_settings:
   enable_starttls_auto: true
   address: smtp.visionduweb.com
   port: 587
   domain: visionduweb.com
   authentication: :login
   user_name: mail@visionduweb.com
   password: Mot_de_passe_du_compte_mail
   openssl_verify_mode: 'none'

Mails délivrés par GMX

production:
 delivery_method: :smtp
 smtp_settings:
   enable_starttls_auto: true
   address: mail.gmx.com
   port: 587
   domain: mail.gmx.com
   authentication: :login
   user_name: le-mail@gmx.fr
   password: mot-de-passe
   openssl_verify_mode: 'none'

Mails délivrés par OVH

production:
 delivery_method: :smtp
 smtp_settings:
   enable_starttls_auto: true
   address: ns0.ovh.net ou utiliser de préférence ssl0.ovh.net
   port: 587
   domain: green-nrj.com
   authentication: :login
   user_name: le-mail@green-nrj.com
   password: mot-de-passe
   openssl_verify_mode: 'none'

Mails délivrés par sendmail

production:
 delivery_method: :sendmail

Consulter les logs

Consulter les logs pour identifier les éventuelles erreurs de Redmine.
cd /var/log/redmine/default/
ls
production.log

Onglet Administration de Redmine

Cliquer sur le lien Administration en haut à gauche de l'interface web de Redmine pour paramétrer votre Redmine : domaine/redmine/admin

Utilisateurs

L'administrateur se connecte par défaut avec le login admin et le mot de passe admin.
Se connecter à Redmine en tant qu'administrateur pour changer le login et le mot de passe.
Cliquer sur le lien Utilisateurs pour modifier les informations de l'administrateur : domaine/redmine/users
- Modifier le pseudo / login.
- Modifier le nom et le prénom.
- Modifier le mail.
- Modifier le mot de passe.

Trackers

# Cliquer sur Nouveau tracker pour ajouter un tracker.
# "Aucun workflow n'est défini pour ce tracker" va être affiché. Modifier.
# Aller dans Workflow et éditer : Rôle:Manager Tracker:Documentation (Cliquer sur modifier) N'afficher que les statuts utilisés dans ce tracker
# Pour le rôle Manager et le tracker Documentation, je coche toutes les cases. Depuis le menu tracker, l'alerte "Aucun workflow n'est défini pour ce tracker" ne sera plus affichée.

Informations

Cliquer sur le lien Informations : domaine/redmine/admin/info

Version installée sur Linux Mint 19

Trouver la version de Redmine : apt-cache policy redmine
La version de Redmine installée sur une GNU/Linux Mint 19 Tara xfce 64bit :
Redmine 3.4.4.stable
Compte administrateur par défaut changé 	
Répertoire de stockage des fichiers accessible en écriture 	
Répertoire public des plugins accessible en écriture (./public/plugin_assets) 	
Bibliothèque RMagick présente (optionnelle) 	
Binaire convert de ImageMagick présent (optionel) 	
Environment:
 Redmine version                3.4.4.stable
 Ruby version                   2.5.1-p57 (2018-03-29) [x86_64-linux-gnu]
 Rails version                  4.2.10
 Environment                    production
 Database adapter               Mysql2
SCM:
 Filesystem                     
Redmine plugins:
 no plugin installed

Version installée sur Linux Debian Stretch 9.5 stable

Les paquets officiels Redmine sont disponibles pour Debian.
Depuis juillet 2018, la version stable 3.3.1 est prise en charge dans Debian 9.
Pour utiliser Redmine dans un environnement de production nécessitant une stabilité à long terme, utiliser les paquets officiels.
La version de Redmine installée sur une GNU/Linux Debian Stretch 9.5 serveur 64bit stable :
Redmine 3.3.1.stable
Compte administrateur par défaut changé 	
Répertoire de stockage des fichiers accessible en écriture 	
Répertoire public des plugins accessible en écriture (./public/plugin_assets) 	
Bibliothèque RMagick présente (optionnelle) 	
Binaire convert de ImageMagick présent (optionel) 	
Environment:
 Redmine version                3.3.1.stable
 Ruby version                   2.3.3-p222 (2016-11-21) [x86_64-linux-gnu]
 Rails version                  4.2.7.1
 Environment                    production
 Database adapter               Mysql2
SCM:
 Filesystem                     
Redmine plugins:
 no plugin installed

Version installée sur Linux Debian Stretch 9.5 SID

La version stable 3.4.6 est prise en charge dans Debian 9.5 SID.
Pour utiliser Redmine dans un environnement de production nécessitant une stabilité à long terme, utiliser les paquets officiels.
La version de Redmine installée sur une GNU/Linux Debian Stretch 9.5 serveur 64bit SID :
Redmine 3.4.6.stable
Compte administrateur par défaut changé
Répertoire de stockage des fichiers accessible en écriture
Répertoire public des plugins accessible en écriture (./public/plugin_assets)
Bibliothèque RMagick présente (optionnelle)
Binaire convert de ImageMagick présent (optionel)
Environment:
 Redmine version                3.4.6.stable
 Ruby version                   2.5.1-p57 (2018-03-29) [x86_64-linux-gnu]
 Rails version                  4.2.10
 Environment                    production
 Database adapter               Mysql2
SCM:
 Filesystem                     
Redmine plugins:
 no plugin installed

Connaître sa version de rails installée sur le serveur

rails -v
# Affiche la version 4.2.7.1 sur Debian Stretch 9.5 :
Rails 4.2.7.1

Configuration

Changer le favicon de Redmine

Le favicon.ico de Redmine se trouve dans le dossier public.
Changer le favicon.ico et il sera immédiatement pris en compte par Redmine.

Changer le logo de Redmine

Le logo de Redmine se trouve dans le dossier du themes utilisé.
/opt/redmine/redmine-4.0-stable-prod-vdw/public/themes/circle/images/
file logo.png
logo.png: PNG image data, 38 x 40, 8-bit/color RGBA, non-interlaced

Patcher la CSS principale

# Une fois le premier projet créé avec un sous projet par exemple, l'affichage du tableau est divisé sur 4 colonnes ce qui donne un vieux rendu non responsive à Redmine.
# Ajouter display: inline-flex; vers la ligne 598 dans le fichier application.css par défaut.
cd /opt/redmine/redmine-4.0-stable-prod-vdw/public/stylesheets
sudo nano application.css
#projects-index {
  column-count: auto;
  column-width: 400px;
  -webkit-column-count: auto;
  -webkit-column-width: 400px;
  -webkit-column-gap : 0.5rem;
  -moz-column-count: auto;
  -moz-column-width: 400px;
  -moz-column-gap : 0.5rem;
/* Ne pas diviser les blocs des projets pour un affichage plus agréable. */
display: inline-flex;
}

Changer de thème ou ajouter un nouveau thème

Depuis le lien d'administration, aller sur configuration, affichage, puis, choisir parmi un thème disponible.
Utiliser le lien direct domaine/redmine/settings?tab=display
Choisir un nouveau thème a installer pour Redmine.
Liste de thèmes pour Redmine : https://www.redmine.org/projects/redmine/wiki/Theme_List

Installer le thème Redmine Flatly light sur le serveur

Page Github officielle de Flatly light : https://github.com/Nitrino/flatly_light_redmine
# Décompresser le thème dans votre répertoire de thèmes Redmine.
cd /usr/share/redmine/public/themes/
sudo wget https://github.com/Nitrino/flatly_light_redmine/archive/master.zip
sudo unzip master.zip
sudo rm master.zip
# Renommer le dossier.
sudo mv flatly_light_redmine-master/ Flatly_Light_Redmine/
# Changer les droits pour redmine:redmine
sudo chown -R redmine:redmine Flatly_Light_Redmine/
# Redémarrer Redmine pour rendre le nouveau thème installé disponible dans votre liste de thèmes.
sudo /etc/init.d/apache2 restart
Sélectionner le thème dans la liste déroulante "Thème" depuis "Administration / Configuration / Affichage".
Enregistrer les modifications pour afficher le thème.
Noter que ce thème comprend tout de même quelques bogues.
Impossible de sauvegarder une annonce pour la modifier.
La recherche par mot clé est affichée en anglais.

Circle

Ajouter son mail depuis le site officiel pour recevoir un lien de téléchargement : https://www.redmineup.com/pages/themes/circle
cd /opt/redmine/redmine-4.0-stable-prod-vdw/public/themes
sudo wget https://www.redmineup.com/license_manager/40766?token=1a55bb1224f0f20e4b404af0a6661f7c4c824
sudo unzip 40766\?token\=1a55bb1224f0f20e4b404af0a6661f7c4c824
sudo rm 40766\?token\=1a55bb1224f0f20e4b404af0a6661f7c4c824 
sudo chown -R redmine:redmine circle/

PurpleMine2

# Adresse Github du thème PurpleMine2 : https://github.com/mrliptontea/PurpleMine2
cd /opt/redmine/redmine-4.0-stable-prod-mdp/public/themes
sudo wget https://codeload.github.com/mrliptontea/PurpleMine2/zip/master
sudo unzip master
sudo rm master
sudo mv PurpleMine2-master/ PurpleMine2/
sudo chown -R redmine:redmine PurpleMine2/
# Changer la première couleur du bandeau si nécessaire.
cd /opt/redmine/redmine-4.0-stable/public/themes/PurpleMine2/stylesheets
sudo nano application.css
# CTRL w pour chercher #top-menu{
# Remplacer avec la couleur adaptée.
# Changer la deuxième couleur du bandeau.
cd /opt/redmine/redmine-4.0-stable/public/themes/PurpleMine2/stylesheets
sudo nano application.css
# CTRL w pour chercher #header{position:relative;background-color
# Remplacer avec la couleur adaptée.

Dwarf

https://github.com/themondays/Dwarf

A1

https://www.redmineup.com/pages/themes/a1

Ajouter un dépôt

Dépôts pouvant être ajoutés :
Subversion
CVS
Mercurial
Bazaar
Darcs
Git
Ko.png Ajouter un dépôt : https://www.redmine.org/projects/redmine/wiki/FrRedmineRepository

Ajouter un plugin

Ok.png Liste de plugins pour Redmine : https://www.redmine.org/plugins?page=1
Pour installer un plugin Redmine, aller dans le répertoire /opt/redmine/plugins ( ou équivalent )
Télécharger le plugin et le décompresser.
The rake task db:migrate_plugins has been deprecated, please use the replacement version redmine:plugins:migrate
sudo rake redmine:plugins:migrate

Si la base de données doit être mise à jour, lancer la commande suivante :
rake redmine:plugins:migrate RAILS_ENV=production
Relancer Apache
service apache2 restart

Exemples de Plugins

Ok-ko.png https://www.redmine.org/plugins/monitoring-controlling
Ok-ko.png https://www.redmineup.com/pages/plugins/questions
Ok-ko.png https://www.redmine.org/plugins/redmine_contacts
Ok-ko.png https://www.redmine.org/plugins/redmine_people
Ok-ko.png https://www.redmine.org/plugins/sidebar_hide
Ok-ko.png https://usersnap.com/integrations/redmine
Ok-ko.png http://www.redmine.org/plugins/meta
Ko.png D'autres plugins : https://www.redmine.org/plugins?page=47

Plugins testés qui n'ont pas fonctionnés

Obsolète : Plugins pour Redmine.

Redmine checklists

Installation

Ok.png Page officielle du plugin sur Redmine : https://www.redmineup.com/pages/plugins/checklists
Cliquer sur le bouton télécharger. Ajouter son mail. Le lien de téléchargement est envoyé par mail.
Installation du plugin :
# Je n'arrive à rien quand j'utilise l'installation avec les paquets du dépôt Debian ou Mint comme proposé pour l'installation de Redmine sur cette page.
# Je rencontre des problèmes de droits sur certains fichiers, peut être du à la façon de créer l'utilisateur redmine, et, des problèmes de gems.
# En suivant le tutoriel Installer Redmine sur Debian avec RVM, et, les commandes suivantes, j'arrive bien à installer le plugin avec le version 4.0.2.stable de Redmine.
cd /opt/redmine
su - redmine
# Saisir le mot de passe (redmine)
cd redmine-4.0-stable/
cd plugins/
wget https://www.redmineup.com/license_manager/66499?token=1a55bb1224f0f20e4b404af0a6661f7c4c824&utm_source=Main&utm_medium=email&utm_campaign=download_plugin_email&utm_term=download_plugin_email&utm_content=download_plugin_email
unzip 66499\?token\=1a55bb1224f0f20e4b404af0a6661f7c4c824
rm 66499?token=1a55bb1224f0f20e4b404af0a6661f7c4c824
# Ne pas revenir dans le dossier principale de Redmine. Rester dans le dossier des plugins.
source /opt/redmine/.rvm/scripts/rvm
rvm list gemsets
rvm use gemset ruby-2.4.5@redmine-4.0-stable
bundle install --without development test
bundle exec rake redmine:plugins:migrate RAILS_ENV=production
# Quitter l'utilisateur redmine.
exit
# Redémarrer Apache2.
sudo service apache2 restart
Le plugin a bien mis à jour la base de données de Redmine et est maintenant fonctionnel depuis une issue Redmine :
Redmine checklists.png
Je n'arrivais pas à installer le plugin sur la version 4.x de Redmine, mais, le bogue a été corrigé :
https://www.redmineup.com/pages/help/checklists/installing-redmine-checklists-plugin-on-linux#comment-4473628030

Désinstallation

# Se placer dans le répertoire racine de Redmine.
cd /opt/redmine
su - redmine
# Saisir le mot de passe (redmine)
cd redmine-4.0-stable/
source /opt/redmine/.rvm/scripts/rvm
rvm list gemsets
rvm use gemset ruby-2.4.5@redmine-4.0-stable
# Lancer le script de maintenance va supprimer les tables du plugin de la base de données.
bundle exec rake redmine:plugins:migrate NAME=redmine_checklists VERSION=0 RAILS_ENV=production

Utiliser un canal de discussion en complément de Redmine

redmine_messenger

Ce plugin permet de publier les mises à jour des tickets présents dans vos différents projets Redmine vers un (ou plusieurs) salon(s) Slack, Rocket.Chat, Discord ou Mattermost.
!!! Un problème d'accent est posté sur le Github et reste en attente de résolution !!!
Certains caractères spéciaux ne sont pas affichés sur Slack, comme par exemple ' qui devient '
https://github.com/AlphaNodes/redmine_messenger/issues/38
Page du plugin sur le site officiel de Redmine : https://www.redmine.org/plugins/redmine_messenger
Github du plugin : https://github.com/AlphaNodes/redmine_messenger
Télécharger le plugin : https://github.com/AlphaNodes/redmine_messenger/archive/master.zip
Manuel d'installation du plugin : https://github.com/alphanodes/redmine_messenger#installation
Installation du plugin :
# Je n'arrive à rien quand j'utilise l'installation avec les paquets du dépôt Debian ou Mint comme proposé pour l'installation de Redmine sur cette page.
# Je rencontre des problèmes de droits sur certains fichiers, peut être du à la façon de créer l'utilisateur redmine, et, des problèmes de gems.
# En suivant le tutoriel Installer Redmine sur Debian avec RVM, et, les commandes suivantes, j'arrive bien à installer le plugin.
cd /opt/redmine
su - redmine
# Saisir le mot de passe (redmine)
cd redmine-4.0-stable/
cd plugins/
wget https://github.com/AlphaNodes/redmine_messenger/archive/master.zip
unzip master.zip
rm master.zip
mv redmine_messenger-master/ redmine_messenger/
# Ne pas revenir dans le dossier principale de Redmine. Rester dans le dossier des plugins.
# Changer le nom du dossier du plugin redmine_messenger-master par redmine_messenger
source /opt/redmine/.rvm/scripts/rvm
rvm list gemsets
rvm use gemset ruby-2.4.5@redmine-4.0-stable
bundle install --without development test
bundle exec rake redmine:plugins:migrate RAILS_ENV=production
# Quitter l'utilisateur redmine.
exit
# Redémarrer Apache2.
sudo service apache2 restart
Le plugin est installé, il reste encore a le configurer.
Créer un compte et un projet depuis Slack
# Site officiel
https://slack.com
# Créer un espace de travail :
https://md-progressistes.slack.com
# Créer un salon :
#redmine
Générer un "Webhooks entrants" depuis le lien https://slack.com/apps/build/custom-integration
Un lien est proposé pour cibler un salon de discussion en particulier #redmine
Ajouter un descriptif, par exemple : Nouveau message en provenance de Redmine.
Personnaliser le nom d’utilisateur pour les publications de cette intégration. : message-en-provenance-de-redmine
Valider cette configuration.
Un message apparaît dans le salon ciblé :
Utilisateur [22 h 10] a ajouté une intégration à cette chaîne : message-en-provenance-de-redmine
# Enregistrer la configuration de Slack.
Configurer le plugin redmine_messenger dans Redmine
# Noter que la configuration ci-dessous peut être personnalisée de façon différente pour chaque projet de Redmine depuis l'onglet Configuration/Messenger
# Il n'est alors pas nécessaire de configurer le plugin qui sert uniquement pour une configuration généraliste.
# Configurer le plugin de façon généraliste.
Messenger - URL WebHook entrant
Messenger - Icône affiché (Par défaut : https://raw.githubusercontent.com/alphanodes/redmine_messenger/master/assets/images/icon.png )
Messenger - Nom du salon
Messenger - Nom du robot
Vérifier SSL
...
# Tester SANS ACTIVER cette option, si les icones s'affichent tout le temps sur l'issue.
# Si oui, c'est que les deux options ci-dessous créent un bogue. Si non, c'est un comportement normal.
Convert names to mentions ? 
Default people for mentions
...
Afficher l'utilisateur assigné au ticket ?
Publier pour chaque mises à jour ?
Description du nouveau ticket ?
Publier la description suite à une mise à jour ?
Mises à jour des tickets privés?
Mises à jour des notes privées ?
Post Wiki ajouté ?
Mises à jour du wiki ?
# Enregistrer la configuration de Redmine.
Mettre la base de données du plugin redmine_messenger à jour
Suite à la configuration du plugin, j'obtiens des erreurs en interne suite à mes tentatives de créations ou de mises à jour d'issues ou de pages wiki.
Je constate une erreur dans les logs qui fait référence à une table de la base de données.
Je relance la mise à jour des tables depuis le répertoire plugins !
Normalement, si l'installation est faite correctement, comme détaillée plus haut, cette erreur ne devrait pas se produire.
~/redmine-4.0-stable/plugins$ bundle exec rake redmine:plugins:migrate RAILS_ENV=production
(in /opt/redmine/redmine-4.0-stable)
1 CreateMessengerSettings: migrating
 -- adapter_name()
    -> 0.0000s
 -- adapter_name()
    -> 0.0000s
 -- adapter_name()
    -> 0.0000s
 -- create_table(:messenger_settings, {:options=>"ENGINE=InnoDB", :id=>:integer})
    -> 0.0252s
 1 CreateMessengerSettings: migrated (0.0255s)
 
 2 AddDefaultMentions: migrating
 -- add_column(:messenger_settings, :default_mentions, :string, {})
    -> 0.0300s
 2 AddDefaultMentions: migrated (0.0302s)
 
 3 AddPrivateSettings: migrating
 -- add_column(:messenger_settings, :post_private_contacts, :integer, {:default=>0, :null=>false})
    -> 0.0165s
 -- add_column(:messenger_settings, :post_private_db, :integer, {:default=>0, :null=>false})
    -> 0.0288s
 3 AddPrivateSettings: migrated (0.0456s)
Après avoir modifié un ticket de Redmine, un message est instantanément posté sur Slack.
Le plugin, et, sa nouvelle configuration fonctionne maintenant. 
Ce plugin redmine_messenger semble bien le plus abouti.
Il devrait permettre de poster sur différents réseaux :
Slack - Rocket.Chat - Discord - Mattermost.
Testé avec un ticket partagé sur Slack.
Changer la langue du message envoyé sur Slack
Projet Public - Issue Demande de support #127: test updated by Zer00CooL
Je cherche à remplacer le "updated by" par "Mis à jour par".
Vérifier la configuration globale de la machine virtuelle, qui est en anglais par défaut.
Même passée en français forcé, le tickets postés sur Slack sont en anglais. Je traduis le plugin en français.
Ce texte dépend directement de la configuration du plugin.
Je dépose une nouvelle contribution pour la langue française dans le code source du plugin partagé sur GitHub : https://github.com/AlphaNodes/redmine_messenger/
redmine_messenger/config/locales/fr.yml
# French strings
fr:
  default_mentionsl_info: Personnes à notifier par défaut, séparées par des virgules (@all, @here)
  error_messenger_invalid_url: n'est pas une URL valide
  label_messenger_contact_created: "[%{project_url}] Le contact %{url} créé par *%{user}*"
  label_messenger_contact_updated: "[%{project_url}] Le contact %{url} mis à jour par *%{user}*"
  label_messenger_db_entry_created: "[%{project_url}] Entrée de base de données %{url} créée par *%{user}*"
  label_messenger_db_entry_updated: "[%{project_url}] Entrée de base de données %{url} mis à jour par *%{user}*"
  label_messenger_default_not_visible: Le paramètre par défaut n'est pas visible pour des raisons de sécurité
  label_messenger_issue_created: "[%{project_url}] Ticket %{url} créé par *%{user}*"
  label_messenger_issue_updated: "[%{project_url}] Ticket %{url} mis à jour par *%{user}*"
  label_messenger_password_created: "[%{project_url}] Mot de passe %{url} créé par *%{user}*"
  label_messenger_password_updated: "[%{project_url}] Mot de passe %{url} mis à jour par *%{user}*"
  label_messenger_project_text_field_info: Laissez ce champ vide pour le système par défaut.
  label_messenger_setting: Paramètres de messagerie
  label_messenger_settings_default: Choix de l'option
  label_messenger_settings_disabled: Désactivé
  label_messenger_settings_enabled: Activé
  label_messenger_wiki_created: "[%{project_url}] Wiki %{url} créé par *%{user}*"
  label_messenger_wiki_updated: "[%{project_url}] Wiki %{url} mis à jour par *%{user}*"
  label_messenger: Messenger
  label_settings_auto_mentions: Convert names to mentions ?
  label_settings_default_mentions: Default people for mentions
  label_settings_display_watchers: Afficher l'utilisateur assigné au ticket ?
  label_settings_messenger_channel: Messenger - Nom du salon
  label_settings_messenger_icon: Messenger - Icône affiché
  label_settings_messenger_url: Messenger - URL WebHook entrant
  label_settings_messenger_username: Messenger - Nom du robot
  label_settings_messenger_verify_ssl: Vérifier SSL
  label_settings_new_include_description: Description du nouveau ticket ?
  label_settings_post_contact_updates: Mises à jour de contact ?
  label_settings_post_contact: Contact ajouté ?
  label_settings_post_db_updates: Mises à jour des entrées de base de données ?
  label_settings_post_db: Entrée de base de données ajoutée ?
  label_settings_post_password_updates: Mises à jour du mot de passe ?
  label_settings_post_password: Mot de passe ajouté ?
  label_settings_post_private_contacts: Contacts privés ?
  label_settings_post_private_db: Entrées de base de données privées ?
  label_settings_post_private_issues: Mises à jour des tickets privés?
  label_settings_post_private_notes: Mises à jour des notes privées ?
  label_settings_post_updates: Publier pour chaque mises à jour ?
  label_settings_post_wiki_updates: Mises à jour du wiki ?
  label_settings_post_wiki: Post Wiki ajouté ?
  label_settings_updated_include_description: Description suite à une mise à jour ?
  messenger_channel_info_html: 'Vous devez spécifier le canal à utiliser. Vous pouvez définir plusieurs canaux, séparés par une virgule.'
  messenger_contacts_intro: Activer les modifications pour les contacts à envoyer au canal Messenger prédéfini.
  messenger_db_intro: Activer les modifications pour la base de données à envoyer au canal Messenger prédéfini.
  messenger_issue_intro: Activer les modifications pour les tickets à envoyer au canal Messenger prédéfini.
  messenger_passwords_intro: Activez les modifications pour les mots de passe devant être envoyés au canal Messenger prédéfini.
  messenger_settings_intro: "Laissez l'URL de Messenger dans la zone d'administration vide afin de ne pas envoyer de messages de Redmine à Messenger. Peu importe ce que vous avez configuré ici. Si vous souhaitez envoyer des messages de tous les projets Redmine à Messenger, renseignez l’URL. Les messages seront envoyés au canal spécifique. Si vous souhaitez uniquement être averti par certains des projets (pas tous), laissez l'URL du messager ici vide et accédez à la configuration du projet spécifique."
  messenger_settings_project_intro: "Si vous laissez vide l'URL de Messenger dans la zone d'administration au cas où vous ne seriez pas averti globalement de toutes les modifications apportées au projet, vous pouvez configurer votre URL Messenger dans les paramètres du projet."
  messenger_url_info_html: 'Générer une <a target="_blank" href="https://github.com/AlphaNodes/redmine_messenger#prepare-your-messenger-service">Incoming WebHook</a> URL du service de messagerie. Laissez-le vide si vous souhaitez uniquement activer des projets spécifiques avec des paramètres de projet.'
  messenger_verify_ssl_info_html: 'Si votre service Messenger utilise un certificat SSL non valide ou auto-signé, désactivez-le.'
  messenger_wiki_intro: Activez les modifications pour les wikis à envoyer au canal Messenger prédéfini.
permission_manage_messenger: Gérer messenger
Désinstaller redmine_messenger
# Se placer dans le répertoire racine de Redmine.
cd /opt/redmine
su - redmine
# Saisir le mot de passe (redmine)
cd redmine-4.0-stable/
source /opt/redmine/.rvm/scripts/rvm
rvm list gemsets
rvm use gemset ruby-2.4.5@redmine-4.0-stable
# Lancer le script de maintenance va supprimer les tables du plugin de la base de données.
bundle exec rake redmine:plugins:migrate NAME=redmine_messenger VERSION=0 RAILS_ENV=production

== 3 AddPrivateSettings: reverting ============================================
-- remove_column(:messenger_settings, :post_private_db, :integer, {:default=>0, :null=>false})
   -> 0.1454s
-- remove_column(:messenger_settings, :post_private_contacts, :integer, {:default=>0, :null=>false})
   -> 0.0997s
== 3 AddPrivateSettings: reverted (0.2513s) ===================================

== 2 AddDefaultMentions: reverting ============================================
-- remove_column(:messenger_settings, :default_mentions, :string, {})
   -> 0.0477s
== 2 AddDefaultMentions: reverted (0.0481s) ===================================

== 1 CreateMessengerSettings: reverting =======================================
-- drop_table(:messenger_settings, {:options=>"ENGINE=InnoDB", :id=>:integer})
   -> 0.0337s
== 1 CreateMessengerSettings: reverted (0.0339s) ==============================
# Supprimer le dossier du plugin.
rm -rf plugins/redmine_messenger
Restart Redmine (application server)

Traduire Redmine

Il est possible de participer à la traduction de Redmine, tout comme il est possible de modifier le contenu d'une langue proposée par défaut.
Il faudra faire d'avantage de recherches pour savoir comment faire.
Ko.png Équipe de traduction : http://www.redmine.org/projects/redmine/wiki/Translation_Team
Ko.png Traduire Redmine dans votre propre langue : http://www.redmine.org/projects/redmine/wiki/HowTo_translate_Redmine_in_your_own_language

Sauvegarder Redmine

Scripts Bash pour la sauvegarde de Redmine

Préparer les éléments de la sauvegarde

# Créer un dossier pour stocker les scripts de maintenance.
# Aller dans le dossier de votre utilisateur sudoers
cd ~/
# Créer un dossier script-maintenance
sudo mkdir script-maintenance
### Aller dans le dossier script-maintenance
cd script-maintenance
# Créer les deux fichiers suivants qui vont contenir un script de sauvegarde.
sudo touch sauvegarde_fichiers_redmine.sh
sudo touch sauvegarde_sql_redmine.sh
# Créer un dossier pour stocker les sauvegardes.
# Aller dans le dossier de votre utilisateur sudoers
cd ~/
# Créer un dossier backup qui va accueillir vos sauvegardes
sudo mkdir backup
cd backup/
# Créer un dossier sql et un dossier fichiers
sudo mkdir sql
sudo mkdir fichiers
cd sql
# Créer un dossier redmine
sudo mkdir redmine
# Revenir dans le dossier backup puis aller dans le dossier fichiers
cd ..
cd fichiers
# Créer un dossier redmine
sudo mkdir redmine
# Changer les droits d'accès aux dossiers de script et de sauvegarde.
# Aller dans le dossier de votre utilisateur sudoers
cd ~/
# Changer les droits du dossier backup et script-maintenance pour 640
sudo chmod -R 640 backup/
sudo chmod -R 640 script-maintenance/
# Les dossiers de scripts et de sauvegarde appartiennent à l'utilisateur root.
sudo chown -R root:root backup/ script-maintenance/

Script de sauvegarde de la base de données

# Créer le script de sauvegarde sql de la base de données de Redmine.
# Aller dans le dossier de votre utilisateur sudoers.
cd ~/
# Les droits du dossier qui va accueillir le script étant en 640, faire sudo bash pour pouvoir accéder au dossier script-maintenance.
sudo bash
# Aller dans le dossier de maintenance.
cd script-maintenance/
# Ouvrir le fichier qui va accueillir le script pour sauvegarder la base de données.
nano sauvegarde_sql_redmine.sh
# Alternative pour ouvrir le script de sauvegarde sql de la base de données de Redmine plus rapidement.
# Aller dans le dossier de votre utilisateur sudoers.
cd ~/
sudo nano script-maintenance/sauvegarde_sql_redmine.sh
# Ajouter le code suivant :
# Sauvegarder la base de données MariaDB de Redmine.
sudo mysqldump --single-transaction -h localhost -u <utilisateur> -p<password> <redmine_database> > /home/<UTILISATEUR>/backup/sql/redmine/sauvegarde_sql_redmine_`date +%d_%m_%y_%Hh`.sql
# Sauvegarder la base de données MySQL de Redmine.
# sudo mysqldump --skip-lock-tables -h localhost -u <utilisateur> -p<password> <redmine_database> > /home/<UTILISATEUR>/backup/sql/redmine/sauvegarde_sql_redmine_`date +%d_%m_%y_%Hh`.sql
# Lancer le script de sauvegarde sql de la base de données de Redmine.
# Aller dans le dossier de votre utilisateur sudoers.
cd ~/
sudo sh script-maintenance/sauvegarde_sql_redmine.sh
# Copier le fichier de la sauvegarde sql vers une autre destination, par exemple, vers le serveur web.
cd ~/
sudo cp backup/sql/redmine/sauvegarde_sql_redmine_jj_mm_aa_hhh.sql /var/www/html/backup.sql

Script de sauvegarde des fichiers

# Créer le script de sauvegarde sql de la base de données de Redmine.
# Aller dans le dossier de votre utilisateur sudoers.
cd ~/
# Les droits du dossier qui va accueillir le script étant en 640, faire sudo bash pour pouvoir accéder au dossier script-maintenance.
sudo bash
# Aller dans le dossier de maintenance.
cd script-maintenance/
# Ouvrir le fichier qui va accueillir le script pour sauvegarder la base de données.
nano sauvegarde_fichiers_redmine.sh
# Alternative pour ouvrir le script de sauvegarde sql de la base de données de Redmine plus rapidement.
# Aller dans le dossier de votre utilisateur sudoers.
cd ~/
sudo nano script-maintenance/sauvegarde_fichiers_redmine.sh
# Ajouter le code suivant :
# !/bin/bash
# sauvegarde_fichiers_redmine.sh
# sh sauvegarde_fichiers_redmine.sh
mkdir -p /home/USER/backup/fichiers/redmine/sauvegarde_fichiers_redmine_$(date +'%d_%m_%y_%Hh')

cd /var/lib/redmine/default/files
cp -aRv * /home/deUSERbian/backup/fichiers/redmine/sauvegarde_fichiers_redmine_$(date +'%d_%m_%y_%Hh')

cd /home/USER/backup/fichiers/redmine/
tar -zcf sauvegarde_fichiers_redmine_$(date +'%d_%m_%y_%Hh').tgz /home/USER/backup/fichiers/redmine/sauvegarde_fichiers_redmine_$(date +'%d_%m_%y_%Hh')
# Lancer le script de sauvegarde sql de la base de données de Redmine.
# Aller dans le dossier de votre utilisateur sudoers.
cd ~/
sudo sh script-maintenance/sauvegarde_fichiers_redmine.sh
# Copier le fichier de la sauvegarde de fichiers vers une autre destination, par exemple, vers le serveur web.
cd ~/
sudo cp backup/fichiers/redmine/sauvegarde_fichiers_redmine_jj_mm_aa_hhh.tgz /var/www/html/fichiers.tgz

Chiffrement et intégrité de la sauvegarde

La méthode ci-dessous ne me permet pas d'ouvrir l'archive chiffrée avec GNU/Linux Mint.
Préférer une autre méthode avec 7z : Chiffrer une archive avec 7z.

Exporter une copie de la sauvegarde vers le dossier Dropbox en local

# Installer le paquet pour pouvoir se connecter à Dropbox
Connecter son serveur à Dropbox.
Arrêter la connexion avec Dropbox. Continuer les étapes suivantes.
pkill dropbox
# Le dossier Dropbox a été créé dans le dossier /home/UTILISATEUR/ lors de l'installation du paquet de Dropbox.
# Créer dans le dossier Dropbox un dossier Unis-pour-le-climat qui sera destiné a recevoir la sauvegarde de Redmine.
# Créer un nouveau script dans le dossier script-maintenance
sudo touch script-maintenance/deplacer-sauvegarde-vers-dropbox-local.sh
# Éditer le fichier deplacer-sauvegarde-vers-dropbox-local.sh
sudo nano script-maintenance/deplacer-sauvegarde-vers-dropbox-local.sh
# Ajouter le code suivant :
# Se placer dans le répertoire de l'utilisateur.
cd /home/UTILISATEUR/
# Copier les données du dossier backup vers Dropbox en local.
cp backup/fichiers/redmine/sauvegarde_fichiers_redmine_$(date +'%d_%m_%y_%Hh').tgz Dropbox/Unis-pour-le-climat/backup/fichiers/redmine/sauvegarde_fichiers_redmine_$(date +'%d_%m_%y_%Hh').tgz
cp backup/sql/redmine/sauvegarde_sql_redmine_$(date +'%d_%m_%y_%Hh').sql Dropbox/Unis-pour-le-climat/backup/sql/redmine/sauvegarde_sql_redmine_$(date +'%d_%m_%y_%Hh').sql
# Donner le droit 755 pour permettre la synchronisation avec le cloud Dropbox.
# Retirer les droits pour restreindre l'accès avec chmod 640.
sudo chmod -R 755 Dropbox/
# Chiffrer un dossier avec un mot de passe.
7z a -t7z -m0=lzma2 -mx=9 -mfb=64 -md=32m -ms=on -mhe=on -p'PASSWORD1' Dropbox/Unis-pour-le-climat/backup/fichiers/redmine/sauvegarde_fichiers_redmine_$(date +'%d_%m_%y_%Hh').7z Dropbox/Unis-pour-le- climat/backup/fichiers/redmine/sauvegarde_fichiers_redmine_$(date +'%d_%m_%y_%Hh').tgz
7z a -t7z -m0=lzma2 -mx=9 -mfb=64 -md=32m -ms=on -mhe=on -p'PASSWORD2' Dropbox/Unis-pour-le-climat/backup/sql/redmine/sauvegarde_sql_redmine_$(date +'%d_%m_%y_%Hh').7z Dropbox/Unis-pour-le-climat/backup/sql/redmine/sauvegarde_sql_redmine_$(date +'%d_%m_%y_%Hh').sql
# Déchiffrer le fichier avec sudo bash en local, puisque le dossier est en chmod 640 par défaut.
# Supression des archives non sécurisées pour ne pas les exporter.
rm Dropbox/Unis-pour-le-climat/backup/fichiers/redmine/sauvegarde_fichiers_redmine_$(date +'%d_%m_%y_%Hh').tgz
rm Dropbox/Unis-pour-le-climat/backup/sql/redmine/sauvegarde_sql_redmine_$(date +'%d_%m_%y_%Hh').sql
# Exécuter le script pour exporter une copie de la sauvegarde vers le dossier Dropbox en local.
sudo sh script-maintenance/deplacer-sauvegarde-vers-dropbox-local.sh
# Relancer la connexion avec Dropbox en utilisant le script pour démarrer et arrêter Dropbox.
Script pour démarrer et arrêter Dropbox.
La synchronisation avec le dépôt de Dropbox est effectuée.
# Déchiffrer une archive chiffrée avec 7z
7z x fichier.7z

Récapitulatif pour effectuer une sauvegarde locale et distante

cd ~/
sudo sh script-maintenance/sauvegarde_sql_redmine.sh
sudo sh script-maintenance/sauvegarde_fichiers_redmine.sh
sudo sh script-maintenance/deplacer-sauvegarde-vers-dropbox-local.sh
sh /usr/local/bin/Demarrer-Arreter-Dropbox.sh

Lancer toutes les actions en un seul script

Créer un nouveau script dans le dossier /usr/local/bin.
cd /usr/local/bin
sudo touch Automatisation-sauvegarde-cron.sh
sudo nano Automatisation-sauvegarde-cron.sh
# Ajouter le code suivant :
#!/bin/bash
# Ajouter le script Automatisation-sauvegarde-cron.sh dans /usr/local/bin
# Lancer le script : sh /usr/local/bin/Automatisation-sauvegarde-cron.sh
cd ~/

# Supprimer les vieux fichiers présents dans Dropbox.
find /home/debian/Dropbox/Unis-pour-le-climat/backup/fichiers/redmine/. -type f -mtime +10 -exec echo "rm -f {}" \;
find  /home/debian/Dropbox/Unis-pour-le-climat/backup/sql/redmine/. -type f -mtime +10 -exec echo "rm -f {}" \;

sudo sh script-maintenance/sauvegarde_sql_redmine.sh
sudo sh script-maintenance/sauvegarde_fichiers_redmine.sh
sudo sh script-maintenance/deplacer-sauvegarde-vers-dropbox-local.sh
sh /usr/local/bin/Demarrer-Arreter-Dropbox.sh
Lancer ce script permet d'effectuer toutes les actions précédentes.
sh /usr/local/bin/Automatisation-sauvegarde-cron.sh

Script amélioré

Script bash pour sauvegarder Redmine.
Révision par Zer00CooL : https://gist.github.com/ZerooCool/b06925403f94960e32c3c52f2db81b01

Créer la tâche Cron pour une sauvegarde automatique

# Pour un site peu fréquenté mais sur lequel un travail est journalièrement déposé, envisager par exemple deux sauvegardes par jour, toutes les 12 heures.
# Ce script commence à travailler à partir du moment ou il est ajouté dans les tâches cron.
# Créer le fichier de log pour la tâche cron qui transfert les sauvegardes vers DropBox.
sudo touch /var/log/cron-dropbox.log
# Le propriétaire et le groupe du fichier cron-dropbox.log ont été changés pour l'utilisateur courant de debian.
sudo chown debian:debian /var/log/cron-dropbox.log
# Ajouter la tâche cron.
crontab -e
# m h  dom mon dow   command
15 */12 * * * /usr/local/bin/Automatisation-sauvegarde-cron.sh >> /var/log/cron-dropbox.log 2>&1
L'écriture dans le fichier fonctionne correctement.
Créer une tâche Cron.
Sur le même principe, mettre en place une sauvegarde automatique pour Joomla.

Migrer Redmine sur un autre serveur

Réinstaller Redmine sur un nouveau serveur avec la même configuration

Exemple pour migrer un serveur en production vers un serveur local :
Serveur 1 en production, Debian 9.5 Stretch, Redmine version 3.3.1
Serveur 2 en local, Debian 9.5 Stretch, Redmine version 3.3.1

Récupérer les données sur le Serveur 1 en production

Base de données :
sudo mysqldump --single-transaction -h localhost -u <Utilisateur> -p<password> redmine_default > sauvegarde_sql_redmine.sql
Fichiers :
Sauvegarder les fichiers du répertoire /var/lib/redmine/default/files/

Importer les données sur le Serveur 2 en local

Base de données :
sudo mysql -u <Utilisateur> -p<password> redmine_default < sauvegarde_sql_redmine.sql
Fichiers :
Importer les fichiers dans le répertoire /var/lib/redmine/default/files/
Changer de propriétaire et de groupe pour redmine :
sudo chown -R redmine:redmine /var/lib/redmine/default/files/
Mettre à jour la base de données :
cd /usr/share/redmine/
rake db:migrate RAILS_ENV=production

Nettoyer le cache et les sessions existantes :
rake tmp:cache:clear
rake tmp:sessions:clear
## Ou comme ça :
## RAILS_ENV=production bundle exec rake tmp:cache:clear tmp:sessions:clear
Redémarrer Apache2 après la modification : /etc/init.d/apache2 restart
Se connecter au Redmine local avec votre mot de passe administrateur du site de production.
Si la connexion ne se fait pas, vérifier que la base de données de production ait bien été chargée en local.
Importer à nouveau la base de données de production, relancer la commande de migration de la base de données.
Cette fois il devrait être possible de se connecter sur le Redmine local, avec les données du site de production.
La base de données du Redmine de production est maintenant disponible et fonctionnelle en local.

Mettre Redmine à jour sur Debian

Objectif : Passer de Redmine 3.3.1 sur une Debian stable à Redmine 3.4.6 sur une Debian SID.
Attention ! Le changement de contenu dans le fichier sources.list peut casser votre Debian.
Mes essais sur une machine virtuelle avec Debian 9.5 et xfce n'ont pas aboutis.
Il semble que le paquet mariadb-server cassait la machine virtuelle, soit car corrompu, soit, par manque de place.
La version de Debian 9.5 Stretch stable accepte uniquement la version de Redmine 3.3.1 stable présente dans les dépôts.
Mes essais sur une machine virtuelle avec Debian 9.5 en mode serveur ont aboutis correctement, avec le sources.list suivant et Redmine 3.3.1-1 installé.
Vérifier le contenu du fichier /etc/apt/sources.list de Debian.
Le contenu du fichier sources.list stable :
deb http://deb.debian.org/debian stretch main contrib non-free
deb-src http://deb.debian.org/debian stretch main contrib non-free
deb http://security.debian.org/ stretch/updates main contrib non-free
deb-src http://security.debian.org/ stretch/updates main contrib non-free
deb http://deb.debian.org/debian stretch-updates main contrib non-free
deb-src http://deb.debian.org/debian stretch-updates main contrib non-free
Mettre à jour Debian stable avec la commande apt update puis apt upgrade.
La version de Debian 9.5 Stretch SID permet d'installer la dernière version de Redmine 3.4.6 stable présente dans les dépôts.
Mes essais sur une machine virtuelle avec Debian 9.5 en mode serveur ont aboutis correctement, avec le sources.list suivant et Redmine 3.4.6-1 mis à jour.
Remplacer le contenu du fichier /etc/apt/sources.list de Debian.
Le contenu du fichier sources.list : Passage vers SID a ajouter dans le fichier /etc/apt/sources.list de Debian :
deb http://ftp.de.debian.org/debian/ sid main non-free contrib
deb http://ftp.de.debian.org/debian/ buster main non-free contrib
deb http://ftp.de.debian.org/debian/ stretch main non-free contrib
deb http://security.debian.org/debian-security stretch/updates main contrib non-free
deb http://ftp.de.debian.org/debian/ stretch-proposed-updates main contrib non-free
deb http://ftp.de.debian.org/debian/ stretch-updates main contrib non-free
Suite à cette expérimentation, j'utiliserais par la suite les dépôts suivants, à préférer :
deb http://debian.proxad.net/debian/ stretch main non-free contrib
deb http://deb.debian.org/debian/ sid main contrib non-free
deb http://deb.debian.org/debian/ testing main contrib non-free
deb http://security.debian.org/ buster/updates main contrib non-free
deb-src http://security.debian.org/ buster/updates main contrib non-free
deb http://deb.debian.org/debian/ buster main non-free contrib
deb-src http://deb.debian.org/debian/ buster main non-free contrib
deb http://deb.debian.org/debian/ buster-updates main contrib non-free
deb-src http://deb.debian.org/debian/ buster-updates main contrib non-free
Arrêter le service Apache2 et MySQL avant de lancer la mise à jour des paquets.
service apache2 stop
service mysql stop
Arrêter aussi les conteneurs de Docker, des fois que Docker soit également mis à jour.
docker stop $(docker ps -a -q)
Mettre à jour Debian SID  avec la commande apt update puis apt upgrade.
Si tout se passe bien, vous avez pu changer de dépôt correctement.
Une fois en SID Redmine est à jour avec la version 3.4.6.
La base de données est à présent vide sur la machine virtuelle, et, Redmine informe être en version 3.3.1 depuis Administration de Redmine, dans le lien de menu Information.
Mettre à jour la base de données :
cd /usr/share/redmine/
rake db:migrate RAILS_ENV=production
Nettoyer le cache et les sessions existantes :
rake tmp:cache:clear
rake tmp:sessions:clear
La version 3.3.1 de Redmine ne semble pas changer pour la version 3.4.6 depuis Administration de Redmine, dans le lien de menu Information.
C'est peut être du au fait que je n'ai pas redémarrer Apache2.
Télécharger la sauvegarde de votre base de données de production sur votre serveur si le fichier de sauvegarde ne s'y trouve pas déjà.
Utiliser par exemple wget pour récupérer la dernière sauvegarde fonctionnelle depuis le cloud Dropbox.
wget https://www.dropbox.com/s/PATH-ALEATOIRE/sauvegarde_sql_redmine_03_10_18_00h.sql.tar.gz
Décompresser le fichier chiffré avec le bon mot de passe :
openssl enc -d -aes256 -in fichier.sql.tar.gz | tar xz
Décompresser le fichier tar.gz
tar -zxvf fichier.tar.gz
Importer la sauvegarde de la base de données qui était en production.
sudo mysql -u <Utilisateur> -p<password> redmine_default < sauvegarde_sql_redmine.sql
Fichiers :
Importer les fichiers dans le répertoire /var/lib/redmine/default/files/
Changer de propriétaire et de groupe pour redmine :
sudo chown -R redmine:redmine /var/lib/redmine/default/files/
Mettre à jour la base de données :
cd /usr/share/redmine/
rake db:migrate RAILS_ENV=production
Des lignes s'affichent sur le terminal ce qui laisse à penser que le processus de mise à jour de la base de données fait son travail.
Nettoyer le cache et les sessions existantes :
rake tmp:cache:clear
rake tmp:sessions:clear
Note : On devrait pouvoir supprimer Redmine 3.4.6 du dépôt SID et forcer l'installation de Redmine 3.3.1 du dépôt Stretch avec la commande suivante :
apt install -y -t stretch redmine
Ce n'est pas le but ici puisque nous sommes passé en Debian SID pour pouvoir utiliser la version de Redmine 3.4.6.
Lors de mon test avec la machine virtuelle, j'utilisais l'utilisateur de base de données avec tous les droits dans la configuration de la base de données de Redmine.
Lors de mon test en production, j'utilisais l'utilisateur Gestionnaire aux droits restreints dans la configuration de la base de données de Redmine.
Des erreurs ont été rencontrées durant la mise à jour, du fait que l'utilisateur aux droits restreint n'avait pas tous les droits.
J'ai corrigé les droits, un par un, et, la mise à jour a pu aboutir correctement.
Redémarrer Apache2 après la modification : /etc/init.d/apache2 restart
Aller dans Administration, Information. La version affichée pour Redmine est bien la version 3.4.6.
La mise a jour de Redmine a bien été effectuée !
Vérifier les droits en écriture.
Les dossiers suivants ne sont plus affichés comme étant accessibles en écriture depuis le menu Administration / Information de Redmine.
Répertoire de stockage des fichiers accessible en écriture 	
Répertoire public des plugins accessible en écriture (./public/plugin_assets)
sudo chown redmine:redmine -R /var/lib/redmine/default/
sudo chown redmine:redmine -R /var/cache/redmine/
J'en profite pour redonner le fichier Gemfile.lock au propriétaire redmine et au groupe redmine.
sudo chown redmine:redmine /usr/share/redmine/Gemfile.lock

Mise à jour de Redmine - Généralités

Étape 1 - Vérifier les pré-requis

La première étape pour la mise à jour de Redmine est de vérifier que vous remplissez les exigences de la version que vous vous apprêtez à installer.

Étape 2 - Sauvegarde

La plupart des mises à jour sont sans danger mais il est toujours prudent de réaliser une sauvegarde.
Il est recommandé de sauvegarder vos données et vos fichiers.

Étape 3 - Mettre à jour

Le processus de mise à jour dépendant de la manière que vous avez téléchargé Redmine.

Option 1 - Mettre à jour depuis une version téléchargée

Documentation pour une migration vers Redmine 2.x : https://www.redmine.org/projects/redmine/wiki/FrRedmineUpgrade

Option 2 - Mettre à jour depuis un checkout SVN Dépot

Aller dans le répertoire racine de Redmine et exécuter la commande suivante :
svn update

Étape 4 - Mise à jour de la base de données

Cette étape va modifier le contenu de la base de données.
Aller dans le répertoire de votre nouvelle installation de Redmine et effectuer la commande suivante :
rake db:migrate RAILS_ENV=production
Si vous avez installé des plugin, effectuer une migration de la base de données avec la commande suivante :
rake redmine:plugins:migrate RAILS_ENV=production

Étape 5 - Nettoyage

Nettoyer le cache et les sessions existantes :
rake tmp:cache:clear
rake tmp:sessions:clear
Redémarrer l'application (passenger)
Lancer le navigateur et aller dans "Administration -> Rôles & permissions" pour vérifier les permissions.
Paramétrer les nouvelles fonctionnalités s'il y en a.

Mise en forme du contenu avec Redmine

Formater le texte

http://www.redmine.org/projects/redmine/wiki/RedmineTextFormattingTextile

Créer un lien

Créer un lien externe : "Redmine web site":http://www.redmine.org
Créer un lien pour une adresse mail : "Mail de Visionduweb":mailto:mail@visionduweb.com
Exemples complémentaires pour créer un lien avec Redmine : http://demo.redmine.org/help/en/wiki_syntax_detailed.html
Exemples complémentaires pour mettre en forme du contenu avec Redmine : https://redmine.org/projects/redmine/wiki/RedmineTextFormattingTextile

Saisir le temps passé

L'estimation et le temps passé peuvent être saisis en utilisant le format suivant :
Heures et minutes: 1h, 1 h, 1 heure, 2 heures, 30m, 30min, 1h30, 1h30m, 1:30
Heures en décimal: 1.5, 1,5 (égal à 1h30)

Notes complémentaires

Générer le fichier secret_token.rb

La commande suivante permet de générer le fichier secret_token.rb utilisé pour sécuriser les données de session.
rake generate_secret_token
( Ou encore ) bundle exec rake generate_secret_token

Erreurs pour member_roles

Je n'ai pas rencontré ce problème. ( Pour le moment en tout cas. )
Si vous avez raté une mise à jour ou une migration dans le passé, vous pouvez avoir une table member_roles et / ou group_users déjà existante.
La migration de la base de données échouera. Renommer les tables en ligne de commande avec MySql :
mysql> rename table member_roles to member_roles_saved
mysql> rename table groups_users to groups_users_saved

Undefined method - add_frozen_gem_path

Je n'ai pas rencontré ce problème. ( Pour le moment en tout cas. )
Erreur au sujet de "undefined method 'add_frozen_gem_path'"
Vérifier si le répertoire vendor/rails existe et retirer ou renommer le.
Il pourrait contenir une vieille version de Ruby on Rails.

How to properly rename a projet in Redmine

https://beeznest.com/blog/2016/11/18/how-to-properly-rename-a-projet-in-redmine/

Facultatif - Expériences avec Ruby

Sauvegarder vos données avant de tester les propositions ci-dessous.
Aucune garantie sur l'efficacité ou la justesse des commandes présentées ci-dessous.

Impossible de créer une nouvelle issue depuis Redmine

ActionView::Template::Error (undefined method `accessor' for #<ActiveRecord
# Des erreurs de droits d'accès sur les fichiers suivants sont reportées dans le terminal.
# cd /usr/share/redmine/instances/default/config
# sudo chown redmine:redmine secret_key.txt database.yml email.yml
# sudo chmod 755 secret_key.txt database.yml email.yml
# Les trois fichiers sont bien donnés à l'utilisateur et au groupe redmine avec les droits 755.
# A la suite de ça, la procédure rake db:migrate affiche une nouvelle erreur de droits sur le fichier schema.rb
# Changer les droits ne suffit pas pour rake db:migrate ou sudo rake db:migrate et l'erreur réapparaît.
# /usr/share/redmine/db$ sudo chown redmine:redmine schema.rb
# sudo chmod 755 schema.rb
Modifier la configuration du fichier passenger.conf
cd /etc/apache2/mods-available
sudo nano passenger.conf
Vérifier PassengerDefaultUser www-data et le remplacer par PassengerDefaultUser redmine
Redémarrer Apache2 après la modification : /etc/init.d/apache2 restart
Lancer rake db:migrate
cd /usr/share/redmine/db/migrate
sudo rake db:migrate
/usr/share/redmine/db/migrate$ sudo rake db:migrate
(in /usr/share/redmine)
/usr/lib/ruby/vendor_ruby/sprockets/digest_utils.rb:47: warning: constant ::Fixnum is deprecated
/usr/lib/ruby/vendor_ruby/sprockets/digest_utils.rb:51: warning: constant ::Bignum is deprecated
/usr/lib/ruby/vendor_ruby/sprockets/processor_utils.rb:110: warning: constant ::Fixnum is deprecated
/usr/lib/ruby/vendor_ruby/sprockets/processor_utils.rb:111: warning: constant ::Bignum is deprecated
/usr/lib/ruby/vendor_ruby/builder/xchar.rb:111: warning: constant ::Fixnum is deprecated
Remettre PassengerDefaultUser www-data et redémarrer Apache2.
Redémarrer Apache2 après la modification : /etc/init.d/apache2 restart
Malgré les warnings, cette fois, les issues peuvent être créées.
Cette erreur est sûrement due au fait que j'ai créé un utilisateur redmine qui est ajouté au groupe www-data et que des fichiers de redmine ont été donnés (chown) à redmine:redmine
J'ai du oublier de donner tous les fichiers à redmine:redmine ?

Installer la gem mysql2

# Le paquet pour MySQL :
default-libmysqlclient-dev
# Le paquet pour MariaDB :
libmariadbclient-dev

Supprimer ruby

Pour une raison ou une autre, il peut être nécessaire de supprimer les paquets de ruby.
sudo apt purge -y $(dpkg -l |awk '/ruby/ {print $2 }' |xargs)
Des informations complémentaires sont retournées depuis la console afin de supprimer des répertoires manuellement.
par exemple :
sudo apt purge -y $(dpkg -l |awk '/ruby/ {print $2 }' |xargs)

Bibliographie

Didacticiel Redmine

Ok-ko.png Redmine de l'APRIL : https://wiki.april.org/w/Didacticiel_Redmine

Documentations officielles

Ok-ko.png Télécharger Redmine : https://www.redmine.org/projects/redmine/wiki/Download
Ok-ko.png Installer Redmine : https://www.redmine.org/projects/redmine/wiki/RedmineInstall
Ok-ko.png Wiki Redmine - Installer Redmine : https://www.redmine.org/projects/redmine/wiki/RedmineInstall
Ok-ko.png Wiki Redmine - Installer Redmine - Fr : https://www.redmine.org/projects/redmine/wiki/FrRedmineInstall
Ok-ko.png Wiki Redmine - Mettre à jour Redmine : http://www.redmine.org/projects/redmine/wiki/FrRedmineUpgrade
Ok-ko.png Remonter un bogue à l'équipe de Redmine - Bogue tracker Redmine : http://www.redmine.org/projects/redmine/issues

Envoyer un mail avec Redmine

Ok-ko.png Fr Redmine Configuration Email : http://www.redmine.org/projects/redmine/wiki/FrRedmineConfigurationEmail
Ok-ko.png Email Configuration : http://www.redmine.org/projects/redmine/wiki/EmailConfiguration

Informations complémentaires

Ok-ko.png Migrer Redmine d’un serveur Linux à un autre : la solution facile : https://blog.tfrichet.fr/migrer-redmine-dun-serveur-linux-a-un-autre-la-solution-facile
Ok-ko.png Debian 8 : Installer Redmine avec Nginx et Let’s Encrypt : https://memo-linux.com/debian-8-installer-redmine-avec-nginx-et-lets-encrypt/
Ok-ko.png Informations complémentaires : https://fraoustin.fr/old/Redmine.html
Ok-ko.png Informations complémentaires : https://knowledge.nystek-editions.com/projets-open-source/redmine/article/installation-de-redmine-sous-debian

Tutoriel Debian

Ok.png Script de déploiement de Redmine sur Debian : https://www.hiroom2.com/2017/06/21/debian-9-install-redmine/
Ok-ko.png Le wiki de Debian concernant Redmine : https://wiki.debian.org/redmine
Ok-ko.png Tutoriel pour l'installation depuis les sources officielles : https://redmine.org/projects/redmine/wiki/HowTo_Install_Redmine_on_Debian_9
Ok-ko.png Installer la dernière version de redmine avec MySQL : http://www.redmine.org/projects/redmine/wiki/HowTo_Install_Redmine_on_Debian_8_with_Apache2-Passenger

Tutoriel Ubuntu

Ok.png How to install Redmine on ubuntu step by step : http://www.redmine.org/projects/redmine/wiki/howto_install_redmine_on_ubuntu_step_by_step
Ok.png Le guide francophone officiel pour Redmine : http://www.redmine.org/projects/redmine/wiki/FrGuide

Tutoriel Mint

Ok-ko.png Script d'installation de Redmine sur GNU/Linux Mint - VirtualHost pour SSL : https://www.hiroom2.com/2017/07/16/linuxmint-18-redmine-en/

Redmine avec Bitnami

Ok-ko.png Redmine avec Bitnami : https://bitnami.com/stack/redmine
Ok-ko.png Installer Redmine avec Bitnami : https://bitnami.com/stack/redmine/installer
Ok-ko.png Utiliser Redmine avec Bitnami depuis une machine virtuelle : https://bitnami.com/stack/redmine/virtual-machine

Alternatives à Redmine

Ok-ko.png Asana : https://asana.com
Ok-ko.png Flyspray : http://www.flyspray.org
Ok-ko.png Gladys
Ok-ko.png Jira : https://www.atlassian.com/software/jira
Ok-ko.png Kanboard est un logiciel de gestion de projet gratuit et open source : https://kanboard.org
Ok-ko.png NQI Orchestra
Ok-ko.png SocialJsProjet

NAVIGATION

PARTICIPER ET PARTAGER

Vous êtes sur le wiki de Vision du Web.
Les pages présentées sur le wiki évoluent tous les jours.
Certaines recherches sont peu abouties et incluent des erreurs.
Pour participer sur le wiki, créer un compte utilisateur en haut à droite.
La recherche interne du wiki permet de trouver le contenu qui vous intéresse.
Les informations présentes sur ce wiki sont issues d'une recherche personnelle.
Identifiez-vous pour poser vos questions sur la page de discussion de VisionDuWeb.
Améliorer le contenu des pages en faisant des propositions depuis l'onglet discussion.
Les informations du wiki ne doivent pas servir à nuire à autrui ou à un système informatique.
De nombreux outils gratuits sont listés et disponibles dans la boîte à outils de Vision du web.
D'autres pages du wiki peuvent correspondre à vos attentes. La liste de toutes les pages du wiki.

VALORISER LE WIKI

Valoriser le contenu partagé sur le wiki avec un don en monnaie numérique :
AEON - Bitcoins - Bitcoins Cash - Bitcoins Gold - Bitcore - Blackcoins - Basic Attention Token - Bytecoins - Clams - Dash - Monero - Dogecoins - Ğ1 - Ethereum - Ethereum Classique - Litecoins - Potcoins - Solarcoins - Zcash

OBTENIR DE LA MONNAIE NUMERIQUE

Obtenir gratuitement de la monnaie numérique :
Gagner des Altcoins - Miner des Altcoins.
Consulter le miroir du wiki depuis Planet Hoster : Le miroir du wiki version du 12 Juillet 2019.