Experimentando con Ubuntu juju y Cloud Foundry

Después de las vacaciones de verano, volvemos con la energia renovada y con ganas de hacer más experimentos 🙂

En una entrada anterior donde os hablabla de Cloud Foundry, un lector me pedia un post sobre como montar un servidor propio. La verdad es que comencé a escribirlo, aunque por motivos que no vienen a cuento tardé más de la cuenta. Y casi justo cuando lo tenia terminado, VMWare lanzó un script que simplifica mucho el proceso de instalación, por lo que borré el post por careced de sentido. Así pués, si todavia estais interesados, solamente tenéis que seguir las instrucciones que aparecen en la página del proyecto en github. El proceso, aunque largo, es muy sencillo.

En esta entrada, en cambio, nos vamos a centrar en ver como os podeis montar vuestro propio servidor de Cloud Foundry, pero en vez de en local, lo vamos a albergar en Amazon EC2. Además, en vez de hacerlo de la forma tradicional (o sea, creando una instancia de EC2 y ejecutando el script de instalación tal como se describe en esta página), vamos a utilizar una nueva herramienta muy interesante que ha aparecido recientemente, y que nos permitirá además escalar los servicios ofrecidos por Cloud Foundry de una manera muy sencilla y rápida.

La herramienta en cuestión se llama Ubuntu Ensemble. Bien, de hecho ya no se llama así 🙁 . Justo cuando estoy escribiendo esta entrada, lo magnificos chicos de Canonical han decidido cambiarle el nombre por Ubuntu juju (esta entrada debe estar “gafada” 🙂 ) en referencia a la magia/brujería practicada en algunas regiones de Africa.

juju es un framework de orquestación para el despliegue de servicios de infraestructura en la “nube” (similar en cuanto a concepto a Chef o Puppet o, en otro nivel, a los ServerTemplates de RightScale), o dicho de otra manera, una especie de APT pero dirigido a entornos que se ejecutan en la “nube” y, a diferencia del primero, en vez de focalizarse en el despliegue de un producto en una máquina, persigue la instalación orquestada en entornos distribuidos de servicios interrelacionados. La idea detrás de juju es que haya una comunidad de desarrolladores que paquetizen el despliegue de sus servicios (similar a lo que hace APT con los paquetes o a las recipes de Chef) mediante lo que llaman charms (hechizos) y que estas charms, además de ser reutilizables por otros usuarios, incluyan los metadatos del servicio, las dependencias a otros servicios, los paquetes necesarios para su despliegue, así como la lógica para gestionar el servicio. Actualmente esta en fase de desarrollo, y solo admite entornos Amazon EC2 (o clones en cuanto a la API, como OpenStack), aunque está previsto soporte a otros entornos en un futuro. Se incluirá por defecto en la release 11.10 de Ubuntu, aunque a dia de hoy, ya se puede probar tanto en la Beta 1 de la release 11.10 como en versiones anteriores (11.04 y 10.04).

Bien, una vez hechas las presentaciones, vamos a experimentar con esta herramienta. En primer lugar vamos a instalar juju. Si estamos utilizando Ubuntu 11.10 es tan sencillo como:

~$ sudo apt-get install juju

Pero si utilizamos Ubuntu 10.04 o 11.04, entonces tendremos que añadir primero el repositorio PPA correspondiente:

~$ sudo apt-get install python-software-properties
~$ sudo add-apt-repository ppa:juju/pkgs
~$ sudo apt-get update
~$ sudo apt-get install juju

Ahora vamos a inicializar el entorno de juju. Primero invocaremos al comando que nos creará un archivo de entorno por defecto:

~$ juju
error: No environments configured. Please edit: /home/frodenas/.juju/environments.yaml

Y editaremos el archivo añadiendo algunas líneas:

~$ vi /home/frodenas/.juju/environments.yaml
environments:
  sample:
    type: ec2
    ec2-uri: https://ec2.eu-west-1.amazonaws.com
    access-key: --- INSERTAR AQUI VUESTRA ACCESS-KEY DE AMAZON EC2 ---
    secret-key: --- INSERTAR AQUI VUESTRA SECRET-KEY DE AMAZON EC2 ---
    control-bucket: --- ELIMINADO POR SEGURIDAD - DEJAR EL VALOR POR DEFECTO ---
    admin-secret: --- ELIMINADO POR SEGURIDAD - DEJAR EL VALOR POR DEFECTO ---
    default-image-id: ami-66f6c512
    default-instance-type: m1.large

Lo que hemos añadido ha sido:

  • ec2-uri: aquí hemos puesto el endpoint de la región de Amazon EC2 que nos interesa, en este caso, la región EU West (Irlanda).
  • access-key y secret-key: vuestras credenciales de Amazon EC2.
  • default-image-id: aquí ponemos el nombre de la AMI de Amazon EC2 que se utilizará por defecto, en este caso, utilizaremos una imagen de Ubuntu Cloud 11.10 de 64 bits disponible en la región de EU West. El nombre de la AMI varia cada dia, por lo que os recomiendo que comproveis la lista actual de imagenes antes de utilizar la que yo he puesto.
  • default-instance-type: aquí ponemos el tipo de instancia de Amazon EC2 que se utilizará por defecto, en este caso, como la instancia contendrá Cloud Foundry y diversos servicios (MySQL, MongoDB y Redis), escogemos la instancia grande (m1.large).

Bien, ahora hemos de arrancar el entorno. Pero antes, y debido a que las charms de juju que nos permiten instalar el servidor de Cloud Foundry y sus servicios todavia no están publicadas en los repositorios oficiales, nos tocará instalarlas manualmente en local:

~$ sudo apt-get install bzr
~$ mkdir charms && cd charms
~/charms$ bzr branch lp:~canonical-sig/+junk/cloudfoundry-server

Ahora si podemos arrancar el entorno de juju (generar antes un par de claves en vuestro sistema sino lo habéis hecho, de lo contrario el entorno no arrancará):

~/charms$ ssh-keygen -t rsa -b 2048
~/charms$ juju bootstrap
2011-09-22 00:46:54,161 INFO Bootstrapping environment 'sample' (type: ec2)...
2011-09-22 00:47:01,753 INFO 'bootstrap' command finished successfully

Esto proceso lo que hará es crear una instancia en Amazon EC2 e instalarle el servidor de juju mediante cloud-init. Con el comando status podremos ver si el entorno está ya arrancado:

~/charms$ juju status
No machines have addresses assigned yet
2011-09-22 00:47:11,893 ERROR No machines have addresses assigned yet

Vemos que la instancia todavía no está levantada. Nos vamos a la consola web de Amazon EC2 y esperamos a que arranque:

Una vez esté en marcha, volvemos a ejecutar el comando status:

~/charms$ juju status
2011-09-22 00:49:00,215 INFO Connecting to environment.
machines:
  0: {dns-name: ec2-46-51-151-139.eu-west-1.compute.amazonaws.com, instance-id: i-af00e1e6}
services: {}
2011-09-22 00:49:01,834 INFO 'status' command finished successfully

Como veis, ahora si nos indica que hay una máquina en marcha. Ahora vamos a desplegar el servidor de Cloud Foundry. Para ello utilizaremos el comando deploy y la charm que nos hemos descargado anteriormente:

~/charms$ juju deploy --repository . cloudfoundry-server
2011-09-22 00:49:25,033 INFO Connecting to environment.
2011-09-22 00:49:27,823 INFO Charm deployed as service: 'cloudfoundry-server'
2011-09-22 00:49:27,825 INFO 'deploy' command finished successfully

Igual que en el caso anterior, esperamos a que arranqué la instancia, se despliegue el servidor y servicios de Cloud Foundry, y estos se pongan en marcha (tened paciencia, es un proceso un poco lento). Podemos ir consultando periodicamente el estado hasta que el servicio está en marcha (el campo “state” pasará de “null” a “installed” y finalmente “started“):

~/charms$ juju status
2011-09-22 00:55:17,906 INFO Connecting to environment.
machines:
  0: {dns-name: ec2-46-51-151-139.eu-west-1.compute.amazonaws.com, instance-id: i-af00e1e6}
  1: {dns-name: ec2-46-137-3-58.eu-west-1.compute.amazonaws.com, instance-id: i-0503e24c}
services:
  cloudfoundry-server:
    charm: local:cloudfoundry-server-26
    relations: {}
    units:
      cloudfoundry-server/0:
        machine: 1
        relations: {}
        state: started
2011-09-22 00:55:20,236 INFO 'status' command finished successfully

El siguiente paso será abrir los puertos necesarios para que nos podamos conectar con el servidor de Cloud Foundry. Para ello utilizaremos el comando expose (y no es necesario indicar los puertos a abrir, ya que estos están indicados en la charm):

~/charms$ juju expose cloudfoundry-server
2011-09-22 00:55:41,155 INFO Connecting to environment.
2011-09-22 00:55:42,485 INFO Service 'cloudfoundry-server' was exposed.
2011-09-22 00:55:42,486 INFO 'expose' command finished successfully

Consultamos el estado del servicio y veremos como ahora nos indica los puertos que están abiertos:

~/charms$ juju status
2011-09-22 00:55:45,701 INFO Connecting to environment.
machines:
  0: {dns-name: ec2-46-51-151-139.eu-west-1.compute.amazonaws.com, instance-id: i-af00e1e6}
  1: {dns-name: ec2-46-137-3-58.eu-west-1.compute.amazonaws.com, instance-id: i-0503e24c}
services:
  cloudfoundry-server:
    charm: local:cloudfoundry-server-26
    exposed: true
    relations: {}
    units:
      cloudfoundry-server/0:
        machine: 1
        open-ports: [80/tcp, 443/tcp, 4222/tcp]
        relations: {}
        state: started
2011-09-22 00:55:48,101 INFO 'status' command finished successfully

En teoria ahora está todo levantado, pero por si acaso, vamos a comprobarlo conectandonos a la máquina que contiene el servidor de Cloud Foundry. Para ello utilizaremos el comando ssh del propio juju y el número de máquina que nos ha indicado el comando status:

~/charms$ juju ssh 1
2011-09-22 00:56:14,640 INFO Connecting to environment.
2011-09-22 00:56:16,265 INFO Connecting to machine 1 at ec2-46-137-3-58.eu-west-1.compute.amazonaws.com

Una vez hayamos entrado, miraremos si los servicios de Cloud Foundry están levantados:

ubuntu@ip-10-228-250-63:~$ cd /opt/cloudfoundry-server/vcap/bin
ubuntu@ip-10-228-250-63:/opt/cloudfoundry-server/vcap/bin$ sudo ./vcap status
router              :    RUNNING
cloud_controller    :    RUNNING
dea                 :    RUNNING
health_manager      :    RUNNING
redis_gateway       :    RUNNING
redis_node          :    RUNNING
mysql_gateway       :    RUNNING
mysql_node          :    RUNNING
mongodb_gateway     :    RUNNING
mongodb_node        :    RUNNING

Como vemos, todos los servicios de Cloud Foundry están en marcha. Ya nos podemos desconectar de la instancia de Amazon EC2:

ubuntu@ip-10-228-250-63:/opt/cloudfoundry-server/vcap/bin$ exit
Connection to ec2-46-137-3-58.eu-west-1.compute.amazonaws.com closed.

Ahora vamos a proceder a conectarnos a Cloud Foundry para ver si responde. Lo primero que deberemos hacer es bajarnos el cliente vmc:

~/charms$ sudo apt-get install ruby-vmc

Pero para poder conectarnos remotamente necesitamos disponer de un registro wildcard DNS que redirija nuestras peticiones hacia el servidor de Cloud Foundry. En nuestro caso, como es solo un experimento low cost, vamos a utilizar un truco. Lo que vamos a hacer en crear un tunel ssh de manera que las peticiones al puerto 80 de nuestra máquina se redirijan al puerto 80 de la instancia de Amazon EC2 que contiene el servidor de Cloud Foundry (si en vuestra máquina ya estais utilizando el puerto 80, lo podeis cambiar a otro, por ejemplo, el 8080). Pero para poder montar el túnel contra la instancia de Amazon EC2, necesitamos tener la clave privada y que esta coincida con la clave pública almacenada en la instancia de Amazon EC2. Como en el archivo de entorno de juju no hemos especificado ningún par de claves, este ha utilizado el par de claves de nuestro usuario (de ahí que os recordava anteriormente el generar un par de claves). Así pués, lo que haremos es indicar al ssh que utilize la clave privada de nuestro usuario:

~/charms$ cd ~/.ssh
~/.ssh$ sudo ssh -i id_rsa -L 80:46.137.3.58:80 ubuntu@46.137.3.58 -N

El problema de este metodo es que nos bloquea la sesión de terminal, por lo que nos tocará abrir una nueva sesión. Una vez la tengamos, procederemos a provar la conexión contra Cloud Foundry:

~$ vmc target api.vcap.me
Succesfully targeted to [http://api.vcap.me]</p>
<p>~$ vmc info</p>
<p>VMware's Cloud Application Platform
For support visit http://support.cloudfoundry.com</p>
<p>Target:   http://api.vcap.me (v0.999)
Client:   v0.3.10

Bien, parece que el servidor responde. Ahora vamos a crear un usuario:

~$ vmc register
Email: frodenas@gmail.com
Password: ********
Verify Password: ********
Creating New User: OK
Successfully logged into [http://api.vcap.me]</p>
<p>~$ vmc info</p>
<p>VMware's Cloud Application Platform
For support visit http://support.cloudfoundry.com</p>
<p>Target:   http://api.vcap.me (v0.999)
Client:   v0.3.10</p>
<p>User:     frodenas@gmail.com
Usage:    Memory   (0B of 2.0G total)
          Services (0 of 16 total)
          Apps     (0 of 20 total)

Perfecto! El servidor de Cloud Foundry ya está listo para ser usado!

Podríamos finalizar el experimento aquí, pero vamos a ir un poco más allá. En un teórico entorno de producción, seguramente nos quedaremos cortos con solo 1 instancia de Cloud Foundry y que esta incluya todos los servicios. Lo que haríamos es crear más instancias y albergar en cada una de ellas alguno de los servicios disponibles. Vamos a ver como lo podemos hacer con juju.

En primer lugar, nos descargamos los charms que nos interesen. Aquí os pongo los charms de los servicios de DEA (el agente de Cloud Foundry que ejecutará nuestras aplicaciones), MySQL, MongoDB y Redis:

~$ cd charms
~/charms$ bzr branch lp:~canonical-sig/+junk/cloudfoundry-server-dea
~/charms$ bzr branch lp:~canonical-sig/+junk/cf-mysql
~/charms$ bzr branch lp:~canonical-sig/+junk/cf-mongodb
~/charms$ bzr branch lp:~canonical-sig/+junk/cf-redis

Vamos a utilizar como ejemplo la instalación de un nuevo servidor de MongoDB. Utilizaremos igual que antes el comando deploy:

~/charms$ juju deploy --repository . cf-mongodb
2011-09-22 01:04:42,031 INFO Connecting to environment.
2011-09-22 01:04:45,147 INFO Charm deployed as service: 'cf-mongodb'
2011-09-22 01:04:45,149 INFO 'deploy' command finished successfully

Y esperaremos a que el servicio de MongoDB esté levantado (cuando aparezca “state: started“):

~/charms$ juju status
2011-09-22 01:11:07,813 INFO Connecting to environment.
machines:
  0: {dns-name: ec2-46-51-151-139.eu-west-1.compute.amazonaws.com, instance-id: i-af00e1e6}
  1: {dns-name: ec2-46-137-3-58.eu-west-1.compute.amazonaws.com, instance-id: i-0503e24c}
  2: {dns-name: ec2-79-125-44-111.eu-west-1.compute.amazonaws.com, instance-id: i-7b04e532}
services:
  cf-mongodb:
    charm: local:cf-mongodb-1
    relations: {mongodb-cluster: cf-mongodb}
    units:
      cf-mongodb/0:
        machine: 2
        relations:
          mongodb-cluster: {state: up}
        state: started
  cloudfoundry-server:
    charm: local:cloudfoundry-server-26
    exposed: true
    relations: {}
    units:
      cloudfoundry-server/0:
        machine: 1
        open-ports: [80/tcp, 443/tcp, 4222/tcp]
        relations: {}
        state: started
2011-09-22 01:11:11,105 INFO 'status' command finished successfully

Ahora lo que debemos hacer es informar al servidor de Cloud Foundry de que tiene una nueva instancia de MongoDB disponible para ser usada. Para realizar esta acción, simplemente debemos establecer una relación entre las 2 instancias mediante juju, y este, mediante las instrucciones contenidas en la charm, hará las modificaciones pertinentes en el archivo de configuración de Cloud Foundry. Así pués, vamos a ello:

~/charms$ ~/charms$ juju add-relation cloudfoundry-server cf-mongodb
2011-09-22 01:11:36,088 INFO Connecting to environment.
2011-09-22 01:11:37,997 INFO Added cf-server relation to all service units.
2011-09-22 01:11:37,997 INFO 'add_relation' command finished successfully

Consultamos ahora el estado y vemos que nos aparece la relación:

~/charms$ juju status
2011-09-22 01:11:51,639 INFO Connecting to environment.
machines:
  0: {dns-name: ec2-46-51-151-139.eu-west-1.compute.amazonaws.com, instance-id: i-af00e1e6}
  1: {dns-name: ec2-46-137-3-58.eu-west-1.compute.amazonaws.com, instance-id: i-0503e24c}
  2: {dns-name: ec2-79-125-44-111.eu-west-1.compute.amazonaws.com, instance-id: i-7b04e532}
services:
  cf-mongodb:
    charm: local:cf-mongodb-1
    relations: {cf-server: cloudfoundry-server, mongodb-cluster: cf-mongodb}
    units:
      cf-mongodb/0:
        machine: 2
        relations:
          cf-server: {state: up}
          mongodb-cluster: {state: up}
        state: started
  cloudfoundry-server:
    charm: local:cloudfoundry-server-26
    exposed: true
    relations: {cf-server: cf-mongodb}
    units:
      cloudfoundry-server/0:
        machine: 1
        open-ports: [80/tcp, 443/tcp, 4222/tcp]
        relations:
          cf-server: {state: up}
        state: started
2011-09-22 01:11:55,279 INFO 'status' command finished successfully

Vamos a comprobar si el servicio está levantado en Cloud Foundry mediante una conexión ssh de juju:

~/charms$ juju ssh 2
2011-09-22 01:12:17,200 INFO Connecting to environment.
2011-09-22 01:12:18,813 INFO Connecting to machine 2 at ec2-79-125-44-111.eu-west-1.compute.amazonaws.com
ubuntu@ip-10-58-121-108:~$ cd /opt/cloudfoundry-server/vcap/bin
ubuntu@ip-10-58-121-108:/opt/cloudfoundry-server/vcap/bin$ sudo ./vcap status
router              :    STOPPED
cloud_controller    :    STOPPED
dea                 :    STOPPED
health_manager      :    STOPPED
redis_gateway       :    STOPPED
redis_node          :    STOPPED
mysql_gateway       :    STOPPED
mysql_node          :    STOPPED
mongodb_gateway     :    RUNNING
mongodb_node        :    RUNNING
ubuntu@ip-10-58-121-108:/opt/cloudfoundry-server/vcap/bin$ exit
Connection to ec2-79-125-44-111.eu-west-1.compute.amazonaws.com closed.

Vemos como en esta instancia solamente se está ejecutando el servicio de MongoDB. Si viésemos que necesitamos otra instancia adicional de MongoDB, en este caso no haría falta ejecutar los comandos anteriores. Simplemente utilizando el comando add-unit nos crearía una nueva instancia que formaria parte de un cluster de MongoDb y con la relación con el servidor de Cloud Foundry creada por defecto:

~/charms$ juju add-unit cf-mongodb

Y hasta aquí llega el experimento. Un consejo antes de finalizar: si tenéis cualquier problema ejecutando alguno de los pasos anteriores y no sabeis que está pasando, podeis utilizar el comando debug-log para ver el log del servidor de juju e intentar determinar la causa del problema:

~/charms$ juju debug-log
2011-09-22 01:13:31,421 INFO Connecting to environment.
2011-09-22 01:13:32,588 INFO Enabling distributed debug log.
2011-09-22 01:13:32,696 INFO Tailing logs - Ctrl-C to stop.

Como último paso, como siempre, recordar que hay que finalizar el entorno. Utilizaremos para ello el comando destroy-environment:

~/charms$ juju destroy-environment
WARNING: this command will destroy the 'sample' environment (type: ec2).
This includes all machines, services, data, and other resources. Continue [y/N]yes
2011-09-22 01:14:02,900 INFO Destroying environment 'sample' (type: ec2)...
2011-09-22 01:14:04,644 INFO Waiting on 3 EC2 instances to transition to terminated state, this may take a while
2011-09-22 01:14:27,728 INFO 'destroy_environment' command finished successfully

Este comando debería eliminar también las instancias de Amazon EC2, pero por si acaso, no está de más que lo comproveis vosotros mismos en la consola web de Amazon EC2.

Bien, como hemos visto, esta herramienta promete bastante. Si bien está previsto que entre por defecto en la release 11.10 de Ubuntu del mes de Octubre de 2011, la versión liberada estará todavia un poco verde, por lo que no os la recomiendo para un entorno de producción. Mientras tanto, espero que disfrutéis experimentado con ella (probad alguna de las charms oficiales o crearos vosotros mismos alguna de prueba). Si alguien se anima, que deje sus impresiones en los comentarios de esta entrada.

Comments

Comment by Rogelio on 2012-03-06 19:59:48 +0000

Ferdy,

Google me trajo aqui cuando busque: “cloudfoundry ec2 ami”. Encuentro muy interesante tu blog, tenemos algunos intereses comunes.

Al igual que tú, en este momento estoy interesado en open source PaaS como CloudFoundry. Los conoci en la conferencia CloudExpo 2011 en Santa Clara, CA. Todavia no he tenido una oportunidad de conocer OpenStack.

Mi objetivo es utilizar la plataforma tanto para aplicaciones front-end web y batch jobs: spring batch y Hadoop. Me gusta CloudFoundry para usarlo en Amazon EC2 o en nuestras propias instalaciones.

Soy originario de Mexico, vivo en el sur de California, arriba el español!

Gracias por la informacion en tu blog, lo visitare nuevamente en un futuro.

Rogelio

Comment by ferdy on 2012-03-06 23:13:57 +0000

Bienvenido al blog Rogelio.

Comment by fernando Gutierrez on 2012-07-29 15:23:32 +0000

ferdy, no me ha quedado muy claro la verdadera funcionalidad del servicio de juju, pues tengo una instancia en amazon AWS gratis por un año y directamente y sin unstakar nada en una instancia, monte el servidor de ubuntu y configure un servidior web, corro una aplicación, pero esto no es del todo gratis, porque si me paso de uso y otras servicios me cobran, entonces cual es el papel con juju, si segun entiendo se conectara a Amazon y hay crear un usuario y pues siempre te cobraran ,si te pasas de que ofrecen. Me imagene que juju, servia para montar o conectarse a una cloud gratuita de ubuntu??.

saludos,

Comment by ferdy on 2012-08-05 22:19:21 +0000

Fernando, juju no proporciona ningún servicio de cloud (ni gratis ni de pago), es un servicio para poder orquestar la instalación de productos de una forma sencilla en entornos cloud. Por decirlo de otra manera, en vez de instalarte tu mismo el servidor web con la BBDD (etc), juju te proporciona una especia de recetas para simplificarte la instalación y posterior mantenimiento (escalado, actualización, …).

Comment by Pablo on 2012-11-03 07:36:10 +0000

Estoy intentando configurar un nube privada con Ubuntu Cloud y he tenido algunos problemas con la configuración del environment de juju, ¿hay alguna manera similar de configurar juju para una nube privada con Ubuntu Cloud Infraestructure utilizando MAAS?, es decir, ¿es similar el procedimiento de configuración de una nube privada como de una publica?.

Comment by Jamelgo on 2013-06-10 11:27:50 +0000

Esto está bastante desfasado.

Comment by Eduardo Peredo on 2013-12-03 20:29:36 +0000

Por lo que entiendo es una especie de consola para la administración de los “charms”, pero lo que me queda duda es si la administración es local o remota. Jugare con juju un rato para averiguarlo.

Publicado en General | Etiquetado

Cloud Foundry

La compra hace 2 años de SpringSource por parte de VMware me pilló por sorpresa, ya que no entendia que hacia un proveedor de soluciones de virtualización comprando una empresa cuyo negocio era un framework para construir aplicaciones Java. Los analistas rápidamente comenzaron a elocubrar, que si VMware queria ampliar mercado ya que la cotización en bolsa estava estancada, que si significava la muerte de SpringSource (lo mismo dijeron de Hyperic), … Pero pocos se imaginaron entonces que su intención era ofrecer una solución PaaS, a pesar de que en la nota de prensa lo decía muy claro y que a los pocos dias se anunciara Cloud Foundry Enterprise Java Cloud, una especie de PaaS para aplicaciones Java corriendo en AWS. Pasado un tiempo, parecia además que no tenian una estrategia muy clara, que primero creo una alianza con salesforce, que luego la alianza es también con Google. Pués bien, la semana pasada nos vuelven a sorprender y anuncian la creación de Cloud Foundry, un PaaS de código abierto.

¿En que se diferencia esta de otras soluciones como Google AppEngine, Heroku o Engine Yard? Pués basicamente en 2 aspectos:

  • El primero es que es la primera plataforma PaaS liberada como open-source y que no está ligada a ningún entorno cloud concreto. Puedes descargarte el codigo, modificarlo, e instalarlo donde quieras (en local, en AWS/RackSpace/OpenStack, bajo una infraestructura VMware, …).
  • Y la segunda es que no está limitada ni a un lenguaje ni a un framework concreto, sino que admite algunos de los lenguajes y frameworks más populares actualmente, como Spring for Java, Grails, Ruby on Rails, Sinatra for Ruby y Node.js, además de soportar 3 motores de BD diferentes, MongoDB, MySQL y Redis.

En definitiva, que es la primera plataforma PaaS completamente gratuita y que no nos liga a una tecnologia en concreto (vendor lock-in). Como esta estrategia es bastante disruptiva, seguramente dinamizará el mercado y pronto veremos otras soluciones parecidas.

El servico se ofrecerá en 4 sabores, 2 de los cuales ya estan disponibles:

  • CloudFoundry.com: en entorno PaaS operado por Vmware, completamente montado y listo para usar. De momento este servicio está en beta y, por tanto, se ofrece de forma gratuita, aunque en un futuro está previsto que este entorno sea explotado comercialmente.
  • CloudFoundry.org: la comunidad open-source donde podremos participar en su desarrollo, y/o descargar e instalar la plataforma donde te plazca
  • Cloud Foundry Micro Cloud: una imagen gratuita para VMware Fusion o Player y lista para ser usada en tu escritorio. La idea es que puedas desarrollar y probar en tu propia estación de trabajo y luego despliegues contra un entorno de producción que se comporta exactamente igual al de tu escritorio. El servicio estará disponible durante el 2do trimestre de este año.
  • Cloud Foundry for the Enterprise and Service Providers: una versión comercial para ser utilizada en un entorno empresarial o por parte de proveedores de servicios que quieran ofrecer por si mismos un PaaS.

Si no lo has hecho ya, te recomiendo que pruebes la primera opción y te apuntes a la beta de CloudFoundry.com. Las invitaciones para probar el servicio se estan entregando con cuentagotas, pero con un poco de suerte te llegará una en breve. Como yo ya he recibido la mia, os voy a explicar mis experimentos.

En primer lugar instalamos Ruby y RubyGems, ya que la interficie de comandos para interactuar con los servicios está basada en este lenguaje y viene empaquetada como una gema. Acto seguido procedemos a instalar vmc:

~$ sudo gem install vmc

Fetching: vmc-0.3.10.gem (100%)

Successfully installed vmc-0.3.10

1 gem installed

Installing ri documentation for vmc-0.3.10…

Installing RDoc documentation for vmc-0.3.10…

Una vez instalada correctamente, indicamos que servidor nos va a dar servicio. En este caso escogeremos el servidor beta de cloudfoundy.com (aunque nos podemos descargar e instalar nuestro propio servidor):

~$ vmc target api.cloudfoundry.com

Succesfully targeted to [http://api.cloudfoundry.com]

Ahora le indicamos al servidor nuestras credenciales:

~$ vmc login

Email: xxx@xxx.xxx

Password: *********

Successfully logged into [http://api.cloudfoundry.com]

Acto seguido nos creamos una aplicación de pruebas. Vamos con ejemplo sencillo usando Ruby y el framework de Sinatra:

~$ cd repos

~/repos$ mkdir test-frodenas

~/repos$ cd test-frodenas/

~/repos/test-frodenas$ vi test-frodenas.rb

require ‘sinatra’

get ‘/’ do

“Hello Ferdy from Cloud Foundry”

end

Y ahora vamos a desplegar nuestra aplicación. Dejaremos todas las opciones por defecto excepto el nombre de la aplicación:

~/repos/test-frodenas$ vmc push

Would you like to deploy from the current directory? [Yn]:

Application Name: test-frodenas

Application Deployed URL: ‘test-frodenas.cloudfoundry.com’?

Detected a Sinatra Application, is this correct? [Yn]:

Memory Reservation [Default:128M] (64M, 128M, 256M, 512M, 1G or 2G)

Creating Application: OK

Would you like to bind any services to ‘test-frodenas’? [yN]:

Uploading Application:

Checking for available resources: OK

Packing application: OK

Uploading (0K): OK

Push Status: OK

Staging Application: OK

Starting Application: OK

Comprobamos que la aplicación se ha levantado correctamente:

~/repos/test-frodenas$ vmc instances test-frodenas

+——-+———+——————–+

| Index | State | Start Time |

+——-+———+——————–+

| 0 | RUNNING | 04/21/2011 09:56PM |

+——-+———+——————–+

~/repos/test-frodenas$ vmc stats test-frodenas

+———-+————-+—————-+————–+————–+

| Instance | CPU (Cores) | Memory (limit) | Disk (limit) | Uptime |

+———-+————-+—————-+————–+————–+

| 0 | 0.1% (4) | 22.0M (128M) | 44.0K (2G) | 0d:0h:2m:50s |

+———-+————-+—————-+————–+————–+

Y solo nos queda acceder a la URL de la aplicación para comprobar que responde:

En caso de tener algún problema, podemos revisar los logs

~/repos/test-frodenas$ vmc logs test-frodenas

====> logs/stderr.log < ==== 172.30.8.253 - - [21/Apr/2011 19:57:27] “GET / HTTP/1.0” 200 30 0.0008 172.30.8.253 - - [21/Apr/2011 19:57:28] “GET / HTTP/1.0” 200 30 0.0003 172.30.8.253 - - [21/Apr/2011 19:57:28] “GET /favicon.ico HTTP/1.0” 404 18 0.0003 ====> logs/stdout.log < ==== == Sinatra/1.2.1 has taken the stage on 33248 for production with backup from Thin >> Thin web server (v1.2.11 codename Bat-Shit Crazy)

Maximum connections set to 1024

Listening on 0.0.0.0:33248, CTRL+C to stop

Vamos a explorar que otras opciones tenemos disponibles:

~/repos/test-frodenas$ vmc help

Usage: vmc [options] command [] [command_options]

Try ‘vmc help [command]’ or ‘vmc help options’ for more information.

Currently available vmc commands are:

Getting Started

target [url] Reports current target or sets a new target

login [email] [–email, –passwd] Login

info System and account information

Applications

apps List deployed applications

Application Creation

push [appname] Create, push, map, and start a new application

push [appname] –path Push application from specified path

push [appname] –url Set the url for the application

push [appname] –instances Set the expected number of instances

push [appname] –mem M Set the memory reservation for the application

push [appname] –no-start Do not auto-start the application

Application Operations

start Start the application

stop Stop the application

restart Restart the application

delete Delete the application

rename Rename the application

Application Updates

update [–path] Update the application bits

mem [memsize] Update the memory reservation for an application

map Register the application to the url

unmap Unregister the application from the url

instances Scale the application instances up or down

Application Information

crashes List recent application crashes

crashlogs Display log information for crashed applications

logs [–all] Display log information for the application

files [path] [–all] Display directory listing or file download for [path]

stats Display resource usage for the application

instances List application instances

Application Environment

env List application environment variables

env-add Add an environment variable to an application

env-del Delete an environment variable to an application

Services

services Lists of services available and provisioned

create-service [–name,–bind] Create a provisioned service

create-service Create a provisioned service and assign it

create-service Create a provisioned service and assign it , and bind to

delete-service [servicename] Delete a provisioned service

bind-service Bind a service to an application

unbind-service Unbind service from the application

clone-services Clone service bindings from

Administration

user Display user account information

passwd Change the password for the current user

logout Logs current user out of the target system

add-user [–email, –passwd] Register a new user (requires admin privileges)

delete-user Delete a user and all apps and services (requires admin privileges)

System

runtimes Display the supported runtimes of the target system

frameworks Display the recognized frameworks of the target system

Misc

aliases List aliases

alias <alias[=]command≶ Create an alias for a command

unalias Remove an alias

targets List known targets and associated authorization tokens

Help

help [command] Get general help or help on a specific command

help options Get help on available options

Así pues una de las opciones es ver que entornos de ejecución tenemos disponibles:

~/repos/test-frodenas$ vmc runtimes

+——–+————-+———–+

| Name | Description | Version |

+——–+————-+———–+

| node | Node.js | 0.4.5 |

| java | Java 6 | 1.6 |

| ruby18 | Ruby 1.8 | 1.8.7 |

| ruby19 | Ruby 1.9 | 1.9.2p180 |

+——–+————-+———–+

Los frameworks:

~/repos/test-frodenas$ vmc frameworks

+———+

| Name |

+———+

| spring |

| node |

| grails |

| sinatra |

| rails3 |

+———+

E incluso conocer los servicios que podemos utilizar:

~/repos/test-frodenas$ vmc services

============== System Services ==============

+———+———+——————————-+

| Service | Version | Description |

+———+———+——————————-+

| mysql | 5.1 | MySQL database service |

| mongodb | 1.8 | MongoDB NoSQL store |

| redis | 2.2 | Redis key-value store service |

+———+———+——————————-+

=========== Provisioned Services ============

Y ya solo nos queda parar o eliminar la aplicación para dejar el entorno limpio:

~/repos/test-frodenas$ vmc delete test-frodenas

Deleting application [test-frodenas]: OK

Si esto de trabajar con línea de comandos os parece *anticuado* y preferis utilizar un IDE, teneis a vuestro disposición la SpringSource Tool Suite, un editor completo para construir aplicaciones bajo Spring, o simplemente el plugin de CloudFoundry en el Marketplace de Eclipse. Os dejo algunas imagenes del plugin:

Tiene buena pinta ¿verdad? En un próximo post explicaré como instalar el entorno en tu propio servidor, ¿o alguien lo ha hecho ya y nos cuenta su experiencia?

Comments

Comment by ialcazar on 2011-05-03 14:48:44 +0000

Buena entrada. Me ha quedado bastante claro las diferentes soluciones que van a plantear. Sin duda tiene una pinta excelente. Hoy mismo he hecho una prueba con la invitación que me han enviado.

Espero el siguiente post sobre como montar un servidor propio que seguro que le sacamos mucha utilidad.

Un saludo

Publicado en General | Etiquetado