Cómo instalar Redmine en Ubuntu Server

Logo Redmine

Esta entrada versa sobre la instalación de un servicio Redmine (gestión de tareas y proyectos) en un equipo con Linux, más en particular esta entrada se ha instalado en Ubuntu Server 10.10 de 64 bits, pero debería ser fácilmente adaptable a cualquier otra distribución o versión.

Algunas de las funcionalidades que le pediremos a esta instalación serán las siguientes:

  • Balanceo de carga (mediante servidor web Apache y módulo proxy y proxy_balancer).
  • Acceso seguro por medio de HTTPS (módulo SSL de Apache).
  • Arranque del servicio mediante un script (basado en gem mongrel) que se auto ejecute al reiniciar la máquina.
  • Rotación de logs (con logrotate).
  • Instalación del servicio de modo que se facilite la actualización de versión de Redmine (configuración, plugins, …).

Pasos a seguir:

Instalación de Ruby on Rails

Esto ya lo he documentado anteriormente en la siguiente entrada: Cómo instalar Ruby on Rails en Ubuntu.

Sólo añadir la instalación de la gema mongrel para lanzar un servidor Rails que atienda a Redmine:

sudo gem install mongrel

Bajar y configurar Redmine

Iremos a la web de Redmine y descargaremos la última versión estable, en este tutorial es la versión 1.1.1, además haremos la descarga sobre la carpeta y usuario de Apache (/var/www a partir de ahora todas las operaciones de configuración se harán relativas a este directorio):

cd /var/www
wget http://rubyforge.org/frs/download.php/74128/redmine-1.1.1.tar.gz

Descomprimimos y creamos un enlace para poder hacer referencia a la carpeta de Redmine con independencia de la versión instalada:

tar xzf redmine-1.1.1.tar.gz
ln -s redmine-1.1.1 redmine

Ahora creamos carpetas específicas para la configuración y plugins, para facilitar también la actualización de versión:

mkdir redmine-config redmine-files redmine-logs redmine-plugins

Creamos los ficheros de configuración a partir de los de ejemplo y los enlazamos en su carpeta:

cd redmine/config
cp database.yml.example ../../redmine-config/database.yml
ln -s ../../redmine-config/database.yml
cp email.yml.example ../../redmine-config/email.yml
ln -s ../../redmine-config/email.yml
cd -

Ahora editamos y configuramos la base de datos (con producción y desarrollo basta), personaliza los campos [user_name] y [password], e incluso el nombre de la base de datos o el adaptador, aquí hemos usado MySQL:

vim redmine-config/database.yml
production:
  adapter:  mysql
  database: redmine
  host:     localhost
  username: [user_name]
  password: [password]
  encoding: utf8
 
development:
  adapter:  mysql
  database: redmine
  host:     localhost
  username: [user_name]
  password: [password]
  encoding: utf8

Creamos la base de datos:

cd redmine
rake db:create
cd -

Y la información para envío de correos (esto evidentemente depende del servidor de correo que utilices para enviar correos, por favor, no me preguntéis a mí a este respecto, para ello mejor usad Google), personaliza el [dominio] con el nombre del dominio dónde alojes a Redmine:

vim redmine-config/email.yml
production:
  delivery_method:  :smtp
  smtp_settings:
    address:        localhost
    port:           25
    domain:         [dominio]
    authentication: :none
 
development:
  delivery_method:  :smtp
  smtp_settings:
    address:        localhost
    port:           25
    domain:         [dominio]
    authentication: :none

Hacemos lo propio para los ficheros adjuntos:

mv redmine/files redmine-files
cd redmine
ln -s ../redmine-files files
cd -

Para los logs:

mv redmine/log redmine-log
cd redmine
ln -s ../redmine-log log
cd -

Para los plugins, la idea es bajarlos en la carpeta redmine-plugins y enlazarlos en la carpeta de Redmine vendor/plugins; por ejemplo si tuviésemos que instalar el plugin Advanced Roadmap (también de la casa), haríamos lo siguiente:

cd redmine-plugins
wget http://ociotec.com/redmine/attachments/download/140/advanced_roadmap.0.4.0.tar.gz
tar xzf advanced_roadmap.0.4.0.tar.gz
ln -s advanced_roadmap.0.4.0 advanced_roadmap
cd ../redmine/vendor/plugins
ln -s ../../../redmine-plugins/advanced_roadmap
cd -
cd redmine
rake db:migrate:plugins
cd -

Llegado este punto sería conveniente probar lo instalado aunque sea en modo de desarrollo y con webrick:

cd redmine
ruby script/server
---> Press CTRL+C to STOP
cd -

Probamos lo instalado en un navegador web en la URL que tengamos (si es en la misma máquina sería localhost) con el puerto 3000 (por defecto al lanzarlo con la línea de comandos de arriba): http://localhost:3000.

Tal y como se lee arriba, una vez que hayamos accedido, pulsamos CTRL + C para terminar y volvemos al directorio anterior.

Servicios para Redmine

Tendremos que crear un script que apoyándose en mongrel_rails lance varias instancias de Redmine para atender las peticiones con balanceo de carga, cada una de las instancias atenderá peticiones en un puerto.

Editamos el fichero que arrancará Redmine:

sudo vim /etc/init.d/redmine
#!/usr/bin/env ruby
 
require "fileutils"
include FileUtils
 
require "rubygems"
 
begin
  gem 'mongrel'
rescue => e
  puts "Error: daemon mode of redmine requires mongrel installed"
  exit 1
end
 
def name
  "redmine"
end
 
def path
  "/var/www/redmine"
end
 
def user
  "www-data"
end
 
def environment
  "production"
end
 
def ports
  ["3000", "3001", "3002", "3003"]
end
 
def start
  ports.each do |port|
    system "su - #{user} -c 'cd #{path}; mongrel_rails start -d -e #{environment} -p #{port} -P #{path}/log/mongrel.#{port}.pid'"
  end
end
 
def stop
  ports.each do |port|
    system "cd #{path}; mongrel_rails stop -P #{path}/log/mongrel.#{port}.pid"
    system "rm -f #{path}/log/mongrel.#{port}.pid"
  end
end
 
command = ARGV.shift
 
case command
when 'start'
  start
  exit 0
when 'stop'
  stop
  exit 0
when 'restart'
  stop
  start
  exit 0
else
  p "Usage: /etc/init.d/#{name} start|stop|restart"
  exit 1
end

Tendremos que configurar los siguientes valores:

  • name: Nombre corto del script.
  • path: Path a la instalación de Redmine.
  • user: Usuario con el que lanzaremos las instancias de Redmine, normalmente con el usuario de Apache.
  • environment: Entorno de ejecución Rails, normalmente el de producción.
  • ports: Puertos para las instancias de los procesos que atenderán las peticiones. En nuestro ejemplo hemos seleccionado 4 puertos, recordad que si el usuario no es root, deben de ser puertos por encima del 1024.

Le dotamos de permisos de ejecución:

sudo chmod +x /etc/init.d/redmine

Actualizamos los scripts de arranque para incluir el recién creado script de arranque de Redmine:

sudo update-rc.d redmine defaults

Aprovechamos y arrancamos los servicios (para parar se usa stop y restart para reiniciar):

sudo /etc/init.d/redmine start

Podemos probar que las 4 instancias funcionan en http://localhost:3000, http://localhost:3001, http://localhost:3002 y http://localhost:3003.

Apache con balanceo de carga

Lo primero es instalar los módulos de Apache de proxy y balanceo de carga:

sudo a2enmod proxy
sudo a2enmod proxy_http
sudo a2enmod proxy_balancer

Editamos un nuevo sitio para Apache:

sudo vim /etc/apache2/sites-available/redmine
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
ProxyPass        /redmine balancer://redmine_cluster
ProxyPassReverse /redmine balanver://redmine_cluster
 
Header add Set-Cookie "BalancerMember=%{BALANCER_WORKER_NAME}e; path=/redmine" env=BALANCER_ROUTE_CHANGED
 
<proxy balancer://redmine_cluster>
        BalancerMember http://127.0.0.1:3000
        BalancerMember http://127.0.0.1:3001
        BalancerMember http://127.0.0.1:3002
        BalancerMember http://127.0.0.1:3003
        ProxySet stickysession=BalancerMember
</proxy>
 
<location /redmine>
        Order Deny,Allow
        Allow from All
</location>

En la configuración de arriba tendremos que tocar varias cosas:

  • Prefijo para acceder a Redmine, en el ejemplo se presupone que se accederá a Redmine mediante una URL del estilo a http://dominio.com/redmine, de ahí el prefijo /redmine en las líneas 1, 2, 4 y 14.
  • Las líneas 7 a 10 redirigen a los 4 procesos en los 4 puertos que ya habíamos configurado en el script de arranque de la sección anterior, si no hubiésemos usado los puertos sugeridos, aquí habría que hacer las modificaciones pertinentes.
  • Las líneas 4 y 11 son opcionales, sirven para luego poder depurar desde el navegador web cuál de todos los procesos que servirán Redmine nos ha tocado, mediante la visualización de una cookie.

Habilitamos el sitio y reiniciamos Apache para aplicar los cambios:

sudo a2ensite redmine
sudo /etc/init.d/apache2 restart

Ya podemos acceder a nuestro Redmine con balanceo de carga con la URL que tengamos, del estilo a http://dominio.com/redmine, podemos ver qué proceso nos ha atendido buscando la coockie BalancerMember dentro de las coockies de nuestro dominio.

Acceso seguro con SSL

Lo primero es habilitar el módulo de SSL de Apache, si es que no está ya habilitado y reniciar Apache:

sudo a2enmod ssl
sudo /etc/init.d/apache2 restart

Con esto ya quedaría habilitado el acceso seguro.

Si además queremos forzar a que siempre se acceda de forma segura (para evitar el robo de claves a nuestros usuarios), debemos modificar el fichero de configuración Apache de Redmine:

sudo vim /etc/apache2/sites-available/redmine
1
2
3
4
5
6
7
8
...
<location /redmine>
        Order Deny,Allow
        Allow from All
        RewriteEngine On
        RewriteCond %{HTTPS} off
        RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI}
</location>

Esto redirigirá cualquier petición HTTP a HTTPS de manera automática. Sólo queda instalar los módulos de redirección de Apache y reniciarlo:

sudo a2enmod rewrite
sudo /etc/init.d/apache2 restart

Rotación de logs

Sólo nos falta hacer una gestión de los logs adecuada, para que no nos colapse el disco duro con megas y megas de logs…

Para ello haremos uso del estupendo paquete logrotate, lo primero es instalarlo (si es que no lo tuvieras ya instalado, dado que es de uso muy generalizado por otros paquetes):

sudo apt-get install logrotate

Editamos un fichero de configuración para los logs de redmine:

sudo vim /etc/logrotate.d/redmine
/var/www/redmine-log/mongrel.log /var/www/redmine-log/production.log /var/www/redmine-log/development.log {
    rotate 7
    daily
    compress
    copytruncate
}

Este fichero rotará los logs todos los días, y comprimirá y guardará 7 copias de días pasados, para los logs de mongrel y de los entornos de producción y desarrollo.

Enlazar Redmine con la gestión de configuración

Si queremos que Redmine examine los cambios realizados en los repositorios que tengamos en Gestión de la Configuración (Subversion, CVS, GIT, Mercurial, …) tendremos que añadir una tarea al CRON para que examine cambios periódicamente:

sudo vim /etc/cron.d/redmine_subversion
*/30 * * * * www-data ruby /var/www/redmine/script/runner "Repository.fetch_changesets" -e production &> /dev/null

En el ejemplo de arriba se examinarán cambios cada 30 minutos, esto puedes cambiarlo a tu gusto.

9 comentarios

  1. how to win your ex boyfriend back

    Cómo instalar Redmine en Ubuntu Server « OCIO y TECnología

  2. private jet

    Cómo instalar Redmine en Ubuntu Server « OCIO y TECnología

  3. Picazamora dice: Responder

    Hola estaba siguiendo tu pedazo manual y me e quedado en un paso.

    que es al crear la base de datos.

    Cuando ponemos

    rake db:create

    Ese codigo mi terminal no lo acepta, me imagino que es una orden ruby no deberiamos poner:

    ruby rake db:create

    aunque así tampoco me funciona, y no entiendo muy bien por que tengo instalado ruby 1.8.7 trabajo con un servidor externo y no tengo el control total de la maquina 🙁
    Muchas gracias de antemano y muy buen trabajo!

    1. Nico dice: Responder

      acabo de tener el mismo problema ..

      1. pop dice: Responder

        Si el problema es debido al gem rmagick, prueba con

        $ sudo apt-get install libmagickcore-dev libmagickwand-dev

  4. Añadido enlace a la Gestión de Configuración desde Redmine.

  5. Añadida configuración para acceso vía SSL.

  6. Muchas gracias por tomarte el tiempo para explicarnos todo eso!! Si todo el mundo tuviera tu disciplina! 🙂

    1. Bueno, no destaco precisamente por un gran nivel de disciplina, pero se agradece el detalle 😉

Deja un comentario