Ejecutando Redmine Project Management En nginx (Debian Wheezy)

Redmine es una herramienta de gestión de proyectos escrita en Ruby. Este tutorial explica cómo servir Redmine con la ayuda de thin (un servidor web Ruby rápido) a través de un servidor web nginx en Debian Wheezy.

¡No emito ninguna garantía de que esto funcione para ti!

1 Nota Preliminar

He preparado un sitio web www.example.com con la raíz del documento /var/www/example.com/web (Redmine se instalará allí) que es propiedad del usuario web1 y del grupo client0.

También he preparado una base de datos MySQL para Redmine con el nombre c0db1. El nombre de usuario es c0db1 también, la contraseña es FyZ5z4QGfhTf8.

2 Instalando Redmine

Primero instalamos algunos requisitos previos:

apt-get install thin ruby rake rubygems libopenssl-ruby libmysql-ruby librmagick-ruby ruby-dev libmysqlclient-dev libmagick-dev curl

gem install sass  
 gem install compass

Descarga la última versión de Redmine y cópiala a nuestra raíz del documento /var/www/example.com/web:

cd /tmp  
 wget http://www.redmine.org/releases/redmine-2.4.2.tar.gz  
tar xvfz redmine-2.4.2.tar.gz  
mv redmine-2.4.2/* /var/www/example.com/web  
cd /var/www/example.com/web  
chown -R web1:client0 *

Completa los detalles de inicio de sesión para nuestra base de datos MySQL:

cp config/database.yml.example config/database.yml  
 vi config/database.yml

[...]
production:
  adapter: mysql2
  database: c0db1
  host: localhost
  username: c0db1
  password: "FyZ5z4QGfhTf8"
  encoding: utf8
[...]

Instala algunos otros paquetes necesarios y llena la base de datos:

apt-get install libmagickwand-dev

gem install rmagick

gem install bundler

bundle install --without development test postgresql sqlite

rake generate_secret_token

rake db:migrate RAILS_ENV="production"

rake redmine:load_default_data RAILS_ENV="production"

3 Configurando thin

A continuación, configuramos thin, nuestro servidor web Ruby al que nginx enviará solicitudes.

ln -s /etc/thin1.9.1 /etc/thin

mkdir /var/log/thin  
 chmod 755 /var/log/thin  
 cd /etc/thin

Crea un archivo de configuración thin que se llame como el propietario de la raíz del documento (web1):

vi web1.yml

Asegúrate de usar el usuario correcto (web1) en las líneas de log, pid, socket y user, así como el grupo correcto (client0) en la línea de group. Usa la raíz del documento correcta en la línea chdir:

---
chdir: /var/www/example.com/web
environment: production
timeout: 30
log: /var/log/thin/web1.log
pid: /var/run/thin/web1.pid
max_conns: 1024
max_persistent_conns: 512
require: []
wait: 30
socket: /var/run/thin/web1.sock
daemonize: true
user: web1
group: client0
servers: 1
prefix: /

Crea el directorio /var/run/thin (donde thin creará su socket):

mkdir /var/run/thin  
 chown -R web1:client0 /var/run/thin

Para asegurarnos de que el directorio exista cuando thin se inicie, agregamos la línea test -e /var/run/thin || install -m 755 -o web1 -g client0 -d /var/run/thin al script de inicio /etc/init.d/thin (justo después de la línea SCRIPT_NAME):

vi /etc/init.d/thin

[...]
DAEMON=/usr/bin/thin
SCRIPT_NAME=/etc/init.d/thin

test -e /var/run/thin || install -m 755 -o web1 -g client0 -d /var/run/thin

[...]

Ahora inicia thin…

/etc/init.d/thin start

… y toma nota del socket que crea (/var/run/thin/web1.0.sock en este caso) - lo necesitaremos en la configuración de nginx:

root@server1:/etc/thin# /etc/init.d/thin start  
 [start] /etc/thin1.9.1/web1.yml ...  
 Iniciando servidor en /var/run/thin/web1.0.sock ...  
 root@server1:/etc/thin#

Si estás usando Monit, puedes agregar las siguientes líneas a /etc/monit/monitrc para asegurarte de que thin siempre esté en funcionamiento:

vi /etc/monit/monitrc

[...]
check process thin with pidfile /var/run/thin/web1.0.pid
   start program = "/etc/init.d/thin start"
   stop  program = "/etc/init.d/thin stop"
[...]

Reinicia Monit después:

/etc/init.d/monit restart

4 Configurando nginx

A continuación, debemos configurar nuestro vhost de nginx a través del cual queremos acceder a Redmine. Debes pegar la siguiente configuración en tu contenedor server {} (o en el campo Directivas de nginx si usas ISPConfig) - asegúrate de usar el socket thin correcto:

client_max_body_size 100M;

location / {
    proxy_set_header X-Reak-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;
    proxy_redirect off;

    if (-f $request_filename/index.html) {
      rewrite (.*) $1/index.html break;
    }

    if (-f $request_filename.html) {
      rewrite (.*) $1.html break;
    }

    if (!-f $request_filename) {
      proxy_pass http://unix:/var/run/thin/web1.0.sock;
      break;
    }
}

¡Eso es todo! Ahora visita tu sitio web, y deberías poder usar Redmine. El nombre de usuario predeterminado es admin, la contraseña también es admin.

Ejecutando Redmine Project Management En nginx (Debian Wheezy)