Redmine Projektmanagement auf nginx (Debian Wheezy) ausführen

Redmine ist ein Projektmanagement-Tool, das in Ruby geschrieben ist. Dieses Tutorial erklärt, wie man Redmine mit Hilfe von thin (einem schnellen Ruby-Webserver) über einen nginx-Webserver auf Debian Wheezy bereitstellt.

Ich gebe keine Garantie, dass dies bei Ihnen funktioniert!

1 Vorbemerkung

Ich habe eine Website www.example.com mit dem Dokumentenstamm /var/www/example.com/web vorbereitet (dort wird Redmine installiert), die dem Benutzer web1 und der Gruppe client0 gehört.

Ich habe auch eine MySQL-Datenbank für Redmine mit dem Namen c0db1 vorbereitet. Der Benutzername ist ebenfalls c0db1, das Passwort ist FyZ5z4QGfhTf8.

2 Redmine installieren

Zuerst installieren wir einige Voraussetzungen:

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

Laden Sie die neueste Redmine-Version herunter und kopieren Sie sie in unseren Dokumentenstamm /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 *

Füllen Sie die Anmeldedaten für unsere MySQL-Datenbank aus:

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

Installieren Sie einige andere benötigte Pakete und füllen Sie die Datenbank:

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 thin konfigurieren

Als nächstes konfigurieren wir thin, unseren Ruby-Webserver, an den nginx Anfragen weiterleiten wird.

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

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

Erstellen Sie eine thin-Konfigurationsdatei, die nach dem Besitzer des Dokumentenstamms (web1) benannt ist:

vi web1.yml

Stellen Sie sicher, dass Sie den richtigen Benutzer (web1) in den Log-, PID-, Socket- und Benutzerzeilen sowie die richtige Gruppe (client0) in der Gruppenzeile verwenden. Verwenden Sie den richtigen Dokumentenstamm in der chdir-Zeile:

---
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: /

Erstellen Sie das Verzeichnis /var/run/thin (wo thin seinen Socket erstellen wird):

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

Um sicherzustellen, dass das Verzeichnis existiert, wenn thin gestartet wird, fügen wir die Zeile test -e /var/run/thin || install -m 755 -o web1 -g client0 -d /var/run/thin zum Init-Skript /etc/init.d/thin hinzu (direkt nach der SCRIPT_NAME-Zeile):

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

[...]

Jetzt starten Sie thin…

/etc/init.d/thin start

… und beachten Sie den Socket, den es erstellt (in diesem Fall /var/run/thin/web1.0.sock) - wir benötigen ihn in der nginx-Konfiguration:

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#

Wenn Sie Monit verwenden, können Sie die folgenden Zeilen zu /etc/monit/monitrc hinzufügen, um sicherzustellen, dass thin immer läuft:

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

Starten Sie Monit danach neu:

/etc/init.d/monit restart

4 nginx konfigurieren

Als nächstes müssen wir unseren nginx vhost konfigurieren, über den wir auf Redmine zugreifen möchten. Sie müssen die folgende Konfiguration in Ihren server {} Container (oder das nginx-Direktivenfeld, wenn Sie ISPConfig verwenden) einfügen - stellen Sie sicher, dass Sie den richtigen thin-Socket verwenden:

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

Das war’s! Besuchen Sie jetzt Ihre Website, und Sie sollten in der Lage sein, Redmine zu verwenden. Der Standardbenutzername ist admin, das Passwort ist ebenfalls admin.

Redmine Projektmanagement auf nginx (Debian Wheezy) ausführen