Jak zainstalować narzędzie do zarządzania projektami Taiga na Ubuntu 16.04

• Wymagania wstępne
• Zainstaluj PostgreSQL
• Zainstaluj Python
• Zainstaluj RabbitMQ
• Zainstaluj Nodejs
• Zainstaluj tajdze Backend
• Zainstaluj Frontend
• Zainstaluj wydarzenia Taiga
• Skonfiguruj Circus
• Zainstaluj Nginx jako odwrotny serwer proxy
• Wniosek

Taiga to darmowa i otwarta aplikacja do zarządzania projektami. W przeciwieństwie do innych narzędzi do zarządzania projektami, Taiga stosuje przyrostowe zwinne podejście do zarządzania rozwojem projektu. Taiga to bardzo potężna i całkowicie konfigurowalna aplikacja. Backend Taiga jest napisany w Pythonie przy użyciu frameworka Django. Frontend jest napisany w JavaScript przy użyciu frameworków CoffeeScript i AngularJS. Taiga zawiera takie funkcje, jak współpraca przy projekcie, tablica Kanban, śledzenie błędów, raportowanie, śledzenie czasu, zaległości, wiki i inne.

Wymagania wstępne

• Instancja serwera Vultr Ubuntu 16.04 z co najmniej 1 GB pamięci RAM.
• Użytkownik sudo .

W tym samouczku użyjemy taiga.example.comjako nazwy domeny wskazanej na serwerze. Zamień wszystkie wystąpienia na taiga.example.comswoją rzeczywistą nazwę domeny.

Zaktualizuj system podstawowy, korzystając z przewodnika Jak zaktualizować system Ubuntu 16.04 . Po zaktualizowaniu systemu przejdź do instalacji PostgreSQL.

Zainstaluj PostgreSQL

PostgreSQL to obiektowo-relacyjny system baz danych znany ze swojej stabilności i szybkości. Taiga używa PostgreSQL do przechowywania swojej bazy danych. Dodaj repozytorium PostgreSQL do systemu.

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

Zaimportuj klucz do podpisywania GPG i zaktualizuj listy pakietów.

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

Zainstaluj serwer bazy danych PostgreSQL.

sudo apt -y install postgresql

Uruchom serwer PostgreSQL i włącz go automatycznie podczas uruchamiania.

sudo systemctl start postgresql
sudo systemctl enable postgresql

Zmień hasło dla domyślnego użytkownika PostgreSQL.

sudo passwd postgres

Zaloguj się jako użytkownik PostgreSQL.

sudo su - postgres

Utwórz nowego użytkownika PostgreSQL dla Taiga.

createuser taiga 

PostgreSQL zapewnia psqlpowłokę do uruchamiania zapytań w bazie danych. Przejdź do powłoki PostgreSQL.

psql

Ustaw hasło dla nowo utworzonego użytkownika dla bazy danych Taiga.

ALTER USER taiga WITH ENCRYPTED password 'DBPassword';

Zastąp DBPasswordbezpiecznym hasłem. Utwórz nową bazę danych dla instalacji Taiga.

CREATE DATABASE taiga OWNER taiga;

Wyjdź ze psqlskorupy.

\q

Przejdź do sudoużytkownika.

exit

Zainstaluj Python

Taiga wymaga Pythona w wersji 3.4 lub nowszej, a Python 3.5 jest wstępnie zainstalowany w dystrybucji Ubuntu 16.04. Zainstaluj jeszcze kilka wymaganych pakietów.

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

Środowisko wirtualne Python służy do tworzenia izolowanego środowiska wirtualnego dla projektu Python. Środowisko wirtualne zawiera własne katalogi instalacyjne i nie udostępnia bibliotek globalnym ani innym środowiskom wirtualnym. Po pomyślnym zainstalowaniu Python 3 powinieneś być w stanie sprawdzić jego wersję.

python3 -V

Zobaczysz następujące.

user@vultr:~$ python3 -V
Python 3.5.2

Aktualizacja pip, która jest aplikacją menedżera zależności.

sudo pip3 install --upgrade setuptools pip 

Zainstaluj także kilka narzędzi do budowania, które będą wymagane później do skompilowania zależności.

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

Zainstaluj RabbitMQ

Taiga używa RabbitMQ do przetwarzania kolejki komunikatów. RabbitMQ wymaga bibliotek Erlang do działania. Zainstaluj Erlang.

sudo apt -y install erlang

Dodaj repozytorium RabbitMQ.

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

Zaimportuj klucz do podpisywania GPG RabbitMQ.

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

Zaktualizuj informacje o repozytorium.

sudo apt update

Zainstaluj RabbitMQ.

sudo apt -y install rabbitmq-server

Uruchom i włącz serwer RabbitMQ.

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

Dodaj użytkownika RabbitMQ i vhost. Udziel także użytkownikowi uprawnień za pośrednictwem hosta.

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

Pamiętaj, aby zastąpić StrongMQPasswordje bezpiecznym hasłem.

Zainstaluj Nodejs

Node.js w wersji 7 lub nowszej jest wymagany do kompilacji interfejsu użytkownika Taiga. Dodaj repozytorium Node.js w wersji 8.

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

Zainstaluj Node.js i pwgennarzędzie.

sudo apt install -y nodejs pwgen npm

pwgenzostaną wykorzystane później do wygenerowania silnego tajnego ciągu. Zainstaluj CoffeeScript, ponieważ będzie on używany do kompilacji plików tajgi zapisanych w frameworku CoffeeScript.

sudo npm install -g coffee-script gulp

Zainstaluj tajdze Backend

Dodaj nowego użytkownika systemu dla Taiga, aby mieć pewność, że procesy Taiga będą działać jako użytkownik nieuprzywilejowany.

sudo adduser taiga
sudo su - taiga

Uwaga : od tej pory wszystkie polecenia muszą być uruchamiane jako użytkownik nieuprzywilejowany, taigadopóki nie zostaniesz poproszony o powrót do sudoużytkownika.

Utwórz nowy katalog do przechowywania plików dziennika.

mkdir -p ~/logs

Sklonuj repozytorium zaplecza Taiga z GitHub i sprawdź najnowszą stabilną gałąź.

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

Teraz utwórz nowe środowisko wirtualne dla Taiga za pomocą Python 3.

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

Zainstaluj wymagane zależności Pythona za pomocą pip.

pip3 install -r requirements.txt

Zapełnij bazę danych niezbędnymi danymi początkowymi.

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

Powyższe polecenia zapisują dane w bazie danych PostgreSQL. Taiga dostarcza również niektóre dane demonstracyjne lub przykładowe, które mogą być przydatne do oceny produktu. Jeśli chcesz zainstalować przykładowe dane, uruchom następujące polecenie.

python3 manage.py sample_data

Uwaga : Instalowanie przykładowych danych jest opcjonalne i służy wyłącznie do oceny produktu.

Zanim przystąpimy do tworzenia pliku konfiguracyjnego dla zaplecza Taiga, musimy wygenerować tajny ciąg. Ten ciąg będzie używany do szyfrowania danych sesji.

Wygeneruj losowy ciąg 64 znaków.

pwgen -s -1 64

Powinieneś zobaczyć wynik jako ciąg losowy.

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

Utwórz nowy plik konfiguracyjny dla zaplecza Taiga.

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

Wypełnij plik następującym kodem.

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"

Pamiętaj, aby zastąpić example domain namerzeczywistą z powyższego kodu. Zastąp Generated_Secret_Keytakże rzeczywistym tajnym kluczem i StrongMQPasswordrzeczywistym hasłem użytkownika kolejki komunikatów Taiga. Jeśli masz gotowy serwer SMTP i chcesz natychmiast korzystać z funkcji wysyłania wiadomości e-mail, możesz cofnąć zaznaczenie opcji e-mail i ustawić odpowiednią wartość. Jeśli nie masz gotowego serwera poczty, możesz na razie pominąć konfigurowanie funkcji poczty e-mail i ustawić ją później w tym pliku konfiguracyjnym.

Jeśli chcesz włączyć logowanie GitHub, utwórz aplikację w GitHub i podaj identyfikator klienta API oraz klucz tajny klienta.

Aby natychmiast sprawdzić, czy można uruchomić backend Taiga, uruchom wbudowany serwer Django.

workon taiga
python manage.py runserver

Jeśli serwer uruchomił się pomyślnie, zobaczysz następujące dane wyjściowe.

(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.

Aby sprawdzić, czy można uzyskać dostęp do interfejsu API, otwórz kolejną sesję terminala i uruchom następujące.

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

Zobaczysz podobne wyniki zwrócone przez wywołanie 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

Zatrzymaj serwer zaplecza Taiga, naciskając „ ctrl + C” i dezaktywuj środowisko wirtualne.

deactivate

Zainstaluj Frontend

Interfejs Taiga jest komponentem Taiga, który obsługuje interfejs użytkownika sieci. Sklonuj repozytorium frontonu Taiga od Github i sprawdź najnowszą stabilną gałąź.

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

Utwórz nowy plik konfiguracyjny dla frontonu Taiga.

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

Wypełnij plik.

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

Pamiętaj, aby zastąpić example domainrzeczywistą domeną. Możesz także zmienić domyślny język i inne parametry w powyższej konfiguracji.

Zainstaluj wydarzenia Taiga

Oprócz frontendu i backendu musimy także zainstalować wydarzenia Taiga. Wydarzenia Taiga to serwer z gniazdami sieciowymi, który pozwala frontendowi Taiga wyświetlać w czasie rzeczywistym zmiany w modułach, takich jak zaległości, Kanban i inne. Wykorzystuje również serwer RabbitMQ do przetwarzania wiadomości.

Sklonuj repozytorium wydarzeń Taiga z Github.

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

Zainstaluj zależności Node.js za pomocą npm.

npm install

Utwórz nowy plik konfiguracyjny dla wydarzeń w Tajdze.

nano ~/taiga-events/config.json

Wypełnij plik.

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

Zamień Generated_Secret_Keyna faktyczny tajny klucz o długości 64 znaków, który wcześniej wygenerowałeś. Tajny klucz powinien być dokładnie taki sam, jak klucz podany w pliku konfiguracyjnym zaplecza Taiga. Zaktualizuj także StrongMQPasswordrzeczywiste hasło użytkownika kolejki wiadomości Taiga.

Skonfiguruj Circus

Circus jest menedżerem procesów dla aplikacji w języku Python. Użyjemy Circus do zarządzania zapleczem i wydarzeniami Taiga.

Wróć do sudoużytkownika.

exit

Uwaga : od tej chwili będziesz musiał uruchamiać polecenia za pomocą sudoużytkownika.

sudo apt -y install circus

Utwórz nowy plik konfiguracyjny Circus do uruchamiania backendu Taiga.

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

Wypełnij plik.

[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

Utwórz nową konfigurację Circus do obsługi wydarzeń z Tajgi.

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

Wypełnij plik.

[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

Uruchom ponownie Circus i włącz automatyczne uruchamianie w czasie rozruchu.

sudo systemctl restart circusd
sudo systemctl enable circusd

Sprawdź status Circus.

circusctl status

Jeśli Circus poprawnie uruchomił wszystkie procesy Tajgi, zobaczysz następujące dane wyjściowe.

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

Jeśli zauważysz, że którykolwiek z procesów nie jest aktywny, uruchom sudo chmod -R 777 /home/taiga/logsi uruchom ponownie Circus. Sprawdź ponownie status procesów Circus, tym razem na pewno znajdziesz działającą usługę.

Teraz pomyślnie zainstalowaliśmy i uruchomiliśmy Taiga. Zanim będziemy mogli go użyć, musimy ujawnić instalację za pomocą dowolnego produkcyjnego serwera WWW.

Zainstaluj Nginx jako odwrotny serwer proxy

Będziemy używać Nginx jako odwrotnego proxy do obsługi aplikacji dla użytkowników. Otrzymamy również i zainstalujemy certyfikaty SSL od Let's Encrypt.

Certbot to oficjalny klient wystawiający certyfikaty Let's Encrypt CA. Dodaj repozytorium Certbot PPA do systemu.

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

Zainstaluj Nginx i Certbot.

sudo apt -y install nginx certbot

Uwaga : Aby uzyskać certyfikaty z Let's Encrypt CA, musisz upewnić się, że domena, dla której chcesz wygenerować certyfikaty, jest skierowana w stronę serwera. Jeśli nie, dokonaj niezbędnych zmian w rekordach DNS swojej domeny i poczekaj na propagację DNS przed ponownym żądaniem certyfikatu. Certbot sprawdza urząd domeny przed podaniem certyfikatów.

Teraz użyj wbudowanego serwera WWW w Certbot, aby wygenerować certyfikaty dla swojej domeny.

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

Wygenerowane certyfikaty prawdopodobnie będą przechowywane w /etc/letsencrypt/live/taiga.example.com/katalogu. Certyfikat SSL zostanie zachowany jako fullchain.pem, a klucz prywatny zostanie zapisany jako privkey.pem.

Ważność certyfikatów Let's Encrypt wygasa za 90 dni, dlatego zaleca się skonfigurowanie automatycznego odnawiania certyfikatów za pomocą zadań Cron. Cron to usługa systemowa służąca do wykonywania zadań okresowych.

Otwórz plik zadania cron.

sudo crontab -e

Dodaj następujący wiersz.

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

Powyższe zadanie crona będzie uruchamiane codziennie o północy. Jeśli certyfikat wygasa, automatycznie odnowi certyfikaty.

Wygeneruj silny parametr Diffie-Hellmana. Zapewnia dodatkową warstwę bezpieczeństwa przy wymianie danych między hostem a serwerem.

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

Utwórz nowy blok serwera Nginx, aby obsługiwał frontend Taiga.

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

Wypełnij plik następującymi danymi.

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;

}

Pamiętaj, aby zmienić domain namei path to the SSL certificates. Włącz wirtualny host.

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

Teraz możesz zrestartować serwer WWW Nginx i umożliwić mu automatyczne uruchamianie przy starcie.

sudo systemctl restart nginx
sudo systemctl status nginx

Na koniec napraw własność i uprawnienia do plików Taiga.

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

Wniosek

Możesz teraz uzyskać dostęp do instalacji Taiga, przechodząc do https://taiga.example.com. Zaloguj się przy użyciu początkowego konta administratora z nazwą użytkownika „ admin” i hasłem „ 123123”. Twoja instalacja jest teraz gotowa do użytku produkcyjnego. Zacznij od utworzenia nowego projektu lub oceny produktu. Jeśli już zarządzasz projektem na Github, Jira lub Trello, możesz łatwo zaimportować projekty do Taiga za pomocą importerów .