Cómo instalar Taiga Project Management Tool en Ubuntu 16.04

• Prerrequisitos
• Instalar PostgreSQL
• Instalar Python
• Instalar RabbitMQ
• Instalar Nodejs
• Instalar el backend de Taiga
• Instalar Frontend
• Instalar Taiga Events
• Configurar circo
• Instalar Nginx como proxy inverso
• Conclusión

Taiga es una aplicación gratuita y de código abierto para la gestión de proyectos. A diferencia de otras herramientas de gestión de proyectos, Taiga utiliza un enfoque ágil incremental para gestionar el desarrollo del proyecto. Taiga es una aplicación muy potente y totalmente personalizable. El backend de Taiga está escrito en Python usando el marco Django. La interfaz está escrita en JavaScript utilizando los marcos de trabajo de CoffeeScript y AngularJS. Taiga incluye características tales como colaboración de proyectos, tablero Kanban, seguimiento de errores, informes, seguimiento de tiempo, retrasos, wiki y más.

Prerrequisitos

• Una instancia de servidor Vultr Ubuntu 16.04 con al menos 1 GB de RAM.
• Un usuario de sudo .

En este tutorial, usaremos taiga.example.comcomo el nombre de dominio señalado al servidor. Reemplace todas las apariciones de taiga.example.comcon su nombre de dominio real.

Actualice su sistema base utilizando la guía Cómo actualizar Ubuntu 16.04 . Una vez que su sistema ha sido actualizado, proceda a instalar PostgreSQL.

Instalar PostgreSQL

PostgreSQL es un sistema de base de datos relacional de objetos y conocido por su estabilidad y velocidad. Taiga usa PostgreSQL para almacenar su base de datos. Agregue el repositorio PostgreSQL en el sistema.

echo "deb http://apt.postgresql.org/pub/repos/apt/ xenial-pgdg main" | sudo tee /etc/apt/sources.list.d/pgdg.list

Importe la clave de firma GPG y actualice las listas de paquetes.

wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
sudo apt update

Instale el servidor de base de datos PostgreSQL.

sudo apt -y install postgresql

Inicie el servidor PostgreSQL y permita que se inicie automáticamente en el momento del arranque.

sudo systemctl start postgresql
sudo systemctl enable postgresql

Cambie la contraseña para el usuario predeterminado de PostgreSQL.

sudo passwd postgres

Inicie sesión como usuario de PostgreSQL.

sudo su - postgres

Cree un nuevo usuario de PostgreSQL para Taiga.

createuser taiga 

PostgreSQL proporciona el psqlshell para ejecutar consultas en la base de datos. Cambie al shell PostgreSQL.

psql

Establezca una contraseña para el usuario recién creado para la base de datos Taiga.

ALTER USER taiga WITH ENCRYPTED password 'DBPassword';

Reemplazar DBPasswordcon una contraseña segura. Cree una nueva base de datos para la instalación de Taiga.

CREATE DATABASE taiga OWNER taiga;

Salga de la psqlcáscara.

\q

Cambiar al sudousuario.

exit

Instalar Python

Taiga requiere Python versión 3.4 o posterior y Python 3.5 viene preinstalado en la distribución Ubuntu 16.04. Instale algunos paquetes más necesarios.

sudo apt -y install python3 python3-pip python3-dev python3-dev virtualenvwrapper

El entorno virtual de Python se usa para crear un entorno virtual aislado para un proyecto de Python. Un entorno virtual contiene sus propios directorios de instalación y no comparte bibliotecas con entornos virtuales globales y de otro tipo. Una vez que Python 3 se haya instalado correctamente, debería poder verificar su versión.

python3 -V

Verás lo siguiente.

user@vultr:~$ python3 -V
Python 3.5.2

Actualización pip, que es una aplicación de administrador de dependencias.

sudo pip3 install --upgrade setuptools pip 

Además, instale algunas herramientas de compilación que serán necesarias más adelante para compilar las dependencias.

sudo apt -y install build-essential binutils-doc autoconf flex bison libjpeg-dev libfreetype6-dev zlib1g-dev libzmq3-dev libgdbm-dev libncurses5-dev automake libtool libffi-dev curl git tmux gettext

Instalar RabbitMQ

Taiga usa RabbitMQ para procesar la cola de mensajes. RabbitMQ requiere que las bibliotecas Erlang funcionen. Instala Erlang.

sudo apt -y install erlang

Agregue el repositorio RabbitMQ.

echo 'deb http://www.rabbitmq.com/debian/ stable main' | sudo tee /etc/apt/sources.list.d/rabbitmq.list

Importe la clave de firma RabbitMQ GPG.

wget -O- https://www.rabbitmq.com/rabbitmq-release-signing-key.asc | sudo apt-key add -

Actualice la información del repositorio.

sudo apt update

Instala RabbitMQ.

sudo apt -y install rabbitmq-server

Inicie y habilite el servidor RabbitMQ.

sudo systemctl start rabbitmq-server
sudo systemctl enable rabbitmq-server

Agregue un usuario RabbitMQ y vhost. Además, otorgue permiso al usuario sobre el host.

sudo rabbitmqctl add_user taiga StrongMQPassword
sudo rabbitmqctl add_vhost taiga
sudo rabbitmqctl set_permissions -p taiga taiga ".*" ".*" ".*"

Asegúrese de reemplazar StrongMQPasswordcon una contraseña segura.

Instalar Nodejs

Se requiere Node.js versión 7 o posterior para compilar la interfaz de Taiga. Agregue el repositorio Node.js versión 8.

curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -

Instale Node.js y la pwgenutilidad.

sudo apt install -y nodejs pwgen npm

pwgense usará más tarde para generar una cadena secreta fuerte. Instale CoffeeScript, ya que se utilizará para compilar archivos Taiga escritos en el marco de CoffeeScript.

sudo npm install -g coffee-script gulp

Instalar el backend de Taiga

Agregue un nuevo usuario del sistema para Taiga para asegurarse de que los procesos de Taiga se ejecuten como un usuario sin privilegios.

sudo adduser taiga
sudo su - taiga

Nota : De ahora en adelante, todos los comandos deben ejecutarse como usuario sin privilegios taigahasta que se le solicite que vuelva a cambiar de sudousuario.

Cree un nuevo directorio para almacenar los archivos de registro.

mkdir -p ~/logs

Clone el repositorio backend Taiga de GitHub y compruebe la última rama estable.

git clone https://github.com/taigaio/taiga-back.git taiga-back
cd taiga-back
git checkout stable

Ahora cree un nuevo entorno virtual para Taiga usando Python 3.

mkvirtualenv -p /usr/bin/python3 taiga
pip3 install --upgrade setuptools

Instale las dependencias de Python requeridas usando pip.

pip3 install -r requirements.txt

Rellene la base de datos con los datos iniciales necesarios.

python3 manage.py migrate --noinput
python3 manage.py loaddata initial_user
python3 manage.py loaddata initial_project_templates
python3 manage.py compilemessages
python3 manage.py collectstatic --noinput

Los comandos anteriores escribirán datos en la base de datos PostgreSQL. Taiga también envía algunos datos de demostración o muestra que pueden ser útiles para evaluar el producto. Si desea instalar los datos de muestra, ejecute lo siguiente.

python3 manage.py sample_data

Nota : La instalación de datos de muestra es opcional y está destinada únicamente a evaluar el producto.

Antes de proceder a crear el archivo de configuración para el backend de Taiga, necesitamos generar una cadena secreta. Esta cadena se usará para cifrar los datos de la sesión.

Genere una cadena aleatoria de 64 caracteres.

pwgen -s -1 64

Debería ver la salida como una cadena aleatoria.

(taiga) taiga@vultr:~/taiga-back$ pwgen -s -1 64
fhDfyYVJ4EH3tvAyUzmfWSeCXuf5sy5EEWrMQPaf9t3JSFrpiL6yvUEOWsFOTscP

Cree un nuevo archivo de configuración para Taiga Backend.

nano ~/taiga-back/settings/local.py

Rellene el archivo con el siguiente código.

from .common import *

MEDIA_URL = "https://taiga.example.com/media/"
STATIC_URL = "https://taiga.example.com/static/"
SITES["front"]["scheme"] = "https"
SITES["front"]["domain"] = "taiga.example.com"

SECRET_KEY = "Generated_Secret_Key"

DEBUG = False
PUBLIC_REGISTER_ENABLED = True

DEFAULT_FROM_EMAIL = "mail@example.com"
SERVER_EMAIL = DEFAULT_FROM_EMAIL

#CELERY_ENABLED = True

EVENTS_PUSH_BACKEND = "taiga.events.backends.rabbitmq.EventsPushBackend"
EVENTS_PUSH_BACKEND_OPTIONS = {"url": "amqp://taiga:StrongMQPassword@localhost:5672/taiga"}

# Uncomment and populate with proper connection parameters
# for enable email sending. EMAIL_HOST_USER should end by @domain.tld
#EMAIL_BACKEND = "django.core.mail.backends.smtp.EmailBackend"
#EMAIL_USE_TLS = False
#EMAIL_HOST = "mail.example.com"
#EMAIL_HOST_USER = "mail@example.com"
#EMAIL_HOST_PASSWORD = "SMTPPassword"
#EMAIL_PORT = 25

# Uncomment and populate with proper connection parameters
# for enable github login/singin.
#GITHUB_API_CLIENT_ID = "yourgithubclientid"
#GITHUB_API_CLIENT_SECRET = "yourgithubclientsecret"

Asegúrese de reemplazar el example domain namecon el actual en el código anterior. Además, reemplace Generated_Secret_Keycon la clave secreta real y StrongMQPasswordcon la contraseña real para el usuario de la cola de mensajes de Taiga. Si tiene un servidor SMTP listo y desea utilizar las funciones de envío de correo electrónico de inmediato, puede descomentar las opciones de correo electrónico y establecer el valor apropiado. Si no tiene un servidor de correo listo, puede omitir la configuración de la función de correo electrónico por ahora y configurarla más adelante en este archivo de configuración.

Si desea habilitar el inicio de sesión de GitHub, cree una aplicación en GitHub y proporcione el ID de cliente API y el secreto del cliente.

Para verificar de inmediato si se puede iniciar el backend de Taiga, ejecute el servidor Django incorporado.

workon taiga
python manage.py runserver

Verá el siguiente resultado si el servidor se ha iniciado correctamente.

(taiga) taiga@vultr:~/taiga-back$ workon taiga
(taiga) taiga@vultr:~/taiga-back$ python manage.py runserver
Trying import local.py settings...
Trying import local.py settings...
Performing system checks...

System check identified no issues (0 silenced).
October 28, 2017 - 10:29:38
Django version 1.10.6, using settings 'settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Para verificar si se puede acceder a la API, abra otra sesión de terminal y ejecute lo siguiente.

curl http://127.0.0.1:8000/api/v1/

Verá un resultado similar devuelto por la llamada API.

user@vultr:~$ curl http://127.0.0.1:8000/api/v1/
{"webhooks": "http://127.0.0.1:8000/api/v1/webhooks", "invitations": "http://127.0.0.1:8000/api/v1/invitations", "severities": "http://127.0.0.1:8000/api/v1/severities", "memberships": "http://127.0.0.1:8000/api/v1/memberships", "user-storage": "http://127.0.0.1:8000/api/v1/user-storage", "epics/(?P<resource_id>\\d+)/voters": "http://127.0.0.1:8000/api/v1/epics/(?P<resource_id>\\d+)/voters", "wiki": "http://127.0.0.1:8000/api/v1/wiki", "priorities": "http://127.0.0.1:8000/api/v1/priorities", "userstories/attachments": "http://127.0.0.1:8000/api/v1/userstories/attachments", "epics/(?P<epic>[^/.]+)/related_userstories": "http://127.0.0.1:8000/api/v1/epics/(?P<epic>[^/.]+)/related_userstories", "timeline/user": "http://127.0.0.1:8000/api/v1/timeline/user", "userstories/(?P<resource_id>\\d+)/voters": "http://127.0.0.1:8000/api/v1/userstories/(?P<resource_id>\\d+)/voters", "wiki-links": "http://127.0.0.1:8000/api/v1/wiki-links", "epics/attachments": "http://127.0.0.1:8000/api/v1/epics/attachments", "issues/custom-attributes-values": "http://127.0.0.1:8000/api/v1/issues/custom-attributes-values

Detenga el servidor de back-end Taiga presionando " ctrl + C" y desactive el entorno virtual.

deactivate

Instalar Frontend

La interfaz de Taiga es el componente de Taiga que sirve a la interfaz de usuario web. Clone el repositorio frontend Taiga de Github y compruebe la última rama estable.

cd ~
git clone https://github.com/taigaio/taiga-front-dist.git taiga-front-dist
cd taiga-front-dist
git checkout stable

Cree un nuevo archivo de configuración para la interfaz de Taiga.

nano ~/taiga-front-dist/dist/conf.json

Rellene el archivo.

{
    "api": "https://taiga.example.com/api/v1/",
    "eventsUrl": "wss://taiga.example.com/events",
    "eventsMaxMissedHeartbeats": 5,
    "eventsHeartbeatIntervalTime": 60000,
    "eventsReconnectTryInterval": 10000,
    "debug": true,
    "debugInfo": false,
    "defaultLanguage": "en",
    "themes": ["taiga"],
    "defaultTheme": "taiga",
    "publicRegisterEnabled": true,
    "feedbackEnabled": true,
    "privacyPolicyUrl": null,
    "termsOfServiceUrl": null,
    "maxUploadFileSize": null,
    "contribPlugins": [],
    "tribeHost": null,
    "importers": [],
    "gravatar": true
}

Asegúrese de reemplazar el example domaincon el dominio real. También puede cambiar el idioma predeterminado y otros parámetros en la configuración anterior.

Instalar Taiga Events

Además del frontend y el backend, también necesitamos instalar eventos Taiga. Taiga events es un servidor de socket web, y permite que la interfaz de Taiga muestre cambios en tiempo real en módulos como backlog, Kanban y más. También utiliza el servidor RabbitMQ para el procesamiento de mensajes.

Clonar el repositorio de eventos Taiga de Github.

cd ~
git clone https://github.com/taigaio/taiga-events.git taiga-events
cd taiga-events

Instale las dependencias de Node.js usando npm.

npm install

Cree un nuevo archivo de configuración para los eventos de Taiga.

nano ~/taiga-events/config.json

Rellene el archivo.

{
    "url": "amqp://taiga:StrongMQPassword@localhost:5672/taiga",
    "secret": "Generated_Secret_Key",
    "webSocketServer": {
        "port": 8888
    }
}

Reemplácelo Generated_Secret_Keycon la clave secreta de 64 caracteres que ha generado previamente. La clave secreta debe ser exactamente la misma que la que proporcionó en el archivo de configuración del backend de Taiga. Además, actualice StrongMQPasswordcon la contraseña real para el usuario de la cola de mensajes de Taiga.

Configurar circo

Circus es un administrador de procesos para aplicaciones Python. Usaremos Circus para ejecutar el backend y eventos de Taiga.

Cambiar de nuevo al sudousuario.

exit

Nota : A partir de ahora, deberá ejecutar los comandos con el sudousuario.

sudo apt -y install circus

Cree un nuevo archivo de configuración de Circus para ejecutar el backend Taiga.

sudo nano /etc/circus/conf.d/taiga.ini

Rellene el archivo.

[watcher:taiga]
working_dir = /home/taiga/taiga-back
cmd = gunicorn
args = -w 3 -t 60 --pythonpath=. -b 127.0.0.1:8001 taiga.wsgi
uid = taiga
numprocesses = 1
autostart = true
send_hup = true
stdout_stream.class = FileStream
stdout_stream.filename = /home/taiga/logs/gunicorn.stdout.log
stdout_stream.max_bytes = 10485760
stdout_stream.backup_count = 4
stderr_stream.class = FileStream
stderr_stream.filename = /home/taiga/logs/gunicorn.stderr.log
stderr_stream.max_bytes = 10485760
stderr_stream.backup_count = 4

[env:taiga]
PATH = /home/taiga/.virtualenvs/taiga/bin:$PATH
TERM=rxvt-256color
SHELL=/bin/bash
USER=taiga
LANG=en_US.UTF-8
HOME=/home/taiga
PYTHONPATH=/home/taiga/.virtualenvs/taiga/lib/python3.5/site-packages

Cree una nueva configuración de Circus para ejecutar Taiga Events.

sudo nano /etc/circus/conf.d/taiga-events.ini

Rellene el archivo.

[watcher:taiga-events]
working_dir = /home/taiga/taiga-events
cmd = /usr/local/bin/coffee
args = index.coffee
uid = taiga
numprocesses = 1
autostart = true
send_hup = true
stdout_stream.class = FileStream
stdout_stream.filename = /home/taiga/logs/taigaevents.stdout.log
stdout_stream.max_bytes = 10485760
stdout_stream.backup_count = 12
stderr_stream.class = FileStream
stderr_stream.filename = /home/taiga/logs/taigaevents.stderr.log
stderr_stream.max_bytes = 10485760
stderr_stream.backup_count = 12

Reinicie Circus y permita que comience automáticamente en el momento del arranque.

sudo systemctl restart circusd
sudo systemctl enable circusd

Verifique el estado de Circus.

circusctl status

Si Circus ha iniciado todos los procesos de Taiga correctamente, verá el siguiente resultado.

user@vultr:~$ circusctl status
circusd-stats: active
plugin:flapping: active
taiga: active
taiga-events: active

Si ve que alguno de los procesos no está activo, ejecute sudo chmod -R 777 /home/taiga/logsy reinicie Circus. Verifique nuevamente el estado de los procesos de Circus, esta vez definitivamente encontrará el servicio en ejecución.

Ahora, tenemos Taiga instalada y funcionando con éxito. Antes de poder usarlo, necesitamos exponer la instalación usando cualquier servidor web de producción.

Instalar Nginx como proxy inverso

Usaremos Nginx como proxy inverso para servir la aplicación a los usuarios. También obtendremos e instalaremos certificados SSL de Let's Encrypt.

Certbot es el cliente oficial de emisión de certificados para Let's Encrypt CA. Agregue el repositorio Certbot PPA al sistema.

sudo add-apt-repository ppa:certbot/certbot
sudo apt update

Instala Nginx y Certbot.

sudo apt -y install nginx certbot

Nota : Para obtener certificados de Let's Encrypt CA, debe asegurarse de que el dominio para el que desea generar los certificados apunte hacia el servidor. De lo contrario, realice los cambios necesarios en los registros DNS de su dominio y espere a que se propague el DNS antes de volver a solicitar el certificado. Certbot verifica la autoridad del dominio antes de proporcionar los certificados.

Ahora use el servidor web incorporado en Certbot para generar los certificados para su dominio.

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

Es probable que los certificados generados se almacenen en el /etc/letsencrypt/live/taiga.example.com/directorio. El certificado SSL se conservará como fullchain.pem, y la clave privada se guardará como privkey.pem.

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

Abra el archivo de trabajo cron.

sudo crontab -e

Agrega la siguiente línea.

0 0 * * * /usr/bin/certbot renew --quiet

El trabajo cron anterior se ejecutará diariamente a medianoche. Si el certificado vence, vencerá automáticamente los certificados.

Genere un fuerte parámetro Diffie-Hellman. Proporciona una capa adicional de seguridad para el intercambio de datos entre el host y el servidor.

sudo openssl dhparam -out /etc/ssl/dhparam.pem 2048 

Cree un nuevo bloque de servidor Nginx para servir a la interfaz de Taiga.

sudo nano /etc/nginx/sites-available/taiga

Rellene el archivo con lo siguiente.

server {
    listen 80;
    server_name taiga.example.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl;
    server_name taiga.example.com;

    access_log /home/taiga/logs/nginx.access.log;
    error_log /home/taiga/logs/nginx.error.log;

    large_client_header_buffers 4 32k;
    client_max_body_size 50M;
    charset utf-8;

    index index.html;

    # Frontend
    location / {
        root /home/taiga/taiga-front-dist/dist/;
        try_files $uri $uri/ /index.html;
    }

    # Backend
    location /api {
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Scheme $scheme;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_pass http://127.0.0.1:8001/api;
        proxy_redirect off;
    }

    location /admin {
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Scheme $scheme;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_pass http://127.0.0.1:8001$request_uri;
        proxy_redirect off;
    }

    # Static files
    location /static {
        alias /home/taiga/taiga-back/static;
    }

    # Media files
    location /media {
        alias /home/taiga/taiga-back/media;
    }

     location /events {
        proxy_pass http://127.0.0.1:8888/events;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_connect_timeout 7d;
        proxy_send_timeout 7d;
        proxy_read_timeout 7d;
    }

    add_header Strict-Transport-Security "max-age=63072000; includeSubdomains; preload";
    add_header Public-Key-Pins 'pin-sha256="klO23nT2ehFDXCfx3eHTDRESMz3asj1muO+4aIdjiuY="; pin-sha256="633lt352PKRXbOwf4xSEa1M517scpD3l5f79xMD9r9Q="; max-age=2592000; includeSubDomains';

    ssl on;
    ssl_certificate /etc/letsencrypt/live/taiga.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/taiga.example.com/privkey.pem;
    ssl_session_timeout 5m;
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    ssl_prefer_server_ciphers on;
    ssl_ciphers 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!3DES:!MD5:!PSK';
    ssl_session_cache shared:SSL:10m;
    ssl_dhparam /etc/ssl/dhparam.pem;
    ssl_stapling on;
    ssl_stapling_verify on;

}

Asegúrese de cambiar el domain namey el path to the SSL certificates. Habilitar el host virtual.

sudo ln -s /etc/nginx/sites-available/taiga /etc/nginx/sites-enabled/taiga

Ahora puede reiniciar el servidor web Nginx y habilitarlo para que se inicie automáticamente en el arranque.

sudo systemctl restart nginx
sudo systemctl status nginx

Finalmente, arregle la propiedad y el permiso en los archivos de Taiga.

sudo chown -R taiga:taiga /home/taiga/
sudo chmod o+x /home/taiga/

Conclusión

Ahora puede acceder a la instalación de Taiga yendo a https://taiga.example.com. Inicie sesión con la cuenta de administrador inicial con nombre de usuario " admin" y contraseña " 123123". Su instalación ya está lista para su uso en producción. Comience creando un nuevo proyecto o evaluando el producto. Si ya está administrando un proyecto en Github, Jira o Trello, puede importar fácilmente los proyectos a Taiga utilizando los importadores .