Instalar servidor de repositorios GIT con gitolite y cgit en Ubuntu Server 12.04

Logo Git


Muchos trabajamos a diario con miles de archivos, sean de configuración o de software. Pero todos en mayor o menor medida requerimos una herramienta que nos permita llevar un control de los cambios que realizamos o del avance que llevamos de nuestros proyectos.

Existen muchas alternativas para llevar a cabo dicha tarea entre las que se encuentran: CVS, SVN y GIT. No voy a entrar en detalles de cada uno, porque no es la temática del post, pero para mi tipo de trabajo encaja perfectamente GIT.

Que es GIT?

Como reza en la página web del proyecto:

Git es un sistema de control de versiones distribuido libre y de código abierto, diseñado para manejar todo, desde pequeños a grandes proyectos con rapidez y eficiencia.

El problema radica en que GIT, como tal no es todo lo sencillo de configurar y poner en producción que uno querría. Para solventar dicho handicap, el señor Sitaram Chamarty puso manos a la obra y se sacó de la manga el proyecto gitolite.

Dicho lo dicho, MANOS A LA OBRA!

Instalando Gitolite

Partamos de la base que tenemos instalado y funcionando Ubuntu Server 12.04.
Instalamos algunos paquetes requeridos
GIT:

root@serverdesarrollo:~# apt-get install git
Leyendo lista de paquetes... Hecho
Creando árbol de dependencias
Leyendo la información de estado... Hecho
Paquetes sugeridos:
  git-daemon-run git-daemon-sysvinit git-doc git-el git-arch git-cvs git-svn
  git-email git-gui gitk gitweb
Se instalarán los siguientes paquetes NUEVOS:
  git
0 actualizados, 1 se instalarán, 0 para eliminar y 0 no actualizados.
Se necesita descargar 0 B/5.963 kB de archivos.
Se utilizarán 14,0 MB de espacio de disco adicional después de esta operación.
Selecting previously unselected package git.
(Leyendo la base de datos ... 55564 ficheros o directorios instalados actualmente.)
Desempaquetando git (de .../git_1%3a1.7.9.5-1_i386.deb) ...
Configurando git (1:1.7.9.5-1) ...

Creamos un usuario que almacenará nuestros repositorios
Muchos usan el usuario gitolite, yo uso el usuario gitserver, usted es libre de elegir que nombre de usuario desea utilizar.

root@serverdesarrollo:~# sudo adduser \
--system \
--shell /bin/bash \
--gecos 'Sistema de Control de Versiones Git' \
--group \
--disabled-password \
--home /home/gitserver \
gitserver
Adding system user `gitserver' (UID 111) ...
Adding new group `gitserver' (GID 119) ...
Adding new user `gitserver' (UID 111) with group `gitserver' ...
Creating home directory `/home/gitserver' ...

Para evitar problemas de permisos luego con cgit y apache, agregamos el usuario www-data al grupo gitserver

root@serverdesarrollo:~# adduser www-data gitserver
Adding user `www-data' to group `gitserver' ...
Adding user www-data to group gitserver
Done.

Exportar nuestra clave privada al servidor GIT
Para poder realizar la administración remota de nuestro servidor GIT (agregar repositorios, administrar permisos y usuarios, etc) requerimos subir nuestra clave SSH publica a nuestro servidor.

Si ya tenemos una clave generada, nos podemos saltar el siguiente paso e ir directamente al paso donde subimos la clave al servidor.

Para generar nuestra clave publica ejecutamos en nuestra maquina:

john@rigardo:~ $ ssh-keygen -t rsa -f ~/.ssh/john
Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in john.
Your public key has been saved in john.pub.
The key fingerprint is:
33:d5:89:be:e6:a4:14:b0:d4:f2:68:03:95:33:a1:3f john@rigardo
The key's randomart image is:
+--[ RSA 2048]----+
|      oo         |
|     o+.   o .   |
|    o +o. o o    |
|     + * o       |
|      E S .      |
|     . o + .     |
|        . +      |
|       . =       |
|        . .      |
+-----------------+

Como podemos observar, hemos creado nuestro par de claves, una publica y otra privada:

john@rigardo:~ $ ls -l ~/.ssh/john*
-rw------- 1 john john 1675 feb 18 17:23 /home/john/.ssh/john
-rw-r--r-- 1 john john  403 feb 18 17:23 /home/john/.ssh/john.pub

Ahora subimos nuestra clave pública a nuestro servidor GIT

john@rigardo:~/.ssh $ rsync -varuz john.pub soporte@192.168.56.100:/tmp/
sopote@192.168.56.100's password:
sending incremental file list
john.pub

sent 414 bytes  received 31 bytes  32.96 bytes/sec
total size is 394  speedup is 0.89

Ahora, vamos de nuevo a la consola de nuestro servidor GIT.
Primero cambiamos el propietario de la clave publica que acabamos de importar

root@serverdesarrollo:~# sudo chown gitserver:gitserver /tmp/john.pub

Luego, nos cambiamos al usuarios que creamos (en mi caso gitserver)

root@serverdesarrollo:~# sudo su - gitserver
gitserver@serverdesarrollo:/home/john$

Clonamos el repositorio donde se encuentra alojado el proyecto gitolite

gitserver@serverdesarrollo:~$ git clone git://github.com/sitaramc/gitolite
Cloning into 'gitolite'...
remote: Counting objects: 8010, done.
remote: Compressing objects: 100% (2630/2630), done.
remote: Total 8010 (delta 5503), reused 7684 (delta 5218)
Receiving objects: 100% (8010/8010), 1.83 MiB | 364 KiB/s, done.
Resolving deltas: 100% (5503/5503), done.

Creamos la carpeta bin donde instalaremos los archivos binarios que usaremos para administrar y configurar gitolite

gitserver@serverdesarrollo:~$ mkdir bin

Ahora instalamos gitolite en la carpeta que creamos

gitolite/install -to /home/gitserver/bin

Instalamos gitolite indicándole la clave publica que subimos previamente

gitserver@serverdesarrollo:~$ bin/gitolite setup -pk /tmp/john.pub
Initialized empty Git repository in /home/gitserver/repositories/gitolite-admin.git/
Initialized empty Git repository in /home/gitserver/repositories/testing.git/
WARNING: /home/gitserver/.ssh missing; creating a new one
WARNING: /home/gitserver/.ssh/authorized_keys missing; creating a new one
gitserver@serverdesarrollo:~$

Editamos el archivo de configuracion /home/gitserver/.gitolite.rc y modificamos la linea que contiene UMASK así:

    UMASK                           =>  0027,

voila!! ya tenemos nuestro servidor GIT funcional, pero ahora debemos crear nuestros repositorios y opcionalmente agregar usuarios y grupos. Para ello cerramos sesión en nuestro servidor.

gitserver@serverdesarrollo:~$ logout
root@serverdesarrollo:~# exit
john@serverdesarrollo:~$ logout
Connection to 192.168.56.100 closed.
john@rigardo:~ $

Lo interesante del proyecto gitolite es su forma de administrar: usamos GIT, para administrar un servidor GIT.
Primero clonamos el repo de administración de gitolite

john@rigardo:~/git/devserver $ git clone gitserver@192.168.56.100:gitolite-admin
Cloning into 'gitolite-admin'...
remote: Counting objects: 6, done.
remote: Compressing objects: 100% (4/4), done.
remote: Total 6 (delta 0), reused 0 (delta 0)
Receiving objects: 100% (6/6), done.

Si echamos un vistazo, nos daremos cuenta que este repositorio tiene básicamente 2 carpetas: keydir y conf

john@rigardo:~/git/devserver $ cd gitolite-admin/
john@rigardo:~/git/devserver/gitolite-admin [master] $ ls
conf  keydir
  • El directorio llamado keydir es donde copiaremos las claves públicas de nuestros colaboradores o de quienes tendrán acceso al repositorio, sea de escritura y/o lectura.
  • Mientras, el directorio llamado conf es usado para definir los repositorios y sus respectivos permisos de acceso.

Para este caso, usaré la clave pública de mi colaboradora Isabel y crearemos nuestro primer repositorio llamado proyecto
primero colocaremos la clave pública de Isabel en el directorio keydir

john@rigardo:~/git/devserver/gitolite-admin [master] $ cp ~/isabel.pub keydir/
john@rigardo:~/git/devserver/gitolite-admin [master] $

Ahora, creamos el repositorio llamado proyecto y le asignaremos al usuario john como propietario y a la usuaria isabel con permisos de lectura

john@rigardo:~/git/devserver/gitolite-admin [master] $ vim conf/gitolite.conf

 

@repo-admin    = john
@repo-readonly  = isabel

repo gitolite-admin
    RW+     =   john

repo proyecto
        RW+     =       @repo-admin
        R       =       @repo-readonly

Que hicimos?

  • Creamos el grupo @repo-admin y en el matriculamos el usuario john
  • Creamos el grupo @repo-readonly y en el matriculamos el usuario isabel
  • Creamos un nuevo repositorio llamado proyecto y le asignamos los siguientes permisos:
    • Los usuarios del grupo @repo-admin tienen permisos de lectura y escritura
    • Los usuarios del grupo @repo-readonly tienen permisos de solo lectura

Ahora guardaremos y aplicaremos todos los cambios:

Primero guardamos nuestros cambios en las claves publicas de manera local

john@rigardo:~/git/devserver/gitolite-admin [master] $ git add keydir/isabel.pub
john@rigardo:~/git/devserver/gitolite-admin [master] $ git commit -m "usuario isabel agregado al servidor GIT"
[master 4ddd323] usuario isabel agregado al servidor GIT
 1 file changed, 1 insertion(+)
 create mode 100644 keydir/isabel.pub

Y luego los enviamos al servidor GIT

john@rigardo:~/git/devserver/gitolite-admin [master] $ git push
Counting objects: 6, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (4/4), 714 bytes, done.
Total 4 (delta 0), reused 0 (delta 0)
To gitserver@192.168.56.100:gitolite-admin
   2cf8cf1..4ddd323  master -> master

Ahora le toca el turno al repositorio que recién creamos

john@rigardo:~/git/devserver/gitolite-admin [master] $ git add conf/gitolite.conf
john@rigardo:~/git/devserver/gitolite-admin [master] $ git commit -m 'creado el repositorio "Proyecto" y aplicados los permisos de acceso'
[master 60a6ce2] creado el repositorio "Proyecto" y aplicados los permisos de acceso
 1 file changed, 7 insertions(+), 2 deletions(-)

Y de nuevo, sincronizamos los cambios con el servidor GIT

john@rigardo:~/git/devserver/gitolite-admin [master] $ git push
Counting objects: 7, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (4/4), 459 bytes, done.
Total 4 (delta 0), reused 0 (delta 0)
remote: Initialized empty Git repository in /home/gitserver/repositories/proyecto.git/
To gitserver@192.168.56.100:gitolite-admin
   4ddd323..60a6ce2  master -> master

Hasta aquí tenemos nuestro servidor GIT funcional, ¿pero como hacemos para visualizar mas fácilmente los cambios realizados? allí es donde entra cgit

¿Que es cgit?

Cgit es una interfaz web, programada en C que facilita la visualización de nuestros repositorios GIT.

Instalando CGIT

La instalación se realizara enteramente en nuestro servidor GIT.
Instalamos algunos paquetes requeridos

root@serverdesarrollo:~# apt-get install build-essential libssl-dev
Leyendo lista de paquetes... Hecho
Creando árbol de dependencias
Leyendo la información de estado... Hecho
Se instalarán los siguientes paquetes extras:
  binutils cpp cpp-4.6 dpkg-dev fakeroot g++ g++-4.6 gcc gcc-4.6 libalgorithm-diff-perl libalgorithm-diff-xs-perl libalgorithm-merge-perl
  libc-dev-bin libc6-dev libdpkg-perl libgomp1 libmpc2 libmpfr4 libquadmath0 libstdc++6-4.6-dev linux-libc-dev make manpages-dev libssl-doc
  libssl1.0.0 zlib1g-dev
Paquetes sugeridos:
  binutils-doc cpp-doc gcc-4.6-locales debian-keyring g++-multilib g++-4.6-multilib gcc-4.6-doc libstdc++6-4.6-dbg gcc-multilib autoconf
  automake1.9 libtool flex bison gdb gcc-doc gcc-4.6-multilib libmudflap0-4.6-dev libgcc1-dbg libgomp1-dbg libquadmath0-dbg
  libmudflap0-dbg binutils-gold glibc-doc libstdc++6-4.6-doc make-doc
Se instalarán los siguientes paquetes NUEVOS:
  binutils build-essential cpp cpp-4.6 dpkg-dev fakeroot g++ g++-4.6 gcc gcc-4.6 libalgorithm-diff-perl libalgorithm-diff-xs-perl
  libalgorithm-merge-perl libc-dev-bin libc6-dev libdpkg-perl libgomp1 libmpc2 libmpfr4 libquadmath0 libstdc++6-4.6-dev linux-libc-dev
  make manpages-dev libssl-dev libssl-doc zlib1g-dev
0 actualizados, 27 se instalarán, 0 para eliminar y 0 no actualizados.
Necesito descargar 35,2 MB de archivos.
Se utilizarán 94,6 MB de espacio de disco adicional después de esta operación.
¿Desea continuar [S/n]?
...
...

Descargamos el código fuente de la aplicación

root@serverdesarrollo:~/instaladores/cgit# wget -cd http://hjemli.net/git/cgit/snapshot/cgit-0.9.1.tar.gz
Connecting to hjemli.net (hjemli.net)|178.79.139.143|:80... connected.
Created socket 3.
Releasing 0x09ff98d8 (new refcount 1).
...
...
...
2013-03-14 23:30:39 (184 KB/s) - `cgit-0.9.1.tar.gz' saved [80445]

Descomprimimos

root@serverdesarrollo:~/instaladores/cgit# tar zxvf cgit-0.9.1.tar.gz
root@serverdesarrollo:~/instaladores/cgit# cd cgit-0.9.1/

Cgit requiere de los binarios de GIT para poderse compilar, para ello llevamos a cabo lo siguiente:

root@serverdesarrollo:~/instaladores/cgit/cgit-0.9.1# make get-git
...
...
100 3163k  100 3163k    0     0   283k      0  0:00:11  0:00:11 --:--:--  407k

La ubicación por defecto donde se instala cgit es “/var/www/htdocs/cgit”, vamos a modificar esto e instalarlo en “/var/www/gitrepos”, para ello creamos el archivo cgit.conf con lo siguiente

CGIT_SCRIPT_PATH = /var/www/gitrepos

Compilamos cgit

root@serverdesarrollo:~/instaladores/cgit/cgit-0.9.1# make
...
...
CC cgit
root@serverdesarrollo:~/instaladores/cgit/cgit-0.9.1#

Y lo instalamos

root@serverdesarrollo:~/instaladores/cgit/cgit-0.9.1# sudo make install
    SUBDIR git
    SUBDIR git
    CC cgit
install -m 0755 -d /var/www/gitrepos
install -m 0755 cgit /var/www/gitrepos/cgit.cgi
install -m 0755 -d /var/www/gitrepos
install -m 0644 cgit.css /var/www/gitrepos/cgit.css
install -m 0644 cgit.png /var/www/gitrepos/cgit.png
install -m 0755 -d /usr/lib/cgit/filters
install -m 0755 filters/* /usr/lib/cgit/filters

Cambiamos el propietario del directorio /var/www/gitrepos por www-data

root@serverdesarrollo:/etc/apache2# chown www-data:www-data /var/www/gitrepos -R

Con esto hemos instalado cgit.

Editamos el archivo /etc/apache2/sites-available/default y antes de cerrar el VirtualHost agregamos lo siguiente


        ServerAdmin webmaster@localhost

        DocumentRoot /var/www
...

        Options +ExecCGI
        DirectoryIndex cgit.cgi
        AddHandler cgi-script .cgi
        AllowOverride None
        Order allow,deny
        Allow from all

...

Finalmente editamos el archivo /etc/cgitrc así:

virtual-root=/gitrepos/cgit.cgi/
enable-index-links=1
enable-log-filecount=1
enable-log-linecount=1
snapshots=tar.gz tar.bz zip
root-title=Sistema de Control de Versiones
root-desc=Interfáz web de visualización
css=/gitrepos/cgit.css
logo=/gitrepos/cgit.png

# Listado de repositoros
repo.url=proyecto
repo.path=/home/gitserver/repositories/proyecto.git
repo.desc=Mi primer repositorio en GIT
repo.owner=John Edisson Ortiz

Reiniciamos Apache

root@serverdesarrollo:~# service apache2 restart
 * Restarting web server apache2: Could not reliably determine the server's fully qualified domain name, using 127.0.1.1 for ServerName
 ... waiting apache2: Could not reliably determine the server's fully qualified domain name, using 127.0.1.1 for ServerName      [ OK ]
root@serverdesarrollo:~#

Finalmente accedemos a cgit usando la url http://192.168.56.100/gitrepos/

CGIT funcionando
CGIT en accion
(La ip puede variar dependiendo de la ip de tu servidor)

Cgit tiene múltiples opciones de configuración, es bueno que exploren las enormes posibilidades que nos brinda este excelente software.

Un comentario en “Instalar servidor de repositorios GIT con gitolite y cgit en Ubuntu Server 12.04

  1. Hola!

    Gracias por el tutorial! pero no consigo entender como ves la interfaz esa de cgit, a mi me sale bastante básica y no veo los repositorios. Pero desde terminal me funciona todo perfectamente.

    Responder

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s