Curso Cloud Computing, Parte 2: Google App Engine

1

Cloud Computing: Google App Engine 31 de Mayo de 2011, 18:00-21:00

Dr. Diego Lz. de Ipiña Glz. de [email protected]

http://paginaspersonales.deusto.es/dipina http://www.slideshare.net/dipina

http://www.morelab.deusto.es

2

Agenda1. Ejemplo de PaaS: Google App Engine (180’)– Introducción (15’)– DataStore API y GQL (25’)– Memcache y Cron (20’)– Versiones Python y Java de Google App Engine (60’)– Desarrollo de una aplicación de ejemplo sobre GoogleApp

(60’)

3

Google App Engine

• All the power of Google in one, simple platform.– Zero to sixty: App Engine enables your application to scale

automatically without worrying about managing machines.– Supercharged APIs: The App Engine platform provides

amazing services such as Task Queue, XMPP, and Propsective search, all powered by the same infrastructure that powers Google's applications.

– You're in control: The simple, web-based dashboard makes it easy to manage your application without having to babysit it.

4

• Google App Engine es una herramienta para el alojamiento de aplicaciones web escalables sobre la infraestructura de Google– Su misión es permitir al desarrollador web crear fácilmente aplicaciones web

escalables sin ser un experto en sistemas• Aporta las siguientes características a los desarrolladores:

– Limita la responsabilidad del programador al desarrollo y primer despliegue – Google App Engine provee recursos computacionales dinámicamente según son necesarios

– Toma control de los picos de tráfico – si nuestro portal crece en popularidad no es necesario actualizar nuestra infraestructura (servidores, BBDD)• Ofrece replicación y balanceo de carga automática apoyado en componentes como

Bigtable– Fácilmente integrable con otros servicios de Google – los desarrolladores

pueden hacer uso de componentes existentes y la librería de APIs de Google (email, autenticación, pagos, etc.)

Ejemplo Plataforma Cloud: Google App Engine

5

• Ofrece una plataforma completa para el alojamiento y escalado automático de aplicaciones, consistiendo en:– Servidores de aplicaciones Python y Java– La base de datos BigTable– El sistema de ficheros GFS

• Como desarrollador simplemente tienes que subir tu código Python o Java compilado a Google, lanzar la aplicación y monitorizar el uso y otras métricas

• Google App Engine incluye la librería estándar de Python 2.5 y soporta Java 1.6– No todas las acciones se permiten (acceso a ficheros, llamadas al SO, algunas

llamadas de red)• Se ejecuta en un entorno restringido para permitir que las aplicaciones escalen

• Ejemplo: – https://appengine.google.com– http://enpresadigitala.appspot.com/encuestas– http://code.google.com/intl/en/appengine/docs/

Google App Engine:Características

6

Facturación Google App Engine• Hasta 10 aplicaciones con 500 MB de almacenamiento y 5 millones de visitas al

mes cada una• Página de presupuestado y facturación de recursos:

http://code.google.com/intl/es/appengine/docs/billing.html• Detalles sobre las cuotas en:

http://code.google.com/intl/es/appengine/docs/quotas.html

Recurso Unidad Coste de la unidad

Ancho de banda de salida gigabytes 0,12 dólares

Ancho de banda de entrada gigabytes 0,10 dólares

Tiempo de CPU horas de CPU 0,10 dólares

Datos almacenados gigabytes al mes 0,15 dólares

Destinatarios de mensajes de correo electrónico

destinatarios 0,0001 dólares

7

8

Google App Engine: Python y Java

• Vamos a revisar primero (brevemente) cómo realizar aplicaciones con Python

• Luego nos centraremos en cómo hacerlo desde Java en mayor grado de detalle

9

GAE for Python: Instalación

• Descargar Google App Engine SDK para Python de: http://code.google.com/appengine/downloads.html

• Herramientas de la SDK para Python:– dev_appserver.py, el servidor web de desarrollo– appcfg.py, sirve para subir tu aplicación a App Engine– Herramienta de descarga de datos – es una herramienta

sencilla que te permite subir datos en ficheros CSV al almacen de datos de appengine• http://code.google.com/intl/es/appengine/docs/python/tools/up

loadingdata.html

10

Principios

• Una aplicación de App Engine se comunica con el servidor que la aloja a través de CGI– Cuando recibe una petición el servidor lee de la

entrada estándar y de las variables de entorno– Cuando genera una respuesta escribe a la salida

estándar

11

Mi primera aplicación1. Crear el directorio helloworld2. Crea el fichero helloworld.py dentro de él con el siguiente contenido, que corresponde a una

respuesta HTTP:print 'Content-Type: text/plain'print ''print 'Hello, world!‘

3. Crea el fichero de configuración requerido por toda aplicación App Engine denominado app.yaml, en formato YAML (http://www.yaml.org/):– http://code.google.com/appengine/docs/configuringanapp.html

application: helloworldversion: 1runtime: pythonapi_version: 1

handlers:- url: /.* script: helloworld.py

4. Arranca el servidor con el comando: dev_appserver.py helloworld/ El switch --help da más indicaciones sobre las opciones aceptadas por el servidor

5. Vete a la siguiente URL para probarlo: http://localhost:8080/

12

Ejecutando Hola Mundo en Google App Engine

13

Opciones Avanzadas para GAE for Python

• Framework webapp que soporta el estándar WSGI

• Acceso a datos de usuarios mediante la Users API

• DataStore API• Plantillas en Google App Engine

14

Usando el Almacén de Datos de Google App Engine

• Guardar datos en una aplicación web escalable puede ser difícil• La infraestructura de App Engine se encarga de la distribución, replicación

y balanceo de carga de los datos detrás de una API sencilla que también ofrece un motor de consultas y transacciones

• App Engine incluye una API de modelado de datos para Python– Se asemeja a la API de Django pero utiliza el servidor de datos escalable

BigTable por detrás.• No es relacional, todas las entidades de un mismo tipo tienen las mismas propiedades• Una propiedad puede tener uno o varios valores

• El siguiente import nos da acceso a la base de datos de Google App Engine: – from google.appengine.ext import db

• Para más detalles sobre el DataStore API ir a: http://code.google.com/appengine/docs/datastore/

15

La API del DataStore• Incluye una API de modelado de datos y un lenguaje similar a SQL que NO permite

JOINs y que se llama GQL, haciendo el desarrollo de aplicaciones escalables basadas en datos muy sencillo.

from google.appengine.ext import dbfrom google.appengine.api import users

class Pet(db.Model):  name = db.StringProperty(required=True)  type = db.StringProperty(required=True, choices=set(["cat", "dog", "bird"]))  birthdate = db.DateProperty()  weight_in_pounds = db.IntegerProperty()  spayed_or_neutered = db.BooleanProperty()  owner = db.UserProperty()

pet = Pet(name="Fluffy",          type="cat",          owner=users.get_current_user())pet.weight_in_pounds = 24pet.put()

16

GQL Query Language• Para limpiar la base de datos creada: dev_appserver.py --

clear_datastore helloworld/• Ejemplo GQL:

if users.get_current_user(): user_pets = db.GqlQuery("SELECT * FROM Pet WHERE

pet.owner = :1“, users.get_current_user()) for pet in user_pets: pet.spayed_or_neutered = True

db.put(user_pets)

17

Usando plantillas en Google App Engine

• Empotrar HTML en código es algo lioso y difícil de mantener.• Los sistemas de plantillas están diseñados para mantener HTML aparte en otro

fichero donde elementos con sintaxis especial indican dónde deberían aparecer los datos de la aplicación

• Dentro de App Engine puede utilizarse cualquier motor de plantillas empaquetándolo con el código de tu aplicación, webapp incluye el mecanismo de plantillas de Django, donde se pueden pasar objetos del modelo datos – Para utilizarlo hay que incluir los dos siguientes imports:

import osfrom google.appengine.ext.webapp import template

– Además reemplazar las sentencias self.response.out.write por la sentencia template.render(path, template_values), que toma como parámetros de entrada:• El camino al fichero de la plantilla• Un diccionario de valores

– Y retorna:• El texto a renderizar

18

Registrando la aplicación

19

Verificación de tu cuenta

20

Verificación de tu Cuenta

21

Registrando la aplicación en appengine.google.com

22

Registrando la applicación

23

Subiendo la aplicación

• Es necesario realizar los siguientes pasos:1. Editar el fichero app.yaml file y cambiar el valor de la

aplicación: de helloworld al nombre de id de aplicación (enpresadigitala)

2. Ejecutar el siguiente comando: appcfg.py update helloworld/

3. Acceder a la aplicación en http://application-id.appspot.com, por ejemplo en http://enpresadigitala.appspot.com/

24

Subiendo la aplicación

25

Accediendo a la aplicación

26

Programando Google App Engine con Django

• Google App Engine y Django tienen la habilidad de usar el estándar WSGI para ejecutar aplicaciones– Como consecuencia podemos utilizar la pila de Django en Google App Engine, incluso su parte de middleware– Lo único que tenemos que hacer es cambiar los modelos de datos de Django para que usen la DataStore API de Google

App Engine• Como ambas APIs son muy similares, tenemos la misma flexibilidad usando la potencia de BigTable, es trivial adaptar un

modelo Django a Google App Engine• Además como Google App Engine ya incluye Django, solamente hay que importar los módulos que utilizarías normalmente

• Para usar el gestor WSGI tenemos que realizar los siguientes pasos:– Importar util de google.appengine.ext.webapp– Importar WSGI handler de Django– [OPCIONAL] Redirigir los logs a la Admin Console de Google App Engine

• Es conveniente cambiar las siguientes configuraciones en Django:– Dejar vacías las variables DATABASE_* de settings.py– Deshabilitar el middleware de session y autenticación que hace uso de los modelos Django

• Más info en: http://code.google.com/appengine/articles/django.html • Revisar ejemplo de encuestas programado en Django para AppEngine en:

examples/googleappengine/python/djangosolopsiteappengine

27

Ejemplo Django Compleja sobre App Engine

28

App Engine para Java

• Crea aplicaciones web a través de tecnologías estándar de Java y las ejecuta en la infraestructura escalable Google– Usa JVM Java 6, interfaz de servlets Java y la compatibilidad de

interfaces estándar como JDO, JPA, JavaMail y JCache

• App Engine utiliza el estándar Java Servlet para aplicaciones web– JVM se ejecuta en un entorno seguro de la "zona de pruebas" para

aislar tu aplicación por servicio y seguridad. • Una aplicación en GAE sólo pueda realizar acciones que no interfieran con

el rendimiento ni con la escalabilidad de otras aplicaciones.

29

Funcionalidad de AppEngine for Java

• App Engine proporciona un conjunto de servicios escalables que pueden utilizar las aplicaciones para:– Almacenar datos persistentes. En Java, el almacén de datos admite 2 interfaces Java

estándar: los objetos de datos Java (JDO) 2.3 y el API de persistencia de Java (JPA) 1.0.– Acceder a recursos en la red. A través de la URL Fectch API. – Cachear información. Memcache de App Engine proporciona un almacenamiento en

caché distribuido, transitorio y rápido de los resultados de cálculos y consultas de almacén de datos. La interfaz Java implementa JCache (JSR 107).

– Enviar email. Da soporte de JavaMail para el envío de correos– Procesar imágenes. A través de la Images Java API, permite a las aplicaciones

transformar y manipular datos de imágenes en varios formatos.– Gestionar usuarios. A través de la Users Java API permite utilizar Cuentas de Google para

la autenticación del usuario.– Lanzar tareas planificadas o en background. Mediante la Task Queue Java API y la

gestión de tareas por Cron.

30

Instalación de AppEngine for Java

1. Descargar el fichero de:– http://code.google.com/intl/es/appengine/downloads.ht

ml#Google_App_Engine_SDK_for_Java

2. Descomprimir el fichero .zip3. Crear una variable de entorno

APPENGINE_JAVA_SDK que apunte al directorio raíz de instalación de la SDK

4. Incluir el directorio %APPENGINE_JAVA_SDK%\bin en la variable de entorno PATH

31

Pasos para crear una Aplicación con Google App Engine para Java

1. Crear el proyecto de la aplicación2. Crear la clase servlet3. Crear el fichero de despliegue de la aplicación:

web.xml4. Crear el archivo appengine-web.xml5. Ejecutar el proyecto6. Probar el proyecto:

http://localhost:8080/<nombre-aplicación> 7. Subir la aplicación al dominio appspot.com

32

Configuración del Entorno

1. Instalar java2. Descomprimir la distribución de GAE for Java a una carpeta de tu disco

duro3. Modificar la variable de entorno APPENGINE_JAVA_SDK para que

apunte a ese directorio4. Modificar la variable de entorno PATH para que apunte a

%APPENGINE_JAVA_SDK%\bin5. Descomprimir el fichero downloads\apache-ant-1.8.1-

bin.zip6. Modificar la variable de entorno PATH para que apunte a <ANT_DIR>\

bin7. cd examples\googleappengine\java\guestbook8. ant

33

Paso 1: Creando la estructura del proyecto• Dos opciones:

– Usar el plug-in para Eclipse: http://code.google.com/intl/es/appengine/docs/java/tools/eclipse.html– Usar la plantilla de proyecto disponible en %APP_ENGINE_HOME%\demos\

new_project_template

• Las aplicaciones Java de App Engine utilizan el API Java Servlet para interactuar con el servidor web. – Un servlet HTTP es una clase de aplicación que puede procesar y responder solicitudes web. Esta

clase amplía la clase javax.servlet.GenericServlet o a la clase javax.servlet.http.HttpServlet.

• La estructura del directorio de trabajo será la siguiente:Guestbook/ src/ ...Java source code... META-INF/ ...other configuration... war/ ...JSPs, images, data files... WEB-INF/ ...app configuration... classes/ ...compiled classes... lib/ ...JARs for libraries...

34

Paso 2: Creando la clase Servlet• Crear en el directorio src/guestbook/ un fichero

denominado GuestbookServlet.java con el siguiente contenido:package guestbook;

import java.io.IOException;import javax.servlet.http.*;

public class GuestbookServlet extends HttpServlet { public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {    resp.setContentType("text/plain");      resp.getWriter().println("Hello, world");   }}

35

Paso 3: Creando el fichero de despliegue – web.xml

• Cuando el servidor web recibe una solicitud, decide qué clase de servlet ejecutar mediante un archivo de configuración conocido como "descriptor de implementación de la aplicación web". – Este archivo se denomina web.xml y se ubica en el directorio war/WEB-INF/ del directorio que

contiene los ficheros de una aplicación web en Java<?xml version="1.0" encoding="utf-8"?><!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd"><web-app xmlns="http://java.sun.com/xml/ns/javaee" version="2.5"> <servlet> <servlet-name>guestbook</servlet-name> <servlet-class>guestbook.GuestbookServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>guestbook</servlet-name> <url-pattern>/guestbook</url-pattern> </servlet-mapping> <welcome-file-list> <welcome-file>index.html</welcome-file> </welcome-file-list></web-app>

36

Paso 4: Crear el fichero de configuración de aplicación GAE:

appengine-web.xml• App Engine necesita un archivo de configuración adicional para poder desarrollar y ejecutar

la aplicación, denominado appengine-web.xml – Se ubica en WEB-INF/ junto a web.xml. – Incluye la ID registrada de la aplicación, el número de versión de la aplicación y listas de archivos que

se deben tratar como archivos estáticos (por ejemplo, imágenes y CSS) y archivos de recursos (por ejemplo, JSP y otros datos de aplicación).

• El directorio war/WEB-INF/ incluye un archivo denominado appengine-web.xml que contiene lo siguiente:

<?xml version="1.0" encoding="utf-8"?><appengine-web-app xmlns="http://appengine.google.com/ns/1.0"> <application>librocitas</application> <version>1</version></appengine-web-app>

37

Paso 5: Ejecución del Proyecto

• El SDK de App Engine incluye un servidor web de pruebas para depurar tu aplicación.

• El servidor simula los servicios y el entorno App Engine, que incluyen restricciones en la zona de pruebas, el almacén de datos y los servicios.

• Con el fichero ant ejecuta: ant runserver– Puedes detenerlo con Ctrl-C

38

Paso 6: Subiendo la aplicación

1. Puedes crear y administrar aplicaciones web App Engine con la consola de administración de App Engine a través de la siguiente URL: http://appengine.google.com/

2. Para crear una nueva aplicación, haz clic en el botón "Create an Application" (Crear aplicación)

3. Edita el archivo appengine-web.xml y, a continuación, cambia el valor del elemento <application> para que sea la ID registrada de tu aplicación (librocitas).

4. Ejecuta el siguiente comando en línea de comandos para subir la aplicación: $ appcfg update www

5. Vete a: http://librocitas.appspot.com/

39

El fichero de Ant• Apache Ant facilita la administración de tu proyecto desde la línea de

comandos o desde otros entornos de desarrollo integrados (IDE) compatibles con Ant.

• El SDK de Java incluye un conjunto de macros de Ant para realizar tareas de desarrollo de App Engine, entre las que se incluyen:– El inicio del servidor de desarrollo y – La subida de la aplicación a App Engine

• Algunos problemas con el build.xml suministrado por new-project-template– Fichero adaptado en examples/guestbook/build.xml:

• Hay que definir variable de entorno APP_ENGINE_SDK para desligar build.xml de su localización en disco

• Introducir tarea para copiar jars con dependencias

40

Usando el Servicio de Usuarios• Google App Engine ofrece varios servicios útiles basados en la infraestructura de Google a los que se

puede acceder a través de aplicaciones utilizando una serie de bibliotecas incluidas en el kit de desarrollo de software (SDK)– Por ejemplo, el servicio de usuarios te permite integrar tu aplicación con cuentas de usuarios de Google

package guestbook;import java.io.IOException;import javax.servlet.http.*;import com.google.appengine.api.users.User;import com.google.appengine.api.users.UserService;import com.google.appengine.api.users.UserServiceFactory;

public class GuestbookServlet extends HttpServlet {    public void doGet(HttpServletRequest req, HttpServletResponse resp)              throws IOException {        UserService userService = UserServiceFactory.getUserService();        User user = userService.getCurrentUser();

        if (user != null) {            resp.setContentType("text/plain");            resp.getWriter().println("Hello, " + user.getNickname());        } else {            resp.sendRedirect(userService.createLoginURL(req.getRequestURI()));        }    }}

41

Uso de un JSP• Aunque podríamos generar el código HTML para la interfaz de usuario

directamente a partir del código Java del servlet, no sería algo fácil de mantener, ya que el código HTML se complica

• Es más conveniente utilizar un sistema de plantillas, en el que la interfaz de usuario esté diseñada e implementada en archivos independientes con marcadores y lógica para insertar datos proporcionados por la aplicación.

• Pasos:– En el directorio war/, crea un archivo llamado guestbook.jsp con el contenido de la siguiente

transparencia– Modificar el fichero web.xml para que el welcome-file apunte a guestbook.jsp– Acceder a la ruta: http://localhost:8080/guestbook.jsp o http://localhost:8080/

• Al cargar una JSP por primera vez, el servidor de desarrollo lo convierte en código fuente Java y, a continuación, compila este código en código de bytes de Java

• Al subir la aplicación a App Engine, el SDK compila todas las JSP en código de bytes y únicamente sube el código de bytes.

42

Uso de un JSP<%@ page contentType="text/html;charset=UTF-8" language="java" %><%@ page import="com.google.appengine.api.users.User" %><%@ page import="com.google.appengine.api.users.UserService" %><%@ page import="com.google.appengine.api.users.UserServiceFactory" %><html> <body><% UserService userService = UserServiceFactory.getUserService(); User user = userService.getCurrentUser(); if (user != null) {%> <p>Hello, <%= user.getNickname() %>! (You can<a href="<%=

userService.createLogoutURL(request.getRequestURI()) %>">sign out</a>.)</p><%

} else {%> <p>Hello!<a href="<%=

userService.createLoginURL(request.getRequestURI()) %>">Sign in</a>to include your name with greetings you post.</p><%

}%> </body>

43

Formulario Libro Invitados• La aplicación de libro de invitados necesita un formulario web para que el usuario

publique un nuevo saludo, así como una forma de procesar ese formulario– El código HTML del formulario se inserta en la JSP guestbook.jsp:

<form action="/sign" method="post"> <div><textarea name="content" rows="3"

cols="60"></textarea></div> <div><input type="submit" value="Post Greeting" /></div> </form> 

– El destino del formulario es una nueva URL, /sign, controlada por una nueva clase de servlet,SignGuestbookServlet que procesa el formulario y redirige a: /guestbook.jsp• Es necesario modificar web.xml para crear una nueva entrada para este servlet, con los

siguientes datos:<servlet> <servlet-name>sign</servlet-name> <servlet-class>guestbook.SignGuestbookServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>sign</servlet-name> <url-pattern>/sign</url-pattern> </servlet-mapping>

44

El Servlet que Procesa una Nueva Entrada en Libro

package guestbook;import java.io.IOException;import java.util.logging.Logger;import javax.servlet.http.*;import com.google.appengine.api.users.User;import com.google.appengine.api.users.UserService;import com.google.appengine.api.users.UserServiceFactory;public class SignGuestbookServlet extends HttpServlet { private static final Logger log = Logger.getLogger(SignGuestbookServlet.class.getName()); public void doPost(HttpServletRequest req, HttpServletResponse resp)

throws IOException { UserService userService = UserServiceFactory.getUserService(); User user = userService.getCurrentUser(); String content = req.getParameter("content"); if (content == null) { content = "(No greeting)"; } if (user != null) { log.info("Greeting posted by user " + user.getNickname() + ": " + content); } else { log.info("Greeting posted anonymously: " + content); } resp.sendRedirect("guestbook.jsp"); }}

45

Logeo de Información con App Engine

• El nuevo servlet utiliza la clase java.util.logging.Logger para escribir mensajes en el registro.

• Puedes controlar el comportamiento de esta clase a través de un archivo logging.properties y de un conjunto de propiedades del sistema en el archivo appengine-web.xml de la aplicación.– Copia el archivo de ejemplo del

SDK appengine-java-sdk/config/user/logging.properties en el directorio war/WEB-INF/ de la aplicación• Para modificar el nivel de registro de todas las clases del paquete guestbook, edita el

archivo logging.properties y añade una entrada para guestbook.level, como se muestra a continuación:

.level = WARNINGguestbook.level = INFO

– A continuación edita el archivo war/WEB-INF/appengine-web.xml de la aplicación como se indica:<appengine-web-app xmlns="http://appengine.google.com/ns/1.0"> ... <system-properties> <property name="java.util.logging.config.file"

value="WEB-INF/logging.properties"/> </system-properties> </appengine-web-app>

• Los ficheros de logeo se descargan con la consola de administración o la aplicación appcfg de App Engine: https://appengine.google.com/logs

46

Uso del Almacen de Datos JDO• La infraestructura de App Engine se encarga de todas las tareas de distribución,

replicación y balanceo de carga de los datos de un API sencilla, además de ofrecer un potente motor de consulta y transacciones.– Ofrece dos API: un API estándar y otra de nivel inferior.– App Engine for Java permite el uso de dos estándares de API diferentes para el

almacén de datos: Objetos de datos Java (JDO) y API de persistencia Java (JPA).• Estas interfaces las proporciona DataNucleus Access Platform, una implementación de

software libre de varios estándares de persistencia Java, con un adaptador para Google DataStore

• Utilizaremos la interfaz JDO para la recuperación y la publicación de los mensajes de los usuarios en el almacén de datos de App Engine.– Access Platform necesita un archivo de configuración que le indique que debe utilizar

el almacén de datos de App Engine como servidor para la implementación de JDO: META-INF/jdoconfig.xml

• Documentación detallada de JDO puede encontrarse en: http://code.google.com/appengine/docs/java/datastore/

47

Funcionamiento de JDO• Al crear clases JDO, debes utilizar anotaciones Java para describir cómo

se deben guardar las instancias en el almacén de datos y cómo se deben volver a crear al recuperarlas de dicho almacén. – Access Platform conecta las clases de datos a la implementación mediante un

paso de procesamiento posterior a la compilación, que DataNucleus denomina "mejora" de las clases.

• JDO permite almacenar objetos Java (a veces denominados "objetos Java antiguos y simples" o POJO) en cualquier almacén de datos con un adaptador compatible con JDO, como DataNucleus Access Platform

• El complemento Access Platform para el almacén de datos de App Engine permite almacenar instancias de clases definidas en el almacén de datos de App Engine

• Ejemplo: la clase Greeting representará mensajes individuales publicados en el libro de invitados de nuestra aplicación

48

La Clase de Persistencia Greetingpackage guestbook;import java.util.Date;import javax.jdo.annotations.IdGeneratorStrategy;import javax.jdo.annotations.IdentityType;import javax.jdo.annotations.PersistenceCapable;import javax.jdo.annotations.Persistent;import javax.jdo.annotations.PrimaryKey;import com.google.appengine.api.users.User;@PersistenceCapable(identityType = IdentityType.APPLICATION)public class Greeting { @PrimaryKey @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY) private Long id; @Persistent private User author; @Persistent private String content; @Persistent private Date date; public Greeting(User author, String content, Date date) { this.author = author; this.content = content; this.date = date; } ...}

49

La Clase de Persistencia Greeting• Esta sencilla clase define tres propiedades para un

saludo: author, content y date • Estos tres campos privados presentan la anotación @Persistent, que

indica a DataNucleus que debe almacenarlos como propiedades de objetos en el almacén de datos de App Engine.

• La clase también define un campo llamado id, una clave Long que presenta dos anotaciones: @Persistent y @PrimaryKey.

• El almacén de datos de App Engine tiene una noción de las claves de entidades y puede representar las claves de varias formas en un objeto.

• Más información sobre cómo definir modelos de datos puede encontrarse en: http://code.google.com/intl/es/appengine/docs/java/datastore/dataclasses.html

50

Serializando datos con JDO• Cada solicitud que utiliza el almacén de datos crea una nueva instancia de la clase

PersistenceManager que se obtiene a través de PersistenceManagerFactory– Una instancia de PersistenceManagerFactory tarda algún tiempo en inicializarse

• Afortunadamente, sólo se necesita una instancia para cada aplicación

• Creamos la clase singleton PMF para resolverlo:package guestbook;import javax.jdo.JDOHelper;import javax.jdo.PersistenceManagerFactory;public final class PMF { private static final PersistenceManagerFactory pmfInstance =

JDOHelper.getPersistenceManagerFactory("transactions-optional");

private PMF() {} public static PersistenceManagerFactory get() { return

pmfInstance; }}

• Para usarlo creamos una nueva instancia de Greeting mediante la ejecución del constructor. – Para guardar la instancia en el almacén de datos, crea una clase PersistenceManager a través de PMF.get()

e invocamos sobre él makePersistent()

51

Serializando datos con JDO• Dentro del fichero SignGuestBookServlet introduciríamos los siguientes

cambios para serializar los saludos en App Engine DataStore, a través de JDO:

String content = req.getParameter("content");Date date = new Date(); Greeting greeting = new Greeting(user, content, date);PersistenceManager pm = PMF.get().getPersistenceManager();

try { pm.makePersistent(greeting);} finally { pm.close();}

52

Consultando datos con JDO• El estándar JDO define un mecanismo para consultas de objetos persistentes denominado JDOQL. • Modificaremos guestbook.jsp para realizar la consulta introduciendo los siguientes cambios:

<%@ page import="java.util.List" %><%@ page import="javax.jdo.PersistenceManager" %><%@ page import="guestbook.Greeting" %><%@ page import="guestbook.PMF" %>

…<%PersistenceManager pm = PMF.get().getPersistenceManager();String query = "select from " + Greeting.class.getName() + " order by date desc range

0,5"; List<Greeting> greetings = (List<Greeting>) pm.newQuery(query).execute();

if (greetings.isEmpty()) { %> <p>The guestbook has no messages.</p> <%} else { for (Greeting g : greetings) { if (g.getAuthor() == null) { %> <p>An anonymous person wrote:</p> <% } else { %> <p><b><%= g.getAuthor().getNickname() %></b> wrote:</p> <% } %> <blockquote><%= g.getContent() %></blockquote> <%

}}pm.close();%>

53

Usando Ficheros Estáticos• Hay muchos casos en los que querrás mostrar los archivos estáticos directamente

en el navegador web: imágenes, vídeos• Para una mayor eficiencia, App Engine muestra los archivos estáticos desde

servidores independientes en lugar de los que ejecutan servlets.• App Engine considera todos los archivos del directorio WAR como archivos

estáticos, salvo JSP y los archivos de WEB-INF/• Cualquier solicitud de una URL cuya ruta coincida con un archivo estático lo

muestra • Puedes configurar los archivos que quieres que App Engine considere como

archivos estáticos a través del archivo appengine-web.xml– La siguiente página da más información al respecto:

http://code.google.com/intl/es/appengine/docs/java/config/appconfig.html• Para este ejemplo:

– Crear main.css con el siguiente contenido:body { font-family: Verdana, Helvetica, sans-serif; background-color:

#FFFFCC; }

• Añadir a guestbook.jsp lo siguiente: <head> <link type="text/css" rel="stylesheet" href="/stylesheets/main.css" />

</head>

54

Creando de Objetos y Claves• Para almacenar un objeto de datos sencillo en el almacén de datos, ejecuta el

método makePersistent() del PersistenceManager y transfiérelo a la instancia.PersistenceManager pm = PMF.get().getPersistenceManager();Employee e = new Employee("Alfred", "Smith", new Date());try { pm.makePersistent(e);} finally { pm.close();}

• Las claves más sencillas están basadas en los tipos Long o String, pero también se pueden crear con la clase Key. import com.google.appengine.api.datastore.Key;import com.google.appengine.api.datastore.KeyFactory;// ...Key k = KeyFactory.createKey(Employee.class.getSimpleName(),

"[email protected]");

• Para recuperar un elemento por clave podemos usar lo siguiente, se puede pasar como segundo argumento una clave, un entero o un string:Employee e = pm.getObjectById(Employee.class,

"[email protected]");

55

Actualización y Borrado de Objetos

• El siguiente código muestra cómo actualizar un objeto persistente:public void updateEmployeeTitle(User user, String newTitle) { PersistenceManager pm = PMF.get().getPersistenceManager();

 try {  Employee e = pm.getObjectById(Employee.class, user.getEmail());    if (titleChangeIsAuthorized(e, newTitle) {    e.setTitle(newTitle);    } else {    throw new UnauthorizedTitleChangeException(e, newTitle);    } } finally {  pm.close(); }

}

• El siguiente ejemplo muestra cómo borrar un objeto:pm.deletePersistent(e);

56

Realizando Consultas con JDO• JDOQL es similar a SQL, aunque es más adecuado para bases de datos relacionadas con

objetos, como, por ejemplo, el almacén de datos de App Engine.• Dos usos diferentes:

1. Puedes especificar parte o la totalidad de la consulta mediante métodos de ejecución en el objeto de consulta

import java.util.List;import javax.jdo.Query;// ...Query query = pm.newQuery(Employee.class);query.setFilter("lastName == lastNameParam");query.setOrdering("hireDate desc");query.declareParameters("String lastNameParam");

try { List<Employee> results = (List<Employee>) query.execute("Smith");

if (results.iterator().hasNext()) { for (Employee e : results) { // ... }} else { // ... no results ...}

} finally {query.closeAll();

}

57

Realizando Consultas con JDO2. Puedes especificar una consulta completa en una cadena mediante la

sintaxis de cadena JDOQL:Query query = pm.newQuery("select from Employee " +    "where lastName == lastNameParam " +    "order by hireDate desc " +    "parameters String lastNameParam");

List<Employee> results = (List<Employee>) query.execute("Smith");

3. Otro modo:Query query = pm.newQuery(Employee.class,    "lastName == lastNameParam order by hireDate desc");

query.declareParameters("String lastNameParam");List<Employee> results = (List<Employee>) query.execute("Smith");

Query query = pm.newQuery(Employee.class,    "lastName == 'Smith' order by hireDate desc");

58

Filtros y Restricciones en Consultas JDO sobre App Engine

• Algunos ejemplos de filtros son:query.setFilter("lastName == 'Smith' && hireDate >

hireDateMinimum");query.declareParameters("Date hireDateMinimum");Query query = pm.newQuery(Employee.class,

    "(lastName == 'Smith' || lastName == 'Jones')" +    " && firstName == 'Harold'");

• ATENCIÓN: importantes restricciones en las consultas, revisar:– http://code.google.com/intl/es/appengine/docs/java/datastore/queriesandin

dexes.html#Restrictions_on_Queries• Ejemplo: Los filtros de desigualdad sólo están permitidos en una propiedad

59

Ejemplo Objeto Serializable• La siguiente clase define un objeto que puede serializarse en JDO:

import java.io.Serializable;public class DownloadableFile implements Serializable { private byte[] content; private String filename; private String mimeType;

// ... accessors ...}

• La siguiente clase define cómo usarlo:import javax.jdo.annotations.Persistent;import DownloadableFile;// ...@Persistent(serialized = "true");private DownloadableFile file;

60

Ejemplo Relación 1 a 1 entre Entidades

import com.google.appengine.api.datastore.Key;// ... imports ...@PersistenceCapablepublic class ContactInfo { @PrimaryKey @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY) private Key key;

@Persistent private String streetAddress; @Persistent private String city; @Persistent private String stateOrProvince; @Persistent private String zipCode; // ... accessors ...}

import ContactInfo;// ... imports ...@PersistenceCapablepublic class Employee { @PrimaryKey @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY) private Key key;

@Persistent private ContactInfo myContactInfo;

// ... accessors ...}

61

Relaciones Uno a Varios• Ejemplo de relación bidireccional uno a varios:

// Employee.javaimport java.util.List;// ...@Persistentprivate List<ContactInfo> contactInfoSets;

// ContactInfo.javaimport Employee;// ...@Persistentprivate Employee employee;

62

Relaciones Varios a Varios• Ejemplo de relación varios a varios, sólo se puede hacer guardando colecciones de claves en ambas relaciones implicadas:

//Person.javaimport java.util.Set;import com.google.appengine.api.datastore.Key;// ...@Persistentprivate Set<Key> favoriteFoods;

//Food.javaimport java.util.Set;import com.google.appengine.api.datastore.Key;// ...@Persistentprivate Set<Key> foodFans;

// Album.java// ...public void addFavoriteFood(Food food) { favoriteFoods.add(food.getKey()); food.getFoodFans().add(getKey());}public void removeFavoriteFood(Food food) { favoriteFoods.remove(food.getKey()); food.getFoodFans().remove(getKey());}

63

Características Avanzadas de Google App Engine

• Planificación de tareas con Cron for Java– http://code.google.com/appengine/docs/java/config/cron.html

• Memcache Java API– http://code.google.com/appengine/docs/java/memcache/overview.html

• URL Fech Java API– http://code.google.com/appengine/docs/java/urlfetch/overview.html

• Envío de mensajes instantáneos con XMPP e email – http://code.google.com/appengine/docs/java/xmpp/overview.html

• Colas de tareas – permite ejecutar asíncronamente tareas– http://code.google.com/appengine/docs/java/taskqueue/overview.html

64

Planificación de Tareas con Cron

• El servicio App Engine Cron Service permite planificar tareas que se ejecutan en un momento o periodos determinados.– Los trabajos cron (cron jobs) son ejecutados por App Engine Cron

Service

• Algunos ejemplos de uso serían:– Envío de email con informe diario– Actualización de tu caché de datos cada 10 minutos

• Documentación en: http://code.google.com/appengine/docs/java/config/cron.html– Formato de las planificaciones:

("every"|ordinal) (days) ["of" (monthspec)] (time)

65

Planificación de Tareas con Cron• El fichero WEB-INF\cron.xml controla cron para tu aplicación:

<?xml version="1.0" encoding="UTF-8"?><cronentries> <cron>

<url>/recache</url>  <description>Repopulate the cache every 2 minutes</description>  <schedule>every 2 minutes</schedule></cron><cron> <url>/weeklyreport</url>  <description>Mail out a weekly report</description>  <schedule>every monday 08:30</schedule>  <timezone>America/New_York</timezone></cron>

</cronentries>

66

Memcache Java API• Las aplicaciones web escalables de alto rendimiento utilizan a menudo

una caché distribuida de datos integrados en memoria delante o en lugar de un sistema de almacenamiento complejo permanente para algunas tareas– App Engine incluye un servicio de memoria caché

• El API Java de Memcache implementa la interfaz JCache (javax.cache), un estándar en formato borrador descrito en JSR 107– JCache proporciona una interfaz en forma de mapa para recopilar datos

• Puedes almacenar y recuperar valores de la memoria caché mediante las claves• Controlar cuándo los valores vencen en la memoria caché• Inspeccionar el contenido de la memoria caché y obtener estadísticas sobre ella• Utilizar "funciones de escucha" para añadir un comportamiento personalizado al

establecer y borrar valores.

67

Pasos para Hacer uso de Memcache

1. Obtención y configuración de una instancia de Cache, para ello hay que configurar los parámetros del método createCache

import javax.cache.Cache;import javax.cache.CacheException;import javax.cache.CacheFactory;// ...Cache cache;try { Map props = new Map; props.put(GCacheFactory.EXPIRATION_DELTA, 3600); props.put(MemcacheService.SetPolicy.ADD_ONLY_IF_NOT_PRESENT, true); CacheFactory cacheFactory = CacheManager.getInstance().getCacheFactory(); // cache = cacheFactory.createCache(Collections.emptyMap()); cache = cacheFactory.createCache(props);} catch (CacheException e) { // ... }

2. Establecimiento y obtención de valores. – Se comporta como un mapa– Puedes almacenar claves y valores a través del método put() y recuperar valores con el método get()– Otros métodos de interés son: remove(), clear(), containsKey(), isEmpty() y size()

3. Más documentación en: http://code.google.com/intl/es/appengine/docs/java/memcache/usingjcache.html

68

URL Fetch Java API• GAE permite realizar conexiones HTTP y HTTPS a través del servicio URL

Fetch, que en el caso de GAE for Java se implementa mediante la clase java.net.URLConnection

• La funcionalidad que da es:– Acceso sencillo a los contenidos de una página mediante java.net.URL y

el método openStream()– El método openConnection() de java.net.URL devuelve una

instancia de HttpURLConnection, sobre la que se puede hacer getInputStream() y getOutputStream()

– Se pueden cambiar propiedades de la conexión como:• Añadir cabeceras: connection.setRequestProperty("X-MyApp-Version", "2.7.3");

• Modificar el hecho de que las peticiones se redirijan directamente: connection.setRequestProperty("X-MyApp-Version", "2.7.3");

• Más detalles en: http://code.google.com/intl/en/appengine/docs/java/urlfetch/usingjavanet.html

69

Mail Java API

• Una aplicación en App Engine puede enviar mensajes en representación del administrador de la página o de usuarios autorizados con cuentas Google– La Mail Service Java API hace uso de javax.mail

• Se puede configurar tu aplicación para recibir mensajes en una dirección con el formato [email protected]

• Cuando una aplicación se ejecuta en el servidor de desarrollo, el mensaje enviado se imprime en el log, no se envía

70

Enviando un Mensaje...import java.util.Properties;import javax.mail.Message;import javax.mail.MessagingException;import javax.mail.Session;import javax.mail.Transport;import javax.mail.internet.AddressException;import javax.mail.internet.InternetAddress;import javax.mail.internet.MimeMessage;// ... Properties props = new Properties();Session session = Session.getDefaultInstance(props, null);String msgBody = "...“;try { Message msg = new MimeMessage(session); msg.setFrom(new InternetAddress("[email protected]", "Example.com Admin")); msg.addRecipient(Message.RecipientType.TO,

                             new InternetAddress("[email protected]", "Mr. User")); msg.setSubject("Your Example.com account has been activated"); msg.setText(msgBody); Transport.send(msg);} catch (AddressException e) { // ...} catch (MessagingException e) { // ...}

71

Recibiendo un Mensaje• Los pasos a seguir son:

1. Configurar tu aplicación para ser receptora de email en la dirección: [email protected]

a. Modificando el fichero appengine-web.xml: <inbound-services> <service>mail</service></inbound-services>

b. Modificando el fichero web.xml, que recibirá mensajes en la siguiente dirección: /_ah/mail/<address><servlet> <servlet-name>mailhandler</servlet-name> <servlet-class>MailHandlerServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>mailhandler</servlet-name> <url-pattern>/_ah/mail/*</url-pattern> </servlet-mapping> <security-constraint> <web-resource-collection> <url-pattern>/_ah/mail/*</url-pattern> </web-resource-collection> <auth-constraint> <role-name>admin</role-name> </auth-constraint> </security-constraint>

72

Recibiendo un Mensaje

• Los pasos a seguir son:2. Crear un servlet que reciba los mensajes

import java.io.IOException;import java.util.Properties; import javax.mail.Session; import javax.mail.internet.MimeMessage; import javax.servlet.http.*; public class MailHandlerServlet extends HttpServlet { public void doPost(HttpServletRequest req, HttpServletResponse

resp) throws IOException { Properties props = new Properties(); Session session = Session.getDefaultInstance(props, null); MimeMessage message = new MimeMessage(session,

req.getInputStream()); …}

73

Task Queue API

• Una aplicación Java puede crear una cola configurada en el fichero de configuración WEB-INF/queue.xml  

• Para encolar una tarea, hay que obtener una instancia de Queue usando una QueueFactory y luego invocar el método add()– Puedes obtener una cola por nombre declarada en el fichero queue.xml o la

cola por defecto con el método getDefaultQueue()– Se puede añadir una tarea a la cola pasando una instancia de TaskOptions

al método add()• Se invocará un servlet que será quien ejecute la tarea encolada (ver ejemplo

siguiente trasparencia)

• Espacio de nombres en versión beta: com.google.appengine.api.labs.taskqueue

74

Ejemplo de Task Queue API• El siguiente ejemplo muestra cómo añadir una tarea a una cola:

import com.google.appengine.api.labs.taskqueue.Queue;import com.google.appengine.api.labs.taskqueue.QueueFactory;import static

com.google.appengine.api.labs.taskqueue.TaskOptions.Builder.*;

// ...Queue queue = QueueFactory.getDefaultQueue();queue.add(url("/worker").param("key", key));

75

Ejemplo de Task Queue API• Ejemplo de queue.xml, donde s indica segundos, m minutos, h horas y

d días, es decir, la frecuencia con la que las tareas encoladas serían procesadas:<queue-entries>  <queue>    <name>default</name>    <rate>1/s</rate>  </queue>  <queue>    <name>mail-queue</name>    <rate>2000/d</rate>    <bucket-size>10</bucket-size>  </queue>  <queue>    <name>background-processing</name>    <rate>5/s</rate>  </queue></queue-entries>

76

Combinando Struts2 y GAE

• Revisar ejemplo: struts2tutorial• Modificaciones a realizar en la distribución de

struts2tutorial:– Reimplementar la clase freemarker.core.TextBlock

– Inicializar a null el SecurityManager de OgnlRuntime

• Explicación de cómo hacerlo en: – http://whyjava.wordpress.com/2009/08/30/creating-struts

2-application-on-google-app-engine-gae/

77

Plugin for Eclipse for Java

• Instrucciones en: http://code.google.com/eclipse/docs/download.html

• Descarga Eclipse Galileo for Java Developers de: http://www.eclipse.org/downloads/

78

Importación y Exportación de Datos

• Se pueden acceder a datos detrás de tu Intranet desde una aplicación de Google App Engine, con Google Secure Data Connector y el servicio urlfetch (com.google.appengine.api.urlfetch.*)– http://code.google.com/intl/en/securedataconnector/docs

/1.3/tutorials/appengine.html

• Se pueden importar y exportar datos del datastore en forma de ficheros CSV– Solamente disponible en Python de momento:

• http://code.google.com/appengine/docs/python/tools/uploadingdata.html

79

Google App Engine for Business• Las aplicaciones generadas con App Engine for Business usan las APIs de

Java y Python, pero permiten acceder al desarrollador a capacidades especiales (premium):– Acceso a SSL y SQL– Tendrán un coste adicional

• Mas información en: http://code.google.com/appengine/business/

80

Limitaciones Google App Engine

• El servicio tiene varias limitaciones:– Solo hasta recientemente no todo el mundo podía acceder a él– Es gratis durante el periodo de pruebas, pero con límites de uso: 500 MB de

almacenamiento, 200 millones de megaciclos/día y 10 Gb de ancho de banda• Google cobra para webs que requieren alta escalabilidad

• Existen escasas aplicaciones comerciales desarrolladas en esta plataforma– Repositorio de ejemplos: http://appgallery.appspot.com/

• VOSAO CMS - http://www.vosao.org/

• Limitaciones técnicas originales parcialmente resueltas:– Los desarrolladores solamente tienen acceso de lectura al sistema de ficheros de App

Engine– Solamente se puede ejecutar código a partir de una petición HTTP– Solamente se puede subir código puramente Python (resuelto con soporte Java)– No se puede descargar o ejecutar scripts en su base de datos (remote_api)– Las aplicaciones deben ser escritas en Python o Java

• Guido van Rosum, creador de Python está detrás de Google App Engine

81

Google App Engine vs. Amazon Web Services

• A primera vista Google App Engine es un competidor a la suite de servicios web ofrecida por Amazon:– S3 para almacenamiento– EC2 para la creación de servidores virtuales– SimpleDB como base de datos

• Pero …– Google App Engine es una plataforma mucho más

acoplada y menos flexible• Si quieres hacer uso de BigTable tienes que escribir y desplegar un

script de Python a su servidor de aplicaciones ofreciendo una interfaz web accesible a BigTable (resuelto parcialmente)

82

Google App Engine vs. Amazon Web Services

83

Referencias• Google App Engine

– http://code.google.com/appengine/

84

Cloud Computing: Google App Engine 31 de Mayo de 2011, 18:00-21:00

Dr. Diego Lz. de Ipiña Glz. de [email protected]

http://paginaspersonales.deusto.es/dipina http://www.slideshare.net/dipina

http://www.morelab.deusto.es