Tres Kaleiders en GR8Conf

Pensaba escribir un artículo sobre la conferencia GR8Conf a la que hemos asistido esta semana en Copenhague. Al final lo he escrito en el blog de Kaleidos así que os remito allí para leer mis impresiones:

Tres Kaleiders en GR8Conf

Greach 2014

La tercera edición de Greach tuvo lugar los pasados 28 y 29 de Marzo en el Campus Sur de la Universidad Politécnica de Madrid, que amablemente, cedió sus instalaciones.
La principal novedad de esta edición fue que, para atraer a más público internacional, se decidió (después de un intenso debate) que todas las charlas fueran en inglés. Ya se intentó hacer esto en la edición 2013 pero algunos ponentes nacionales no estuvieron estuvimos muy de acuerdo y al final no se hizo. Este año por fin se ha hecho y desde mi punto de vista ha sido todo un éxito.

En mi caso, además de presentar la charla Metaprogramming with Groovy, me involucré como co-organizador para ayudar a Alberto Vilches con todo lo referente a la organización de un evento como este: call for papers, agenda, patrocinadores, contactar con todos los speakers, vuelos, lanyards, encuestas,... Realmente, hasta que no te metes de lleno en la organización de un evento así, no sabes todo el trabajo que hay detrás.
Ha sido una experiencia muy positiva y el año que viene seguro que repito. No obstante esto implicó que las dos últimas semanas no durmiera más de 5 horas cada día.

Respecto a las charlas, el nivel de las mismas fue muy bueno y creo que la agenda quedó bien distribuida. Había caras conocidas de otros años entre los speakers tanto nacionales como extranjeros pero también hubo muchas caras nuevas.

También me gustaría aprovechar y dar de nuevo las gracias a todos los patrocinadores porque sin ellos el evento no habría sido posible.

Los cuatro Kaleiders que dimos charla :-)

Respecto a mi charla, estoy muy contento con el resultado. La metaprogramación es algo que llevaba utilizando desde hace mucho tiempo pero nunca había profundizado lo suficiente. Así, tener que prepararme la charla fue una magnífica oportunidad para aprender más. Al ser la charla en inglés, mi principal miedo era que alguno de los rockstars estuviera entre el público, levantara la mano y me dijera algo como "Lo siento pero todo eso que estás contando no es así". Por suerte no pasó nada de eso e incluso después de la charla, Burt Beckwith se acercó a comentarme una pequeña diferencia entre la implementación del ExpandoMetaclass entre Grails y Groovy y además me dijo que la charla le había gustado. Así que Achievement Unlocked ;-)


Justo antes de comenzar la charla


Después de la charla con Burt Beckwith


alotor y yo :-)

Para el que esté interesado, aquí están las slides y el vídeo de mi charla, junto con el código de los ejemplos:

Metaprogramming with groovy from Iván López

Si quereis ver todavía más fotos, Jose Miguel Rodriguez creó este album en Flickr.

Próxima parada: GR8Conf en Copenhague en 3 semanas, aunque esta vez como asistente :-)

Instalación de Redmine en Debian 7

A la hora de gestionar proyectos existen multitud de herramientas y opciones disponibles. Algunas son gratis, otras no, unas ofrecen la posibilidad de instalarlas en tus propios servidores, otras se contratan "en la nube".
Redmine es una de las que permiten instalarlo en tus propios servidores. Se trata de un gestor de proyectos escrito con Ruby on Rails, es multiplataforma y soporta múltiples bases de datos. Además es software libre con licencia GPLv2.
Entre sus características destaca el soporte multi-proyecto, sistema de roles y permisos muy flexible y personalizable, gestión de tareas, wikis, foros, subida de archivos y documentos, notificaciones por email y por RSS,...

Llevo casi 4 años utilizando Redmine en el día a día del trabajo (además de administrándolo) y después de instalarlo varias veces de cero y actualizarlo entre versiones otras tantas por fin me he decidido a juntar todas mis notas y escribir un tutorial actualizado.

Partimos de una Debian 7 64 bits recién instalada sin nada adicional a excepción de OpenSSH. Toda la instalación se realizará con un usuario no root en su home, aunque algunos comandos requieren el uso de sudo. Aunque Redmine viene configurado por defecto para utilizar MySQL, en mi caso lo voy a instalar utilizando Postgresql.

Instalación de Postgresql 9.3

En los repos de Debian no está la última versión por lo que lo mejor es utilizar un repo oficial. En la actualidad ya se ha publicado la versión 9.3.2 y será ésta la que utilicemos.

Añadir el repo de Postgres

sudo vi /etc/apt/sources.list.d/pgdg.list

# Postgresql
deb http://apt.postgresql.org/pub/repos/apt/ wheezy-pgdg main

Añadir clave de verificación

wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -

Actualizar los paquetes e instalar postgresql-9.3

sudo apt-get update
sudo apt-get install postgresql-9.3

Damos permisos para conectarnos a las bases de datos

sudo vi /etc/postgresql/9.3/main/pg_hba.conf

# Cambiar la siguiente línea:
local   all             postgres                                peer

# por:
local   all             postgres                                trust

Reiniciar el servidor para que aplique los cambios:

sudo /etc/init.d/postgresql restart

Crear la base de datos

$ psql -U postgres
psql (9.3.2)
Type "help" for help.

postgres=# CREATE ROLE redmine LOGIN ENCRYPTED PASSWORD 'my-secret-password' NOINHERIT VALID UNTIL 'infinity';
postgres=# CREATE DATABASE redmine WITH ENCODING='UTF8' OWNER=redmine;

Instalación de paquetes adicionales

Para poder compilar las gemas de ruby que instalaremos más tarde necesitamos una serie de paquetes. Algunos son los mínimos para poder compilar cualquier fuente: gcc, make,... y otros son necesarios para las gemas.

sudo apt-get install build-essential

Instalar librería necesaria para utilizar Postgresql desde una aplicación Ruby on Rails

sudo apt-get install libpq-dev

Instalación de Apache

Para poder servir el Redmine una vez instalado vamos a utilizar apache.
Instalar apache2 y habilitar los módulos necesarios:

sudo apt-get install apache2 libapache2-mod-fcgid libapache2-mod-proxy-html libfcgi-dev

sudo a2enmod rewrite
sudo a2enmod proxy_http
sudo a2enmod proxy

Instalación de ImageMagick

Para la generación de pdfs y pngs Redmine utiliza ImageMagick, por lo que si queremos utilizar esta funcionalidad deberemos instalarlo junto con las librerías necesarias.

$ sudo apt-get install imagemagick libmagickwand-dev libmagickcore-dev

Instalación de Ruby

Ahora ya podemos instalar Ruby. Utilizaremos la versión 1.9.3.

sudo apt-get install ruby1.9.3

Instalación de Redmine

Por fin, después de haber instalado todas las dependencias podemos empezar con la instalación de Redmine.

Descargar la última versión disponible. En el momento de escribir este artículo es la versión 2.4.2

wget http://www.redmine.org/releases/redmine-2.4.2.tar.gz
tar zxvf redmine-2.4.2.tar.gz
ln -s redmine-2.4.2 redmine
cd redmine

La creación del enlace simbólico no es necesaria pero es una buena práctica. Además nos sirve en el futuro para actualizar la versión sin tener que tocar la configuración del Apache.

Crear el archivo de configuración de la base de datos a partir del que viene de ejemplo y editarlo

cp config/database.yml.example config/database.yml
vi config/database.yml

production:
  adapter: postgresql
  database: redmine
  host: localhost
  username: redmine
  password: "my-secret-password"
  encoding: utf8

Importante quitar mysql de los environments de develop y test porque sino luego intentará instalar las dependencias y fallará. Poner "postgresql" en todos aunque no se configure nada más. Sólo vamos a usar el environment de producción.

Añadir una gema que luego utilizaremos para que se instale junto con el resto.

echo 'gem "fcgi"' > Gemfile.local

Instalar gema de postgresql

sudo gem install pg

Instalar gestor de gemas

sudo gem install bundler

Instalar todas las dependencias de Redmine

sudo bundle install --without development test

Crear las tablas de la base de datos

RAILS_ENV=production rake db:migrate

Crear los datos iniciales (recomendado en inglés)

RAILS_ENV=production rake redmine:load_default_data

Crear directorios y dar permisos

mkdir -p tmp tmp/pdf public/plugin_assets
chmod -R 755 files log tmp public/plugin_assets

Generar el session store secret

rake generate_secret_token

Y listo, ahora sólo falta probar que todo funciona correctamente. Para ello, ejecutamos el servidor web embebido (no utilizar en producción).

$ ruby script/rails server webrick -e production
=> Booting WEBrick
=> Rails 3.2.13 application starting in production on http://0.0.0.0:3000
=> Call with -d to detach
=> Ctrl-C to shutdown server
[2013-12-28 11:05:17] INFO  WEBrick 1.3.1
[2013-12-28 11:05:17] INFO  ruby 1.9.3 (2013-11-22) [x86_64-linux]
[2013-12-28 11:05:17] INFO  WEBrick::HTTPServer#start: pid=25214 port=3000

Nos conectamos con el navegador a http://localhost:3000 y nos logamos con admin/admin.

Configuración de Apache

Para servir el Redmine para poder utilizarlo en producción vamos a utilizar Apache junto con fcgi.

Desde el directorio redmine copiamos el archivo htaccess y de fcgi a partir de las plantillas.

cp public/htaccess.fcgi.example public/.htaccess
cp public/dispatch.fcgi.example public/dispatch.fcgi
chmod +x public/dispatch.fcgi

Editar el archivo de configuración de entornos para utilizar el de producción por defecto

vi config/environment.rb

# Añadir la siguiente línea al principio del archivo
ENV['RAILS_ENV'] ||= 'production'

Añadir el nuevo virtual host al apache

sudo vi /etc/apache2/sites-enabled/000-default

<VirtualHost *:80>
    ErrorLog /var/log/apache2/redmine-error-log
    CustomLog /var/log/apache2/redmine-access-log combined

    ServerName redmine.my-domain.com
    ServerAdmin admin@my-domain.com
    DocumentRoot /home/ivan/redmine/public
    ProxyPreserveHost On

    <Directory "/home/ivan/redmine/public/">
        Options Indexes ExecCGI FollowSymLinks
        Order allow,deny
        Allow from all
        AllowOverride all
    </Directory>
</VirtualHost>

Dar permisos de escritura al usuario de apache a algunos archivos y directorios

sudo chown -R www-data:www-data files log tmp public/plugin_assets

Reiniciar apache

sudo /etc/init.d/apache2 restart

Y listo, si todo va bien deberíamos poder conectarnos a nuestro nuevo Redmine con el dominio que hayamos definido en nuestro virtual host, en este caso http://redmine.my-domain.com.

Bola extra: Actualizar una versión antigua de Redmine

Como he comentado al principio del artículo, llevo utilizando Redmine casi 4 años (empecé en la versión 0.9.6) y he actualizado de versión en bastantes ocasiones. El proceso de actualización es muy simple.

Instalar la nueva versión como hemos hecho hasta ahora y comprobar que todo funciona correctamente.

Parar apache y hacer una copia de seguridad de nuestra base de datos actual (espero que además hagas copias periódicas).

sudo /etc/init.d/apache2 stop
pg_dump -U postgres redmine > db_redmine.sql

Después de instalar la nueva versión de redmine, en lugar de crear todas las tabla en la base de datos, lo que tenemos que hacer es ejecutar la migración de las mismas.

rake db:migrate RAILS_ENV=production

Esto lo que hace es ejecutar todas las migraciones desde la versión que teníamos instalada hasta la versión actual para que el modelo de datos sea el adecuado.

Si tenemos plugins instalados, ejecutar sus migraciones.

rake redmine:plugins:migrate RAILS_ENV=production

Copiar los archivos subidos del directorio files del redmine antiguo al nuevo.

Limpiar cache y sesiones.

rake tmp:cache:clear
rake tmp:sessions:clear

Finalmente reiniciar apache y logarnos de nuevo. Luego, en el menú Administration -> Information podemos comprobar que la migración se ha realizado correctamente y estamos con la versión adecuada:

Para el que no esté muy seguro sobre las actualizaciones, decir que en todas las actualizaciones de estos años no he tenido ningún problema y todas han funcionado a la perfección. En esta última actualización he pasado directamente de la versión 1.4.4 a la 2.4.2. Han sido cinco versiones mayor (2.0, 2.1, 2.2, 2.3 y 2.4) y 27 versiones en total de diferencia entre ambas y cero problemas :-)

Codemotion 2013

El pasado fin de semana tuvo lugar la segunda edición de Codemotion en el que participé, además de como representante de Madrid-GUG, como ponente.

Para el que no lo conozca, Codemotion es un evento por y para las comunidades. Es un punto de encuentro en el que nos reunimos todas las comunidades: Groovy, Java, Python, Ruby, Php,... A lo largo de dos días, 8 tracks y más de 100 charlas se han reunido en el Campus Sur de la Universidad Politécnica de Madrid más de 1500 personas para hablar y disfrutar de su pasión.

En cuanto a las charlas, las del viernes me parecieron más flojas que las del sábado, aunque también es cierto que el viernes hubo muchas charlas de patrocinadores que no me llamaban tanto la atención. La organización fue muy buena teniendo en cuenta el número de asistentes y todo lo que había que coordinar.

Para los que estén interesados en mi charla, a continuación teneis las slides y el código fuente de las demos se encuentra disponible en mi github.

Quiero tiempo real y lo quiero para ayer from Iván López

Leído: Programming Grails

Ya se sabe, vacaciones, más tiempo libre, estar en la playa casi sin conexión a internet,... qué mejor forma de aprovechar el tiempo que leyendo :-)

Libro escrito por otro de los Core Developer de Grails, Burt Beckwith y como él mismo cuenta en la introducción, orientado a desarrolladores con experiencia en Grails que quieren conocer con más detalle cómo funciona la magia del framework y cómo se integra con Groovy, Spring y Hibernate. Si no conoces Grails este no debería ser tu primer libro porque no cuenta los distintos artefactos y cómo funciona el framework, sino que se mete directamente en sus tripas.

Para empezar en el capítulo 1 damos un repaso a Groovy, lenguaje en el que se basa Grails. Se explica de una manera sencilla las particularidades del lenguaje y lo que lo diferencia de Java. Además se explican las colecciones, mapas, closures e incluso se habla un poco de meta-programación. El siguiente capítulo explica con detalle los 16 plugins core de una aplicación Grails: controllers, codecs, filters, urlMappings,... Da un punto de partida de cómo funcionan y deja con ganas de ponerte con el IDE a mirar con más detalle.
El resto de capítulos habla de la capa de Persistencia, la relación con Spring, con Hibernate, la externalización de la configuración... y distintos "gotchas" a tener en cuenta y que más de una vez seguro que te han ocurrido y no sabías por qué.

El libro me ha dejado un sabor un poco agridulce. Por una parte algunos capítulos como la parte de Spring, Hibernate o los Plugins me han gustado mucho y he aprendido bastante. Por otra parte otros como el de los plugins core de Grails hay que leerlos con el IDE abierto para ir analizando las distintas clases e interfaces que van explicando, puesto que si no se entiende nada. Tendré que volver a releerlos delante del ordenador para seguir profundizando en las tripas del framework.
Por último, alguno de los últimos capítulos como el relacionado con los entornos Cloud o cómo actualizar las aplicaciones me han parecido un poco de relleno.

Aún así, me parece un libro imprescindible si ya llevas tiempo con el framework y quieres conocer más cómo funciona under the hood.

Leído: The Definitive Guide to Grails 2

Aunque ya llevo varios años trabajando con Grails siempre está bien mantenerse al día con las actualizaciones de los libros existentes a las últimas versiones del framework. El libro está escrito por Graeme Rocher y Jeff Brown, Grails Team Leader y Core Developer de Grails respectivamente, lo que implica que ambos conocen bien las tripas del framework y saben de lo que hablan.

Durante 12 capítulos van explicando la esencia del framework y los pilares en los que se basa, principalmente Spring y Hibernate y Groovy como lenguaje de programación. Así, vamos viendo como empezar instalándolo y creando nuestra primera aplicación, las clases de dominio, los controladores, las vistas, los servicios hasta la internacionalización, GORM o el desarrollo de plugins. Los capítulos están bien estructurados y cuentan con buenos ejemplos con los que van explicando las particularidades de cada tipo de artefacto del framework. También incluyen en cada capítulo un apartado en el que se explica como testear el tipo de artefacto que se está explicando. Creo que habría sido mejor que los ejemplos de los tests hubiesen sido con Spock en lugar de con Junit, aunque mientras Grails no incluya Spock por defecto, tiene sentido no tener que instalar dependencias adicionales para hacer los tests. Yo sin embargo, siempre recomiendo a cualquiera que trabaje con Grails (e incluso con Java) que utilice Spock para realizar los tests puesto que conseguirá que sus tests sean mucho más explícitos, expresivos y fáciles de mantener que con Junit.

Para finalizar comentaré que aunque la gran mayoría de lo que he leído lo conocía, siempre viene bien refrescar conceptos y reforzar algunas partes del framework que son algo más complejas. También he aprendido algún truco nuevo que seguro que utilizo dentro de poco en algún proyecto. En definitiva, un libro interesante para cualquiera que se quiera iniciar en Grails y también para desarrolladores que lleven tiempo trabajando con el framework.

Leído: Seven Databases in Seven Weeks

Con este artículo empiezo una serie en el blog en los que iré contando mi opinión sobre distintos libros técnicos que voy leyendo. Uno de mis propósitos para este año es lograr sacar tiempo para leer 5 ó 6 libros técnicos y, a ser posible, que no estén relacionados unos con otros ni estén centrados en un campo específico.

Así, empezamos con Seven Databases in Seven Weeks: A Guide to Modern Databases and the NoSQL Movement. A lo largo del libro hemos visto distintas bases de datos de distintos paradigmas. Desde las clásicas relacionales, hasta las modernas NoSQL con sus distintas variantes: orientadas a documentos, clave-valor, basada en columnas hasta las orientadas a grafos.

El libro no pretende ser una guía del DBA para cada una de esas bases de datos ni tampoco un manual de instalación de cada una de ellas, sino que directamente nos va mostrando distintas características de cada una a través de diversos ejemplos. También se centra en los distintos criterios que debemos tener en cuenta a la hora de elegir una u otra y destaca sus puntos fuertes y deficiencias.

Las bases de datos que se muestran, en el mismo orden de aparición son:
- PostgreSQL: Se trata de una de las base de datos opensource relacionales más potentes que existen en la actualidad. Aunque personalmente llevo utilizándola varios años, aprendí muchas cosas de tipos nativos, array n-dimensionales y búsquedas full text search.
- Riak: Entra dentro de la categoría de clave-valor aunque añade conceptos muy interesantes como un completo interfaz REST y enlaces entre campos de distintas relaciones.
- HBase: Es una base de datos orientada a columnas. Aunque inicialmente parece una base de datos relacional tal cual, ya en la introducción nos indican claramente que no es la típica base de datos que utilizaremos para nuestro pequeño catálogo de productos, sino que debemos tener muchos gigabytes o terabytes de datos para aprovecharla realmente. Al estar diseñada para un gran volumen de datos, el escalado es muy fácil de implementar. Otras cosas interesantes son el versionado automático de columnas y la compresión nativa de datos.
- MongoDB: Probablemente sea una de las bases de datos NoSQL más conocidas en la actualidad. El hecho de que sitios como Foursquare estén implementados con MongoDB le ha dado mucha fama. MongoDB encaja en la categoría de bases de datos orientadas a documentos, donde su principal característica es ser schemaless, es decir, no obligar a tener un esquema definido en las colecciones. Los documentos son JSON y entre sus principales características destacan la replicación de los datos y el sharding de grandes colecciones.
- CouchDB: Al igual que MongoDB, CouchDB es una base de datos orientada a documentos JSON y con interfaz REST. Una de sus principales características es que está diseñada para funcionar desde en un teléfono Android, en un pc hasta en un Datacenter.
- Neo4J: Se trata de una base de datos orientada a grafos. Es ideal para modelar tipos de relaciones de amistad, gustos,... Su principal lema es "si puedes dibujarlo como cajas y líneas en una pizarra, entonces puedes almacenarlo en Neo4J". Me ha impresionado porque es un nuevo paradigma de bases de datos para mí y sirve para cambiar el chip.
- Redis: La base de datos clave-valor por excelencia. Además posee numerosas operaciones para realizar todo tipo de operaciones: rankings ordenados, listas,...

Para terminar, añadiré que la lectura del libro es amena y cómoda. Cada capítulo está dividido en "3 días" y al final de cada día se incluyen una serie de ejercicios para practicar y afianzar lo aprendido. En mi caso, los ejercicios no los he podido hacer porque me llevarían demasiado tiempo (del que no dispongo). Aún así, estoy contento con lo aprendido a lo largo del libro que me ha servido para conocer otro tipo de bases de datos para utilizar en el futuro si los problemas a resolver lo requieren.