Implications of microservices and containers on enterprise IT

Adopting containers and microservices allows your enterprise to be more modern, agile and event-driven. These steps prevent inefficiencies from bogging down infrastructure.

IT managers, architects and developers are all trying to come to terms with how microservices and containers will change enterprise IT. It's a good question on one level, but in reality, something deeper is driving technology and IT.

To understand microservices and containers, start by grasping the flow of value this digital transformation defines, then align IT and data center capabilities with the transformative drivers. Finally, build for agility -- not just for the next big thing.

IT planners and managers must understand that changes in the fundamental relationship between applications and workers -- in particular, by the paradigm of contextual, event-driven, mobile workers -- drive the use of containers and microservices. The shift in IT direction will keep expensive, long-lived IT infrastructure aligned with a dynamic marketplace. It is not simply a matter of more efficient cloud hosting or lower operations complexity, but a matter of better serving organizations that demand IT responsiveness to their needs.

Modern workers

At Liberty Mutual, a shift in IT direction brought more agility and value to the business.

Application software evolved from recording business activity to facilitating that activity. Applications built a path of least resistance for companies to follow in establishing operational plans. Enterprise architects have tried to align applications to business goals for more than a decade, but they're often frustrated because the IT tools available dictate the way in which workers can conduct business.

The advent of smart mobile devices encapsulates this phenomenon. Workers who are empowered with mobile apps require support for what task they're trying to do, not a predefined workflow path to follow. The mobile worker is event-driven, which means applications have to be as well. Microservices aren't an IT development looking for a business justification; they're a way to structure applications to respond to tactical needs.

Lower overhead than traditional virtualization

At the application level, microservices force architects and developers to think not only of features and processes as services, but to rethink the whole notion of workflow and application composition. With service-oriented architecture and other service-based methodologies, workflows bind components into composed applications. The goal of microservices is to let the worker's activity bind and compose components. Each step and feature is made available on demand.

Perhaps the most critical implication of microservices and agile IT is every component is mission-critical. In an application model where components are explicitly composed, you can meaningfully divide up mission-critical and nonmission-critical apps. With microservices, a component could be part of a mission-critical app or not, depending on the worker context. Compliance, security and reliability must meet standards overall and not just where needed.

It is not simply a matter of more efficient cloud hosting or lower operations complexity, but a matter of better serving organizations that demand better IT responsiveness to their needs.

The extemporaneous nature of microservices is what's driving the container trend. Virtualization, be it in the data center or the cloud, imposes an overhead cost on the applications that depends on how it's mechanized. If services are small and tactical, then virtualization overhead is difficult to justify. Containers are essential if microservices are to see wide adoption, and microservices are essential to an event-driven IT model.

Microservices must be based on the right component architectures, which allow IT to deploy and scale components dynamically. RESTful, stateless components and even functional programming will actively deter developers from building stateful components. Development managers and architects now have functional tools, with vendors such as Microsoft and Oracle addressing functional programming evolution through Lambda expressions. However, they'll have to impose functional discipline around microservices development, because the imperative model of programming is still available.

Improving the back end

Adopting containers doesn't guarantee data centers will evolve optimally to support microservices and event-driven IT. The more agile application components become, the more inefficient their deployment could be. Take steps to prevent it. Work with business stakeholders and developers so that the application design avoids excessive, unwarranted componentization. Runaway microservices use leads to IT inefficiency without improving end-user agility. Beyond this, the IT operations team must modify data center operations practices and the data center itself.

Microservices and event-driven components work best if network delays are minimized throughout the entire data center and even between multiple data centers or public cloud services. Use fast local networks for the data center backbone, providing optimized network data paths in servers and network adapters, and avoid overloading virtual switches. Interconnect data centers to reduce latency and packet loss, which deteriorate microservices performance significantly.

What can't be made faster should be avoided. Spec out application deployment and DevOps tools as needed to place microservices properly. Host microservices close to the point of worker connection, but also as close as possible to fixed resources, such as databases, to avoid excessive propagation delay. Seek out orchestration tools that consider these points when placing a microservice on IT resources. Train the IT operations staff to provide the correct connection information in installation parameters and policies.

Microservices and containers, driven as they are by business agility, will likely create the largest force that drives a data center to adopt private cloud, supporting hybrid cloud deployment. While it is possible to build a microservices and container model on virtualization principles, the need for agile application response to work events dictates open migration of features and functions. Cloud-friendly practices internally and with assiduous public cloud adoption will make elastic component scaling easier.

Next Steps

Building an app? Here's how to use microservices

Containerization reinvigorates old applications

Microsoft offers microservices alternative with Service Fabric

Follow 6 key steps to deploy microservices in production

Dig Deeper on Managing Virtual Containers