In my previous post, I discussed the differences between hybrid cloud and cloud portability, as well as how to achieve true hybrid cloud deployments without compromising on infrastructure API abstraction, by providing several use cases for cloud portability.
Cloud Portability Defined (Again)
For the sake of clarity, I thought it would be a good idea to include my definition of cloud portability again here: "Cloud portability is the ability to run the same application on multiple cloud infrastructures, private or public. This is basically what makes hybrid cloud possible."
Clearly, the common infrastructure API abstraction approach forces too many restrictions on the user, which makes it fairly useless for many of the cloud portability use cases.
In this post, I would like to propose another method for making cloud portability, and therefore true hybrid cloud, a reality.
An Alternative Approach
One of the use cases I previously mentioned for allowing application deployment portability to an environment, which doesn't conform to the same set of features and APIs, is mobile development — iOS and Android. With operating systems, we see that software providers are able to successfully solve the portability aspect without forcing a common abstraction.
What can we learn about cloud portability from the iOS/Android use case?
Treat portability differently between the application consumer and the application owner: One of the main observations from the iOS/Android case is that, while the consumer is often completely abstracted from the differences between the two platforms, the application developer is not abstracted and often needs to treat each platform differently and sometimes even duplicate certain aspects of the application's components and logic to suit the underlying environment. The application owner, therefore, has the incentive to support and even invest in portability, as this increases the application's overall market reach.
Minimizing the differences, not eliminating them: While the application owner has more incentive to support each platform natively, it is important to use cloud portability as a framework that will allow for minimizing, but not eliminating, the differences to allow simpler development and maintenance.
The main lesson from this use case is that to achieve a similar degree of cloud portability, we need to make a distinction between the application consumer and the application owner. For cloud portability, in order to ensure a native experience for the application consumer, we need to assume that the application owner will be required to duplicate their integration effort per target cloud.
This is the same approach we should take with cloud application portability!
So, how does one go about doing that?
Achieving Cloud Portability With ARIA — A Simple Multi-Cloud Orchestration Framework
In this section, I will refer to this specific project as a means by which to illustrate the principles that I mentioned above in more concrete terms.
Project ARIA is a new Apache-licensed project that provides simple, zero footprint multi-cloud orchestration based on TOSCA. It was built originally as the core orchestration for Cloudify and is now an independent project.
The diagram below provides an inside look at the ARIA architecture.
There are three pillars, upon which ARIA is built that are needed to manage the entire stack and lifecycle of an application:
An infrastructure-neutral, easily extensible templating language.
TOSCA Templating Language vs. API Abstraction
ARIA utilizes the TOSCA templating language in its application blueprints, which provides a means for deploying and orchestrating a single application on multiple infrastructures through individual plugins, thereby circumventing the need for a single abstraction layer.
Templating languages, such as TOSCA, provide far greater flexibility for abstraction than API abstraction as it allows easy extensibility and customization without the need to develop or change the underlying implementation code. This is done by mapping the underlying cloud API into types and allowing the user to define the way it accesses and uses those types through scripts.
With Cloudify, we chose to use TOSCA as the templating language because of its inherent infrastructure-neutral design as well as being designed as a DSL, which has lots of the characteristics of a language that utilizes the support of inheritance, interfaces, and a strong typing system.
Built-in plugins for a wide range of cloud services provide out of the box integration points with the most common of these services, but unlike the least common denominator approach (i.e. a single API abstraction layer), they can be easily extended to support any cloud service.
Workflows enable interaction with the deployment graph and provide another way to abstract common cloud operational tasks such as upgrades, snapshots, scaling, etc.
Putting It All Together
By combining the three aforementioned elements, the user is given a set of building blocks for managing the entire application stack and its lifecycle. It also provides a richer degree of flexibility, which allows users to define their own degree of abstraction per use case or application.
In this manner, cloud portability is achievable without the need to change your underlying code, and, in doing so, you enable true hybrid cloud.