Cloud Platform Blog

Get started with App Engine for PHP - scalable, secure and reliable

2013-05-16T14:49:00.000-07:00

At Google I/O, we announced PHP as the latest supported runtime for Google App Engine in Limited Preview. PHP is one of the world's most popular programming languages, used by developers to power everything from simple web forms to complex enterprise applications.

Now PHP developers can take advantage of the scale, reliability and security features of App Engine. In addition, PHP runs well with other parts of Google Cloud Platform. Let's look at how this works.

Connecting to Google Cloud SQL from App Engine for PHP

Many PHP developers start with MySQL when choosing a database to store critical information, and a wide variety of products and frameworks such as Wordpress make extensive use of MySQL’s rich feature set. Google Cloud SQL provides a reliable, managed database service that is MySQL 5.5 compatible and works well with App Engine.

To set up a Cloud SQL database, sign into Google Cloud Console - create a new project, choose Cloud SQL and create a new instance.

After you create the instance, it's automatically associated with your App Engine app.

You will notice Cloud SQL instances don’t need an IP address. Instead they can be accessed via a compound identifier made up of their project name and instance name, such as hello-php-gae:my-cloudsql-instance.

From within PHP, you can access Cloud SQL directly using the standard PHP MySQL libraries - mysql, mysqli or PDO_MySQL. Just specify your Cloud SQL database with its identifier, such as:

<?php

$db = new PDO(
  'mysql:unix_socket=/cloudsql/hello-php-gae:my-cloudsql-instance;dbname=demo_db;charset=utf8',
  'demo_user',
  'demo_password'
);

foreach($db->query('SELECT * FROM users') as $row) {
  echo $row['username'].' '.$row['first_name']; //etc...
}

Methods such as query() work just as you’d expect with any MySQL database. This example uses the popular PDO library, although other libraries such as mysql and mysqli work just as well.

Storing files with PHP and Google Cloud Storage

Reading and writing files is a common task in many PHP projects, whether you are reading stored application state, or generating formatted output (e.g., writing PDF files). The challenge is to find a storage system that is as scalable and secure as Google App Engine itself. Fortunately, we have exactly this in Google Cloud Storage (GCS).

The first step in setting up Google Cloud Storage is to create a bucket:

With the PHP runtime, we’ve implemented native support for GCS. In particular, we’ve made it possible for PHP’s native filesystem functions to read and write to a GCS bucket.

This code writes all prime numbers less than 2000 into a file on GCS:

<?php

$handle = fopen('gs://hello-php-gae-files/prime_numbers.txt','w');

fwrite($handle, "2");
for($i = 3; $i <= 2000; $i = $i + 2) {
  $j = 2;
  while($i % $j != 0) {
    if($j > sqrt($i)) {
      fwrite($handle, ", ".$i);
      break;
    }
    $j++;
  }
}

fclose($handle);

The same fopen() and fwrite() commands are used just as if you were writing to a local file. The difference is we’ve specified a Google Cloud Storage URL instead of a local filepath.

And this code reads the same file back into memory and pulls out the 100th prime number, using file_get_contents():

<?php

$primes = explode(",",
  file_get_contents('gs://hello-php-gae-files/prime_numbers.txt')
);

if(isset($primes[100]))
  echo "The 100th prime number is ".$primes[100];

And more features supported in PHP

Many of our most popular App Engine APIs are now supported in PHP, including our zero-configuration Memcache, Task Queues for asynchronous processing, Users API, Mail API and more. The standard features you’d expect from App Engine, including SSL support, Page Speed Service, versioning and traffic splitting are all available as well.

Open today in Limited Preview

Today we’re making App Engine for PHP available in Limited Preview. Read more about the runtime in our online documentation, download an early developer SDK, and sign up to deploy applications at https://cloud.google.com/appengine/php.

- Posted by Andrew Jessup, Product Manager

Get started with Google Cloud Datastore - a fast, powerful, NoSQL database

2013-05-16T09:00:00.000-07:00

At Google I/O, we announced Google Cloud Datastore, a fully managed solution for storing non-relational data. Based on the popular Google App Engine High Replication Datastore (HRD), Cloud Datastore provides a schemaless, non-relational datastore with the same accessibility of Google Cloud Storage and Google Cloud SQL.

Cloud Datastore builds off the strong growth and performance of HRD, which has over 1PB of data stored, 4.5 trillion transactions per month and a 99.95% uptime. It also comes with the following features:

Built-in query support: near SQL functionality that allows you to search, sort and filter across multiple indexes that are automatically maintained
ACID transactions: data consistency (both Strong and Eventual) that spans multiple replicas and requests
Automatic scaling: built on top of Google’s BigTable infrastructure, the Cloud Datastore will automatically scale with your data
High availability: by utilizing Google’s underlying Megastore service, the Cloud Datastore ensures that data is replicated across multiple datacenters and is highly available
Local development environment: the Cloud Datastore SDK provides a full-featured local environment that allows you to develop, iterate and manage your Cloud Datastore instances efficiently
Free to get started: 50k read & write operations, 200 indexes, and 1GB of stored data for free per month

Getting started with Cloud Datastore

To get started, head over to the Google Cloud Console and create a new project. After supplying a few pieces of information you will have a Cloud Project that has the Cloud Datastore enabled by default. For this post we’ll use the project ID cloud-demo.

With the project created and the Cloud Datastore enabled, we’ll need to download the Cloud Datastore client library. Once extracted, it’s time to start writing some code. For the sake of this post, we’ll focus on accessing the Cloud Datastore from a Python application running on a Compute Engine VM (which is also now in Preview). We’ll assume that you’ve already created a new VM instance.

import googledatastore as datastore

def main()
  writeEntity()
  readEntity()

Next include writeEntity() and readEntity() functions:

def WriteEntity():
  req = datastore.BlindWriteRequest()
  entity = req.mutation.upsert.add()
  path = entity.key.path_element.add()
  path.kind = 'Greeting'
  path.name = 'foo'
  message = entity.property.add()
  message.name = 'message'
  value = message.value.add()
  value.string_value = 'to the cloud and beyond!'
  try:
    datastore.blind_write(req)
  except datastore.RPCError as e:
    # remember to do something useful with the exception
    pass

def ReadEntity(): 
  req = datastore.LookupRequest()
  key = req.key.add()
  path = key.path_element.add()
  path.kind = 'Greeting0'
  path.name = 'foo0'
  try:
    resp = datastore.lookup(req)
    return resp
  except datastore.RPCError as e:
    # remember to do something useful with the exception
    pass

First create a new file called “demo.py”. Inside demo.py, we’ll add code to write and then read an entity from the Cloud Datastore. Finally we can update main() to print out the property values within the fetched entity:

def main():
  writeEntity();
  resp = readEntity();

  entity = resp.found[0].entity
  for p in entity.property:
    print 'Entity property name: %s', p.name
    v = p.value[0]
    print 'Entity property value: %s', v.string_value

Before we can run this code we need to tell the client library which Cloud Datastore instance we would like to use. This is done by exporting the following environment variable:

~$ export DATASTORE_DATASET cloud-datastore-demo

Finally we’re able to run the application by simply issuing the following:

~$ python demo.py

Besides the output that we see in console window, we’re also able to monitor our interactions within the Cloud Console. By navigating back to Cloud Console, selecting our cloud-datastore-demo project, and then selecting the Cloud Datastore we’re taken to our instance’s dashboard page that includes number of entities, properties, and property types, as well as index management, ad-hoc query support and breakdown of stored data.

And that’s really just the beginning. To fully harness the features and functionality that the Cloud Datastore offers, be sure to check out the larger Getting Started guide and the Cloud Datastore documentation.

Cloud Datastore is the latest addition to the Cloud Platform storage family, joining Cloud Storage for storing blob data, Cloud SQL for storing relational data, and Persistent Disk for storing block data. All fully managed so that you can focus on creating amazing solutions and leave the rest to us.

And while this is a Preview Release, the team is off to a great start. As we move the service towards General Availability we’re looking forward to improving JSON support, more deeply integrating with the Cloud Console, streamlining our billing and driving every bit of performance that we can out of the API and underlying service.

Happy coding!

-Posted by Chris Ramsdale, Product Manager

Google Compute Engine is now open to all

2013-05-15T18:03:00.000-07:00

Last year we announced Google Compute Engine to enable any business or developer to use Google’s infrastructure for their applications. Now we’re taking the next step: Google Compute Engine is open to everyone in preview, and you can sign up online now.

Over the past year, we’ve launched several features and made significant improvements behind the scenes. We’re now announcing several new capabilities that make it easier and more economical to use Compute Engine for a broader set of applications.

Sub-Hour Billing: We heard feedback from our early users who wanted more granular billing increments so they could run short-lived workloads. Now all instances are charged for in one-minute increments with a ten-minute minimum, so you don’t pay for compute minutes that you don’t use.
New shared-core instance types: Compute Engine’s new micro and small instance types are designed as a cost-effective option for running small workloads that don’t need a lot of CPU power, like development and test workloads.
Larger Persistent Disks: We’re increasing the size of Persistent Disks that can be attached to instances by up to 8,000%. You can now attach up to 10 terabytes of persistent disk to a Compute Engine virtual machine, giving you plenty of persistent storage for a wide variety of applications.
Advanced Routing Capabilities: Compute Engine now supports software-defined routing capabilities based on our broad SDN innovation. These capabilities are designed to handle your advanced network routing needs like configuring instances to function as gateways, configuring VPN servers and building applications that span your local network and Google’s cloud.
ISO 27001 Certification: We’ve also completed ISO 27001:2005 certification for Compute Engine, App Engine, and Cloud Storage to demonstrate that these products meet the international standard for managing information security.

To get started, go to the Google Cloud Console, select Compute Engine and click the “New Instance” button.

Fill out the required information and click “Create” on the right hand side. Your new virtual machine will be ready to use in about a minute.

To all of our customers who helped us evolve the product over the past months, thank you; your feedback has helped shape Compute Engine. To those of you who have been eager to try Compute Engine, the wait is over and you can sign up for Compute Engine online today.

- Posted by Navneet Joneja, Product Manager

Ushering in the next generation of computing at Google I/O

2013-05-15T14:35:00.000-07:00

Over the last fourteen years we have been developing some of the best infrastructure in the world to power Google’s global-scale services. With Google Cloud Platform, our goal is to open that infrastructure and make it available to any business or developer anywhere. Today, we are introducing improvements to the platform and making Google Compute Engine available for anyone to use.

Google Compute Engine - now available for everyone

Google Compute Engine provides a fast, consistently high-performance environment for running virtual machines. Later today, you’ll be able to go online to cloud.google.com and start using Compute Engine.

In addition, we’re introducing new Compute Engine features:

Sub-hour billing charges for instances in one-minute increments with a ten-minute minimum, so you don’t pay for compute minutes that you don’t use
Shared-core instances provide smaller instance shapes for low-intensity workloads
Advanced Routing features help you create gateways and VPN servers, and enable you to build applications that span your local network and Google’s cloud
Large persistent disks support up to 10 terabytes per volume, which translates to 10X the industry standard

We’ve also completed ISO 27001:2005 international security certification for Compute Engine, Google App Engine, and Google Cloud Storage.

Google App Engine adds the PHP runtime

App Engine 1.8.0 is now available and includes a Limited Preview of the PHP runtime - your top requested feature. We’re bringing one of the most popular web programming languages to App Engine so that you can run open source apps like Wordpress. It also offers deep integration with other parts of Cloud Platform including Google Cloud SQL and Cloud Storage.

We’ve also heard that we need to make building modularized applications on App Engine easier. We are introducing the ability to partition apps into components with separate scaling, deployments, versioning and performance settings.

Introducing Google Cloud Datastore

Google Cloud Datastore is a fully managed and schemaless solution for storing non-relational data. Based on the popular App Engine High Replication Datastore, Cloud Datastore is a standalone service that features automatic scalability and high availability while still providing powerful capabilities such as ACID transactions, SQL-like queries, indexes and more.

Over the last year we have continued our focus on feature enhancement and developer experience across App Engine, Compute Engine, Google BigQuery, Cloud Storage and Cloud SQL. We also introduced Google Cloud Endpoints and Google Cloud Console.

With these improvements, we have seen increased usage with over 3 million applications and over 300,000 unique developers using Cloud Platform in a given month. Our developers inspire us everyday, and we can’t wait to see what you build next.

-Posted by Urs Hölzle, Senior Vice President

Data Sensing Lab at Google I/O 2013: Google Cloud Platform meets the Internet of Things

2013-05-13T10:03:00.000-07:00

Cross-posted with the Google Developers Blog

After last year's Google I/O conference, the Google Cloud Platform Developer Relations team started to think about how attendees experienced the event. We wanted to help attendees gain more insight about the conference space and the environment itself. Which developer Sandboxes were the busiest? Which were the loudest locations, and which were the best places to take a quick nap? We think about data problems all the time, and this looked like an interesting big data challenge that we could try to solve. So this year, we decided to try to answer our questions with a project that's a bit different, kind of futuristic, and maybe a little crazy.

Since we love open source hardware hacking as much as we love to share open source code, we decided to team up with the O'Reilly Data Sensing Lab to deploy hundreds of Arduino-based environmental sensors at Google I/O 2013. Using software built with the Google Cloud Platform, we'll be collecting and visualizing ambient data about the conference, such as temperature, humidity, air quality, in real time! Altogether, the sensors network will provide over 4,000 continuous data streams over a ZigBee mesh network managed by Device Cloud by Etherios.

In addition, our motes will be able to detect fluctuations in noise level, and some will be attached to footstep counters, to understand collective movement around the conference floor. Of course, since a key goal of Google I/O is to promote innovation in the open, the project's Cloud Platform code, the Arduino hardware designs, and even the data collected, will be open source and available online after the conference.

Google Cloud Platform, which provides the software backend for this project, has a variety of features for building applications that collect and process data from a large number of client devices - without having to spend time managing hardware or infrastructure. Google App Engine Datastore, along with Google Cloud Endpoints, provides a scalable front end API for collecting data from devices. Google Compute Engine is used to process and analyse data with software tools you may already be familiar with, such as R and Hadoop. Google BigQuery provides fast aggregate analysis of terabyte datasets. Finally, App Engine's web application framework is able to surface interactive visualizations to users.

Networked sensor technology is in the early stages of revolutionizing business logistics, city planning, and consumer products. We are looking forward to sharing the Data Sensing Lab with Google I/O attendees, because we want to show how using open hardware together with the Google Cloud Platform can make this technology accessible to anyone.

With the help of the Google Maps DevRel team, we'll be displaying visualizations of interesting trends on several screens around the conference. Members of the Data Sensing Lab will be on hand in the Google I/O Cloud Sandbox to show off prototypes and talk to attendees about open hardware development. Lead software developer Amy Unruh and Kim Cameron from the Cloud Platform Developer Relations team will talk about how we built the software involved in this project in a talk called "Behind the Data Sensing Lab". In case you aren't able to attend Google I/O 2013, this session will be available online after the conference. Learn more about the Google Cloud Platform on our site, and to dive in to building applications, check out our developer documentation.

-Posted by Michael Manoochehri, Developer Programs Engineer

Welcome to the Google Cloud Platform blog

2013-05-09T19:43:00.000-07:00

Welcome to the Google Cloud Platform blog, the evolution of the Google App Engine blog, which continues as a key component of our broader Google Cloud Platform vision. On this blog, you can find product updates, developer tips, and other content related to Google Cloud Platform.

Our goal is to build the best cloud platform for developers; one that is comprised of multiple services that work together in harmony. A key component of delivering on this goal is creating a centralized communication channel to discuss updates across the entire Google Cloud Platform.

Moving forward, you can find all of the same content that we posted on the App Engine blog here. In addition to App Engine releases, updates, and customer stories, you can expect similar content for the rest of the platform - including Google Compute Engine, Google BigQuery, Google Cloud SQL, Google Cloud Storage, Google Cloud Endpoints and all future Cloud Platform products and services.

Looking back at the first post on the App Engine blog is a reminder that our ambitious mission remains the same. That is, we want to give you access to the same building blocks that Google uses for its own applications, so you can continue to build amazing things. We are committed to providing the best possible technology for you to build your business in the cloud.

Okay, time to get back to building. Subscribe here to get notifications for our new blog. And while you’re at it, follow us on Google+ and Twitter too.

-Posted by Chris Ramsdale, Product Manager

Tune in live to Google Cloud Platform at Google I/O 2013

2013-05-09T19:34:00.000-07:00

Google I/O 2013 is only a week away! We look forward to sharing updates across Google Cloud Platform. Here’s everything you need to know to keep up with the latest happenings at I/O.

This year, we will have a Google Cloud Platform track kickoff given by Urs Holzle, Senior Vice President of Technical Infrastructure, on Wednesday, May 15th at 12:45 PM Pacific. You can watch the stream on the I/O Live Stream page. Urs will make a few special announcements, so you won’t want to miss it.

At I/O, we have an entire Cloud Platform track complete with code labs and conference sessions. Even if you aren’t attending, you can still tune in to the following sessions on the live stream, which you’ll also be able to find on the homepage of cloud.google.com:

Track Kickoff: Ushering in the Next Generation of Cloud Computing (5/15 12:45PM PT)
What’s New and Cool with Google Compute Engine (5/15 3:50PM PT)
All the Ships in the World: Visualizing Data with Google Cloud and Maps (5/16 12:45PM PT)
From Nothing to Nirvana in Minutes: Cloud Backend for Your Android Application (5/16 3:30PM PT)
A New Language for App Engine (5/16 4:25PM PT)

All of our sessions (including the live ones above) will be available on demand as soon as we can get them posted. We’ll post live updates on Google+ and Twitter, so be sure to follow us and take part in the conversation.

Until I/O!

-Posted by Zafir Khan, Product Marketing Manager

Bringing Debian to Google Compute Engine

2013-05-09T19:28:00.004-07:00

This was an exciting week for the Debian community who released Debian 7.0 “wheezy” that brings big improvements including hardened security, improved 32/64-bit compatibility and addresses a lot of community feedback. Today we’re adding Debian images for Google Compute Engine. Debian, in collaboration with us, is providing images for both Debian 7.0 “wheezy” and the previous stable release, Debian 6.0 “squeeze.” This support will make it easy for anyone using Debian today to migrate their workloads onto Compute Engine.

For fast performance and to reduce bandwidth costs, Google is hosting a Debian package mirror for use by Google Compute Engine Debian instances. We’ve updated our docs and will support Debian via our usual support options or you can also check out what Debian offers.

We are continually evaluating other operating systems that we can enable with Compute Engine. However, going forward, Debian will be the default image type for Compute Engine. We look forward to hearing your feedback.

-Posted by Jimmy Kaplowitz, Site Reliability Engineer and Debian developer

Automatically Process Cloud Storage Uploads with Change Notifications

2013-05-09T19:26:00.000-07:00

Do your customers upload files to Google Cloud Storage for your applications to process? For example, a photo app may want to create thumbnails of new images as soon as they are uploaded. Normally you would have to poll for updated objects which can be a resource waste or cause you to react slowly. Most times writing and deploying custom scripts to trigger your application is cumbersome.

Today, we're releasing object change notification as a preview feature, allowing you to watch your Google Cloud Storage buckets for new, modified, or deleted objects with a webhook you provide. Now your application can be automatically triggered when an important change happens and start processing data immediately. We've also updated gsutil with a notifyconfig command. A Google App Engine webhook can be as simple as the following:

class MainPage(webapp2.RequestHandler):
  def post(self):
    resource_state = self.request.headers['X-Goog-Resource-State']
    if resource_state == 'sync':
      # Initial message that the notification channel is active.
      pass
    elif resource_state == ‘exists’:
      an_object = json.loads(self.request.body)
      bucket = an_object['bucket']
      object_name = an_object['name']
      # Take action!
    elif resource_state == ‘not_exists’:
      # Object was deleted.
      pass

We're also releasing an update to the Google Cloud Storage JSON API, bringing it into parity with our existing XML API, including exposing new methods such as Copy and Compose. As a part of this release, we are making the API available to everyone without requiring an invitation.

Enjoy, and as always, we watch StackOverflow.

- Posted by Dave Barth, Product Manager

App Engine 1.7.7 Released

2013-04-09T13:25:00.000-07:00

3 weeks following our last release, the App Engine team is happy to announce 1.7.7. We plan to deliver our Google I/O release next month.

Outbound sockets moved to Preview
Outbound sockets is now in preview in this release for Java and Python. With outbound sockets, billing-enabled App Engine applications can now make outbound connections with TCP or UDP sockets. This allows developers to build applications that weren’t previously possible on App Engine, such as IMAP or DNS clients.

In the Python runtime, we’ve added support for the Python SSL Library, so you can now open secure connections to remote services such as Apple’s Push Notification service. Similarly, Java developers can now use the javax.net.ssl package to make outbound SSL connections.

Java 7 runtime upgraded to General Availability

The App Engine team is committed to quickly releasing features to General Availability. You may recall we announced that the Java 7 runtime was in preview just 2 months ago. Since then we have seen 200% adoption week over week, and today are happy to announce the General Availability of the runtime.

In order to help developers move over, all app deployments initiated using the new 1.7.7 SDK will use Java 7 unless you explicitly opt out with a command line flag. In the near future, we plan to automatically update all existing Java 6 applications to Java 7. Most applications shouldn’t be affected by this change, but we encourage you to start testing your application in advance. For more compatibility information, we suggest that you check out the Java SE 7 and JDK 7 Compatibility notes.

Google App Engine Maven Plugin

The Google App Engine Maven plugin has been updated to support new goals: now you can directly enhance Datanucleus classes, and generate Google Cloud Endpoints service discovery and client libraries.

Improving the developer experience - goodbye $2.10!

We’re happy to announce that billing-enabled applications will no longer be required to spend a minimum of $2.10 per week. This means that you can enable billing for a free tier application and continue running within the free tier without concern that a spike in traffic will terminate serving (note that you can always specify a daily dollar budget). The minimum spend was originally intended to prevent abuse and ensure that we can offer a stable, reliable system with a free tier. We have determined that we can continue to support the free tier, without relying on the minimum spend. So, goodbye $2.10!

Cloud SDK Preview

In our continuing effort to make developers’ lives easier, we are happy to share with you a preview release of the Google Cloud SDK which includes everything from the App Engine SDKs for Java, Python or Go as well as all the tools needed to target Google Compute Engine, Google Cloud SQL, Google Cloud Storage and Google BigQuery in one easy-to-use package. Please try it out; we are eager to hear your feedback.

A note on reliability improvements

A key benefit of running on a managed service like App Engine is the changes that occur behind the scenes that automatically improve the performance of your applications. In just the past two months, we’ve made many such improvements:

Faster and more consistent deployments. Many customers are seeing up to 10x reductions in time to deploy a new application version.

We have fully deployed an entirely new scheduler system which autoscales applications more smoothly and efficiently.

Admin console dashboard charts and current load/error reports have moved to a new, more reliable backend

The release version of App Engine is now visible in the Admin Console and in request logs

Several stability and scheduling improvements to Task Queue

The complete list of features and bug fixes for 1.7.7 can be found in our release notes. For App Engine coding questions and answers check us out on Stack Overflow, and for general discussion and feedback, find us on our Google Group.

- Posted by Chris Ramsdale, Product Manager

Python 2.5, thanks for the good times

2013-04-09T09:56:00.001-07:00

Python 2.5 has a special place in the heart of any Google App Engine developer, as it was the first runtime we launched way back in 2008. Since then, both Python and App Engine have advanced a great deal.

A year ago we announced our support for Python 2.7, which brings syntactic and semantic improvements to the language and includes powerful features like threading and a large selection of third-party libraries.

Not only does Python 2.7 make developers’ lives easier, the runtime is extremely cost-effective. Our customers have taken advantage of features like concurrent requests to reduce their front-end instance costs by more than 70% while handling the same amount of traffic.

Not surprisingly, the Python 2.7 runtime has proven to be extremely popular. Just over a year after launch, more than 78% of active Python applications on App Engine are using the new runtime, and more are being added every minute.

As both Python and App Engine evolve, we must occasionally make hard choices about which legacy runtimes we should continue to support. Today we are announcing the deprecation of the Python 2.5 runtime. The deprecation period will follow the guidelines set in our terms of service.

What does this mean?

We will continue to run Python 2.5 applications throughout the deprecation period. For most customers, upgrading to Python 2.7 is trivial as most elements of Python 2.5 are forwards-compatible with Python 2.7. We’ve prepared a handy migration guide that covers the steps to migrate in detail.
If your application is still using the already deprecated Master/Slave Datastore, then you should first plan the migration to our more reliable High Replication Datastore, as the Master/Slave Datastore is not accessible from Python 2.7.
Future versions of the App Engine Python Development SDK will display warnings to developers deploying updates to a deprecated runtime.
Starting from January 2014, we will no longer allow new applications to be created using the Python 2.5 runtime.

Our summary of the new features we’ve introduced in Python 2.7 including additional standard libraries and third-party libraries that are supported.

A handy migration guide, explaining the steps to move a Python 2.5 app to Python 2.7

App Engine engineers give an in-depth discussion during Google I/O on the many improvements in Python 2.7, and how to quickly take advantage of them.

If you have any questions about this deprecation, we encourage you to contact us at google-appengine-python25-deprecation@googlegroups.com.

-Posted by Andrew Jessup, Product Manager

Google Compute Engine - Expanded Availability, New Features, and Lower Prices

2013-04-04T10:17:00.000-07:00

Cross-posted with the Google Developers Blog

Starting today, Google Compute Engine is available to all customers who sign up for our Gold Support package. We’re also happy to announce a 4% reduction on all Compute Engine pricing.

In the nine months since announcing Compute Engine, customers have been using Google’s Infrastructure as a Service product and giving us valuable feedback. Sebastian Stadil of Scalr wrote, in a recent review:

“Google Compute Engine is not just fast. It’s Google fast. In fact, it’s a class of fast that enables new service architectures entirely.”

We’re happy to hear that, because one of our main goals in building Compute Engine is to enable a new generation of applications with direct access to the capabilities of Google’s vast computing infrastructure.

Based on user feedback, we’ve added a number of major features including:

The option to boot from persistent disks mounted as the root file system, persistent disk snapshots, the ability to checkpoint and restore the contents of network resident persistent disks on demand, and the ability to attach and detach persistent disks from running instances.

An improved administration console, the Google Cloud Console (preview), which allows you to administer all your Google Cloud Platform services via a unified interface.

Screenshot of new Cloud Console in action

Five new instance type families (diskless versions of our standard instance types, plus diskful and diskless versions of high-memory and high-cpu configurations), with 16 new instance types.

Two new supported zones in Europe, which provide lower latency and higher performance for our European customers. We’ve also made it easy to migrate virtual machine instances from one zone to another via an enhancement to our gcutil command line tool.

An enhanced metadata server, with the ability to support recursive queries, blocking gets and selectable response formats, along with support for updating virtual machine tags and metadata on running instances (which enables dynamic reconfiguration scenarios).

While we've been hard at work developing new features, we've also had the opportunity to play. Check out the amazing World Wide Maze Chrome Experiment, developed by the Chrome team in Japan. This game converts any web site of your choice into an interactive, three dimensional maze, navigated remotely via your smartphone. Compute Engine virtual machines run Node.js to manage the game state and synchronization with the mobile device, while Google App Engine hosts the game’s web UI. This application provides an excellent example of the new kinds of rich, high performance back end services enabled by Google Cloud Platform.

With today’s announcement, we look forward to welcoming many new customers, and bringing exciting new applications to Google Cloud Platform!

-Posted by Marc Cohen, Developer Relations

Integrate Voice and SMS with Twilio on Google Cloud Platform

2013-04-02T07:17:00.000-07:00

Have you ever wanted to integrate SMS or voice communications into your app? We’ve been working with our friends over at Twilio to make it easier to do so. Today we’re announcing native Python and Java libraries for working with Twilio APIs onto Google Cloud Platform.

Lots of apps on App Engine have already been built with phone functionality. Check out the sample code for a group messaging app and the sample code for an app that dispatches voicemails and SMS messages to PagerDuty. Learn how to send business cards via sms through this step by step guide.

You can start building voice and SMS features into your App Engine apps today. Together with Twilio, we’ll help you get started with 2,000 free text message or voice minutes.

Ready to get started?

Sign up for App Engine.

Get your Twilio account and 2,000 free text message or voice minutes.

Check out our guide on how to integrate Twilio services into your app.

Here’s a quick peek at how easy it can be to send a text message from App Engine using Python. After installing the Twilio library, it just takes a few lines of code to send an SMS.

-Posted by Robert Do, Product Marketing Manager

Education Awards on Google App Engine

2013-03-27T10:28:00.000-07:00

Last year we invited proposals for innovative projects built on Google’s infrastructure. Today we are pleased to announce the 11 recipients of a Google App Engine Education Award. Professors and their students are using the award in cloud computing courses to study databases, distributed systems, web mashups and to build educational applications. Each selected project received $1000 in Google App Engine credits.

Awarding computational resources to classroom projects is always gratifying. It is impressive to see the creative ideas students and educators bring to these programs.

Below is a brief introduction to each project. Congratulations to the recipients!

John David N. Dionisio, Loyola Marymount University

Project description: The objective of this undergraduate database systems course is for students to implement one database application in two technology stacks, a traditional relational database and on Google App Engine. Students are asked to study both models and provide concrete comparison points.

Xiaohui (Helen) Gu, North Carolina State University

Project description: Advanced Distributed Systems Class

The goal of the project is to allow the students to learn distributed system concepts by developing real distributed system management systems and testing them on real world cloud computing infrastructures such as Google App Engine.

Shriram Krishnamurthi, Brown University

Project description: WeScheme is a programming environment that runs in the Web browser and supports interactive development. WeScheme uses App Engine to handle user accounts, serverside compilation, and file management.

Feifei Li, University of Utah

Project description: A graduate-level course that will be offered in Fall 2013 on the design and implementation of large data management system kernels. The objective is to integrate features from a relational database engine with some of the new features from NoSQL systems to enable efficient and scalable data management over a cluster of commodity machines.

Mark Liffiton, Illinois Wesleyan University

Project description: TeacherTap is a free, simple classroom-response system built on Google App Engine. It lets students give instant, anonymous feedback to teachers about a lecture or discussion from any computer or mobile device with a web browser, facilitating more adaptive class sessions.

Eni Mustafaraj, Wellesley College

Project description: Topics in Computer Science: Web Mashups. A CS2 course that combines Google App Engine and MIT App Inventor. Students will learn to build apps with App Inventor to collect data about their life on campus. They will use Google App Engine to build web services and apps to host the data and remix it to create web mashups. Offered in the 2013 Spring semester.

Manish Parashar, Rutgers University

Project description: Cloud Computing for Scientific Applications -- Autonomic Cloud Computing teaches students how a hybrid HPC/Grid + Cloud cyber infrastructure can be effectively used to support real-world science and engineering applications. The goal of our efforts is to explore application formulations, Cloud and hybrid HPC/Grid + Cloud infrastructure usage modes that are meaningful for various classes of science and engineering application workflows.

Orit Shaer, Wellesley College

Project description: GreenTouch

GreenTouch is a collaborative environment that enables novice users to engage in authentic scientific inquiry. It consists of a mobile user interface for capturing data in the field, a web application for data curation in the cloud, and a tabletop user interface for exploratory analysis of heterogeneous data.

Elliot Soloway, University of Michigan

Project description: WeLearn Mobile Platform: Making Mobile Devices Effective Tools for K-12. The platform makes mobile devices (Android, iOS, WP8) effective, essential tools for all-the-time, everywhere learning. WeLearn’s suite of productivity and communication apps enable learners to work collaboratively; WeLearn’s portal, hosted on Google App Engine, enables teachers to send assignments, review, and grade student artifacts. WeLearn is available to educators at no charge.

Jonathan White, Harding University

Project description: Teaching Cloud Computing in an Introduction to Engineering class for freshmen. We explore how well-designed systems are built to withstand unpredictable stresses, whether that system is a building, a piece of software or even the human body. The grant from Google is allowing us to add an overview of cloud computing as a platform that is robust under diverse loads.

Dr. Jiaofei Zhong, University of Central Missouri
Project description: By building an online Course Management System, students will be able to work on their team projects in the cloud. The system allows instructors and students to manage the course materials, including course syllabus, slides, assignments and tests in the cloud; the tool can be shared with educational institutions worldwide.

-Posted by Andrea Held, Google University Relations

App Engine 1.7.6 Released

2013-03-19T13:10:00.000-07:00

The App Engine team is continuing to make monthly improvements to our platform. We have a number of new features and fixes for this month’s release.

New App Engine billing system for paid applications

We’re making it easier to pay for App Engine each billing cycle by transitioning to a new billing system. This change will happen automatically for billing-enabled applications, with no action required on your part. With the new system you can now:

take advantage of monthly billing cycles

make a payment at any time during the month

specify direct debit as a form of payment

assign a primary and backup credit card

We’ll start moving applications to this new billing system over the next few weeks. You don’t need to make any changes and the migration itself will be transparent.

Other notable features

Full Text Search API stats are now available in the admin console. You can start viewing these stats in advance of being able to pay for additional search resources in an upcoming release.

We’ve added asynchronous methods, which is now in Preview, to the Task Queue API. This feature improves utilization by allowing your app to add, lease and delete multiple tasks in parallel.

A major overhaul to the Python dev_appserver, the software used to simulate App Engine while in development. The new dev_appserver is multi-threaded, meaning development is faster, and provides a more accurate simulation of the production environment.

Admin console dashboard charts and current load/errors reports are moving to a new, more reliable backend over the next few weeks.

Improved support for Python libraries, with Django 1.4.2 and webob 1.2.3 now Generally Available.

The complete list of features and bug fixes for 1.7.6 can be found in our release notes. For App Engine coding questions and answers check us out on Stack Overflow, and for general discussion and feedback, find us on our Google Group.

-Posted by Chris Ramsdale, Product Manager

Using Tailbone to talk to App Engine with JavaScript

2013-03-18T10:50:00.000-07:00

Today’s post comes from Doug Fritz from the Data Arts Team of the Google Creative Lab. In this post, Doug shares a small open source project for reading and writing to the Google App Engine Datastore with JavaScript.

Today, the Google Creative Lab is sharing a small open source project called Tailbone that lets developers read and write to the Google App Engine Datastore using JavaScript. We’re hoping that it makes App Engine a bit more accessible to developers who aren’t familiar with Python, Java or Go, or prefer not to use them.

I share an office with three creative programmers who work almost entirely in HTML5 and JavaScript. An important part of our work is writing server-side code for new projects that read or write data to to the App Engine Datastore or use Google accounts to store authenticated user-specific information. To make that process easier for my JavaScript-fluent colleagues, I created Tailbone to act as a RESTful API for an app’s Datastore.

To get started, you still have to install App Engine’s SDK and Python, but after that you’re all set. We’ve written a detailed tutorial that guides you through the installation and an example app for creating an authenticated profile page with an editable name and photo.

It’s my hope that Tailbone makes App Engine a little bit less intimidating for people who don’t have much experience with server-side coding. I know there are a few in my office. If there are any others out there, this is for you.

-Posted by Doug Fritz, Creative Lab, Data Arts Team

Python 2.5, thanks for the good times

2013-03-08T11:20:00.000-08:00

We will continue to run Python 2.5 applications throughout the deprecation period. For most customers, upgrading to Python 2.7 is trivial as most elements of Python 2.5 are forwards-compatible with Python 2.7. We’ve prepared a handy migration guide that covers the steps to migrate in detail.
If your application is still using the already deprecated Master/Slave Datastore, then you should first plan the migration to our more reliable High Replication Datastore, as the Master/Slave Datastore is not accessible from Python 2.7.
Future versions of the App Engine Python Development SDK will display warnings to developers deploying updates to a deprecated runtime.
Starting from January 2014, we will no longer allow new applications to be created using the Python 2.5 runtime.

We encourage all developers using Python 2.5 to consider migrating as soon as possible. We’re confident that the vast majority of our customers will find the upgrade straightforward and the benefits substantial.

If you’re considering migrating, here are some useful resources:

Our summary of the new features we’ve introduced in Python 2.7 including additional standard libraries and third-party libraries that are supported.

A handy migration guide, explaining the steps to move a Python 2.5 app to Python 2.7

App Engine engineers give an in-depth discussion during Google I/O on the many improvements in Python 2.7, and how to quickly take advantage of them.

If you have any questions about this deprecation, we encourage you to contact us at google-appengine-python25-deprecation@googlegroups.com.

-Posted by Andrew Jessup, Product Manager

Improve your App Engine skills with Google Developers Academy

2013-02-28T14:22:00.000-08:00

Are you developing on Google App Engine today or interested in learning how to use it? If you've gone through all the great App Engine docs and Getting Started tutorials (Python, Java, or Go) but want to take your App Engine skills a step further, then Google Developers Academy (GDA) is the place to go! We launched GDA this past summer at Google I/O 2012, with content for beginners as well as seasoned developers. What can you find on App Engine in GDA today?

If you’re interested in getting more background on what cloud computing is and where App Engine fits into that ecosystem, then this intro class (Introduction to Google App Engine) is for you. Once you’re done with this class, you’ll be ready to tackle the Getting Started tutorial, and after that, move on to the App Engine 101 in Python class.

While some of the material found in App Engine 101 is similar to what's in the Getting Started tutorial, the 101 class targets developers who skipped the tutorial or completed it at some point in the past but don't want to repeat the exact same thing. The main differences include the following changes to the tutorial's content:

Use of the Python NDB API
Jinja2 templates
Discussion of data consistency and datastore indexes

You can use the relational MySQL-compatible Google Cloud SQL service as an alternative to App Engine's native non-relational datastore. Some applications do require a relational database, especially if you’re porting an existing app that relies on one. In this case, you want to learn about Cloud SQL and how to use it with App Engine. That’s why we have the Using Python App Engine with Google Cloud SQL class.

Of course, Google is best known for search. With App Engine's powerful Search API, you can index not only plain text, but also HTML, atoms, numbers, dates, and locations (lat/long). Getting Started with the Python Search API is a two-part class that will indeed get you started: in the first part of the class, you’ll create an application using a variety of data and learn how to index such data (using “documents”). In Part 2, you’ll learn how to execute queries as well as how to update your indexes when you modify your data.

If variety is what you're after, then look no further than the newest class in GDA: Getting Started with Go, App Engine and Google+ API. You will not only learn how to create an App Engine app using the Go programming language, but also learn how to connect to the Google+ API with the Google APIs Client Library for Go.

These are just a few examples of the types of classes you'll find in GDA. We also have content that features many other Google technologies, including Android, Chrome, YouTube, Maps, Drive, and Wallet. We invite you to swing by for a visit soon.

-Posted by Wesley Chun, Google Developer Relations team

Deploying App Engine apps with DevTable

2013-02-27T11:20:00.000-08:00

Today’s post comes from Jake Moshenko, founder of DevTable. DevTable is a collaborative hosted IDE which aims to provide a single development environment that can be accessed online from any device or location. It also allows you to collaborate on projects in real-time with your teammates. DevTable supports development and deployment of Google App Engine projects in the cloud.

At DevTable, we support development of Google App Engine apps with Python directly on the cloud, without having to install and run the App Engine SDK locally. While the App Engine SDK development experience is excellent, it is not yet supported on mobile or web platforms.

Some of the major reasons to use DevTable for App Engine are:

Cloud based editing and deployment of your App Engine projects
Autocomplete for Python code, including built-in App Engine libraries
OAuth deployment, so DevTable never has access to your Google Credentials
Native App Engine deployment for production releases
Git DVCS integration, including GitHub support
Mimic deploy, for faster intermediate testing feedback

To get started, first log in to your DevTable account and create a new project using our Google App Engine template. This template loads the basic webapp "hello world" project that you’re probably already familiar with from the App Engine documentation. Follow the instructions to create a new App Engine app and to authorize DevTable to deploy on your behalf. Don’t worry, we use OAuth deployment, which means we will never ask you for your Google password.

Now that you have everything set up, press the Run Project button and select View on App Engine Mimic, which will deploy the Mimic bootstrap code to a special version of your app. This may take up to a few minutes, but each test deploy after this should happen instantaneously. Once Mimic has been deployed, you will see “Hello, world.” proudly displayed in a new browser tab. Each time you refresh this page, the newest code is pulled from your DevTable project, so editing and testing code is seamless. Try it now; change the message in your app’s main .py file, then refresh the tab which is showing your project.

Python autocomplete and documentation in DevTable

Mimic works by creating a proxy which intercepts requests to your app and loads your app code dynamically from the datastore. DevTable keeps this code in sync with your latest changes. One added bonus to testing your code using DevTable and Mimic is that your test code will be running in the production App Engine environment, so some APIs and capabilities will work that don’t work on the Development Server, such as the App Identity API and making multiple concurrent requests.

Mimic bootstrap code deployment

Once you are happy with how your app works in Mimic, you may want to deploy your application to production. Click the Deploy button, to deploy your app directly to App Engine, which may take a few minutes. Once deployment is complete, you can view your app at the production url, which is probably something like .appspot.com.

What can you do with this? You can build and deploy apps completely in the cloud. You can use DevTable as an emergency backup editor to check out your code from Git, fix a small bug, and push to production, without having access to your development machine, from the beach! You can use our real-time collaboration support to pair program an App Engine app concurrently across the world. Our users are constantly surprising us with new ways to use DevTable, and we’re excited to see what you can come up with too!

We encourage you to get started now building apps using DevTable on App Engine. If you have any questions or suggestions, we are always available at support@devtable.com. Just send us an email and we’ll get back to you as quickly as we can.

- Contributed by Jake Moshenko, founder of DevTable

New Google Cloud Platform case studies - including Angry Birds and more

2013-02-26T10:34:00.000-08:00

One of the most rewarding parts of working on Google App Engine is seeing our developers create groundbreaking new applications on top of our infrastructure. To help our current and prospective users gain insight into the vast array of these applications, we recently added a section to the Google Cloud Platform site with a collection of case studies. Whether you’re interested in learning about how businesses are building on our platform or just looking for inspiration for your next project, we hope you find these pieces informative.

Rovio
Creator of the blockbuster “Angry Birds” game series used App Engine when creating web versions of their game. They were able to create customized versions of their game in just 2 weeks using App Engine, allowing them to capitalize on opportunities to grow their business.

GetAround
TechCrunch Disrupt award-winning car sharing service used App Engine to build a marketplace connecting car owners to people looking to rent cars. They scaled their product without adding additional staff.

MAG Interactive
Developer of mobile casual games, including the hit game Ruzzle, scaled their backend using App Engine. They grew to over 5 million users, and experienced “no scalability issues at all.”

Nubbius
The Cloud Gate used App Engine to create nubbius, a software-as-a-service offering for lawyers to manage their workflow from anywhere. They saved more than $130,000 per year while scaling rapidly.

RedBus
Online travel agency used Google BigQuery to unify tens of thousands of bus schedules into a single booking operation. They analyzed data sets as large as 2 TB in less than 30 seconds, and spent 80% less than they would have on a Hadoop infrastructure,

This is a sample of the many case studies we have on our site. Check out cloud.google.com/customers to see the full list. You can read about companies varying in size, industry, and use cases, who are using Google Cloud Platform to build their products and businesses.

- Posted by Zafir Khan, Product Marketing Manager

Google Cloud Platform introduces new support packages

2013-02-21T11:00:00.000-08:00

Support is as important as product features when choosing a platform for your applications. And let’s face it, sometimes we all need a bit of help. No matter which Google Cloud Platform services you are using—App Engine, Compute Engine, Cloud Storage, Cloud SQL, BigQuery, etc.—or what time of day, you should be able to get the answers you need. While you can go to Stack Overflow or Google Groups, we realize some of you may need 24x7 coverage, phone support or direct access to a Technical Account Manager team.

To meet your support requirements, we’re introducing a comprehensive collection of support packages for services on Google Cloud Platform, so you can decide what level best fits your needs:

Bronze: All customers get access to online documentation, community forums, and billing support. (Free)
Silver: In addition to Bronze, you can email our support team for questions related to product functionality, best practices, and service errors. ($150/month)
Gold: In addition to Silver, you'll receive 24x7 phone support and consultation on application development, best practices or architecture for your specific use case. (Starts at $400/month)
Platinum: The most comprehensive and personalized support. In addition to Gold, you’ll get direct access to a Technical Account Manager team. (Contact Sales for more information)

Sign up or click here to find out more information about the new Google Cloud Platform support options.

Posted by Brett McCully, Google Cloud Platform team

Java 7 and Cloud Endpoints Preview

2013-02-21T10:16:00.000-08:00

Today we are announcing two new preview features: Google App Engine Java 7 runtime support and Google Cloud Endpoints. Preview features are ‘experimental’ features on a path towards general availability.

Java 7 Runtime Support for App Engine

The App Engine Java 7 runtime allows App Engine developers to keep pace with innovations in the Java language and runtime. It is important that you begin testing your applications with the new Java 7 runtime before the complete rollout in a few months.

Some of the language features you now have access to include:

invokedynamic support, which allows developers, tools providers, and language implementations to take advantage of a new bytecode, invokedynamic, to handle method invocations efficiently even when there is no static type information. For example:

public static void invokeExample() {
   String s;
   MethodType mt; 
   MethodHandle mh;
   
   MethodHandles.Lookup lookup = MethodHandles.lookup();
   MethodType mt = MethodType.methodType(String.class, char.class,
          char.class);
   MethodHandle mh = lookup.findVirtual(String.class, "replace", mt);
   s = (String) mh.invokeExact("App Engine Java 6 runtime",'6','7');
   System.out.println(s);
}

Try-with-resources, which helps avoid memory leaks and related bugs by automatically closing resources that are used in a try-catch statement.

public static void viewTable(Connection con, String query) throws SQLException {
   try (
      Statement stmt = con.createStatement();
      ResultSet rs = stmt.executeQuery(query)
   ) {
      while (rs.next()) {
         // process results
         //
      }
   } catch (SQLException e) {
      // con resource is auto-closed, no need to do anything here!
      //
   }
}

Flexible Type Creation when using generics, enabling you to create parameterized types more succinctly. For example, you can write:

Map> myMap = new HashMap<>();

instead of:

Map> myMap = new HashMap>();

In addition to the language features listed above, the App Engine Java 7 runtime also includes:

Use of String class in Switch statements.
Expression of binary literals using simple prefixes 0b or 0B.
Single catch blocks that can handle multiple exceptions.
Simplified varargs method invocation.

Want to get started now? Download the latest App Engine Java SDK and then check out the docs here.

Cloud Endpoints Preview

Have you ever wanted a simple way to get a cloud backend for that Android or iPhone app you are working on? Wish it was easier to expose RESTful APIs from your web application? Google Cloud Endpoints simplifies building highly scalable and flexible backends for your web and mobile applications. Use Cloud Endpoints to store application data in the cloud that spans both devices and users. You can now easily expose your own authenticated, reliable, REST-based APIs hosted from an App Engine application and consume them in your Android, iOS, or web clients. Deeply integrated authentication support allows your users to have a transparent yet secure experience accessing your services. You have access to strongly typed client libraries for your custom service optimized for Android and iOS.

To use Cloud Endpoints, you simply write a Java or Python class with methods you want to expose to web or mobile clients. You then annotate the methods with attributes that control exactly how they are represented in REST interfaces on the wire. Finally, use Cloud Endpoints to generate your strongly-typed client libraries for Android, iOS and a lightweight JavaScript library.
For example, you can create a simple class to list some important data:

public class SuperHeroes {
   public List listSuperHeroes() {
      List list = new ArrayList();
      list.add(new SuperHero ("Champion of the Obvious", "Brad Abrams"));
      list.add(new SuperHero ("Mr. Justice", "Chris Ramsdale"));

      return list;
   }
}

Then, expose it over a standard REST interface with a simple attribute and a versioning pattern.

@Api(name = "superheroes", version = "v1")public class SuperHeroesV1 { ...

Now you have a simple REST interface.

$ curl http://localhost:8888/_ah/api/superheroes/v1/superheroes
{
 "items": [
  {
   "knownAs" : "Champion of the Obvious",
   "realName" : "Brad Abrams"
  },
  {
   "knownAs" : "Mr. Justice",
   "realName" : "Chris Ramsdale"
  }

And you can make strongly typed calls from your Android clients:

Real result = superheroes.list().execute();

Or Objective-C iOS client:

GTLQuerySuperHeroesV1 *query = [GTLQuerySuperHeroesV1 queryForSuperHeroesList];
[service executeQuery:query completionHandler:^(GTLServiceTicket *ticket, 

GTLSuperHeroes *object, NSError *error) {
  NSArray *items = [object items];
}];

Or the web client in JavaScript:

// ...
var ROOT = 'https://' + window.location.host + '/_ah/api';
gapi.client.load('superheroes', 'v1',
                 loadSuperheroesCallback, ROOT);
// Get the list of superheroes
gapi.client.superheroes.superheroes.list().execute(function(resp) {
  displaySuperheroesList(resp);
});

Read the documentation for Java or Python to discover how you can build a simple tic-tac-toe game using Cloud Endpoints.

To get started with Cloud Endpoints, download the App Engine 1.7.5 SDK and the latest Google Plugin for Eclipse. Be sure to look at the docs and follow along in the discussion forums on Stack Overflow.

For more on using Cloud Endpoints with Python, check out +Danny Hermes and +Dan Holevoet on Google Developers Live.

-Posted by Brad Abrams, Product Manager, and Chris Ramsdale, Product Manager

New Google App Engine training videos now available

2013-02-14T12:33:00.000-08:00

Do you wonder how App Engine orchestrates hundreds of instances so smoothly? Can you imagine how Datastore queries and transactions work behind the scenes? Do you want to know the magic of how App Engine experts dramatically reduce traffic costs using edge caching?

We’ve just published a series of great App Engine training videos to help you better understand our platform. These seven voice-over technical videos provide insight for both newbies as well as seasoned App Engine developers. The videos delve into each major App Engine component’s operation and how a developer can best utilize them.

Each video runs for half an hour or less. We recommend you follow the videos in sequence if you are new to App Engine, or you can pick and choose if you’re already familiar with the platform.

Throughout the year, we intend to publish codelabs to complement the voice-over training videos, not only for App Engine, but for Google Cloud Storage, Google Cloud SQL, Google BigQuery, and Google Compute Engine as well. So stay tuned for updates!

-Posted by Gary Downing, Cloud Platform Solutions Technical Training Manager

App Engine 1.7.5 Released

2013-02-13T12:09:00.000-08:00

After a brief break last month, the App Engine team is back on our monthly release cycle. We made lots of improvements to our platform in 2012 and look forward to delivering more this year.

In 1.7.5, we are releasing High-Memory Instances and Mail Bounce Notifications to General Availability. We’ve heard the feedback that you would like to have more memory without having to pay for more CPU. With this release, you can now utilize F4 or B4 instances with 1GB memory, which is double the amount of memory available before. Mail Bounce Notifications notify apps when mail sent through App Engine fails to deliver, so you’ll always know whether your communications are going through.

We are also introducing Experimental support for the Java 7 runtime and Google Cloud Endpoints. Improvements in Java 7 include strings in switch statements, improved type inference for generic instance creation, and the ability to use InvokeDynamic(). Cloud Endpoints makes it easy to expose your code as RESTful and RPC services that can be easily consumed by your own web and mobile applications. Finally, an update to the Google Plugin for Eclipse makes it possible for developers to build App Engine backends that communicate with client-side Android applications via Google Cloud Messaging for Android and Cloud Endpoints.

The complete list of features and bug fixes for 1.7.5 can be found in our release notes. For App Engine coding questions and answers check us out on Stack Overflow, and for general discussion and feedback, find us on our Google Group. You can also subscribe to the Google Cloud Platform newsletter and read our February edition.

-Posted by Chris Ramsdale, Product Manager

Research Projects on Google App Engine

2013-02-12T10:15:00.000-08:00

Last spring Google University Relations announced an open call for proposals for Google App Engine Research Awards. We invited academic researchers to use Google App Engine for research experiments and analysis, encouraging them to take advantage of the platform’s ability to manage heavy data loads and run large-scale applications. Submissions included proposals in various subject areas such as mathematics, computer vision, bioinformatics, climate and computer science. We selected seven projects and have awarded each $60,000 in Google App Engine credits recognizing their innovation and vision.

Today we would like to share a brief introduction of the winning projects and their Principal Investigators:

K. Mani Chandy, Simon Ramo Professor and Professor of Computer Science, California Institute of Technology
Cloud-based Event Detection for Sense and Response: Develop a low-cost alternative to traditional seismic networks. The image below is taken from the Community Seismic Network map showing active clients and events in real time.

A dense network of seismic stations enables the Community Seismic Network to perform a finer-grained analysis of seismic events than possible with existing seismic networks.

Lawrence Chung, Associate Professor, The University of Texas at Dallas
Google App Engine: Software Benchmark and Google App Engine Simulation Forecaster: Develop a tool to estimate software performance and cost on Google App Engine.

Julian Gough, Professor, University of Bristol, UK
Personalised DNA Analysis: Develop a service that provides personal DNA analysis.

Ramesh Raskar, PhD, MIT Media Lab; Dr. Erick Baptista Passos, IFPI (Federal Institute of Technology, Brazil)
VisionBlocks: develop a tool that delivers computer vision to people everywhere. The image below shows a current prototype implementation of VisionBlocks.

Many algorithms are already included, and you'll be able create your own blocks as well.

Norman Sadeh, Professor, Director of Mobile Commerce Lab, School of
Computer Science, Carnegie Mellon University
Mapping the Dynamics of a City & Nudging Twitter Users: uncovering local collective knowledge about the a city using social media.

William Stein, Professor of Mathematics, University of Washington
Sage: Creating a Viable Free Open Source Alternative to Magma, Maple, Matlab, and Mathematica.

Enrique Vivoni, Associate Professor, Hydrologic Science, Engineering & Sustainability, Arizona State University
Cloud Computing-Based Visualization and Access of Global Climate Data Sets: provide scientific data on global climate trends.

Congratulations to the award winners! We are excited about the proposals’ creativity and innovation and look forward to learning about their discoveries. To read more about specific projects, go here.

-Posted by Andrea Held, Program Manager, Google University Relations