Come installare Wekan (Kanban open source) su CentOS 7

• Prerequisiti
• Installa Node.js
• Installa MongoDB
• Installa Wekan
• Impostazione del proxy inverso Nginx
• Installa il servizio Systemd
• Avvolgendo

Wekan è una scheda kanban costruita con il framework JavaScript Meteor. È considerata un'alternativa open source e self-hosted a Trello, fornendo quasi le stesse funzionalità. Ti consente di creare elenchi di gestione "da fare" basati su carte. Wekan è molto utile per aumentare la produttività quando si lavora in un ambiente collaborativo. Wekan ha un'interfaccia web completamente reattiva ed è tradotta attivamente in molte lingue.

Prerequisiti

• Un'istanza del server Vultr CentOS 7.
• Un utente sudo .

Per questo tutorial, useremo wekan.example.comcome nome di dominio puntato verso l'istanza Vultr. Assicurati di sostituire tutte le occorrenze del nome di dominio di esempio con quello effettivo.

Aggiorna il tuo sistema di base usando la guida Come aggiornare CentOS 7 . Dopo aver aggiornato il sistema, procedere con l'installazione delle dipendenze.

Installa Node.js

Wekan supporta solo Node.js LTS version 4.8. Per installare Node.js, useremo il gestore versione nodo. Installa nvmeseguendo lo script di installazione.

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

Per iniziare immediatamente a utilizzare nvm, esegui questo.

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

Se nvmè stato installato correttamente, dovresti essere in grado di controllarne la versione.

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

Installa Node.js.

nvm install v4.8

Imposta la versione predefinita di Node.js.

nvm use node

Se Node.js è stato installato correttamente, dovresti essere in grado di controllarne la versione.

node -v

Vedrai questo risultato.

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

NVM installa Node.js solo per l'utente corrente. Affinché Node.js sia accessibile a livello globale, esegui questo.

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

Node.js è ora disponibile come /bin/node.

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

Installa MongoDB

MongoDB è un server di database NoSQL gratuito e open source. A differenza dei database tradizionali che utilizzano le tabelle per organizzare i propri dati, MongoDB è orientato ai documenti e utilizza documenti simili a JSON senza schemi. Wekan utilizza MongoDB per archiviare i suoi dati.

Wekan è compatibile solo con MongoDB version 3.2. MongoDB non è disponibile nel YUMrepository predefinito , quindi sarà necessario creare un nuovo file repository.

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

Popolare il file con il seguente contenuto.

[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

Installa MongoDB.

sudo yum install -y mongodb-org

Avviare il server MongoDB e abilitare l'avvio automatico.

sudo systemctl start mongod
sudo systemctl enable mongod

Protezione dell'istanza MongoDB

Per impostazione predefinita, non è abilitata l'autenticazione in un server MongoDB. Qualsiasi utente che abbia accesso al terminale del server disporrà di privilegi completi sull'installazione di MongoDB. Per proteggere il server di database e limitare l'accesso di un utente non privilegiato, dovremo impostare l'autenticazione sul server.

MongoDB fornisce una mongoshell, che viene utilizzata per eseguire query su MongoDB. Passa alla mongoshell digitando.

mongo

Crea un nuovo utente MongoDB con i privilegi di root. Puoi usare qualsiasi nome utente a tua scelta. Assicurati di sostituire la password .

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

Dovresti vedere il seguente output.

[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"
                }
        ]
}

Chiudere l'interfaccia di comando MongoDB sul terminale Linux premendo " Ctrl+C".

Modifica il file di configurazione di MongoDB.

sudo nano /etc/mongod.conf

Aggiungi la seguente riga alla fine del file.

security:
 authorization: enabled

Riavvia MongoDB in modo che la modifica della configurazione abbia effetto.

sudo systemctl restart mongod

Ora che la sicurezza è stata abilitata, è possibile verificare se funziona passando nuovamente alla shell mongo utilizzando il mongocomando. Questa volta, se si esegue una query, ad esempio show dbsper visualizzare l'elenco dei database, verrà visualizzato un messaggio che riporta l'autorizzazione non riuscita. Esci sudonuovamente dall'utente dopo aver testato l'accesso come nuovo utente appena creato.

Accedi come l' administratorutente appena creato.

mongo -u admin -p

Fornire la password dell'utente per un accesso riuscito. Crea un nuovo utente per il Wekandatabase che verrà utilizzato per archiviare i dati Wekan.

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

Assicurati di cambiarlo StrongPasswordcon una password complessa. Vedrai il seguente output.

[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" ] }

Installa Wekan

Controlla l'ultimo collegamento alla versione Wekan su Github poiché le nuove versioni sono molto frequenti. Scarica l'ultima versione di Wekan da Github sostituendo il collegamento al pacchetto di installazione.

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

Estrarre l'archivio scaricato in una nuova directory denominata wekan.

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

Installa Bzip2, necessario per estrarre le dipendenze Node.js.

sudo yum -y install bzip2

Installa le dipendenze Node.js.

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

Il server Wekan legge le configurazioni dalle variabili di ambiente. Eseguire i comandi seguenti per impostare le configurazioni come variabili di ambiente.

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

Assicurati di sostituire la password MongoDB per l' wekanutente che hai creato. Inoltre, aggiorna l'URL della posta in base alle impostazioni del tuo server SMTP. Se non si dispone di un server di posta pronto, è sempre possibile modificare questa configurazione in un secondo momento. Aprire il firewall per consentire la porta 4000attraverso il firewall.

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

Per avviare immediatamente l'applicazione.

cd ~/wekan/bundle
node main.js

Ora puoi accedere all'applicazione andando a http://wekan.example.com:4000. Vedrai l'interfaccia per accedere alla scheda kanban Wekan.

Per l'uso in produzione, si consiglia di impostare un proxy inverso per servire l'applicazione sulla HTTPporta standard e un systemdservizio per gestire il processo dell'applicazione. In questo tutorial, utilizzeremo il web server Nginx come proxy inverso, protetto con un SSL gratuito Let's Encrypt.

Impostazione del proxy inverso Nginx

Installa il server web Nginx e Certbot, che è l'applicazione client per Let's Encrypt CA.

sudo yum -y install certbot nginx

Prima di poter richiedere i certificati SSL, è necessario consentire la porta 80e 443attraverso il firewall. Certbot controllerà l'autorità di dominio prima di emettere certificati.

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

Ora che stiamo eseguendo Wekan su una HTTPSporta standard , non è necessario consentire la porta 4000attraverso il firewall. Regola il firewall per rimuovere la porta 4000.

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

Nota: il nome di dominio che si sta utilizzando per ottenere i certificati dalla CA Let's Encrypt deve essere puntato verso il server. Il client verifica l'autorità di dominio prima di emettere i certificati .

Genera i certificati SSL.

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

È probabile che i certificati generati siano archiviati nella /etc/letsencrypt/live/wekan.example.com/directory. Il certificato SSL verrà archiviato come fullchain.peme la chiave privata verrà archiviata come privkey.pem.

Let's Encrypt certificati scadranno tra 90 giorni, quindi si consiglia di impostare il rinnovo automatico dei certificati utilizzando Cronjob. Cron è un servizio di sistema che viene utilizzato per eseguire attività periodiche.

Apri il file di lavoro cron.

sudo crontab -e

Aggiungi la seguente riga alla fine del file.

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

Il precedente cron job verrà eseguito ogni giorno alle 5:30. Se i certificati sono in scadenza, li rinnoverà automaticamente.

Crea un nuovo host virtuale.

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

Popolare il file con il seguente.

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;
        }
}

Sostituisci wekan.example.comcon il tuo nome di dominio effettivo nella configurazione sopra.

Riavvia Nginx per rendere effettive le modifiche.

sudo systemctl restart nginx

Abilita Nginx per l'avvio automatico all'avvio.

sudo systemctl enable nginx

Installa il servizio Systemd

Crea un nuovo utente per il processo.

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

Ora sposta tutti i file nella /opt/wekandirectory.

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

Fornire la proprietà dei file all'utente appena creato.

sudo chown -R wekan:wekan /opt/wekan

Wekan non accetta dati da alcun file di configurazione. Al contrario, vi accede dalle variabili di ambiente. Creeremo un nuovo file per memorizzare le variabili di ambiente. Il file contenente le variabili di ambiente verrà passato attraverso il Systemdservizio.

Creare un nuovo file per archiviare le variabili di ambiente.

 sudo nano /opt/wekan/config.env

Popolare il file con il seguente contenuto.

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

Assicurati di sostituire il usernamee password.

Fornire la proprietà wekanall'utente.

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

Creare un nuovo file di servizio per il servizio systemd di Wekan.

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

Popolare il file con il seguente.

[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

Salvare il file ed uscire dall'editor. Ora puoi avviare facilmente Wekan.

sudo systemctl start wekan

Per consentire a Wekan di avviarsi automaticamente all'avvio.

sudo systemctl enable wekan

Per verificare lo stato del servizio Wekan.

sudo systemctl status wekan

Avvolgendo

Ora puoi accedere all'istanza di Wekan su https://wekan.example.com. Inizia creando un nuovo account. Dopo aver creato l'account, è possibile abilitare l'accesso amministrativo all'utente appena creato. Accedere alla shell MongoDB come utente amministrativo.

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

Ora seleziona il wekandatabase e aggiorna l'oggetto per promuovere l'utente nell'amministratore.

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

Assicurati di sostituire admin_usercon il nome utente effettivo dell'utente che hai creato. Dall'interfaccia di amministrazione, sarai in grado di disabilitare l'auto-registrazione e aggiornare le impostazioni SMTP.

Congratulazioni, hai installato con successo la scheda Wekan Kanban sulla tua istanza di Vultr CentOS.