Amazon Web Services vs. Google App Engine: The Race to the One-Click Cloud

August 27, 2008
One-Click Shopping

Can Amazon Build the One-Click Cloud?

It’s a great time to program for the cloud, no matter what Ted Dziuba’s entertaining but barely coherent rants have to say (will someone get that guy some experience?). Amazon and Google are going toe-to-toe, with Amazon’s addition of sorting in Simple DB bringing it up to par with Google App Engine’s Datastore API. Sorting was the biggest missing piece in Simple DB and the most compelling reason to choose the Datastore API instead. No longer.  

But Google App Engine (GAE) and the Datastore API still win. Here’s why:

  1. The Datastore API is projected to be 10x cheaper. $0.15-$0.18 per GB-month sounds a lot better than Simple DB’s $1.50 per GB-month.
  2. GQL. GAE’s SQL subset is just brain dead simple. As adept as programmers are at learning new frameworks, it’s nice to have something brain dead every once in awhile. Simple DB takes a few more cycles to learn (brain cycles that is — more coffee and such. Modafinil perhaps? Anyone tried it? I’m curious).
  3. GAE has better Object Relational Mapping (ORM). GAE basically uses Django’s sweet ORM system. You’ve got to jump through a lot more hoops to get something as nice with Simple DB. 
  4. GAE automatically scales the web application, not just the database. With Amazon, you have to add load balancing and bring machines up and down yourself, even if you’re using Simple DB. While there are third-party tools to help, they’re not built-in. Again, GAE is brain dead here.  

Sure, App Engine only supports Python. The ultimate question, though, is what functionality can you get in the end? For web apps, App Engine gives you more, particularly for scaling (which is kind of the whole point). Don’t know Python? Learn it. It will save you time in the end. Instead of endlessly fiddling with your load balancer and custom scripts for bringing instances up and down, you’ll spend your time adding the next killer feature your users will love.

In the end, the Amazon/Google “main event” is a huge win for you, me, and our users. The sorting announcement from Amazon comes on the heals of a flurry of other new features from both companies, including Amazon’s impressive persistent storage addition for EC2 called the Elastic Block Store, querying by attributes on Simple DB, GAE’s support for 10 applications per user instead of 3, GAE’s batch writes, etc. Neither one is pulling any punches, and the tools at our disposal as developers are progressing at a breathtaking pace as a result.

Amazon’s is clearly the more complete offering (you can do anything on it, in any language), but it needs to learn from Google’s focus on the dominant deployment scenarios.  Amazon could easily win if it does the following:

  1. Makes Simple DB pricing competitive with Google’s projected prices.
  2. Adds a query language for Simple DB along the lines of GQL.
  3. Adds automatic scaling for web applications, not just the database.
  4. Offers complete deployment solutions for the dominant web applications frameworks, from Tomcat/Spring/Hibernate to Django and Zend, with ORM models already adapted to Simple DB, instances automatically replicated with traffic, etc. Basically the same thing as App Engine for more web app frameworks than App Engine supports and adapted to the Amazon platform. Sure, there are third-party solutions for some of this stuff, but those will never be trusted as much as something offered directly from Amazon.

I’m a big fan of Amazon and Werner Vogels (one of the most innovative people in the industry, and also apparently a pretty nice guy), but Amazon desperately needs to learn from what Google has done. It’s ultimately a question of “usability” for developers. The originators of “one-click shopping” are losing in the game they practically invented. 

Amazon needs to turn on the one-click cloud.

Advertisements

Simple DB First Impressions

January 16, 2008

I ran into some MySQL replication issues on our server cluster the other day, prompting me to finally check out Amazon’s new Simple DB.

Here are my top-level impressions:

  1. It takes a little while to wrap your head around the relational database versus Amazon’s sets and items.
  2. The query syntax and the APIs are very simple and straightforward once you wrap your head around them.
  3. The example classes are a little clumsy. Maven support would double the speed of going through the Java ones.
  4. *Once they support ordering*, you’ll never touch your database again.
  5. They don’t support ordering.

For the first 30 minutes of playing with it, I could not have been more excited. I was just picturing deleting all those Hibernate-related classes from my code, and I thought I might never have to look at mysql logs of my.cnf again in my life. All that, and my database would scale with even less work than it would in my load-balanced MySQL cluster.

That’s when I happened upon the sad truth that Simple DB does not yet support ordering. I had my tables all converted to Amazon’s domains and items in my head, and then I realized it was all for nothing. I need ordering for most of my queries, and I’m sure many of you do too.

It seems quite likely Amazon will add support for ordering in the near future, as word has it they included it in the private beta before the current semi-public beta stage.  They likely took it out over performance concerns, as ordering gets expensive when databases are distributed over many machines.

Once they support ordering, though, the rest is so clean that I’ll almost certainly switch.  The time savings in reduced database maintenance make it a simple decision.

Oh, and I’ll post more about this, but the LittleShoot site is live. Beta downloads are still invite-only, but we’re getting very very close to wider release. I’m currently tweaking some of the security details with publishing your files, but once that’s done it’s off to the races.

You can read more about LittleShoot on the site and you can sign up to be notified when you can join the beta. Exciting stuff.