Comment installer Wekan (Open Source Kanban) sur CentOS 7

• Conditions préalables
• Installez Node.js
• Installer MongoDB
• Installer Wekan
• Configuration du proxy inverse Nginx
• Configurer le service Systemd
• Emballer

Wekan est un tableau kanban construit avec le framework JavaScript Meteor. Il est considéré comme une alternative open source et auto-hébergée à Trello, offrant presque les mêmes fonctionnalités. Il vous permet de créer des listes de gestion "à faire" basées sur des cartes. Wekan est très utile pour augmenter la productivité lorsque vous travaillez dans un environnement collaboratif. Wekan possède une interface Web entièrement réactive et il est activement traduit dans de nombreuses langues.

Conditions préalables

• Une instance de serveur Vultr CentOS 7.
• Un utilisateur sudo .

Pour ce didacticiel, nous utiliserons wekan.example.comle nom de domaine pointé vers l'instance Vultr. Veuillez vous assurer de remplacer toutes les occurrences de l'exemple de nom de domaine par celui réel.

Mettez à jour votre système de base à l'aide du guide Comment mettre à jour CentOS 7 . Une fois votre système mis à jour, procédez à l'installation des dépendances.

Installez Node.js

Wekan ne supporte que Node.js LTS version 4.8. Pour installer Node.js, nous utiliserons le gestionnaire de version de nœud. Installez nvmen exécutant le script d'installation.

wget -qO- https://raw.githubusercontent.com/creationix/nvm/v0.33.4/install.sh | bash

Pour commencer immédiatement à utiliser nvm, exécutez ceci.

export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"

Si l' nvminstallation a réussi, vous devriez pouvoir vérifier sa version.

[user@vultr ~]$ nvm --version
0.33.4

Installez Node.js.

nvm install v4.8

Définissez la version par défaut de Node.js.

nvm use node

Si Node.js a été installé avec succès, vous devriez pouvoir vérifier sa version.

node -v

Vous verrez cette sortie.

[user@vultr ~]$ node -v
v4.8.4

NVM installe Node.js pour l'utilisateur actuel uniquement. Pour que Node.js soit accessible globalement, exécutez ceci.

n=$(which node);n=${n%/bin/node}; chmod -R 755 $n/bin/*; sudo cp -r $n/{bin,lib,share} /usr

Node.js est désormais disponible en tant que /bin/node.

[user@vultr ~]$ sudo which node
/bin/node

Installer MongoDB

MongoDB est un serveur de base de données NoSQL gratuit et open source. Contrairement aux bases de données traditionnelles qui utilisent des tables pour organiser leurs données, MongoDB est orienté document et utilise des documents de type JSON sans schémas. Wekan utilise MongoDB pour stocker ses données.

Wekan n'est compatible qu'avec MongoDB version 3.2. MongoDB n'est pas disponible dans le YUMréférentiel par défaut , vous devrez donc créer un nouveau fichier de référentiel.

sudo nano /etc/yum.repos.d/mongodb-org-3.2.repo

Remplissez le fichier avec le contenu suivant.

[mongodb-org-3.2]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/3.2/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-3.2.asc

Installez MongoDB.

sudo yum install -y mongodb-org

Démarrez le serveur MongoDB et activez-le pour démarrer automatiquement.

sudo systemctl start mongod
sudo systemctl enable mongod

Sécurisation de l'instance MongoDB

Par défaut, aucune authentification n'est activée sur un serveur MongoDB. Tout utilisateur ayant accès au terminal du serveur aura tous les privilèges sur l'installation de MongoDB. Pour sécuriser le serveur de base de données et restreindre l'accès d'un utilisateur non privilégié, nous devrons configurer une authentification sur le serveur.

MongoDB fournit un mongoshell, qui est utilisé pour exécuter des requêtes sur MongoDB. Basculez vers le mongoshell en tapant.

mongo

Créez un nouvel utilisateur MongoDB avec des privilèges root. Vous pouvez utiliser n'importe quel nom d'utilisateur de votre choix. Veuillez vous assurer de remplacer le mot de passe .

db.createUser(
  {
    user: "admin",
    pwd: "StrongAdminPassword",
    roles: [ { role: "root", db: "admin" } ]
  }
)

Vous devriez voir la sortie suivante.

[user@vultr ~]$ mongo
MongoDB shell version: 3.2.17
connecting to: test
Welcome to the MongoDB shell.

...

2017-09-29T20:42:29.042+0000 I CONTROL  [initandlisten]
> db.createUser(
...   {
...     user: "admin",
...     pwd: "StrongAdminPassword",
...     roles: [ { role: "root", db: "admin" } ]
...   }
... )
Successfully added user: {
        "user" : "admin",
        "roles" : [
                {
                        "role" : "root",
                        "db" : "admin"
                }
        ]
}

Quittez l'interface de commande MongoDB vers le terminal Linux en appuyant sur " Ctrl+C".

Modifiez le fichier de configuration MongoDB.

sudo nano /etc/mongod.conf

Ajoutez la ligne suivante à la fin du fichier.

security:
 authorization: enabled

Redémarrez MongoDB pour que le changement de configuration puisse prendre effet.

sudo systemctl restart mongod

Maintenant que la sécurité a été activée, vous pouvez tester si elle fonctionne en basculant à nouveau vers le shell mongo à l'aide de la mongocommande. Cette fois, si vous exécutez une requête, comme show dbspour afficher la liste des bases de données, vous verrez un message signalant l'échec de l'autorisation. Revenez à l' sudoutilisateur après avoir testé la connexion en tant que nouvel utilisateur que vous venez de créer.

Connectez-vous en tant administratorqu'utilisateur que vous venez de créer.

mongo -u admin -p

Fournissez le mot de passe de l'utilisateur pour une connexion réussie. Créez un nouvel utilisateur pour la Wekanbase de données qui sera utilisée pour stocker les données Wekan.

use wekan
db.createUser(
    {
      user: "wekan",
      pwd: "StrongPassword",
      roles: ["readWrite"]
    }
 ) 

Assurez-vous de changer le StrongPasswordavec un mot de passe fort. Vous verrez la sortie suivante.

[user@vultr ~]$ mongo -u admin -p
MongoDB shell version: 3.2.17
Enter password:
connecting to: test

...

2017-09-29T20:52:32.450+0000 I CONTROL  [initandlisten]
>
> use wekan
switched to db wekan
> db.createUser(
...     {
...       user: "wekan",
...       pwd: "StrongPassword",
...       roles: ["readWrite"]
...     }
...  )
Successfully added user: { "user" : "wekan", "roles" : [ "readWrite" ] }

Installer Wekan

Vérifiez le dernier lien vers la version Wekan sur Github car les nouvelles versions sont très fréquentes. Téléchargez la dernière version de Wekan depuis Github en remplaçant le lien vers le package d'installation.

cd ~
wget https://github.com/wekan/wekan/releases/download/v0.41/wekan-0.41.tar.gz

Extrayez l'archive téléchargée dans un nouveau répertoire nommé wekan.

mkdir wekan
tar xzvf wekan-*.tar.gz -C wekan

Installer Bzip2, qui est nécessaire pour extraire les dépendances Node.js.

sudo yum -y install bzip2

Installez les dépendances Node.js.

cd wekan/bundle/programs/server && npm install

Le serveur Wekan lit les configurations à partir des variables d'environnement. Exécutez les commandes suivantes pour définir les configurations en tant que variables d'environnement.

export MONGO_URL='mongodb://wekan:[email protected]:27017/wekan?authSource=wekan'
export ROOT_URL='http://wekan.example.com'
export MAIL_URL='smtp://user:[email protected]:25/'
export MAIL_FROM='[email protected]'
export PORT=4000

Assurez-vous de remplacer le mot de passe MongoDB pour l' wekanutilisateur que vous avez créé. Mettez également à jour l'URL de messagerie en fonction des paramètres de votre serveur SMTP. Si vous n'avez pas de serveur de messagerie prêt, vous pouvez toujours modifier cette configuration ultérieurement. Ouvrez le pare-feu pour autoriser le port à 4000travers le pare-feu.

sudo firewall-cmd --zone=public --add-port=4000/tcp --permanent
sudo firewall-cmd --reload

Pour démarrer immédiatement l'application.

cd ~/wekan/bundle
node main.js

Vous pouvez maintenant accéder à l'application en allant sur http://wekan.example.com:4000. Vous verrez l'interface pour vous connecter au tableau kanban Wekan.

Pour une utilisation en production, il est recommandé de configurer un proxy inverse pour servir l'application sur le HTTPport standard et un systemdservice pour gérer le processus d'application. Dans ce tutoriel, nous utiliserons le serveur Web Nginx comme proxy inverse, sécurisé avec un SSL gratuit Let's Encrypt.

Configuration du proxy inverse Nginx

Installez le serveur Web Nginx et Certbot, qui est l'application cliente de Let's Encrypt CA.

sudo yum -y install certbot nginx

Avant de pouvoir demander les certificats SSL, vous devez autoriser le port 80et 443le pare-feu. Certbot vérifiera l'autorité de domaine avant d'émettre des certificats.

sudo firewall-cmd --zone=public --add-service=http --permanent
sudo firewall-cmd --zone=public --add-service=https --permanent

Maintenant que nous exécutons Wekan sur un HTTPSport standard , nous n'avons plus besoin d'autoriser le port à 4000travers le pare-feu. Ajustez le pare-feu pour supprimer le port 4000.

sudo firewall-cmd --zone=public --remove-port=4000/tcp --permanent
sudo firewall-cmd --reload

Remarque: Le nom de domaine que vous utilisez pour obtenir les certificats de l'autorité de certification Let's Encrypt doit être dirigé vers le serveur. Le client vérifie l'autorité de domaine avant d'émettre les certificats .

Générez les certificats SSL.

sudo certbot certonly --standalone -d wekan.example.com

Les certificats générés sont susceptibles d'être stockés dans le /etc/letsencrypt/live/wekan.example.com/répertoire. Le certificat SSL sera stocké sous fullchain.pemet la clé privée sera stockée sous privkey.pem.

Les certificats Let's Encrypt expirent dans 90 jours, il est donc recommandé de configurer le renouvellement automatique des certificats à l'aide de Cronjob. Cron est un service système utilisé pour exécuter des tâches périodiques.

Ouvrez le fichier de tâche cron.

sudo crontab -e

Ajoutez la ligne suivante à la fin du fichier.

30 5 * * * /usr/bin/certbot renew --quiet

La tâche cron ci-dessus s'exécutera tous les jours à 5h30. Si les certificats doivent expirer, il les renouvellera automatiquement.

Créez un nouvel hôte virtuel.

sudo nano /etc/nginx/conf.d/wekan.example.com.conf

Remplissez le fichier avec les éléments suivants.

upstream wekan {
        server 127.0.0.1:4000;
}
server {
        listen  80;
        listen [::]:80;
        server_name  wekan.example.com;

        location / {
                if ($ssl_protocol = "") {
                        rewrite     ^   https://$server_name$request_uri? permanent;
                }
        }
}

server {
        listen 443 ssl;
        listen [::]:443 ssl;
        server_name wekan.example.com;

        add_header Strict-Transport-Security "max-age=15768000";

        ssl_certificate /etc/letsencrypt/live/wekan.example.com/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/wekan.example.com/privkey.pem;

        ssl_session_timeout 1d;
        ssl_session_cache shared:SSL:10m;
        ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
        ssl_ciphers 'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:ECDHE-ECDSA-DES-CBC3-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:DES-CBC3-SHA:!DSS';
        ssl_prefer_server_ciphers on;

        ssl_stapling on;
        ssl_stapling_verify on;

        error_page 497  https://$host:$server_port$request_uri;
        location / {
            proxy_pass http://wekan;
            proxy_http_version 1.1;
            proxy_set_header Host $host:$server_port;
            proxy_set_header Referer $http_referer;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto https;
            proxy_set_header X-Forwarded-Ssl on;
            proxy_set_header X-Nginx-Proxy true;

            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection "upgrade";

            proxy_redirect off;

            proxy_send_timeout 86400;
            proxy_read_timeout 86400;
        }
}

Remplacez wekan.example.compar votre nom de domaine réel dans la configuration ci-dessus.

Redémarrez Nginx pour que les modifications prennent effet.

sudo systemctl restart nginx

Activez Nginx pour démarrer automatiquement au démarrage.

sudo systemctl enable nginx

Configurer le service Systemd

Créez un nouvel utilisateur pour le processus.

sudo adduser wekan -s /usr/sbin/nologin -d /opt/wekan

Déplacez maintenant tous les fichiers dans le /opt/wekanrépertoire.

sudo mv ~/wekan/* /opt/wekan/

Attribuez la propriété des fichiers à l'utilisateur nouvellement créé.

sudo chown -R wekan:wekan /opt/wekan

Wekan ne prend pas de données d'aucun fichier de configuration. Au lieu de cela, il y accède à partir de variables d'environnement. Nous allons créer un nouveau fichier pour stocker les variables d'environnement. Le fichier contenant les variables d'environnement sera transmis via le Systemdservice.

Créez un nouveau fichier pour stocker les variables d'environnement.

 sudo nano /opt/wekan/config.env

Remplissez le fichier avec le contenu suivant.

MONGO_URL='mongodb://wekan:[email protected]:27017/wekan?authSource=wekan'
ROOT_URL='http://wekan.example.com'
MAIL_URL='smtp://user:[email protected]:25/'
MAIL_FROM='[email protected]'
PORT=4000
HTTP_FORWARDED_COUNT=1

Veuillez vous assurer de remplacer le usernameet password.

Fournissez la propriété à l' wekanutilisateur.

sudo chown -R wekan:wekan /opt/wekan/config.env

Créez un nouveau fichier de service pour le service Wekan systemd.

sudo nano /etc/systemd/system/wekan.service

Remplissez le fichier avec les éléments suivants.

[Unit]
Description=Wekan Server
After=syslog.target
After=network.target

[Service]
Type=simple
Restart=on-failure
StartLimitInterval=86400
StartLimitBurst=5
RestartSec=10
ExecStart=/bin/node /opt/wekan/bundle/main.js
EnvironmentFile=/opt/wekan/config.env
ExecReload=/bin/kill -USR1 $MAINPID
RestartSec=10
User=wekan
Group=wekan
WorkingDirectory=/opt/wekan
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=Wekan

[Install]
WantedBy=multi-user.target

Enregistrez le fichier et quittez l'éditeur. Maintenant, vous pouvez facilement démarrer Wekan.

sudo systemctl start wekan

Pour permettre à Wekan de démarrer automatiquement au démarrage.

sudo systemctl enable wekan

Pour vérifier l'état du service Wekan.

sudo systemctl status wekan

Emballer

Vous pouvez maintenant accéder à l'instance Wekan sur https://wekan.example.com. Commencez par créer un nouveau compte. Une fois le compte créé, vous pouvez activer l'accès administrateur à l'utilisateur nouvellement créé. Connectez-vous au shell MongoDB en tant qu'administrateur.

mongo -u wekan -p --authenticationDatabase "wekan"

Sélectionnez maintenant la wekanbase de données et mettez à jour l'objet pour promouvoir l'utilisateur en tant qu'administrateur.

use wekan
db.users.update({username:'admin_user'},{$set:{isAdmin:true}})

Veuillez vous assurer de remplacer admin_userpar le nom d'utilisateur réel de l'utilisateur que vous avez créé. Depuis l'interface d'administration, vous pourrez désactiver l'auto-enregistrement et mettre à jour les paramètres SMTP.

Félicitations, vous avez correctement installé la carte Wekan Kanban sur votre instance Vultr CentOS.