Ya hemos hablado anteriormente de Google App Engine, más específicamente en este post de introducción a google app engine. Hoy vamos a crear nuestra primera aplicación con Google App Engine.
Existen muchas formas de publicar aplicaciones en Google App Engine. Podemos utilizar Python y la librería web disponible en el mismo SDK de App Engine. Podemos utilizar Java usando un entorno basado en servlets o podemos usar el lenguaje de programación de Google go que está aún en fase experimental.
Para esta primera aplicación vamos a utilizar Python porque es el lenguaje mejor soportado y con mayor robustez por parte del App Engine y porque me siento más cómodo con él que con Java o GoLang. En artículos posteriores utilizaré Java y GoLang.
Al igual que pasa con los diferentes lenguajes posibles con los que utilizar el App Engine de Google, es posible utilizar el framework de desarrollo web Django (entre otros) en nuestras aplicaciones. En este artículo vamos a hacer uso únicamente del framework webapp disponible de facto en el App Engine.
Preparando el Entorno de Desarrollo
Lo primero que tenemos que hacer para crear nuestra aplicación es descargar una copia del SDK del App Engine para Python de su página de descargas y descomprimirlo en algún sitio seguro de nuestro disco duro.
Una vez tenemos el SDK descomprimido en nuestro disco duro, podemos poner a punto nuestro entorno de desarrollo y utilizar el comando dev_appserver.py para realizar nuestras pruebas. Si eres usuario de Windows o Mac puedes utilizar los botones de Ejecutar y Desplegar si no quieres utilizar la consola de comandos.
El entorno de desarrollo nos permite desarrollar y probar aplicaciones para App Engine completas en nuestra máquina antes de desplegarlas en los servidores de Google y ponerlas a disposición del resto de la humanidad.
Una aplicación sencilla
Las aplicaciones desarrolladas en Python para el App Engine, se comunican con el servidor utilizando el estándar CGI. El servidor recibe peticiones POST o GET que son procesadas y entonces producirá la respuesta HTTP que será enviada de nuevo al navegador web.
Por ahora, vamos a escribir una sencilla aplicación para App Engine que sea capaz de responder a una petición. Primero creamos un directorio llamado genbeta-app para nuestra aplicación. Todos los archivos relacionados con nuestra aplicación estarán contenidos dentro de este directorio.
Dentro del recién creado directorio vamos a crear dos archivos, index.py y app.yaml. Toda aplicación de App Engine debe incluir un archivo app.yaml, éste archivo se usa para configurar las aplicaciones y define los manejadores a los que entregar las peticiones provenientes del cliente. Recuerda que ya hablamos sobre la programación dirigida por eventos la semana pasada.
El contenido del archivo app.yaml para nuestra aplicación chusta sera este:
application: genbeta-app
version: 1
runtime: python
api_version: 1
handlers:
- url: /.*
script: index.pyLo único destacable es la sección handlers que hemos mantenido simple y enrutará todas las peticiones entrantes a un documento llamado index.py. A través de la implementación de App Engine, el código en index.py será ejecutado cuando el servidor reciba una petición. Los datos recibidos por medio de POST son accesibles como la entrada estándar y podemos acceder a ellos a través de sys.stdin.
Nuestra aplicación va a procesar una entrada de datos para encontrar un valor numérico y actuar en consecuencia para devolver una respuesta al navegador:
# -*- encoding: utf-8 -*-
import sys
import random
print 'Content-Type: text/html'
print ''
print ''
# Lee la entrada desde el formulario
data = sys.stdin.read()
try:
resp = int(data[data.find('=')+1:])
except:
resp = -1
print 'Tu número es ', resp
answer = random.randint(1, 100)
if resp < answer:
print 'Tu número es demasiado bajo'
if resp == answer:
print 'Has acertado campeón, toma un pin!'
if resp > answer:
print 'Tu número es demasiado alto'
print ''
print ''''''El código anterior se explica prácticamente solo. Enviamos el header indicando el tipo de contenido de nuestra respuesta y después procesamos la información proveniente del formulario. Seleccionamos solo el número de la cadena proveniente del formulario (resp=<numero>) y operamos sobre él. Dibujamos de nuevo el formulario.
Puede parecerte la aplicación más estúpida del mundo, y de hecho lo es, pero vamos a probarla. Para ejecutar nuestra aplicación debemos ejecutar el script dev_appserver.py que está en el directorio raiz del SDK pasándole como parámetro el directorio genbeta-app, en mi caso:
python dev_appserver.py genbeta-app/
Warning: You are using a Python runtime (2.7) that is more recent than the production runtime environment (2.5). Your application may use features that are not available in the production environment and may not work correctly when deployed to production.
INFO 2011-07-26 18:21:49,662 appengine_rpc.py:159] Server: appengine.google.com
INFO 2011-07-26 18:21:49,671 appcfg.py:453] Checking for updates to the SDK.
WARNING 2011-07-26 18:21:50,329 datastore_file_stub.py:511] Could not read datastore data from /tmp/dev_appserver.datastore
INFO 2011-07-26 18:21:50,329 rdbms_sqlite.py:58] Connecting to SQLite database '' with file '/tmp/dev_appserver.rdbms'
INFO 2011-07-26 18:21:50,354 dev_appserver_multiprocess.py:637] Running application genbeta-app on port 8080: http://localhost:8080Enviando datos con GET
Si en lugar de utilizar POST usamos GET en nuestros formularios o directamente en la URL, los datos no estarán disponibles en la aplicación a través de sys.stdin() sino que será parte del entorno de la variable QUERY_STRING. Como puedes comprobar, esta forma de utilizar el App Engine es una chusta de proporciones considerables. Cuando usamos el framework webapp de App Engine no hace falta preocuparse de todo esto porque la implementación queda oculta por el mismo.
Webapp Framework
Ahora que hemos escrito una aplicación con un poco de App Engine a muy bajo nivel es momento de utilizar algo de más alto nivel. Una aplicación que use el framework webapp se compone de tres partes:
-
Una o más clases
ResquestHandlerpara procesar las peticiones y devolver una respuesta -
Una instancia de
WSGIApplicationque encamina/dispara/enruta la peticiones entrantes hacia sus manejadores basándose en su URL -
Una función main que ejecuta el bucle principal utilizando el adaptador CGI
La librería webapp se hace cargo de la mayoría de tareas mundanas relacionadas con los detalles de implementación de HTTP en nuestra aplicación. Vamos a migrar nuestra aplicación a webapp:
# -*- encoding: utf-8 -*-
from google.appengine.ext import webapp
from google.appengine.ext.webapp.util import run_wsgi_app
import random
class MainHandler(webapp.RequestHandler):
formdata = ''''''
def get(self):
self.response.headers['Content-Type'] = 'text/html'
self.response.out.write(self.formdata)
def post(self):
resp = self.request.get('resp')
try:
resp = int(resp)
except:
resp = -1
answer = random.randint(1, 100)
if resp < answer:
msg = 'Tu número es demasiado bajo'
if resp is answer:
msg = 'Has acertado campeón, toma un pin!'
if resp > answer:
msg = 'Tu número es demasiado alto'
self.response.out.write('Tu número es : '+str(resp)+'
\n')
self.response.out.write(msg+'\n')
self.response.out.write(self.formdata)
def main():
application = webapp.WSGIApplication(
[('/.*', MainHandler)],
debug=True)
run_wsgi_app(application)
if __name__ is '__main__':
main()El módulo webapp se encuentra en el paquete google.appengine.ext. El código anterior define un manejador de peticiones o request handler llamado MainHandler que se mapea a cualquier URL ('/.*'). Cuando webapp recibe una petición HTTP instancia la clase MainHandler que llama al método GET o POST que ejecuta su cuerpo y devuelve un resultado.
Conclusión
Como habéis podido comprobar el uso del App Engine de Google es muy sencillo y usar el framework webapp no tiene misterio. En el próximo artículo sobre App Engine en Python hablaremos sobre que son las plantillas y como utilizarlas.
Más en Genbeta Dev | Introducción a Google App Engine, Usar plantillas con Google App Engine
