Instalación de Redmine en VPS

Configuración

Después de instalar los componentes principales, es necesario configurarlos para un funcionamiento estable y seguro de Redmine. Esto incluye la configuración de Nginx como proxy inverso, el inicio de Puma como servicio del sistema y la habilitación de HTTPS.

1. Configuración de Puma como servicio del sistema (systemd)

Para que Redmine se inicie automáticamente al arrancar el servidor y funcione en segundo plano, configuraremos Puma como un servicio de systemd.

Cree un archivo de servicio para Puma:

sudo nano /etc/systemd/system/redmine.service # Creación de un nuevo archivo de servicio

Pegue el siguiente contenido, reemplazando redmineuser por el nombre de su usuario y /var/www/redmine por la ruta de su instalación de Redmine:

[Unit]
Description=Puma HTTP Server for Redmine
After=network.target postgresql.service

[Service]
Type=simple
User=redmineuser
Group=redmineuser
WorkingDirectory=/var/www/redmine
Environment=RAILS_ENV=production
ExecStart=/home/redmineuser/.rvm/bin/rvm-auto-ruby bundle exec puma -C /var/www/redmine/config/puma.rb
ExecReload=/bin/kill -s HUP $MAINPID
TimeoutSec=15
RestartSec=2
Restart=on-failure

[Install]
WantedBy=multi-user.target

Guarde y cierre el archivo.

Ahora cree el archivo de configuración de Puma config/puma.rb:

nano /var/www/redmine/config/puma.rb # Creación del archivo de configuración de Puma

Pegue el siguiente contenido:

# config/puma.rb
# Reemplace 'redmineuser' con el nombre de su usuario
# Reemplace '/var/www/redmine' con la ruta de su instalación de Redmine

workers Integer(ENV['WEB_CONCURRENCY'] || 2)
threads_count = Integer(ENV['RAILS_MAX_THREADS'] || 5)
threads threads_count, threads_count

rackup DefaultRackup
port        ENV['PORT']     || 3000
environment ENV['RACK_ENV'] || 'production'

pidfile    "/var/www/redmine/tmp/pids/puma.pid"
state_path "/var/www/redmine/tmp/pids/puma.state"
stdout_redirect "/var/www/redmine/log/puma.stdout.log", "/var/www/redmine/log/puma.stderr.log", true

# On workers boot
on_worker_boot do
  ActiveRecord::Base.establish_connection if defined?(ActiveRecord)
end

# Allow puma to be restarted by rails restart command.
plugin :tmp_restart

Guarde y cierre el archivo.

Recargue systemd, habilite e inicie el servicio Redmine:

sudo systemctl daemon-reload           # Recargar configuración de systemd
sudo systemctl enable redmine.service  # Habilitar inicio automático del servicio Redmine
sudo systemctl start redmine.service   # Iniciar servicio Redmine
sudo systemctl status redmine.service  # Comprobar estado del servicio

Asegúrese de que el servicio esté en ejecución y no contenga errores. La salida debe ser "active (running)" en verde.

2. Configuración de Nginx como proxy inverso

Instale Nginx, si aún no está instalado:

sudo apt install nginx -y # Instalación de Nginx

Cree un nuevo archivo de configuración de Nginx para Redmine:

sudo nano /etc/nginx/sites-available/redmine.conf # Creación del archivo de configuración de Nginx

Pegue el siguiente contenido, reemplazando your_domain.com por su dominio:

upstream redmine {
    server unix:///var/www/redmine/tmp/sockets/puma.sock fail_timeout=0;
    # O, si Puma escucha en un puerto TCP:
    # server 127.0.0.1:3000;
}

server {
    listen 80;
    server_name your_domain.com; # Reemplace con su dominio
    return 301 https://$host$request_uri; # Redirección HTTP a HTTPS
}

server {
    listen 443 ssl http2;
    server_name your_domain.com; # Reemplace con su dominio

    ssl_certificate /etc/letsencrypt/live/your_domain.com/fullchain.pem; # Será creado por Certbot
    ssl_certificate_key /etc/letsencrypt/live/your_domain.com/privkey.pem; # Será creado por Certbot
    ssl_session_timeout 1d;
    ssl_session_cache shared:SSL:10m;
    ssl_session_tickets off;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384';
    ssl_prefer_server_ciphers on;

    root /var/www/redmine/public; # Ruta al directorio public de Redmine

    access_log /var/log/nginx/redmine_access.log;
    error_log /var/log/nginx/redmine_error.log;

    location / {
        try_files $uri @redmine;
    }

    location @redmine {
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_redirect off;
        proxy_pass http://redmine; # Usamos upstream redmine
    }

    error_page 500 502 503 504 /500.html;
    client_max_body_size 100M; # Tamaño máximo de archivos a subir
    keepalive_timeout 10;
}

Guarde y cierre el archivo. Active la configuración creando un enlace simbólico y eliminando el predeterminado:

sudo ln -s /etc/nginx/sites-available/redmine.conf /etc/nginx/sites-enabled/ # Creación de enlace simbólico
sudo rm /etc/nginx/sites-enabled/default # Eliminación de la configuración predeterminada de Nginx
sudo nginx -t                          # Comprobación de la sintaxis de la configuración de Nginx
sudo systemctl restart nginx           # Reinicio de Nginx

Si Puma está configurado para un socket, entonces en config/puma.rb debe añadir la línea bind "unix:///var/www/redmine/tmp/sockets/puma.sock" y asegurarse de que el directorio tmp/sockets exista y tenga los permisos correctos.

mkdir -p /var/www/redmine/tmp/sockets
chmod 777 /var/www/redmine/tmp/sockets # Temporalmente para pruebas, más tarde se puede restringir

3. Configuración de TLS/HTTPS con Certbot

Se recomienda encarecidamente utilizar HTTPS para proteger el tráfico. Utilizaremos Certbot para obtener certificados SSL/TLS gratuitos de Let's Encrypt.

sudo apt install certbot python3-certbot-nginx -y # Instalación de Certbot y el plugin para Nginx
sudo certbot --nginx -d your_domain.com           # Obtención e instalación del certificado (reemplace el dominio)

Certbot modificará automáticamente su configuración de Nginx para usar HTTPS y configurará la renovación automática de certificados. Siga las instrucciones en pantalla. Asegúrese de que su dominio ya apunte a la dirección IP de su VPS.

4. Verificación de funcionamiento

Abra su dominio (https://your_domain.com) en el navegador. Debería ver la página de inicio de sesión de Redmine. Por defecto, el nombre de usuario es: admin, la contraseña es: admin. Asegúrese de cambiarla en el primer inicio de sesión.

También puede verificar la disponibilidad usando curl:

curl -I https://your_domain.com # Verificación de encabezados HTTP

Asegúrese de que el estado HTTP sea 200 OK. Si surgen problemas, revise los registros de Nginx (/var/log/nginx/error.log) y Puma/Redmine (/var/www/redmine/log/puma.stderr.log o /var/www/redmine/log/production.log).

Copias de seguridad y mantenimiento

Las copias de seguridad regulares y el mantenimiento oportuno son críticos para cualquier sistema en producción, incluyendo Redmine. Esto evitará la pérdida de datos y asegurará un funcionamiento estable.

1. Qué respaldar

Para una recuperación completa de Redmine, necesitará tres componentes principales:

1. Base de datos de Redmine: Contiene todas las tareas, proyectos, usuarios, configuraciones y otros datos estructurados.
2. Directorio files: Almacena todos los archivos adjuntos, imágenes y documentos subidos por los usuarios.
3. Archivos de configuración de Redmine: Archivos clave, como config/database.yml, config/configuration.yml (para la configuración de correo y otras opciones) y config/initializers/secret_token.rb.

2. Script simple de copia de seguridad automática

Crearemos un script Bash simple que realizará la copia de seguridad de estos componentes. Cree un directorio para las copias de seguridad y el script en sí.

sudo mkdir -p /var/backups/redmine # Creación del directorio para almacenar las copias de seguridad
sudo chown redmineuser:redmineuser /var/backups/redmine # Cambio de propietario
nano /home/redmineuser/redmine_backup.sh # Creación del script de copia de seguridad

Pegue el siguiente contenido en el script, reemplazando redmine_user, redmine_db, /var/www/redmine y /var/backups/redmine con sus propios valores.

#!/bin/bash

# Variables
DB_USER="redmine_user"
DB_NAME="redmine_db"
REDMINE_ROOT="/var/www/redmine"
BACKUP_DIR="/var/backups/redmine"
TIMESTAMP=$(date +%Y%m%d%H%M%S)

# Creación del directorio para la copia de seguridad actual
CURRENT_BACKUP_DIR="$BACKUP_DIR/$TIMESTAMP"
mkdir -p "$CURRENT_BACKUP_DIR"

echo "Iniciando la copia de seguridad de Redmine en $CURRENT_BACKUP_DIR..."

# 1. Copia de seguridad de la base de datos PostgreSQL
echo "Volcado de la base de datos..."
sudo -u postgres pg_dump -Fc "$DB_NAME" > "$CURRENT_BACKUP_DIR/redmine_db.dump"
if [ $? -eq 0 ]; then
    echo "Volcado de la base de datos creado con éxito."
else
    echo "Error al crear el volcado de la base de datos."
fi

# 2. Copia de seguridad del directorio files
echo "Copiando archivos..."
rsync -a "$REDMINE_ROOT/files" "$CURRENT_BACKUP_DIR/"
if [ $? -eq 0 ]; then
    echo "Archivos copiados con éxito."
else
    echo "Error al copiar archivos."
fi

# 3. Copia de archivos de configuración
echo "Copiando archivos de configuración..."
cp "$REDMINE_ROOT/config/database.yml" "$CURRENT_BACKUP_DIR/"
cp "$REDMINE_ROOT/config/configuration.yml" "$CURRENT_BACKUP_DIR/"
cp "$REDMINE_ROOT/config/initializers/secret_token.rb" "$CURRENT_BACKUP_DIR/"
if [ $? -eq 0 ]; then
    echo "Archivos de configuración copiados con éxito."
else
    echo "Error al copiar archivos de configuración."
fi

# 4. Eliminación de copias de seguridad antiguas (por ejemplo, más de 7 días)
echo "Eliminando copias de seguridad antiguas (más de 7 días)..."
find "$BACKUP_DIR" -maxdepth 1 -mtime +7 -exec rm -rf {} \;
echo "Copia de seguridad completada."

Haga el script ejecutable:

chmod +x /home/redmineuser/redmine_backup.sh # Hacemos el script ejecutable

3. Configuración de Cron para el inicio automático de la copia de seguridad

Agregue el script al programador Cron para que se ejecute automáticamente, por ejemplo, diariamente a las 3:00 de la madrugada.

crontab -e # Apertura de crontab para el usuario actual

Agregue la siguiente línea al final del archivo:

0 3 * * * /home/redmineuser/redmine_backup.sh >> /var/log/redmine_backup.log 2>&1

Esta línea significa: "Cada día a las 3 horas y 0 minutos, ejecutar el script y redirigir su salida a un archivo de registro".

4. Dónde almacenar las copias de seguridad

Almacenar las copias de seguridad en el mismo servidor que el sistema en producción es arriesgado. Si el servidor falla, perderá tanto el sistema como las copias de seguridad. Se recomienda utilizar almacenamiento externo:

• Almacenamiento compatible con S3: Servicios como AWS S3, Backblaze B2, DigitalOcean Spaces. Puede usar utilidades como s3cmd o rclone para la carga automática de copias de seguridad.
• VPS separado: Alquile un pequeño VPS exclusivamente para almacenar copias de seguridad y sincronícelas allí a través de SSH/rsync.
• NAS/servidor local: Si tiene su propia infraestructura, puede configurar la sincronización con ella.

Por ejemplo, para enviar a S3, puede agregar una línea al script que utilice aws cli o rclone después de crear la copia de seguridad local.

5. Actualizaciones: Rolling vs. Ventana de mantenimiento

Mantener Redmine y el software base actualizados es importante para la seguridad y para obtener nuevas funciones.

• Actualizaciones del SO y paquetes del sistema: Se recomienda aplicar actualizaciones de seguridad regularmente (una vez a la semana/mes) en una "ventana de mantenimiento" (maintenance window), cuando la carga del servidor es mínima.

  
  sudo apt update && sudo apt upgrade -y # Actualización de paquetes del sistema
  sudo apt autoremove -y # Eliminación de paquetes innecesarios
  

• Actualizaciones de Ruby: Las actualizaciones de Ruby deben probarse cuidadosamente, ya que pueden afectar el funcionamiento de Redmine. Use RVM para instalar una nueva versión de Ruby, pruebe Redmine con ella y luego cambie.
• Actualizaciones de Redmine:
  • Siempre realice una copia de seguridad completa antes de actualizar Redmine.
  • Detenga el servicio de Redmine (sudo systemctl stop redmine.service).
  • Descargue la nueva versión de Redmine, descomprímala, copie los archivos (excepto files, config, plugins).
  • Actualice los gems (bundle install --without development test).
  • Ejecute las migraciones de la base de datos (bundle exec rake db:migrate RAILS_ENV=production).
  • Inicie el servicio de Redmine (sudo systemctl start redmine.service).

Planifique las actualizaciones de Redmine como proyectos separados, preferiblemente probándolas primero en un servidor de staging.

Solución de problemas + FAQ

Esta sección contiene respuestas a preguntas frecuentes y soluciones a problemas típicos que pueden surgir durante la instalación y operación de Redmine en un VPS.

1. Redmine no se inicia o muestra un error 502 Bad Gateway con Nginx. ¿Qué debo verificar?

El error 502 Bad Gateway generalmente significa que Nginx no puede comunicarse con la aplicación backend (Puma). Esto puede ser causado por varias razones:

• Puma no está iniciado: Verifique el estado del servicio Puma: sudo systemctl status redmine.service. Si está inactivo, revise los logs de Puma: journalctl -u redmine.service o /var/www/redmine/log/puma.stderr.log.
• Configuración incorrecta de Nginx: Asegúrese de que proxy_pass en la configuración de Nginx apunte a la dirección/socket correcto de Puma (por ejemplo, http://127.0.0.1:3000 o unix:///var/www/redmine/tmp/sockets/puma.sock). Verifique la sintaxis de Nginx: sudo nginx -t.
• Problemas de permisos: Asegúrese de que el usuario de Nginx (normalmente www-data) tenga acceso al socket de Puma, si está usando un socket.
• Problemas con la base de datos: Si Puma se inicia pero falla inmediatamente, es posible que Redmine no pueda conectarse a la base de datos. Verifique config/database.yml y asegúrese de que PostgreSQL esté en ejecución (sudo systemctl status postgresql).

2. ¿Cómo configurar el envío de correo desde Redmine?

Para enviar notificaciones desde Redmine (por ejemplo, sobre nuevas tareas o comentarios), debe configurar los parámetros SMTP. Edite el archivo config/configuration.yml (si no existe, copie configuration.yml.example):

# config/configuration.yml
default:
  email_delivery:
    delivery_method: :smtp
    smtp_settings:
      address: "smtp.your-email-provider.com" # Por ejemplo, smtp.mail.ru, smtp.gmail.com
      port: 587 # O 465 para SSL
      authentication: :plain
      domain: "your_domain.com" # Su dominio
      user_name: "noreply@your_domain.com" # Su email
      password: "your_email_password" # Contraseña del correo
      enable_starttls_auto: true

Después de guardar el archivo, reinicie el servicio de Redmine (Puma): sudo systemctl restart redmine.service. Verifique el envío de un correo electrónico de prueba en la configuración de Redmine (Administración -> Configuración -> Notificaciones por email).

3. ¿Qué configuración mínima de VPS es adecuada para Redmine?

Para Redmine y un equipo pequeño (hasta 10 usuarios), se recomienda un VPS mínimo con 2 núcleos de CPU, 4 GB de RAM y 80 GB de disco SSD. Esto asegurará un funcionamiento bastante cómodo sin retrasos notables. Para equipos más grandes o uso intensivo, se debe considerar 4 núcleos de CPU y 8 GB de RAM.

4. ¿Qué elegir: VPS o dedicado para esta tarea?

Para la mayoría de los escenarios de uso de Redmine (equipos pequeños y medianos, hasta 50 usuarios activos), un VPS será la solución óptima y económicamente ventajosa. Un servidor dedicado debe elegirse si tiene un equipo muy grande, una carga extremadamente alta, requisitos estrictos de rendimiento y aislamiento de recursos, o si planea alojar muchos otros servicios que consumen muchos recursos en el mismo hardware físico.

5. ¿Cómo actualizar Redmine a una nueva versión?

El proceso de actualización de Redmine incluye varios pasos:

1. Copia de seguridad: Realice una copia de seguridad completa de la base de datos y del directorio files.
2. Detención de Redmine: sudo systemctl stop redmine.service.
3. Descarga de la nueva versión: Descargue el nuevo archivo de Redmine, descomprímalo en un nuevo directorio.
4. Copia de archivos: Copie sus config/database.yml, config/configuration.yml, config/initializers/secret_token.rb, así como el directorio files y plugins de la instalación antigua a la nueva.
5. Instalación de gems: Vaya al nuevo directorio de Redmine y ejecute bundle install --without development test.
6. Migración de la base de datos: bundle exec rake db:migrate RAILS_ENV=production.
7. Inicio de Redmine: sudo systemctl start redmine.service.

Siempre lea las instrucciones oficiales de actualización para la versión específica de Redmine, ya que puede haber pasos específicos.

6. ¿Por qué no se muestran las imágenes/archivos o surgen errores al cargarlos?

Este problema suele estar relacionado con permisos de acceso incorrectos al directorio files o la ausencia de ImageMagick. Verifique lo siguiente:

• Permisos de acceso: Asegúrese de que el directorio /var/www/redmine/files y todo su contenido sean escribibles por el usuario bajo el cual se ejecuta Puma (redmineuser) y Nginx (www-data). Ejecute: sudo chown -R redmineuser:redmineuser /var/www/redmine/files y sudo chmod -R 755 /var/www/redmine/files.
• ImageMagick: Redmine utiliza ImageMagick para procesar imágenes (por ejemplo, para previsualizaciones). Asegúrese de que esté instalado: sudo apt install imagemagick libmagickwand-dev -y.
• Tamaño de los archivos: Verifique client_max_body_size en la configuración de Nginx. Si intenta cargar un archivo de mayor tamaño del permitido, Nginx puede rechazar la solicitud.

7. ¿Cómo cambiar el puerto en el que se ejecuta Puma?

Por defecto, Puma escucha en el puerto 3000. Para cambiarlo, edite el archivo /var/www/redmine/config/puma.rb y cambie la línea port ENV['PORT'] || 3000 al puerto deseado, por ejemplo: port 3001. Luego, reinicie el servicio de Redmine: sudo systemctl restart redmine.service. No olvide actualizar la configuración de Nginx si está utilizando un puerto TCP en lugar de un socket.

Conclusiones y próximos pasos

¡Felicidades! Ha instalado y configurado Redmine con éxito en su VPS, creando una plataforma confiable y totalmente controlada para la gestión de proyectos y el seguimiento de tareas. Ahora su equipo puede colaborar de manera efectiva, seguir el progreso y alcanzar objetivos, teniendo control total sobre sus datos y herramientas.

Para aprovechar al máximo el potencial de su nuevo sistema, considere los siguientes pasos:

• Integración con sistemas de control de versiones: Configure la integración de Redmine con sus repositorios Git o SVN para vincular automáticamente los commits con las tareas y ver los cambios directamente desde Redmine.
• Instalación de plugins: Explore la extensa biblioteca de plugins de Redmine para ampliar la funcionalidad, como informes adicionales, diagramas, integraciones con otros servicios o mejoras en la interfaz de usuario.
• Monitoreo del rendimiento: Implemente herramientas de monitoreo (por ejemplo, Prometheus + Grafana) para rastrear la carga del servidor, el uso de memoria y disco, así como el rendimiento de Redmine, para responder a tiempo a posibles problemas.