Cómo instalar Wekan (Open Source Kanban) en CentOS 7

• Prerrequisitos
• Instalar Node.js
• Instalar MongoDB
• Instalar Wekan
• Configurar el proxy inverso de Nginx
• Configurar el servicio Systemd
• Terminando

Wekan es una placa kanban construida con el marco Meteor JavaScript. Se considera una alternativa de código abierto y autohospedada a Trello, que proporciona casi las mismas características. Le permite crear listas de administración de tareas pendientes basadas en tarjetas. Wekan es muy útil para aumentar la productividad cuando se trabaja en un entorno colaborativo. Wekan tiene una interfaz web totalmente receptiva y se traduce activamente en muchos idiomas.

Prerrequisitos

• Una instancia de servidor Vultr CentOS 7.
• Un usuario de sudo .

Para este tutorial, usaremos wekan.example.comcomo el nombre de dominio que apunta hacia la instancia de Vultr. Asegúrese de reemplazar todas las apariciones del nombre de dominio de ejemplo con el nombre real.

Actualice su sistema base utilizando la guía Cómo actualizar CentOS 7 . Una vez que su sistema ha sido actualizado, proceda a instalar las dependencias.

Instalar Node.js

Wekan solo es compatible Node.js LTS version 4.8. Para instalar Node.js, usaremos el administrador de versiones de nodo. Instale nvmejecutando el script de instalación.

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

Para comenzar a usarlo inmediatamente nvm, ejecute esto.

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

Si se nvmha instalado correctamente, entonces debería poder verificar su versión.

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

Instalar Node.js.

nvm install v4.8

Establecer la versión predeterminada de Node.js.

nvm use node

Si Node.js se ha instalado correctamente, entonces debería poder verificar su versión.

node -v

Verá esta salida.

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

NVM instala Node.js solo para el usuario actual. Para que Node.js sea accesible globalmente, ejecute esto.

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

Node.js ahora disponible como /bin/node.

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

Instalar MongoDB

MongoDB es un servidor de base de datos NoSQL gratuito y de código abierto. A diferencia de las bases de datos tradicionales que usan tablas para organizar sus datos, MongoDB está orientado a documentos y usa documentos similares a JSON sin esquemas. Wekan usa MongoDB para almacenar sus datos.

Wekan solo es compatible con MongoDB version 3.2. MongoDB no está disponible en el YUMrepositorio predeterminado , por lo que deberá crear un nuevo archivo de repositorio.

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

Rellene el archivo con el siguiente contenido.

[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

Instalar MongoDB.

sudo yum install -y mongodb-org

Inicie el servidor MongoDB y permita que se inicie automáticamente.

sudo systemctl start mongod
sudo systemctl enable mongod

Asegurar la instancia de MongoDB

Por defecto, no hay autenticación habilitada en un servidor MongoDB. Cualquier usuario que tenga acceso a la terminal del servidor tendrá todos los privilegios en la instalación de MongoDB. Para asegurar el servidor de la base de datos y restringir el acceso de un usuario sin privilegios, necesitaremos configurar la autenticación en el servidor.

MongoDB proporciona un mongoshell, que se utiliza para ejecutar consultas en MongoDB. Cambie al mongoshell escribiendo.

mongo

Cree un nuevo usuario de MongoDB con privilegios de root. Puede usar cualquier nombre de usuario de su elección. Asegúrate de reemplazar la contraseña .

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

Debería ver el siguiente resultado.

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

Salga de la interfaz de comando de MongoDB al terminal de Linux presionando " Ctrl+C".

Edite el archivo de configuración de MongoDB.

sudo nano /etc/mongod.conf

Agregue la siguiente línea al final del archivo.

security:
 authorization: enabled

Reinicie MongoDB para que el cambio de configuración surta efecto.

sudo systemctl restart mongod

Ahora que se ha habilitado la seguridad, puede probar si está funcionando cambiando al shell mongo nuevamente usando el mongocomando. Esta vez, si ejecuta una consulta, como show dbspara mostrar la lista de bases de datos, verá un mensaje que informa de una autorización fallida. sudoVuelva a salir al usuario después de probar el inicio de sesión como el nuevo usuario que acaba de crear.

Inicie sesión como el administratorusuario que acaba de crear.

mongo -u admin -p

Proporcione la contraseña del usuario para un inicio de sesión exitoso. Cree un nuevo usuario para la Wekanbase de datos que se utilizará para almacenar datos de Wekan.

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

Asegúrese de cambiar el StrongPasswordcon una contraseña segura . Verá el siguiente resultado.

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

Instalar Wekan

Verifique el último enlace al lanzamiento de Wekan en Github ya que los nuevos lanzamientos son muy frecuentes. Descargue la última versión de Wekan de Github reemplazando el enlace al paquete de instalación.

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

Extraiga el archivo descargado en un nuevo directorio llamado wekan.

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

Instalar Bzip2, que es necesario para extraer las dependencias de Node.js.

sudo yum -y install bzip2

Instale las dependencias de Node.js.

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

El servidor Wekan lee las configuraciones de las variables de entorno. Ejecute los siguientes comandos para establecer las configuraciones como variables de entorno.

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

Asegúrese de reemplazar la contraseña de MongoDB para el wekanusuario que ha creado. Además, actualice la URL del correo de acuerdo con la configuración de su servidor SMTP. Si no tiene un servidor de correo listo, siempre puede cambiar esta configuración más adelante. Abra el firewall para permitir el puerto a 4000través del firewall.

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

Para iniciar inmediatamente la aplicación.

cd ~/wekan/bundle
node main.js

Ahora puede acceder a la aplicación yendo a http://wekan.example.com:4000. Verá la interfaz para iniciar sesión en el tablero kanban de Wekan.

Para uso en producción, se recomienda configurar un proxy inverso para servir la aplicación en el HTTPpuerto estándar y un systemdservicio para administrar el proceso de la aplicación. En este tutorial, utilizaremos el servidor web Nginx como proxy inverso, asegurado con un SSL gratuito Let's Encrypt.

Configurar el proxy inverso de Nginx

Instale el servidor web Nginx y Certbot, que es la aplicación cliente para Let's Encrypt CA.

sudo yum -y install certbot nginx

Antes de que pueda solicitar los certificados SSL, deberá permitir el puerto 80y a 443través del firewall. Certbot verificará la autoridad del dominio antes de emitir certificados.

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

Ahora que estamos ejecutando Wekan en un HTTPSpuerto estándar , no necesitamos permitir el puerto a 4000través del firewall. Ajuste el firewall para eliminar el puerto 4000.

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

Nota: El nombre de dominio que está utilizando para obtener los certificados de Let's Encrypt CA debe apuntar hacia el servidor. El cliente verifica la autoridad del dominio antes de emitir los certificados .

Generar los certificados SSL.

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

Es probable que los certificados generados se almacenen en el /etc/letsencrypt/live/wekan.example.com/directorio. El certificado SSL se almacenará como fullchain.pemy la clave privada se almacenará como privkey.pem.

Encriptemos los certificados caducan en 90 días, por lo que se recomienda configurar la renovación automática de los certificados utilizando Cronjob. Cron es un servicio del sistema que se utiliza para ejecutar tareas periódicas.

Abra el archivo de trabajo cron.

sudo crontab -e

Agregue la siguiente línea al final del archivo.

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

El trabajo cron anterior se ejecutará todos los días a las 5:30 a.m. Si los certificados vencen, los renovará automáticamente.

Crea un nuevo host virtual.

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

Rellene el archivo con lo siguiente.

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

Reemplace wekan.example.comcon su nombre de dominio real en la configuración anterior.

Reinicie Nginx para que los cambios surtan efecto.

sudo systemctl restart nginx

Habilite Nginx para que se inicie automáticamente en el momento del arranque.

sudo systemctl enable nginx

Configurar el servicio Systemd

Crea un nuevo usuario para el proceso.

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

Ahora mueva todos los archivos al /opt/wekandirectorio.

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

Proporcione la propiedad de los archivos al usuario recién creado.

sudo chown -R wekan:wekan /opt/wekan

Wekan no toma datos de ningún archivo de configuración. En cambio, accede a él desde variables de entorno. Crearemos un nuevo archivo para almacenar las variables de entorno. El archivo que contiene las variables de entorno se pasará a través del Systemdservicio.

Cree un nuevo archivo para almacenar variables de entorno.

 sudo nano /opt/wekan/config.env

Rellene el archivo con el siguiente contenido.

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

Asegúrese de reemplazar el usernamey password.

Proporcionar la propiedad al wekanusuario.

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

Cree un nuevo archivo de servicio para el servicio systemd Wekan.

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

Rellene el archivo con lo siguiente.

[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

Guarde el archivo y salga del editor. Ahora puedes iniciar Wekan fácilmente.

sudo systemctl start wekan

Para permitir que Wekan se inicie automáticamente en el momento del arranque.

sudo systemctl enable wekan

Para verificar el estado del servicio de Wekan.

sudo systemctl status wekan

Terminando

Ahora puede acceder a la instancia de Wekan en https://wekan.example.com. Comience creando una nueva cuenta. Una vez que haya creado la cuenta, puede habilitar el acceso administrativo al usuario recién creado. Inicie sesión en el shell MongoDB como usuario administrativo.

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

Ahora seleccione la wekanbase de datos y actualice el objeto para promover el usuario al usuario administrador.

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

Asegúrese de reemplazar admin_usercon el nombre de usuario real del usuario que creó. Desde la interfaz de administración, podrá desactivar el autorregistro y actualizar la configuración de SMTP.

Felicitaciones, ha instalado con éxito la placa Wekan Kanban en su instancia de Vultr CentOS.