Como instalar o Wekan (Kanban de código aberto) no CentOS 7

• Pré-requisitos
• Instale o Node.js
• Instale o MongoDB
• Instale o Wekan
• Configurando o Nginx Reverse Proxy
• Configurar o serviço Systemd
• Empacotando

O Wekan é um quadro kanban criado com a estrutura JavaScript do Meteor. É considerado uma alternativa de código aberto e auto-hospedado ao Trello, fornecendo quase os mesmos recursos. Ele permite que você crie listas de gerenciamento de tarefas pendentes baseadas em cartões. O Wekan é muito útil para aumentar a produtividade ao trabalhar em um ambiente colaborativo. O Wekan possui uma interface da web totalmente responsiva e é traduzida ativamente em vários idiomas.

Pré-requisitos

• Uma instância do servidor Vultr CentOS 7.
• Um usuário sudo .

Neste tutorial, usaremos wekan.example.comcomo o nome de domínio apontado para a instância do Vultr. Certifique-se de substituir todas as ocorrências do nome de domínio de exemplo pelo nome real.

Atualize seu sistema básico usando o guia Como atualizar o CentOS 7 . Depois que seu sistema for atualizado, continue com a instalação das dependências.

Instale o Node.js

Wekan suporta apenas Node.js LTS version 4.8. Para instalar o Node.js, usaremos o gerenciador de versão do nó. Instale nvmexecutando o script do instalador.

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

Para começar a usar imediatamente nvm, execute isso.

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

Se nvmtiver sido instalado com sucesso, você poderá verificar sua versão.

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

Instale o Node.js.

nvm install v4.8

Defina a versão padrão do Node.js.

nvm use node

Se o Node.js foi instalado com sucesso, você deve poder verificar sua versão.

node -v

Você verá esta saída.

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

O NVM instala o Node.js apenas para o usuário atual. Para que o Node.js esteja acessível globalmente, execute isso.

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

O Node.js agora está disponível como /bin/node.

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

Instale o MongoDB

O MongoDB é um servidor de banco de dados NoSQL gratuito e de código aberto. Ao contrário dos bancos de dados tradicionais que usam tabelas para organizar seus dados, o MongoDB é orientado a documentos e usa documentos semelhantes a JSON sem esquemas. O Wekan usa o MongoDB para armazenar seus dados.

Wekan é compatível apenas com MongoDB version 3.2. O MongoDB não está disponível no YUMrepositório padrão , portanto, você precisará criar um novo arquivo de repositório.

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

Preencha o arquivo com o seguinte conteúdo.

[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

Instale o MongoDB.

sudo yum install -y mongodb-org

Inicie o servidor MongoDB e ative-o automaticamente.

sudo systemctl start mongod
sudo systemctl enable mongod

Protegendo a instância do MongoDB

Por padrão, não há autenticação ativada em um servidor MongoDB. Qualquer usuário que tenha acesso ao terminal do servidor terá privilégios totais na instalação do MongoDB. Para proteger o servidor de banco de dados e restringir o acesso de um usuário sem privilégios, precisaremos configurar a autenticação no servidor.

O MongoDB fornece um mongoshell, usado para executar consultas no MongoDB. Alterne para o mongoshell digitando.

mongo

Crie um novo usuário do MongoDB com privilégios de root. Você pode usar qualquer nome de usuário de sua escolha. Certifique-se de substituir a senha .

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

Você deve ver a seguinte saída.

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

Saia da interface de comando do MongoDB para o terminal Linux pressionando " Ctrl+C".

Edite o arquivo de configuração do MongoDB.

sudo nano /etc/mongod.conf

Anexe a seguinte linha no final do arquivo.

security:
 authorization: enabled

Reinicie o MongoDB para que a alteração na configuração possa entrar em vigor.

sudo systemctl restart mongod

Agora que a segurança foi ativada, você pode testar se está funcionando alternando para o shell mongo novamente usando o mongocomando Dessa vez, se você executar uma consulta, como show dbspara mostrar a lista de bancos de dados, verá uma mensagem relatando falha na autorização. Saia para o sudousuário novamente após testar o logon como o novo usuário que você acabou de criar.

Efetue login como o administratorusuário que você acabou de criar.

mongo -u admin -p

Forneça a senha do usuário para um login bem-sucedido. Crie um novo usuário para o Wekanbanco de dados que será usado para armazenar dados Wekan.

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

Certifique-se de alterar a StrongPasswordsenha com uma senha forte. Você verá a seguinte saída.

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

Instale o Wekan

Verifique o link mais recente para o lançamento do Wekan no Github, pois novos lançamentos são muito frequentes. Baixe a versão mais recente do Wekan do Github, substituindo o link para o pacote do instalador.

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

Extraia o arquivo baixado para um novo diretório chamado wekan.

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

Instalação Bzip2, necessária para extrair as dependências do Node.js.

sudo yum -y install bzip2

Instale as dependências do Node.js.

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

O servidor Wekan lê configurações das variáveis ​​de ambiente. Execute os seguintes comandos para definir as configurações como variáveis ​​de 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

Certifique-se de substituir a senha do MongoDB para o wekanusuário que você criou. Além disso, atualize o URL do email de acordo com as configurações do servidor SMTP. Se você não tiver o servidor de correio pronto, sempre poderá alterar essa configuração posteriormente. Abra o firewall para permitir a porta 4000através do firewall.

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

Para iniciar imediatamente o aplicativo.

cd ~/wekan/bundle
node main.js

Agora você pode acessar o aplicativo acessando http://wekan.example.com:4000. Você verá a interface para efetuar login no quadro Kanban do Wekan.

Para uso em produção, é recomendável configurar um proxy reverso para atender o aplicativo na HTTPporta padrão e um systemdserviço para gerenciar o processo do aplicativo. Neste tutorial, usaremos o servidor da web Nginx como um proxy reverso, protegido com um SSL grátis Let's Encrypt.

Configurando o Nginx Reverse Proxy

Instale o servidor da web Nginx e o Certbot, que é o aplicativo cliente da Let's Encrypt CA.

sudo yum -y install certbot nginx

Antes de poder solicitar os certificados SSL, você precisará permitir a porta 80e 443através do firewall. O Certbot verificará a autoridade do domínio antes de emitir certificados.

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

Agora que estamos executando o Wekan em uma HTTPSporta padrão , não precisamos permitir a porta 4000através do firewall. Ajuste o firewall para remover a porta 4000.

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

Nota: O nome do domínio que você está usando para obter os certificados da autoridade de certificação Let's Encrypt deve ser apontado para o servidor. O cliente verifica a autoridade do domínio antes de emitir os certificados .

Gere os certificados SSL.

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

Os certificados gerados provavelmente serão armazenados no /etc/letsencrypt/live/wekan.example.com/diretório O certificado SSL será armazenado como fullchain.peme a chave privada será armazenada como privkey.pem.

Os certificados Let's Encrypt expiram em 90 dias, portanto, é recomendável configurar a renovação automática dos certificados usando o Cronjob. Cron é um serviço do sistema usado para executar tarefas periódicas.

Abra o arquivo de tarefa cron.

sudo crontab -e

Adicione a seguinte linha no final do arquivo.

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

O trabalho cron acima será executado todos os dias às 05:30. Se os certificados expirarem, eles serão renovados automaticamente.

Crie um novo host virtual.

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

Preencha o arquivo com o seguinte.

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

Substitua wekan.example.compelo seu nome de domínio real na configuração acima.

Reinicie o Nginx para que as alterações tenham efeito.

sudo systemctl restart nginx

Habilite o Nginx para iniciar automaticamente no momento da inicialização.

sudo systemctl enable nginx

Configurar o serviço Systemd

Crie um novo usuário para o processo.

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

Agora mova todos os arquivos para o /opt/wekandiretório

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

Forneça a propriedade dos arquivos para o usuário recém-criado.

sudo chown -R wekan:wekan /opt/wekan

O Wekan não recebe dados de nenhum arquivo de configuração. Em vez disso, acessa-o a partir de variáveis ​​de ambiente. Criaremos um novo arquivo para armazenar as variáveis ​​de ambiente. O arquivo que contém as variáveis ​​de ambiente será passado pelo Systemdserviço.

Crie um novo arquivo para armazenar variáveis ​​de ambiente.

 sudo nano /opt/wekan/config.env

Preencha o arquivo com o seguinte conteúdo.

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

Certifique-se de substituir o usernamee password.

Forneça a propriedade ao wekanusuário.

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

Crie um novo arquivo de serviço para o serviço systemd Wekan.

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

Preencha o arquivo com o seguinte.

[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

Salve o arquivo e saia do editor. Agora você pode facilmente iniciar o Wekan.

sudo systemctl start wekan

Para permitir que o Wekan inicie automaticamente no momento da inicialização.

sudo systemctl enable wekan

Para verificar o status do serviço Wekan.

sudo systemctl status wekan

Empacotando

Agora você pode acessar a instância Wekan em https://wekan.example.com. Comece criando uma nova conta. Depois de criar a conta, você pode habilitar o acesso administrativo ao usuário recém-criado. Efetue login no shell do MongoDB como usuário administrativo.

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

Agora selecione o wekanbanco de dados e atualize o objeto para promover o usuário para o usuário administrador.

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

Substitua admin_userpelo nome de usuário real do usuário que você criou. Na interface administrativa, você poderá desativar o auto-registro e atualizar as configurações SMTP.

Parabéns, você instalou com êxito a placa Wekan Kanban na sua instância do Vultr CentOS.