Redmine en un VPS: instalación, configuración y mantenimiento

Redmine en VPS: instalación, configuración y mantenimiento — es el proceso de desplegar el popular sistema de gestión de proyectos Redmine en un servidor virtual privado, que incluye la configuración del entorno, la configuración del acceso a través de un servidor web con HTTPS y la garantía de un funcionamiento estable mediante copias de seguridad y actualizaciones. La instalación de Redmine en un VPS permite un control total sobre los datos, configurar el sistema según las necesidades específicas del equipo y garantizar un alto rendimiento, lo que lo convierte en una solución ideal para empresas que valoran la flexibilidad y la seguridad de sus datos de proyecto.

¿Qué es Redmine y por qué es ideal para VPS?

Redmine es un sistema de gestión de proyectos de código abierto, potente y flexible, basado en la web, escrito en el framework Ruby on Rails. Proporciona una amplia gama de herramientas para organizar eficazmente el trabajo de equipos de cualquier tamaño: desde pequeñas startups hasta grandes corporaciones. Entre las características clave de Redmine se encuentran el seguimiento de tareas (issue tracker), diagramas de Gantt, calendarios, páginas wiki, foros, gestión de documentos, seguimiento del tiempo, así como soporte para múltiples proyectos y roles de usuario. Gracias a su extensibilidad a través de plugins, Redmine puede adaptarse a prácticamente cualquier flujo de trabajo.

La elección de un VPS para el despliegue de Redmine, o, como se suele decir, el autoalojamiento de Redmine (Redmine self-hosted), ofrece una serie de ventajas innegables frente a las soluciones SaaS en la nube o el hosting virtual ordinario:

• Control total y seguridad de los datos: Al alojar Redmine en su propio VPS, usted controla completamente los datos del proyecto, su almacenamiento y seguridad. Esto es fundamental para empresas con altos requisitos de confidencialidad.
• Flexibilidad y personalización: Puede instalar cualquier plugin, modificar el código, configurar el entorno del servidor de acuerdo con las necesidades únicas de su proyecto, lo cual es imposible en las plataformas SaaS estándar.
• Optimización del rendimiento: Un VPS permite ajustar con precisión los recursos del servidor (CPU, RAM, disco) a la carga de Redmine, asegurando una velocidad de trabajo óptima incluso con un gran número de usuarios y proyectos. No depende de los "vecinos" en un hosting compartido.
• Eficiencia económica: Para equipos medianos y grandes, un VPS propio con Redmine a menudo resulta más rentable a largo plazo en comparación con las suscripciones mensuales a soluciones SaaS comerciales, especialmente a medida que crece el número de usuarios.
• Integración: Es más fácil integrar Redmine con otros servicios internos, como sistemas de control de versiones (Git, SVN), pipelines de CI/CD o sistemas de monitorización.

Así, Redmine en un servidor VPS es la elección de quienes buscan máxima flexibilidad, seguridad y rendimiento, sin querer pagar de más por soluciones en la nube preconfiguradas con funcionalidad limitada.

Principales características de Redmine para la gestión de proyectos

• Gestión de tareas y errores: Sistema flexible de seguimiento de tareas con tipos, estados, prioridades y asignados configurables.
• Diagramas de Gantt y calendarios: Visualización de plazos del proyecto y dependencias de tareas, planificación de recursos.
• Wiki y foros: Almacén centralizado de conocimientos del proyecto y plataforma para discusiones.
• Seguimiento del tiempo: Registro del tiempo dedicado a las tareas, generación de informes.
• Gestión de archivos y documentos: Almacenamiento y versionado de documentos, vinculación a tareas y proyectos.
• Soporte para múltiples proyectos: Posibilidad de gestionar un número ilimitado de proyectos con diferentes configuraciones y participantes.
• Control de acceso basado en roles: Configuración detallada de permisos para diferentes grupos de usuarios.
• Integración con sistemas de control de versiones: Vinculación de commits con tareas, visualización de repositorios.
• Campos y flujos de trabajo personalizables: Adaptación del sistema a las necesidades específicas del proyecto o la empresa.

Si busca alternativas para la gestión de proyectos, considere también soluciones como Vikunja en VPS o Kanboard en VPS, que ofrecen sus propios enfoques únicos para la organización del trabajo.

Requisitos del sistema de Redmine: ¿qué VPS elegir?

Para un funcionamiento exitoso y estable de Redmine en un VPS, es necesario considerar sus requisitos del sistema. Redmine, al ser una aplicación Ruby on Rails, tiene sus propias características de consumo de recursos. La elección correcta de la configuración del VPS garantizará un funcionamiento rápido de la interfaz, un procesamiento ágil de las solicitudes y un trabajo cómodo para todos los usuarios.

Requisitos mínimos y recomendados para VPS

Los requisitos mínimos son adecuados para pruebas, uso personal o equipos muy pequeños (hasta 5 usuarios) con baja actividad. Para una carga de trabajo real, se recomiendan configuraciones más potentes.

• Sistema operativo: Ubuntu Server (20.04 LTS o posterior), Debian (11 o posterior), CentOS Stream (8 o posterior). Estos SO soportan bien Docker y tienen paquetes actualizados.
• Procesador (CPU):
  • Mínimo: 1 vCPU (núcleo virtual).
  • Recomendado: 2 vCPU para equipos de 5-10 personas, 4+ vCPU para equipos más grandes (20+ usuarios) o alta actividad.
• Memoria RAM:
  • Mínimo: 1 GB RAM (para Redmine sin Docker, solo base de datos).
  • Con Docker: 2 GB RAM (Redmine, PostgreSQL, Redis).
  • Recomendado: 4 GB RAM para equipos de 10-20 personas, 8+ GB RAM para equipos grandes o si se utilizan plugins adicionales, trabajo intensivo con informes.
• Espacio en disco:
  • Mínimo: 20 GB NVMe SSD. Redmine utiliza activamente la base de datos y almacena archivos adjuntos. NVMe SSD acelera significativamente el trabajo con el disco en comparación con los SSD o HDD normales.
  • Recomendado: 50-100 GB NVMe SSD o más, dependiendo del volumen de archivos adjuntos, el número de proyectos y el tiempo de uso. Cuanto más rápido sea el disco, más receptivo será Redmine.
• Base de datos:
  • PostgreSQL (versión 10+): Elección preferida para Redmine, ya que suele mostrar un mejor rendimiento y fiabilidad.
  • MySQL/MariaDB (versión 5.7+/10.2+): También es compatible, pero PostgreSQL es más recomendado en la comunidad Redmine.
• Redis: Recomendado para el almacenamiento en caché y tareas en segundo plano (Sidekiq) para mejorar el rendimiento de Redmine.
• Interfaz de red: Conexión de red estable, preferiblemente de 1 Gbit/s.

Al elegir un VPS, siempre es mejor optar por una configuración con un pequeño margen, especialmente en RAM y espacio en disco, para evitar problemas de rendimiento a medida que el proyecto crece y el número de usuarios aumenta. El uso de NVMe SSD es prácticamente obligatorio para un trabajo cómodo con Redmine.

Preparación del VPS para la instalación de Redmine: pasos básicos

Antes de proceder a la instalación directa de Redmine, es necesario preparar su VPS. Estos pasos preparatorios garantizarán la estabilidad, seguridad y el correcto funcionamiento de todos los componentes. Utilizaremos Docker y Docker Compose para simplificar el despliegue, lo cual es un enfoque moderno y recomendado para Redmine autoalojado.

Acceso al servidor, actualización del SO e instalación de Docker

En primer lugar, conéctese a su VPS por SSH. Para ello, utilice el comando:

ssh root@SU_DIRECCIÓN_IP_VPS

Reemplace SU_DIRECCIÓN_IP_VPS por la dirección IP real de su servidor. Si utiliza un usuario con derechos limitados, reemplace root por el nombre de su usuario.

Después de una conexión exitosa, actualice los paquetes del sistema operativo a la versión más reciente. Esto es importante para la seguridad y la compatibilidad:

sudo apt update
sudo apt upgrade -y
sudo apt dist-upgrade -y
sudo apt autoremove -y

Para sistemas basados en CentOS/RHEL, utilice sudo dnf update -y.

Reinicie el servidor si se recomienda después de una actualización del kernel o de componentes críticos:

sudo reboot

Después de reiniciar, vuelva a conectarse por SSH.

A continuación, instale Docker Engine y Docker Compose. Esto permitirá desplegar fácilmente Redmine y sus dependencias (base de datos, Redis) en contenedores aislados.

# Instalación de los paquetes necesarios
sudo apt install ca-certificates curl gnupg lsb-release -y

# Añadir la clave GPG oficial de Docker
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# Añadir el repositorio de Docker
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Actualizar el índice de paquetes e instalar Docker Engine
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

# Verificar la instalación de Docker
sudo docker run hello-world

Si no desea usar sudo para cada comando Docker, añada su usuario al grupo docker:

sudo usermod -aG docker $USER
newgrp docker

Cierre y vuelva a iniciar la sesión SSH para que los cambios surtan efecto.

Configuración del firewall (UFW)

La configuración del firewall es fundamental para proteger su servidor. Utilizaremos UFW (Uncomplicated Firewall).

# Instalación de UFW (si no está instalado)
sudo apt install ufw -y

# Permitir SSH (puerto 22)
sudo ufw allow ssh

# Permitir HTTP (puerto 80) y HTTPS (puerto 443) para acceso web
sudo ufw allow http
sudo ufw allow https

# Habilitar UFW
sudo ufw enable

Confirme la acción pulsando y. Verifique el estado del firewall:

sudo ufw status verbose

Ahora su VPS está listo para la instalación de Redmine.

Instalación de Redmine en VPS con Docker Compose

El uso de Docker Compose simplifica significativamente la instalación de Redmine, permitiendo definir todos los servicios necesarios (Redmine, PostgreSQL, Redis) y sus interconexiones en un solo archivo. Esto hace que el proceso sea reproducible y fácil de gestionar.

Creación del archivo docker-compose.yml para Redmine

Primero, cree un directorio para su proyecto Redmine y navegue hasta él:

mkdir ~/redmine
cd ~/redmine

Ahora cree el archivo docker-compose.yml:

nano docker-compose.yml

Pegue el siguiente contenido en el archivo. Esta configuración define tres servicios: Redmine, PostgreSQL (base de datos) y Redis (para caché y tareas en segundo plano de Sidekiq).

version: '3.8'

services:
  redmine:
    image: redmine:latest
    container_name: redmine_app
    restart: always
    ports:
      - "3000:3000" # Puerto de Redmine, estará disponible en el puerto 3000 del host
    environment:
      REDMINE_DB_ADAPTER: postgresql
      REDMINE_DB_DATABASE: redmine_production
      REDMINE_DB_HOST: db
      REDMINE_DB_PORT: 5432
      REDMINE_DB_USERNAME: redmine_user
      REDMINE_DB_PASSWORD: YOUR_DB_PASSWORD # !!! Reemplace con una contraseña segura !!!
      REDMINE_SECRET_KEY_BASE: YOUR_SECRET_KEY_BASE # !!! Reemplace con una cadena aleatoria !!!
      REDMINE_SECRETS_KEY_BASE: YOUR_SECRET_KEY_BASE # Para compatibilidad con versiones más nuevas
      REDMINE_RAILS_ENV: production
      REDMINE_EMAIL_DELIVERY_METHOD: smtp
      REDMINE_SMTP_HOST: smtp.example.com # Reemplace con su servidor SMTP
      REDMINE_SMTP_PORT: 587
      REDMINE_SMTP_USER: [email protected] # Reemplace con su dirección de correo electrónico
      REDMINE_SMTP_PASSWORD: YOUR_EMAIL_PASSWORD # Reemplace con la contraseña de su correo
      REDMINE_SMTP_AUTHENTICATION: login
      REDMINE_SMTP_ENABLE_STARTTLS_AUTO: 'true'
      REDMINE_CACHE_STORE: redis_cache_store
      REDMINE_REDIS_URL: redis://redis:6379/1
    volumes:
      - redmine_data:/usr/src/redmine/files # Para almacenar archivos adjuntos
      - redmine_plugins:/usr/src/redmine/plugins # Para plugins
      - redmine_themes:/usr/src/redmine/public/themes # Para temas
    depends_on:
      - db
      - redis
    networks:
      - redmine_network

  db:
    image: postgres:13
    container_name: redmine_db
    restart: always
    environment:
      POSTGRES_DB: redmine_production
      POSTGRES_USER: redmine_user
      POSTGRES_PASSWORD: YOUR_DB_PASSWORD # !!! Debe coincidir con REDMINE_DB_PASSWORD !!!
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - redmine_network

  redis:
    image: redis:latest
    container_name: redmine_redis
    restart: always
    networks:
      - redmine_network

volumes:
  redmine_data:
  redmine_plugins:
  redmine_themes:
  db_data:

networks:
  redmine_network:
    driver: bridge

Puntos importantes al editar docker-compose.yml:

• YOUR_DB_PASSWORD: Reemplace con una contraseña de base de datos compleja y única. Debe ser la misma para REDMINE_DB_PASSWORD y POSTGRES_PASSWORD.
• YOUR_SECRET_KEY_BASE: Esta es una clave críticamente importante para la seguridad de Redmine. Genere una cadena aleatoria, por ejemplo, usando el comando rake secret dentro del contenedor de Redmine o un generador en línea. Por ejemplo, openssl rand -hex 64.
• Configuración SMTP: Asegúrese de configurar la sección SMTP para el envío de notificaciones por correo electrónico. Reemplace smtp.example.com, [email protected] y YOUR_EMAIL_PASSWORD con los datos de su proveedor de correo.
• Puerto 3000:3000: Redmine estará disponible en el puerto 3000 de su VPS. Configuraremos Nginx/Caddy como proxy inverso para acceder a través de los puertos estándar 80/443 más adelante.

Guarde el archivo (Ctrl+O, luego Enter, Ctrl+X).

Inicio de Redmine e inicialización de la base de datos

Ahora que el archivo docker-compose.yml está listo, puede iniciar Redmine. Ejecute el siguiente comando en el directorio ~/redmine:

docker compose up -d

Este comando descargará las imágenes necesarias, creará los contenedores y los iniciará en segundo plano (-d). El proceso puede tardar un tiempo la primera vez.

Después del inicio, es necesario inicializar la base de datos de Redmine. Esto se hace desde dentro del contenedor de Redmine. Primero, asegúrese de que los contenedores estén en ejecución:

docker compose ps

Debería ver el estado Up para los tres servicios. Luego, ejecute las migraciones de la base de datos y cargue los datos predeterminados (idioma, estados de tareas, etc.):

docker compose exec redmine bundle exec rake db:migrate RAILS_ENV=production
docker compose exec redmine bundle exec rake redmine:load_default_data RAILS_ENV=production

Cuando se le solicite el idioma predeterminado, introduzca es para español.

Después de ejecutar con éxito estos comandos, su Redmine estará listo para funcionar. Puede acceder a él a través de la dirección IP de su VPS y el puerto 3000, por ejemplo, http://SU_DIRECCIÓN_IP_VPS:3000. El inicio de sesión predeterminado es: admin, la contraseña: admin. ¡Asegúrese de cambiar la contraseña en el primer inicio de sesión!

En este punto, la instalación de Redmine en el servidor ha finalizado. El siguiente paso es configurar el acceso seguro a través de un nombre de dominio y HTTPS.

Configuración de Reverse Proxy y HTTPS para Redmine

El acceso directo a Redmine por dirección IP y puerto 3000 no es una solución segura ni conveniente para un entorno de producción. Para ello se utilizan un reverse proxy (servidor proxy inverso) y HTTPS. El reverse proxy permite dirigir el tráfico desde su nombre de dominio al puerto interno de Redmine, y HTTPS garantiza el cifrado de datos entre el usuario y el servidor.

Consideraremos dos opciones populares: Nginx y Caddy. Ambos cumplen la tarea, pero Caddy suele ser más fácil de configurar gracias a la gestión automática de certificados HTTPS de Let's Encrypt.

Opción 1: Nginx como Reverse Proxy con Certbot

Si Nginx aún no está instalado, instálelo:

sudo apt install nginx -y

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

sudo nano /etc/nginx/sites-available/redmine.conf

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

server {
    listen 80;
    server_name your_domain.com www.your_domain.com; # Reemplace con su dominio

    location / {
        proxy_pass http://127.0.0.1:3000; # Proxy al puerto interno de Redmine
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_redirect off;
    }
}

Cree un enlace simbólico a este archivo en sites-enabled para que Nginx lo active:

sudo ln -s /etc/nginx/sites-available/redmine.conf /etc/nginx/sites-enabled/

Verifique la configuración de Nginx en busca de errores y reinícielo:

sudo nginx -t
sudo systemctl reload nginx

Ahora su Redmine debería ser accesible por HTTP a través de http://your_domain.com.

Configuración de HTTPS con Certbot

Instale Certbot para obtener y renovar automáticamente los certificados SSL de Let's Encrypt:

sudo apt install certbot python3-certbot-nginx -y

Ejecute Certbot para su dominio:

sudo certbot --nginx -d your_domain.com -d www.your_domain.com

Certbot modificará automáticamente la configuración de Nginx, añadirá las entradas necesarias para HTTPS y configurará la redirección automática de HTTP a HTTPS. Siga las instrucciones de Certbot. Una vez completado, su Redmine estará disponible por HTTPS: https://your_domain.com.

Opción 2: Caddy como Reverse Proxy con HTTPS automático

Caddy es un potente servidor web que obtiene y renueva automáticamente los certificados SSL de Let's Encrypt, lo que simplifica significativamente la configuración de HTTPS. Si prefiere la simplicidad, Caddy es una excelente opción.

Primero, detenga Nginx si estaba instalado y en ejecución, para evitar conflictos de puertos:

sudo systemctl stop nginx
sudo systemctl disable nginx

Instale Caddy. La forma más sencilla es usar el repositorio oficial:

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install caddy -y

Cree o edite el archivo de configuración de Caddy (Caddyfile):

sudo nano /etc/caddy/Caddyfile

Elimine el contenido existente e inserte lo siguiente, reemplazando your_domain.com por su dominio:

your_domain.com {
    reverse_proxy 127.0.0.1:3000
}

Guarde el archivo y recargue Caddy:

sudo systemctl reload caddy

Caddy obtendrá automáticamente un certificado SSL para your_domain.com y configurará HTTPS. Su Redmine estará disponible en https://your_domain.com.

Independientemente del reverse proxy elegido, asegúrese de que los registros DNS de su dominio (registro A) apunten a la dirección IP de su VPS.

Mantenimiento de Redmine: copias de seguridad, actualizaciones y monitorización

El mantenimiento regular de Redmine en un VPS es fundamental para garantizar su funcionamiento estable, seguro y actualizado. Esto incluye la copia de seguridad de datos, las actualizaciones oportunas y la monitorización del rendimiento.

Estrategia de copia de seguridad de datos de Redmine

Las copias de seguridad son su seguro contra la pérdida de datos. Para Redmine, es necesario respaldar dos partes principales: la base de datos y los archivos (adjuntos, plugins, temas).

Copia de seguridad de la base de datos PostgreSQL

La base de datos es el corazón de Redmine. Utilizaremos pg_dump para crear un volcado de la base de datos desde dentro del contenedor Docker de PostgreSQL.

# Vaya al directorio con docker-compose.yml
cd ~/redmine

# Cree un directorio para las copias de seguridad (si no existe)
mkdir -p ./backups/db

# Realice el volcado de la base de datos
docker compose exec db pg_dump -U redmine_user redmine_production > ./backups/db/redmine_db_$(date +%Y%m%d_%H%M%S).sql

Reemplace redmine_user y redmine_production con sus valores si son diferentes.

Copia de seguridad de los archivos de Redmine

Los archivos adjuntos, plugins y temas se almacenan en volúmenes de Docker. También es necesario hacer una copia de seguridad de ellos. Para ello, puede utilizar el comando docker cp o simplemente copiar el contenido de los volúmenes si están montados como directorios en el host (lo que hicimos en docker-compose.yml).

# Cree un directorio para las copias de seguridad de archivos
mkdir -p ./backups/files

# Copie los archivos de Redmine (adjuntos)
docker compose cp redmine_app:/usr/src/redmine/files ./backups/files/redmine_files_$(date +%Y%m%d_%H%M%S)

# Copie los plugins
docker compose cp redmine_app:/usr/src/redmine/plugins ./backups/files/redmine_plugins_$(date +%Y%m%d_%H%M%S)

# Copie los temas
docker compose cp redmine_app:/usr/src/redmine/public/themes ./backups/files/redmine_themes_$(date +%Y%m%d_%H%M%S)

Para automatizar este proceso, puede crear un script de shell y añadirlo a cron. Por ejemplo, el script backup_redmine.sh:

#!/bin/bash

BACKUP_DIR="/home/$USER/redmine/backups"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

# Copia de seguridad de la base de datos
docker compose exec db pg_dump -U redmine_user redmine_production > "$BACKUP_DIR/db/redmine_db_$TIMESTAMP.sql"

# Copia de seguridad de los archivos
docker compose cp redmine_app:/usr/src/redmine/files "$BACKUP_DIR/files/redmine_files_$TIMESTAMP"
docker compose cp redmine_app:/usr/src/redmine/plugins "$BACKUP_DIR/files/redmine_plugins_$TIMESTAMP"
docker compose cp redmine_app:/usr/src/redmine/public/themes "$BACKUP_DIR/files/redmine_themes_$TIMESTAMP"

# Eliminación de copias de seguridad antiguas (por ejemplo, de más de 7 días)
find "$BACKUP_DIR/db" -type f -name "*.sql" -mtime +7 -delete
find "$BACKUP_DIR/files" -maxdepth 1 -type d -name "redmine_files_*" -mtime +7 -exec rm -rf {} +
find "$BACKUP_DIR/files" -maxdepth 1 -type d -name "redmine_plugins_*" -mtime +7 -exec rm -rf {} +
find "$BACKUP_DIR/files" -maxdepth 1 -type d -name "redmine_themes_*" -mtime +7 -exec rm -rf {} +

echo "Copia de seguridad de Redmine completada en $TIMESTAMP"

Haga que el script sea ejecutable: chmod +x backup_redmine.sh. Añádalo a cron (crontab -e) para su ejecución diaria, por ejemplo, a las 2 de la madrugada:

0 2 * * * /home/$USER/redmine/backup_redmine.sh >> /var/log/redmine_backup.log 2>&1

Para soluciones de copia de seguridad más avanzadas, considere la posibilidad de utilizar herramientas como Restic, que permite gestionar eficazmente las copias de seguridad incrementales y enviarlas a almacenamientos en la nube.

Actualización de Redmine e imágenes Docker

Las actualizaciones regulares de Redmine y sus componentes son importantes para obtener nuevas funciones, correcciones de errores y parches de seguridad.

1. Actualización de imágenes Docker:

   cd ~/redmine
   docker compose pull # Descargará nuevas versiones de las imágenes (redmine, postgres, redis)
   docker compose down # Detendrá los contenedores actuales
   docker compose up -d # Iniciará los contenedores con las nuevas imágenes

2. Migraciones de base de datos (si es necesario): Después de actualizar la imagen de Redmine, pueden ser necesarias migraciones de la base de datos. Siempre ejecútelas:

   docker compose exec redmine bundle exec rake db:migrate RAILS_ENV=production

3. Actualización de plugins: Si utiliza plugins, verifique su compatibilidad con la nueva versión de Redmine y actualícelos manualmente, siguiendo las instrucciones de los desarrolladores de los plugins. A menudo, esto requiere copiar nuevos archivos de plugin al directorio plugins y ejecutar migraciones para los plugins:

   docker compose exec redmine bundle exec rake redmine:plugins:migrate RAILS_ENV=production

4. Limpieza de la caché: Después de las actualizaciones, se recomienda limpiar la caché de Redmine:

   docker compose exec redmine bundle exec rake tmp:cache:clear RAILS_ENV=production
   docker compose exec redmine bundle exec rake tmp:sessions:clear RAILS_ENV=production

¡Siempre haga una copia de seguridad completa antes de iniciar el proceso de actualización!

Monitorización del rendimiento y el estado

• Estado de los contenedores Docker:

  docker compose ps
  docker stats

  docker stats mostrará el uso de CPU, RAM, I/O para cada contenedor.

• Uso de recursos del VPS:

  htop # Monitor interactivo de procesos
  free -h # Uso de la memoria RAM
  df -h # Uso del espacio en disco

• Logs de Redmine: Verifique los logs de Redmine en busca de errores:

  docker compose logs redmine

La monitorización regular ayudará a identificar posibles problemas antes de que afecten el trabajo de su equipo.

Elección de un VPS para Redmine bajo carga real: configuraciones y precios

La elección de la configuración óptima de un VPS para Redmine depende directamente del tamaño de su equipo, la intensidad de uso y el volumen de datos almacenados. Pagar de más por recursos excesivos es tan indeseable como la falta de recursos, que provoca ralentizaciones y fallos.

Recomendaciones de configuración de VPS para diferentes escenarios

Valebyte.com ofrece una amplia gama de tarifas de VPS que son ideales para el despliegue de Redmine. A continuación se presenta una tabla con las configuraciones recomendadas para varios escenarios de uso:

Escenario de uso	Cantidad de usuarios	CPU (vCores)	RAM (GB)	Disco (NVMe SSD)	Costo aproximado de VPS/mes (USD)
Personal / Prueba	1-3	1	2	30 GB	$5 - $8
Equipo pequeño	5-15	2	4	50 GB	$10 - $18
Equipo mediano	15-30	4	8	100 GB	$20 - $35
Equipo grande / Alta carga	30+	6-8+	16+	200 GB+	$40 - $70+

Aclaraciones sobre la tabla:

• CPU (vCores): Redmine no siempre utiliza intensivamente el procesador, pero con un gran número de solicitudes simultáneas o informes complejos, los núcleos adicionales mejoran significativamente el rendimiento.
• RAM (GB): La memoria RAM es uno de los recursos más críticos. Redmine, PostgreSQL y Redis utilizan activamente la RAM para el almacenamiento en caché. La falta de RAM conduce a un intercambio activo (swapping), lo que ralentiza el funcionamiento de todo el sistema. Siempre es mejor tener un pequeño margen.
• Disco (NVMe SSD): La presencia de NVMe SSD es prácticamente obligatoria. La velocidad de las operaciones de disco influye directamente en la capacidad de respuesta de Redmine, especialmente al trabajar con la base de datos y un gran número de archivos adjuntos. Los SSD o HDD normales pueden convertirse en un cuello de botella.
• Costo aproximado: Los precios pueden variar entre diferentes proveedores, pero dan una idea general del presupuesto. Valebyte.com ofrece tarifas competitivas con NVMe SSD de alto rendimiento.

Factores que influyen en la elección de la configuración

• Cantidad de usuarios activos: Cuantas más personas trabajen simultáneamente en Redmine, mayores serán los requisitos de CPU y RAM.
• Intensidad de uso: Si Redmine se utiliza solo para el seguimiento de tareas, los requisitos son menores. Si se utilizan activamente Wiki, foros, archivos grandes, diagramas de Gantt con muchas tareas, seguimiento del tiempo, los requisitos aumentan.
• Cantidad de proyectos y tareas: Un gran número de proyectos y tareas aumenta el tamaño de la base de datos y la complejidad de las consultas.
• Uso de plugins: Algunos plugins pueden consumir muchos recursos y aumentar la carga del servidor.
• Volumen de archivos almacenados: Los archivos adjuntos ocupan espacio en disco. Si los usuarios suben con frecuencia archivos grandes, se necesita un mayor volumen de disco.

Comience con una configuración que se adapte a sus necesidades actuales y esté preparado para escalar los recursos del VPS a medida que su equipo y proyecto crezcan. La mayoría de los proveedores, incluido Valebyte.com, permiten actualizar fácilmente el plan de tarifas sin reinstalar el sistema.

Conclusiones

La instalación de Redmine en un VPS utilizando Docker Compose es una forma fiable y flexible de obtener un potente sistema de gestión de proyectos bajo control total. Este enfoque garantiza un alto rendimiento, seguridad de los datos y la posibilidad de una configuración precisa para cualquier necesidad del equipo, superando significativamente a las soluciones SaaS en personalización y costo a largo plazo. La elección de una tarifa de VPS adecuada con suficiente RAM y un disco NVMe rápido garantiza un funcionamiento estable y cómodo de Redmine incluso bajo alta carga.