Prof. A.R.

Rele

What Is Google App Engine?

Google App Engine lets users run web applications on Google's infrastructure. App Engine applications are easy to build, easy to maintain, and easy to scale as your traffic and data storage needs grow. With App Engine, there are no servers to maintain: Users just need to upload your application, and it's ready to serve other users. Users can serve your app from your own domain name (such as http://www.example.com/) using Google Apps. Or, you can serve your app using a free name on the appspot.com domain. You can share your application with the world, or limit access to members of your organization. Google App Engine supports apps written in several programming languages. With App Engine's Java runtime environment, you can build your app using standard Java technologies, including the JVM, Java servlets, and the Java programming languageor any other language using a JVM-based interpreter or compiler, such as JavaScript or Ruby. App Engine also features two dedicated Python runtime environments, each of which includes a fast Python interpreter and the Python standard library. Finally, App Engine provides a Go runtime environment that runs natively compiled Go code. These runtime environments are built to ensure that your application runs quickly, securely, and without interference from other apps on the system. App Engine costs nothing to get started. All applications can use up to 1 GB of storage and enough CPU and bandwidth to support an efficient app serving around 5 million page views a month, absolutely free. When you enable billing for your application, your free limits are raised, and you only pay for resources you use above the free levels.

The Application Environment

Google App Engine makes it easy to build an application that runs reliably, even under heavy load and with large amounts of data. App Engine includes the following features: dynamic web serving, with full support for common web technologies persistent storage with queries, sorting and transactions automatic scaling and load balancing APIs for authenticating users and sending email using Google Accounts a fully featured local development environment that simulates Google App Engine on your computer task queues for performing work outside of the scope of a web request scheduled tasks for triggering events at specified times and regular intervals
Your application can run in one of three runtime environments: the Go environment, the Java environment, and the Python environment

The Sandbox
Applications run in a secure environment that

provides limited access to the underlying operating system. These limitations 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 the hardware, operating system and physical location of the web server.

The Java Runtime Environment

You can develop your application for the Java runtime environment using common Java web development tools and API standards. Your app interacts with the environment using the Java Servlet standard, and can use common web application technologies such as JavaServer Pages (JSPs). The Java runtime environment uses Java 6. The App Engine Java SDK supports developing apps using either Java 5 or 6. The environment includes the Java SE Runtime Environment (JRE) 6 platform and libraries. The restrictions of the sandbox environment are implemented in the JVM. An app can use any JVM bytecode or library feature, as long as it does not exceed the sandbox restrictions. Your app accesses most App Engine services using Java standard APIs. For the App Engine datastore, the Java SDK includes implementations of the Java Data Objects (JDO) and Java Persistence API (JPA) interfaces. Your app can use the JavaMail API to send email messages with the App Engine Mail service. Thejava.net HTTP APIs access the App Engine URL fetch service.

Storing Your Data

The App Engine environment provides a range of

options for storing your data: App Engine Datastore provides a NoSQL schemaless object datastore, with a query engine and atomic transactions. Google Cloud SQL provides a relational SQL database service for your App Engine application, based on the familiar MySQL RDBMS. Google Cloud Storage provides a storage service for objects and files up to terabytes in size, accessible from Python and Java applications.

The Data Store

App Engine provides a distributed NoSQL data storage service that features a query engine and transactions. Just as the distributed web server grows with your traffic, the distributed 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. Datastore entities are "schemaless." The structure of data entities is provided by and enforced by your application code. The Java JDO/JPA interfaces and the Python datastore interface include features for applying and enforcing structure within your app. Your app can also access the datastore directly to apply as much or as little structure as it needs. The datastore is strongly consistent and uses optimistic 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 multiple 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 within 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

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 using the same high-speed Google infrastructure that retrieves web pages for many other Google products.

Mail Applications can send email messages using App Engine's mail service. The mail service uses Google infrastructure to send email messages.
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 transactional features of the datastore, such as temporary data or data copied from the datastore to the cache for high speed access. 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.

Development Workflow
The App Engine software development kits (SDKs) for Java, Python,

and Go each include a web server application that emulates all of the App Engine services on your local computer. Each SDK includes all of the APIs and libraries available on App Engine. The web server also simulates the secure sandbox environment, including checks for attempts to access system resources disallowed in the App Engine runtime environment. Each SDK also includes 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. When you build a new major release of an application that 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.

Java SDK
You develop and upload Java applications for Google App Engine using the App Engine Java software development kit (SDK). The SDK includes software for a web server that you can run on your own computer to test your Java applications. The server simulates all of the App Engine services, including a local version of

the datastore, Google Accounts, and the ability to fetch URLs and send email from your computer using the App Engine APIs.

Trying a Demo Application

The App Engine Java SDK includes several demo

applications in the demos/ directory. The final version of the guest book application you will create in this tutorial is included under the directory guestbook/. Start the guest book demo in the development server by running the following command at a command prompt: appengine-java-sdk\bin\dev_appserver.cmd appenginejava-sdk\demos\guestbook\war The development server starts, and listens for requests on port 8080. Visit the following URL in your browser: http://localhost:8080/

Creating a Project
App Engine Java applications use the Java Servlet

standard for interacting with the web server environment. An application's files, including compiled classes, JARs, static files and configuration files, are arranged in a directory structure using the WAR standard layout for Java web applications.

The Project Directory

We will use a single directory named Guestbook/ for

all project files. A subdirectory named src/ contains the Java source code, and a subdirectory named war/ contains the complete application arranged in the WAR format. Our build process compiles the Java source files and puts the compiled classes in the appropriate location in war/.

The Project Directory

The complete project directory looks like this:

Guestbook/ src/ ...Java source code... META-INF/ ...other configuration... war/ ...JSPs, images, data files... WEB-INF/ ...app configuration... lib/ ...JARs for libraries... classes/ ...compiled classes...

The Servlet Class

App Engine Java applications use the Java Servlet

API to interact with the web server. An HTTP servlet is an application class that can process and respond to web requests. Our guest book project begins with one servlet class, a simple servlet that displays a message create the directories for the path src/guestbook/, then create the servlet class file described below.

 In the directory src/guestbook/, make a file named

GuestbookServlet.java with the following contents:

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"); } }

The web.xml File

When the web server receives a request, it determines

which servlet class to call using a configuration file known as the "web application deployment descriptor." This file is named web.xml, and resides in the war/WEB-INF/ directory in the WAR. WEBINF/ and web.xml are part of the servlet specification. In the directory war/WEB-INF/, a file named web.xml has the following contents:

 <?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE web-app PUBLIC "-//Oracle Corporation//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>

The appengine-web.xml File

App Engine needs one additional configuration file to

figure out how to deploy and run the application. This file is named appengine-web.xml, and resides in WEB-INF/ alongside web.xml. It includes the registered ID of your application (Eclipse creates this with an empty ID for you to fill in later), the version number of your application, and lists of files that ought to be treated as static files (such as images and CSS) and resource files (such as JSPs and other application data).

In the directory war/WEB-INF/, a file named appengine-web.xml has the following contents:

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

Running and Testing the Application

The App Engine SDK includes a web server application

you can use to test your application. The server simulates the App Engine environment and services, including sandbox restrictions, the datastore, and the services.
http://localhost:8080/guestbook

Registering the Application

You create and manage App Engine web applications from the App Engine Administration Console, at the following URL: https://appengine.google.com/ Sign in to App Engine using your Google account. To create a new application, click the "Create an Application" button. Follow the instructions to register an application ID, a name unique to this

application.

Edit the appengine-web.xml file, then change the value of the <application> element to be your registered application ID. You should probably elect to use the free appspot.com domain name, and so the full URL for the application will behttp://your_app_id.appspot.com/

Uploading Your Application

You create and manage applications in App Engine

using the Administration Console. Once you have registered an application ID for your application, you upload it to App Engine using either the Eclipse plugin, or a command-line tool in the SDK.

Prompt
You can upload your application code and files using a

command included in the SDK named appcfg.cmd (Windows) AppCfg is a multi-purpose tool for interacting with your app on App Engine. The command takes the name of an action, the path to your app's war/ directory, and other options. To upload the app, using Windows: ..\appengine-java-sdk\bin\appcfg.cmd update

Accessing Your Application

You can now see your application running on App

Engine. If you set up a free appspot.com domain name, the URL for your website begins with your application ID: http://your_app_id.appspot.com/