I’ve been playing with the newly-released Java support in Google App Engine and it is pretty cool. You can do more than I expected you could:
- The Google App Engine Eclipse plug-in gives you a template project and associated config files, Ant build scripts, a deployment tool, and a local run-time environment that acts like GAE (user service, data store, limitations imposed by the platform).
- You’ve got full persistence and query capability via JDO. You pretty much just model your entities as POJO’s, then you annotate the fields in those classes as “persistent” and you’re good to go. You do JDOQL to query your objects. Queries will only return the first 1000 results.
- You can run cron jobs. A cron job wakes up on a schedule and invokes a URL you specify.
- Servlets and JSPs are supported but you can also use things like Struts and Spring (See Will it Work in Google App Engine?).
- You can take advantage Google’s User service, which means anyone with a Google account can sign-in to your app without creating a new account.
- You can take advantage of Memcache if you need it (JCache).
- You can fetch URLs via the URL Fetch service or java.net.URLConnection.
- You can send mail via JavaMail.
- You can use their Image service to resize, rotate, flip, and crop images.
- Both JDK 5 and JDK 6 are supported.
There are some limits:
- Execution of requests is limited to 30 seconds and that includes URLs invoked by cron jobs.
- You can’t write to the file system. If you need to write out files, I assume you’d use S3 or something.
- You can’t open sockets.
- Each developer can create up to 10 applications and apps can’t be deleted so don’t fill up on Hello Worlds.
- You can run an app that has up to 500 MB of storage and serves 5 million page views per month at no cost.
The beauty, obviously, is that as a developer, you get to focus on the code and let Google worry about scaling. For many applications, this Platform-as-a-Service (PaaS) will be preferred over Infrastructure-as-a-Service (IaaS). In an IaaS setup, you can use solutions like RightScale to automatically provision new nodes to handle spikes in demand, but you still have to set that up. Plus, you’ve got the additional cost and headache of installing, configuring, and maintaining the application server and database software (and making sure it is set up to work when new nodes are auto-provisioned). With the app engine, scaling globally is pretty simple: Step 1 – Write (Good) Code; Step 2 – Deploy Code to GAE.