El diario de Ferdy

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 <num|delta> 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 <variable[=]value> 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 <src-app&ft; application to

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

Después de 10 semanas de desarrollo, la semana pasada se liberó la 3ra release pública de OpenStack, llamada Cactus. La lista completa de novedades en esta versión la podeis consultar en su wiki. Aquí os dejo algunas destacadas:

• En Nova:
  • Soporte a dos nuevas tecnologias de virtualización: LXC (Linux Containers) y VMWare/vSphere ESX / ESXi 4.1, Update 1.
  • En el caso de utilizar KVM, ahora podremos mover máquinas virtuales de un servidor físico a otro sin necesidad de pararlas.
  • Soporte a IPv6 independientemente del modo de network que utilizemos.
  • Aunque en modo experimental, la nueva versión 1.1 de la API habilita mecanismos de extensión. Esto facilitará a los desarrolladores que añadan sus propias extensiones a la API de una forma fácil y sin ensuciar el core de la API.
• En Swift:
  • Podemos servir contenido estatico directamente desde Swift. Además el servidor se comporta como un servidor web tradicional, buscando un archivo de index en primer lugar, devolviendo el listado de archivos existentes, y una página de error en caso de no encontrar un archivo (todo esto configurable).
  • Mejoras en el rendimiento al utilizar comunicación asincrona contra los backends.
  • Mejoras en la detección de errores al realizar una validación de checksum para cada acción de GET sobre un objeto. En caso de fallo, el sistema pone el objeto en quarentena e intenta replicarlo desde otro backend.
• En Glance:

  • Nueva interface por linea de comandos que nos permite interactuar con los servicios de Glance. El nuevo comando se llama glance y admite las siguientes opciones:

    Usage: glance [options] [args]

    Commands:

    help Output help for one of the commands below

    add Adds a new image to Glance

    update Updates an image’s metadata in Glance

    delete Deletes an image from Glance

    index Return brief information about images in Glance

    details Return detailed information about images in Glance

    show Show detailed information about an image in Glance

    clear Removes all images and metadata from Glance

  • Hasta ahora solo podíamos indicar el tipo de imagen (machine, kernel, ramdisk) y ahora se ha habilitado que podamos definir el formato (ami, ari, aki, vhd, vmdk, raw, qcow2, vdi) y el contenedor (ami, ari, aki, bare, ovf) de la imagen.

La semana que viene, aprovechando la conferencia de usuarios que se realizará en Santa Clara (con 400 usuarios registrados y 100 en lista de espera), se definirán las nuevas funcionalidades que van a incorporarse en las 2 próximas releases. Si habéis estado siguiendo regularmente la lista de distribución, os habréis dado cuenta que la lista de temas a discutir es bastante amplia, señal inequívoca que esta tecnología suscita bastante interés y que va apartandose cada vez más del vaporware del año pasado.

Yo por mi parte tengo previsto asistir a la conferencia. En la medida de lo posible iré actualizando este blog con lo más destacado que vaya pasando. Stay tuned!

Comments

Comment by Carlos on 2011-06-29 04:49:55 +0000

Muchas gracias por compartir tu conocimiento acerca de Cloud Computing

Mi nombres es Carlos y soy de Peru

Soy nuevo en este tema y por lo q estoy leyendo en tu Blog sabes bastante del tema.

No se si me puedes orientar en mi inicio acerca de este tema te lo agradecería mucho

Muchas Gracias

Existos

Hoy toca jugar con un nuevo servicio de Openstack, liberado hace muy poco tiempo, y que todavia se encuentra en fase “experimental”: Openstack Glance.

Podríamos definir a este proyecto como un servicio de gestión de imagenes de máquinas virtuales, con el objetivo de independizar el sistema de computación o almacenamiento de la gestión de las imagenes. De esta forma, podríamos llegar a instanciar imagenes que se encontrasen almacenadas en localizaciones diferentes (incluso en sistemas gestionados por terceros: ¿un proveedor especializado en imagenes?), o podríamos guardar copias de seguridad de instantáneas en otro centro de datos (por temas de DR), o podríamos almacenar nuestras imagenes en nuestro repositorio, y cambiar de proveedor de IaaS tantas veces como quisiésemos sin tener que estar ligado a ellos (vendor lockin), o podríamos … siempre y cuando los proveedores adopten Glance, claro está (que fácil es soñar 🙂 ). En definitiva, un proyecto con mucho potencial, aunque a expensas de que se convierta en un estándard y los proveedores lo quieran adoptar.

El proyecto se divide en 2 servicios:

• “glance-registry“, un servicio que nos permite registrar y descubrir imagenes de máquinas virtuales;
• “glance-api“, un servicio que nos permite almacenar y recuperar imagenes de máquinas virtuales en repositorios diversos. A dia de hoy los repositorios pueden ser: un almacen en Amazon S3, un almacen en Openstack Swift, un sistema de ficheros, o un almacen HTTP.

Pues bien, una vez definido el proyecto, detallemos las instrucciones de instalación. Como he dicho anteriormente, el proyecto todavia es experimental, con lo que nos encontraremos muchas cosas por pulir.

En primer lugar añadiremos el repositorio PPA de Launchpad donde se encuentra el proyecto y lo instalaremos con el metodo habitual:

~$ sudo add-apt-repository ppa:glance-core/trunk
~$ sudo apt-get update
~$ sudo apt-get install glance

Ahora debemos configurar los servicios. Desgraciadamente el paquete no lleva ningún ejemplo de archivo de configuración, por lo que lo tendremos que crearlo a mano:

~$ cd
~$ mkdir glance
~$ cd glance

A continuación copiad el siguiente texto en vuestro editor preferido y guardarlo como glance.conf. Para vuestra comodidad, lo podeis descargar de aquí (acordaos de renombrarlo como glance.conf):

[DEFAULT]
# Show more verbose log output (sets INFO log level output)
verbose = True
# Show debugging output in logs (sets DEBUG log level output)
debug = False
[app:glance-api]
paste.app_factory = glance.server:app_factory
# Directory that the Filesystem backend store
# writes image data to
filesystem_store_datadir=/var/lib/glance/images/
# Which backend store should Glance use by default is not specified
# in a request to add a new image to Glance? Default: 'file'
# Available choices are 'file', 'swift', and 's3'
default_store = file
# Address to bind the API server
bind_host = 0.0.0.0
# Port the bind the API server to
bind_port = 9292
# Address to find the registry server
registry_host = 0.0.0.0
# Port the registry server is listening on
registry_port = 9191
[app:glance-registry]
paste.app_factory = glance.registry.server:app_factory
# Address to bind the registry server
bind_host = 0.0.0.0
# Port the bind the registry server to
bind_port = 9191
# SQLAlchemy connection string for the reference implementation
# registry server. Any valid SQLAlchemy connection string is fine.
# See: http://www.sqlalchemy.org/docs/05/reference/sqlalchemy/connections.html#sqlalchemy.create_engine
sql_connection = sqlite:///glance.sqlite
# Period in seconds after which SQLAlchemy should reestablish its connection
# to the database.
#
# MySQL uses a default `wait_timeout` of 8 hours, after which it will drop
# idle connections. This can result in 'MySQL Gone Away' exceptions. If you
# notice this, you can lower this value to ensure that SQLAlchemy reconnects
# before MySQL can drop the connection.
sql_idle_timeout = 3600

El siguiente paso es arrancar los servicios, tanto el registry como el servidor api. Podemos arrancarlos de forma independiente, pero en este caso vamos a hacerlo de forma conjunta:

~/glance$ sudo glance-control all start

Si todo ha ido bien, el sistema nos dirá que ha arrancado los 2 servicios y que ha utilizado el archivo de configuración glance.conf:

Starting glance-api with /home/ferdy/glance/glance.conf
Starting glance-registry with /home/ferdy/glance/glance.conf

Para comprobar que todo está correcto, vamos a lanzar una consulta al servidor api. Para ello utilizaremos curl, aunque podemos realizar la misma prueba desde nuestro navegador:

~/glance$ curl http://localhost:9292

Y el servidor nos devolverá las imagenes registradas (en este caso, ninguna):

{"images": []}

Ahora vamos a almacenar una imagen de una máquina virtual. En primer lugar nos descargamos una imagen de Ubuntu (si ya tenéis una imagen, podeis saltaos este paso), y luego la almacenaremos y registraremos en el sistema:

~/glance$ wget http://uec-images.ubuntu.com/maverick/current/maverick-server-uec-amd64.tar.gz
~/glance$ glance-upload --type raw maverick-server-uec-amd64.tar.gz "Ubuntu Maverick 10.10"

Como respuesta recibiremos los metadatos de la imagen:

Stored image. Got identifier: {u'created_at': u'2011-03-04T23:47:58.145889',
 u'deleted': False,
 u'deleted_at': None,
 u'id': 1,
 u'is_public': True,
 u'location': u'file:///var/lib/glance/images/1',
 u'name': u'Ubuntu Maverick 10.10',
 u'properties': {},
 u'size': 187634470,
 u'status': u'active',
 u'type': u'raw',
 u'updated_at': None}

Ahora volvemos a realizar la consulta sobre el servidor api, y veremos que ya tenemos registrada nuestra imagen:

~/glance$ curl http://localhost:9292
{"images": [
   {"type": "raw",
    "id": 1,
    "name": "Ubuntu Maverick 10.10",
    "size": 187634470}
  ]
}

Incluso podemos pedirle que nos devuelva los metadatos completos de las imagenes registradas:

~/glance$ curl http://localhost:9292/images/detail
{"images": [
   {"status": "active",
    "name": "Ubuntu Maverick 10.10",
    "deleted": false,
    "created_at": "2011-03-04T23:47:58.145889",
    "updated_at": "2011-03-04T23:48:02.011583",
    "id": 1,
    "location": "file:///var/lib/glance/images/1",
    "is_public": true,
    "deleted_at": null,
    "type": "raw",
    "properties": {},
    "size": 187634470}
   ]
}

Y en el caso de que tengamos varias imagenes y queramos obtener los metadatos de una imagen en concreto, podemos utilizar el siguiente comando (aunque en este caso nos los devuelve en forma de headers de HTTP):

~/glance$ curl -I http://localhost:9292/images/1
HTTP/1.1 200 OK
Content-Type: text/html; charset=UTF-8
Content-Length: 0
X-Image-Meta-Type: raw
X-Image-Meta-Id: 1
X-Image-Meta-Deleted: False
X-Image-Meta-Location: file:///var/lib/glance/images/1
X-Image-Meta-Properties: {}
X-Image-Meta-Deleted_at: None
X-Image-Meta-Created_at: 2011-03-04T23:47:58.145889
X-Image-Meta-Size: 187634470
X-Image-Meta-Status: active
X-Image-Meta-Is_public: True
X-Image-Meta-Updated_at: 2011-03-04T23:48:02.011583
X-Image-Meta-Name: Ubuntu Maverick 10.10
Date: Fri, 04 Mar 2011 23:57:05 GMT

Y nada más, ya que de momento las opciones por línia de comando son muy limitadas. De igual forma, a dia de hoy no hay integración con el sistema de computación nova, por lo que tendremos que esperar a que un futuro no muy lejano se vayan ampliando las funcionalidades de este proyecto.

Y como siempre, antes de acabar, acordaos de apagar los servicios:

~/glance$ sudo glance-control all stop
Stopping glance-api  pid: 3518  signal: 15
Stopping glance-registry  pid: 3519  signal: 15

Comments

Comment by Diego Parrilla on 2011-03-05 09:38:55 +0000

Gran post. Glance está verde todavía, pero la posibilidad de tener un registros distribuidos de imágenes por la red es algo muy potente.

En el Roadmap futuro el registro también realizará conversiones entre diferentes formatos de disco virtual y de contenedor (ovf, vmx, ami…). En ese punto lo incorporaremos a la distro de StackOps.

Diego Parrilla

StackOps CEO

Comment by ferdy on 2011-03-06 00:52:44 +0000

Gracias Diego. Coincido contigo que este proyecto promete bastante, y creo además, que favorecerá que aparezcan negocios relacionados con el almacenamiento y provisioning de imagenes.

Comment by Armando on 2011-03-21 10:46:16 +0000

pero donde esta el paquete de instalación!!

eske tengo al profe aquí al lado i no para!!

Comment by ferdy on 2011-03-21 23:47:24 +0000

Armando, ejecuta:

~$ sudo add-apt-repository ppa:glance-core/trunk
~$ sudo apt-get update
~$ sudo apt-get install glance

Y te instalará el paquete.

Comment by Francisco on 2011-04-05 02:17:15 +0000

Que tal, esta muy bueno el blog, me ha ayudado mucho.

Podrían por favor colocar mas referencias a servidores que podemos cargar usando glance?

Estamos experimentando con esta aplicación, pero me gustaria probarla lo mas que sea posible.

Muchas gracias.

Comment by daniel on 2014-03-04 18:32:39 +0000

alguien me puede ayudar a subir imagenes ISO a openstack lo tengo instalado pero no he podido subir nada aun, la maquina de cirros funciona super bien

Como lo prometido es deuda, aquí teneis las instrucciones para manejar openstack desde una consola web en vez de la línea de comandos.

Lo primero que debéis hacer es instalar el sistema de control de versiones bazaar, ya que el dashboard de Openstack todavia no está disponible en forma de paquete:

~$ sudo apt-get install bzr

A continuación vamos a instalar el módulo que contiene la interfaz para actuar con el controlador de openstack (django-nova):

~$ mkdir src
~$ cd src
~/src$ mkdir django-nova
~/src$ cd django-nova
~/src/django-nova$ bzr init-repo .
~/src/django-nova$ bzr branch lp:django-nova/trunk

Ahora instalaremos el módulo que contiene el dashboard (openstack-dashboard). Este módulo es una referencia que ha de servir de ejemplo para que otras empresas creen sus propios dashboards, y a dia de hoy no esta claro que en futuro se convierta en oficial, aunque a efectos de este tutorial ya nos vale:

~/src/django-nova$ cd ..
~/src$ mkdir openstack-dashboard
~/src$ cd openstack-dashboard
~/src/openstack-dashboard$ bzr init-repo .
~/src/openstack-dashboard$ bzr branch lp:openstack-dashboard trunk

Antes de arrancar la consola, debemos ajustar algunos parametros. En primer lugar creamos y editamos el archivo de configuración (local_settings.py):

~/src/openstack-dashboard$ cd trunk/local
~/src/openstack-dashboard/trunk/local$ cp local_settings.py.example local_settings.py
~/src/openstack-dashboard/trunk/local$ vi local_settings.py

En este archivo debemos especificar los siguientes parámetros:

• NOVA_ACCESS_KEY: debemos especificar el contenido de la variable EC2_ACCESS_KEY que encontrareis en el archivo novarc
• NOVA_SECRET_KEY: debemos especificar el contenido de la variable EC2_SECRET_KEY que encontrareis en el archivo novarc
• NOVA_ADMIN_USER: debemos especificar el contenido de la variable NOVA_USERNAME que encontrareis en el archivo novarc
• NOVA_PROJECT: debemos especificar el nombre de un proyecto sobre el que el usuario indicado anteriormente tengo permisos

Ahora ya podemos seguir con el proceso de configuración:

~/src/openstack-dashboard/trunk/local$ apt-get install -y python-setuptools
~/src/openstack-dashboard/trunk/local$ cd ..
~/src/openstack-dashboard/trunk$ sudo easy_install virtualenv
~/src/openstack-dashboard/trunk$ python tools/install_venv.py ../../django-nova/trunk
~/src/openstack-dashboard/trunk$ tools/with_venv.sh dashboard/manage.py syncdb

En este punto, el proceso de instalación nos pedirá si queremos crear un usuario administrador de la consola. Indicamos que si queremos crearlo, y nos preguntará por un nombre de usuario, nuestro email y una contraseña para el usuario a crear:

You just installed Django's auth system, which means you don't have any superusers defined.
Would you like to create one now? (yes/no): yes
Username (Leave blank to use 'ferdy'):
E-mail address: YOUR_EMAIL
Password: PASSWORD
Password (again): PASSWORD

Una vez instalados y configurados todos los módulos, vamos a arrancar el servidor web:

~/src/openstack-dashboard/trunk$ tools/with_venv.sh dashboard/manage.py runserver 0.0.0.0:8000

Y ahora nos conectaremos al dashboard utilizando la URL http://localhost:8000. Lo primero que nos aparecerá será la pantalla de login, donde introduciremos el usuario y contraseña que hemos creado anteriormente:

Una vez conectados nos aparece una pantalla con la relación de nuestros proyectos:

Si consultamos “Miproyecto” os aparece el dashboard con las acciones que podeis realizar sobre el:

En primer lugar vamos a consultar las imagenes publicadas. Pulsamos sobre el enlace de “Images” situado en el menu de la izquierda y nos aparece la relación de imagenes disponibles:

Si pulsamos en el identificador de la imagen emi (campo ID), nos aparecen los detalles de la imagen:

Ahora vamos a instanciarla. Pulsamos sobre “Launch“, y nos aparece una pantalla donde podremos indicar las características de la instancia que queremos arrancar. Escogemos que solo queremos arrancar 1 instancia, indicamos el tipo de instancia (m1.small – Memory: 2048MB, VCPUS: 1) y le asignamos la credencial miclave:

Ya tenemos la instancia lanzada. La aplicación nos dirigirá a la pantalla de instancias donde podreís ver todas las instancias junto con el estado de las mismas (campo State) y la dirección IP asignada:

Si pulsamos en el identificador de una instancia (camp ID), nos aparecen los detalles de la instancia:

Mientras esperamos a que la instancia esté disponible (estado running), nos vamos a ver las credenciales disponibles. Pulsamos sobre el enlace de Keys situado en el menu de la izquierda y nos aparece la relación de claves disponibles:

Si pulsamos sobre el enlace de Volumes en el menu de la izquierda, podremos ver la relación de volumenes de almacenamiento disponibles:

Ahora volvemos a las instancias para comprobar si ya esta disponible:

En caso de que así sea, podeis abrir una sesión de terminal y conectaros via SSH a vuestra instancia. Y como siempre, una vez os hayáis cansado de jugar, no os olvideis de apagar la instancia pulsando sobre “Terminate“:

Para próximos posts, intentaré explicar como configurar la gestión de almacenamiento.

Comments

Comment by rmacian on 2011-04-28 17:45:11 +0000

Hola,

Primero de todos felicitarte por la cantidad de contenido por la brevedad de proyecto.

He seguido la entrada de instalación y este y cuando ya estoy intentando arrancar la instancia se me queda en scheduling. Mirando los logs veo que aparece un error

Error: libvirt version is too old (does not support getVersion). Los paquetes instalados son los propios de launchpad excepto uno

# dpkg -l | grep libvirt

ii libvirt-bin 0.8.8-1ubuntu3~ppalucid1 the programs for the libvirt library

ii libvirt0 0.8.8-1ubuntu3~ppalucid1 library for interfacing with different virtu

ii python-libvirt 0.7.5-5ubuntu27.9 libvirt Python bindings

Alguna idea ?

Comment by ferdy on 2011-04-29 03:44:27 +0000

Hola, el problema lo tienes precisamente en el paquete del binding de Python para libvirt (python-libvirt), ya que, tal como dice el error, la version que tienes es obsoleta. Esta comprobación se introdujo en nova hace 1 mes aprox .

Has probado a actualizar solo este paquete?

Comment by chetan on 2011-06-24 15:33:25 +0000

Hello ,

We testing Openstack with single node environment , alll is going well , however having problem installing openstack-dashboard end up with error :

Installing custom SQL …

Installing indexes …

No fixtures found.

next we able to run WebUserInterFace however no way to login :shows erro 1110 [connection refused].

my local_setttng.py :

import os

DEBUG = True

TEMPLATE_DEBUG = DEBUG

PROD = False

USE_SSL = False

LOCAL_PATH = os.path.dirname(os.path.abspath(\__file__))

DATABASES = {

‘default’: {

‘ENGINE’: ‘django.db.backends.sqlite3’,

‘NAME’: os.path.join(LOCAL_PATH, ‘dashboard_openstack.sqlite3’),

},

}

CACHE_BACKEND = ‘dummy://’

# Send email to the console by default

EMAIL_BACKEND = ‘django.core.mail.backends.console.EmailBackend’

# Or send them to /dev/null

#EMAIL_BACKEND = ‘django.core.mail.backends.dummy.EmailBackend’

# django-mailer uses a different settings attribute

MAILER_EMAIL_BACKEND = EMAIL_BACKEND

EMAIL_HOST = ‘localhost’

EMAIL_PORT = 25

# Configure these for your outgoing email host

# EMAIL_HOST = ‘smtp.my-company.com’

# EMAIL_PORT = 25

# EMAIL_HOST_USER = ‘djangomail’

# EMAIL_HOST_PASSWORD = ‘top-secret!’

OPENSTACK_ADMIN_TOKEN = “999888777666”

OPENSTACK_KEYSTONE_URL = “http://localhost:5000/v2.0/”

TOTAL_CLOUD_RAM_GB = 30

NOVA_DEFAULT_ENDPOINT = ‘http://localhost:8773/services/Cloud’

NOVA_DEFAULT_REGION = ‘nova’

NOVA_ACCESS_KEY = ‘261c1aac-398c-4f5d-9b1e-0b6a58d8d90d:nubeblog’

NOVA_SECRET_KEY = ‘8dec5030-11a2-4569-b7a9-8ffbcc7f2c5d’

NOVA_ADMIN_USER = ‘diego’

NOVA_PROJECT = ‘nubelog’

Comment by ferdy on 2011-06-25 14:57:43 +0000

Chetan, I suggest you to open a ticket at the Dashboard for OpensStack Launchpad site.

He estado jugando estos últimos dias con OpenStack, una plataforma IaaS de código abierto que nos permite la creación de recursos de computación (OpenStack Nova) y almacenamiento (OpenStack Swift) en la nube. El proyecto, liderado originalmente por Rackspace y la Nasa, y a los que se les han añadido últimamente una importante comunidad de desarrolladores, fue creado hace tan solo unos pocos meses (Diego nos explica en su blog la historia de este proyecto), y aunque a dia de hoy sigue estando inmaduro, la última versión liberada (Bexar) ya comienza a ser “usable”.

Si os animais a probarla, os detallo a continuación los pasos que hay que seguir para su instalación, aunque podeis encontrar mucha más información en la wiki o en los manuales del proyecto.

En primer lugar vamos a añadir el repositorio PPA de Launchpad. En mi caso, como me gusta jugar con fuego, voy a utilizar el repositorio donde se encuentran los paquetes “bleeding edge”, es decir, el repositorio donde se encuentran los últimos commits que se hayan hecho sobre el tronco:

~$ sudo apt-get install python-software-properties
~$ sudo add-apt-repository ppa:nova-core/trunk
~$ sudo apt-get update

(en caso de que querais utilizar la última versión estable, cambiad el ppa:nova-core/trunk por ppa:nova-core/release)

A continuación instalamos el paquete de nova junto con sus dependencias (es importante instalar primero el servidor de RabbitMQ):

~$ sudo apt-get install rabbitmq-server
~$ sudo apt-get install nova-common nova-doc nova-api nova-network nova-objectstore nova-scheduler nova-compute
~$ sudo apt-get install euca2ools unzip

El siguiente paso es configurar el paquete. En general, podeis dejar los ajustes por defecto (que se encuentran en /etc/nova/nova.conf), aunque en mi caso he tenido que realizar una pequeña modificación: si ejecutais el software en una máquina virtual (por ejemplo VirtualBox o Parallels), será necesario añadir al archivo nova.conf la siguiente línia:

--libvirt_type=qemu

Antes de comenzar a jugar, vamos a reiniciar por si acaso el servicio libvirt (la interfaz para interactuar con diferentes tecnologías de virtualización):

~$ sudo service libvirt-bin restart

Acto seguido configuramos una red para nuestras máquinas virtuales. En este caso utilizaremos la dirección CIDR 10.0.0.0/8, sobre la que crearemos 1 red virtual con 64 direcciones IP:

~$ sudo nova-manage network create 10.0.0.0/8 1 64

Ahora nos creamos un usuario (ferdy) y un proyecto (miproyecto), nos descargaremos las credenciales (que vendrán empaquetadas en el archivo nova.zip) y cargaremos en nuestro profile de usuario las variables necesarias para interactuar con el proyecto:

~$ cd
~$ mkdir proyecto-nova
~$ cd proyecto-nova
~/proyecto-nova$ sudo nova-manage user admin ferdy
~/proyecto-nova$ sudo nova-manage project create miproyecto ferdy
~/proyecto-nova$ sudo nova-manage project zipfile miproyecto ferdy
~/proyecto-nova$ unzip nova.zip
~/proyecto-nova$ . novarc

Llegados a este punto ya tenemos todo configurado. Es hora de descargarse una imagen y publicarla en un bucket (por ejemplo: mibucket). En este caso vamos a utilizar una imagen de Ubuntu Server de 64bits (en el repositorio de Ubuntu podeis encontrar más imagenes):

~/proyecto-nova$ wget http://uec-images.ubuntu.com/maverick/current/maverick-server-uec-amd64.tar.gz
~/proyecto-nova$ uec-publish-tarball maverick-server-uec-amd64.tar.gz mibucket

Como resultado nos informará del identificador de imagen (emi), el identificador de kernel (eki) y el identificador de ramdisk (eri):

emi="ami-dqay5v06"; eri="none"; eki="ami-7l5uc5w8";

Es importante recordar el identificador de imagen, ya que será el que utilizemos en la creación de instancias, pero si por cualquier razón lo olvidamos, con el comando euca-describe-images podremos ver las imagenes publicadas junto con su emi:

IMAGE <b>ami-dqay5v06</b> mibucket/maverick-server-uec-amd64.img.manifest.xml	miproyecto  available	private		x86_64	machine	ami-7l5uc5w8
IMAGE ami-7l5uc5w8 mibucket/maverick-server-uec-amd64-vmlinuz-virtual.manifest.xml miproyecto	available	private		x86_64	kernel	true

A continuación nos crearemos un par de claves (miclave) para poder acceder a nuestras máquinas virtuales:

~/proyecto-nova$ euca-add-keypair miclave > miclave.priv
~/proyecto-nova$ chmod 0600 miclave.priv

Y crearemos una regla en el grupo de seguridad por defecto para autorizar el trafico entrante por el puerto 22 (SSH):

~/proyecto-nova$ euca-authorize default -P tcp -p 22 -s 0.0.0.0/0

Llegados a este punto ya podemos instanciar la máquina virtual. En este caso utilizaremos una instancia de tipo pequeño (m1.tiny – Memory: 512MB, VCPUS: 1) y le asignaremos la credencial creada anteriormente (miclave). Acordaos de cambiar el identificador de la imagen por el vuestro:

~/proyecto-nova$ euca-run-instances <i>ami-dqay5v06</i> -k miclave -t m1.tiny

Que como resultado nos informará del identificador de instancia (i-nnnnnnnn) y el estado (en este caso scheduling):

RESERVATION	r-6nwfk587 miproyecto	default
INSTANCE	<b>i-00000001</b> ami-dqay5v06 <b>scheduling</b>	miclave (miproyecto, None) 0	 m1.tiny	2011-03-02T23:17:32Z	unknown zone

Ahora vamos a esperar a que la instancia arranque. Con el comando euca-describe-instances podemos conocer en que estado se encuentra y si se le ha asignado ya una dirección IP:

RESERVATION	r-6nwfk587 miproyecto	default
INSTANCE	i-00000001 ami-dqay5v06	<b>10.0.0.3</b>	10.0.0.3	<b>launching</b>	miclave (miproyecto, ubuntu)	0	m1.tiny	2011-03-02T23:17:32Z	nova

Una vez el estado pase a running:

RESERVATION	r-6nwfk587 miproyecto	default
INSTANCE	i-00000001 ami-dqay5v06	10.0.0.3	10.0.0.3	<b>running</b>	miclave (miproyecto, ubuntu)	0	m1.tiny	2011-03-02T23:17:32Z	nova

es hora de conectarnos a nuestra instancia. Para ello utilizaremos un SSH con las credenciales obtenidas anteriormente y la IP asignada a nuestra instancia:

~/proyecto-nova$ ssh -i miclave.priv root@<i>10.0.0.3</i>

Y finalmente, cuando os hayáis cansado de jugar, acordaos de apagar la instancia con el comando:

~/proyecto-nova$ euca-terminate-instances <i>i-00000001</i>

En el próximo post explicaré como manejar estas instancias desde una consola web en vez de la línea de comandos.

Comments

Comment by Carlos on 2011-06-29 00:17:42 +0000

Muy bueno tu blog

Mi nombre es Carlos me gustaria saber mas sobre este tema y poder implemetar Open Stack

No se si me puedes recomendar alguna pagina o libro en internet para poder informarme mejor muchas gracias y sigue adelante

Comment by ferdy on 2011-06-29 01:22:04 +0000

Carlos, la página de documentación de OpenStack es un buen lugar de inicio. Y si no quieres complicarte la vida instalando OpenStack manualmente, puedes utilizar la distro de StackOps.

Comment by Hernan Nina on 2011-10-03 04:15:16 +0000

Hola Ferdy,

Gracias por el Blog sobre OpenStack.

Que diferencia existe OpenStack con Adobe EC2

Saludos Gracias