Come installare Taiga Project Management Tool su CentOS 7

• Prerequisiti
• Installa PostgreSQL
• Installa Python 3
• Installa RabbitMQ
• Installa Nodejs
• Installa Taiga Backend
• Installa Frontend
• Installa Taiga Events
• Configura Circo
• Installa Nginx come proxy inverso
• Conclusione

Taiga è un'applicazione gratuita e open source per la gestione dei progetti. A differenza di altri strumenti di gestione del progetto, Taiga utilizza un approccio agile incrementale per gestire lo sviluppo del progetto. Taiga è un'applicazione molto potente e completamente personalizzabile. Il backend di Taiga è scritto in Python usando il framework Django. Il frontend è scritto in JavaScript usando i framework CoffeeScript e AngularJS. Taiga include funzionalità come collaborazione di progetto, Kanban board, tracciamento dei bug, reportistica, tracciamento dei tempi, backlog, wiki e altro.

Prerequisiti

• Un'istanza del server Vultr CentOS 7 con almeno 1 GB di RAM.
• Un utente sudo .

In questo tutorial, useremo taiga.example.comcome nome di dominio puntato al server. Sostituisci tutte le occorrenze di taiga.example.comcon il tuo vero nome di dominio.

Aggiorna il tuo sistema di base usando la guida Come aggiornare CentOS 7 . Dopo aver aggiornato il sistema, procedere con l'installazione di PostgreSQL.

Installa PostgreSQL

PostgreSQL è un sistema di database relazionale ad oggetti noto per la sua stabilità e velocità. Taiga utilizza PostgreSQL per memorizzare il suo database. Aggiungi il repository PostgreSQL nel sistema.

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

Installa il server di database PostgreSQL.

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

Inizializza il database.

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

Avviare il server PostgreSQL e abilitarlo ad avviarsi automaticamente all'avvio.

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

Cambia la password per l'utente PostgreSQL predefinito.

sudo passwd postgres

Accedi come utente PostgreSQL.

sudo su - postgres

Crea un nuovo utente PostgreSQL per Taiga.

createuser taiga 

PostgreSQL fornisce la psqlshell per eseguire query sul database. Passa alla shell PostgreSQL.

psql

Imposta una password per l'utente appena creato per il database Taiga.

ALTER USER taiga WITH ENCRYPTED password 'DBPassword';

Sostituisci DBPasswordcon una password sicura. Crea un nuovo database per l'installazione di Taiga.

CREATE DATABASE taiga OWNER taiga;

Esci dalla psqlshell.

\q

Passa sudoall'utente.

exit

Installa Python 3

Python 2.7 viene preinstallato su un server CentOS 7, ma Taiga richiede Python versione 3.4 o successive.

Installeremo Python versione 3.6 dal sorgente. Installa gli strumenti di compilazione e il compilatore richiesti.

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

Scarica il codice sorgente di Python.

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

Estrai e configura l'installazione di Python.

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

Fai un'installazione alternativa.

sudo make altinstall

Nota : installazioni alternative installano Python 3.6 senza sostituire la versione predefinita di Python. Se si sostituisce Python predefinito in CentOS 7, è possibile che il YUMgestore del repository venga interrotto .

Ora sarai in grado di verificarne la versione.

python3.6 -V

Dovresti vedere quanto segue.

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

Installa Python Virtual Environment usando pip.

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

L'ambiente virtuale Python viene utilizzato per creare un ambiente virtuale isolato per un progetto Python. Un ambiente virtuale contiene le proprie directory di installazione e non condivide le librerie con ambienti globali e altri ambienti virtuali.

Installa RabbitMQ

Taiga utilizza RabbitMQ per elaborare la coda dei messaggi. RabbitMQ richiede che le librerie Erlang funzionino. Installa Erlang.

sudo yum -y install erlang

Importa chiave di firma GPG RabbitMQ.

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

Installa RabbitMQ.

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

Avviare e abilitare il server RabbitMQ.

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

Aggiungi utente RabbitMQ e vhost. Inoltre, fornire l'autorizzazione all'utente tramite l'host.

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

Assicurati di sostituire StrongMQPasswordcon una password sicura.

Installa Nodejs

Node.js versione 7 o successive è necessario per compilare il frontend di Taiga. Aggiungi il repository versione 8 di Node.js.

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

Installa Node.js e l' pwgenutilità.

sudo yum install -y nodejs pwgen

pwgenverrà utilizzato in seguito per generare una stringa segreta avanzata. Installa CoffeeScript, poiché verrà utilizzato per compilare i file Taiga scritti con il framework CoffeeScript.

sudo npm install -g coffee-script gulp

Installa Taiga Backend

Aggiungi un nuovo utente di sistema per Taiga per garantire che i processi Taiga siano in esecuzione come utente senza privilegi.

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

Nota : d' ora in poi, tutti i comandi devono essere eseguiti come utente non privilegiato taigafino a quando non viene richiesto di tornare sudoall'utente.

Creare una nuova directory per archiviare i file di registro.

mkdir -p ~/logs

Clona il repository backend Taiga da GitHub e controlla l'ultimo ramo stabile.

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

Configurare virtualenvwrapperper utilizzare Python 3.6 anziché Python predefinito.

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

Infine, sorgente il ~/.bashrcfile.

source ~/.bashrc

Ora crea un nuovo ambiente virtuale per Taiga usando Python 3.6.

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

Installa le dipendenze Python richieste usando pip.

pip3.6 install -r requirements.txt

Popolare il database con i dati iniziali necessari.

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

I comandi precedenti scriveranno i dati nel database PostgreSQL. Taiga inoltre fornisce alcuni dati dimostrativi o di esempio che possono essere utili per la valutazione del prodotto. Se si desidera installare i dati di esempio, eseguire quanto segue.

python3.6 manage.py sample_data

Nota : l' installazione dei dati di esempio è facoltativa e ha il solo scopo di valutare il prodotto.

Prima di procedere con la creazione del file di configurazione per il backend Taiga, è necessario generare una stringa segreta. Questa stringa verrà utilizzata per crittografare i dati della sessione.

Genera una stringa casuale di 64 caratteri.

pwgen -s -1 64

Dovresti vedere l'output come una stringa casuale.

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

Crea un nuovo file di configurazione per il backend Taiga.

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

Popolare il file con il seguente codice.

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 = "mail@example.com"
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 = "mail@example.com"
#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"

Assicurati di sostituire il nome di dominio di esempio con quello attuale nel codice sopra. Inoltre, sostituiscilo Generated_Secret_Keycon la chiave segreta effettiva e StrongMQPasswordcon la password effettiva per l'utente della coda messaggi Taiga. Se hai un server SMTP pronto e desideri utilizzare immediatamente le funzionalità di invio e-mail, puoi decommentare le opzioni e-mail e impostare i valori appropriati. Se non si dispone di un server di posta pronto, è possibile saltare l'impostazione della funzione e-mail per ora e impostarla successivamente in questo file di configurazione.

Se si desidera abilitare l'accesso GitHub, creare un'applicazione in GitHub e fornire l'ID client API e il segreto client.

Per verificare immediatamente se è possibile avviare il backend Taiga, eseguire il server Django integrato.

workon taiga
python manage.py runserver

Verrà visualizzato il seguente output se il server è stato avviato correttamente.

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

Per verificare se è possibile accedere all'API, aprire un'altra sessione del terminale ed eseguire quanto segue.

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

Vedrai un output simile restituito dalla chiamata 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",

Arresta il server back-end Taiga premendo " Ctrl + C" e disattiva l'ambiente virtuale.

deactivate

Installa Frontend

Il frontend Taiga è il componente di Taiga che serve l'interfaccia utente Web. Clona il repository frontend Taiga da Github e controlla l'ultimo ramo stabile.

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

Crea un nuovo file di configurazione per il frontend Taiga.

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

Popolare il file con questo.

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

Assicurati di sostituire il exampledominio con il dominio effettivo. Puoi anche cambiare la lingua predefinita e altri parametri nella configurazione sopra.

Installa Taiga Events

Oltre al frontend e al backend, dobbiamo anche installare eventi Taiga. Taiga events è un server socket web e consente al frontend Taiga di mostrare le modifiche in tempo reale in moduli come backlog, Kanban e altro. Utilizza il server RabbitMQ per l'elaborazione dei messaggi.

Clona il repository di eventi Taiga da Github.

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

Installa le dipendenze Node.js usando npm.

npm install

Crea un nuovo file di configurazione per gli eventi Taiga.

nano ~/taiga-events/config.json

Popolare il file con il seguente.

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

Sostituisci Generated_Secret_Keycon l'attuale chiave segreta lunga 64 caratteri che hai generato in passato. La chiave segreta dovrebbe essere esattamente uguale alla chiave fornita nel file di configurazione del backend Taiga. Inoltre, aggiorna il StrongMQPasswordcon la password effettiva per l'utente della coda messaggi Taiga.

Configura Circo

Circus è un gestore dei processi per le applicazioni Python. Useremo Circus per eseguire il backend e gli eventi Taiga.

Torna sudoall'utente.

exit

Nota : da adesso dovrai eseguire i comandi usando l' sudoutente.

Installa Circus utilizzando pip.

sudo pip3.6 install circus

Crea nuove directory per archiviare le configurazioni Circus.

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

Crea il file di configurazione predefinito per Circus.

sudo nano /etc/circus/circus.ini

Popolare il file con la seguente configurazione.

[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 un nuovo file di configurazione Circus per eseguire il backend Taiga.

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

Popolare il file con il seguente.

[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 una nuova configurazione Circus per l'esecuzione di Eventi Taiga.

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

Popolare il file con il seguente.

[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

Ora avremo bisogno di creare un systemdfile di servizio per eseguire Circus. L'utilizzo systemdgarantirà l'avvio automatico di Circus durante il riavvio e gli errori.

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

Popolare il 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

Avvia Circus e abilita l'avvio automatico all'avvio.

sudo systemctl start circus
sudo systemctl enable circus

Controlla lo stato di Circus.

circusctl status

Vedrai il seguente output.

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

Ora abbiamo Taiga installato e funzionante con successo. Prima di poterlo utilizzare, è necessario esporre l'installazione utilizzando qualsiasi server Web di produzione.

Installa Nginx come proxy inverso

Useremo il web server Nginx come proxy inverso per servire l'applicazione agli utenti. Otterremo e installeremo anche certificati SSL da Let's Encrypt.

Installa Nginx e Certbot. Certbot è il client ufficiale per l'emissione di certificati per Let's Encrypt CA.

sudo yum -y install nginx certbot

Modifica le impostazioni del firewall per consentire lo standard HTTPe le HTTPSporte attraverso il firewall poiché Certbot deve stabilire una connessione HTTP per verificare l'autorità del dominio.

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

Nota : per ottenere certificati da Let's Encrypt CA, è necessario assicurarsi che il dominio per il quale si desidera generare i certificati sia puntato verso il server. In caso contrario, apporta le modifiche necessarie ai record DNS del tuo dominio e attendi che il DNS si propaghi prima di effettuare nuovamente la richiesta di certificato. Certbot controlla l'autorità di dominio prima di fornire i certificati.

Ora usa il web server integrato in Certbot per generare i certificati per il tuo dominio.

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

È probabile che i certificati generati siano archiviati nella /etc/letsencrypt/live/taiga.example.com/directory. Il certificato SSL verrà conservato come fullchain.peme la chiave privata verrà salvata come privkey.pem.

Let's Encrypt certificati scadranno tra 90 giorni, quindi si consiglia di impostare il rinnovo automatico per i certificati utilizzando i processi Cron. Cron è un servizio di sistema che viene utilizzato per eseguire attività periodiche.

Apri il file di lavoro cron.

sudo crontab -e

Aggiungi la seguente riga.

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

Il precedente cron job verrà eseguito ogni giorno a mezzanotte. Se il certificato è in scadenza, rinnoverà automaticamente i certificati.

Genera un Diffie-Hellmanparametro forte . Fornisce un ulteriore livello di sicurezza per lo scambio di dati tra host e server.

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

Crea un nuovo blocco server Nginx per servire il frontend Taiga.

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

Popolare il file con il seguente.

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;

}

Assicurati di modificare il nome di dominio e il percorso dei certificati SSL.

Ora puoi riavviare il web server Nginx e abilitarlo ad avviarsi automaticamente all'avvio.

sudo systemctl restart nginx
sudo systemctl status nginx

Infine, correggi la proprietà e l'autorizzazione sui file Taiga.

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

Conclusione

Ora puoi accedere all'installazione di Taiga andando su https://taiga.example.com. Accedi utilizzando l'account amministratore iniziale con nome utente " admin" e password " 123123". L'installazione è ora pronta per l'uso in produzione. Inizia creando un nuovo progetto o valutando il prodotto. Se stai già gestendo un progetto su Github, Jira o Trello, puoi importare facilmente i progetti in Taiga utilizzando gli importatori .