This is our first blog dedicated to cloud computing. It is intended to be used by all interested on the cloud, to share ideas, questions and best practices on how to program on the cloud.
Currently, everyone seems to have different definition of what cloud computing really means. That is why we decided to create this blog, hoping that it will guide you step by step through the whole process of using it as a platform of your cutting edge applications.
In this blog we will talk about Google and its web application hosting service – App Engine. We will cover its basic concepts and how to write applications for it.
Introducing Google App Engine
Gives you an overview of Google App Engine and its components, tools, and major features.
Creating an application
Describes how to create an application, setting up a development environment, setting up accounts and domain names, and deploying the application on Google App Engine. It also demonstrates how to use of the App Engine features – Google Accounts, the data store, and memcache – to implement a pattern to many web applications: storing and retrieving user preferences.
Handling Web requests
Contains details about App Engine’s architecture, the various features of the frontend, app servers, and static file servers, and details about the App Server runtime environment for Python and Java. The frontend routes requests to the App Engine servers and the static file servers, and manages secure connections and Google Accounts authentication and authorization.
Gives a brief introduction of the App Engine datastore, a strongly consistent scalable data object storage system with support for local transactions. It also introduces data entities, keys and properties, and Python and Java APIs for creating, updating, and deleting entities.
Describes the datastore queries and indexes, and the Python and Java APIs for queries. The App Engine datastore’s query engine uses prebuilt indexes for all queries. This paragraph describes the features of the query engine in detail, and how each feature uses indexes. It also discusses how to define and manage indexes for your application queries.
Talks about datastore transactions and how to keep your data consistent. The App Engine datastore uses local transactions in a scalable environment. This paragraph attempts to provide a complete explanation of how the datastore updates data, and how to design your data and your app to best take advantage of these features.
Data Modeling with Python
Introduces data modeling with Python, how to use Python data modeling API to enforce invariants in your data schema. The datastore itself is a schemaless, a fundamental aspect of its scalability.
The Java Persistence API
Introduces the Java Persistence API (JPA), how its concepts translate to the datastore, how to use it to model data schemas, and how using it makes your application easier to port to other environments. JPA is a J2EE standard interface. App Engine also supports another standard interface known as Java Data Objects (JDO), though JDO will not be covered.
The Memory Cache
Gives an overview of Google’s memory cache service – memcache, and its Python and Java APIs. Aggressive caching is essential for high-performance web applications.
Fetching URL and Web Resources
Talks about how to fetch resources on the Internet via HTTP by using the URL Fetch service.
Sending and Receiving Mail and Instant Messages
Talks about how to send and receive mail and instant messages. It covers receiving mail and XMPP chat messages relayed by App Engine using request handlers. It also discusses creating and processing messages using tools in the API.
Bulk Data Operations and Remote Access
Gives you and introduction of how to perform large maintainance operations on your live application using scripts running on your computer. Tools included in the SDK make it easy to back up, restore, load, and retrieve data in your datastore. You can also write your own tools using the remote access API for data transformations and other jobs. You can also run an interactive Python shell that uses the remote API to manipulate a live Python or Java app.
Task Queues and Scheduled Tasks
Introduces queues and scheduled tasks. Task queues perform tasks in parallel by running your code on multiple application servers. Tasks can also be executed on a regular schedule with no user interaction.
The Django Web Application Framework
Gives an overview of the Django Web Application Framework with the Python runtime environment. It discusses how to set up a Django project, using the Django App Engine Helper, and taking advantage of features of Django via the Helper such as using the App Engine data modeling interface with forms and text fixtures.
Deploying and Managing Applications
Talks about how to deploy, upload and run your applications on App Engine, to update and test an application using app versions, and how to manage and inspect the running application.