Cloud Platforms: Google App Engine
Google App Engine’s overview and pros
Google App Engine is a cloud computing platform for developing and hosting web applications in Google-managed data centers. It differs from similar solutions, such as Amazon Web Services, which serve as Infrastructure-as-a-Service, while App Engine is Platform-as-a-Service. It virtualizes applications across multiple servers and data centers. Main App Engine offerings include dynamic web serving, persistent storage with queries, automatic scaling, load balancing, APIs for authenticating users and sending e-mails using Google Accounts. The offerings also feature a local development environment for simulating App Engine on a user’s computer and scheduled tasks for triggering events at specified times.
- Google App Engine’s setup, development, and deployment are fairly simple, since App Engine supports a narrow web app scenario and users do not have to instal an operating system, configure Apache, or optimize MySQL.
- App Engine also features a dedicated Python runtime environment, which includes a fast Python interpreter and the standard library. The Java and Python runtime environments are built to ensure that the application runs quickly, securely, and without interference from other apps on the system.
- If necessary, the technology handles deploying the code to a cluster, monitoring, failover, and launching application instances.
- Google App’s pricing model is another advantage: one needs a zero-cost package to get started with the solution. All applications can use up to 500 MB of storage, as well as enough CPU and bandwidth to support an efficient app serving around 5 million page views per month, absolutely free. When a user enables billing for an application, her/his free limits are raised, and s/he only pays for the resources used above the free levels.
- A platform provides a powerful distributed storage service that features a query engine and transactions. Just as the distributed web server grows with one’s traffic, the distributed datastore grows with her/his data. The App Engine datastore is not like a traditional relational database. Data objects, or “entities,” have a kind and a set of properties. Datastore entities are “schemaless.” The structure of data entities is provided by and enforced by one’s application code. The Java JDO/JPA interfaces and the Python datastore interface include features for applying and enforcing structure within one’s app. The 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 an entity occurs in a transaction that is retried a fixed number of times if other processes are trying to update the same entity simultaneously. One’s application can execute multiple datastore operations in a single transaction, which either all succeed or all fail, ensuring the integrity of her/his data.
- Applications run in a secure environment that provides limited access to the underlying operating system. The sandbox isolates the application in its own secure, reliable environment that is independent of the hardware, operating system, and physical location of the web server.
Cons and recommended use
Below, we enlist certain difficulties you may encounter working with App Engine.
- The Google App Engine PaaS delivers a computing platform and solution stack as a service, often consuming cloud infrastructure and sustaining cloud applications. It facilitates deployment of applications without the cost and complexity of buying and managing the underlying hardware and software layers. 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.
- Though high security is an advantage of Google App Engine, it also brings a set of limitations, including that an application can only access other computers on the Internet through the provided URL fetch and e-mail services. An application cannot write to the file system. An app can read files, but only files uploaded with the application code. The app must use the App Engine datastore, memcache, or other services for all data that persists between requests. Further, application code only runs in response to a web request, a queued task, or a scheduled task, and must return response data within 30 seconds in any case. A request handler cannot spawn a subprocess or execute code after the response has been sent.
- Google Datastore is implemented on top of Google BigTable and it is the only persistence mechanism eligible to be used.
Google App Engine can be deployed as a solution for individual developers who need to test the scalability of their applications or who are involved in some basic projects.
- Cloud Platforms: enStratus
- Cloud Platforms: Windows Azure—Ideal Cloud Architecture for .NET Developers
- Cloud Platforms: Amazon EC2—Extremely Scalable Cloud Computing Environment
The post was written by Sergey Bushik and Katherine Vasilega.