Taiga Installation on CentOS 7: Complete Setup Guide

Taiga is a robust, free, and open-source solution tailored for project management. Unlike traditional tools, it adopts an incremental agile methodology to streamline project development. With a customizable architecture, Taiga offers substantial flexibility. Its backend is crafted using Python with the Django framework, while the frontend leverages JavaScript written in CoffeeScript and AngularJS. Key features include project collaboration, Kanban boards, bug and time tracking, reporting tools, backlogs, wiki integration, and more.

Requirements

• An active CentOS 7 server instance with a minimum of 1GB RAM
• A sudo-enabled user account

This setup utilizes taiga.example.com as the sample domain pointing to the server. Be sure to substitute it with your actual domain wherever it appears.

Before proceeding, ensure your system is up to date using the CentOS 7 update guide. After updating, move on to the PostgreSQL installation.

Installing PostgreSQL

PostgreSQL is a dependable and high-performance object-relational database engine. Taiga relies on it to manage and store its data. First, add the PostgreSQL repository to your server:

sudo yum -y install https://download.postgresql.org/pub/repos/yum/10/redhat/rhel-7-x86_64/pgdg-centos10-10-1.noarch.rpm

Install the PostgreSQL server along with essential components:

sudo yum -y install postgresql10-server postgresql10-contrib postgresql10

Initialize the PostgreSQL database:

sudo /usr/pgsql-10/bin/postgresql-10-setup initdb

Enable and start the PostgreSQL service to automatically launch on system boot:

sudo systemctl start postgresql-10

sudo systemctl enable postgresql-10

Set a new password for the default PostgreSQL user account:

sudo passwd postgres

Switch to the PostgreSQL user environment:

sudo su - postgres

Create a new database user dedicated to Taiga:

createuser taiga

Access the PostgreSQL shell for database operations:

psql

Assign a secure password to the new Taiga user:

ALTER USER taiga WITH ENCRYPTED password 'DBPassword';

Make sure to replace DBPassword with a strong, secure password.

Next, set up a new database for Taiga and assign ownership to the created user:

CREATE DATABASE taiga OWNER taiga;

Exit the PostgreSQL shell:

\q

Return to the sudo-enabled user account:

exit

Installing Python 3.6

While CentOS 7 includes Python 2.7 by default, Taiga needs Python version 3.4 or newer. Here, Python 3.6 will be compiled from source. Begin by installing essential build packages and compilers:

sudo yum -y install gcc autoconf flex bison libjpeg-turbo-devel freetype-devel zlib-devel zeromq3-devel gdbm-devel ncurses-devel automake libtool libffi-devel curl git tmux libxml2-devel libxslt-devel openssl-devel gcc-c++

Download the Python 3.6 source archive:

wget https://www.python.org/ftp/python/3.6.3/Python-3.6.3.tar.xz

Extract the archive and configure the build environment:

tar xf Python-3.6.3.tar.xz

cd Python-3.6.3

./configure --enable-optimizations --prefix=/usr

Execute an alternate installation to preserve the default Python version:

sudo make altinstall

Important: Avoid overwriting the system Python as it is required by the YUM package manager.

Verify the Python 3.6 installation:

python3.6 -V

You should get this output:

[user@Python-3.6.3]$ python3.6 -V

Python 3.6.3

Use pip to install virtual environment tools:

sudo pip3.6 install virtualenv virtualenvwrapper

sudo pip3.6 install --upgrade setuptools pip

Virtual environments are essential for Python development. They provide isolated workspaces that contain their own package directories, avoiding conflicts with other environments or system-wide installations.

Installing RabbitMQ for Message Queuing

Taiga depends on RabbitMQ for processing message queues. RabbitMQ requires Erlang to operate correctly. Begin by installing Erlang:

sudo yum -y install erlang

Import RabbitMQ’s GPG signing key:

sudo rpm --import https://www.rabbitmq.com/rabbitmq-release-signing-key.asc

Download and install RabbitMQ:

sudo yum -y install https://dl.bintray.com/rabbitmq/rabbitmq-server-rpm/rabbitmq-server-3.6.12-1.el7.noarch.rpm

Enable and start the RabbitMQ service:

sudo systemctl start rabbitmq-server

sudo systemctl enable rabbitmq-server

Create a user and virtual host for Taiga and grant necessary permissions:

sudo rabbitmqctl add_user taiga StrongMQPassword

sudo rabbitmqctl add_vhost taiga

sudo rabbitmqctl set_permissions -p taiga taiga ".*" ".*" ".*"

Replace StrongMQPassword with a secure password of your choice.

Installing Node.js and CoffeeScript

To compile Taiga’s frontend, Node.js version 7 or higher is required. Add the Node.js v8 repository:

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

Install Node.js and the pwgen utility for generating secure keys:

sudo yum install -y nodejs pwgen

Install CoffeeScript and Gulp using npm:

sudo npm install -g coffee-script gulp

Setting Up the Taiga Backend

Create a new user under which the Taiga backend will run:

sudo useradd -s /bin/bash taiga

sudo su - taiga

Note: From this point on, run all commands as the taiga user until further notice.

Create a logs directory:

mkdir -p ~/logs

Clone the backend repository and check out the stable branch:

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

cd taiga-back

git checkout stable

Set up the virtualenvwrapper to use Python 3.6 explicitly:

echo "VIRTUALENVWRAPPER_PYTHON='/bin/python3.6'" >> ~/.bashrc

echo "source /usr/bin/virtualenvwrapper.sh" >> ~/.bashrc

source ~/.bashrc

Create and activate a new Python virtual environment:

mkvirtualenv -p /bin/python3.6 taiga

pip3.6 install --upgrade setuptools

Install Python dependencies from the requirements file:

pip3.6 install -r requirements.txt

Populate the database with essential data and perform static file preparation:

python3.6 manage.py migrate --noinput

python3.6 manage.py loaddata initial_user

python3.6 manage.py loaddata initial_project_templates

python3.6 manage.py compilemessages

python3.6 manage.py collectstatic --noinput

To install sample data for demo purposes, run:

python3.6 manage.py sample_data

Creating Backend Configuration

Generate a strong secret key to encrypt sessions:

pwgen -s -1 64

You should see an output similar to:

CZfjWjHctPwnLZsDysWqaZcYfRCviHbI4fVRwfhpbtAHPNBtmkcegpwpYjTtEziJ

Edit the local backend settings file:

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

Insert the following configuration, replacing placeholders with actual values:

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

#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

#GITHUB_API_CLIENT_ID = "yourgithubclientid"

#GITHUB_API_CLIENT_SECRET = "yourgithubclientsecret"

Running and Testing the Taiga Backend

To verify if the backend works, run the Django development server:

workon taiga

python manage.py runserver

You will see output similar to the following, indicating success:

Trying import local.py settings...

Performing system checks...

System check identified no issues (0 silenced).

Django version 1.10.6, using settings 'settings'

Starting development server at http://127.0.0.1:8000/

Quit the server with CONTROL-C.

In another terminal, confirm API access with curl:

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

The API will return endpoints similar to this:

{"locales": "...", "auth": "...", "users": "...", "roles": "...", "user-storage": "...", "notify-policies": "...", "projects": "...", "projects/(?P\\d+)/fans": "...", "projects/(?P\\d+)/watchers": "...", "project-templates": "..."}

Stop the backend with Ctrl + C and deactivate the environment:

deactivate

Install and Configure Taiga Frontend

The frontend of Taiga provides the user-facing web interface. Begin by cloning the official frontend repository and switching to the latest stable branch:

cd ~

git clone https://github.com/taigaio/taiga-front-dist.git taiga-front-dist

cd taiga-front-dist

git checkout stable

Create and populate a configuration file for the frontend:

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

{

"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

}

Remember to update the domain and optional parameters as required.

Set Up Taiga Events for Real-Time Updates

Taiga Events powers real-time updates in Kanban, backlog, and other components. Clone the events module and install its dependencies:

cd ~

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

cd taiga-events

npm install

Create the config file for Taiga Events:

nano ~/taiga-events/config.json

{

"url": "amqp://taiga:StrongMQPassword@localhost:5672/taiga",

"secret": "Generated_Secret_Key",

"webSocketServer": {

"port": 8888

}

}

Use the same secret key and message queue credentials defined in your backend configuration.

Manage Services with Circus

Now return to the sudo user session:

exit

Install the Circus process manager:

sudo pip3.6 install circus

Create the necessary folders and initial configuration files:

sudo mkdir /etc/circus

sudo mkdir /etc/circus/conf.d

sudo nano /etc/circus/circus.ini

[circus]

check_delay = 5

endpoint = tcp://127.0.0.1:5555

pubsub_endpoint = tcp://127.0.0.1:5556

include = /etc/circus/conf.d/*.ini

Configure backend and events watchers for Circus:

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

[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.6/site-packages

Now create the events process config:

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

[watcher:taiga-events]

working_dir = /home/taiga/taiga-events

cmd = /usr/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

Create the systemd unit file to manage Circus as a service:

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

[Unit]

Description=Circus process manager

After=syslog.target network.target nss-lookup.target

[Service]

Type=simple

ExecReload=/usr/bin/circusctl reload

ExecStart=/usr/bin/circusd /etc/circus/circus.ini

Restart=always

RestartSec=5

[Install]

WantedBy=default.target

Start and enable Circus on boot:

sudo systemctl start circus

sudo systemctl enable circus

circusctl status

A successful status shows:

taiga: active

taiga-events: active

Serve Taiga Securely via Nginx with Let's Encrypt

Install Nginx and Certbot:

sudo yum -y install nginx certbot

Adjust firewall rules for HTTP and HTTPS:

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

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

sudo firewall-cmd --reload

Ensure your domain is pointing to your server, then request the certificate:

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

Schedule auto-renewal of the SSL certificate:

sudo crontab -e

Add this cron job:

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

Generate a Diffie-Hellman key:

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

Then configure your Nginx virtual host (use the config you’ve already provided).

Restart the web server and verify:

sudo systemctl restart nginx

sudo systemctl status nginx

Finally, adjust permissions to ensure correct ownership:

sudo chown -R taiga:taiga /home/taiga/

sudo chmod o+x /home/taiga/

Conclusion

You can now access Taiga at https://taiga.example.com. Use the default admin login:

• Username: admin
• Password: 123123

Create a new project or import from other platforms like GitHub, Jira, or Trello to get started.