Crear servidor propio de Git en CentOS 6.5

0. Índice de
contenidos.

• 1. Entorno
• 2. Introducción
• 3. Vamos al lío
• 4. Conclusiones

1. Entorno

Este tutorial está escrito usando el siguiente entorno:

• Hardware: Portátil Mac Book Pro 17″ (2,6 Ghz Intel Core i7, 8 GB DDR3)
• Sistema Operativo: Mac OS X Snow Leopard 10.6.4
• Maquina virtual con CentOS 6.5

2. Introducción

Git es un sistema de control de versiones distribuido del que ya hemos hablado en distintas ocasiones en el portal,
por lo que si no lo conoces te recomiendo las siguientes lecturas:

• Git y cómo trabajar con un
  repositorio de código distribuido
• 
  Primeros pasos con github: subir un proyecto al repositorio
• Trabajando con GIT,
  introducción al uso de los branch y git-completion.bash

Lo más habitual cuando se trabaja con Git es crearnos una cuenta en algún servicio como Github o BitBucket que nos
proporcionan un servidor de Git con el que podemos trabajar y subir nuestros proyectos personales o privados.

Pero a veces nos encontramos con clientes que por motivos de seguridad no quieren tener el código de sus proyectos en
la «nube» ni aún pagando un servicio privado.

Es por ese motivo que os voy a enseñar como se crea un servidor propio de Git con la desventaja de que el backup de
los datos y la gestión de los usuarios tendremos que hacerla nosotros.

3. Vamos al lío

Lo primero que necesitamos es una instancia de Linux, en nuestro caso lo vamos a hacer en CentOS aunque en otras
distribuciones como Ubuntu los pasos son muy similares.

Una vez tenemos acceso a la máquina Linux bien sea por SSH o en el propio terminal de la máquina, con un usuario con permisos,
tenemos que instalar una instancia de Git.

Para hacerlo en CentOS previamente tenemos que instalar una serie de dependencias para lo que ejecutamos:

  $> yum ­-y install zlib­-devel openssl-­devel cpio expat-­devel gettext-­devel gcc perl-­ExtUtils-­MakeMaker

Seguidamente instalamos el paquete de Git de este modo:

  $> yum install git

Para toda la gestión con Git vamos a crear un usuario específico al que vamos a llamar «git», en un alarde de
originalidad sin predecentes 😉

Para ello desde un terminal ejecutamos:

  $> sudo adduser git

Y le damos una password, por ejemplo «git», con el comando:

  $> sudo passwd git

Ahora nos logamos con el nuevo usuario «git»:

  $> su git

Nos solicita la password. Se la introducimos correctamente y nos posicionamos en su home:

  $> cd ~

Dentro del home del usuario «git» vamos a crear la carpeta de proyectos «projects» donde vamos a almacenar nuestros
proyectos:

  $> mkdir projects

Nos situamos en este directorio:

  $> cd projects

Ahora vamos a crear nuestro primer proyecto al que vamos a llamar «autentia-test.git». Para ello creamos el
directorio

  $> mkdir autentia-test.git

Y dentro de este directorio vamos a crear el proyecto de Git con el comando:

  $> git --bare init

Si todo es correcto nos encontraremos con este mensaje: «Initialized empty Git repository in /home/git/projects/autentia-test.git/»

Para probar el repositorio, desde la misma máquina o desde otra máquina cliente, podemos hacer un clone del proyecto con el comando:

  $> git clone git@ip_maquina_git:~/projects/autentia-test.git
  Cloning into 'autentia-test'...

En este punto solicita la password del usuario git de la máquina. Una vez introducida se descarga el proyecto en nuestra máquina cliente y
ya podemos trabajar como en cualquier otro repositorio de Git.

Es bastante molesto tener que introducir la password cada vez que hagamos push en el proyecto o queramos clonar otros proyectos. Para evitar esto
vamos a establecer un enlace de confianza con llave pública y privada a través de SSH entre la máquina del servidor Git y nuestra máquina cliente.

Para ello desde el servidor vamos a habilitar un directorio donde los clientes nos van a dejar su clave pública.

  $> mkdir /home/git/clients 

Ahora creamos el directorio .ssh dentro de la carpeta /home/git del servidor. Es muy importante que está carpeta solo tenga permisos 700 y
pertenezca exclusivamente al usuario git.

  $> mkdir /home/git/.ssh
  $> chmod 700 .ssh

Dentro de la carpeta .shh vamos a crear el fichero authorized_keys donde vamos a almacenar todas las claves públicas de los clientes que
se quieran conectar a nuestro repositorio de Git. Es muy importante que este fichero pertenezca al usuario git y que los permisos estén seteados a 600.

  $> cd .ssh
  $> touch authorized_keys
  $> chmod 600 authorized_keys

El cliente tiene que crear su par de clave pública y clave privada. Para ello simplemente tiene que ejecutar en un terminal:

  $> ssh-keygen -t rsa

Este comando por defecto creará dos ficheros en el directorio .ssh de la home del usuario de la máquina cliente; un fichero con la clave privada (id_rsa)
y otro fichero con la clave pública (id_rsa.pub). Es muy importante que nuestra clave privada no la compartamos con nadie en ninguna circunstancia.

El siguiente paso es trasmitir a la carpeta «clients» del servidor de Git la clave pública, de esta forma:

  $> scp /home/username/.ssh/id_rsa.pub git@ip_maquina_git:~/clients/username_rsa.pub

Es una buena práctica almacenar en la carpeta «clients» el fichero con el nombre del usuario para que no se sobrescriba con alguno existente. Ahora,
dentro del servidor de Git, pasamos el contenido del fichero al archivo «authorized_keys».

  $> cat /home/git/clients/username_rsa.pub >> .ssh/authorized_keys

Desde este momento cuando nuestro cliente vaya a interacturar con el servidor de Git ya no le pedirá la password.

4. Conclusiones

Como véis no es muy complicado tener nuestro propio repositorio de Git, por lo que no tenemos que depender de servicios como GitHub o BitBucket y nuestros
clientes más «recelosos» ya no tienen excusa para no usar Git.

Cualquier duda o sugerencia en la zona de comentarios.

Saludos.