Your browser is not supported. Please update it.

19 July 2018

Ghosts of past can haunt microservices future

It is hard to avoid microservices and associated terms like DevOps and software containers these days which suggests they are being oversold in the same way that AI often is in the broader sphere. The difference being that microservices is definitely the way to go for any greenfield service development, since many of the tools and methods are already well proven in the general enterprise data center world and the benefits such as speed of development and scalability vastly outweigh slight risks.

It is a different story for the majority of operators and broadcasters burdened by legacy systems, as these may be monolithic and often impose a heavy drag on innovation. In these cases, migration to microservices must occur, but operators should proceed cautiously with prototyping, placing a toe in the water, rather than rushing headlong to re-engineer existing software. Otherwise there is a significant risk of joining the growing catalog of microservices migration failures. It is better to learn from other people’s mistakes than make one’s own in this case because the cost of failure can be significant and result not just in loss of momentum, but also of customers.

The underlying concept of microservices, like so much else in IT, is hardly new, having emerged at least 25 years ago with the field then known as object-oriented programming. Before then software would be written from scratch and although existing components could be used from libraries they tended to be for complete tasks such as sorting an array of numbers or inverting a matrix. The idea of objects was to break down software into smaller manageable components that can then be assembled almost like a kit, reducing programming effort and also, in principle, making maintenance and upgrades easier. Only smaller components would have to be swapped or possibly amended each time.

That really is the essence of microservices but with some steps forward reflecting the parallel evolution of hardware, network infrastructure and demands for more efficient and rapid software development. One major step was the emergence of commoditized virtualized hardware costing less than dedicated systems while another is the phenomenon of DevOps meaning the integration between development, operations along with the associated functions of testing and quality assurance (QA). In the past, an enhancement would require new software development which in turn would have to go through testing and QA cycles in the field with an iterative process going back and forward between operations and testing teams until all bugs had been fixed. This was very slow and cumbersome so that major service upgrades could take a year to roll out while inertia often held back otherwise desirable smaller enhancements. DevOps compresses these cycles into a single process that can be conducted by just one team with the relevant microservice components then slotted in without affecting day to day operations.

Associated with this are the concepts of Software Defined Networking (SDN), which separates higher level control from lower level forwarding of data as IP packets and Network Functions Virtualization (NFV), which in turn isolates specific tasks from the hardware they run on to give greater fluidity and scalability. These all help break down whole infrastructures including hardware and software into components that can be managed and upgraded independently.

Recently the whole field of microservices has started moving into a new generation which increases efficiency, achieving even greater reusability and sharing of underlying functions between multiple applications. The previous generation, still most widely deployed, is based on virtual machines that run on intermediate generic operating systems called hypervisors. This is a software layer between the microservices components and the underlying operating system of the server they are running on, enabling virtualization because this layer is common to many machines. In this way the hypervisor enables virtual machines to operate like independent servers with their own OSs and middleware. But this came at the cost of performance and some flexibility because of the resources consumed by the hypervisor.

The latest approach replaces the hypervisor with software containers, which are modules that allow microservices to connect directly with the underlying OS kernel for greater efficiency and flexibility. Examples include the market leading container called Docker and also Kubernetes performing what is sometimes described as virtualization at the operating system level, although it is almost below that, exploiting just the low-level functions in say Linux kernels to allocate CPU, memory and other resources for each application on demand. When supporting microservices, each container can execute these functions on behalf of multiple applications, which enhances their efficiency and utility in an overall DevOps process. This is because the process convergence is taken right down to the hardware level.

This is where microservices becomes really interesting for pay TV operators as they start to dovetail with ongoing developments towards IP migration, such as the Converged Cable Access Platform (CCAP). Cisco is one to have jumped on this trend with its cloud CMTS (cable modem termination system) which it says has been built on microservices and container technology. The benefit for operators cited by Cisco is a reduction in the number of qualification cycles for new features, speeding up development and implementation of new features for MSOs. Cisco’s first cloud CMTS router was announced in June 2018, reducing space, power, cooling and onsite maintenance by shifting CMTS and CCAP functions to the cloud with software.

Imagine Communications, a Texas based vendor of IP workflow software for video is another champion of microservices and the benefits of containers. Its microservices-based Zenium platform is an upgraded version of the end-to-end Kayak production workflow management system it acquired by taking over Digital Rapids. Using microservice modules as the building blocks for Kayak, Digital Rapids had succeeded in building a workflow system that could interoperate with almost any production component from any supplier. The latest version has been adopted by Sky Italia, among others, for functions including video QoS (Quality of Service), having been attracted by the potential to draw on over 1,000 Zenium microservice modules to construct workflows and production applications. This number highlights the greater granularity of microservices compared to their predecessors so that they are sometimes described as software elements or atoms.

But this compartmentalization can also be a challenge because there are many moving parts. The whole architecture is more complex because it has to manage interconnections between these components and ensure there is scope for dealing with the much greater number of potential failure points compared with traditional systems.

Tracing performance problems and troubleshooting when a particular higher-level process or service fails can be difficult because its tentacles extend across many microservice components with large numbers of inter-dependencies. This may be manageable in a greenfield because there are quite mature microservices platforms that already incorporate tools or capabilities for automated monitoring to ensure that new services do not create unexpected failures. The idea of isolating changes to specific components only works if the inter-dependencies are well mapped and monitored. Also important is to ensure that this distribution across multiple components does not create new security vulnerabilities which again comes down to handling interdependencies as well as ensuring each component is secure in itself.

Fault tolerance also needs close attention because services must be able to withstand outright failures and respond quickly to unexplained timeouts. Failures can proliferate quickly in a microservices environment by cascading through the dependencies, so sophisticated tolerance mechanisms need to be employed. The old adage holds that simplicity above the bonnet conceals complexity inside, so it is important that platforms are robust, mature and well tested if they are to deliver on these promises.

But away from the greenfield, microservices brings greater risk when existing software is re-engineered into components. Rewriting the legacy system from scratch is rarely an option because it is too risky, expensive and time consuming, so the only recourse is to restructure the software gradually into microservices, taking it slowly and ensuring at each step that there is always a fallback to the existing application.

By the same token, data unification is rarely an option either for similar reasons, so part of the transformation will involve developing a transformational layer that will extract relevant data from legacy databases for emerging microservices. There are then many detailed points that are covered in manuals of microservices. Many of the challenges have already been faced by others in enterprise data centers so there is now a repository of expertise to draw on.

This leads to the final point that is just as important, if not more so, than the others, which is that microservices and DevOps will not work unless they are aligned with the software development culture. Many of the failures have occurred when this is not the case, where operations, development and quality assurance teams have remained separate without communicating throughout the software development process. Teams need to coalesce around functions or services rather than development roles. Microservices is as much about philosophy as technology.