Ricerca nel sito web

Come installare Taiga Project Management System su Ubuntu 20.04

Su questa pagina

  1. Prerequisiti
  2. Per iniziare
  3. Installa Node.js
  4. Installa e configura PostgreSQL
  5. Installa RabbitMQ e Redis
  6. Installa e configura il backend Taiga
  7. Installa e configura Taiga Forntend
  8. Installa e configura l'evento Taiga
  9. Crea un file di servizio Systemd
  10. Configura Nginx come proxy inverso
  11. Accedi all'interfaccia utente web di Tails
  12. Conclusione

Taiga è uno strumento di gestione dei progetti gratuito, open source, semplice ma potente per startup, sviluppatori Agile e designer. Supporta i team che lavorano con Agile su entrambi i framework Scrum e Kanban. Il frontend è scritto in JavaScript mentre il backend è scritto in Python e Django. È un'applicazione molto potente e completamente personalizzabile e può gestire progetti sia semplici che complessi per sviluppatori e team. Può essere integrato facilmente con molti servizi tra cui Kanban, Scrum, Talky.io e Appear.in.

In questo tutorial, ti mostreremo come installare Taiga Project Management Tool sul server Ubuntu 20.04.

Prerequisiti

  • Un server che esegue Ubuntu 20.04.
  • Un nome di dominio valido indicato con l'IP del tuo server.
  • Il server è configurato con una password di root.

Iniziare

Innanzitutto, aggiorna i pacchetti di sistema all'ultima versione con il seguente comando:

apt-get update -y

Una volta aggiornati tutti i pacchetti, installa le altre dipendenze richieste per Taiga eseguendo il seguente comando:

apt-get install git gnupg2 pwgen automake wget curl gettext python3 virtualenvwrapper python3-dev python3-pip python3-dev libssl-dev tmux build-essential libgdbm-dev binutils-doc autoconf flex gunicorn bison libjpeg-dev libzmq3-dev libfreetype6-dev zlib1g-dev libncurses5-dev libtool libxslt-dev libxml2-dev libffi-dev

Successivamente, dovrai impostare un nome host completo sul tuo sistema. Puoi impostarlo con il seguente comando:

hostnamectl set-hostname taiga.example.com

Successivamente, dovrai associare il tuo nome host con il tuo indirizzo IP. Puoi farlo modificando il file /etc/hosts:

nano /etc/hosts

Aggiungi le seguenti righe:

your-server-ip taiga.example.com

Salva e chiudi il file quando hai finito.

Installa Node.js

Successivamente, dovrai installare Node.js sul tuo sistema. Per impostazione predefinita, l'ultima versione di Node.js non è disponibile nel repository predefinito di Ubuntu 20.04. Quindi dovrai aggiungere il repository Node.js al tuo sistema. Puoi aggiungerlo con il seguente comando:

curl -sL https://deb.nodesource.com/setup_12.x | bash -

Una volta aggiunto il repository, installa l'ultima versione di Node.js con il seguente comando:

apt-get install nodejs -y

Dopo aver installato Node.js, verifica la versione installata di Node.js con il seguente comando:

node -v

Dovresti ottenere il seguente output:

v12.19.0

Installa e configura PostgreSQL

Taiga utilizza il server PostgreSQL come back-end del database. Quindi dovrai installarlo nel tuo sistema. Innanzitutto, aggiungi la chiave GPG PostgreSQL con il seguente comando:

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

Successivamente, aggiungi il repository PostgreSQL con il seguente comando:

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

Successivamente, aggiorna il repository e installa l'ultima versione di PostgreSQL con il seguente comando:

apt-get update -y
apt-get install postgresql -y

Quindi, modifica la password PostgreSQL con il seguente comando:

passwd postgres

Dovresti ottenere il seguente output:

New password: 
Retype new password: 
passwd: password updated successfully

Successivamente, cambia l'utente in postgres e crea un utente per Taiga:

su - postgres
:~$ createuser taiga

Successivamente, accedi alla shell PostgreSQL con il seguente comando:

:~$ psql

Produzione:

psql (13.0 (Ubuntu 13.0-1.pgdg20.04+1))
Type "help" for help.

Una volta effettuato l'accesso, creare un utente e un database con il seguente comando:

postgres=# ALTER USER taiga WITH ENCRYPTED password 'yourpassword';
postgres=# CREATE DATABASE taiga OWNER taiga;

Successivamente, esci dalla shell e dall'utente PostgreSQL con il seguente comando:

postgres=# \q
:~$ exit

Installa RabbitMQ e Redis

Taiga utilizza RabbitMQ come broker di messaggi e Redis per la memorizzazione nella cache. Quindi dovrai installare entrambi i pacchetti nel tuo sistema. Puoi installare entrambi i pacchetti con il seguente comando:

apt-get install rabbitmq-server redis-server -y

Successivamente, crea un nuovo utente e host virtuale per RabbitMQ con il seguente comando:

rabbitmqctl add_user taiga yourpassword
rabbitmqctl add_vhost taiga
rabbitmqctl set_permissions -p taiga taiga ".*" ".*" ".*"

Una volta terminato, puoi procedere al passaggio successivo.

Installa e configura il backend Taiga

Innanzitutto, crea un utente separato per Taiga con il seguente comando:

adduser taiga

Successivamente, aggiungi l'utente Taiga al gruppo sudo usando il seguente comando:

adduser taiga sudo

Quindi, cambia l'utente in taiga e crea una directory per archiviare i registri di taiga:

su - taiga
mkdir -p ~/logs

Successivamente, scarica il backend Taiga dal repository Git con il seguente comando:

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

Quindi, cambia la directory nella directory scaricata e controlla l'ultimo ramo:

cd taiga-back
git checkout stable

Quindi, attiva il comando mkvirtualenv con il seguente comando:

nano ~/.bashrc

Aggiungi la seguente riga:

source '/usr/share/virtualenvwrapper/virtualenvwrapper.sh'

Attiva il nuovo profilo con il seguente comando:

source ~/.bashrc

Successivamente, crea un ambiente virtuale Python per Taiga:

mkvirtualenv -p /usr/bin/python3 taiga_venv

Successivamente, installa tutte le dipendenze richieste con il seguente comando:

pip3 install -r requirements.txt

Successivamente, migra e carica i dati con il seguente comando:

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

Successivamente, dovrai modificare il file local.py e definire le impostazioni dell'applicazione e del database:

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

Aggiungi le seguenti righe:

from .common import *

MEDIA_URL = "http://taiga.example.com/media/"
STATIC_URL = "http://taiga.example.com/static/"
SITES["front"]["scheme"] = "http"
SITES["front"]["domain"] = "taiga.example.com"

SECRET_KEY = "OQOEJNSJIQHDBQNSUQEJSNNANsqQPAASQLSMSOQND"

DEBUG = False
PUBLIC_REGISTER_ENABLED = True

DEFAULT_FROM_EMAIL = ""
SERVER_EMAIL = DEFAULT_FROM_EMAIL

#CELERY_ENABLED = True

EVENTS_PUSH_BACKEND = "taiga.events.backends.rabbitmq.EventsPushBackend"
EVENTS_PUSH_BACKEND_OPTIONS = {"url": "amqp://taiga::5672/taiga"}

Salva e chiudi il file, quindi avvia il server back-end Taiga con il seguente comando:

workon taiga_venv
python manage.py runserver

Una volta avviato correttamente il server, dovresti ottenere il seguente output:

System check identified no issues (0 silenced).
November 02, 2020 - 09:24:41
Django version 2.2.16, using settings 'settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Premere CTRL + C per arrestare il server.

Successivamente, disattivare l'ambiente virtuale con il seguente comando:

deactivate

Installa e configura Taiga Forntend

Innanzitutto, cambia l'utente in Taiga e scarica l'ultima versione del frontend Taiga dal repository Git:

su - taiga
git clone https://github.com/taigaio/taiga-front-dist.git

Cambia la directory nella directory scaricata e controlla l'ultimo ramo stabile con il seguente comando:

cd taiga-front-dist
git checkout stable

Successivamente, copia il file di configurazione di esempio con il seguente comando:

cp ~/taiga-front-dist/dist/conf.example.json ~/taiga-front-dist/dist/conf.json

Quindi, modifica il file di configurazione con il seguente comando:

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

Modifica le seguenti righe:

{
    "api": "http://taiga.example.com/api/v1/",
    "eventsUrl": "ws://taiga.example.com/events",
    "eventsMaxMissedHeartbeats": 5,
    "eventsHeartbeatIntervalTime": 60000,
    "eventsReconnectTryInterval": 10000,
    "debug": true,
    "debugInfo": false,
    "defaultLanguage": "en",
    "themes": ["taiga"],
    "defaultTheme": "taiga",
    "publicRegisterEnabled": true,
    "feedbackEnabled": true,
    "supportUrl": "https://tree.taiga.io/support",
    "privacyPolicyUrl": null,
    "termsOfServiceUrl": null,
    "GDPRUrl": null,
    "maxUploadFileSize": null,
    "contribPlugins": [],
    "tribeHost": null,
    "importers": [],
    "gravatar": true,
    "rtlLanguages": ["fa"]
}

Salva e chiudi il file quando hai finito.

Installa e configura l'evento Taiga

Successivamente, vai alla tua home directory e scarica l'ultima versione dell'evento Taiga con il seguente comando:

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

Quindi, cambia la directory nella directory scaricata e installa tutti i moduli NPM con il seguente comando:

cd taiga-events
npm install

Successivamente, copia il file di configurazione di esempio con il seguente comando:

cp config.example.json config.json

Successivamente, modifica il file config.json e imposta l'URL di rabbitmq e la chiave segreta::

nano config.json

Aggiungi/modifica le seguenti righe:

{
    "url": "amqp://taiga::5672/taiga",
    "secret": "OQOEJNSJIQHDBQNSUQEJSNNANsqQPAASQLSMSOQND",
    "webSocketServer": {
        "port": 8888
    }
}

Salva e chiudi il file, quindi esci dall'utente Taiga con il seguente comando:

exit

Crea un file di servizio Systemd

Successivamente, dovrai creare un file di servizio systemd per l'evento Taiga e Taiga. Innanzitutto, crea un file di servizio systemd per l'evento Taiga con il seguente comando:

nano /etc/systemd/system/taiga_events.service

Aggiungi le seguenti righe:

[Unit]
Description=taiga_events
After=network.target

[Service]
User=taiga
WorkingDirectory=/home/taiga/taiga-events
ExecStart=/bin/bash -c "node_modules/coffeescript/bin/coffee index.coffee"
Restart=always
RestartSec=3

[Install]
WantedBy=default.target

Salva e chiudi il file, quindi ricarica il servizio systemd con il seguente comando:

systemctl daemon-reload

Successivamente, avvia il servizio eventi Taiga e abilitalo per l'avvio al riavvio del sistema con il seguente comando:

systemctl start taiga_events
systemctl enable taiga_events

Successivamente, crea un file di servizio systemd per Taiga con il seguente comando:

nano /etc/systemd/system/taiga.service

Aggiungi le seguenti righe:

[Unit]
Description=taiga_back
After=network.target

[Service]
User=taiga
Environment=PYTHONUNBUFFERED=true
WorkingDirectory=/home/taiga/taiga-back
ExecStart=/home/taiga/.virtualenvs/taiga_venv/bin/gunicorn --workers 4 --timeout 60 -b 127.0.0.1:8001 taiga.wsgi
Restart=always
RestartSec=3

[Install]
WantedBy=default.target

Salva e chiudi il file, quindi ricarica il servizio systemd con il seguente comando:

systemctl daemon-reload

Successivamente, avvia il servizio Taiga e abilitalo per l'avvio al riavvio del sistema con il seguente comando:

systemctl start taiga
systemctl enable taiga

Successivamente, verifica lo stato dell'evento Taiga e del servizio Taiga con il seguente comando:

systemctl status taiga_events taiga

Dovresti vedere il seguente output:

? taiga_events.service - taiga_events
     Loaded: loaded (/etc/systemd/system/taiga_events.service; disabled; vendor preset: enabled)
     Active: active (running) since Mon 2020-11-02 09:30:21 UTC; 46s ago
   Main PID: 26383 (node)
      Tasks: 7 (limit: 2353)
     Memory: 15.2M
     CGroup: /system.slice/taiga_events.service
             ??26383 node node_modules/coffeescript/bin/coffee index.coffee

Nov 02 09:30:21 taiga.example.com systemd[1]: Started taiga_events.

? taiga.service - taiga_back
     Loaded: loaded (/etc/systemd/system/taiga.service; disabled; vendor preset: enabled)
     Active: active (running) since Mon 2020-11-02 09:30:55 UTC; 13s ago
   Main PID: 26478 (gunicorn)
      Tasks: 5 (limit: 2353)
     Memory: 266.4M
     CGroup: /system.slice/taiga.service
             ??26478 /home/taiga/.virtualenvs/taiga_venv/bin/python /home/taiga/.virtualenvs/taiga_venv/bin/gunicorn --workers 4 --timeout 60 >
             ??26494 /home/taiga/.virtualenvs/taiga_venv/bin/python /home/taiga/.virtualenvs/taiga_venv/bin/gunicorn --workers 4 --timeout 60 >
             ??26495 /home/taiga/.virtualenvs/taiga_venv/bin/python /home/taiga/.virtualenvs/taiga_venv/bin/gunicorn --workers 4 --timeout 60 >
             ??26496 /home/taiga/.virtualenvs/taiga_venv/bin/python /home/taiga/.virtualenvs/taiga_venv/bin/gunicorn --workers 4 --timeout 60 >
             ??26497 /home/taiga/.virtualenvs/taiga_venv/bin/python /home/taiga/.virtualenvs/taiga_venv/bin/gunicorn --workers 4 --timeout 60 >

Nov 02 09:30:55 taiga.example.com gunicorn[26495]: [2020-11-02 09:30:55 +0000] [26495] [INFO] Booting worker with pid: 26495
Nov 02 09:30:55 taiga.example.com gunicorn[26496]: [2020-11-02 09:30:55 +0000] [26496] [INFO] Booting worker with pid: 26496
Nov 02 09:30:55 taiga.example.com gunicorn[26494]: Trying import local.py settings...
Nov 02 09:30:55 taiga.example.com gunicorn[26495]: Trying import local.py settings...
Nov 02 09:30:55 taiga.example.com gunicorn[26497]: Trying import local.py settings...
Nov 02 09:30:55 taiga.example.com gunicorn[26497]: 2020-11-02 09:30:55 +0000] [26497] [INF
Nov 02 09:30:55 taiga.example.com gunicorn[26495]: 2
Nov 02 09:30:55 taiga.example.com gunicorn[26496]: 2
Nov 02 09:30:55 taiga.example.com gunicorn[26496]: rying import local.py settings...
Nov 02 09:30:55 taiga.example.com gunicorn[26497]: rying import local.py settings...

Configura Nginx come proxy inverso

È una buona idea configurare Nginx come proxy inverso per Taiga. Innanzitutto, installa Nginx con il seguente comando:

apt-get install nginx -y

Una volta installato, crea un file di configurazione dell'host virtuale Nginx con il seguente comando:

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

Aggiungi le seguenti righe:

server {
    listen 80;
    server_name taiga.example.com;

    large_client_header_buffers 4 32k;
    client_max_body_size 50M;
    charset utf-8;

    access_log /home/taiga/logs/nginx.access.log;
    error_log /home/taiga/logs/nginx.error.log;

    # 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;
    }

    # Admin access (/admin/)
    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;
    }

    # Events
    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;
    }
}

Salva e chiudi il file, quindi riavvia Nginx per applicare le modifiche:

systemctl restart nginx

Accedi all'interfaccia utente web di Tails

Ora apri il tuo browser web e accedi all'interfaccia web di Taiga utilizzando l'URL http://taiga.example.com. Verrai reindirizzato alla seguente pagina:

Fai clic sul pulsante Accedi. Verrai reindirizzato alla seguente pagina:

Fornire il nome utente predefinito come admin e la password come 123123 quindi fare clic sul pulsante LOGIN. Dovresti vedere la dashboard di Taiga nella pagina seguente:

Conclusione

Congratulazioni! hai installato e configurato correttamente lo strumento di gestione del progetto Taiga con Nginx su Ubuntu 20.04. Ora puoi distribuire Taiga nel tuo ambiente di sviluppo e iniziare a lavorarci.