Cloud Platform Blog

News Ltd’s Traderoo Powered by Google App Engine

2013-05-24T10:48:00.001-07:00

(Cross-posted on the Official Google Australia Blog)

Today’s guest blogger is Joshua Lowcock, Head of Commercial Platforms and Products for News Limited, an Australian media company. Joshua describes how his company used Google App Engine in Australia.

News Limited is one of Australia’s largest media companies, spanning newspapers, magazines, online, and subscription TV. We publish over 140 online and printed newspapers in major Australian cities including Sydney, Melbourne, Brisbane, Adelaide, and Perth, as well as in suburban areas.

Classified advertising is a key revenue stream across all our markets, but traditionally booking and billing classifieds had been a manual and time-consuming process. We wanted to implement a solution that would allow customers to serve themselves by placing ads online.

Google App Engine has enabled customers to do just that. We chose Google App Engine as the application because it is easy to build, easy to maintain and simple to scale as the user base and data storage grows. Functionalities within the Google App Engine environment, such as Google BigQuery, have also been useful. We can do an in-depth analysis of our ads and item pricing, as well as provide an internal reporting tool, all using BigQuery.

The end result is a self-service, production booking and billing system - www.traderoo.com.au - which we have developed on Google App Engine. It’s proving to be a real winner for both our business and our customers. It’s fundamentally changed the way customers engage with our company, creating a more usable experience and superb responsiveness. It’s easy to use, and gives more control over ad content, as well as the ability to publish ads online immediately. Online ads are free, while print ads are optional and require a small fee, but complement online ads by extending the advertiser’s reach.

When customers book ads using the Traderoo website, they get automatic email notification from the platform that tells them how their advertisement is performing. Traderoo is optimised for PC, laptop, smartphone and tablet, so the browser and ad placement remain consistent, no matter what device our customers are using.

The real advantage for us is that our classified business has achieved faster time to market, lower costs and less overheads in the form of call centre time and manual data entry. The site has been a huge success, and we look forward to continuing to use Google App Engine as we develop Traderoo further.

-Contributed by Joshua Lowcock, Head of Commercial Platforms and Products for News Limited

Reducing Google App Engine High Replication Datastore prices by up to 25%

2013-05-23T06:00:00.000-07:00

Since its inception in 2011, Google App Engine High Replication Datastore (HRD) has grown and currently processes over 4.5 trillion transactions per month with 99.95% uptime. In addition, HRD serves as the basis of Google Cloud Datastore, which we announced last week at Google I/O.

We are always evaluating opportunities to create more value for you and today we are reducing Datastore prices by up to 25%. This price change impacts both App Engine HRD and Cloud Datastore.

Below is a breakdown of the new pricing:

Storage

Resource	Old Unit Cost	New Unit Cost
Stored Data (Datastore)	$0.24 / GB / Month	$0.18 / GB / Month

Operations

Operation	Old Cost	New Cost
Write	$0.10 per 100k operations	$0.09 per 100k operations
Read	$0.07 per 100k operations	$0.06 per 100k operations
Small	$0.01 per 100k operations	unchanged

If you are unfamiliar with Datastore you can learn more about App Engine HRD and Cloud Datastore.

- Posted by Peter Magnusson, Engineering Director

GDC’13: Learn how to build games on Google Cloud Platform

2013-05-23T00:17:00.000-07:00

At the Game Developers Conference last month, we held a day of sessions showing developers how to take advantage of Google Cloud Platform to build all kinds of different games. We invited some of our top developers to share their stories and best practices, including LeanPlum, who is building a powerful mobile optimization platform, EA, who is building some really amazing games, and Staq, who is creating a unique game management platform. Check out the videos of the sessions below and let us know what you think.

Intro to Google Cloud Platform - PaaS, IaaS, Storage, Analytics (48:18 min)

Google Cloud Platform has everything needed to build highly scalable applications. Launch an app without system administrators, while having the ultimate flexibility of root on a virtual machine. Get high performance asset hosting, and analyze terabyte-sized data to optimize games.

Connect Mobile Apps to the Cloud Without Breaking a Sweat (43:50 min)

Google Cloud Endpoints makes it easy to build OAuth 2-protected, RESTful APIs and instantly generate client libraries for Android, iOS, and JavaScript. See how you can use this feature to trivially connect your Android, iOS, and mobile browser applications to powerful backends built on App Engine.

Create Amazingly Scalable Games on Google Cloud Platform (40:35 min)

Quickly deliver compelling game experiences by leveraging the scalability of Google App Engine combined with the unlimited flexibility of virtual machines on Google Compute Engine. From 1 to 100,000 cores, learn how to unleash your next great game on Google Cloud Platform.

Understanding Your Players Using Near Real-time Data Analytics (41:20 min)

The volume of data generated by games can be immense and the insights one can derive from them invaluable. Learn how to analyze player behavior, virality, segment users, and understand retention in near real-time using //staq and Google BigQuery.

How EA Builds Mobile Game Servers on Google App Engine (44:23 min)

Electronic Arts presents an overview of how Google App Engine propels the production of back-end servers required for connected, social games on mobile, with real-world applications of the platform's services and built-in automatic scaling.

- Posted by Ryan Boyd, Developer Advocate

How Scalr helped grandcentrix build the Eurovision app to support 125 million viewers

2013-05-20T22:50:00.003-07:00

Today’s guest post is from Thomas Orozco, Solutions Engineer at Scalr, which provides cloud management services and integrates with Google Cloud Platform. Thomas shares Scalr’s experience working with another Google partner, grandcentrix, to deliver the Eurovision companion app.

Eurovision is a song contest where each European country sends one singer to compete in a televised competition (similar to American Idol for our American readers). It is the one of the most watched non-sporting TV events in the world, with an estimated 125 million live viewers every year!

This year, Eurovision created a second screen application that included singer biographies, real-time updates, contest voting and results. The “smartmrs” backend for the Eurovision companion app, developed by grandcentrix, was powered by Google Cloud Platform. grandcentrix leveraged Google Compute Engine for VMs and used our product at Scalr for orchestration.

Capacity planning without a target
Initially, Eurovision didn’t know how much traffic its companion app would receive, so they decided to work with Scalr and Compute Engine because of its flexibility. grandcentrix needed infrastructure that could scale up and down quickly, with instances that would instantly start serving user requests. Without knowing expected traffic levels, the objective was to take the backend service to a point where it could scale horizontally - that is, where adding twice the capacity would result in twice the throughput.

We had the following components running on Google Compute Engine:

Nginx as a load balancer
Apache running the app’s PHP code
Redis as a datastore for most queries
MySQL as a datastore for relationally heavy queries

Scalr was used as a control panel to launch instances and orchestrate the pieces together through automated configuration and DNS management.

How Compute Engine helped us get there
The network
Google Compute Engine has a high performance network - packets move consistently and quickly. To take full advantage of this we went for Compute Engine’s largest compute offering and tuned our network settings a bit to accommodate more connections (think net.ipv4.tcp_tw_reuse, net.ipv4.netfilter.ip_conntrack_tcp_timeout_time_wait, and net.nf_conntrack_max, among others).

The elasticity, provisioning times, and billing
During the first Eurovision semifinal voting phase, traffic went up by a factor of 5. We were able to quickly spin up extra capacity in just a few minutes and handle the traffic that we were receiving.

During the finals, we were extra careful and decided to spin up 2x capacity just before the voting. We kept those instances up for 30 minutes, and shut them down as soon as the voting phase ended. Compute Engine’s sub hour billing was greatly appreciated by the grandcentrix team and saved them approximately 50% of what it would have cost on other providers.

The (complete) flexibility
Google Compute Engine gives us full access to the instances, so we can understand what’s happening under the hood and optimize it. Here’s an example: DNS resolution.

Here, we connected to the DB instances by pointing the app to a Scalr-managed hostname that lists their IP addresses and gets updated when we add or remove DB servers.

Having low-level (socket) access let us understand the need for and implement randomization logic to distribute traffic evenly across our database servers and get consistent performance throughout the show.

Ready for showtime!
In the end, the infrastructure was ready for the Eurovision finals on Saturday. Google Cloud Platform, grandcentrix and Scalr were able to deliver 50,000 RPS, with 99% of the requests completed within 35ms at the app server layer.

The traffic was higher than expected when voting started, but significantly lower than expected during the results phase (turns out people watch a TV show on TV!), and grandcentrix was able to shut down a large part of the cluster to save on cost and take advantage of Compute Engine’s sub-hour billing!

In the end, Google Cloud Platform provided the technology, pricing, and robustness that grandcentrix and Scalr needed to deliver a high performance solution for Eurovision.

- Contributed by Thomas Orozco, Solutions Engineer, Scalr

- Posted by Brian Goldfarb, Head of Marketing

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