Jak zainstalować narzędzie do zarządzania projektami Taiga na CentOS 7

• Wymagania wstępne
• Zainstaluj PostgreSQL
• Zainstaluj Python 3
• 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 CentOS 7 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 za pomocą przewodnika Jak zaktualizować CentOS 7 . Po zaktualizowaniu systemu przejdź do instalacji PostgreSQL.

Zainstaluj PostgreSQL

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

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

Zainstaluj serwer bazy danych PostgreSQL.

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

Zainicjuj bazę danych.

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

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

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

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 3

Python 2.7 jest fabrycznie zainstalowany na serwerze CentOS 7, ale Taiga wymaga Pythona w wersji 3.4 lub nowszej.

Zainstalujemy Python w wersji 3.6 ze źródła. Zainstaluj wymagane narzędzia do kompilacji i kompilator.

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

Pobierz kod źródłowy Python.

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

Wyodrębnij i skonfiguruj instalację Pythona.

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

Wykonaj alternatywną instalację.

sudo make altinstall

Uwaga : Alternatywne instalacje instalują Python 3.6 bez zastępowania domyślnej wersji Python. Jeśli zastąpisz domyślnego Pythona w CentOS 7, może to spowodować YUMuszkodzenie menedżera repozytorium.

Teraz będziesz mógł sprawdzić jego wersję.

python3.6 -V

Powinieneś zobaczyć następujące.

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

Zainstaluj środowisko wirtualne Python za pomocą pip.

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

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

Zainstaluj RabbitMQ

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

sudo yum -y install erlang

Zaimportuj klucz do podpisu RabbitMQ GPG.

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

Zainstaluj RabbitMQ.

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

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://rpm.nodesource.com/setup_8.x | sudo -E bash -

Zainstaluj Node.js i pwgennarzędzie.

sudo yum install -y nodejs pwgen

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 useradd -s /bin/bash 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

Skonfiguruj virtualenvwrapperużycie Pythona 3.6 zamiast domyślnego Pythona.

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

Wreszcie źródło ~/.bashrcpliku.

source ~/.bashrc

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

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

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

pip3.6 install -r requirements.txt

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

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

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

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ć przykładową nazwę domeny rzeczywistą nazwą w powyższym kodzie. 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ć odpowiednie wartości. 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 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.

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

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 ten plik tym.

{
    "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ć exampledomenę rzeczywistą 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 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 następującymi danymi.

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

Zamień Generated_Secret_Keyna rzeczywisty tajny klucz o długości 64 znaków, który wygenerowałeś w przeszłości. 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.

Zainstaluj Circus używając pip.

sudo pip3.6 install circus

Utwórz nowe katalogi do przechowywania konfiguracji Circus.

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

Utwórz domyślny plik konfiguracyjny dla Circus.

sudo nano /etc/circus/circus.ini

Wypełnij plik następującą konfiguracją.

[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

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

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

Wypełnij plik następującymi danymi.

[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

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

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

Wypełnij plik następującymi danymi.

[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

Teraz będziemy musieli utworzyć systemdplik usługi, aby uruchomić Circus. Użycie systemdzapewni automatyczne uruchamianie programu Circus podczas ponownego uruchamiania i awarii.

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

Wypełnij plik.

[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

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

sudo systemctl start circus
sudo systemctl enable circus

Sprawdź status Circus.

circusctl status

Zobaczysz następujące dane wyjściowe.

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

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ć serwera internetowego Nginx jako odwrotnego proxy do obsługi aplikacji dla użytkowników. Otrzymamy również i zainstalujemy certyfikaty SSL od Let's Encrypt.

Zainstaluj Nginx i Certbot. Certbot to oficjalny klient wystawiający certyfikaty Let's Encrypt CA.

sudo yum -y install nginx certbot

Dostosuj ustawienia zapory, aby zezwalać na standard HTTPi HTTPSporty przez zaporę, ponieważ Certbot musi nawiązać połączenie HTTP w celu weryfikacji uprawnień do domeny.

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

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

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 o zmianie nazwy domeny i ścieżki do certyfikatów SSL.

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 .