Zentrales Git Repository unter Debian GNU/Linux 5.0 "Lenny" Howto

Einleitung

In einem anderen Howto habe ich bereits das Aufsetzen und die Verwendung eines einfachen lokalen Git-Repositories erläutert. Diese Einfachheit und die dezentralistische Art und Weise, wie Git seine Repositories verwaltet, sind auch die Stärken dieses Code Management Systems. Dennoch möchte man inbesondere in größeren Arbeitsumgebungen u.U. ein zentrales Git-Repository verwenden, das bspw. unterschiedliche Zugriffsverfahren ermöglicht (Filesystem, HTTP, SSH etc.).

In diesem Howto möchte ich die Inbetriebnahme eines zentralen Git-Repositories erläutern, auf das sowohl per SSH als auch per HTTP zugegriffen werden kann und das eine Weboberfläche anbietet, um innerhalb des Repositories via Browser navigieren zu können. In diesem Howto werde ich das Tool gitosis verwenden, das uns die Möglichkeit bietet, beliebig viele Git-Repositories innerhalb kürzester Zeit zu deployen. Zudem wird jede Nacht ein Snapshot des Repositories erstellt, das bspw. zu Archivierungs- und Distributionszwecken verwendet werden kann. Als Basissystem verwende ich Debian GNU/Linux 5.0 “Lenny”.

Lokales vs. zentrales Git-Repository

Bei Git handelt es sich zwar um ein verteiltes Code Management System, jedoch bietet es sich an, zusätzlich zu den bei den Entwicklern vorliegenden lokalen Instanzen des Repositories eine zentrale Instanz von Git aufzusetzen, die die o.g. Aufgaben erfüllt (unterschiedliche Transportprotokolle, Snapshots, Commit Mails etc.). Der typische Entwicklungszyklus von Software und die Art der Zusammenarbeit der Entwicklerteams geben einige Anforderungen an ein Versionskontrollsystem vor.

Jeder Entwickler besitzt eine Kopie des Git-Repositories, die er bspw. via git clone lokal erstellt hat. Auf dieser Datenbasis fährt er mit seiner Arbeit fort (Änderungen von bestehenden Dateien, Hinzufügen neuer Dateien etc.). Möchte er diese Änderungen nun in das zentrale Repository einpflegen, benutzt er das Kommando git commit.

Installation von Git

Zunächst installieren wir die Basis von Git:

# aptitude install git-core

Installation von gitosis

Durch die dezentrale Art und Weise, wie Git die einzelnen Repositories verwaltet, findet man vorwiegend Howtos, die diesen Aspekt aufgreifen. Da wir uns jedoch einer zentralen Lösung zum Hosting von Git-Repositories zuwenden wollen, möchte ich an dieser Stelle das speziell dafür geschaffene Tool gitosis erläutern. Das Tool ermöglicht u.a. die Verwendung von Git-Benutzern, die keinen Shell-Account auf dem Server benötigen. Alle Git-User, die keinen solchen Account haben, werden automatisch auf einen zentralen Useraccount gemappt, der keinerlei Systemrechte besitzt.

Zunächst installieren wir das Tool gitosis mittels:

# aptitude install gitosis

Neben gitosis selbst wird hierbei eine Vielzahl von Abhängigkeiten installiert, wie bspw. die gesamte Python-Umgebung. Zudem wird automatisch ein neuer Benutzer gitosis erstellt und ihm das ebenfalls bei der Installation erstellte Home-Verzeichnis /srv/gitosis zugewiesen. Dies ist auch das Verzeichnis, das später unsere Git-Repositories aufnehmen wird.

Konfiguration von gitosis

Gitosis verwendet von sich aus die schlüsselbasierte SSH-Authentifizierung, um Clients beim Server zu authentifizieren. Daher benötigt der Server, auf dem die Git-Repositories gehostet werden, zunächst die entsprechenden öffentlichen RSA-Schlüssel der einzelnen Workstations, die Zugriff auf das Repository erhalten sollen.

Wir erzeugen zunächst ein neues Verzeichnis /etc/gitosis/sshkeys, in das wir später die öffentlichen SSH-Schlüssel der einzelnen Clients einfügen werden und ordnen dieses Verzeichnis dem Benutzer und der Gruppe gitosis zu:

# mkdir -p /etc/gitosis/sshkeys

# chown -R gitosis:gitosis /etc/gitosis/sshkeys

Generierung des RSA-Schlüsselpaares (Client)

Nun benötigen wir auf dem Clientrechner ein RSA-Schlüsselpaar, das aus dem privaten und öffentlichen Teil des Schlüssels besteht. Dieses generieren wir für jeden Benutzer, der später den Zugriff auf das Git-Repository erhalten soll mittels:

$ ssh-keygen -t rsa

Das Kommando fragt uns nach dem Namen der Datei, unter dem es den Schlüssel speichern soll. Wir speichern diesen unter der Vorgabe ~/.ssh/id_rsa:

Generating public/private rsa key pair.
Enter file in which to save the key (/home/ctp/.ssh/id_rsa): <---- ENTER drücken

Nun fragt uns das obige Kommando nach einer Passphrase, mittels derer es den privaten Teil des Schlüssels selbst verschlüsseln würde. Da wir eine automatische Authentifizierung ohne Passwortabfrage benötigen, geben wir hier kein Passwort an:

Enter passphrase (empty for no passphrase): <---- ENTER drücken
Enter same passphrase again: <---- ENTER drücken               

Zuletzt erhalten wir eine Statusmeldung und einen Fingerprint des Schlüsselpaares und finden anschließend den öffentlichen Teil der Schlüssels in der Datei ~/.ssh/id_rsa.pub.

Kopieren des öffentlichen RSA-Schlüssels für Admin

Nun kopieren wir den öffentlichen Teil unseres RSA-Schlüssels (Client Rechner) auf den Server in das von uns erstellte Verzeichnis /etc/gitosis/sshkeys:

$ scp ~/.ssh/id_rsa.pub root@10.0.1.3:/etc/gitosis/sshkeys/ctp

Anmerkung: unser Server, der die Git-Repositories hosten wird, besitzt in unserem Fall die IP-Adresse 10.0.1.3. Diese muss an die eigene Netzwerkumgebung angepasst werden! Zudem verwenden wir für jeden öffentlichen RSA-Schlüssel eine eigene Schlüsseldatei im Verzeichnis /etc/gitosis/sshkeys, die wir nach dem Benutzernamen benennen (in unserem Fall also ctp).

Diesen Schritt führen wir für alle Hosts/Clients durch, die administrativen Zugriff auf die Git-Repositories erhalten sollen (und nur für diese!). Anschließend ordnen wir alle öffentlichen Schlüssel dem Benutzer und der Gruppe gitosis zu:

# chown -R gitosis:gitosis /etc/gitosis/sshkeys

Initialisierung des Git-Repositories

Nun initialisieren wir das administrative Git-Repository:

# su gitosis

$ gitosis-init < /etc/gitosis/sshkeys/ctp

Daraufhin erhalten wir die folgende Statusmeldung:

Initialized empty Git repository in /srv/gitosis/repositories/gitosis-admin.git/ 
Reinitialized existing Git repository in /srv/gitosis/repositories/gitosis-admin.git/

Non-standard Port für SSH

In meinem Fall verwende ich für den SSH-Server nicht den Standardport 22, sondern 22022. Da Gitosis automatisch Git via SSH tunnelt, müssen wir zunächst eine entsprechende Konfiguration unter ~/.ssh/config auf dem Clientrechner anlegen, die den non-standard SSH-Port berücksichtigt:

Host 10.0.1.3  
Port 22022

Initiales Auschecken des Repositories

Da wir das Git-Repository mittels unseres öffentlichen RSA-Schlüssels initialisiert haben, können wir nun den dessen Inhalt, der die gesamte Git-Konfiguration trägt, auf dem lokalen Rechner auschecken via:

$ git clone gitosis@10.0.1.3:gitosis-admin.git

Mit dem Auschecken erhalten wir sowohl eine lokale Kopie des RSA-Schlüsselverzeichnisses der Benutzer, die Zugriff auf das Git-Repository erhalten sollen, als auch eine Kopie der Git-Konfiguration gitosis-admin/gitosis.conf

Anlegen weiterer Repositories

Bis hierhin haben wir als Administrator Zugriff auf das administrative Repository gitosis-admin. Nun wollen wir ein weiteres Repository namens projektrepo erstellen, das wir als gewöhnliches Entwickler-Repository verwenden wollen. Dazu modifizieren wir die Datei gitosis-repo/gitosis.conf, die wir ausgecheckt haben (keine direkten Änderungen auf dem Server!) und fügen ihr die folgende Definition hinzu:

[group projektrepo]
writable = projektrepo
members = ctp@hilbert

Anschließend speichern wir die Änderungen der Konfigurationsdatei, indem wir diese in das administrative Git-Repository gitosis-admin committen:

$ git commit -a -m "Added new repository 'projektrepo'"

$ git push

Nun erstellen wir auf dem lokalen PC das neue Repository projektrepo:

$ mkdir projektrepo

$ cd projektrepo

$ git init

Nun fügen wir alle Dateien dem Verzeichnis projektrepo hinzu, die später unter die Versionskontrolle gestellt werden sollen und führen anschließend die folgenden Kommandos aus:

$ git add .

$ git remote add origin gitosis@10.0.1.3:projektrepo

$ git commit -a -m "Initial commit"

$ git push --all

Git Web-Interface cgit

Möchte man schnell via Webbrowser auf sein Git-Repository zugreifen, um bspw. den Status des Projekts einzusehen, benötigt man ein entsprechendes Web-Interface. Ein solches einfaches und performantes Interface bietet uns cgit.

Zunächst einmal benötigen wir einen Webserver. Da ich stets ein schlankes und performantes System anstrebe, entscheide ich mich an dieser Stelle, wie so oft, für Lighttpd als Webserver. Ein entsprechendes Howto zur Installation von Lighttpd unter Debian GNU/Linux 5.0 “Lenny” habe ich bereits in einem anderen Howto veröffentlicht. Daher setzen wir zuallererst diesem Howto folgend Lighttpd auf (Grundinstallation ohne CGI/FastCGI) und kehren anschließend hierhin zurück.

Da es sich bei cgit um eine CGI-Applikation handelt, aktivieren wir das CGI-Modul mittels:

# lighty-enable-mod cgi

Nun fügen wir eine entsprechende vhost-Definition an das Ende der Hauptkonfigurationsdatei des Webservers /etc/lighttpd/lighttpd.conf an:

$HTTP["host"] == "git.asconix.lan" {
  server.document-root = "/var/www/cgit"
  index-file.names	= ( "cgit.cgi" )
  cgi.assign = ( "cgit.cgi" => "" )
  url.rewrite-once = (
    "^/([^?/]+/[^?]*)?(?:\?(.*))?$" => "/cgit.cgi?url=$1&$2",
  )
}

Da wir in unserer obigen Konfiguration URL-Rewriting verwenden, müssen wir ebenfalls in der Konfigurationsdatei /etc/lighttpd/lighttpd.conf das entsprechende Modul mod_rewrite laden. Dies tun wir, indem wir der Sektion server.modules die folgende Definition hinzufügen:

server.modules = (
        ...
        "mod_rewrite"
)

Damit haben wir bereits den Webserver soweit konfiguriert, dass dieser das CGI-Skript cgit hosten kann.

Anschließend installieren wir einige Pakete und Bibliotheken, die wir später zum Kompilieren von cgit benötigen werden:

# aptitude install build-essential libssl-dev

Nun checken wir die Sourcen des Projekts via Git aus:

# cd /usr/local/src

# git clone git://hjemli.net/pub/git/cgit

Anschließend wechseln wir in das Verzeichnis /usr/local/src/cgit und initialisieren bzw. updaten darin das Git Submodul:

# cd /usr/local/src/cgit

# git submodule init

# git submodule update

Nun passen wir noch das Makefile /usr/local/src/cgit/Makefile an. Zunächst passen wir darin den Document-Root für die Webapplikation an (Zeile 3):

CGIT_SCRIPT_PATH = /var/www/cgit

Ebenfalls passen wir den Konfigurationspfad an (Zeile 5):

CGIT_CONFIG = /usr/local/etc/cgitrc

Anschließend kompilieren wir die Sourcen des Projekts mittels:

# make && make install

Nun müssen wir noch die Konfigurationsdatei /usr/local/etc/cgitrc anlegen. In unserem Fall sieht diese folgendermaßen aus:

virtual-root=/

css=/cgit.css
logo=/cgit.png

repo.url=projektrepo
repo.path=/srv/gitosis/repositories/projektrepo.git
repo.desc=My first project repository

Zuletzt müssen wir die Zugriffsrechte reglementieren. Da die Git-Repositories dem Benutzer bzw. der Gruppe gitosis gehören, der Webserver jedoch unter der UID/GID www-data läuft und dennoch auf die Repository-Verzeichnisse unterhalb von /srv/gitosis/repositories zugreifen soll, fügen wir den Benutzer www-data der Gruppe gitosis hinzu:

# usermod -a -G gitosis www-data

Die Wirkung des obigen Kommandos überprüfen wir mittels:

# id www-data

Als Ausgabe erhalten wir hierbei:

uid=33(www-data) gid=33(www-data) groups=33(www-data),104(gitosis)