Módulo de Puppet para Grails

Nota: esta entrada también la publiqué en inglés en mi blog.

Sobre el módule

El siguiente módulo de Puppet del que quería hablar es el módulo de Puppet para Grails. Igual que los anteriores módulos para Puppet, está publicado en la cuenta Github de OSOCO, y es uno de los más sencillos, pero también de los que más hemos usado en nuestra infraestructura, por razones obvias 😀 .

Este módulo permite instalar múltiples versiones de Grails en un nodo de Puppet. El uso no podría ser más simple, como puedes ver en el siguiente código de ejemplo:

class jenkins {
    ...
    grails { "grails-1.3.5":
        version => '1.3.5',
        destination => '/opt'
    }

    grails { "grails-1.3.9":
        version => '1.3.9',
        destination => '/opt'
    }

    grails { "grails-2.0.0":
        version => '2.0.0',
        destination => '/opt'
    }

    grails { "grails-2.0.1":
        version => '2.0.1',
        destination => '/opt'
    }
    ...
}

En este ejemplo, una clase jenkins declara múltiples instalaciones de Grails (para poder lanzar las baterías de tests de cada proyecto con la versión apropiada de Grails), para lo que añade varios recursos de tipo grails parametrizados por la versión y el directorio destino. El módulo de Grails resuelve la URL de descarga (la cual, desde la versión 1.3.6 ha de apuntar a Amazon S3, mientras que anteriormente se resolvía a una URL propia) y descargará y desempaquetará el ZIP sólo en caso necesario (es decir, si la versión dada no existe ya en el directorio de destino especificado).

Dependencias

El módulo depende del módulo de Puppet para WGet de OSOCO, por lo que debes tener una copia de ambos módulos en tu directorio de módulos. O, si usas puppet-librarian, puedes símplemente añadir lo siguiente a tu fichero Puppetfile:

mod "wget",
   :git => "git://github.com/osoco/puppet-wget.git"
mod "grails",
   :git => "git://github.com/osoco/puppet-grails.git"

Android GCM Sender

Esta entrada es una traducción al español de la que publiqué en mi blog, que está en inglés.

Motivación

Imagina que estás desarrollando una aplicación Android que necesita recibir notificaciones push. La aplicación encargada de enviar esos mensajes a GCM está siendo desarrollado por otro equipo, y no sólo no está terminada todavía, sino que además el equipo está en otro departamento de la empresa. No, de hecho está en otra empresa :-) . Quieres estar seguro de que tu aplicación cumple las especificaciones (es decir, reacciona de cierta manera cuando recibe cierta notificación), pero no quieres depender de ese otro equipo (y por supuesto, tampoco quieres desarrollar una aplicación que envíe notificaciones 😀 ):

Solución

Esa necesidad de una aplicación de envío de mensajes configurables a GCM es el segundo artefacto que Adrian Santalla y yo desarrollamos en los dos primeros hacker fridays de OSOCO, al que hemos llamado Android GCM Sender (siendo el primero el plugin de Android GCM para Grails).

Suscribe tus dispositivos usando la URL proporcionada y añade tu identificador de proyecto

Empezó siendo la aplicación de prueba para dicho plugin, pero nos dimos cuenta que sería fácil evolucionarla hasta el punto de ser útil para cualquiera: sólo necesitábamos parametrizar el identificador de proyecto (que puedes obtener creando un proyecto tipo Google API) y crear una acción que permitiese la suscripción de dispositivos Android. Puedes usar Android GCM Sender en la siguiente URL: http://grails-android-gcm-sender.herokuapp.com/.

Uso

El primer paso sería suscribir tus identificadores de dispositivo Android usando la URL http://grails-android-gcm-sender.herokuapp.com/device/subscribe?deviceToken=yourDeviceToken&projectId=yourProjectId. No olvides sustituir substitute yourDeviceToken y yourProjectId con tu identificador de proyecto e identificador de dispositivo Android, y recuerda que esta URL está pensaba para ser invocada con algún tipo de HTTPBuilder dentro de una aplicación Android – opr eso no produce ninguna salida :-). Pero si quieres usarla directamente en tu navegador, también funcionará 😀 .

Compón tu mensaje, envíalo a los dispositivos seleccionados y observa el resultado del envío

Después de eso, escribe tu identificador de proyecto en la página de inicio de Android GCM Sender y dale al botón de actulizar. Verás un formulario que te permite enviar mensajes (simples o compuestos) a uno o varios dispositivos Android. Ten en cuenta que siempre tendrás disponibles dos dispositivos falsos para el caso en que quieras hacer algún tipo de prueba con ellos. Después de rellenar el formulario. puedes darle al botón Send y verás el resultado del envío. Y si tus identificadores de dispositivo y proyecto son válidos, deberías recibir una notificación push con el mensaje que compusiste en la vista anterior 😀 .

Ten en cuenta que para mantener los datos en un volumen pequeño, tus identificadores de dispositivo y proyecto sólo se guardan durante 24 horas – piensa que en realidad es una feature y no un bug 😀 ya que así no te tienes que preocupar de des-suscribir tus dispositivos o similar. De hecho, la base de datos está en memoria, por lo que nosotros no tenemos acceso a ella.

Código fuente

Android GCM sender corre en Heroku, pero su código fuente está disponible en la cuenta Github de OSOCO, por lo que puedes alojarlo tú mismo si quieres. La aplicación ha sido desarrollada usando Grails, y a la UI se le ha añadido un poco de picante con Ajaxify.

Módulo de Puppet para MySQL

Nota: esta entrada también la publiqué en inglés en mi blog. If you are an english reader, you may want to check it.

Continuando con los móldulos de Puppet que hemos publicado en la cuenta de GitHub de OSOCO, hoy hablaré del módulo de Puppet para MySQL, que me ha parecido uno de los más útiles cuando hemos creado nuestras infraestructuras :-) .

Hay cantidad de módulos MySQL ya publicados, pero los que probé antes de crear el nuestro eran muy potentes, y por lo tanto complejos y con muchas dependencias. En este caso, quería intentar conseguir justo lo contrario: un módulo sencillo que símplemente funcionase a la hora de hacer las tareas más comunes relacionadas con MySQL: instalarlo, establecer la password de root, crear bases de datos y permitir el acceso de usuarios a las mismas.

Para usar el módulo símplemente debes añadirlo a tus módulos (en nuestro caso usamos Puppet Librarian para la gestión de dependencias) y declarar los recursos que necesitas. El siguiente ejemplo muestra nuestra configuración de MySQL para el nodo que es responsable de hospedar a Jenkins:

class ci_mysql {

    mysql::database { 'someProjectTestDB': }
    mysql::database { 'anotherProjectTestDB': }

    $test_user_name = 'test'
    $test_user_pwd = 'test'

    mysql::user { 'someProjectTestDB-test-user':
        user => "$test_user_name",
        password => "$test_user_pwd",
        database => 'someProjectTestDB',
        host => '%'
    }

    mysql::user { 'anotherProjectTestDB-test-user':
        user => "$test_user_name",
        password => "$test_user_pwd",
        database => 'anotherProjectTestDB',
        host => '%'
    }

    mysql::user { 'anotherProjectTestDB-readonly-user':
        user => 'readonlyuser',
        password => 'readonlyuser',
        database => 'anotherProjectTestDB',
        privileges => 'SELECT'
    }
}

Sólo con eso se instalará el servidor de MySQL y será lanzado como un servicio. Además se crearán dos bases de datos (someProjectTestDB y anotherProjectTestDB) con un usuario con todos los permisos de acceso (de nombre test). Finalmente, el usuario readonlyuser tendrá acceso a la base de datos anotherProjectTestDB, pero sólo podrá hacer consultas de tipo select. Directo y sencillo :) .

La clase también puede ser configurada con los siguientes parámetros opcionales:

class ci_mysql {
   class { "mysql::install":
      version => "5.1.61-0+squeeze1",
      root_pwd => "myFancyRootPassword",
      data_dir => "/mnt/mysql/datadir",
   }   
   ...
}

De esa manera puedes especificar la versión de MySQL, la contraseña del root, y el directorio de datos que usará MySQL para guardar las bases de datos. Por último, añadir que este módulo lo hemos probado tanto en Debian como en Gentoo (por lo que debería funcionar bien en Ubuntu).

Grails Android GCM Plugin

Nota: esta entrada también está publicada en mi blog en inglés. If you are an english reader, you might want to read that version.

Como resultado de los dos primeros hacker fridays de OSOCO, Adrian Santalla y yo publicamos el plugin de Grails para Android GCM (entre otras cosas 😀 ), cuyo código fuente está disponible en Github.

Este pequeño plugin proporciona a tu aplicación Grails acceso a Android GCM (el servicio que Googe usa para las notificaciones push de Android) a través de un servicio que es injectado en los artefactos de tu aplicación.

El plugin está publicado en el repositorio oficial de plugins de Grails, así que instalarlo es tan fácil como invocar la orden install-plugin, tras lo cual cualquier servicio, controlador, etc, de tu aplicación podrá usar el servcio androidGCMService. El siguiente ejemplo ilustra el caso de uso más básico:

$ grails create-app AwesomeApp 
$ cd AwesomeApp
$ grails install-plugin android-gcm
$ grails create-controller Cool
$ cat > grails-app/controllers/awesomeapp/CoolController.groovy << EOF
package awesomeapp

class CoolController {

    def androidGcmService

    def index() {  
        render androidGcmService.sendMessage(
            [ 
                aMessageKey : 'The message value for the key aMessageKey', 
                anotherMessageKey : 'The message value for the key anotherMessageKey' 
            ],
            ['anAndroidDeviceToken', 'anotherAndroidDeviceToken'],
            'youShallCollapseThisMessage', 'yourGCMAPIKeyProvidedByGoogle'      
        )          
    }
}
EOF
$ grails run-app
$ $ wget -O - http://localhost:8080/AwesomeApp/cool/index 2> /dev/null
MulticastResult(multicast_id=8596196938900195177,total=2,success=0,failure=2,canonical_ids=0,results: [[ errorCode=InvalidRegistration ], [ errorCode=InvalidRegistration ]])

Como se ve, el controlador intenta enviar un mensaje (el cual, por su parte, está compuesto por dos mensajes, cada uno con su clave y valor) a dos dispositivos Android, marcando el mensaje como de tipo collapse, y pasando la clave de acceso al API de GCM porporcionada por Google. Cuando el resultado es renderizado, se muestra un objeto de clase MulticastResult (dado que hemos intentado enviar el mensaje a múltiples dispositivos) con el resultado del envío del mensaje (que en este caso es un error de tipo InvalidRegistration para ambos dispositivos, ya que estamos inventándonos su identificador de registro 😀 ). Ten en cuenta que si quieres probar este ejemplo tendrás que sustituir yourGCMAPIKeyProvidedByGoogle con un identificador de API válido, si no lo haces el API de Android al que el plugin invoca fallará con una bonita excepción de tipo null pointer :-( .

Puedes ver una lista completa de los métodos proporcionados por el servido y de las opciones de configuración disponibles en el README del proyecto en Github.

Módulos de Puppet para Git y Subversión

Nota: esta entrada también está publicada en inglés en mi blog. If you are an english reader you may want to check out the english version :-) .

Puppet

Durante este último año hemos estado usando puppet, una herramienta de configuración que permite automatizar el despligue y configuración de software usando un DSL (en vez de, por ejemplo, scripts caseros de dudosa portabilidad). Durante este tiempo hemos escribo algunos módulos agnósticos de OSOCO, que hemos publicado en nuestra cuenta de Github, así que he pensado en hacerles algo de publicidad :-D. Empezaré con dos de los más sencillos, puppet-git y puppet-svn, que te permiten hacer checkouts y actualizar repositorios de estos dos populares SCM’s

Puppet Git

Puedes encontrar el código fuente de este módulo en su repositorio de Github. Permite hacer un checkout de un repositorio o mantener actualizada una copia ya existente. Un caso de uso de ejemplo podría ser un servidor que necesita instalar una serie de herramientas cuando arranca, y se puede ver en otro módulo Puppet que tenemos publicado, el de aws-tools, cuyo código relevante puedes ver a continuación:

class my_awesome_puppet_class {
    include git
    $path = "/my/existing/aws-tools/path"
    git::clone { "aws-tools-clone":
        url => "https://github.com/osoco/aws-tools.git",
        path => "$path/aws-tools",
        username => "",
        password => "",
    }
    git::pull { "aws-tools-pull":
        path => "$path/aws-tools",
    }
}

Como se puede ver, definimos un par de recursos de tipo clone y pull, los cuales son lo suficientemente inteligentes para ejecutar su operación asociada sólo cuando tiene sentido: la operación de clone sólo se ejecutará cuando el directorio de destino no exista, mientras que la operación pull sólo lo hará cuando si exista :-) . Esto mantendrá la copia de las maravillosas aws-tools 😀 disponible y actualizada.

Puppet Subversion

Prácticamente lo mismo, pero usando el viejo y bueno Subversion (para aquellos que os lo estéis preguntando – si, todavía puedes usar subversion y ser guay 😀 ). Nuevamente, el código fuente está disponible en Github y proporciona básicamente las mismas opearaciones. En este caso, el ejemplo muestra un servidor web que al arrancar ha de obtener una copia de la web que sirve, así como mantenerla siempre actualizada:

class awesome_website_configuration {
    include svn
    $document_root = "/var/www/awesome_website"
    svn::checkout { "awesome-website-checkout":
        username => "my-readonly-svn-user",
        password => "someSecretPassword", 
        url => "https://svn.somecompany.org/svn/awesome_web/trunk",
        path => $document_root,
    }
    svn::update { "awesome-website-update":
        username => "my-readonly-svn-user",
        password => "someSecretPassword", 
        path => $document_root,
    }
}

Y eso es todo. Probablemente no son los módulos más extraordinarios que encontrarás, pero son útiles :-) .