Redmine 3 mit Gitolite 3 installieren

Eine gelungene, kostenfreie Kombination für ein Ticketsystem mit Versionskontrolle bieten Redmine als Ticketsystem und git als Versionskontrolle. Gitolite dient dabei als Mittler, um Nutzer des Ticketsystems gegenüber dem eigenen Git-Server zu authentifizieren und so die Versionskontrolle über das Ticketsystem steuerbar zu machen. Mehr dazu gibt es im neuen Jahr in einem eigenen Blog-Beitrag, den ich dann hier verlinke.

Voraussetzungen für die neue Infrastruktur

Dieser Artikel ist eine Anleitung, wie man auf einem eigenen, dafür geeigneten Server diese Kombination aufsetzt.
Ausgegangen wird hier von Debian als Betriebssystem, und der eingeloggte User ist root. Es wird vorausgesetzt, dass man Pakete installieren und einen einfachen Editor wie vim oder nano benutzen kann.

Zunächst installiert man die grundlegenden Softwarepakete, die benötigt werden:

apt-get install rubygems gitolite3 build-essential libssh2-1 libssh2-1-dev cmake libgpg-error-dev mysql apoache2

Anschließend werden dem System zwei User für git („git“) und Redmine („redmine“) hinzugefügt:

adduser --system --shell /bin/bash --gecos 'Git Administrator' --group --disabled-password --home /opt/gitolite git
adduser --system --shell /bin/bash --gecos 'Redmine Administrator' --group --disabled-password --home /opt/redmine redmine

Da das Ticketsystem später die Kontrolle über die Versionskontrolle ausüben soll, legen wir einen SSH-Key für den User redmine an:

su redmine
ssh-keygen -t rsa -N '' -f ~/.ssh/redmine_gitolite_admin_id_rsa
exit

Versionskontrolle kontrollieren

Nun kann Gitolite mit

dpkg-reconfigure gitolite3

neu konfiguriert werden, da die Konfiguration bei Installation ein paar Settings anders setzt, als wir es gerne hätten. Die Parameter zur Konfiguration sind:
user: git
repos path: /opt/gitolite
admin ssh-key: /opt/redmine/.ssh/redmine_gitolite_admin_id_rsa.pub

Redmine und Gitolite benötigen teilweise sudo-Rechte für den jeweilig anderen User, Redmine für die Installation temporär sogar darüber hinaus. Dazu konfigurieren wir unseren Server für das Ticketsystem mit Versionskontrolle mit

visudo

Folgendes wird zusätzlich eingetragen:

# temp – *REMOVE* after installation
redmine ALL=(ALL) NOPASSWD:ALL

# redmine gitolite integration
redmine ALL=(git) NOPASSWD:ALL
git ALL=(redmine) NOPASSWD:ALL

Installation des Ticketsystems Redmine

Jetzt wird Redmine installiert. Dazu loggen wir uns als User redmine ein und wechseln in sein Home-Verzeichnis.

sudo su - redmine
cd ~

Wir befinden uns jetzt in /opt/redmine, wo wir den aktuellen Code über github ziehen.

git init
git remote add origin https://github.com/redmine/redmine.git
git fetch -p

Da wir uns im Home-Verzeichnis befinden, schließen wir noch ein paar Verzeichnisse und Dateien aus:

vim .gitignore

Auszuschließende Items sind zum Beispiel:
.ssh/
.bash_history

Als nächstes checken wir die aktuelle stabile Version aus.

git add .gitignore
git commit -m 'local gitignore'
git checkout 3.1-stable

An dieser Stelle kann man jetzt noch die Quelle vom Original zu einer eigenen Quelle verschieben.

git remote rm origin
git remote add origin __URL__

Wir benutzen Redmine mit einer MySQL-Datenbank. Sollte noch kein MySQL-Server installiert sein, bitte nachholen. Ansonsten mit

mysql -u root -p -v -e "CREATE DATABASE redmine CHARACTER SET utf8; CREATE USER '__USER__'@'localhost' IDENTIFIED BY '__PASSWORD__'; GRANT ALL PRIVILEGES ON redmine.* TO '__USER__'@'localhost';"

__*__ bitte mit geeigneten Werten ersetzen.

Das oben erstellte Login verwenden wir nun zur Konfiguration von Redmine. Wir kopieren die Config-Templates und editieren diese:

cd /opt/redmine/config
cp database.yml.example database.yml
cp configuration.yml.example configuration.yml

vim database.yml
vim configuration.yml

Erweiterte Erläuterungen zur Konfiguration gibt es hier für die Datenbank und hier für Generelles.

Danach wechseln wir zurück ins Home-Verzeichnis und beginnen mit der Installation. Zur eigentlichen Installation von Redmine müssen wir im Gemfile noch eine Anpassung vornehmen.

cd ~
sudo gem install bundler
nano Gemfile

Hier ändern wir die mysql2-Version auf 4.2.0, wenn man Percona als MySQL-Server in der Version 5.6 benutzen möchte.

Jetzt wird endlich installiert:

bundle install --without development test postgresql sqlite
rake generate_secret_token
RAILS_ENV=production rake db:migrate

Plugins für das Ticketsystem

Nachdem Redmine grundlegend installiert wurde, kümmern wir uns jetzt um die Plugins:

cd ~/plugins
git clone https://github.com/jbox-web/redmine_bootstrap_kit.git
git clone https://github.com/jbox-web/redmine_git_hosting.git
cd redmine_bootstrap_kit/
git checkout 0.2.4
cd ../redmine_git_hosting/
git checkout 1.2.0
cd ~
bundle install --without development test
bundle exec rake redmine:plugins:migrate RAILS_ENV=production NAME=redmine_git_hosting

Der eingangs erstellte SSH-Key wird jetzt in das Plugin verlinkt:

ln -s /opt/redmine/.ssh/redmine_gitolite_admin_id_rsa /opt/redmine/plugins/redmine_git_hosting/ssh_keys/redmine_gitolite_admin_id_rsa
ln -s /opt/redmine/.ssh/redmine_gitolite_admin_id_rsa.pub /opt/redmine/plugins/redmine_git_hosting/ssh_keys/redmine_gitolite_admin_id_rsa.pub

Das Ticketsystem mit Versionskontrolle überprüfen

Wir wechseln jetzt auf die Seite des Users git und überprüfen Gitolite.

sudo su - git
sed -i 's/$GL_GITCONFIG_KEYS = ""/$GL_GITCONFIG_KEYS = ".*"/g' /opt/gitolite/.gitolite.rc
exit
ssh -i .ssh/redmine_gitolite_admin_id_rsa git@localhost info

Dabei sollte eine Antwort ähnlich wie diese hier kommen:
hello admin, this is git@__SERVER__ running gitolite3 3.6.1-2 (Debian) on git 2.1.4

R W gitolite-admin
R W testing

Als letztes wird nun Redmine mittels des Passenger-Moduls zum Laufen gebracht. Es wird vorausgesetzt, dass ein entsprechender vhost-Eintrag existiert, der auf /opt/redmine/public verweist. Das Passenger-Modul installiert man mit

passenger-install-apache2-module

und trägt danach die in der Installation erzeugten Pfade in die apache-Konfiguration ein.

Bei mir hat diese Anleitung zum Aufsetzen eines Ticketsystems mit Versionskontrolle bisher immer sehr gut funktioniert. Wenn ihr Probleme habt, schreibt bitte in die Kommentare, damit diese Anleitung ständig verbessert werden kann. Gleichzeitig können wir durch den regen Ausstausch mit euch aber auch die Qualität unserer PHP-Schulungen für Webentwickler noch weiter erhöhen.

Quellen und weiterführende Links:
Redmine
Gitolite
Redmine und Gitolite
Apache Passenger
Redmine git hosting
Redmine git hosting Plugin-Seite

Der Beitrag Ticketsystem mit Versionskontrolle erschien zuerst auf Entwicklungshilfe NRW.