Executando Gerenciamento de Projetos Redmine no nginx (Debian Wheezy)

Redmine é uma ferramenta de gerenciamento de projetos escrita em Ruby. Este tutorial explica como servir o Redmine com a ajuda do thin (um servidor web Ruby rápido) através de um servidor web nginx no Debian Wheezy.

Não dou nenhuma garantia de que isso funcionará para você!

1 Nota Preliminar

Preparei um site www.example.com com o diretório raiz /var/www/example.com/web (o Redmine será instalado lá) que é de propriedade do usuário web1 e do grupo client0.

Também preparei um banco de dados MySQL para o Redmine com o nome c0db1. O nome de usuário é c0db1 também, a senha é FyZ5z4QGfhTf8.

2 Instalando o Redmine

Primeiro, instalamos alguns pré-requisitos:

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

Baixe a versão mais recente do Redmine e copie-a para nosso diretório raiz /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 *

Preencha os detalhes de login para nosso banco de dados 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
[...]

Instale alguns outros pacotes necessários e preencha o banco de dados:

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

Em seguida, configuramos o thin, nosso servidor web Ruby que o nginx irá encaminhar as solicitações.

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

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

Crie um arquivo de configuração thin que é nomeado como o proprietário do diretório raiz (web1):

vi web1.yml

Certifique-se de usar o usuário correto (web1) nas linhas de log, pid, socket e usuário, bem como o grupo correto (client0) na linha do grupo. Use o diretório raiz correto na linha 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: /

Crie o diretório /var/run/thin (onde o thin criará seu socket):

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

Para garantir que o diretório exista quando o thin for iniciado, adicionamos a linha test -e /var/run/thin || install -m 755 -o web1 -g client0 -d /var/run/thin ao script init /etc/init.d/thin (logo após a linha 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

[...]

Agora inicie o thin…

/etc/init.d/thin start

… e anote o socket que ele cria (/var/run/thin/web1.0.sock neste caso) - precisaremos dele na configuração do nginx:

root@server1:/etc/thin# /etc/init.d/thin start  
 [start] /etc/thin1.9.1/web1.yml ...  
 Starting server on /var/run/thin/web1.0.sock ...  
 root@server1:/etc/thin#

Se você estiver usando o Monit, pode adicionar as seguintes linhas ao /etc/monit/monitrc para garantir que o thin esteja sempre em execução:

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"
[...]

Reinicie o Monit em seguida:

/etc/init.d/monit restart

4 Configurando nginx

Em seguida, devemos configurar nosso vhost nginx através do qual queremos acessar o Redmine. Você deve colar a seguinte configuração em seu container server {} (ou no campo Diretivas do nginx se usar ISPConfig) - certifique-se de usar o socket thin correto:

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;
    }
}

É isso! Agora visite seu site e você deve ser capaz de usar o Redmine. O nome de usuário padrão é admin, a senha também é admin.

Executando Gerenciamento de Projetos Redmine no nginx (Debian Wheezy)