Cum se instalează Instrumentul de gestionare a proiectelor Taiga pe CentOS 7

• Cerințe preliminare
• Instalați PostgreSQL
• Instalați Python 3
• 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 CentOS 7 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 actualizați CentOS 7 . 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 cunoscut pentru stabilitatea și viteza sa. Taiga folosește PostgreSQL pentru a stoca baza de date. Adăugați depozitul PostgreSQL în sistem.

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

Instalați serverul de baze de date PostgreSQL.

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

Inițializează baza de date.

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

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

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

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 3

Python 2.7 vine preinstalat pe un server CentOS 7, dar Taiga necesită Python versiunea 3.4 sau mai recentă.

Vom instala Python versiunea 3.6 de la sursă. Instalați instrumentele de compilare necesare și compilatorul.

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

Descărcați codul sursă Python.

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

Extrageți și configurați instalarea Python.

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

Faceți o instalare alternativă.

sudo make altinstall

Notă : Instalările alternative instalează Python 3.6 fără a înlocui versiunea implicită a Python. Dacă înlocuiți Python-ul implicit în CentOS 7, acesta poate sparge YUMmanagerul de depozitare.

Acum veți putea verifica versiunea sa.

python3.6 -V

Ar trebui să vedeți următoarele.

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

Instalați Python Virtual Environment folosind pip.

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

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.

Instalați RabbitMQ

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

sudo yum -y install erlang

Importați cheia de semnare GPG RabbitMQ.

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

Instalați RabbitMQ.

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

Porniți și activați serverul RabbitMQ.

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

Adăugați RabbitMQ utilizator ș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://rpm.nodesource.com/setup_8.x | sudo -E bash -

Instalați Node.js și pwgenutilitarul.

sudo yum install -y nodejs pwgen

pwgenva fi folosit ulterior pentru a genera un șir secret puternic. Instalați CoffeeScript, deoarece va fi utilizat pentru a compila fișierele Taiga scrise cu 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 useradd -s /bin/bash 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

Configurați-vă virtualenvwrappersă utilizați Python 3.6 în loc de Python implicit.

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

În cele din urmă, sursa ~/.bashrcfișierul.

source ~/.bashrc

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

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

Instalați dependențele necesare Python folosind pip.

pip3.6 install -r requirements.txt

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

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

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.6 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
CZfjWjHctPwnLZsDysWqaZcYfRCviHbI4fVRwfhpbtAHPNBtmkcegpwpYjTtEziJ

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

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

Populați fișierul cu următorul cod.

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ă înlocuiți numele de domeniu exemplu cu cel 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 decomanda opțiunile de e-mail și puteți seta valorile 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 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.

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/
{"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",

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 cu aceasta.

{
    "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 exampledomeniul cu cel 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. 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 cu următoarele.

{
    "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 în trecut. 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 și evenimente Taiga.

Comutați înapoi la sudoutilizator.

exit

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

Instalați Circus folosind pip.

sudo pip3.6 install circus

Creați noi directoare pentru a stoca configurațiile Circus.

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

Creați fișierul de configurare implicit pentru Circus.

sudo nano /etc/circus/circus.ini

Populați fișierul cu următoarea configurație.

[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

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 cu următoarele.

[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

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

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

Populați fișierul cu următoarele.

[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

Acum va trebui să creăm un systemdfișier service pentru a rula Circus. Utilizarea se systemdva asigura că Circus este pornit automat în timpul repornirii și eșecurilor.

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

Populați fișierul.

[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

Porniți Circus și activați pornirea automat la ora de pornire.

sudo systemctl start circus
sudo systemctl enable circus

Verificați starea Circus.

circusctl status

Veți vedea următoarea ieșire.

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

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 serverul web 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.

Instalați Nginx și Certbot. Certbot este clientul oficial care eliberează certificate pentru Let's Encrypt CA.

sudo yum -y install nginx certbot

Ajustați setarea firewallului pentru a permite standardul HTTPși HTTPSporturile prin firewall, deoarece Certbot trebuie să creeze o conexiune HTTP pentru verificarea autorității domeniului.

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

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 Diffie-Hellmanparametru puternic . 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/conf.d/taiga.conf

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 numele de domeniu și calea către certificatele SSL.

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 .