Instalar Redmine 4.2.3 en Rocky Linux con PostgreSQL y Apache

Instale Redmine 4.2.3 en Rocky Linux 8.4 usando PostgreSQL y Apache (httpd) con Phusion Passenger como gestor de aplicaciones. Este tutorial cubre dependencias, RVM y Ruby 2.7, creación de la base de datos PostgreSQL, instalación de Redmine, integración con Passenger y configuración de virtual hosts (HTTP y HTTPS). Incluye listas de verificación, seguridad, copia de seguridad y solución de problemas comunes.

Importante: se asume que dispone de privilegios root y que PostgreSQL ya está instalado. Domine los pasos en un entorno de pruebas antes de pasar a producción.

Objetivo y variantes de búsqueda

Objetivo principal: desplegar Redmine 4.2.3 en Rocky Linux con PostgreSQL y Apache. Variantes útiles para búsqueda interna: “instalar Redmine Rocky Linux”, “Redmine PostgreSQL Apache Passenger”, “Redmine RVM Ruby 2.7”, “despliegue Redmine producción RockyLinux”.

Definición rápida

Redmine: gestor de proyectos y seguimiento de incidencias web, libre y de código abierto, escrito en Ruby on Rails. Passenger: servidor de aplicaciones que integra Rails con Apache/Nginx. RVM: gestor de versiones de Ruby.

Resumen del entorno de ejemplo

• Sistema operativo: Rocky Linux 8.4 (Green Obsidian)
• IP: 192.168.1.10
• Privilegios: root
• Dominio: redmine.example.com
• Redmine objetivo: /var/www/redmine
• Ruby: 2.7 (via RVM)
• Base de datos: PostgreSQL
• Servidor web: Apache (httpd) + Phusion Passenger

Requisitos previos comprobados

• PostgreSQL instalado y accesible (local o remoto).
• DNS apunta al servidor o archivo /etc/hosts configurado para el dominio.
• Puertos 80/443 abiertos en el firewall si se usará desde red.

Notas:

• Este documento describe una instalación basada en paquetes compilados y RVM para Ruby; existen alternativas (rbenv, paquetes del sistema, contenedores Docker). Ver la sección “Alternativas”.

Paso 1 — Instalar dependencias del sistema

Antes de instalar Redmine, instale las dependencias del sistema necesarias. Ejecute los comandos con sudo o como root.

1. Agregar EPEL:

sudo dnf install epel-release -y

2. Instalar herramientas de compilación y dependencias:

sudo dnf install curl gpg gnupg2 gcc gcc-c++ make patch autoconf automake bison ImageMagick libffi-devel libtool patch redhat-rpm-config readline-devel postgresql-devel zlib-devel openssl-devel -y

3. Instalar dependencias para Apache y módulos de desarrollo:

sudo dnf install libcurl-devel httpd-devel httpd apr-devel apr-util-devel -y

Iniciar y habilitar httpd:

sudo systemctl enable --now httpd
sudo systemctl status httpd

Consejo: si httpd no arranca, consulte journalctl -u httpd -e para ver errores de configuración o módulos faltantes.

Paso 2 — Instalar RVM y Ruby 2.7

Redmine 4.2.x requiere Ruby 2.7. Usaremos RVM para gestionar la versión.

1. Importar claves GPG de los desarrolladores de RVM:

curl -sSL https://rvm.io/mpapis.asc | gpg2 --import -
curl -sSL https://rvm.io/pkuczynski.asc | gpg2 --import -

2. Instalar RVM y cargar el entorno:

curl -L get.rvm.io | bash -s stable
source /etc/profile.d/rvm.sh

3. Instalar requisitos y Ruby 2.7:

rvm reload
rvm requirements run
rvm install 2.7
rvm list
ruby --version

Verifique que la versión activa sea ruby 2.7.x.

Paso 3 — Crear la base de datos PostgreSQL para Redmine

1. Entrar al shell de PostgreSQL:

sudo -u postgres psql

2. Crear rol y base de datos (modifique la contraseña por una segura):

CREATE ROLE redmine LOGIN ENCRYPTED PASSWORD 'StrongPasswordRedmine' NOINHERIT VALID UNTIL 'infinity';
CREATE DATABASE redminedb WITH ENCODING='UTF8' OWNER=redmine;

Salir con \q

Notas de seguridad: use contraseñas fuertes y, si PostgreSQL está expuesto, restrinja accesos por pg_hba.conf y firewall.

Paso 4 — Descargar e instalar Redmine 4.2.3

1. Descargar y extraer los ficheros en /var/www:

cd /var/www/
wget https://www.redmine.org/releases/redmine-4.2.3.tar.gz
tar -xzvf redmine-4.2.3.tar.gz
mv redmine-*/ redmine

2. Configurar conexión a la base de datos (config/database.yml):

export REDMINE=/var/www/redmine
cd $REDMINE
nano config/database.yml

Pegar y ajustar credenciales:

production:
  adapter: postgresql
  database: redminedb
  host: localhost
  username: redmine
  password: "StrongPasswordRedmine"
  encoding: utf8

3. Instalar gem bundler y dependencias Ruby de Redmine:

gem install bundler
bundle config set --local path 'vendor/bundle'
bundle config set --local without 'development test'
bundle install

4. Generar token secreto y migrar la base de datos:

bundle exec rake generate_secret_token
RAILS_ENV=production bundle exec rake db:migrate

5. Ajustar permisos de archivos (propietario apache):

sudo chown -R apache:apache $REDMINE

Consejo: si utiliza un usuario distinto (p. ej. www-data) adapte el comando.

Paso 5 — Instalar Phusion Passenger y módulo para Apache

Passenger integra Rails con Apache. Instalaremos Passenger via gem y su módulo Apache.

1. Instalar passenger:

gem install passenger

2. Ejecutar el instalador del módulo Apache:

passenger-install-apache2-module

Durante el proceso seleccione “Ruby” cuando el instalador pregunte por el tipo de aplicación.

El instalador proporciona un fragmento de configuración Apache; créelo en /etc/httpd/conf.d/passenger.conf. Ejemplo (ajuste rutas a su instalación Ruby/Passenger):

   LoadModule passenger_module /usr/local/rvm/gems/ruby-2.7.2/gems/passenger-6.0.12/buildout/apache2/mod_passenger.so
   
     PassengerRoot /usr/local/rvm/gems/ruby-2.7.2/gems/passenger-6.0.12
     PassengerDefaultRuby /usr/local/rvm/gems/ruby-2.7.2/wrappers/ruby
   

Reinicie httpd:

sudo systemctl restart httpd

Paso 6 — Configurar virtual host Apache para Redmine

Crear /etc/httpd/conf.d/redmine.conf con la configuración HTTP mínima:

PassengerRuby /usr/local/rvm/gems/ruby-2.7.2/wrappers/ruby


    ServerName redmine.example.io
    DocumentRoot "/var/www/redmine/public"

    ErrorLog logs/redmine_error_log
    LogLevel warn

    
        Options Indexes ExecCGI FollowSymLinks
        Require all granted
        AllowOverride all
    

Ejemplo HTTPS (necesita certificados y mod_ssl habilitado):

PassengerRuby /usr/local/rvm/gems/ruby-2.7.2/wrappers/ruby


  ServerName redmine.example.io
  Redirect permanent / https://redmine.example.io/




  ServerName redmine.example.io

  Protocols h2 http/1.1

  
    Redirect permanent / https://redmine.example.io/
  

  DocumentRoot "/var/www/redmine/public"

  ErrorLog /var/log/httpd/redmine.example.io-error.log
  CustomLog /var/log/httpd/redmine.example.io-access.log combined

  SSLEngine On
  SSLCertificateFile /etc/letsencrypt/live/redmine.example.io/fullchain.pem
  SSLCertificateKeyFile /etc/letsencrypt/live/redmine.example.io/privkey.pem

  
    Options Indexes ExecCGI FollowSymLinks
    Require all granted
    AllowOverride all
  

Verificar configuración y reiniciar:

apachectl configtest
sudo systemctl restart httpd

Paso 7 — Verificar la instalación y tareas post-instalación

Abra el navegador en https://redmine.example.io/login

• Usuario por defecto: admin
• Contraseña por defecto: admin

Tras iniciar sesión cambie inmediatamente la contraseña del administrador.

Complete el perfil y cargue la configuración regional por defecto cuando se solicite.

Comprobaciones rápidas después del despliegue

• Acceso a /login funciona y redirige a HTTPS si está configurado.
• Registre un proyecto de prueba y cree una incidencia para validar el flujo.
• Revise logs: /var/log/httpd/* y los logs de Redmine en log/ del directorio de instalación.

Seguridad y endurecimiento (recomendado)

• Forzar HTTPS y HSTS en producción.
• Restringir acceso al puerto 80/443 en el firewall sólo si es necesario.
• Asegurar PostgreSQL cambiando pg_hba.conf y escuchas (listen_addresses) a localhost o IPs necesarias.
• Mantener RVM y gemas Ruby actualizadas; revisiones periódicas.
• Proteger archivos config/database.yml con permisos 640 y propietario root:apache o similar.
• Realizar copia de seguridad de la base de datos y del directorio public/files con frecuencia.

Ejemplo de permiso seguro para database.yml:

sudo chown root:apache /var/www/redmine/config/database.yml
sudo chmod 640 /var/www/redmine/config/database.yml

Copia de seguridad y restauración básicas

Backup de PostgreSQL y archivos Redmine:

# Dump de PostgreSQL
sudo -u postgres pg_dump -Fc redminedb > /root/backups/redminedb-$(date +%F).dump

# Archivar archivos y attachments
tar -czf /root/backups/redmine-files-$(date +%F).tar.gz /var/www/redmine/files /var/www/redmine/public

Restauración básica:

# Restaurar base de datos
sudo -u postgres pg_restore -C -d postgres /root/backups/redminedb-YYYY-MM-DD.dump

# Restaurar archivos
tar -xzf /root/backups/redmine-files-YYYY-MM-DD.tar.gz -C /

Importante: antes de restaurar en producción, ponga Redmine en modo mantenimiento y confirme versiones de base de datos compatibles.

Mantenimiento y tareas de operación

Tareas periódicas recomendadas:

• Ejecutar rake db:migrate al actualizar Redmine.
• Limpiar ficheros temporales: tmp/ y log/ (rotación de logs).
• Actualizar gemas y verificar compatibilidad de plugins.
• Revisar integridad de attachments y permisos del sistema de ficheros.

Comando para rotar logs (ejemplo simple):

# cortar y reiniciar el log de producción
sudo mv /var/www/redmine/log/production.log /var/www/redmine/log/production.log.$(date +%F)
sudo -u apache touch /var/www/redmine/log/production.log

Plugins y correo (SMTP)

Instalar plugin simple:

# Clonar el plugin dentro de plugins/
cd /var/www/redmine
git clone https://github.com/usuario/plugin-ejemplo.git plugins/plugin-ejemplo
bundle install --without development test
RAILS_ENV=production bundle exec rake redmine:plugins:migrate
sudo systemctl restart httpd

Configurar SMTP en config/configuration.yml (ejemplo con TLS):

production:
  email_delivery:
    delivery_method: :smtp
    smtp_settings:
      address: "smtp.example.com"
      port: 587
      domain: "example.com"
      authentication: :login
      user_name: "redmine@example.com"
      password: "su_contraseña"
      enable_starttls_auto: true

Ejecutar pruebas de envío desde la interfaz de administración de Redmine.

Migración desde MySQL a PostgreSQL (guía breve)

Si migra datos desde MySQL:

• Exportar la base de datos MySQL a formato SQL.
• Usar herramientas como mysql2psql o scripts de conversión, teniendo en cuenta diferencias en tipos y codificación.
• Ajustar config/database.yml para PostgreSQL antes de importar.
• Ejecutar pruebas integrales en un entorno de staging.

Contraejemplo: no intentar conversión manual sin comprobar antes la integridad de attachments y codificación UTF-8.

Solución de problemas comunes

• Error 500 en producción: revisar logs en /var/www/redmine/log/production.log y /var/log/httpd/*.
• Passenger no carga: confirmar rutas en /etc/httpd/conf.d/passenger.conf y que mod_passenger exista.
• Problemas de dependencia gem: eliminar vendor/bundle y volver a ejecutar bundle install.
• Conexión a PostgreSQL denegada: comprobar credenciales, pg_hba.conf y que el servicio PostgreSQL esté activo.

Lista de verificación antes de pasar a producción

• Cambiar contraseña admin por una segura
• Configurar HTTPS con certbot o certificados válidos
• Habilitar firewall y reglas de acceso
• Configurar backup automatizado (DB + files)
• Auditar permisos de archivos y owner
• Probar envío de correo SMTP
• Instalar y probar plugins necesarios en staging

Criterios de aceptación

• Redmine responde en /login con HTTPS y muestra la página de login.
• Inicio de sesión con admin/admin (inmediato cambio de contraseña) funciona.
• Se puede crear un proyecto y una incidencia desde la UI.
• Los logs no contienen errores críticos relacionados con Passenger o DB.

Checklist por rol

Administrador de sistemas:

• Configurar backups y rotación de logs
• Mantener paquetes y kernel actualizados
• Restringir acceso a PostgreSQL

Administrador de Redmine (funcional):

• Crear usuarios y roles personalizados
• Configurar correo y notificaciones
• Revisar plugins y permisos de proyecto

Desarrollador/DevOps:

• Automatizar despliegue con Ansible/Chef/Terraform
• Versionar plugins y migraciones
• Ejecutar pruebas de carga si es necesario

Mapa de decisión (flujo de despliegue)

flowchart TD
  A[Preparar servidor Rocky Linux] --> B[Instalar dependencias y EPEL]
  B --> C[Instalar RVM y Ruby 2.7]
  C --> D[Crear DB PostgreSQL]
  D --> E[Descargar y configurar Redmine]
  E --> F[Instalar Passenger y configurar Apache]
  F --> G[Configurar virtual host HTTP/HTTPS]
  G --> H[Verificar aplicación /login]
  H --> I{Listo para producción?}
  I -- Si --> J[Habilitar backups y monitoreo]
  I -- No --> K[Depurar errores y repetir]

Mantenimiento a largo plazo y escalado

• Para alto tráfico, considere usar una pila con Nginx + Passenger, balanceo de carga y réplicas de base de datos.
• Externalice archivos (attachments) a almacenamiento S3 compatible si necesita escalabilidad y backups simplificados.
• Monitorice SLI/SLO básicos: tiempo de respuesta de login, tasa de errores 5xx y uso de CPU/memoria en nodos Passenger.

Alternativas y cuándo no usar esta guía

• Si desea despliegue en contenedores, use imágenes oficiales o Dockerfiles y orquesta con Kubernetes; esta guía está orientada a despliegue en VM/host físico.
• Si prefiere paquetes del sistema para Ruby, considere usar rbenv o paquetes distribuidos (puede simplificar la operación pero limitar versiones).
• Para instalaciones multiusuario de alto aislamiento, usar contenedores es preferible.

Edge cases y consejos

• Si necesita múltiples instancias de Redmine en el mismo host, use sockets y distinto DocumentRoot y PassengerSpawnMethod.
• Al restaurar backups en versiones diferentes de Redmine, compruebe compatibilidad de migraciones.

Glosario en una línea

• RVM: gestor de versiones de Ruby.
• Passenger: servidor de aplicaciones para Ruby (Phusion Passenger).
• Bundler: gestor de dependencias Ruby.
• pg_hba.conf: archivo de control de acceso de PostgreSQL.

Preguntas frecuentes

P: ¿Puedo usar MySQL en lugar de PostgreSQL? R: Sí, Redmine soporta MySQL y MariaDB. Este tutorial usa PostgreSQL por ejemplo; adapte adapter y dependencias.

P: ¿Necesito Passenger o puedo usar Puma/Unicorn? R: Puede usar Puma/Unicorn detrás de un proxy reverso (Nginx/Apache). Passenger simplifica la integración con Apache.

Conclusión

Ha desplegado Redmine 4.2.3 sobre Rocky Linux 8.4 con PostgreSQL y Apache+Passenger. Siga las listas de verificación para endurecimiento, configure backups automáticos y pruebe plugins y correo en un entorno de staging antes de producción. Para escalado, evalúe balanceo de carga, almacenamiento externo para attachments y réplicas de base de datos.

Resumen de acciones recomendadas:

• Cambiar credenciales por defecto y asegurar config/database.yml.
• Habilitar HTTPS y políticas de firewall.
• Configurar backups regulares (DB + files).

Extras sociales (sugerencia de publicación):

• Título (OG): Instalar Redmine 4.2.3 en Rocky Linux con PostgreSQL y Apache
• Descripción (OG): Guía paso a paso para desplegar Redmine 4.2.3 en Rocky Linux 8.4 usando PostgreSQL, RVM/Ruby 2.7 y Apache con Passenger.

¡Listo para producción! Mantenga copias de seguridad y procedimientos de recuperación probados.