Notes on Google App Engine

taxidermistplateΛογισμικό & κατασκευή λογ/κού

7 Νοε 2013 (πριν από 3 χρόνια και 9 μήνες)

85 εμφανίσεις

Page
1

of
12

Notes on
Google
App Engine

Created

12/01
/08

Updated 03/12/09, Updated 05/09/09
, Updated 06/08/09
,
Updated 07/23/09
, Up
dated 11/18/09
,

Updated 01
/02/10

Updated 01/24/11
,
Updated 02/17/11
, Updated 03/31/11
, Updated 11/29/12, Updated 09/09/13


http://code.google.com/googleapps/appsscript/jdbc_overview.html


http://groups.googl
e.com/group/google
-
appengine
-
java/web/will
-
it
-
play
-
in
-
app
-
engine?pli=1


http://gae
-
java
-
persistence.blogspot.com/2009/10/creating
-
bidrectional
-
owned
-
one
-
to
-
many.html

Introduction

Google App Engine is
cloud computing

technology. It virtualizes applications across multiple servers and data
centers.
[1]

Other "cloud"
-
based platforms include offerings
such as
Amazon Web Services

and Microsoft's
Azure
Services Platform
.

App Engine differs from services like Amazon Web Services, though, in that AWS is
Infrastructure as a Service

while App Engine is
Platform as a Service
.


Google App Engine lets you run your web applications on Google's infrastructure.

App Engine applications are
easy to build, easy to maintain, and easy to sc
ale as your traffic and data storage needs grow.

With App Engine,
there are no servers to maintain:

y
ou just upload your application, and it's ready to serve your users.


You can serve y
our app

on the
appspot.com

domain, or
use Google Apps to

serve it fr
om your own domain.

You can share your application with the world, or limit access to members of your organization.


Python was the initial language supported

(original release in April 2008)
, but in late Spring 2009 they began to
offer

Java.
In 2008 and

2009,
development was

focused on the P
ython version
.

Starting in 2010, development

focused on the Java version.

This document has been completely re
-
written to place the Java concepts first
,
moving Python into an Appendix
.


In summer 2010, Google announ
ced Google App Engine for Business, which includes

service level agreements,

a
management console, and SQL database access. Though the SQL access was promised for the end of 2010, it
hasn’t been released yet.

More details are discussed below.

Market Resp
onse

The Google Apps Marketplace offers products and services designed for Google users, including installable apps
that integrate directly with Google Apps. Installable apps are easy to use because they include single sign
-
on,
Google's universal navigati
on, and some even include features that integrate with your domain's data.


Statistics given at a presentation

by Google on 03/31/11 reported:


Currently at 1B page views/day

100K+ developers are updating applications each month

150K+ apps active each week

Page
2

of
12

Pricing


Resources

Unfortunately most
third
-
party
resources have been focused on the Python version, but books have appeared
recently about the Java version.


“Programming Google App Engine:

Build and Run Scalable Web Apps on Google's Infrastructure” by

Dan
Sanderson.
O’Reilly

Press,
November
2009
, 400 pages
.
List price $44.99, Amazon price $28.20, used from
$17.33.
Rated 4
.5

stars on Amazon.com. Appears to cover both the Python and the Java sides.


“Beginning Java Google App Engine” by Kyle Roche an
d Jeff Douglas. APress,
December
2009
, 264 pages
. L
ist
Price $44.99, Amazon price $34.19, used from $2.56. Rated 3.5

stars on Amazon.com.

Reviews were mixed, as
several pointed out that it covers low
-
level material that can be found elsewhere.
Discuss
ed ho
w to build
applications at the s
ervlet level, then provided an overview of the compatibility of various Java frameworks.
Focused on Spring.

Chapter at the end on deployment and administration.


“Using Google App Engine” by Charles

Severance
. O’Reil
ly Press, May

2009
,
262

pages. List price $29.99,
Amazon price
$19.72, used from
$18.72
. Rated 4 stars on Amazon.com.

Reviews were mixed, as they indicated
that half the book isn’t about App Engine in specific, but about
general concepts of the I
nternet

and cloud
computing.

The material on App Engine was rated well.


“Developing with Google App Engine” by
Eugene Ci
urana. AP
ress,
May 2009,
164

pages. List price $19.98,
Amazon price $17.99, used from $12.13. Rated 3 stars on Amazon.com.

A rather short book, which is considered
to be a good introduction, but you can get most of the information from Google’s develop
er documentation.


“Learning Python, 3
rd

Edition”

by Mark Lutz. O’Reilly Press, June 2008,
746

pages. List price $39.99, Amazon
price

$26.39, used from $19.20
.

Rated 4 stars on Amazon.com.

Greatly expanded since the first edition in 1999,
but still the

best
-
written introduction

and set of examples for using P
ython
.

Concepts

The basic model of the Google App Engine is that you are running in a JVM that is cloud
-
based and can access
data from the datastore, which is itself a cloud
-
based persistence facili
ty. The organization of the application is a
series of request handlers, based on the servlet api.


App Engine Services



there are a variety of services available to your application, such as user, image, mail, etc.

Page
3

of
12


The Datastore



this is the persisten
ce facility. It consists of a BigTable, which can be accessed at a low level, or
through JPA and JDO wrappers.


The Sandbox



this represents the runtime work area in which applications can be tested.


User management



user identity is supported through
Google Accounts logins and ids


Development tools

are Ecl
ipse based

and include a plug
-
in that generate application skeletons, and contains a test
application server (based on Tomcat or Jetty) for running your app locally.


The J
ava Runtime environment

is
fairly standard. There is no native support beyond the Servlet and JSP API’s, so
it is up to you to identify any frameworks that you choose to use. Typical candidates are Spring, Struts 2, Wicket,
JSF, and others.




The runtime environment also tracks
Quo
ta
s and limits
. For instance, your app must response within 30
seconds or the request will be canceled, and the app penalized.


The
Deployment process

is like deploying into the Apple App Store. You need a developer id, and an account,
and then you publi
sh into through an API (the Eclipse Plug
-
in has this function on a menu item).

Differences from other Application Hosting

Compared to other scalable hosting services such as
Amazon EC2
, App Engine provides more infrastructure to
make it easy to write scalable applications, but can
only

run a limited range of applications designed for that
infrastructure.


App Engine's infrastructure removes many of the system administration and developm
ent challenges of building
applications to scale to hundreds of requests per second and beyond.
[14]


Google handles deploying code to a
cluster, monitoring, failover, and laun
ching application instances as necessary.


While other services let users install and configure nearly any *NIX compatible software, App Engine requires
developers to use only its
supported languages, APIs, and frameworks
.

Current APIs allow storing and retrieving
data from a
BigTable

non
-
relational data
base; making HTTP requests; sending e
-
mail; manipulating images; and
caching.

Most existing Web applications can't run on App Engine without modification, because they require a
relational database.


Per
-
day and per
-
minute quotas restrict bandwidth and CP
U use, number of requests served, number of concurrent
requests, and calls to the various APIs, and individual requests are terminated if they take more than 30 seconds or
return more than 10MB of data.

Google App Engine for Business (May 2010)

Google App
Engine for Business introduces a number of new features that our enterprise customers have been
asking for, including:



Centralized administration:

A new, company
-
focused administration console lets you manage all the
applications in your domain.



Reliabilit
y and support:

99.9% uptime service level agreement, with premium developer support
available.



Secure by default:

Only users from your Google Apps domain can access applications and your security
policies are enforced on every app.



Pricing that makes sense
:

Each application costs just $8 per user, per month up to a maximum of $1000
a month. Pay only for what you use.



Enterprise features:

Coming later this year, hosted SQL databases, SSL on your company’s domain for
secure communications, and access to advan
ced Google services.


Page
4

of
12

With these new features, we’re making it easier for businesses to take advantage of the core benefits of Google
App Engine: easy development using languages you already know (Java and Python); simple administration, with
no need to wo
rry about hardware, patches or backups; and effortless scalability, automatically getting the capacity
you need when you need it.

App Engine Services

App Engine provides a variety of services that enable you to perform common operations when managing your

application.

The following APIs are provided to access these services:

URL Fetch

Applications can access resources on the Internet, such as web services or other data, using App Engine's URL
fetch service.

The URL fetch service retrieves web resources u
sing the same high
-
speed Google infrastructure that
retrieves web pages for many other Google products.

For more information about the URL fetch service, see
the
URL Fetch API reference
.

Mail

Applications can send email messages using App Engine's mail service.


The mail service uses Google
infrastructure to send email messages.

For more information about the mail service, see
the Mai
l API reference
.

Memcache

The Memcache service provides your application with a high performance in
-
memory key
-
value cache that is
accessible by multiple instances of your application. Memcache is useful for data that does not need the
persistence and tra
nsactional features of the datastore, such as temporary data or data copied from the datastore to
the cache for high speed access. For more information about the Memcache service, see
the Memca
che API
reference
.

Image Manipulation

The Image service lets your application manipulate images. With this API, you can resize, crop, rotate and flip
images in JPEG and PNG formats. For more information on the image manipulation service, see
the Images API
reference
.

Structure of an Example Application

Implement
ed as a set of request handlers, such as doGet, and doPut(), followed by a response generation using
inline HTML or a JSP.


With service

calls


Google A
pp Engine is focused on GWT, but can support others.

Interestingly, the GWT organization is not
visibly based on a service, but is something in which you write a “server” and “client”.

Examples that we have found Useful

MyERP: an applicat
ion on the Google Marketplace.


Zoho Invoice: another erp/financial application


What do these
apps
use for storage?

It appears that they are not actually running on the App Engine, but instead
have an App Engine
-
based stub for login and advertizing, then

the guts of the program is a more traditional J2EE
app (perhaps in the cloud).

Page
5

of
12

The Datastore

Datastore entities are schemaless:

Two entities of the same kind are not obligated to have the same properties, or
use the same value types for the same properti
es.

The application is responsible for ensuring that entities conform
to a schema when needed.


The datastore provides a low
-
level API with simple operations on entities, including
get
,
put
,
delete
, and
query
.

You can use the low
-
level API to implement o
ther interface adapters, or just use it directly in your
applications.


App Engine provides a powerful distributed data storage service that features a query engine and transactions. Just
as the distributed web server grows with your traffic, the distribut
ed datastore grows with your data.


The App Engine datastore is not like a traditional relational database. Data objects, or "entities," have a kind and a
set of properties. Queries can retrieve entities of a given kind filtered and sorted by the values
of the properties.
Property values can be of any of the supported
property value types
.


The datastore uses
optimistic locking

for concurrency control. An update of a entity occurs in a transaction that is
retried a fixed number of times if other processes are trying to update the same entity simultaneously. Your
application can execute mult
iple datastore operations in a single transaction which either all succeed or all fail,
ensuring the integrity of your data.


The datastore implements transactions across its distributed network using "entity groups." A transaction
manipulates entities wit
hin a single group. Entities of the same group are stored together for efficient execution of
transactions. Your application can assign entities to groups when the entities are created.


For more information about the datastore, see
the Datastore API reference
.


Working with App Engine's scalable datastore requires you to rethink your indoctrination to the benefits of
normalized data. Of course, if you have worked long enough in the real world
, you probably have sacrificed
normalization on the altar of performance once or twice already. The difference is, when dealing with the App
Engine datastore, you must de
-
normalize early and often.

De
-
normalization

is no longer a dirty word; instead, it i
s
a design tool that you will apply in many aspects of your App Engine for Java applications.


The main drawback to App Engine for Java's leaky persistence comes up when you try to port an application
written for an RDBMS to App Engine for Java.

The App E
ngine for Java datastore is not a drop
-
in replacement
for a relational database, so what you do with App Engine for Java may not be easy to translate to an RDBMS
port.

Taking an existing schema and porting it to the datastore is an even less likely scenar
io.

If you do decide to
port a legacy Java enterprise application to App engine, be advised to proceed with caution, and back it up with
analysis.

Google App Engine is a platform for applications designed for it specifically. Google App Engine for
Java's

support for JDO and JPA enables these apps to be ported back to more traditional, albeit un
-
normalized,
enterprise applications.

The Sandbox

Applications run in a secure environment that provides limited access to the underlying operating system.

These
l
imitations allow App Engine to distribute web requests for the application across multiple servers, and start and
stop servers to meet traffic demands.


The sandbox isolates your application in its own secure, reliable
environment that is independent of th
e hardware, operating system and physical location of the web server.


Examples of the limitations of the secure sandbox environment include:




An application can only access other computers on the Internet through the provided URL fetch and
email services

and APIs.

Other computers can only connect to the application by making HTTP (or
HTTPS) requests on the standard ports.

Page
6

of
12



An application cannot write to the file system.

An app can read files, but only files uploaded with the
application code.

The app m
ust use the App Engine datastore for all data that persists between requests.



Application code only runs in response to a web request, and must return response data within a few
seconds.

A request handler cannot spawn a sub
-
process or execute code after
the response has been sent.

User and Session Management

The user service provides a way to have Google log you in.


Session management needs further discussion.

The Java Runtime Environment

Built around servlets, plus the Google Datastore


See
http://www.slideshare.net/sggtug/talk
-
1
-
google
-
app
-
engine
-
development
-
java
-
data
-
models
-
and
-
other
-
th
ings
-
you
-
should
-
know
-
navin
-
kumar
-
cto
-
of
-
socialwokcom


Out of the box, you can use JSP’s in a simple form.

Using JPA

Remember that this isn’t Hibernate, but is the JPA counterpart of it. Hence, there are restrictions such as not
having a Criteria API, etc
.


In addition, there are limits within the App Engine implementation of JPA. The following are not supported:



Owned many
-
to
-
many relationships, and unowned relationships. You can implement unowned
relationships using explicit Key values, though type che
cking is not enforced in the API.



"Join" queries. You cannot use a field of a child entity in a filter when performing a query on the parent
kind. Note that you can test the parent's relationship field directly in a query using a key.



Aggregation queries

(group by, having, sum, avg, max, min)



Polymorphic queries. You cannot perform a query of a class to get instances of a subclass.

Each class is
represented by a separate entity kind in the datastore.

Frameworks that are A
pplicable

http://stackoverflow.com/questions/762821/what
-
java
-
framework
-
would
-
you
-
use
-
with
-
google
-
app
-
engine




Slim3



This is interesting because it is focused on building
MVC applications on top of the Google App
Engine, in a simple way. It is also interesting in that it is written at a lower level than the JPA layer itself
(connecting to the data store, and apparently operating about 3 times faster). Like Struts, this al
so has a
tag lib for common HTML elements, and for form management.



Spring


the notes indicate that Spring ORM and Spring MVC are compatible.



Struts?

Presentation Frameworks

GWT

is preferred

because it is from Google
, but it would appear that we can use a
ny, including Wicket, JSF, etc.
This is because all Google is providing is the servlet API and the persistence facilities. Everything else must be
coded or a library integrated for it.


On the JavaScript (client
-
browser) side, there are no limits, since
it is running on the browser. There are few
statistics available, but it appears that traditional Java Apex and JavaScript tools such as prototype, script.ac.ulous,
and jQuery are used.

Page
7

of
12

Configuration

All system properties and environment variables are pri
vate to your application.

Setting a system property only
affects your application's view of that property, and not the JVM's view.


You can set system properties and environment variables for your app in the
deployment descriptor
.


App Engine sets two system properties that identify the runtime environment:



com.google.appengine.runtime.environment

is
"Production"

when running
on App Engine, and
"Development"

when running in the d
evelopment server.



com.google.appengine.runtime.version

is the version ID of the runtime environment,
such as
"1.3.0"
.

In addition to using
System.getProperty()
, you can access system properties using our
type
-
safe API
.
For example:

if

(
SystemProperty
.
environment
.
value
()

==





SystemProperty
.
Environment
.
Value
.
Production
)

{





// The app is running on App Engine...

}

App Engine also sets t
he following system properties when it initializes the JVM on an app server:



file.separator



path.separator



line.separator



java.version



java.vendor



java.vendor.url



java.class.version



java.specification.version



java.specification.vendor



java.specification.na
me



java.vm.vendor



java.vm.name



java.vm.specification.version



java.vm.specification.vendor



java.vm.specification.name



user.dir

Quotas and Limits

Google App Engine allocates resources to your application automatically as traffic increases to support many
sim
ultaneous requests. However, App Engine reserves automatic scaling capacity for applications with low
latency, where the application responds to requests in less than one second. Applications with very high latency
(over one second per request for many req
uests) are limited by the system, and require a special exemption in
order to have a large number of simultaneous dynamic requests. If your application has a strong need for a high
throughput of long
-
running requests, you can
request an exemption

from the simultaneous dynamic request limit.
The vast majority of applications do not require any exemption.


Applications that are heavily CPU
-
bound may also incur some additional latency in

order to efficiently share
resources with other applications on the same servers. Requests for static files are exempt from these latency
limits.


Each incoming request to the application counts toward the
Requests

quota.

Page
8

of
12


Data received as part of a reque
st counts toward the
Incoming Bandwidth (billable)

quota. Data sent in response
to a request counts toward the
Outgoing Bandwidth (billable)

quota.


Both HTTP and HTTPS (secure) requests count toward the
Requests
,
Incoming Bandwidth (billable)

and
Outgoing

Bandwidth (billable)

quotas. The Quota Details page of the Admin Console also reports
Secure
Requests
,
Secure Incoming Bandwidth

and
Secure Outgoing Bandwidth

as separate values for informational
purposes. Only HTTPS requests count toward these values.


C
PU processing time spent executing a request handler counts toward the
CPU Time (billable)

quota.


For more information on quotas, see
Quotas
, and the "Quota Details" section of
the Admin Console
.


In addition to quotas, the following limits apply to request handlers:

Limit

Amount

request size

10 megabytes

response size

10 megabytes

request duration

30 seconds

maxi
mum total number of files (app files and static files)

3,000

maximum size of an application file

10 megabytes

maximum size of a static file

10 megabytes

maximum total size of all application and static files

150 megabytes

Development Tools

As a Java de
veloper, your main tools are Eclipse, the App Engine SDK, and the Google Plugin for Eclipse.


The Ap
p Engine SDK is on version 1.4.3

as of
March 31
, 2011. It
includes a web server application that emulates
all of the App Engine services on your local comp
uter. The SDK includes all of the APIs and libraries available on
App Engine. The web server also simulates the secure sandbox environment, including checks for imports of
disabled modules and attempts to access disallowed system resources.


The SDK also i
ncludes a tool to upload your application to App Engine. Once you have created your application's
code, static files and configuration files, you run the tool to upload the data. The tool prompts you for your
Google account email address and password.


T
he App Engine Java SDK includes tools for testing your application, uploading your application files, and
downloading log data. The SDK also includes a component for
Apache Ant

to si
mplify tasks common to App
Engine projects.


The
Google Plugin for Eclipse

adds features to the Eclipse IDE for App Engine development, testing and
deployment, and includes the
complete App Engine SDK.

The Eclipse plugin also makes it easy to develop
Google Web Toolkit

applications and run them on App Engine.


The
development server

runs your application on your local computer for development and testing.

The server
simulates the App Engine datastore, services and sandbox restrictions.

The development server can also generate
configuration for datas
tore indexes based on the queries the app performs during testing.


A multipurpose tool called
AppCfg

handles all command
-
line interaction with your application running on

App
Engine. AppCfg can upload your application to App Engine, or just update the datastore index configuration so
you can build new indexes before updating the code.


It can also download the app's log data, so you can analyze
your app's performance using

your own tools.

Page
9

of
12

Create a Google App Project

This is done is about 3 dialog boxes


The result is:


Run on a Development Server

This is based on tomcat/Jetty


The datastore is local

Deployment I
ssues

When you build a new major release of an application tha
t is already running on App Engine, you can upload the
new release as a new version. The old version will continue to serve users until you switch to the new version.
You can test the new version on App Engine while the old version is still running.


Page
10

of
12

The Administration Console

is the web
-
based interface for managing your applications running on App Engine.
You can use it to create new applications, configure domain names, change whi
ch version of your application is
live, examine access and error logs, and bro
wse an application's datastore.

Google Accounts

App Engine includes a service API for integrating with Google Accounts.

Your application can allow a user to
sign in with a Googl
e account, and access the email address and displayable name associated with the account.
Using Google Accounts lets the user start using your application faster, because the user may not need to create a
new account.

It also saves you the effort of imple
menting a user account system just for your application.


If your application is running under Google Apps, it can use the same features with members of your organization
and Google Apps accounts.


The Users API can also tell the application whether the cu
rrent user is a registered administrator for the
application.

This makes it easy to implement admin
-
only areas of your site.

Deploying to Google App Engine

Once you have created the world's next killer application (because we really need a user
-
friendly g
reeting
application), you'll want to deploy it. The whole point of using Google App Engine is that you can deploy your
application on Google's solid infrastructure, making it easier to scale. Google App Engine is designed to provide a
platform for building

scalable applications "that grow from one to millions of users without infrastructure
headaches" (as stated on the App Engine home page). In order to use this infrastructure, you need a
Google App
Engine for Java account
.


Like many things in life, the first time is free. The free version of App Engine for Java gives a deployed
application enough CPU, bandwidth, and storage to serve about 5 million pageviews.
Beyond that, it's pay as you
go. (Also keep in mind that what's available as of this writing is a preview release of the App Engine for Java
platform.)


Once you get the account, you should see an empty list of applications at the
App Engine for Java site
. Click the
Create New Application

button and a form like the one in Figure 8 should appear. Enter a unique application
name and a description, after which you
will see a confirmation message with your application's identifier.

The identifier belongs in your application's app.yaml file as well. Note that the identifier cannot be changed. If you
use Google authentication for your application, "GAEj Article For Ric
k Part 1" will be displayed in the Sign In
pages when you access your application. You'll use
gaejarticleforrick

to deploy the application to
Google App Engine with the App Engine for Java Eclipse plugin.

Appendix A: Cost Information

App Engine for Busine
ss makes it affordable to run your company’s applications in the cloud with simple pricing
that doesn’t require quota management or over
-
provisioning.


Each application costs $8 per user, up to a maximum of $1000, per month.


For $8 per user, the applica
tion gets as much processing power as it needs for your intranet users in your Google
Apps domain. Each application gets plenty of storage too, but you can also buy more to share across all your
applications if you need it. At the end of the month, all of
the bills for each application are combined together into
a single bill for easy payment
-

no need to share a company card with the entire development team. And you only
ever pay for what you use.


You will also use App Engine for Business to run publicly

accessible apps, such as your company's website or
service. We’re still working out the details on pricing for that, so stay tuned.

Page
11

of
12

Appendix B: Related T
ools and Providers

There appear to be very few related tools. Perhaps everyone builds them directly
. Here is the only one that we
could find:



MyEclipse for Spring now allows users to quickly scaffold applications for Google App Engine (GAE),
streamlining deployment to the Google Cloud.


Using the power of MyEclipse for Spring scaffolding, users can poi
nt to existing Java Beans, JPA Entities or DB
Tables and generate fully functional Spring applications that are built to run on GAE.

MyEclipse for Spring tailors
and optimizes the generated code and configurations so that the generated application is read
y to run on GAE
.

Appendix C
: The Python Runtime Environment

Starting in 2007/
200
8, App Engine provided

a runtime environment that uses the Python programming language.


The Python runtime environment uses Python version 2.5 or later.


The environment incl
udes
the Python standard library
. Of course, calling a library method that violates a
sandbox restriction, such as attempting to open a socket or write to a file, will not succeed. For convenience,
severa
l modules in the standard library whose core features are not supported by the runtime environment have
been disabled, and code that imports them will raise an error.


Application code must be written exclusively in Python. Code with extensions written in
C is not supported.


The Python environment provides rich Python APIs for
the datastore
,
Google Accounts
,
URL fetch

and
email

services. App Engine also provides a simple Python web application framework called
webapp

to make it easy to
start building applications.

The Application Framework

For convenience, App Engine also includes
the Django web application framework
, version 0.96.1. Note that
the App Engin
e datastore is not a relational database, which is required by some Django components. Some
components, such as the Django template engine, work as documented, while others require a bit more effort. See
the
Articles

section for tips on using Django with App Engine.


You can upload other third
-
party libraries with your application, as long as they are implemented in pure Python
and do not require any unsupported standard library modules.


For more
information about the Python runtime environment, see
The Python Runtime Environment
.

The Template Facility

This is based on Django templates.


<h1>Shout out</h1>

{% for shout in shouts

%}

<div
class=”container”>

<div class=”{% ifequal shout.who “”

%} row {% else %} row altrow {% endifequal

%}”>

<div class=”text message”> {{ shout.message }} </div>

<div class=”text normaltext”> from </div>

{% ifequal shout.who “” %}

<div class=”text username”> An
onymous </div>

{% else %}

<div class=”text username”> {{shout.who}} </div>

{% endifequal %}

</div>

</div>

{% endfor

%}

<form action=”" method=”post”>

Page
12

of
12

<p>Message: <input type=”text” name=”message”/></p>

<p>From: <input type=”text” name=”who”/></p>

<p><input

type=”submit” value=”shout”></p>

</form>

Deploying to AppSpot

Click on Deploy in the Google app launcher to deploy it on Google.

Then you can access it @ url:
http://shoutout.appspot.com