Ship containers and run them like production
A hands-on, 18-week path from "what even is a container" to running a multi-service app on a real Kubernetes cluster with autoscaling, Ingress, Helm and a GitOps pipeline watching your back. Split out from the DevOps & Cloud course into its own deep dive, because containers and orchestration deserve the room to breathe.
Prerequisites & tooling
What you should already know
- Comfortable in a terminal: navigating directories, running commands, reading error output
- Basic Git — clone, commit, push — enough to pull a sample repo and follow along
- Can build and run at least one small app (any language) outside a container
- Handy alongside our DevOps & Cloud course, but not required as a prerequisite
Stack you'll work with
Free, install-locally tooling — everything here runs on your own machine, no cloud account required until the capstone (and even then, a local cluster works fine).
The full 18-week roadmap
Six weeks of Docker fundamentals, eleven weeks of Kubernetes and Helm, and a capstone that deploys a real multi-service app end to end with CI/CD watching over it.
Containers vs. Virtual Machines & Docker Architecture
What a container actually is under the hood, and why it's not "a tiny VM."
- Namespaces & cgroups — the two Linux primitives containers are built from
- The Docker Engine architecture: daemon, CLI, containerd & runc
- Installing Docker & running your first container end to end
Dockerfiles, Images & Layers
Write a Dockerfile that builds fast and doesn't waste layer cache.
- Every Dockerfile instruction — FROM, RUN, COPY, CMD, ENTRYPOINT & more
- How the layer cache works, and ordering instructions to exploit it
- Containerizing a real app from scratch, image tags & .dockerignore
Volumes & Persisting Container Data
Containers are disposable — your data usually shouldn't be.
- The container filesystem, and why it disappears when the container dies
- Named volumes vs. bind mounts vs. tmpfs, and when to use each
- Running a database in a container without losing data on restart
Docker Networking
How containers find each other, and how the outside world finds them.
- Bridge, host & none networks — what each isolates and exposes
- Custom user-defined networks & built-in container-name DNS
- Port publishing, container-to-container calls & a two-container demo
Docker Compose: Multi-Container Apps
One YAML file, one command, a whole app's worth of containers.
- Writing a compose.yaml: services, networks, volumes & env vars
- Service dependencies, healthchecks & startup ordering
- Standing up a full app + API + database stack with one command
Multi-stage Builds, Image Optimization & Registries
Ship a small, fast, production-shaped image — not a 1.2GB dev environment.
- Multi-stage builds: compile in one stage, ship a lean runtime in another
- Alpine/distroless base images, non-root users & image scanning
- Tagging strategy & pushing to Docker Hub / GHCR / ECR
Kubernetes Architecture & Your First Cluster
The control plane and node components, before you type a single kubectl command.
- API server, etcd, scheduler & controller manager — what each does
- kubelet, kube-proxy & the container runtime on every node
- Spinning up a local cluster with Minikube/kind & your first kubectl commands
Pods, ReplicaSets & Deployments
The building blocks of every workload you'll ever run on Kubernetes.
- Pods as the atomic unit, and why you rarely create one directly
- ReplicaSets, Deployments & declarative desired-state management
- Rolling updates & rollbacks with zero downtime
Services, Networking & Service Discovery
Pods die and get new IPs constantly — Services are how everything still finds them.
- ClusterIP, NodePort & LoadBalancer Services, and when to use each
- Label selectors, endpoints & how a Service finds its Pods
- Cluster DNS & calling one Service from another by name
ConfigMaps, Secrets & App Configuration
Get config and credentials out of your images and into the cluster where they belong.
- ConfigMaps for non-sensitive config, mounted as env vars or files
- Secrets, base64 vs. real encryption, and why that distinction matters
- Environment-specific config without rebuilding a single image
Storage in Kubernetes: PV, PVC & StorageClasses
Persistent storage for the workloads that can't just restart clean.
- PersistentVolumes & PersistentVolumeClaims — the storage abstraction layer
- StorageClasses & dynamic provisioning instead of pre-creating volumes
- Access modes, reclaim policies & running a database on Kubernetes
Ingress, Load Balancing & TLS
One entry point, many services, real HTTPS.
- Ingress resources & Ingress controllers (NGINX Ingress) explained
- Host-based & path-based routing to multiple backend Services
- TLS termination at the Ingress & automated certs with cert-manager
Helm: Packaging Kubernetes Apps
Stop hand-editing YAML for every environment — template it once.
- Charts, templates, values.yaml & the Helm templating language
- Installing public charts & writing your own chart from scratch
- Releases, upgrades, rollbacks & per-environment values files
Resource Management, Scaling & the HPA
Give every Pod a resource budget, then let Kubernetes scale to meet demand.
- Resource requests & limits, and how the scheduler uses them
- The Horizontal Pod Autoscaler — scaling replicas on CPU/memory metrics
- Cluster autoscaling & load-testing a Deployment to watch it scale live
StatefulSets, Jobs & CronJobs
The workload types Deployments were never meant to cover.
- StatefulSets: stable identities & ordered rollout for stateful workloads
- Jobs for run-to-completion tasks, with retries & parallelism
- CronJobs for scheduled work — backups, reports, cleanup tasks
Health Checks, Logging & Observability
Know when a Pod is actually broken, not just running.
- Liveness, readiness & startup probes — what each protects against
- Centralizing logs & a first Prometheus + Grafana metrics stack
- Building a dashboard & alert for a workload you actually run
GitOps & CI/CD for Kubernetes
Git as the single source of truth for what's actually running.
- A CI pipeline that builds, tests & pushes an image on every commit
- GitOps with ArgoCD: the cluster continuously reconciles to match Git
- Automated rollouts, drift detection & a one-command environment promote
Capstone: Ship a Full App to Kubernetes, End to End
Apply every module in one project — containerize, orchestrate, expose, scale & automate a real multi-service app.
- A multi-service app packaged as a Helm chart, deployed with Ingress, HPA & persistent storage
- CI/CD + GitOps wired end-to-end, with monitoring dashboards watching it run
- Portfolio-ready architecture writeup you can show employers