martes, 22 de abril de 2014

Part 1 - Testing your Datastore models with Google Cloud Platform Interactive Console

This is the first in a series of short articles that will cover a way of testing Google's Datastore models using the Interactive Console present in the dev-server included with Google Cloud SDK. Also we'll be seeing a good way (at least for us)  to create and load large amount of testing data for our models so you can work with datasets similar to the ones you're going to use in production. Finally we'll see how easy is to integrate this tools into a simple app using Ferris MVC.

Note. I'm using Google Cloud Python SDK version 1.9.3, on Ubuntu Linux 12.04, 64 bits. As I want this short intro to grow up in time I'll be using the excellent MVC framework "Ferris" from CloudSherpas from the beginning. The IDE I'm using is EMACS 23.3.  

1. Creating your first "Person" Datastore model 

1. Create a blank project 

First you need to create an empty project to start with. To do so just make a copy of new_project template included with  Google Cloud SDK.

 cp -R new_project_template my_new_project   

2. Install Ferris MVC

Download Ferris MVC from the official site:

 wget -c  

Unzip the package in your "my_new_project" folder or directory

 $ unzip cloudsherpas-ferris-framework-*.zip -d .   
 $ cd cloudsherpas-ferris-framework-*   
 $ mv * ../   
 $ rm -fr cloudsherpas-ferris-framework-*  

Edit your and save your app.yaml file so you know is your project

 application: my-new-app-id                                                
 version: 1.0  

Start your app for the first time just to check everything is ok

To start your app for the first time just launch the dev server  like this.

 $ my_new_project   

Then open your browser at http://localhost:8080 (local app URL) and to http://localhost:8000 (local admin console).

3. Creating your first Datastore Model 

For the purposes of this article we'll create a simple two-properties model for the Kind "Person". This model includes the "name" of the person an also a multi-value text field for saving tags related to this person. Following the directory structure we'd just created by copying Ferris to our project, we need to create our model under  the folder app/models like this: (you can use the text editor or IDE of your choice).

 # app/models/  
 from ferris import BasicModel                                                     
 from google.appengine.ext import ndb   

 class Person(BasicModel):                         
   NDB Model for Person                                                
   name: StringProperty - Required                                
   skills: StringProperty(repeated=True) - Optional                                            
  name = ndb.StringProperty(required=True)        
  tags = ndb.StringProperty(repeated=True)   

Once you create your model you can restart your development server (CTRL+C) and my_new_project again.

Using the interactive console to test your model 

Google's Cloud SDK contains a very nice administration app that includes an interactive console to test your code or data for different purposes. In this case, we are going to use the interactive console to test our simple Person model by creating new entries and do some queries against it.

Mass creation of test entries with sample data 

One of the things that I find most annoying when testing some app is the lack of real or at least close to real data. A lot of problems (think of performance, scalability, validation and data modeling problems just to name a few),  can be tracked down during early stages of development if just one can count on an adequate dataset to work with.  Even for our simple model is good to have a decent size dataset to play with queries and insertions over tags or names in it.

Although the developement server included with the GC SDK appears to have utilities to mass insert data into Google's Datastore, I could not found a good resource or reference to execute that procedure when one is using NDB (the official doc, mentions DB but not NDB implementation).  In this scenario i'd remembered excelent Perl::Maker package and decided to search for an equivalent for Python. What i'd found was "Faker", a very simple yet powerful tool for creating user data: names, surnames and general paragraphs (lorem ipsum), so, what we are going to do right now is to add Faker to our project and start using the Interactive Console to do some tests.

1. Download Faker from official github site

2. Unzip Faker inside your project folder 

 $ cd my_new_project  
 $ unzip -d .   
 $ mv faker-master faker   

3. Creating mass data from Interactive Console 

Start your development server (if you didn't already) 

 $ my_new_project   

Launch de Admin Console

Point your browser to http://localhost:8000 then click on "Interactive Console" from the left menu bar 

Once there clear the default code in the text box. 
Finally copy and paste the following python code in the text box:

from app.models.person import Person 
from google.appengine.ext import  ndb
from random import randrange
from faker import Faker                                                
# a new instance of Faker                                                                                                                 
fake = Faker()

# a list wich contains fake tags to randomize over                                                                                        
ftags = (['engineering','custom-making','writing','electrician',
ftags_new = []                                                              
for i in range(1,NENTRIES):  
# create a new name                                               
 fname =
# randomize over tags list size and items to create the person's tags            
# randomize the number of tags
 for j in range(0,randrange(9)):
# randomize tags                                            
 print ftags_new                                                            
 person = Person(name=fname, tags=ftags_new)                                
 del ftags_new[:]
# save the new person on datastore everytime                                     

After executing the code above you should see a printed list of all tags list random assigned to each new entry.

['interiors-design', 'writing', 'electrician', 'dancing', 'interiors-design', 'drinking', 'smiling', 'interiors-design']
['electrician', 'writing']
['interiors-design', 'interiors-design', 'dancing', 'smiling', 'smiling']
['drifting', 'electrician', 'dancing', 'interiors-design', 'dancing', 'drinking']
['electrician', 'writing', 'drifting', 'writing', 'writing', 'drinking', 'interiors-design', 'engineering']
['interiors-design', 'interiors-design']
['drinking', 'drinking', 'drinking', 'engineering']

Now you can go to "Datastore Viewer" in the console to see the entries you'd just created. In this case you'd created just 10 entries, but rhe number can be higher.


In the next part we'll be covering querying against Datastore and the repeated attributes and also some very nice options for timing your entries creation process.


[1] Google's App Engine Official Documentation
[2] Ferris MVC
[3] Faker -

jueves, 6 de febrero de 2014

Running Google Cloud's "gcutil" behind a socks proxy with tsocks and ssh tunnel

Suppose you have to use google's cloud platform "gcutil" tool to connect to one or more nodes on a project hosted on google cloud platform but you don't have a direct internet connection although  you still can set up a ssh connection to a gateway who has the ability to connect directly to Internet.

Given this scenario you can follow this simple steps to accomplish your task:

1. Open a terminal and ssh to your gateway using the following command

ssh -D 1080 user@gateway_ip

2. Install tsocks package (Debian/Ubuntu or RedHat/CentOS) 

sudo apt-get install tsocks 


yum install tsocks 

3.  Edit your tsocks.conf file like this:

# your local network/mask
local =
# local =

# Paths
# For this example this machine needs to access as 
# well as port 80 on the network through
# the socks 5 server at (if this machines hostname was 
# "" we could also specify that, unless --disable-hostnames
# was specified to ./configure).

path {
reaches =
reaches =
server = localhost
server_type = 5
default_user = delius
default_pass = hello

# Default server
# For connections that aren't to the local subnets or to
# the server at should be used (again, hostnames could be used
# too, see note above)
# your local ssh-socks server
server =
# Server type defaults to 4 so we need to specify it as 5 for this one
server_type = 5
# The port defaults to 1080 but I've stated it here for clarity 
# the port you'd just select in the previous ssh connection
server_port = 1080 

4. Launch gcutil 

tsocks ./gcutil node-id 

And that's all. 

viernes, 27 de septiembre de 2013

Feliz cumpleaños GNU !

[ Celebrate 30 years of GNU! ]

miércoles, 3 de julio de 2013

Liferay Portal sobre Google Compute Engine

Después de haber usado Linode por un tiempo hemos encontrado que una alternativa viable y económicamente flexible es ejecutar Liferay Portal sobre Google Compute Engine . Este último ofrece un entorno completo de ejecución, simple de configurar y cómodo en términos de administración y costos, con la posibilidad de usar diferentes distribuciones de Linux así como la posibilidad de enlazarnos a otros servicios en cloud de google como CloudStorage y CloudSQL u otros servicios externos. 

Procedimiento de instalación y configuración de Liferay Portal en Google Compute Engine(GCE).

Los pasos para tener una instancia de Liferay Portal corriendo sobre Google Compute Engine se describen a continuación. Se asume en este caso que el usuario ya tiene una cuenta activa de en Google Cloud y que ha activado el billing para el proyecto. 

Paso 1 - Crear una instancia de compute engine 

  1. Haga click en el proyecto creado con billling activo (ej, miempresa-gce-demo-001)
  2. Ingrese los datos de solicitados: nombre de la instancia, descripción, tags y metadatos (son útiles para identificar el uso o cliente de la instancia etc). Seleccione además un sistema operativo para la instancia ( Puede seleccionar Debian7 por ejemplo) teniendo cuidado de no usar uno que esté marcado como "deprecated".  Finalmente haga click en el botón "Create". 
  3. Espere unos segundos hasta que la instancia esté activa (aparecerá en el listado). Cuando esté lista haga click sobre el nombre de la instancia para ver los datos en detalle. Tome nota de la dirección IP pública asignada, el ID del proyecto (project-id)(esquina superior izquierda) y ID de la instancia (instance-id).

Paso 2 - Conectarse a la instancia vía SSH 

  • Descargue e instale la aplicación "gcutil". Esta permitirá el control y acceso a las instancias de GCE desde la consola del sistema operativo. La herramienta se puede descargar de: gcutil site.
  • Una vez instalada la instancia ejecute el siguiente comando para conectarse por primera vez:  
         gcutil ssh --project=proyect_id instance-id

          La primera vez seleccione la contraseña deseada y el programa se encargará de dejar         
          la autorización creada para el cliente ssh la próxima vez. 

          Nota. Este proceso puede tardar aproximadamente 5 minutos la primera vez, así que   
          tenga paciencia. 
  • Cuando haya ingresado quedará en un shell estándar de Linux que podrá usar normalmente.

Paso 3 - Configuración del entorno de usuario 

Una vez en el shell de nuestra instancia de GCE se recomienda crear un entorno de trabajo estándar sobre el cual podamos trabajar fácilmente  a futuro. Nuestra recomendación es usar la siguiente:

mkdir app src tmp 
chmod 1777 

apps: binarios (ej, jboss + liferay) 
src: fuentes usadas para la instalación de paquetes propios o de terceras partes
tmp: carpeta de temporales local en caso de que se tengan múltiples instancias de servidor de aplicaciones y se quieran evitar conflictos con acceso a temporales. 

Paso 4 - Instalación de JDK 7 

El siguiente paso es instalar el JDK. Para el caso se instalará el JDK7. Puede instalarlo usando el siguiente comando:

sudo apt-get install openjdk-7-jdk

Una vez finalice verifique que está correctamente instalado y disponible en el PATH usando:

java -version 

Si tiene problemas verifique la instalación y repita el proceso. 

Paso 5 - Descargar Liferay Portal CE a la instancia 

  • Desde el sitio oficial de Liferay Portal descargue la versión comunitaria o un demo de la versión Enterprise (es la recomendada para aplicaciones en producción). 
  • Para descargarla a la instancia puede usar wget (copiando y pegando el enlace) o descargarla a su máquina y transferirla luego. 
  • Copie el paquete descargado en la carpeta src creada previamente. 
  • Descomprima el paquete con destino a la carpeta tmp: 
          tar xzf liferay-portal-ce-**.tar.gz -C  ~/apps
  • Vaya a la carpeta apps y cree un link simbólico a la carpeta de instalación de Liferay
    ln -s liferay-portal-ce-** liferay61     
         Nota. Este paso no es necesario pero ahorrará tiempo durante la administración   

Paso 7 - Configuración básica e inicio del portal por primera vez 

Dado que el portal por defecto solo escucha en localhost es necesario ajustar la configuración  para que el conector web del servidor de aplicaciones se asocie a todas las interfaces disponibles, para el caso se asume que el bundle de liferay que se está usando es el que incluye JbossAS.  Una forma simple de hacerlo es crear un script del shell adicional que envíe el parámetro de binding al script de arranque del dominio así:

cd ~/apps/liferay61/jboss*/bin
echo "#!/bin/bash" >> 
echo "./ -b 1> ../standalone/log/ \\
       mi-liferay.log &" >> 
chmod +x 
./ & 

Puede verificar el inicio del portal usando tail así:

tail -f ~/apps/liferay61/jboss*/standalone/log/mi-liferay.log 

Una vez haya iniciado puede continuar con el paso siguiente. 

Nota. Se incluye la redirección para poner el portal en background y que no se caiga si cerramos la consola. 

Paso 8 - Configuración de firewall para acceso al servicio 

El portal escucha por defecto en el puerto 8080 por lo que será necesario adicionar una regla al firewall de la instancia para admitir conexiones a dicho puerto. Para el caso se asume que es un servicio público pero bien podría estar limitado a una IP o red específica. 

Para agregar la regla vaya al panel de control de Google Cloud, haga click en el proyecto que crearon, luego click en el menú lateral "Networks". En la sección "Firewalls" seleccione "Create new". 

Una vez allí ponga un nombre a la regla, ej "liferay", una descripción, en la sección de "Protocols & ports" escriba "tcp:8080". Finalmente de click en "Create".

Paso Final. Conectarse a la instancia 

Una vez creada la regla de firewall ya podrá conectarse desde el navegador usando la IP pública de la instancia y apuntando al puerto 8080. El primer paso será configurar Liferay para el inicio (el proceso es muy sencillo y no vale la pena entrar en detalles aquí). Y eso es todo!. El proceso completo puede tardar menos de treinta minutos lo que nos da un nivel de maniobra impresionante a la hora de configurar sitios de prueba, demos para clientes e incluso nuevos sitios. 

Notas finales y recomendaciones 

  • Si la instancia se reinicia o inactiva los datos se perderán. Es importante crear discos con almacenamiento permanente que se monten al inicio de la instancia(s) y que contengan el portal y el JDK aislados. Esto con el fin de reducir los tiempos. 
  • Si se requiere el uso de múltiples instancias con propósito específico vale la pena usar una herramienta de gestión que facilite el trabajo como  RightScale (
  • Si se requiere el uso de balanceadores puede utilizarse nginx ( ) en un nodo de balaceo y un grupo de nodos adicionales "atrás". 
  • Si se requiere el uso de bases de datos externas lo mejor es usar Google Cloud SQL que es enganchable directamente y ofrece driver jdbc compatible con el servidor de aplicaciones (tomcat, jboss etc). 

domingo, 3 de julio de 2011

Nginx, JBoss 5.1 y Liferay Portal 6

Esta guía contiene los pasos necesarios para configurar el servidor
web Nginx como un proxy reverso y balanceador de cargas para Liferay
Porta 6 sobre JBoss 5.1.
grupodot 2011

jueves, 1 de julio de 2010

Conexión de Liferay Portal con Domain Controller

Pasos previos:

1. Instalar windows 2003 server
2. Configurar el servidor como el controlador de un nuevo dominio
inicio / ejecutar / dcpromo

Configuración de Liferay

1. Panel de control / configuración / autenticación
2. Autenticar por screenname
3. Activar LDAP . seleccionar Active Directory
4. Probar la conexión

IP del servidor
Usuario: Ej, Administrador@DCLOCAL
Clave: ***

Modificar el filtro de búsqueda de usuarios a :


Eso es todo !

Pasos para la configuración de Liferay Portal con Active Directory - Microsoft

Paso 1 . Como administrador entrar por el panel de control a "Configuración" luego a "Autentificación". Seleccionar la pestaña "LDAP", luego seleccionar "Habilitado", luego seleccionar "Microsoft Active Directory"
Allí poner los datos como se muestra a continuación:

Paso 2. Probar la conexión con el AD usando la opción "Probar la conexión con LDAP". Si es exitosa seguir con paso 3, sino revisar las credenciales y demás datos y volver a probar.

Paso 3. Configurar los datos de usuario como se muestra a continuación

Paso 4. Probar usuarios usando "Probar la configuración de usuarios LDAP"

Paso 5. Probar grupos usando ""Probar la configuración de grupos LDAP"

Finalmente verificar que la autenticación se haga por Nombre de usuario (screenname).

Configuración de Liferay / Jboss como servicio en Windows Server (2003, 2008)

Configuración de Liferay / Jboss como servicios en Windows 2K Server

Liferay ---> D:\Portal\liferay-portal-5.2.4
JDK 1.6 ---> C:\Program Files\Java\jdk1.6.0_13\

Existen varias opciones para la configuración de aplicaciones Java (como Jboss, Tomcat etc) como servicios nativos de windows que puedan controlarse de forma automática por el sistema operativo, sin embaro la única recomendada por Jboss es el JavaServiceWrapper de Tanuki, y esa es la que describimos a continuación.

1) Descargar el wrapper del sitio oficial

En este caso se usará la versión para windows 32 bits x86

2) Descomprimir el zip en C:\


3) Configuración de binarios

Asumiendo las siguientes variables: (debe registrarlas como variables de entorno del sistema por panel de control/sistema. )


Ejecutar en consola como administrador los siguientes comandos:

copy WRAPPER_HOME\bin\Wrapper.exe %JBOSS_HOME%\bin\Wrapper.exe
copy WRAPPER_HOME\lib\Wrapper.DLL %JBOSS_HOME%\lib\Wrapper.DLL
copy WRAPPER_HOME\lib\wrapper.jar %JBOSS_HOME%\lib\wrapper.jar
mkdir %JBOSS_HOME%\server\YOURCONFIG\wrapper

Verificar que la ejecución de los comandos sea existosa.

4) Configuración del wrapper

Asumiendo JBOSS_HOME=D:\Portal\liferay-portal-5.2.4

a) Crear la carpeta wrapper:

mkdir %JBOSS_HOME%\server\default\wrapper

b) Crear un archivo llamado " wrapper.conf " en la carpeta creada y pegar en él lo siguiente:\Program Files\Java\jdk1.6.0_13\bin\java

# Opciones para la JVM JAVA_OPTS
# variables de entorno - definina aqui otra variables
# parametros de memoria - configure aqui el valor correcto para su entorno

# jboss
# Parametros para jboss
# definir la configuracion de jboss a usar default
# IP exacta en la que escucha el servicio.
# Ubicacion de los logs del wrapper
# Nombre del servicio como aparecera en Panel de control/herramientas administrativas/servicios.
# Descripcion del servicio
wrapper.ntservice.displayname=iferay Portal Jboss AS

5) Grabar el archivo y salir.

6) Probar el servicio

Ejecutar los siguientes comandos:

cd %JBOSS_HOME%\bin\

wrapper.exe -c %JBOSS_HOME%\server\default\wrapper\wrapper.conf

7) Si todo sale OK se procede a instalar el servicio

cd %JBOSS_HOME%\bin\

wrapper.exe -i %JBOSS_HOME%\server\default\wrapper\wrapper.conf

8) Para desinstalarlo en caso de problemas

cd %JBOSS_HOME%\bin\
wrapper.exe -r %JBOSS_HOME%\server\default\wrapper\wrapper.conf

Eso es todo !

[3] Guía de Instalación -