Cómo instalar Taiga Project Management Tool en CentOS 7

• Prerrequisitos
• Instalar PostgreSQL
• Instalar Python 3
• Instalar RabbitMQ
• Instalar Nodejs
• Instalar el backend de Taiga
• Instalar Frontend
• Instalar Taiga Events
• Configurar circo
• Instalar Nginx como un proxy inverso
• Conclusión

Taiga es una aplicación gratuita y de código abierto para la gestión de proyectos. A diferencia de otras herramientas de gestión de proyectos, Taiga utiliza un enfoque ágil incremental para gestionar el desarrollo del proyecto. Taiga es una aplicación muy potente y totalmente personalizable. El backend de Taiga está escrito en Python usando el marco Django. La interfaz está escrita en JavaScript utilizando los marcos de trabajo de CoffeeScript y AngularJS. Taiga incluye características tales como colaboración de proyectos, tablero Kanban, seguimiento de errores, informes, seguimiento de tiempo, retrasos, wiki y más.

Prerrequisitos

• Una instancia de servidor Vultr CentOS 7 con al menos 1 GB de RAM.
• Un usuario de sudo .

En este tutorial, usaremos taiga.example.comcomo el nombre de dominio señalado al servidor. Reemplace todas las apariciones de taiga.example.comcon su nombre de dominio real.

Actualice su sistema base utilizando la guía Cómo actualizar CentOS 7 . Una vez que su sistema ha sido actualizado, proceda a instalar PostgreSQL.

Instalar PostgreSQL

PostgreSQL es un sistema de base de datos relacional de objetos conocido por su estabilidad y velocidad. Taiga usa PostgreSQL para almacenar su base de datos. Agregue el repositorio PostgreSQL en el sistema.

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

Instale el servidor de base de datos PostgreSQL.

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

Inicializar la base de datos.

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

Inicie el servidor PostgreSQL y permita que se inicie automáticamente en el momento del arranque.

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

Cambie la contraseña para el usuario predeterminado de PostgreSQL.

sudo passwd postgres

Inicie sesión como usuario de PostgreSQL.

sudo su - postgres

Cree un nuevo usuario de PostgreSQL para Taiga.

createuser taiga 

PostgreSQL proporciona el psqlshell para ejecutar consultas en la base de datos. Cambie al shell PostgreSQL.

psql

Establezca una contraseña para el usuario recién creado para la base de datos Taiga.

ALTER USER taiga WITH ENCRYPTED password 'DBPassword';

Reemplazar DBPasswordcon una contraseña segura. Cree una nueva base de datos para la instalación de Taiga.

CREATE DATABASE taiga OWNER taiga;

Salga de la psqlcáscara.

\q

Cambiar al sudousuario.

exit

Instalar Python 3

Python 2.7 viene preinstalado en un servidor CentOS 7, pero Taiga requiere Python versión 3.4 o posterior.

Instalaremos Python versión 3.6 desde la fuente. Instale las herramientas de compilación y el compilador necesarios.

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

Descargue el código fuente de Python.

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

Extraiga y configure la instalación de Python.

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

Haz una instalación alternativa.

sudo make altinstall

Nota : Las instalaciones alternativas instalan Python 3.6 sin reemplazar la versión predeterminada de Python. Si reemplaza el Python predeterminado en CentOS 7, puede romper el YUMadministrador del repositorio.

Ahora podrá verificar su versión.

python3.6 -V

Deberías ver lo siguiente.

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

Instale Python Virtual Environment usando pip.

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

El entorno virtual de Python se usa para crear un entorno virtual aislado para un proyecto de Python. Un entorno virtual contiene sus propios directorios de instalación y no comparte bibliotecas con entornos virtuales globales y de otro tipo.

Instalar RabbitMQ

Taiga usa RabbitMQ para procesar la cola de mensajes. RabbitMQ requiere que las bibliotecas Erlang funcionen. Instala Erlang.

sudo yum -y install erlang

Importa la clave de firma RabbitMQ GPG.

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

Instala RabbitMQ.

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

Inicie y habilite el servidor RabbitMQ.

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

Añadir usuario RabbitMQ y vhost. Además, otorgue permiso al usuario sobre el host.

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

Asegúrese de reemplazar StrongMQPasswordcon una contraseña segura.

Instalar Nodejs

Se requiere Node.js versión 7 o posterior para compilar la interfaz de Taiga. Agregue el repositorio Node.js versión 8.

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

Instale Node.js y la pwgenutilidad.

sudo yum install -y nodejs pwgen

pwgense usará más tarde para generar una cadena secreta fuerte. Instale CoffeeScript, ya que se usará para compilar archivos Taiga escritos con el marco de trabajo de CoffeeScript.

sudo npm install -g coffee-script gulp

Instalar el backend de Taiga

Agregue un nuevo usuario del sistema para Taiga para asegurarse de que los procesos de Taiga se ejecuten como un usuario sin privilegios.

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

Nota : De ahora en adelante, todos los comandos deben ejecutarse como usuario sin privilegios taigahasta que se le solicite que vuelva a cambiar de sudousuario.

Cree un nuevo directorio para almacenar los archivos de registro.

mkdir -p ~/logs

Clone el repositorio backend Taiga de GitHub y compruebe la última rama estable.

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

Configure virtualenvwrapperpara usar Python 3.6 en lugar del Python predeterminado.

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

Finalmente, busca el ~/.bashrcarchivo.

source ~/.bashrc

Ahora cree un nuevo entorno virtual para Taiga usando Python 3.6.

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

Instale las dependencias de Python requeridas usando pip.

pip3.6 install -r requirements.txt

Rellene la base de datos con los datos iniciales necesarios.

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

Los comandos anteriores escribirán datos en la base de datos PostgreSQL. Taiga también envía algunos datos de demostración o muestra que pueden ser útiles para evaluar el producto. Si desea instalar los datos de muestra, ejecute lo siguiente.

python3.6 manage.py sample_data

Nota : La instalación de datos de muestra es opcional y está destinada únicamente a evaluar el producto.

Antes de proceder a crear el archivo de configuración para el backend de Taiga, necesitamos generar una cadena secreta. Esta cadena se usará para cifrar los datos de la sesión.

Genere una cadena aleatoria de 64 caracteres.

pwgen -s -1 64

Debería ver la salida como una cadena aleatoria.

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

Cree un nuevo archivo de configuración para Taiga Backend.

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

Rellene el archivo con el siguiente código.

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"

Asegúrese de reemplazar el nombre de dominio de ejemplo con el actual en el código anterior. Además, reemplace Generated_Secret_Keycon la clave secreta real y StrongMQPasswordcon la contraseña real para el usuario de la cola de mensajes de Taiga. Si tiene un servidor SMTP listo y desea utilizar las funciones de envío de correo electrónico de inmediato, puede descomentar las opciones de correo electrónico y establecer los valores apropiados. Si no tiene un servidor de correo listo, puede omitir la configuración de la función de correo electrónico por ahora y configurarla más adelante en este archivo de configuración.

Si desea habilitar el inicio de sesión de GitHub, cree una aplicación en GitHub y proporcione el ID de cliente API y el secreto del cliente.

Para verificar de inmediato si se puede iniciar el backend de Taiga, ejecute el servidor Django incorporado.

workon taiga
python manage.py runserver

Verá el siguiente resultado si el servidor se ha iniciado correctamente.

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

Para verificar si se puede acceder a la API, abra otra sesión de terminal y ejecute lo siguiente.

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

Verá una salida similar devuelta por la llamada 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",

Detenga el servidor de back-end Taiga presionando " Ctrl + C" y desactive el entorno virtual.

deactivate

Instalar Frontend

La interfaz de Taiga es el componente de Taiga que sirve a la interfaz de usuario web. Clone el repositorio frontend Taiga de Github y compruebe la última rama estable.

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

Cree un nuevo archivo de configuración para la interfaz de Taiga.

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

Rellene el archivo con esto.

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

Asegúrese de reemplazar el exampledominio con el dominio real. También puede cambiar el idioma predeterminado y otros parámetros en la configuración anterior.

Instalar Taiga Events

Además del frontend y el backend, también necesitamos instalar eventos Taiga. Taiga events es un servidor de socket web, y permite que la interfaz de Taiga muestre cambios en tiempo real en módulos como backlog, Kanban y más. Utiliza el servidor RabbitMQ para el procesamiento de mensajes.

Clonar el repositorio de eventos Taiga de Github.

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

Instale las dependencias de Node.js usando npm.

npm install

Cree un nuevo archivo de configuración para los eventos de Taiga.

nano ~/taiga-events/config.json

Rellene el archivo con lo siguiente.

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

Reemplace Generated_Secret_Keycon la clave secreta de 64 caracteres que ha generado en el pasado. La clave secreta debe ser exactamente la misma que la que proporcionó en el archivo de configuración del backend de Taiga. Además, actualice StrongMQPasswordcon la contraseña real para el usuario de la cola de mensajes de Taiga.

Configurar circo

Circus es un administrador de procesos para aplicaciones Python. Usaremos Circus para ejecutar backend y eventos de Taiga.

Cambiar de nuevo al sudousuario.

exit

Nota : A partir de ahora, deberá ejecutar los comandos con el sudousuario.

Instalar Circus usando pip.

sudo pip3.6 install circus

Cree nuevos directorios para almacenar configuraciones de Circus.

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

Cree el archivo de configuración predeterminado para Circus.

sudo nano /etc/circus/circus.ini

Rellene el archivo con la siguiente configuración.

[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

Cree un nuevo archivo de configuración de Circus para ejecutar el backend Taiga.

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

Rellene el archivo con lo siguiente.

[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

Cree una nueva configuración de Circus para ejecutar Taiga Events.

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

Rellene el archivo con lo siguiente.

[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

Ahora necesitaremos crear un systemdarchivo de servicio para ejecutar Circus. El uso systemdasegurará que Circus se inicie automáticamente durante el reinicio y las fallas.

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

Rellene el archivo.

[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

Inicie Circus y permita que se inicie automáticamente al momento del arranque.

sudo systemctl start circus
sudo systemctl enable circus

Verifique el estado de Circus.

circusctl status

Verá el siguiente resultado.

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

Ahora, tenemos Taiga instalada y funcionando con éxito. Antes de poder usarlo, necesitamos exponer la instalación usando cualquier servidor web de producción.

Instalar Nginx como un proxy inverso

Utilizaremos el servidor web Nginx como proxy inverso para servir la aplicación a los usuarios. También obtendremos e instalaremos certificados SSL de Let's Encrypt.

Instala Nginx y Certbot. Certbot es el cliente oficial de emisión de certificados para Let's Encrypt CA.

sudo yum -y install nginx certbot

Ajuste la configuración de su firewall para permitir el estándar HTTPy los HTTPSpuertos a través del firewall, ya que Certbot necesita hacer una conexión HTTP para verificar la autoridad 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 : Para obtener certificados de Let's Encrypt CA, debe asegurarse de que el dominio para el que desea generar los certificados apunte hacia el servidor. De lo contrario, realice los cambios necesarios en los registros DNS de su dominio y espere a que se propague el DNS antes de volver a solicitar el certificado. Certbot verifica la autoridad del dominio antes de proporcionar los certificados.

Ahora use el servidor web incorporado en Certbot para generar los certificados para su dominio.

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

Es probable que los certificados generados se almacenen en el /etc/letsencrypt/live/taiga.example.com/directorio. El certificado SSL se conservará como fullchain.pem, y la clave privada se guardará como privkey.pem.

Encriptemos los certificados caducan en 90 días, por lo que se recomienda configurar la renovación automática para los certificados utilizando trabajos Cron. Cron es un servicio del sistema que se utiliza para ejecutar tareas periódicas.

Abra el archivo de trabajo cron.

sudo crontab -e

Agrega la siguiente línea.

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

El trabajo cron anterior se ejecutará diariamente a medianoche. Si el certificado vence, vencerá automáticamente los certificados.

Genera un Diffie-Hellmanparámetro fuerte . Proporciona una capa adicional de seguridad para el intercambio de datos entre el host y el servidor.

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

Cree un nuevo bloque de servidor Nginx para servir a la interfaz de Taiga.

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

Rellene el archivo con lo siguiente.

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;

}

Asegúrese de cambiar el nombre de dominio y la ruta a los certificados SSL.

Ahora puede reiniciar el servidor web Nginx y habilitarlo para que se inicie automáticamente en el arranque.

sudo systemctl restart nginx
sudo systemctl status nginx

Finalmente, arregle la propiedad y el permiso en los archivos de Taiga.

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

Conclusión

Ahora puede acceder a la instalación de Taiga yendo a https://taiga.example.com. Inicie sesión con la cuenta de administrador inicial con nombre de usuario " admin" y contraseña " 123123". Su instalación ya está lista para su uso en producción. Comience creando un nuevo proyecto o evaluando el producto. Si ya está administrando un proyecto en Github, Jira o Trello, puede importar fácilmente los proyectos a Taiga utilizando los importadores .