The evolution towards cloud solutions is one of the biggest revolutions in the IT sphere and it is completely changing the way of planning and evaluating infrastructures in a business setting.
It’s not a piece of news that the Infrastructure as a Service (Iaas) architectures allow system administrators to leverage the service model to consolidate servers, increase the availability of business applications and, in most cases, even to lower costs.
In the transition from virtualization to cloud, VMware has been one of the reference players for sure thanks to its advantage gained in those years when it really was the only company that invested in the development of virtual solutions. Nowadays -whatever the vendor of my hypervisor might be- virtual machines, as a matter of fact, are the fundamental computing unit of an IT system.
However, something is deeply changing in IaaS architectures: we’re talking about two important innovations such as the development of applications built natively for a cloud architecture and containers, which radically simplify the implementation and the development of the more traditional applications. VMware is naturally working as quick as possible to maintain its advantage in this sector too.
Let’s see how by analyzing the solutions introduced during the last VMworld (Europe and USA).
Anatomy of a cloud-native application
According to Kit Colbert -VMware’s VP & CTO and Team Leader of the Cloud Native Application project- the term cloud-native is used for these last-generation applications built on top of dynamic and elastic infrastructures. Software defined datacenter, coupled with the infrastructural elements of the vSphere and NSX packages, is the ideal setting where to run traditional and cloud-native applications.
A multitier traditional application can be developed and brought into production inside private and public clouds while keeping an atomic application setting, implementing a micro-segmentation and eliminating, at last, infrastructural constraints. In the development of big distributed applications the SOA (Service Oriented Application) approach has always been the tested method of choice by those big working teams that, in addition to realize the projectual objective, had larger room for enhancements with time.
In 2015 however the needings of the clients are often unlike those of traditional infrastructures: speed of deployment, scalability, solidity and interoperability with different mobile devices are “the bare minimum” for a new-gen app.
As a matter of fact, among the disadvantages of SOA development, apart from deployment time, we can find the lack of adaptability to the mutations of the infrastructure like system scalability and the increment of the devices that are part of the Internet of Things.
To keep the pace of the evolution of characteristics and development methods, to embrace these new needings, a new element was created.
Containers, that are, the elements that encapsulate this business logic and developed according the principle of microservice, are the main architectural elements of a cloud-native application.
The real software revolution raises here. By developing with the microservice logic you can lighten the load of a developer while still maintaining the basic functional features like:
- Interaction with other containers and/or external systems;
- Storing the set of significant data;
- Execution of one or more complex operations in synchronous or asynchronous mode.
Moreover, each container inside the application can behave with one or more roles, like:
- Expose APIs for future integrations;
- Contain and manage databases;
- Execute processes;
- Behave as client to third-party applications;
- Communicate with mobile devices, browsers and desktop applications.
Stack according to VMware
The working team lead by Kit Colbert himself has the goal of building the embryo of a new framework to host applications developed in containers, called cloud-native applications indeed. At the beginning of 2015, on the official VMware blog lots of announces and technical previews of Photon, Lightwave and other components related to a new environment appeared. These are the new elements that compose the Platform-As-A-Service offer and generate a “comfortable” place where to develop old and new generation applications.
Similarly to a virtual machine, a container has some characteristics in common, among these the main are:
- Enclosing the execution environment including the libraries needed;
- Isolating and at the same time interconnecting containers with network segments created ad-hoc;
- Moving, replicating and distributing the workload.
But the new boundary line marked between the developers world and the sysadmins’ is, indeed, the container engine Photon, that is, the virtual machine that -in the VMware architecture- hosts a minimal version of Linux capable of managing the life cycle of the container itself.
As in every revolution, the real push comes from below, so Photon, whose iso can be downloaded at https://vmware.github.io/photon/, is a system open to contributes from the community.
This behaviour of the big companies is indeed their point of strength at the moment: even though in the past the ‘closure’ of the code was an element of security and control, now, finally, the general trend is to orient developments to the real needings of the public.
Talking about container engines, Docker is a point of reference for sure, at least because it was one of the first available on the market. Docker too is open to the community and it’s not a case that its model has been available from the beginning in VMware Photon: following the guide lines, available at the “Getting Started” section of the reference website, you can realize a development and production environment in a few minutes.
As it’s true for the container model, production and deployment become easier and the whole infrastructures gets lighter, more efficient and portable, as it can be realized by using your own workstation, without compromises and obtaining the same result of a production system.
The revolution of the containers paradigm is complete with a significant improvement of the life cycle of software. Software can be developed with both the microservice logic and in a traditional style, still developers can also put it into production. And as every revolution predicts, we end up with a liberation: finally sysadmins no longer are hostages of development teams during the final phases of an application.
Let’s imagine a world where development starts from a catalogue of existing application, that such catalogue can be changed to fit the needs and that the final result can be brought into production with the help of nobody but still be shared with everybody.. That means developing with containers.
In our next meeting (January issue of GURU advisor) we will talk in depth about development with Docker and Photon.