Hur man installerar Taiga Project Management Tool på CentOS 7

Förutsättningar

Installera PostgreSQL

Installera Python 3

Installera RabbitMQ

Installera Nodejs

Installera Taiga Backend

Installera frontend

Installera Taiga Events

Konfigurera Circus

Installera Nginx som en omvänd proxy

Slutsats

Taiga är en gratis och öppen källkodsapplikation för projektledning. Till skillnad från andra projektledningsverktyg använder Taiga ett stegvis agilt tillvägagångssätt för att hantera utvecklingen av projektet. Taiga är en mycket kraftfull och helt anpassningsbar applikation. Baksidan av Taiga är skriven i Python med Django-ramverket. Gränssnittet är skrivet i JavaScript med hjälp av CoffeeScript- och AngularJS-ramverk. Taiga innehåller funktioner som projektsamarbete, Kanban-kort, buggspårning, rapportering, tidsspårning, eftersläpning, wiki och mer.

Förutsättningar

• En Vultr CentOS 7-serverinstans med minst 1 GB RAM.
• En sudo-användare .

I den här handledningen kommer vi att använda taiga.example.comsom domännamnet pekade på servern. Ersätt alla förekomster av taiga.example.commed ditt faktiska domännamn.

Uppdatera ditt bassystem med hjälp av guiden Hur man uppdaterar CentOS 7 . När ditt system har uppdaterats, fortsätt att installera PostgreSQL.

Installera PostgreSQL

PostgreSQL är ett objektrelationellt databassystem känt för sin stabilitet och hastighet. Taiga använder PostgreSQL för att lagra sin databas. Lägg till PostgreSQL-förvaret i systemet.

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

Installera PostgreSQL-databasservern.

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

Initiera databasen.

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

Starta PostgreSQL-servern och låt den starta automatiskt vid uppstart.

sudo systemctl start postgresql-10
sudo systemctl enable postgresql-10

Ändra lösenordet för standardpostgreSQL-användaren.

sudo passwd postgres

Logga in som PostgreSQL-användare.

sudo su - postgres

Skapa en ny PostgreSQL-användare för Taiga.

createuser taiga 

PostgreSQL tillhandahåller psqlskalet för att köra frågor på databasen. Byt till PostgreSQL-skalet.

psql

Ställ in ett lösenord för den nyskapade användaren för Taiga-databasen.

ALTER USER taiga WITH ENCRYPTED password 'DBPassword';

Ersätt DBPasswordmed ett säkert lösenord. Skapa en ny databas för Taiga-installation.

CREATE DATABASE taiga OWNER taiga;

Gå ut ur psqlskalet.

\q

Växla till sudoanvändaren.

exit

Installera Python 3

Python 2.7 kommer förinstallerat på en CentOS 7-server, men Taiga kräver Python version 3.4 eller senare.

Vi kommer att installera Python version 3.6 från källan. Installera de nödvändiga byggverktygen och kompilatorn.

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

Ladda ner Python-källkoden.

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

Extrahera och konfigurera Python-installationen.

tar xf Python-3.6.3.tar.xz
cd Python-3.6.3
./configure --enable-optimizations --prefix=/usr

Gör en alternativ installation.

sudo make altinstall

Obs : Alternativa installationer installerar Python 3.6 utan att ersätta standardversionen av Python. Om du ersätter standard Python i CentOS 7 kan det bryta YUMlagringshanteraren.

Du kommer nu att kunna kontrollera dess version.

python3.6 -V

Du bör se följande.

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

Installera Python Virtual Environment med pip.

sudo pip3.6 install virtualenv virtualenvwrapper
sudo pip3.6 install --upgrade setuptools pip 

Python virtuell miljö används för att skapa en isolerad virtuell miljö för ett Python-projekt. En virtuell miljö innehåller sina egna installationskataloger och delar inte bibliotek med globala och andra virtuella miljöer.

Installera RabbitMQ

Taiga använder RabbitMQ för att bearbeta meddelandekön. RabbitMQ kräver att Erlang-biblioteken fungerar. Installera Erlang.

sudo yum -y install erlang

Importera RabbitMQ GPG-signeringsnyckel.

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

Installera RabbitMQ.

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

Starta och aktivera RabbitMQ-servern.

sudo systemctl start rabbitmq-server
sudo systemctl enable rabbitmq-server

Lägg till RabbitMQ-användare och vhost. Ge även behörighet till användaren via värden.

sudo rabbitmqctl add_user taiga StrongMQPassword
sudo rabbitmqctl add_vhost taiga
sudo rabbitmqctl set_permissions -p taiga taiga ".*" ".*" ".*"

Se till att ersätta StrongMQPasswordmed ett säkert lösenord.

Installera Nodejs

Node.js version 7 eller senare krävs för att kompilera frontend av Taiga. Lägg till Node.js version 8-förrådet.

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

Installera Node.js och pwgenverktyget.

sudo yum install -y nodejs pwgen

pwgenkommer att användas senare för att generera en stark hemlig sträng. Installera CoffeeScript, eftersom det kommer att användas för att kompilera Taiga-filer skrivna med CoffeeScript-ramverket.

sudo npm install -g coffee-script gulp

Installera Taiga Backend

Lägg till en ny systemanvändare för Taiga för att säkerställa att Taiga-processer körs som en oprivilegierad användare.

sudo useradd -s /bin/bash taiga
sudo su - taiga

Obs : Från och med nu måste alla kommandon köras som den oprivilegierade användaren taigatills du blir ombedd att byta tillbaka till sudoanvändare.

Skapa en ny katalog för att lagra loggfilerna.

mkdir -p ~/logs

Klona Taiga-backend-förrådet från GitHub och kolla in den senaste stabila grenen.

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

Konfigurera för virtualenvwrapperatt använda Python 3.6 istället för standard Python.

echo "VIRTUALENVWRAPPER_PYTHON='/bin/python3.6'" >> ~/.bashrc
echo "source /usr/bin/virtualenvwrapper.sh" >> ~/.bashrc

Till sist, källkod ~/.bashrcfilen.

source ~/.bashrc

Skapa nu en ny virtuell miljö för Taiga med Python 3.6.

mkvirtualenv -p /bin/python3.6 taiga
pip3.6 install --upgrade setuptools

Installera de nödvändiga Python-beroendena med pip.

pip3.6 install -r requirements.txt

Fyll i databasen med nödvändiga initiala data.

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

Ovanstående kommandon kommer att skriva data till PostgreSQL-databasen. Taiga skickar också en del demo- eller exempeldata som kan vara användbara för att utvärdera produkten. Om du vill installera exempeldata, kör följande.

python3.6 manage.py sample_data

Obs : Installation av exempeldata är valfritt och endast avsett för att utvärdera produkten.

Innan vi fortsätter att skapa konfigurationsfilen för Taigas backend måste vi generera en hemlig sträng. Denna sträng kommer att användas för att kryptera sessionsdata.

Skapa en slumpmässig sträng på 64 tecken.

pwgen -s -1 64

Du bör se utdata som en slumpmässig sträng.

(taiga) [taiga@vultr taiga-back]$ pwgen -s -1 64
CZfjWjHctPwnLZsDysWqaZcYfRCviHbI4fVRwfhpbtAHPNBtmkcegpwpYjTtEziJ

Skapa en ny konfigurationsfil för Taiga Backend.

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

Fyll filen med följande kod.

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 = "[email protected]"
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"}

# 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"
#EMAIL_USE_TLS = False
#EMAIL_HOST = "mail.example.com"
#EMAIL_HOST_USER = "[email protected]"
#EMAIL_HOST_PASSWORD = "SMTPPassword"
#EMAIL_PORT = 25

# Uncomment and populate with proper connection parameters
# for enable github login/singin.
#GITHUB_API_CLIENT_ID = "yourgithubclientid"
#GITHUB_API_CLIENT_SECRET = "yourgithubclientsecret"

Make sure to replace the example domain name with the actual one in the above code. Also, replace Generated_Secret_Key with the actual secret key and StrongMQPassword with the actual password for the Taiga message queue user. If you have an SMTP server ready and you wish to use email sending features immediately, you can uncomment the email options and set the appropriate values. If you do not have a mail server ready, you can skip setting up the email feature for now and set it later in this configuration file.

If you wish to enable GitHub login, create an application in GitHub and provide the API client ID and client secret.

To immediately check if the Taiga backend can be started, run the built-in Django server.

workon taiga
python manage.py runserver

You will see the following output if the server has started successfully.

(taiga) [taiga@vultr taiga-back]$ workon taiga
(taiga) [taiga@vultr taiga-back]$ python manage.py runserver
Trying import local.py settings...
Trying import local.py settings...
Performing system checks...

System check identified no issues (0 silenced).
October 25, 2017 - 07:07:28
Django version 1.10.6, using settings 'settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

To verify if the API can be accessed, open another terminal session and run the following.

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

You will see a similar output returned by the API call.

[user@vultr ~]$ curl http://127.0.0.1:8000/api/v1/
{"locales": "http://127.0.0.1:8000/api/v1/locales", "auth": "http://127.0.0.1:8000/api/v1/auth", "users": "http://127.0.0.1:8000/api/v1/users", "roles": "http://127.0.0.1:8000/api/v1/roles", "user-storage": "http://127.0.0.1:8000/api/v1/user-storage", "notify-policies": "http://127.0.0.1:8000/api/v1/notify-policies", "projects": "http://127.0.0.1:8000/api/v1/projects", "projects/(?P<resource_id>\\d+)/fans": "http://127.0.0.1:8000/api/v1/projects/(?P<resource_id>\\d+)/fans", "projects/(?P<resource_id>\\d+)/watchers": "http://127.0.0.1:8000/api/v1/projects/(?P<resource_id>\\d+)/watchers", "project-templates": "http://127.0.0.1:8000/api/v1/project-templates",

Stop the Taiga backend server by pressing "Ctrl + C" and deactivate the virtual environment.

deactivate

Install Frontend

The Taiga frontend is the component of Taiga which serves the Web user interface. Clone the Taiga frontend repository from Github and checkout 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 a new configuration file for the Taiga frontend.

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

Populate the file with this.

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

Make sure to replace the example domain with the actual domain. You can also change the default language and other parameters in the above configuration.

Install Taiga Events

Apart from the frontend and backend, we also need to install Taiga events. Taiga events is a web socket server, and it enables the Taiga frontend to show real-time changes in modules such as backlog, Kanban and more. It uses the RabbitMQ server for message processing.

Clone the Taiga events repository from Github.

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

Install the Node.js dependencies using npm.

npm install

Create a new configuration file for Taiga events.

nano ~/taiga-events/config.json

Populate the file with the following.

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

Replace Generated_Secret_Key with the actual 64 characters long secret key which you have generated in the past. The secret key should be exactly the same as the key you provided in the Taiga backend configuration file. Also, update the StrongMQPassword with the actual password for Taiga message queue user.

Configure Circus

Circus is a process manager for Python applications. We will use Circus to run Taiga backend and events.

Switch back to the sudo user.

exit

Note: From now you will need to run the commands using sudo user.

Install Circus using pip.

sudo pip3.6 install circus

Create new directories to store Circus configurations.

sudo mkdir /etc/circus
sudo mkdir /etc/circus/conf.d

Create the default configuration file for Circus.

sudo nano /etc/circus/circus.ini

Populate the file with the following configuration.

[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

Create a new Circus configuration file for running the Taiga backend.

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

Populate the file with the following.

[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

Create a new Circus configuration for running Taiga Events.

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

Populate the file with the following.

[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

Now we will need to create a systemd service file to run Circus. Using systemd will ensure that Circus is automatically started during reboot and failures.

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

Populate the file.

[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

Starta Circus och aktivera automatisk start vid uppstart.

sudo systemctl start circus
sudo systemctl enable circus

Kontrollera status för Circus.

circusctl status

Du kommer att se följande utdata.

[user@vultr ~]$ circusctl status
taiga: active
taiga-events: active

Nu har vi Taiga installerat och kört. Innan vi kan använda den måste vi exponera installationen med hjälp av en produktionswebbserver.

Installera Nginx som en omvänd proxy

Vi kommer att använda Nginx webbserver som en omvänd proxy för att servera applikationen till användarna. Vi kommer också att skaffa och installera SSL-certifikat från Let's Encrypt.

Installera Nginx och Certbot. Certbot är den officiella certifikatutfärdande klienten för Let's Encrypt CA.

sudo yum -y install nginx certbot

Justera din brandväggsinställning för att tillåta standarden HTTPoch HTTPSportarna genom brandväggen eftersom Certbot behöver göra en HTTP-anslutning för att verifiera domänbehörigheten.

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

Obs : För att få certifikat från Let's Encrypt CA måste du se till att domänen som du vill generera certifikaten för pekar mot servern. Om inte, gör de nödvändiga ändringarna i DNS-posterna för din domän och vänta på att DNS:n sprids innan du gör certifikatbegäran igen. Certbot kontrollerar domänmyndigheten innan certifikaten tillhandahålls.

Använd nu den inbyggda webbservern i Certbot för att generera certifikaten för din domän.

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

De genererade certifikaten kommer sannolikt att lagras i /etc/letsencrypt/live/taiga.example.com/katalogen. SSL-certifikatet kommer att behållas som fullchain.pem, och den privata nyckeln kommer att sparas som privkey.pem.

Låt oss kryptera certifikat går ut om 90 dagar, så det rekommenderas att ställa in automatisk förnyelse för certifikaten med Cron-jobb. Cron är en systemtjänst som används för att köra periodiska uppgifter.

Öppna cron-jobbfilen.

sudo crontab -e

Lägg till följande rad.

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

Ovanstående cron-jobb kommer att köras dagligen vid midnatt. Om certifikatet löper ut kommer det automatiskt att förnya certifikaten.

Generera en stark Diffie-Hellmanparameter. Det ger ett extra lager av säkerhet för datautbyte mellan värden och servern.

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

Skapa ett nytt Nginx-serverblock för att tjäna Taiga-gränssnittet.

sudo nano /etc/nginx/conf.d/taiga.conf

Fyll filen med följande.

server {
    listen 80;
    server_name taiga.example.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl;
    server_name taiga.example.com;

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

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

    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_pass http://127.0.0.1:8001/api;
        proxy_redirect off;
    }

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

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

    add_header Strict-Transport-Security "max-age=63072000; includeSubdomains; preload";
    add_header Public-Key-Pins 'pin-sha256="klO23nT2ehFDXCfx3eHTDRESMz3asj1muO+4aIdjiuY="; pin-sha256="633lt352PKRXbOwf4xSEa1M517scpD3l5f79xMD9r9Q="; max-age=2592000; includeSubDomains';

    ssl on;
    ssl_certificate /etc/letsencrypt/live/taiga.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/taiga.example.com/privkey.pem;
    ssl_session_timeout 5m;
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    ssl_prefer_server_ciphers on;
    ssl_ciphers 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!3DES:!MD5:!PSK';
    ssl_session_cache shared:SSL:10m;
    ssl_dhparam /etc/ssl/dhparam.pem;
    ssl_stapling on;
    ssl_stapling_verify on;

}

Se till att ändra domännamnet och sökvägen till SSL-certifikaten.

Nu kan du starta om Nginx-webbservern och aktivera den att starta vid uppstart automatiskt.

sudo systemctl restart nginx
sudo systemctl status nginx

Slutligen, fixa äganderätten och behörigheten för Taiga-filer.

sudo chown -R taiga:taiga /home/taiga/
sudo chmod o+x /home/taiga/

Slutsats

Du kan nu komma åt Taiga-installationen genom att gå till https://taiga.example.com. Logga in med det ursprungliga administratörskontot med användarnamn " admin" och lösenord " 123123". Din installation är nu redo för produktionsanvändning. Börja med att skapa ett nytt projekt eller utvärdera produkten. Om du redan hanterar ett projekt på Github, Jira eller Trello kan du enkelt importera projekten till Taiga med hjälp av importörerna .