Microservices + Containers: Back to the Physical?

Editor's Note: This essay was originally published on LinkedIn in May 2016.

When I wrote this, Docker was rapidly gaining adoption, Kubernetes had only recently been open sourced, and enterprises were just beginning to embrace cloud-native architectures. Looking back, many of the technologies have evolved, but the larger pattern remains the same: infrastructure keeps moving toward greater abstraction, while simultaneously becoming more distributed. I’ve lightly edited this essay for clarity and readability while preserving the original ideas.

Every few years, enterprise technology undergoes a fundamental shift.

In 2016, that shift was being driven by microservices and containers.

Together, they represented far more than another technology trend. They challenged how applications were designed, deployed, and managed.

Before Microservices

For many years, enterprise infrastructure followed a hardware-centric approach.

Applications were deployed onto carefully managed physical infrastructure, while data protection, disaster recovery, and high availability were largely implemented at the server or storage layer.

Development cycles often lasted one or even two years.

Applications were expected to remain relatively stable throughout their lifecycle.

Service-Oriented Architecture (SOA) attempted to introduce greater modularity, but architectural decisions still largely remained within engineering teams.

Organizations could not easily adopt new programming languages, deployment models, or customer-driven changes without significant effort.

The architecture remained relatively rigid.

Then Came Agile

One of the first major shifts I experienced was Agile development.

I still remember introducing Agile practices around 2010.

At first, it wasn’t easy to understand.

More importantly, it wasn’t easy to explain.

For organizations accustomed to long release cycles and large feature deliveries, Agile felt unfamiliar.

Ironically, Agile made immediate sense in services organizations where customer feedback naturally shaped development.

Product organizations took longer to appreciate its value.

But Agile fundamentally changed one thing.

It shortened the distance between customer feedback and product development.

DevOps Changed Ownership

Agile accelerated development.

DevOps transformed responsibility.

Continuous Integration and Continuous Deployment fundamentally shifted ownership closer to the people operating the applications.

Developers became responsible for deployment.

Operations became part of development.

Infrastructure became programmable.

Personally, I’ve always liked to think of CI/CD as:

Continuous Innovation and Continuous Development.

Because that’s ultimately what organizations are striving for.

Infrastructure also began moving away from carefully maintained “pets” toward disposable “cattle.”

Instead of protecting individual servers, organizations increasingly built systems capable of surviving failure automatically.

Enter Containers and Microservices

Containers took that evolution even further.

Applications became portable.

Deployment became predictable.

Recovery became significantly faster.

Instead of treating infrastructure as something carefully handcrafted, organizations could increasingly think of applications as interchangeable building blocks.

Microservices extended this philosophy.

Applications were no longer built as large, tightly coupled systems.

Instead, they became collections of smaller services communicating through well-defined interfaces.

This offered several advantages:

• Independent deployment
• Better scalability
• Greater resilience
• Faster innovation
• Freedom to choose the right technology for each service

Perhaps most importantly, development teams gained greater autonomy.

Rethinking Virtualization

One thought I had while writing this essay still interests me today.

I wondered whether containers might eventually reduce the need for traditional virtualization.

Containers achieved many of the same goals while introducing far less overhead.

Whether virtualization disappears entirely is less important than the broader lesson.

Technology rarely replaces its predecessor overnight.

Instead, each generation builds upon the previous one.

Today’s enterprise environments happily run:

• Physical servers
• Virtual machines
• Containers
• Kubernetes clusters
• Serverless workloads

Each abstraction solves a different problem.

The Industry Responds

Even in 2016 it was clear that major technology companies understood the significance of this shift.

IBM introduced Bluemix.

Red Hat invested heavily in Atomic Host.

VMware introduced Photon.

Microsoft expanded Azure Container Services.

Every major infrastructure vendor recognized that containerization represented more than another deployment technology.

It represented a new operating model.

Final Thoughts

Looking back, I realize this essay wasn’t really about containers.

It was about ownership.

Every significant infrastructure evolution moves responsibility closer to the people creating value.

Agile moved ownership closer to developers.

DevOps moved ownership closer to operations.

Containers moved ownership closer to applications.

Each shift reduced friction.

Each also required organizations to rethink how they collaborated.

Technology changes quickly.

Organizational thinking changes much more slowly.

The companies that succeed are usually the ones that evolve both together.

Originally published on LinkedIn in May 2016. Republished on abhisekchaudhuri.com as part of the Collected Essays.