Administrando repositorios con gitosis

Como prometí cuando escribí el post Instalando gitosis en Leopard, aquí tenéis una guía básica sobre como administrar repositorios usando gitosis una vez completamos la instalación como se describe en ese post. Esta información se basa en la publicada en el sitio de scie.nti.st que también se referencia en el post anterior.

Yo he creado una carpeta en mi home llamada projects en la que tengo todos los proyectos y el repositorio gitosis-admin necesario para administrar el resto de repositorios, pero podéis hacerlo como queráis.

macbook$ mkdir projects
macbook$ cd projects
macbook$ git clone git@miservidor:gitosis-admin.git

Creación de repositorios

Para crear repositorios, abrimos el fichero gitosis.conf que hay en el repositorio gitosis-admin que acabamos de clonar y veremos que por defecto contiene algo parecido a lo siguiente:

[gitosis]

[group gitosis-admin]
writable = gitosis-admin
members = javier@macbook.local

Básicamente este fichero define un grupo llamado gitosis-admin formado por javier@macbook.local que tiene permiso de escritura sobre el repositorio gitosis-admin. javier@macbook.local es el nombre que gitosis ha dado al fichero de clave pública que le pasamos durante la instalación sin la extensión *.pub que podrás encontrar en la carpeta keydir.

Para crear un nuevo repositorio vamos a crear también un grupo nuevo, para mantener un grupo sólo para administración que en principio sólo me incluye a mí añadiendo las siguientes líneas:

[group a-team]
writable = bomb
members = javier@macbook.local

Para hacer efectivo el cambio, simplemente guardamos el fichero y enviamos los cambios al servidor:

macbook$ git commit -a -m "Creando el equipo A para hacer una bomba"
macbook$ git push

Desde este instante ya tenemos permiso para crear y subir nuestro nuevo repositorio ejecutando los siguientes comandos:

macbook$ mkdir bomb
macbook$ cd bomb
macbook$ git init
macbook$ git remote add origin git@miservidor:bomb.git

# Crear algunos ficheros y hacer cuantos adds y commits se desee

macbook$ git push origin master:refs/heads/master

A partir de este momento el repositorio se crea en el servidor y se puede sincronizar con el repositorio mediante pull y push.

Gestión de usuarios

Como la autentificación se realiza mediante pares de claves RSA públicas y privadas, para añadir otros usuarios basta con copiar sus claves públicas al directorio keydir del repositorio gitosis-admin. Después podremos darles permisos sobre los repositorios modificando el fichero gitosis.conf
Para crear los pares de claves, usamos, como en el momento de la instalación el comando ssh-keygen y copiamos la clave pública al servidor:

murdock$ ssh-keygen -t rsa
murdock$ scp ./ssh/id_rsa.pub javier@macbook:/tmp/murdock.pub #Lo copio a mi portátil para subirlo mediante git

Ahora simplemente movemos la clave a keydir dentro del repositorio gitosis-admin:

macbook$ mv /tmp/murdock.pub ~/projects/gitosis-admin/keydir/

Y editamos nuestro fichero de configuración para dar permiso de escritura a Murdock sobre el repositorio bomb:

[gitosis]

[group gitosis-admin]
writable = gitosis-admin
members = javier@macbook.local

[group a-team]
writable = bomb
members = javier@macbook.local murdock

Subimos los cambios y Murdock podrá acceder fácilmente a los repositorios

macbook$ git add .
macbook$ git commit -a -m "Dando acceso a Murdock al proyecto de Bomba"
macbook$ git push

Y con esto ya sabemos lo básico para gestionar nuestros repositorios con acceso remoto sin pagar a nadie que nos los gestione, ahora a trabajar!

Instalando gitosis en Leopard

Tras investigar sobre sitios de hosting de repositorios he llegado a la conclusión de que lo mejor será que me aloje los repositorios yo mismo porque es gratis y así no tengo limitaciones. La cuestión entonces es cómo configurar mi iMac para que me facilite la administración de los repositorios Git con Leopard.

Para ello, existe una herramienta un tanto peculiar llamada gitosis que permite alojar los repositorios bajo una cuenta especial de usuario, controlando el acceso con claves SSH y gestionándolos únicamente mediante git (Y ahí la peculiaridad del asunto)

El procedimiento de instalación se ha extraído del blog en inglés de la compañía Argument from design por dos razones. La primera, porque así habrá a partir de ahora una guía en español y segundo, porque así no tendré que recordar la URL si tengo que volver a hacer esto.

Lo cierto es que es una solución poco amigable, al más puro estilo hacker, pero para eso somos programadores! Así que a abrir el terminal!

1. Instalar gitosis en el servidor

Lo primero será descargar el código de gitosis y ejecutar el script de instalación en la máquina que usaremos como servidor

server$ git clone git://eagain.net/gitosis.git
server$ cd gitosis
server$ sudo python setup.py install

2. Crear un usuario y grupo para gitosis

Ahora creamos un usuario y un grupo para git al estilo hacker. Para ello primero buscamos un GID y un UID que no se estén usando aún en el sistema listando los que se están usando con los siguientes comandos:

server$ sudo dscl . list users uid
server$ sudo dscl . list groups gid

Con un UID y GID seleccionados (Yo elegí 401 para ambos, pero no pasa nada si son distintos o elegís otros) procedemos primero a crear el grupo git:

server$ sudo dscl . create groups/git
server$ sudo dscl . create groups/git gid 401

Y creamos el usuario git con su directorio home:

server$ sudo dscl . create users/git
server$ sudo dscl . create users/git uid 401
server$ sudo dscl . create users/git NFSHomeDirectory /Users/git
server$ sudo dscl . create users/git gid 401
server$ sudo dscl . create users/git UserShell /bin/bash
server$ sudo dscl . create users/git Password '*'
server$ sudo mkdir /Users/git
server$ sudo chown git /Users/git
server$ sudo chgrp git /Users/git

3. Creamos una clave SSH para el cliente

Creamos un par de claves pública y privada para identificar nuestro cliente ejecutando el siguiente comando:

client$ ssh-keygen -t rsa

Hecho esto, en el directorio ~/.ssh/ se habrán generado los ficheros id_rsa e id_rsa.pub y sólo quedará copiar la clave pública al servidor para que pueda identificarnos. Esto se puede hacer de cualquier forma que se desee, yo propongo como siempre la forma menos amigable posible:

client$ scp ~/.ssh/id_rsa.pub tuservidor.com:/tmp/my_key.pub

4. Configurando gitosis en el directorio home del usuario git

Ya tenemos todos los ingredientes que necesitamos y simplemente queda configurar gitosis para trabajar desde la carpeta home del usuario git. Lo inicializamos con la clave pública de nuestro ordenador cliente para poder administrarlo desde allí:

sudo -H -u git gitosis-init < /tmp/my_key.pub

Y configuramos la variable de entorno PATH del usuario con las rutas que contienen tanto a git como a gitosis:

client$ sudo -u git echo "export PATH=$PATH" > ~/.bashrc
client$ sudo -u git echo 'export PATH=$(git --exec-path):$PATH' >> ~/.bashrc

5. Clonar el repositorio de gitosis a la máquina cliente

Desde la máquina cliente, se debe clonar el repositorio de administración de gitosis, que será la forma en la que administraremos nuestros repositorios

git clone git@tuservidor.com:gitosis-admin.git

Hecho esto, gitosis ya está funcionando en el sistema y podemos empezar a administrarlo modificando el fichero gitosis.conf que se encuentra en este repositorio. En los próximos días colgaré un post sobre como configurar nuevos repositorios y administrarlos, pero por ahora podéis ir adelantando con el post de scie.nti.st que extiende esta guía a otros sistemas UNIX

MySQL y Rails en Leopard

Como estoy de vacaciones, me ha dado por investigar la plataforma Ruby on Rails, así que lo primero que se me ha ocurrido ha sido actualizar rails a su última versión, que en este momento está por la versión 2.3.2. Para hacer esto simplemente hay que ir a un terminal y escribir:

$ sudo gem update --system
$ sudo gem install rails
$ sudo gem update rake

Tras un rato de espera podemos comprobar si la actualización ha tenido éxito ejecutando

$ rails -v
Rails 2.3.2

Hasta ahí bien, hasta que creamos una aplicación e intentamos configurarla para trabajar con MySQL. En esta versión, Rails ya no integra por defecto el driver de conexión con MySQL, habiéndolo sustituido por una base de datos SQLite. Por tanto debe instalarse mediante gem.
Sin embargo, cuando se intenta instalar, ocurre lo siguiente:

$ sudo gem install mysql
Building native extensions. This could take a while...
ERROR: Error installing mysql:
ERROR: Failed to build gem native extension.

...Bla, bla, bla..

El error, tras investigarlo un poco se produce porque Leopard intenta compilar el driver como código universal y MySQL no se distribuye para Leopard de esta manera, sino como un binario para i386 o x64. Por tanto debe compilarse este módulo para la arquitectura que tengamos, que debe coincidir con la del binario de MySQL. Como encima yo tenía MySQL versión de 64 bits he tenido que destruirlo (Como no existe script de desinstalación ni similar, ha sido toda una destrucción en toda regla) para reemplazarlo por la versión de 64 bits. Esto se hace con los siguientes comandos (Cuidado con pulsar intro antes de tiempo con los “sudo rm -rf…”, mejor copiar y pegar directamente los comandos desde aquí):

sudo rm /usr/local/mysql
sudo rm -rf /usr/local/mysql*
sudo rm -rf /Library/StartupItems/MySQLCOM
sudo rm -rf /Library/PreferencePanes/My*
sudo rm -rf /Library/Receipts/mysql*
sudo rm -rf /Library/Receipts/MySQL*
vi /etc/hostconfig # borrar la línea MYSQLCOM=-YES-

Hecho esto ya nos podemos descargar la versión de 32 bits de MySQL e instalarla y compilar por fin nuestro driver de ruby correctamente especificando la arquitectura de la siguiente manera:

sudo env ARCHFLAGS="-arch i386" gem install mysql -- \
--with-mysql-dir=/usr/local/mysql --with-mysql-lib=/usr/local/mysql/lib \
--with-mysql-include=/usr/local/mysql/include

Si todo ha ido bien ya estará todo instalado, id a vuestros database.yml y a programar!

Diseño de juegos de empresa

Interfaz del diseñador de juegos de empresa

Interfaz del diseñador de juegos de empresa

Hoy he presentado mi proyecto de fin de carrera, lo que significa que me he convertido en un nuevo Ingeniero en Informática y que el proyecto generador de juegos de empresa ha superado su primera iteración!

Los juegos de empresa son herramientas de simulación de escenarios económicos o empresariales que se utilizan con frecuencia en las aulas de carreras relacionadas con la administración de empresas. Hasta ahora, estos juegos eran implementados por programadores expertos, por lo que eran sistemas caros de mantener y sobre todo difíciles de modificar.

El proyecto EnGaGe (Enterprise Game Generator) propone un entorno web de desarrollo especializado en juegos de empresa que permite a personas sin conocimientos de programación crearlos y modificarlos por si mismos. Esto posibilita que los propios organizadores de una experiencia práctica puedan crear un juego adaptado a sus posibilidades y que cubra los objetivos de esta experiencia, evitando la necesidad de adaptarse a un software existente o contratar programadores para su creación.

En los próximos meses se tomará una decisión con respecto a la continuidad del proyecto, valorando las posibilidades de su distribución, ya sea como un servicio web o como código libre.

Si estás interesado de alguna manera en este proyecto, no dudes en contactar conmigo.

Get real!!

Acabo de terminar el libro Getting Real! de 37Signals y me siento en la obligación de hablar de él por dos razones:

  1. Es un libro muy directo y muy abierto, donde los autores expresan sin tapujos los pasos que han dado para encontrar el éxito que han obtenido.
  2. Me ha hecho reflexionar sobre muchas cosas que daba por ciertas y que ahora no creo que sean tan ciertas.

La máxima de esta empresa es la simplicidad. No buscar competir dando más cosas innecesarias, sino menos cosas más útiles. Buscan la especialización y la cercanía con el cliente y sobre todo exprimir hasta la última gota los recursos de los que disponen. Hacen de la carencia de recursos una virtud.

Geting Real expresa un proceso de desarrollo que se basa en pura lógica y que ataca a mi parecer de forma directa a los problemas de los que adolecen otros procesos más complejos. Tras ver la resurrección de Star Trek el otro día pensé que este libro sería la respuesta que daría Mr. Spock a los problemas actuales de la ingeniería del software.

¿Tengo problemas para encontrar financiación? Ok, reduce el ámbito del problema hasta el límite que puedas autofinanciar. Y encima no tendrás que dar cuentas a nadie del rendimiento de tu equipo de desarrollo.

¿Problemas con toneladas de documentación que luego nadie lee? No generes documentación, mantén el equipo lo suficientemente pequeño como para no necesitar documentación. Haz interfaces simples que no requieran manuales.

¿Problemas con los requisitos? No escribas especificaciones que hay que cambiar y mantener, usa tus interfaces como prototipo y especificación. Cuando los requisitos cambien, cambia directamente tu aplicación sin duplicar trabajo.

¿Problemas con las peticiones de tus clientes? No les hagas caso hasta que sea evidente que lo que piden es imprescindible. Tampoco lo apuntes, lo imprescindible te lo recordarán lo suficiente como para que no lo olvides.

En general, un libro del que se desprende mucha inteligencia y experiencia en pequeñas dosis que ningún desarrollador debería obviar, como no podía ser menos viniendo de los mismísimos creadores de Ruby on Rails. Y encima es gratis!!

Link: Getting Real!

Glassfish en Ubuntu

Glassfish está incluido como paquete en los repositorios de Ubuntu 8.10, lo que facilita mucho las cosas a la hora de instalarlo, pero parece que alguien pensó que no era una buena idea incluir un script en /etc/init.d/ para que el servidor de aplicaciones se lance durante el arranque.
Esto puede servir para desarrolladores, pero aquellos que necesiten montar un servidor para desplegar sus aplicaciones tendrán que trabajar un poco más. En este post describo el procedimiento que seguí para aquellos que estén en esta situación, si alguien sabe como mejorar el procedimiento será un placer actualizarlo.

1. Instalación de los paquetes necesarios.

Esta es la parte sencilla, ya que APT hace todo por nosotros.

#apt-get install glassfishv2

Cuando finaliza el script tendremos instalado glassfish en /usr/share/glassfishv2 y nuestros dominios en /var/lib/glassfishv2/domains

2. Creando el usuario glassfish

Por motivos de seguridad, no parece buena idea lanzar nuestro servidor con permisos de superusuario en el inicio, por lo que antes de configurar el script de arranque creamos un usuario sin privilegios destinado al efecto.

#sudo adduser glassfish --ingroup admin

El nuevo usuario pertenece al grupo admin, por lo que asignamos a ese grupo la propiedad del directorio de glassfish

#sudo chgrp -R admin /usr/share/glassfishv2

Y asignamos la propiedad de la raíz de los dominios al usuario glassfish

#sudo chgrp -R admin  /var/lib/glassfishv2/domains/
#sudo chown -R glassfish /var/lib/glassfishv2/domains/

3. Creando un script para /etc/init.d

Una vez todo está preparado podemos proceder a escribir un script de control para glassfish, que en mi caso he llamado /etc/init.d/glassfish y es el siguiente:

#! /bin/sh

GLASSFISHPATH=/usr/share/glassfishv2/bin
GLASSFISHDOMAINHOME=/var/lib/glassfishv2/domains/domain1

 

case "$1" in
start)
echo "starting glassfish from $GLASSFISHPATH"
sudo -u glassfish $GLASSFISHPATH/asadmin start-domain --user admin --passwordfile ${GLASSFISHDOMAINHOME}/config/passwordfile domain1
;;
restart)
$0 stop
$0 start
;;
stop)
echo "stopping glassfish from $GLASSFISHPATH"
sudo -u glassfish $GLASSFISHPATH/asadmin stop-domain domain1
;;
*)
echo $"usage: $0 {start|stop|restart}"
exit 3
;;
esac

No olvidemos dar permisos de ejecución al script:

#sudo chmod a+x /etc/init.d/glassfish

Por defecto glassfish solicita un nombre de usuario y password durante el arranque que en el momento de la instalación es:

user: admin
password: adminadmin

Para que esta información se le pase al script automáticamente tendremos que crear si no existe el fichero  /var/lib/glassfishv2/domains/domain1/config/passwordfile  donde escribiremos la siguiente línea:

AS_ADMIN_PASSWORD=adminadmin

4. Retoques finales

Teniendo ya el script preparado sólo falta enlazarlo para que se llame durante el encendido y apagado del equipo, lo cual hacemos mediante el siguiente comando:

#sudo update-rc.d glassfish defaults 90 10

Con lo cual todo está listo para empezar a desplegar aplicaciones a falta de conectar con bases de datos y demás, pero eso ya es algo mejor documentado de lo que por ahora no voy a hablar.

Puedes probar que todo funciona correctamente ejecutando las siguientes órdenes y conectando a http://localhost:8080 para visualizar la página de bienvenida a glassfish.

#sudo service glassfish start
#sudo service glassfish restart
#sudo service glassfish stop

Referencias

Para realizar esta configuración tomé prestadas algunas ideas de un artículo del blog de Jasper Kalkers en inglés, os recomiendo una ojeada si no usais APT o para adaptar este método a otros sistemas operativos.

Hello world

¡Hola a todos! Este es el primer post de mi nuevo Blog. Pretendo que este blog sea un blog de opinión, donde expresaré mis observaciones personales acerca del mundo de las nuevas tecnologías. Soy coautor del blog Pragmatic Techniques, un blog en inglés sobre técnicas de programación y tecnología en general. Podéis informaros sobre mí en la sección “Sobre el autor

Esperando que mis aportaciones sean de provecho, un cordial saludo😉