Taiga unter CentOS 7 installieren und konfigurieren mit PostgreSQL und Python 3.6
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.
