Esecuzione di Redmine Project Management su nginx (Debian Wheezy)

Redmine è uno strumento di gestione progetti scritto in Ruby. Questo tutorial spiega come servire Redmine con l’aiuto di thin (un veloce server web Ruby) attraverso un server web nginx su Debian Wheezy.

Non fornisco alcuna garanzia che questo funzionerà per te!

1 Nota preliminare

Ho preparato un sito web www.example.com con la radice del documento /var/www/example.com/web (Redmine sarà installato lì) che è di proprietà dell’utente web1 e del gruppo client0.

Ho anche preparato un database MySQL per Redmine con il nome c0db1. Il nome utente è c0db1, la password è FyZ5z4QGfhTf8.

2 Installazione di Redmine

Prima installiamo alcune dipendenze:

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

Scarica l’ultima versione di Redmine e copiala nella nostra radice 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 *

Compila i dettagli di accesso per il nostro database 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
[...]

Installa alcuni altri pacchetti necessari e riempi il database:

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 Configurazione di thin

Successivamente configuriamo thin, il nostro server web Ruby a cui nginx inoltrerà le richieste.

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

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

Crea un file di configurazione thin che si chiama come il proprietario della radice del documento (web1):

vi web1.yml

Assicurati di usare l’utente corretto (web1) nelle righe di log, pid, socket e utente, così come il gruppo corretto (client0) nella riga del gruppo. Usa la corretta radice del documento nella riga 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 la directory /var/run/thin (dove thin creerà il suo socket):

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

Per assicurarti che la directory esista quando thin viene avviato, aggiungi la riga test -e /var/run/thin || install -m 755 -o web1 -g client0 -d /var/run/thin allo script di init /etc/init.d/thin (subito dopo la riga 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

[...]

Ora avvia thin…

/etc/init.d/thin start

… e prendi nota del socket che crea (/var/run/thin/web1.0.sock in questo caso) - ne avremo bisogno nella configurazione di 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 stai usando Monit, puoi aggiungere le seguenti righe a /etc/monit/monitrc per assicurarti che thin sia sempre in esecuzione:

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

Riavvia Monit successivamente:

/etc/init.d/monit restart

4 Configurazione di nginx

Successivamente dobbiamo configurare il nostro vhost nginx attraverso il quale vogliamo accedere a Redmine. Devi incollare la seguente configurazione nel tuo contenitore server {} (o nel campo Direttive nginx se usi ISPConfig) - assicurati di usare il socket thin corretto:

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

Ecco fatto! Ora visita il tuo sito web e dovresti essere in grado di utilizzare Redmine. Il nome utente predefinito è admin, la password è anch’essa admin.

Esecuzione di Redmine Project Management su nginx (Debian Wheezy)