The on-demand, self-service, pay-by-use model

The on-demand, self-service, pay-by-use nature of cloud computing is also an extension of established trends. From an enterprise perspective, the on-demand nature of cloud computing helps to support the performance and capacity aspects of service-level objectives. The self-service nature of cloud computing allows organizations to create elastic environments that expand and contract based on the workload and target performance parameters. And the pay-by-use nature of cloud computing may take the form of equipment leases that guarantee a minimum level of service from a cloud provider.

Virtualization is a key feature of this model. IT organizations have understood for years that virtualization allows them to quickly and easily create copies of existing environments —sometimes involving multiple virtual machines — to support test, development, and staging activities. The cost of these environments is minimal because they can coexist on the same servers as production environments because they use few resources.

Likewise, new applications can be developed and deployed in new virtual machines on existing servers, opened up for use on the Internet, and scaled if the application is successful in the marketplace. This lightweight deployment model has already led to a “Darwinistic” approach to business development where beta versions of software are made public and the market decides which applications deserve to be scaled and developed further or quietly retired.

Cloud computing extends this trend through automation. Instead of negotiating with an IT organization for resources on which to deploy an application, a compute cloud is a self-service proposition where a credit card can purchase compute cycles, and a Web interface or API is used to create virtual machines and establish network relationships between them. Instead of requiring a long-term contract for services with an IT organization or a service provider, clouds work on a pay-by-use, or payby-the-sip model where an application may exist to run a job for a few minutes or hours, or it may exist to provide services to customers on a long-term basis. Compute clouds are built as if applications are temporary, and billing is based on resource consumption: CPU hours used, volumes of data moved, or gigabytes of data stored.

The ability to use and pay for only the resources used shifts the risk of how much infrastructure to purchase from the organization developing the application to the cloud provider. It also shifts the responsibility for architectural decisions from application architects to developers. This shift can increase risk, risk that must be managed by enterprises that have processes in place for a reason, and of system, network, and storage architects that needs to factor in to cloud computing designs.

Infrastructure is programmable
This shift of architectural responsibility has significant consequences. In the past, architects would determine how the various components of an application would be laid out onto a set of servers, how they would be interconnected, secured, managed, and scaled. Now, a developer can use a cloud provider’s API to create not only an application’s initial composition onto virtual machines, but also how it scales and evolves to accommodate workload changes.

Consider this analogy: historically, a developer writing software using the Java™ programming language determines when it’s appropriate to create new threads to allow multiple activities to progress in parallel. Today, a developer can discover and attach to a service with the same ease, allowing them to scale an application to the point where it might engage thousands of virtual machines in order to accommodate a huge spike in demand.

The ability to program an application architecture dynamically puts enormous power in the hands of developers with a commensurate amount of responsibility. To use cloud computing most effectively, a developer must also be an architect, and that architect needs to be able to create a self-monitoring and self-expanding application. The developer/architect needs to understand when it’s appropriate to create a new thread versus create a new virtual machine, along with the architectural patterns for how they are interconnected.

When this power is well understood and harnessed, the results can be spectacular. A story that is already becoming legendary is Animoto’s mashup tool that creates a video from a set of images and music. The company’s application scaled from 50 to 3,500 servers in just three days due in part to an architecture that allowed it to scale easily. For this to work, the application had to be built to be horizontal scaled, have limited state, and manage its own deployment through cloud APIs. For every success story such as this, there will likely be a similar story where the application is not capable of self-scaling and where it fails to meet consumer demand. The importance of this shift from developer to developer/architect cannot be understated. Consider whether your enterprise datacenter could scale an application this rapidly to accommodate such a rapidly growing workload, and whether cloud computing could augment your current capabilities.

Applications are composed and are built to be composable
Another consequence of the self-service, pay-by-use model is that applications are composed by assembling and configuring appliances and open-source software as much as they are programmed. Applications and architectures that can be refactored in order to make the most use of standard components are those that will be the most successful in leveraging the benefits of cloud computing. Likewise, application components should be designed to be composable by building them so they can be consumed easily. This requires having simple, clear functions, and well-documented APIs. Building large, monolithic applications is a thing of the past as the library of existing tools that can be used directly or tailored for a specific use becomes ever larger.

For example, tools such as Hadoop, an open-source MapReduce implementation, can be used in a wide range of contexts in which a problem and its data can be refactored so that many parts of it can execute in parallel. When The New York Times wished to convert 11 million articles and images in its archive to PDF format, their internal IT organization said that it would take seven weeks. In the mean time, one developer using 100 Amazon EC2 simple Web service interface instances running Hadoop completed the job in 24 hours for less than $300. (This did not include the time required to upload the data or the cost of the storage.) Even large corporations can use cloud computing in ways that solve significant problems in less time and at a lower cost than with traditional enterprise computing.

Example Web application deployment
As an example of how the combination of virtualization and self service facilitate application deployment, consider a two-tier Web application deployment into a cloud:

1. A developer might choose a load balancer, Web server, and database server appliances from a library of preconfigured virtual machine images.

2. The developer would configure each component to make a custom image. The load balancer would be configured, the Web server populated with its static content by uploading it to the storage cloud, and the database server appliances populated with dynamic content for the site.

3. The developer layers custom code into the new architecture, making the components meet specific application requirements.

4. The developer chooses a pattern that takes the images for each layer and deploys them, handling networking, security, and scalability issues.

5. The secure, high-availability Web application is up and running. When the application needs to be updated, the virtual machine images can be updated, versioned, copied across the development-test-production chain, and the entire infrastructure redeployed. Cloud computing assumes that everything is temporary, and it’s just as easy to redeploy an entire application than it is to manually patch a set of individual virtual machines.

In this example, the abstract nature of virtual machine images supports a composition-based approach to application development. By refactoring the problem, a standard set of components can be used to quickly deploy an application. With this model, enterprise business needs can be met quickly, without the need for the time-consuming, manual purchase, installation, cabling, and configuration of servers, storage, and network infrastructure.

Source of Information : Introduction to Cloud Computing architecture White Paper 1st Edition, June 2009


Subscribe to Developer Techno ?
Enter your email address:

Delivered by FeedBurner