Microservices in Practice – Part 2: Harnessing Linux Containers for Faster, Smaller Deployments

Containers and Microservices: A Perfect Pair

Unless you are completely unfamiliar with cloud technologies and cloud‑native application development, you have likely heard of Linux containers, which have rapidly evolved over the past two years. Containers can be viewed as lightweight virtual machines that are more flexible, faster to inherit, and easier to distribute. Docker, launched in 2012, pioneered a simple method for building, packaging, and distributing cloud‑native applications using Linux containers.

Unlike virtual machines, which each run a full guest OS with its own libraries and binaries, containers share the host OS and libraries while packaging only the necessary application binaries, making them far smaller and faster.

Containers run with a minimal resource footprint; typical packaged applications are only a few hundred megabytes, whereas VM‑based applications can be tens of gigabytes. This size advantage aligns with the two microservice characteristics introduced in Part 1.

Industry leaders are adopting cloud‑based infrastructure, and Docker’s portability enables rapid, automated build and deployment pipelines. Studies show Docker users release software up to seven times faster, with some companies achieving up to 100 releases per day.

Docker images are highly portable across environments and pipelines. For example, BBC News reported a 60% speedup in its CI workflow when moving to Docker‑based infrastructure, thanks to modular images that eliminate repetitive configuration.

Docker acts as a code‑shipping container system, encapsulating workloads into lightweight, self‑contained units that run consistently on almost any hardware platform.

Faster and Smaller: Containers as Nano‑Robots for Software Development

Managing hundreds of container instances becomes feasible with orchestration tools such as Kubernetes, Apache Mesos, and fleet, which provide domain‑specific languages for large‑scale container management.

The immutable‑in‑deployment principle treats containers like livestock rather than pets: once deployed, they are not altered; updates are performed by deploying new containers and retiring the old ones, simplifying large‑scale operations.

A Microservice Architecture: The Best Excuse to Stop Playing Whack‑a‑Mole

Beyond scaling containers, developers must consider three key capabilities when building production‑grade microservice applications:

Logging and monitoring

Zero‑downtime continuous delivery

Dynamic service registry

Logging and Monitoring

When a failure occurs, you need visibility into immutable containers. The ELK stack (Elasticsearch, Logstash, Kibana) provides centralized log aggregation, searchable storage, and dashboard creation, eliminating the need for ad‑hoc use of tools like sed, grep, and awk on individual hosts.

ELK can be deployed in the cloud or on‑premises, either as a managed service or via open‑source distributions, often integrated into platform‑as‑a‑service offerings.

Zero‑Downtime Continuous Delivery

Zero‑downtime deployments—sometimes called blue‑green, red‑black, or canary deployments—ensure that applications remain available during updates, avoiding costly and exhausting manual roll‑outs.

By breaking monoliths into smaller containerized services, deployments affect only a subset of the system, and tools like IBM Bluemix’s Active Deploy automate health‑checking and rollback, reducing human intervention.

Dynamic Service Registry

Service discovery (or service proxy) enables containers to locate and communicate with each other dynamically. Registries such as etcd, Consul, or Registrator automatically register new Docker containers, while service proxies like Netflix Hystrix (a Java library) route requests efficiently based on metadata.

Conclusion

This article demonstrated how containers accelerate cloud‑native application development, enabling faster, smaller, and more manageable deployments with built‑in capabilities such as logging, continuous delivery, and service discovery. Deploying containers on managed services and leveraging microservice‑friendly tools simplifies the transition from monolithic systems to modular, automated architectures.

Future installments will explore additional features and best practices for building robust microservice ecosystems.