This blog has moved to http://blogs.msdn.com/b/appfabric please update your links!
In the previous posts in this series we covered the challenges that Windows Azure AppFabric is trying to solve, and started discussing the Middleware Services in the post regarding Service Bus and Access Control, the post regarding Caching, and the post regarding Building Composite Applications.
In this post we will discuss how the AppFabric Application Infrastructure is optimized for cloud-scale services and middle-tier components, which enables you to get the benefits of cloud computing. These benefits include: horizontal scale-out, high-availability, and multi-tenancy.
As noted above, we already covered the AppFabric Middleware Services, and the support you get for developing and running Composite Applications. As illustrated by the image below, the next crucial AppFabric component that enables all these great capabilities is the AppFabric Container.
The AppFabric Container is an infrastructure run-time component. It enables services and components running on top of it to get all of the great benefits that a cloud-based environment provides.
Services that can run on top of the container include the AppFabric Middleware Services mentioned in previous posts, other middle-tier components provided by Microsoft, and components that you create.
Let's discuss the main capabilities that the AppFabric Container provides.
The Composition Runtime enables managing the full lifecycle of application components including: loading, unloading, starting, and stopping. It also supports configurations such as auto-start and on-demand activation of components. You can configure these at development time, but you can also use the AppFabric Management Portal to manage components' runtime state, set components' runtime properties, and control components' lifecycle. Instead of having to develop these capabilities on your own, you get them out-of-the-box from the Container, and you are able to easily set and configure them.
Multi-tenancy and Sandboxing
One of the basic concepts of cloud computing is optimizing the use of all available resources in a highly elastic way, so that resource usage is maximized and load and resilience is distributed across the available resources. To make this happen, you need to support many tenants in a highly dense way and ensure that no tenant interferes with another. In addition, this has to be handled in an automated manner, based on the requirements of the application. Once again, the Container is engineered to provide these capabilities so you can maximize the use of the underlying resources through multi-tenancy while providing sandboxing of the different tenants.
When designing applications, it is complicated to implement state management and scale-out in conjunction. In order to be able to scale-out your applications, you end up moving your state management to a different application tier, such as the database. This allows stateless components to be more easily scaled-out; however, this really just moves the bottleneck of state management to a different tier. What if components and state could reside together and still be able to scale horizontally? This way they could scale-out together, saving the developer the need to worry about complexities of external state management and other infrastructure capabilities. The Container provides state management capabilities that enable you to scale-out your application without having to externalize your components' state.
Scale-out and High Availability
With state management capabilities provided out-of-the-box, you would next like to optimize your application performance and provide high availability. You want your application to automatically scale according to the application load. The Container provides these abilities. It takes care of transparently replicating application components so there are no single points of failure. It can also automatically spin-up new instances of components as the application load increases and then spin them down as the application load decreases.
Dynamic Address Resolution and Routing
When you run in a fabric-based environment such as the cloud, components can be placed, replaced, and reconfigured dynamically by the environment in order to provide the application with optimal scale and availability. With all of these moving parts, it is critical to keep track of them and work out where they are and how to invoke them. The Container plays a key role in managing all of this logic for you and automatically and efficiently routes requests to the target services and components, saving you the need to worry about changes occurring in the environment.
As you can see, the concepts and capabilities discussed above are key for you to be able to get the advantages of a cloud based environment. If you really want to optimize your application to get these benefits, and had to implement all of these capabilities on your own, it would cost you a lot of time and require you to implement some pretty complicated concepts. This is just another example how AppFabric, and specifically the AppFabric Container, can make the life of the developer a lot easier and more productive when building applications, by providing these capabilities out-of-the-box.
A first Community Technology Preview (CTP) of the features discussed in this post will be released in a few months, so you will be able to start testing them soon.
As a reminder, you can start using our CTP services in our LABS/Preview environment at: https://portal.appfabriclabs.com/. Just sign up and get started.
Other places to learn more on Windows Azure AppFabric are:
Be sure to start enjoying the benefits of Windows Azure AppFabric with our free trial offer. Just click on the image below and start using it today!
Finally, please leave your comments and questions in the comments section below.
Itai Raz, Product Manager