Taiga auf CentOS 7 installieren: Anleitung für Backend & UI

Taiga ist ein leistungsstarkes, kostenloses und quelloffenes Tool zur Projektverwaltung. Im Gegensatz zu klassischen Lösungen basiert es auf einem inkrementellen agilen Ansatz, um Entwicklungsprozesse effizient zu unterstützen. Dank seiner flexiblen Architektur lässt sich Taiga individuell anpassen. Die Backend-Komponente basiert auf Python mit dem Django-Framework, während das Frontend mit JavaScript in CoffeeScript und AngularJS umgesetzt ist. Zu den wichtigsten Funktionen zählen Projektzusammenarbeit, Kanban-Boards, Fehler- und Zeiterfassung, Berichte, Backlogs, Wiki-Integration und vieles mehr.

Voraussetzungen

• Eine aktive CentOS 7 Serverinstanz mit mindestens 1 GB RAM
• Ein Benutzer mit sudo-Rechten

In dieser Anleitung wird taiga.example.com als Beispiel-Domain verwendet. Ersetze diese durch deine eigene Domain.

Bevor du beginnst, solltest du das System mit dem CentOS 7 Update-Guide aktualisieren. Danach kannst du mit der Installation von PostgreSQL fortfahren.

PostgreSQL installieren

PostgreSQL ist ein stabiles und leistungsstarkes objekt-relationales Datenbanksystem. Taiga verwendet es zur Datenspeicherung. Füge zuerst das PostgreSQL-Repository hinzu:

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

Installiere den PostgreSQL-Server und die zugehörigen Pakete:

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

Initialisiere anschließend die PostgreSQL-Datenbank:

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

Aktiviere den PostgreSQL-Dienst und starte ihn:

sudo systemctl start postgresql-10

sudo systemctl enable postgresql-10

Ändere das Passwort für den Standard-Benutzer postgres:

sudo passwd postgres

Wechsle in die PostgreSQL-Benutzerumgebung:

sudo su - postgres

Erstelle einen neuen Benutzer für Taiga:

createuser taiga

Starte die PostgreSQL-Shell:

psql

Vergib ein sicheres Passwort für den Benutzer taiga:

ALTER USER taiga WITH ENCRYPTED password 'DBPassword';

Ersetze DBPassword mit einem sicheren Passwort deiner Wahl.

Erstelle nun die Datenbank für Taiga und weise sie dem Benutzer zu:

CREATE DATABASE taiga OWNER taiga;

Beende die PostgreSQL-Sitzung:

\q

Wechsle zurück zum normalen Benutzer mit sudo-Rechten:

exit

Python 3.6 unter CentOS 7 installieren

Obwohl CentOS 7 standardmäßig Python 2.7 enthält, benötigt Taiga mindestens Python 3.4. In dieser Anleitung wird Python 3.6 direkt aus dem Quellcode kompiliert. Installiere zunächst alle notwendigen Build-Werkzeuge und Compiler:

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++

Lade das Quellpaket von Python 3.6 herunter:

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

Entpacke das Archiv und führe die Konfiguration durch:

tar xf Python-3.6.3.tar.xz

cd Python-3.6.3

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

Führe die alternative Installation durch, damit Python 2.7 bestehen bleibt:

sudo make altinstall

Wichtig: Ersetze nicht die Standard-Python-Version, da dies das YUM-Paketmanagement stören kann.

Überprüfe die erfolgreiche Installation von Python 3.6:

python3.6 -V

Die Ausgabe sollte wie folgt aussehen:

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

Python 3.6.3

Installiere die Pakete für virtuelle Umgebungen:

sudo pip3.6 install virtualenv virtualenvwrapper

sudo pip3.6 install --upgrade setuptools pip

Virtuelle Umgebungen ermöglichen es, isolierte Python-Installationen für einzelne Projekte zu nutzen und so Versionskonflikte zu vermeiden.

RabbitMQ für die Nachrichtenverarbeitung installieren

Taiga verwendet RabbitMQ zur Verarbeitung von Nachrichten. Voraussetzung ist eine funktionierende Erlang-Installation:

sudo yum -y install erlang

Importiere den GPG-Schlüssel von RabbitMQ:

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

Installiere RabbitMQ:

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

Aktiviere und starte den RabbitMQ-Dienst:

sudo systemctl start rabbitmq-server

sudo systemctl enable rabbitmq-server

Richte einen Benutzer und eine virtuelle Umgebung für Taiga ein und gewähre Zugriffsrechte:

sudo rabbitmqctl add_user taiga StrongMQPassword

sudo rabbitmqctl add_vhost taiga

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

Ersetze StrongMQPassword durch ein sicheres Passwort.

Node.js und CoffeeScript installieren

Für die Kompilierung des Frontends wird mindestens Node.js Version 7 benötigt. Binde das Repository für Node.js v8 ein:

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

Installiere Node.js sowie das Tool pwgen zur Generierung von sicheren Schlüsseln:

sudo yum install -y nodejs pwgen

Installiere CoffeeScript und Gulp global mit npm:

sudo npm install -g coffee-script gulp

Taiga-Backend einrichten

Lege einen neuen Benutzer an, unter dem das Taiga-Backend ausgeführt wird:

sudo useradd -s /bin/bash taiga

sudo su - taiga

Hinweis: Ab jetzt alle Befehle als Benutzer taiga ausführen.

Erstelle ein Verzeichnis für Log-Dateien:

mkdir -p ~/logs

Klone das Backend-Repository und wechsle auf den stabilen Branch:

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

cd taiga-back

git checkout stable

Konfiguriere virtualenvwrapper für Python 3.6:

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

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

source ~/.bashrc

Erstelle eine neue virtuelle Umgebung für Taiga und aktualisiere setuptools:

mkvirtualenv -p /bin/python3.6 taiga

pip3.6 install --upgrade setuptools

Installiere alle Python-Abhängigkeiten für das Projekt:

pip3.6 install -r requirements.txt

Führe Datenbankmigrationen und Initialdaten-Importe durch, sowie die Kompilierung von Sprachdateien und statischen Assets:

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

Optional kannst du Beispieldaten laden:

python3.6 manage.py sample_data

Backend-Konfiguration erstellen

Generiere einen sicheren Schlüssel zur Verschlüsselung von Sitzungscookies:

pwgen -s -1 64

Die Ausgabe sieht beispielsweise so aus:

CZfjWjHctPwnLZsDysWqaZcYfRCviHbI4fVRwfhpbtAHPNBtmkcegpwpYjTtEziJ

Bearbeite nun die lokale Konfigurationsdatei des Backends:

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

Füge folgende Konfiguration ein und passe Domain, Schlüssel und Passwörter an:

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"

Taiga-Backend starten und testen

Starte den integrierten Entwicklungsserver von Django zur Überprüfung:

workon taiga

python manage.py runserver

Bei Erfolg erhältst du eine Ausgabe wie diese:

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 einem zweiten Terminalfenster kannst du mit curl prüfen, ob die API antwortet:

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

Die Rückgabe sieht etwa wie folgt aus:

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

Beende den Server mit Strg + C und deaktiviere die virtuelle Umgebung:

deactivate

Taiga-Frontend installieren und konfigurieren

Das Frontend liefert die Web-Oberfläche. Klone das Repository und wechsle in den stabilen Branch:

cd ~

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

cd taiga-front-dist

git checkout stable

Erstelle die Konfigurationsdatei für das Frontend:

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

Inhalt der Datei:

{

"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

}

Ersetze auch hier die Beispiel-Domain durch deine eigene.

Echtzeit-Funktion mit Taiga Events einrichten

Taiga Events ist für Live-Aktualisierungen in Modulen wie Kanban zuständig. Klone das Repository und installiere die Abhängigkeiten:

cd ~

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

cd taiga-events

npm install

Erstelle die Konfigurationsdatei für den Event-Server:

nano ~/taiga-events/config.json

{

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

"secret": "Generated_Secret_Key",

"webSocketServer": {

"port": 8888

}

}

Verwende dieselben Zugangsdaten wie zuvor in der Backend-Konfiguration.

Prozessverwaltung mit Circus einrichten

Wechsle wieder zurück zum sudo-Benutzer:

exit

Installiere Circus:

sudo pip3.6 install circus

Erstelle die Verzeichnisse und Hauptkonfiguration:

sudo mkdir /etc/circus

sudo mkdir /etc/circus/conf.d

sudo nano /etc/circus/circus.ini

Füge folgende Konfiguration ein:

[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

Circus-Überwachung für Backend und Events einrichten

Erstelle nun die Überwachungsdatei für das Taiga-Backend:

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

Füge folgenden Inhalt in die Datei ein:

[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

Als Nächstes wird die Konfiguration für den Taiga-Eventdienst angelegt:

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

Trage folgende Inhalte für die Eventüberwachung ein:

[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

Circus mit systemd verwalten

Damit Circus bei Systemstarts automatisch ausgeführt wird, erstelle einen passenden Dienst über systemd:

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

Füge den folgenden Dienstdefinitionstext ein:

[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

Aktiviere nun den Circus-Dienst und starte ihn manuell:

sudo systemctl start circus

sudo systemctl enable circus

circusctl status

Eine erfolgreiche Installation zeigt beispielsweise diesen Status an:

taiga: active

taiga-events: active

Taiga mit Nginx und Let's Encrypt sicher bereitstellen

Installiere zunächst den Webserver Nginx sowie Certbot, das offizielle Tool zum Beantragen von SSL-Zertifikaten von Let's Encrypt:

sudo yum -y install nginx certbot

Aktiviere HTTP- und HTTPS-Verbindungen in der Firewall:

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

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

sudo firewall-cmd --reload

Stelle sicher, dass deine Domain auf den Server zeigt, und fordere dann das SSL-Zertifikat an:

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

Plane eine automatische Erneuerung des Zertifikats mit einem Cronjob:

sudo crontab -e

Füge folgende Zeile ein, um das Zertifikat täglich um Mitternacht automatisch zu prüfen und ggf. zu erneuern:

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

Erstelle zusätzlich einen sicheren Diffie-Hellman-Schlüssel zur Absicherung der SSL-Verbindung:

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

Richte danach deine Nginx-Serverkonfiguration wie zuvor beschrieben ein.

Starte Nginx neu und prüfe den Dienststatus:

sudo systemctl restart nginx

sudo systemctl status nginx

Zum Abschluss passe die Dateiberechtigungen an, damit der Benutzer taiga vollen Zugriff auf sein Home-Verzeichnis hat:

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

sudo chmod o+x /home/taiga/

Fazit

Du kannst Taiga jetzt unter https://taiga.example.com aufrufen. Melde dich mit dem Standard-Adminkonto an:

• Benutzername: admin
• Passwort: 123123

Starte ein neues Projekt oder importiere bestehende Daten aus Plattformen wie GitHub, Jira oder Trello – die passenden Importwerkzeuge stehen dir in Taiga zur Verfügung.