If you missed our previous session, you can catch up here. This week, we took a deep dive into Terraform exploring what it is, why it matters, and what makes it such a powerful tool in modern cloud engineering.
Container Technology & Kubernetes Explained
In the last decade, container technology has completely transformed how software is built, packaged, shipped, and deployed. From small startups to global enterprises, containers and especially Kubernetes have become the backbone of modern cloud infrastructure. But how did we get here? Why are containers such a big deal? And how does Kubernetes orchestrate them like a world-class conductor of a digital orchestra?
Let’s break it down in a simple, well-structured, and captivating way.
1. What Are Containers? (And Why the Tech World Loves Them)
A container is a lightweight, self-contained package that includes everything an application needs to run:
The app code
Dependencies
Runtime environment
System libraries
Think of a container like a sealed food pack you can heat anywhere.
Whether you're in Lagos or London, the food tastes exactly the same.
Real example
If your Python app requires Python 3.10, Flask, and specific system libraries, a container ensures it runs exactly the same way:
On your laptop
On your team’s machines
In production
In the cloud
Gone are the days of “Works on my machine.”
2. Container Technologies (The Ecosystem That Makes It All Work)
Container technologies include several categories:
a) Container Engine / Runtime
This is the low-level component that actually runs the container.
Examples:
containerd (used by Docker and Kubernetes)
CRI-O (lightweight runtime used in many Kubernetes environments)
runc (executes containers according to OCI specs)
b) Container Client Tools
These are the tools developers interact with.
Examples:
Docker CLI → docker build, docker run
Podman → A daemonless alternative to Docker
Buildah → For building images
Skopeo → For managing container images in registries
c) Container Registries
A place to store and share container images.
Examples:
Docker Hub
GitHub Container Registry
AWS ECR
GCP Container Registry
Azure Container Registry
These registries function like “app stores,” but for infrastructure.
3. Container Runtimes (The Engine Under the Hood)
A container runtime manages:
Creating containers
Executing containers
Managing container lifecycle
Enforcing security isolation
One important detail:
Kubernetes no longer manages Docker directly.
It now uses the Container Runtime Interface (CRI) to communicate with:
containerd
CRI-O
Others that implement CRI
This makes Kubernetes more modular, faster, and cloud-agnostic.
4. Container Orchestration (Why We Need Something Bigger Than Docker)
Running one container is easy.
Running hundreds or thousands across multiple servers is not.
That’s where container orchestration comes in.
Orchestration tools handle:
Automated deployment
Scaling containers up/down
Rollouts and rollbacks
Load balancing
Self-healing containers
Monitoring container health
Leading container orchestration platforms:
Kubernetes (industry standard)
Docker Swarm
Nomad by HashiCorp
But Kubernetes reigns supreme.
5. Kubernetes (K8s): The Operating System of the Cloud
Kubernetes is the most popular orchestration system.
It treats containers like tiny workers and coordinates them intelligently.
It ensures apps always run smoothly, reliably, and scalably even under heavy traffic.
Why companies love Kubernetes
Highly scalable
Works in any cloud (AWS, GCP, Azure, DigitalOcean)
Self-healing
Automated deployments
High availability
Huge community & ecosystem
From Netflix to Spotify to banks and telecom providers Kubernetes powers mission-critical systems globally.
6. Kubernetes Cluster Components (How Kubernetes Actually Works)
A Kubernetes cluster is made up of two key groups of components:
A. Control Plane Components
This is the “brain” of Kubernetes that makes decisions.
1. API Server
Acts as the gateway for all Kubernetes operations
Every command (CLI, UI, automation) interacts with this server
Example: kubectl apply -f app.yaml first hits the API server
2. etcd
Key-value store that holds cluster state
Think of it as the “memory” of Kubernetes
Highly available and distributed
3. Scheduler
Assigns containers (pods) to appropriate worker nodes
Decides placements based on:
CPU
RAM
Node capacity
Affinity rules
4. Controller Manager
Controls long-running processes such as:
Node controller
Replication controller
Endpoint controller
Service account tokens
B. Worker Node Components
This is where containers actually run.
Each worker node includes:
1. Kubelet
Agent that runs on every worker node
Ensures containers are running as instructed
Talks directly to the container runtime
2. Kube-Proxy
Handles networking across nodes
Ensures routing between services and pods
3. Container Runtime
- Actually launches containers (e.g., containerd)
7. How It All Works Together Example Workflow
Let’s say you deploy a containerized Flask app using Kubernetes:
- You write a YAML file (
deployment.yaml). - You run:
kubectl apply -f deployment.yaml
- It goes to API Server.
- Scheduler picks the best worker node.
- Kubelet tells container runtime to start the container.
- Kube-Proxy ensures networking & load balancing.
- Controllers ensure the app maintains the desired replicas.
- If a pod fails → Kubernetes automatically restarts it.
This automation + intelligence is the reason Kubernetes is the backbone of cloud-native computing.
8. Why Containers + Kubernetes Matter Today
They help organizations:
Deploy faster
Reduce costs
Improve reliability
Scale effortlessly
Standardize development
Simplify multi-cloud strategies
Industries using containers + Kubernetes include:
FinTech
E-commerce
Banking
Telecom
Energy
Government
Healthcare
For anyone pursuing cloud engineering, DevOps, or platform engineering, understanding this ecosystem is essential.
Containers changed how we package applications.
Kubernetes changed how we run them at scale.
Together, they form the foundation of modern cloud infrastructure powering the apps we use every day.
This article gives a solid, deep, yet beginner-friendly guide to understanding containers, container runtimes, orchestration, and Kubernetes components. Mastering this knowledge opens the door to advanced cloud engineering roles and DevOps practices.
I’m Ikoh Sylva, a passionate cloud computing enthusiast with hands-on experience in AWS. I’m documenting my cloud journey from a beginner’s perspective, aiming to inspire others along the way.
If you find my content helpful, please like and follow my posts, and consider sharing this article with anyone starting their own cloud journey.
Let’s connect on social media. I’d love to engage and exchange ideas with you!
Top comments (0)