Get from a laptop container to a self-healing, autoscaling, GitOps-driven platform you would be willing to carry a pager for.
It works on your laptop and then it works nowhere else. Containers fix that, but the tooling around them — layer caches, registries, control planes, admission webhooks — has a reputation for eating months. This course takes the shortest honest path through it. You begin by writing a Dockerfile that builds fast and small, using multi-stage builds and distroless base images, then move to Kubernetes (commonly written K8s) and the handful of objects you will touch every day: pods, Deployments, Services, ConfigMaps, Secrets, and resource limits, on a local cluster you can safely break. After that it is real infrastructure: managed clusters on AWS, Azure, Google Cloud, and DigitalOcean; StatefulSets and event-driven autoscaling; Container Network Interface (CNI) plugins, Ingress, and deny-by-default network policies; persistent volumes, snapshots, and rehearsed Velero restores; Role-Based Access Control (RBAC), admission policy, image scanning, and signed images; and a Prometheus, Loki, and Tempo stack that explains why a pod is unhappy. The last module is operating at scale — GitOps, multi-cluster, upgrades, cost per namespace, and breaking things deliberately to learn what holds.
Built by Lakshya Kumar
We grant free access case-by-case — students, career-switchers, builders on a tight budget. Sign in to send us a note.
Sign in to applyFinished the tasks? Take the prompt to your AI and get tested on it. We copy the prompt and open the app — just paste it in.
Cut build times with layer caching and BuildKit, shrink images with multi-stage and distroless, and wire a whole local stack with Compose.
Learn the small set of objects that runs almost every workload, and watch what the control plane does the moment you delete a pod.
Create real clusters on four providers, wire workload identity, and choose node strategies that capture spot savings without evictions.
Run stateful sets, daemons, batch jobs, and sidecars, then autoscale on queue depth instead of pretending CPU is the real signal.
Get traffic in through Ingress and the Gateway API, resolve names with CoreDNS, and enforce policies that deny everything by default.
Claim volumes, expand them live, snapshot before a risky migration, and rehearse a Velero restore long before you need one for real.
Scope service accounts tightly, reject unsafe pods at admission, scan and sign images, and close what a kube-bench scan turns up.
Stand up Prometheus, Loki, and Tempo, build dashboards people actually read, and route alerts against service level objectives.
Drive every change through Git, upgrade without downtime, watch cost per namespace, and break things on purpose to find what holds.
Complete all modules, then submit the required number of capstone projects. Each must earn a passing rating from an admin reviewer.
Build a production Kubernetes platform spanning two clouds (EKS + GKE). Wire up GitOps with ArgoCD, autoscaling with HPA + KEDA + Karpenter, observability with the kube-prometheus stack + Loki + Tempo, security with OPA/Gatekeeper + signed images via Cosign, and disaster recovery with Velero. Demonstrate the platform end-to-end with a sample app: kill a pod, watch ArgoCD heal it; spike load, watch KEDA scale; restore the cluster from a Velero backup; rotate a Cosign key. Document each step with screenshots and timings.
Paste this into any AI chat. Fill in the bracketed parts with your context — you'll get back a straight answer on whether this belongs on your plate.
I'm considering 'Docker & Kubernetes' — a course on container fundamentals through production-grade multi-cloud k8s. Covers Docker (Dockerfiles, BuildKit, distroless), Kubernetes basics (pods, deployments, services), managed k8s (EKS/AKS/GKE/DOKS), workloads (StatefulSets, KEDA), networking (CNI, Ingress, NetworkPolicy, service mesh), storage (PV/PVC, CSI, Velero), security (RBAC, OPA, Cosign, kube-bench), observability (Prometheus/Loki/Tempo), and operating at scale (GitOps, multi-cluster, chaos engineering). 10 modules × 10 tasks each. Context: 1. My current role: [e.g. "backend dev who uses Docker Compose locally", "junior SRE", "platform engineer", "DevOps lead"] 2. Container experience: [e.g. "I've run docker on my laptop", "I deploy to Heroku", "I've used kubectl get pods", "I run a small EKS cluster"] 3. My goal: [e.g. "ship my company's first prod k8s cluster", "pass CKA/CKAD/CKS", "migrate from VMs to k8s", "design a multi-cluster platform"]
Deploy a production-grade Postgres cluster on Kubernetes using CloudNativePG or Zalando: 3 replicas, automatic failover, WAL archiving to S3, PITR restore tested, and a backup-restore drill that hits a 15-minute RTO. Include the StatefulSet, PDB, and PV configs.
Build a GitOps pipeline: Git repo as source of truth, Argo CD syncing 3 environments (dev/staging/prod), automated promotion via PR-merge gates, drift detection alerts, and a rollback flow that reverts via git revert. Demonstrate a deploy + intentional drift + alert + rollback.
Audit a Kubernetes cluster's cost profile: over-provisioned requests, idle nodes, slow-rolling deployments. Implement at least three optimizations (rightsizing via VPA, Karpenter spot, node selector by workload), measure the savings, and produce a before/after report with line-item breakdown.
Set up Istio or Linkerd on a 5-service cluster. Implement traffic-shift canary releases (10/50/100 with auto-rollback on error-rate spike), distributed tracing, and an SLO-driven promotion gate. Demonstrate a deploy that fails the SLO and auto-rolls-back.
Official Kubernetes documentation — concepts, tasks, reference, and tutorials.