How to Install and Configure Taiga Project Management Tool on Ubuntu 16.04

Introduction

Taiga is a free and open-source project management system for Agile developers and designers and project managers who want a beautiful tool that makes work truly enjoyable. Taiga is a very powerful, easy to use and entirely customizable application that can handle both simple and complex projects for startups, software developers. Taiga backend is written in Python and Django that provides an API. The frontend is written in JavaScript using CoffeeScript and AngularJS frameworks.

In this tutorial, we will be going to explain how to install Taiga project management system on Ubuntu 16.04 server.

Requirements:

• A fresh Alibaba cloud instance with Ubuntu 16.04 server installed.

• A static IP address 192.168.0.103 is configured on the instance.

• A Root password is setup on the server.

Launch Alibaba Cloud ECS Instance

First, log in to your Alibaba Cloud ECS Console. Create a new ECS instance, choosing Ubuntu 16.04 as the operating system with at least 2GB RAM. Connect to your ECS instance and log in as the root user.

apt-get update -y

apt-get update -y

Install Required Dependencies

Before starting, you will need to install some dependencies required to compile Python modules. You can install all of them using the following command:

apt-get 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 -y

Taiga runs on the web server. So you will need to install NGINX web server to your system. You can install it using the following command:

apt-get install nginx -y

Once NGINX is installed, start NGINX service and enable it to start on boot using the following command:

systemctl start nginx
systemctl enable nginx

Nodejs is also required by Taiga-events. You can install the Nodejs using the following command:

curl -sL https://deb.nodesource.com/setup_6.x | sudo -E bash -
apt-get install nodejs pwgen npm -y

Taiga backend is written in Python and Django Framework that uses Python 3.5. So you will need to install Python 3.5 to your system. You can install it using the following command:

apt-get install python3 python3-pip python-dev python3-dev python-pip virtualenvwrapper libxml2-dev libxslt-dev -y

Next, you will need to install circus for managing the Taiga-events process created with CoffeeScript. You can install it using the following command:

apt-get install circus -y

Once circus is installed, start circusd service and enable it to start on boot using the following command:

systemctl start circusd
systemctl enable circusd

Install and Configure PostgreSQL Database

Taiga uses PostgreSQL to store its database. By default, PostgreSQL is not available in Ubuntu 16.04 default repository. So you will need to add the PostgreSQL repository into the system. You can do this using the following command:

echo "deb http://apt.postgresql.org/pub/repos/apt/ xenial-pgdg main" | tee /etc/apt/sources.list.d/pgdg.list
wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | apt-key add -

Next, update the repository and install PostgreSQL using the following command:

apt-get update -y
apt-get install postgresql -y

Next, start PostgreSQL service and enable it to start on boot using the following command:

systemctl start postgresql
systemctl enable postgresql

Next, log in to PostgreSQL user and create a database and user for Taiga:

su - postgres
createuser taiga 
psql
ALTER USER taiga WITH ENCRYPTED password 'password';
CREATE DATABASE taiga OWNER taiga;

Exit from the PostgreSQL shell:

\q

Install RabbitMQ

Taiga uses RabbitMQ to process the message queue. So you will need to install RabbitMQ to your server.

First, install Erlang libraries with the following command:

apt-get install erlang -y

Next, add the RabbitMQ repository and Import the RabbitMQ GPG signing key using the following command:

echo 'deb http://www.rabbitmq.com/debian/ stable main' | tee /etc/apt/sources.list.d/rabbitmq.list
wget -O- https://www.rabbitmq.com/rabbitmq-release-signing-key.asc | apt-key add -

Next, update the repository and install RabbitMQ using the following command:

apt-get update -y
apt-get install rabbitmq-server -y

Next, start RabbitMQ service and enable it to start on boot using the following command:

systemctl start rabbitmq-server
systemctl enable rabbitmq-server

Next, you will need to create a new user and virtual host named "taiga" for RabbitMQ:

rabbitmqctl add_user taiga password
rabbitmqctl add_vhost taiga
rabbitmqctl set_permissions -p taiga taiga ".*" ".*" ".*"

Configure Taiga Backend

Taiga-back is a backend of Taiga written in Python and Django Web Framework that provides an API.
First, create a new Taiga user and set the password with the following command:

adduser taiga

Next, log in to Taiga user and create a new directory to store the log files.

su - taiga
mkdir -p ~/logs

Next, clone the Taiga backend repository from GitHub and check out the latest stable branch.

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

You should see the following output:

Cloning into 'taiga-back'...
remote: Counting objects: 32790, done.
remote: Compressing objects: 100% (9/9), done.
remote: Total 32790 (delta 3), reused 13 (delta 3), pack-reused 32772
Receiving objects: 100% (32790/32790), 15.99 MiB | 393.00 KiB/s, done.
Resolving deltas: 100% (22346/22346), done.
Checking connectivity... done.

Next, change the directory to taiga-back and checkout stable repository:

cd taiga-back
checkout stable

Next, create a new Python environment taiga  using the virtualenv.

mkvirtualenv -p /usr/bin/python3 taiga

Next, log in to the new Taiga virtual environment and install all Python modules using the following command:

workon taiga
pip3 install --upgrade setuptools
pip3 install -r requirements.txt

Once all the required modules are installed, populate the database with necessary initial data using the following command:

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

The above command will create an administrator account "admin" with password "123123."

Next, you will need to create the configuration file for the Taiga backend. First, generate a random string of 64 characters with the following command:

pwgen -s -1 64

You should see the following output:

DYnT63VmANLGw8YN0IJcRXjz7DPWoXTArpaPDojFeSDcWTooVaD4Bmx9Ej8bvicz

Next, create a new configuration file for the Taiga Backend:

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

Add the following lines:

from .common import *

MEDIA_URL = "https://example.com/media/"
STATIC_URL = "https://example.com/static/"
SITES["front"]["scheme"] = "http"
SITES["front"]["domain"] = "example.com"
SECRET_KEY = "DYnT63VmANLGw8YN0IJcRXjz7DPWoXTArpaPDojFeSDcWTooVaD4Bmx9Ej8bvicz"
DEBUG = False
PUBLIC_REGISTER_ENABLED = True
DEFAULT_FROM_EMAIL = "mail@example.com"
SERVER_EMAIL = DEFAULT_FROM_EMAIL
EVENTS_PUSH_BACKEND = "taiga.events.backends.rabbitmq.EventsPushBackend"
EVENTS_PUSH_BACKEND_OPTIONS = {"url": "amqp://taiga:password@localhost:5672/taiga"}

Save and close the file, then test "taiga-back" with the following command:

workon taiga
python manage.py runserver

You should see the following output:

Trying import local.py settings...
Trying import local.py settings...
Performing system checks...

System check identified no issues (0 silenced).
May 17, 2018 - 14:37:22
Django version 1.11.2, using settings 'settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Now, open your web browser and type the URL "http://192.168.0.103:8000/api/v1/."
You should see the "taiga-back" API with JSON format in the following image:

Configure Taiga Frontend

First, log in to Taiga user and clone the Taiga frontend repository from Github and check out the latest stable branch.

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

Next, create a new configuration file for the Taiga frontend using the following command:

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

Add the following lines:

{
    "api": "https://example.com/api/v1/",
    "eventsUrl": "wss://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
}

Save and close the file when you are finished.

Configure Taiga Events

You will also need to configure Taiga Events to your server. Taiga events is a web socket server that enables the Taiga frontend to show real-time changes in modules.

First, log in to Taiga user and clone the Taiga events repository from Github:

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

Next, install all the dependencies needed by 'taiga-events' using npm and then install the 'coffee-script' package to the server:

npm install
npm install -g coffee-script

Next, create a new configuration file for Taiga events using the following command:

nano ~/taiga-events/config.json

Add the following lines:

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

Save and close the file when you are finished.

Configure Circus

Circus is a process manager for Python applications that can be used for controlling and managing "taiga-back" and "taiga-events" process. First, create a new Circus configuration file for running the Taiga backend.

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

Add the following lines:

[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

Save and close the file, then create a new file for taiga events:

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

Add the following lines:

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

Save the file, when you are finished.

Next, create a new logs directory for both "taiga-events" and "taiga-back" processes, then restart circusd  service using the following command:

su - taiga
mkdir -p ~/logs
exit
systemctl restart circusd

You can now check the status of circusd  using the following command:

circusctl status

You should see the following output:

circusd-stats: active
plugin:flapping: active
taiga: active
taiga-events: active

Configure NGINX for Taiga

Next, create a new NGINX virtual host directive for Taiga.

nano /etc/nginx/sites-available/taiga

Add the following lines:

server {
     listen 80 default_server;
     server_name _;

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

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

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

     # Django admin access (/admin/)
     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;
     }

     # Taiga-events
     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;
     }
 }

Save and close the file, then enable virtual host using the following command:

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

Finally, restart NGINX service with the following command:

systemctl restart nginx

That's it! Now you can access the Taiga installation by visiting the URL http://example.com.