Cum se instalează Instrumentul de gestionare a proiectelor Taiga pe Ubuntu 16.04

• Cerințe preliminare
• Instalați PostgreSQL
• Instalați Python
• Instalați RabbitMQ
• Instalați Nodejs
• Instalați Taiga Backend
• Instalați Frontend
• Instalați evenimente Taiga
• Configurați Circul
• Instalați Nginx ca proxy invers
• Concluzie

Taiga este o aplicație gratuită și open source pentru managementul de proiect. Spre deosebire de alte instrumente de gestionare a proiectului, Taiga utilizează o abordare incrementală agilă pentru a gestiona dezvoltarea proiectului. Taiga este o aplicație foarte puternică și complet personalizabilă. Backend-ul lui Taiga este scris în Python folosind cadrul Django. Frontend-ul este scris în JavaScript folosind cadrele CoffeeScript și AngularJS. Taiga include caracteristici, cum ar fi colaborarea proiectului, placa Kanban, urmărirea erorilor, raportarea, urmărirea timpului, date de întârziere, wiki și multe altele.

Cerințe preliminare

• O instanță a serverului Vultr Ubuntu 16.04 cu cel puțin 1 GB RAM.
• Un utilizator sudo .

În acest tutorial, vom folosi taiga.example.comca nume de domeniu indicat către server. Înlocuiți toate aparițiile taiga.example.comcu numele de domeniu real.

Actualizați-vă sistemul de bază utilizând ghidul Cum să actualizați Ubuntu 16.04 . După ce sistemul dvs. a fost actualizat, continuați să instalați PostgreSQL.

Instalați PostgreSQL

PostgreSQL este un sistem de baze de date relațional cu obiecte și cunoscut pentru stabilitatea și viteza sa. Taiga folosește PostgreSQL pentru a stoca baza de date. Adăugați depozitul PostgreSQL în sistem.

echo "deb http://apt.postgresql.org/pub/repos/apt/ xenial-pgdg main" | sudo tee /etc/apt/sources.list.d/pgdg.list

Importați cheia de semnare GPG și actualizați listele de pachete.

wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
sudo apt update

Instalați serverul de baze de date PostgreSQL.

sudo apt -y install postgresql

Porniți serverul PostgreSQL și permiteți-l să pornească automat la momentul de pornire.

sudo systemctl start postgresql
sudo systemctl enable postgresql

Modificați parola pentru utilizatorul implicit PostgreSQL.

sudo passwd postgres

Conectați-vă ca utilizator PostgreSQL.

sudo su - postgres

Creați un nou utilizator PostgreSQL pentru Taiga.

createuser taiga 

PostgreSQL oferă psqlshell - ul pentru a rula interogări pe baza de date. Comutați la shell-ul PostgreSQL.

psql

Setați o parolă pentru utilizatorul nou creat pentru baza de date Taiga.

ALTER USER taiga WITH ENCRYPTED password 'DBPassword';

Înlocuiți DBPasswordcu o parolă sigură. Creați o nouă bază de date pentru instalarea Taiga.

CREATE DATABASE taiga OWNER taiga;

Ieșiți din psqlcoajă.

\q

Comutați la sudoutilizator.

exit

Instalați Python

Taiga necesită Python versiunea 3.4 sau o versiune ulterioară, iar Python 3.5 vine preinstalat în distribuția Ubuntu 16.04. Instalați alte câteva pachete necesare.

sudo apt -y install python3 python3-pip python3-dev python3-dev virtualenvwrapper

Mediul virtual Python este utilizat pentru a crea un mediu virtual izolat pentru un proiect Python. Un mediu virtual conține propriile sale directoare de instalare și nu împărtășește biblioteci cu medii virtuale și alte medii virtuale. După ce Python 3 a fost instalat cu succes, ar trebui să poți verifica versiunea sa.

python3 -V

Veți vedea următoarele.

user@vultr:~$ python3 -V
Python 3.5.2

Upgrade pip, care este o aplicație de manager de dependență.

sudo pip3 install --upgrade setuptools pip 

De asemenea, instalați câteva instrumente de compilare care vor fi necesare ulterior pentru a compila dependențele.

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

Instalați RabbitMQ

Taiga folosește RabbitMQ pentru a procesa coada de mesaje. RabbitMQ necesită să funcționeze bibliotecile Erlang. Instalați Erlang.

sudo apt -y install erlang

Adăugați depozitul RabbitMQ.

echo 'deb http://www.rabbitmq.com/debian/ stable main' | sudo tee /etc/apt/sources.list.d/rabbitmq.list

Importați cheia de semnare GPG RabbitMQ.

wget -O- https://www.rabbitmq.com/rabbitmq-release-signing-key.asc | sudo apt-key add -

Actualizați informațiile despre depozit.

sudo apt update

Instalați RabbitMQ.

sudo apt -y install rabbitmq-server

Porniți și activați serverul RabbitMQ.

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

Adăugați un utilizator RabbitMQ și vhost. De asemenea, acordați permisiunea utilizatorului peste gazdă.

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

Asigurați-vă că înlocuiți StrongMQPasswordcu o parolă sigură.

Instalați Nodejs

Node.js este necesară pentru a compila frontend-ul Taiga. Adăugați depozitul Node.js versiunea 8.

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

Instalați Node.js și pwgenutilitarul.

sudo apt install -y nodejs pwgen npm

pwgenva fi folosit ulterior pentru a genera un șir secret puternic. Instalați CoffeeScript, deoarece acesta va fi utilizat pentru a compila fișierele Taiga scrise în cadrul CoffeeScript.

sudo npm install -g coffee-script gulp

Instalați Taiga Backend

Adăugați un nou utilizator de sistem pentru Taiga pentru a vă asigura că procesele Taiga rulează ca utilizator neprivilejat.

sudo adduser taiga
sudo su - taiga

Notă : De acum înainte, toate comenzile trebuie să fie executate ca utilizator neprivilegiat taigapână când vi se cere să reveniți la sudoutilizator.

Creați un nou director pentru a stoca fișierele jurnal.

mkdir -p ~/logs

Clonați depozitul de backend Taiga de la GitHub și verificați cea mai recentă sucursală stabilă.

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

Acum creează un nou mediu virtual pentru Taiga folosind Python 3.

mkvirtualenv -p /usr/bin/python3 taiga
pip3 install --upgrade setuptools

Instalați dependențele necesare Python folosind pip.

pip3 install -r requirements.txt

Populați baza de date cu datele inițiale necesare.

python3 manage.py migrate --noinput
python3 manage.py loaddata initial_user
python3 manage.py loaddata initial_project_templates
python3 manage.py compilemessages
python3 manage.py collectstatic --noinput

Comenzile de mai sus vor scrie date în baza de date PostgreSQL. De asemenea, Taiga livrează câteva date demo sau probă care pot fi utile pentru evaluarea produsului. Dacă doriți să instalați datele de eșantion, executați următoarele.

python3 manage.py sample_data

Notă : Instalarea datelor de probă este opțională și este destinată doar evaluării produsului.

Înainte de a continua să creăm fișierul de configurare pentru backend-ul Taiga, trebuie să generăm un șir secret. Acest șir va fi utilizat pentru criptarea datelor sesiunii.

Generați un șir aleatoriu de 64 de caractere.

pwgen -s -1 64

Ar trebui să vedeți ieșirea ca un șir aleatoriu.

(taiga) taiga@vultr:~/taiga-back$ pwgen -s -1 64
fhDfyYVJ4EH3tvAyUzmfWSeCXuf5sy5EEWrMQPaf9t3JSFrpiL6yvUEOWsFOTscP

Creați un fișier de configurare nou pentru Taiga Backend.

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

Populați fișierul urmând codul următor.

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"

Asigurați-vă că o înlocuiți example domain namecu cea reală din codul de mai sus. De asemenea, înlocuiți Generated_Secret_Keycu cheia secretă reală și StrongMQPasswordcu parola reală pentru utilizatorul de la coada de mesaje Taiga. Dacă aveți un server SMTP gata și doriți să utilizați imediat funcțiile de trimitere a e-mailurilor, puteți să decomandați opțiunile de e-mail și să setați valoarea corespunzătoare. Dacă nu aveți un server de e-mail gata, puteți săriți setarea funcției de e-mail pentru moment și să o setați mai târziu în acest fișier de configurare.

Dacă doriți să activați autentificarea GitHub, creați o aplicație în GitHub și oferiți ID-ul clientului și secretul clientului.

Pentru a verifica imediat dacă backend-ul Taiga poate fi pornit, executați serverul Django încorporat.

workon taiga
python manage.py runserver

Veți vedea următoarea ieșire dacă serverul a început cu succes.

(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 28, 2017 - 10:29:38
Django version 1.10.6, using settings 'settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Pentru a verifica dacă API-ul poate fi accesat, deschideți o altă sesiune de terminal și executați următoarele.

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

Veți vedea o ieșire similară returnată de apelul API.

user@vultr:~$ curl http://127.0.0.1:8000/api/v1/
{"webhooks": "http://127.0.0.1:8000/api/v1/webhooks", "invitations": "http://127.0.0.1:8000/api/v1/invitations", "severities": "http://127.0.0.1:8000/api/v1/severities", "memberships": "http://127.0.0.1:8000/api/v1/memberships", "user-storage": "http://127.0.0.1:8000/api/v1/user-storage", "epics/(?P<resource_id>\\d+)/voters": "http://127.0.0.1:8000/api/v1/epics/(?P<resource_id>\\d+)/voters", "wiki": "http://127.0.0.1:8000/api/v1/wiki", "priorities": "http://127.0.0.1:8000/api/v1/priorities", "userstories/attachments": "http://127.0.0.1:8000/api/v1/userstories/attachments", "epics/(?P<epic>[^/.]+)/related_userstories": "http://127.0.0.1:8000/api/v1/epics/(?P<epic>[^/.]+)/related_userstories", "timeline/user": "http://127.0.0.1:8000/api/v1/timeline/user", "userstories/(?P<resource_id>\\d+)/voters": "http://127.0.0.1:8000/api/v1/userstories/(?P<resource_id>\\d+)/voters", "wiki-links": "http://127.0.0.1:8000/api/v1/wiki-links", "epics/attachments": "http://127.0.0.1:8000/api/v1/epics/attachments", "issues/custom-attributes-values": "http://127.0.0.1:8000/api/v1/issues/custom-attributes-values

Opriți serverul backend Taiga apăsând " ctrl + C" și dezactivați mediul virtual.

deactivate

Instalați Frontend

Frontendul Taiga este componenta Taiga care servește interfața utilizatorului Web. Clonați depozitul de front-uri Taiga din Github și verificați cea mai recentă sucursală stabilă.

cd ~
git clone https://github.com/taigaio/taiga-front-dist.git taiga-front-dist
cd taiga-front-dist
git checkout stable

Creați un nou fișier de configurare pentru frontendul Taiga.

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

Populați fișierul.

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

Asigurați-vă că înlocuiți domeniul example domaincu domeniul real. De asemenea, puteți modifica limba implicită și alți parametri în configurația de mai sus.

Instalați evenimente Taiga

În afară de frontend și backend, trebuie să instalăm și evenimente Taiga. Evenimentele Taiga este un server de socket web și permite frontend-ului Taiga să afișeze schimbări în timp real în module cum ar fi backlog, Kanban și altele. De asemenea, utilizează serverul RabbitMQ pentru procesarea mesajelor.

Clonați depozitul de evenimente Taiga de la Github.

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

Instalați dependențele Node.js folosind npm.

npm install

Creați un nou fișier de configurare pentru evenimentele Taiga.

nano ~/taiga-events/config.json

Populați fișierul.

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

Înlocuiți Generated_Secret_Keycu cheia secretă lungă de 64 de caractere pe care ați generat-o anterior. Cheia secretă ar trebui să fie exact aceeași cu cea oferită în fișierul de configurare Taiga backend. De asemenea, actualizați StrongMQPasswordparola cu utilizatorul coada de mesaje Taiga.

Configurați Circul

Circus este un manager de proces pentru aplicațiile Python. Vom folosi Circus pentru a rula backend-ul și evenimentele Taiga.

Comutați înapoi la sudoutilizator.

exit

Notă : De acum, va trebui să rulați comenzile cu sudoutilizatorul.

sudo apt -y install circus

Creați un nou fișier de configurare Circus pentru rularea backend-ului Taiga.

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

Populați fișierul.

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

Creați o nouă configurație Circus pentru rularea evenimentelor Taiga.

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

Populați fișierul.

[watcher:taiga-events]
working_dir = /home/taiga/taiga-events
cmd = /usr/local/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

Reporniți Circus și activați pornirea automat la momentul de pornire.

sudo systemctl restart circusd
sudo systemctl enable circusd

Verificați starea Circus.

circusctl status

Dacă Circus a început toate procesele Taiga corect, atunci veți vedea următorul rezultat.

user@vultr:~$ circusctl status
circusd-stats: active
plugin:flapping: active
taiga: active
taiga-events: active

Dacă vreunul dintre proces nu este activ, rulați sudo chmod -R 777 /home/taiga/logsși reporniți Circus. Verificați din nou starea proceselor Circus, de data aceasta veți găsi cu siguranță serviciul care funcționează.

Acum, avem Taiga instalat și rulat cu succes. Înainte de a o folosi, trebuie să expunem instalarea folosind orice server web de producție.

Instalați Nginx ca proxy invers

Vom folosi Nginx ca proxy invers pentru a servi aplicația utilizatorilor. De asemenea, vom obține și vom instala certificate SSL de la Let's Encrypt.

Certbot este clientul oficial care eliberează certificate pentru Let's Encrypt CA. Adăugați depozitul Certbot PPA în sistem.

sudo add-apt-repository ppa:certbot/certbot
sudo apt update

Instalați Nginx și Certbot.

sudo apt -y install nginx certbot

Notă : Pentru a obține certificate de la Let's Encrypt CA, trebuie să vă asigurați că domeniul pentru care doriți să generați certificatele este îndreptat către server. Dacă nu, atunci faceți modificările necesare la înregistrările DNS ale domeniului dvs. și așteptați propagarea DNS înainte de a face din nou cererea de certificat. Certbot verifică autoritatea domeniului înainte de furnizarea certificatelor.

Acum utilizați serverul web încorporat în Certbot pentru a genera certificatele pentru domeniul dvs.

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

Este posibil ca certificatele generate să fie stocate în /etc/letsencrypt/live/taiga.example.com/director. Certificatul SSL vor fi păstrate fullchain.pem, iar cheia privată va fi salvat ca privkey.pem.

Haideți să criptați certificatele expiră în 90 de zile, de aceea este recomandat să configurați reînnoirea automată a certificatelor folosind joburi Cron. Cron este un serviciu de sistem care este utilizat pentru a executa sarcini periodice.

Deschideți fișierul de job cron.

sudo crontab -e

Adăugați următoarea linie.

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

Slujba cron de mai sus va rula zilnic la miezul nopții. În cazul în care certificatul expiră, acesta va reînnoi automat certificatele.

Generați un parametru puternic Diffie-Hellman. Acesta oferă un nivel suplimentar de securitate pentru schimbul de date între gazdă și server.

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

Creați un nou bloc de server Nginx pentru a servi frontendul Taiga.

sudo nano /etc/nginx/sites-available/taiga

Populați fișierul cu următoarele.

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;

}

Asigurați-vă că schimbați domain nameși path to the SSL certificates. Activați gazda virtuală.

sudo ln -s /etc/nginx/sites-available/taiga /etc/nginx/sites-enabled/taiga

Acum puteți reporni serverul web Nginx și îl puteți porni automat la pornire.

sudo systemctl restart nginx
sudo systemctl status nginx

În cele din urmă, reparați proprietatea și permisiunea pe fișierele Taiga.

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

Concluzie

Acum puteți accesa instalarea Taiga accesând https://taiga.example.com. Conectați-vă folosind contul de administrator inițial cu numele de utilizator " admin" și parola " 123123". Instalarea dvs. este acum gata pentru utilizare. Începeți prin a crea un proiect nou sau a evalua produsul. Dacă deja gestionați un proiect pe Github, Jira sau Trello, puteți importa cu ușurință proiectele în Taiga utilizând importatorii .