Cloud computing has become the talk of the town. Developers had been using

Platform-as-a-Service or on-demand platforms to build applications that would

run on the Cloud. This means, you can develop your applications and then host

them on somebody else's infrastructure. Google also has ventured into the cloud

computing arena with their App Engine, which was first released as a Beta

version in April 2008. Google App Engine not only leverages their massive

infrastructure to the developers but also help them in reducing the time to

write the code and deploying it on a Web server. Now, developers just have to

build their apps and simply host them on App Engine. They do not have to bother

about the complex setting up of the servers and their maintenance.

Google App Engine is still in its preview release, and costs nothing to get

started. With a free account, one can get up to 500MB of persistent storage and

enough CPU and bandwidth for about 5 million page views a month. The App

Engine's virtualised computing environment caters to all the components of a

modern web application: dynamic runtime, persistent storage, static file

serving, emailing, monitoring and log analysis. Like any other cloud

infrastructure, App Engine also provides scalability of the applications

depending upon the traffic and data storage requirements.

App Engine SDK



The SDK provided by the Google to develop applications for the App Engine
includes a Web server application that simulates the App Engine environment.

Presently, App Engine supports only python programming language, but Google has

said that later other language support will also be offered. In this article, we

will see how to use App Engine SDK to build Web application and then host them

online on Google's App Engine.

The App Engine SDK boasts of a strong API framework, which included Python

scripting runtime, Google user accounts and mail service APIs, and datastore

APIs that provides access to powerful persistence engine with querying and

transaction support. The SDK also provides a server that emulates the Google App

Engine platform. This helps developers to develop applications locally and check

how it will perform on the Google's cloud upon deployment. Once you have created

the application you can deploy it on Google's server using the command line.

Getting started



With this month's PCQ Professional DVD, we have distributed the Google App
Engine version 1.1.5 and also the setup of Python 2.5.2 that is needed to run

the App Engine platform. For this article, we will be using Windows as the

operating platform, and so the installers provided in DVD are for Windows OS.

The installers for Linux and Mac can be downloaded from the App Engine site.

Since python is the pre-requisite for App Engine SDK, we need to install python

version 2.5 first. Then you can install the App Engine SDK. Now you are ready to

develop applications that will run on Google's cloud infrastructure.

The command dev_appserver.py starts the App Engine web server and listens for requests on port 8080.

To test that your setup is running; go to the command line and run the

dev_appserver.py command. If an error message comes of invalid arguments, the

App Engine server has been setup correctly.

Demo application



The web application that we will be making for this demo will be a simple
guestbook sort of application whereby any visitor can leave a comment on the

webpage. In the application, we will have just two requests: one to render the

page and other to record what the visitor comments on the page. To start

creating the application, first create a directory “guestbook” and all the files

for the application will reside in this directory. The App Engine application

requires a configuration file called app.yaml. This yaml file describes which

URLs will be used by which handler scripts. The following code snippet shows the

yaml file for our application. The application identifier “guestbook” is the

name of the application and we specify all URLs to be handled by the main.py

script.

application: pcqdemoapp



version: 1


runtime: python


api_version: 1


handlers:


- url: .*


script: main.py

To upload the web application online on App Server appcfg.py command is used. And when prompted for email and password, pass your email id.

Webapp and datastore



Since the application has to render web pages we have to use webapp framework
which will handle the requests for such tasks. Therefor we will have to import

WSGI handlers to handle the requests and the same will also be used to call

Django template. While the datastore API lets you store persistent data and then

retrieve it throughout your application. The code of the application looks like

following and name the code file as “main.py”.

#!/usr/bin/env python



import wsgiref.handlers


from google.appengine.ext import db


from google.appengine.ext import webapp


from google.appengine.ext.webapp import template


class GuestBook(db.Model):


message = db.StringProperty(required=True)


time = db.DateTimeProperty(auto_now_add=True)


sender = db.StringProperty()


class MyHandler(webapp.RequestHandler):


def get(self):


guestbooks = db.GqlQuery('SELECT * FROM GuestBook ORDER BY time DESC') values =
{



'guestbooks': guestbooks


}


self.response.out.write(template.render('main.html',values))


def post(self):


guestbook = GuestBook(


message=self.request.get('message'),


sender=self.request.get('sender'))


guestbook.put()


self.redirect('/')


def main():


app = webapp.WSGIApplication(<(r'.*', MyHandler)>, debug=True)


wsgiref.handlers.CGIHandler().run(app)


if __name__ == "__main__":


main()

The class GuestBook defines the three attributes for the database structure.

And using GqlQuery on database, we can retrieve the contents of the database.

The class MyHandler inherits from webapp.RequestHandler and therefore in the GET

method we will render the page request. With response.out we will pass the

values retrieved from the datastore but also a template designed that will be

used to display the output in a specified format, in our case it will be

“main.html” file. Similarly, for the POST method we will capture the content

from the user's request, i.e. from the textboxes named message and sender, and

pass the value to variable which is of type GuestBook.

In the above code snippet, we have to redirect the user to same page, so we

will use self.redirect('/') in the POST method, which will return the request

onto the same page webpage after rendering the result from the GET method also.

The demo application can be accessed at http://pcqdemoapp.appspot.com. All applications for App Engine are hosted on appspot.com

The following code snippet shows the main.html file which will be used as

template for our web application.

PCQ Demo Guest Book App

{% for guestbook in guestbooks %}

{% endfor %}

The main.html template will use Django template engine to render the Web

page. Using the script we first loop through the guestbooks list that we have

passed along as a parameter in the GET method when we called the template.

Deploying on App Engine



When we are done with the writing the application, we can test the Web app

on the web server provided with the SDK. To start the web server use the dev_

appserver. py command by giving it the path to the guestbook directory. The
command will be like this:

dev_appserver.py c:/guestbook

The web server would be up, and ready to listen requests on port 8080. To

test the webapp, type the URL http://localhost:8080 in your browser. Even if you

do changes in the web application code, you will not have to restart the Web

server, the changes will reflect as soon as you refresh the browser page. Since,

we are using a Google's datastore to save the comments on the guestbook. So each

time when you use the guestbook application, the comments from the previous

session won't be lost. But if we want to clear the comment history from the

server we have to pass the option when we start the server as follows:

dev_appserver.py —clear_datastore c:/guestbook

Now you can upload and deploy this application on Google App Engine. For that

first we need to register at appengine.google.com website. Sign in into App

Engine using your Google account or create a new one. Now through the App Engine

Administration Console, click the “Create an Application” button and register a

unique application name for your Webapp. This application ID will become the URL

for your webapp if you elect to host your application on appspot.com. For our

guestbook application we registered the application with ID “pcqdemoapp”.

Therefore the URL for that is:

pcqdemoapp.appspot.com

You can access the demo app at this address. Now to upload the guestbook

application, first edit the app.yaml file. Change the value of the application:

setting from guestbook to your registered application ID. Through the command

line, run the following command:

appcfg.py update c:/guestbook

Enter your Google ID and password when prompted and when the update has been

made, you can access your application by prefixing your application ID before

appspot.com and enter that as your URL.

Thus, we can create apps to be hosted on the Google cloud using App Engine

SDK.