Si të instaloni Wekan (Kanban me burim të hapur) në CentOS 7

Parakushtet

Instaloni Node.js

Instaloni MongoDB

Instaloni Wekan

Konfigurimi i përfaqësuesit të kundërt Nginx

Konfiguro Shërbimin Systemd

Përfundimi

Wekan është një tabelë kanban e ndërtuar me kornizën Meteor JavaScript. Konsiderohet si një alternativë me burim të hapur dhe të vetë-pritur për Trello, duke ofruar pothuajse të njëjtat veçori. Kjo ju lejon të krijoni lista të menaxhimit të "për të bërë" të bazuara në karta. Wekan është shumë i dobishëm për të rritur produktivitetin kur punoni në një mjedis bashkëpunues. Wekan ka një ndërfaqe uebi plotësisht të përgjegjshme dhe përkthehet në mënyrë aktive në shumë gjuhë.

Parakushtet

• Një shembull i serverit Vultr CentOS 7.
• Një përdorues sudo .

Për këtë tutorial, ne do të përdorim wekan.example.comsi emër domaini të drejtuar drejt shembullit Vultr. Ju lutemi sigurohuni që të zëvendësoni të gjitha dukuritë e emrit të domenit shembull me atë aktual.

Përditësoni sistemin tuaj bazë duke përdorur udhëzuesin Si të përditësoni CentOS 7 . Pasi sistemi juaj të jetë përditësuar, vazhdoni të instaloni varësitë.

Instaloni Node.js

Wekan mbështet vetëm Node.js LTS version 4.8. Për të instaluar Node.js, ne do të përdorim menaxherin e versionit të nyjeve. Instaloni nvmduke ekzekutuar skriptin e instaluesit.

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

Për të filluar menjëherë përdorimin nvm, ekzekutoni këtë.

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

Nëse nvmështë instaluar me sukses, atëherë duhet të jeni në gjendje të kontrolloni versionin e tij.

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

Instaloni Node.js.

nvm install v4.8

Cakto versionin e paracaktuar të Node.js.

nvm use node

Nëse Node.js është instaluar me sukses, atëherë duhet të jeni në gjendje të kontrolloni versionin e tij.

node -v

Do ta shihni këtë dalje.

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

NVM instalon Node.js vetëm për përdoruesin aktual. Që Node.js të jetë i aksesueshëm globalisht, ekzekutoni këtë.

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

Node.js tani në dispozicion si /bin/node.

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

Instaloni MongoDB

MongoDB është një server i bazës së të dhënave NoSQL pa pagesë dhe me burim të hapur. Ndryshe nga bazat e të dhënave tradicionale që përdorin tabela për të organizuar të dhënat e tyre, MongoDB është i orientuar drejt dokumenteve dhe përdor dokumente të ngjashme me JSON pa skema. Wekan përdor MongoDB për të ruajtur të dhënat e tij.

Wekan është i pajtueshëm vetëm me MongoDB version 3.2. MongoDB nuk është i disponueshëm në YUMdepon e paracaktuar , kështu që do t'ju duhet të krijoni një skedar të ri depo.

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

Plotësoni skedarin me përmbajtjen e mëposhtme.

[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

Instaloni MongoDB.

sudo yum install -y mongodb-org

Nisni serverin MongoDB dhe aktivizoni që të fillojë automatikisht.

sudo systemctl start mongod
sudo systemctl enable mongod

Sigurimi i shembullit MongoDB

Si parazgjedhje, nuk ka asnjë vërtetim të aktivizuar në një server MongoDB. Çdo përdorues që ka akses në terminalin e serverit do të ketë privilegje të plota në instalimin e MongoDB. Për të siguruar serverin e bazës së të dhënave dhe për të kufizuar aksesin e një përdoruesi të paprivilegjuar, do të na duhet të konfigurojmë vërtetimin në server.

MongoDB ofron një mongoguaskë, e cila përdoret për të ekzekutuar pyetje në MongoDB. Kalo te mongoguaska duke shtypur.

mongo

Krijoni një përdorues të ri MongoDB me privilegje rrënjësore. Ju mund të përdorni çdo emër përdoruesi që dëshironi. Ju lutemi sigurohuni që të zëvendësoni fjalëkalimin .

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

Ju duhet të shihni daljen e mëposhtme.

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

Dilni ndërfaqen e komandës MongoDB në terminalin Linux duke shtypur " Ctrl+C".

Redaktoni skedarin e konfigurimit MongoDB.

sudo nano /etc/mongod.conf

Shtoni rreshtin e mëposhtëm në fund të skedarit.

security:
 authorization: enabled

Rinisni MongoDB në mënyrë që ndryshimi i konfigurimit të mund të hyjë në fuqi.

sudo systemctl restart mongod

Tani që siguria është aktivizuar, mund të provoni nëse po funksionon duke kaluar përsëri në guaskën mongo duke përdorur mongokomandën. Këtë herë, nëse kryeni një pyetje, të tillë si show dbspër të shfaqur listën e bazave të të dhënave, do të shihni një mesazh që raporton autorizimin e dështuar. Dilni sudopërsëri te përdoruesi pasi të keni testuar hyrjen si përdoruesi i ri që sapo keni krijuar.

Hyni si administratorpërdoruesi që sapo keni krijuar.

mongo -u admin -p

Jepni fjalëkalimin e përdoruesit për një hyrje të suksesshme. Krijo një përdorues të ri për Wekanbazën e të dhënave që do të përdoret për të ruajtur të dhënat Wekan.

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

Sigurohuni që ta ndryshoni StrongPasswordme një fjalëkalim të fortë. Do të shihni daljen e mëposhtme.

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

Instaloni Wekan

Check for the latest link to the Wekan release on Github as new releases are very frequent. Download the latest version of Wekan from Github replacing the link to the installer package.

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

Extract the downloaded archive into a new directory named wekan.

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

Install Bzip2, which is required to extract the Node.js dependencies.

sudo yum -y install bzip2

Install the Node.js dependencies.

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

The Wekan server reads configurations from the environment variables. Run the following commands to set the configurations as environment variables.

export MONGO_URL='mongodb://wekan:StrongPassword@127.0.0.1:27017/wekan?authSource=wekan'
export ROOT_URL='http://wekan.example.com'
export MAIL_URL='smtp://user:pass@mail.example.com:25/'
export MAIL_FROM='wekan@example.com'
export PORT=4000

Make sure to replace the MongoDB password for the wekan user you have created. Also, update the mail URL according to your SMTP server settings. If you do not have mail server ready, you can always change this configuration later. Open the firewall to allow port 4000 through the firewall.

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

To immediately start the application.

cd ~/wekan/bundle
node main.js

You can now access the application by going to http://wekan.example.com:4000. You will see the interface to log-in to the Wekan kanban board.

For production use, it is recommended to set up a reverse proxy to serve the application on the standard HTTP port and a systemd service to manage the application process. In this tutorial, we will use the Nginx web server as a reverse proxy, secured with a Let's Encrypt free SSL.

Setting up the Nginx Reverse Proxy

Install the Nginx web server and Certbot, which is the client application for Let's Encrypt CA.

sudo yum -y install certbot nginx

Before you can request the SSL certificates, you will need to allow port 80 and 443 through the firewall. Certbot will check the domain authority before issuing certificates.

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

Now that we are running Wekan on a standard HTTPS port, we do not need to allow port 4000 through the firewall. Adjust the firewall to remove port 4000.

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

Note: The domain name which you are using to obtain the certificates from the Let's Encrypt CA must be pointed towards the server. The client verifies the domain authority before issuing the certificates.

Generate the SSL certificates.

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

The generated certificates are likely to be stored in the /etc/letsencrypt/live/wekan.example.com/ directory. The SSL certificate will be stored as fullchain.pem, and the private key will be stored as privkey.pem.

Let's Encrypt certificates expire in 90 days, so it is recommended to set up auto-renewal of the certificates using Cronjob. Cron is a system service which is used to run periodic tasks.

Open the cron job file.

sudo crontab -e

Add the following line at the end of the file.

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

The above cron job will run every day at 5:30 AM. If the certificates are due for expiration, it will automatically renew them.

Create a new virtual host.

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

Populate the file with the following.

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

Replace wekan.example.com with your actual domain name in the above configuration.

Restart Nginx so that the changes can take effect.

sudo systemctl restart nginx

Enable Nginx to automatically start at boot time.

sudo systemctl enable nginx

Setup the Systemd Service

Krijo një përdorues të ri për procesin.

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

Tani lëvizni të gjithë skedarët në /opt/wekandrejtori.

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

Jepni pronësinë e skedarëve përdoruesit të sapokrijuar.

sudo chown -R wekan:wekan /opt/wekan

Wekan nuk merr të dhëna nga asnjë skedar konfigurimi. Në vend të kësaj, ai akseson atë nga variablat e mjedisit. Ne do të krijojmë një skedar të ri për të ruajtur variablat e mjedisit. Skedari që përmban variablat e mjedisit do të kalojë përmes Systemdshërbimit.

Krijoni një skedar të ri për të ruajtur variablat e mjedisit.

 sudo nano /opt/wekan/config.env

Plotësoni skedarin me përmbajtjen e mëposhtme.

MONGO_URL='mongodb://wekan:StrongPassword@127.0.0.1:27017/wekan?authSource=wekan'
ROOT_URL='http://wekan.example.com'
MAIL_URL='smtp://user:pass@mail.example.com:25/'
MAIL_FROM='wekan@example.com'
PORT=4000
HTTP_FORWARDED_COUNT=1

Ju lutemi sigurohuni që të zëvendësoni usernamedhe password.

Jepni pronësinë wekanpërdoruesit.

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

Krijo një skedar të ri shërbimi për shërbimin Wekan systemd.

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

Plotësoni skedarin me sa vijon.

[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

Ruani skedarin dhe dilni nga redaktori. Tani mund të filloni lehtësisht Wekan.

sudo systemctl start wekan

Për të mundësuar që Wekan të fillojë automatikisht në kohën e nisjes.

sudo systemctl enable wekan

Për të kontrolluar statusin e shërbimit Wekan.

sudo systemctl status wekan

Përfundimi

Tani mund të përdorni shembullin Wekan në https://wekan.example.com. Filloni duke krijuar një llogari të re. Pasi të keni krijuar llogarinë, mund të aktivizoni aksesin administrativ te përdoruesi i sapokrijuar. Hyni në guaskën MongoDB si përdorues administrativ.

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

Tani zgjidhni wekanbazën e të dhënave dhe përditësoni objektin për të promovuar përdoruesin te përdoruesi admin.

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

Ju lutemi sigurohuni që ta zëvendësoni admin_userme emrin aktual të përdoruesit të përdoruesit që keni krijuar. Nga ndërfaqja e administratorit, do të jeni në gjendje të çaktivizoni vetë-regjistrimin dhe të përditësoni cilësimet SMTP.

Urime, ju keni instaluar me sukses tabelën Wekan Kanban në shembullin tuaj Vultr CentOS.