Installation and Configuration of the Taiga Project Management System

Organizing means first to evaluate the opportunity, and only then to set the task...

— Unknown author

The art of organizing work and monitoring its performance in modern society is an integral part of successful business. It always starts small. At first, you are working on some project - everything is easy, there is only one task and you perform it. It is enough to keep this task in your memory. But every day there are subtasks, added notes, this is where comes the realization that everything is no longer possible to memorize. You can do with a daily planner here. The number of tasks is growing and you realize that it is impossible to complete the project entirely on your own. Then you have subordinates, you assign them part of the tasks, but how to monitor the performance? How to reassign tasks? The daily planner clearly would not do in this case.

Throughout the history of mankind, many projects have been executed from the simplest to incredibly complex. Various project management systems for goal achievement and management organization have been developed, each has its own advantages and disadvantages, but unfortunately, we will not review them, since they would be a large separate topic for us.

In the modern world, various software has been developed to fortify project management, making it more convinient. There are quite a lot of them, but today we will consider the decent software of Taiga project management system, which employs Agile methodologies families Scrum and Kanban. This software is mainly used by developers and designers. Unfortunately, even considering that the project is free, there is very little information about this software in the Russian segment of the Internet. Therefore, we, the Syncweb team, hoping to simplify the entry threshold to start using this project.

Checking the Requirements

First we will check the necessary minimum requirements for

  • you need root access;
  • Python of version 3.4 or higher;
  • PostgreSQL DBMS of version 9.4 or higher;
  • RabbitMQ;
  • at least 0.75 GB of RAM (required to install lxml), just in case we will use 1GB.
  • During installation, you will need: Ruby of version 2.1 or higher and NodeJS of version 7.0 or higher.

For more information, please refer to the official website.

In general, you can install in several ways, but we are not looking for easy way and will do it manually. As an operating system (OS) we will use Ubuntu 18.04.

During the installation, you will need to modify or create quite a few files, and each installation must have its own settings. We will enclose such settings in brackets and title in English with explanations like example -.​

Also we will often use console text editor vi, you can use any other. To enter text insertion mode, press i and start typing. And to save the changes and close the file, first press Esc, then :wq.

Installing Required Packages

To begin with, we will install several convenient packages:

# apt update
# apt install -y mc net-tools

Let's create the supp user:

# adduser supp

And allow access via sudo:

# adduser supp
Adding user `supp' to group `sudo' ...
Adding user supp to group sudo

Then edit the /etc/ssh/sshd_config file

Uncomment the line

PermitRootLogin no

And add

AllowUsers supp

Now restart the SSH daemon:

# systemctl restart sshd

Let's log in under the supp user. Pre-install the required packages:

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

Ngix Installation

Next, you need to install Nginx, the official repository has version 1.14, so we will use the instructions from the official website.

First, install the necessary packages to connect the repository:

$ sudo apt install -y curl gnupg2 ca-certificates lsb-release

Now connect the repository of stable version:

$ echo "deb `lsb_release -cs` nginx" | sudo tee /etc/apt/sources.list.d/nginx.list

Import the key for authentication of packages:

$ curl -fsSL | sudo apt-key add -

And now let's set:

$ sudo apt update
$ sudo apt install nginx

Instructions for installation on your own can be found on the official Nginx page.

Then install RabbitMQ and Redis:

$ sudo apt install -y rabbitmq-server redis-server

PostgreSQL Installation

Now install PostgreSQL DBMS, but the current version in repository is 10, and the official latest version is 11.3. If you look at the performance tests of different versions of PostgreSQL, for example, on the Habr website, you can see the performance improvements of newer versions compared to older ones. Therefore, we will install from the official website, using the instructions.

To begin with, add a repository:

$ echo "deb bionic-pgdg main" | sudo tee /etc/apt/sources.list.d/pgdg.list

Import the package authentication key:

$ wget --quiet -O - | sudo apt-key add -
$ sudo apt update

Continuing installation:

$ sudo apt install -y postgresql-11 postgresql-contrib-11
$ sudo apt install -y postgresql-doc-11 postgresql-server-dev-11
$ sudo apt install -y python3 python3-pip python3-dev virtualenvwrapper
$ sudo apt install -y libxml2-dev libxslt-dev
$ sudo apt install -y libssl-dev libffi-dev

Now, before further actions, restart the server:

$ sudo shutdown -r now 

After restarting the server, log in under our supp user and create a taiga user:

$ sudo adduser taiga
$ sudo adduser taiga sudo
$ sudo su taiga
$ cd ~

ATTENTION! Further actions must be performed under Taiga user

Initialize PostgreSQL DBMS setup:

$ sudo -u postgres createuser taiga
$ sudo -u postgres createdb taiga -O taiga --encoding='utf-8' --locale=en_US.utf8 --template=template0

Now let's make settings for RabbitMQ, where {YOUR_PASSWORD_EVENTS} is the RabbitMQ password, which will be used in the configuration files below.

$ sudo rabbitmqctl add_user taiga {YOUR_PASSWORD_EVENTS}
Creating user "taiga"
$ sudo rabbitmqctl add_vhost taiga
Creating vhost "taiga"
$ sudo rabbitmqctl set_permissions -p taiga taiga ".*" ".*" ".*"
Setting permissions for user "taiga" in vhost "taiga"

BACKEND Installation

Now let's make settings for RabbitMQ, where {YOUR_PASSWORD_EVENTS} is the RabbitMQ password, which will be used in the configuration files below.

$ cd ~
$ git clone taiga-back
$ cd taiga-back
$ git checkout stable
Branch 'stable' set up to track remote branch 'stable' from 'origin'.
Switched to a new branch 'stable'

Create virtualenv taiga:

$ mkvirtualenv -p /usr/bin/python3 taiga
Already using interpreter /usr/bin/python3
Using base prefix '/usr'
New python executable in /home/taiga/.virtualenvs/taiga/bin/python3
Also creating executable in /home/taiga/.virtualenvs/taiga/bin/python
Installing setuptools, pkg_resources, pip, wheel...done.

And install the necessary packages:

$ pip install -r requirements.txt

Now initialize the database:

$ python migrate --noinput
$ python loaddata initial_user
$ python loaddata initial_project_templates
$ python compilemessages
$ python collectstatic --noinput

After these steps, an admin user with 123123 password is created. You need to remember these, as you will enter these data at the initial authorization in the web-interface.

To create a non-empty database, for example, to see how to create and work with or to demonstrate the work, enter the command

$ python sample_data

To complete backend configuration, create ~/taiga-back/settings/ settings file with the following contents, where:

  • {YOUR_DOMAIN} is your domain, for example,;
  • {YOUR_SECRET_KEY} is the secret key, the more complex and longer - the better, it will be used when configuring the (EVENTS) file coming up next;
  • {YOUR_PASSWORD_EVENTS} is the password for push events, which was prescribed when configuring RabbitMQ;
  • {YOUR_GOOGLE_EMAIL} is your Google Email, because in this example we use settings from Gmail;
  • {YOUR_PASSWORD_EMAIL} is the password for Email.

Also, please pay attention to the HTTPS protocol

$ vi ~/taiga-back/settings/
from .common import *
MEDIA_URL = "https://{YOUR_DOMAIN}/media/"
STATIC_URL = "https://{YOUR_DOMAIN}/static/"
SITES["front"]["scheme"] = "https"
SITES["front"]["domain"] = "{YOUR_DOMAIN}"
DEBUG = False
EVENTS_PUSH_BACKEND_OPTIONS = {"url": "amqp://taiga:{YOUR_PASSWORD_EVENTS}@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"
# Uncomment and populate with proper connection parameters
# for enable github login/singin.
#GITHUB_API_CLIENT_ID = "yourgithubclientid"
#GITHUB_API_CLIENT_SECRET = "yourgithubclientsecret"

Now all that is left is to run the backend and check:

$ workon taiga
$ python runserver
Trying import settings...
Trying import settings...
Performing system checks...
System check identified no issues (0 silenced).
May 14, 2019 - 23:16:15
Django version 1.11.20, using settings 'settings'
Starting development server at
Quit the server with CONTROL-C.

FRONTEND Installation

Now let's proceed with the frontend installation.

$ cd ~
$ git clone taiga-front-dist
$ cd taiga-front-dist
$ git checkout stable

Then copy the example configuration file:

$ cp ~/taiga-front-dist/dist/conf.example.json ~/taiga-front-dist/dist/conf.json

And change the contents of the file according to the example below, where:

  • {YOUR_DOMAIN} is your domain, for example,;
  • defaultLanguage: ru parameter determines the default language;
  • publicRegisterEnabled: true parameter is responsible for the possibility of free registration on the main page, if you do not need anyone to register - set the value to false:
$ sudo vi ~/taiga-front-dist/dist/conf.json
    "api": "https://{YOUR_DOMAIN}/api/v1/",
    "eventsUrl": "wss://{YOUR_DOMAIN}/events",
    "eventsMaxMissedHeartbeats": 5,
    "eventsHeartbeatIntervalTime": 60000,
    "eventsReconnectTryInterval": 10000,
    "debug": false,
    "debugInfo": false,
    "defaultLanguage": "ru",
    "themes": ["taiga"],
    "defaultTheme": "taiga",
    "publicRegisterEnabled": true,
    "feedbackEnabled": true,
    "supportUrl": "",
    "privacyPolicyUrl": null,
    "termsOfServiceUrl": null,
    "GDPRUrl": null,
    "maxUploadFileSize": null,
    "contribPlugins": [],
    "tribeHost": null,
    "importers": [],
    "gravatar": true,
    "rtlLanguages": ["fa"]

EVENTS Installation

Installation is a little complicated, but we chose such path! Now let's set up events:

$ cd ~
$ git clone taiga-events
$ cd taiga-events

Now set nodejs:

$ curl -sL | sudo -E bash -
$ sudo apt install -y nodejs

Let's also set javascript dependencies:

$ npm install

Now configure the configuration event file, making a copy of it in advance:

$ cp config.example.json config.json

The approximate contents of the file will be as follows, where:

  • {YOUR_PASSWORD_EVENTS} - is the password created when configuring RabbitMQ;
  • {YOUR_SECRET_KEY} - is the key used in the configuration file when configuring backend:
$ sudo vi ./config.json
    "url": "amqp://taiga:{YOUR_PASSWORD_EVENTS}@localhost:5672/taiga",
    "secret": "{YOUR_SECRET_KEY}",
    "webSocketServer": {
        "port": 8888

Now you need to add events as a service. To do this, create a file and make it similar to the code below:

$ sudo vi ./config.json
ExecStart=/bin/bash -c "node_modules/coffeescript/bin/coffee"

It remains to add the service to autorun and run it:

$ sudo systemctl daemon-reload
$ sudo systemctl start taiga_events
$ sudo systemctl enable taiga_events

We handled the event service, but now we need to do the same for backend. So again create a file with the following content:

$ sudo vi /etc/systemd/system/taiga.service
ExecStart=/home/taiga/.virtualenvs/taiga/bin/gunicorn --workers 4 --timeout 60 -b taiga.wsgi

Now launch a new taiga service and add to autorun:

$ sudo systemctl daemon-reload
$ sudo systemctl start taiga
$ sudo systemctl enable taiga

Now check if the service has started successfully:

$ sudo systemctl status taiga
* taiga.service - taiga_back
 Loaded: loaded (/etc/systemd/system/taiga.service; enabled; vendor preset: en
 Active: active (running) since Fri 2019-05-17 04:09:22 +05; 3min 8s ago
Main PID: 15247 (gunicorn)
  Tasks: 5 (limit: 1131)
 CGroup: /system.slice/taiga.service
     |-15247 /home/taiga/.virtualenvs/taiga/bin/python3 /home/taiga/.virtu
     |-15251 /home/taiga/.virtualenvs/taiga/bin/python3 /home/taiga/.virtu
     |-15252 /home/taiga/.virtualenvs/taiga/bin/python3 /home/taiga/.virtu
     |-15253 /home/taiga/.virtualenvs/taiga/bin/python3 /home/taiga/.virtu
     `-15254 /home/taiga/.virtualenvs/taiga/bin/python3 /home/taiga/.virtu

Let's get together, there are the last touches remaining. Final Nginx configuration touches. First, delete the default configuration:

$ sudo rm /etc/nginx/conf.d/default.conf

or in some cases, the default configuration file may be somewhere else:

$ sudo rm /etc/nginx/sites-enabled/default

Create a folder for logs:

$ mkdir -p ~/logs

Installing Let's Encrypt Certificates

We will use HTTPS to improve the security of our website. Learn more about SSL certificates from our article. So, let's use free Let's Encrypt certificates and Certbot client

$ sudo apt update
$ sudo apt install -y software-properties-common
$ sudo add-apt-repository universe
$ sudo add-apt-repository ppa:certbot/certbot
$ sudo apt update
$ sudo apt install -y certbot python-certbot-nginx

Now you can issue a certificate where: {YOUR_DOMAIN} is your domain, for example,;

$ sudo certbot --nginx certonly -d {YOUR_DOMAIN}

Now create a DH (Diffie Hellman) key:

$ cd /etc/ssl
$ sudo openssl dhparam -out dhparam.pem 4096

For installation on your own, you can use the instructions from the official website of Certbot.

$ sudo vi /etc/nginx/conf.d/taiga.conf
server {
    listen 80 default_server;
    server_name _;
    return 301 https://$server_name$request_uri;
server {
    listen 443 ssl default_server;
    server_name {YOUR_DOMAIN};
    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;
    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_redirect off;
    # 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_redirect off;
    # Static files
    location /static {
        alias /home/taiga/taiga-back/static;
    # Media files
    location /media {
        alias /home/taiga/taiga-back/media;
    # Events
        location /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";
    ssl_certificate /etc/letsencrypt/live/{YOUR_DOMAIN}/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/{YOUR_DOMAIN}/privkey.pem;
    ssl_session_timeout 5m;
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:10m;
    ssl_dhparam /etc/ssl/dhparam.pem;
    ssl_stapling on;
    ssl_stapling_verify on;

Now check the configuration:

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

As you can see, there are no errors, so restart Nginx:

$ sudo systemctl restart nginx

At this stage, you can already use the Taiga project management system, but you can also install asynchronous mode. The fact is that by default Taiga executes all tasks in synchronous mode, but some tasks can be executed in asynchronous mode, such as webhook or import/export.

Setting Asynchronous Tasks Mode

First, let's check that RabbitMQ server and Redis server are installed:

$ sudo apt-get install -y rabbitmq-server redis-server

Then we need to change the line in the ~/taiga-back/settings/ file:


Now create the /etc/systemd/system/taiga_celery.service file to create a service (daemon):

$ sudo vi /etc/systemd/system/taiga_celery.service
ExecStart=/home/taiga/.virtualenvs/taiga/bin/celery -A taiga worker --concurrency 4 -l INFO
ExecStop=/bin/kill -s TERM $MAINPID

Now reboot systemd, add a new service to autorun and start:

$ sudo systemctl daemon-reload
$ sudo systemctl start taiga_celery
$ sudo systemctl enable taiga_celery
$ sudo systemctl restart taiga

The installation of the Taiga project management system is completed… Not really. We have not set the firewall up!

Firewall Configuration

Ubuntu 18 uses ufw, first check its status:

$ sudo ufw status
Status: inactive

As you can see, the firewall is not active. Now let's check a list of pre-created templates (in ufw logic it's app):

$ sudo ufw app list
Available applications:

As you can see, by default there are only settings for ssh. Here are templates for ports 80 and 443:

$ sudo vi /etc/ufw/applications.d/www
description=World Wide Web.
$ sudo vi /etc/ufw/applications.d/www-ssl
title=WWW ssl
description=World Wide Web ssl.


$ sudo ufw app list
Available applications:

Now activate

$ sudo ufw allow OpenSSH
Rules updated
Rules updated (v6)
$ sudo ufw allow WWW
Rules updated
Rules updated (v6)
$ sudo ufw allow WWWSSL
Rules updated
Rules updated (v6)
$ sudo ufw enable


$ sudo ufw status
Status: active
To              Action     From
--              ------     ----
OpenSSH         ALLOW     Anywhere
WWW             ALLOW     Anywhere
WWWSSL          ALLOW     Anywhere
OpenSSH (v6)    ALLOW     Anywhere (v6)
WWW (v6)        ALLOW     Anywhere (v6)
WWWSSL (v6)     ALLOW     Anywhere (v6)

And now the installation is finally completed. Overview

Now it is time to look at the results of your work. Go to our address at https://{YOUR_DOMAIN}:

There's nothing wrong with the fact there is already data present on the image. If you remember, in the instructions we have shown the possibility to fill the database for demonstation purposes. On the top right, we log in by pressing the “Login” button:

Do you remember the admin user with 123123 password? Log in as admin and do not forget to change the password in the user settings. You can also select the language of the user interface. After logging in, we find ourselves on the dashboard:

In the upper part, select the project (in this example, the project “Project example 0” is selected), and then you find yourself in the project management screen. Let's see what Kanban looks like in the implementation:

Now let's see what Scrum looks like:

In each project, you can add or remove users, assign roles:

Of course, there are various settings of the project itself:

If you are familiar with Agile methodology, you have heard about Epics. The following image shows how this looks in

This usability of the Taiga project management system does not end here. There is also software for mobile platforms. In particular, we will briefly review applications for Android devices:

This application has paid functions, but free features would be sufficient for most users. To connect to your server, select use custom server and enter your data:

After logging in, you also see the dashboard:

The functionality of this application is almost as good as its web version:

From mobile devices you can access Taiga via the web-interface, but unfortunately, not all browsers always adequately handle some features. For example, in Kanban task transfer doesn't always work in many browsers. After all, Taiga has its own API that allows you to use all the functionality.


We have reviewed the Taiga project management system, which uses Agile methodology families Kanban and Scrum. Of course, to fully learn to work with this system is not a moment's work, and this article didn't cover it, but if you imagine the opportunities after learning and implementing this software - it will undoubtedly benefit your business and future projects. We are the main examples of this. Syncweb actively and successfully uses Taiga in its internal projects.

In addition, Taiga is free of charge when used on your own servers. Availability of various integration capabilities, API, active development (the project is not abandoned, the updates are released regularly), active community - these are the advantages of Taiga. The main disadvantages, in our opinion, are the difficulty in installing and updating and a small number of Russian-language resources for this software, which slightly increases the threshold of knowledge for system administrators concerning installation and implementation to the organization, but we hope that our instruction will help to reduce this requirement. It wasn't hard with us, was it?

Reliable VPS servers for