Snapshots in the cloud: The developers friend
By Cameron McKenzie
So, what’s the best tasting part of the cloud, especially if you’re working on a Java development team?
The question isn’t so much about what the best part of the cloud is, or why you might want to use the cloud. Think of a cake. The best tasting part of the cake is definitely the icing, although those sugary little roses you sometimes get on them are pretty tasty too. Of course, people wouldn’t love cake if it was nothing but icing and sugary roses, but the icing and roses are definitely the best tasting parts.
The environment snapshot
For many enterprises adopting a cloud based development strategy, hands down the best feature of developing in the cloud is the ability to take a misbehaving application that simply won’t respond to any of your best attempts to troubleshoot it, create a virtual snapshot of the entire environment as it misbehaves, and then store that environment in an out of the way place in your cloud while others troubleshoot the problem; and the flustered developer can put the entire troubled environment on the backburner while he or she addresses some other problems, and more experienced developers or administrators work on curious application or environmental problems.
And of course, the ability to take a snapshot in the cloud is more than simply having a backup copy of a particular build of your application that could be redeployed anywhere. The insight you can garner from a virtual snapshot or your runtime environment will include not only your deployed application, but all of the system and environment variables that might be affecting the system as well, information that wouldn’t necessarily be available when redeploying an enterprise application archive (EAR file) to a different server.
Snapshot vs. a VMWare type image
Of course, a similar functionality can be achieved with imaging software and virtual environments, so the idea isn’t completely novel. But the thing about doing these types of things in a cloud stack such as the one provided by VMWare’s VFabric, is the fact that the image creation can be done at pretty much the clicking of a button, and you can switch between environments quickly and seamlessly. The administrative overhead of imaging a machine and then loading that image up somewhere else when the time comes is removed, and troubleshooting or even comparing an application in different stages of development becomes much less of an administrative hassle. And what’s more, the cost of disc space in most cloud computing environments is trivial when compared to actual bandwidth or processor usage fees, making it fairly cheap to image off multiple stages of an application that is either under development, or in the middle of some testing or troubleshooting.
Leveraging economies of scale in the cloud
While the cloud delivers significant cost savings when it comes to managing the lifecycle and scalability of deployed applications, the benefits to the actual Java developer who is building these enterprise applications is sometimes less obvious. However, the promise of cheap storage space and relatively low usage fees for applications that are deployed, but experience minimal use, make it very easy for developers to take snapshots of their entire development environments, either freezing those environments to be revisited later, or allowing others to troubleshoot problems while developers go forward on separate virtual images while other, potentially more specialized developers, deal with bugs and problems. The cloud provides many benefits to modern enterprise environments, but the ability to cheaply and easily snapshot a given environment is, from a developers perspective, certainly one of the tastiest.
01 Feb 2011