Wei L.
Sample Production checklist is now our standard
The nine questions from the first lesson are now part of our service launch review.
Kubernetes in production: scaling, probes and debugging
Run workloads reliably: right sized resources, honest probes, disruption budgets, autoscaling, observability and a calm incident debugging routine
Created by Lena Fischer
- Updated September 2026
- English
- Advanced
What you will learn
- Set requests and limits from measured usage and predict eviction order
- Design probes that reflect real health without causing cascading restarts
- Keep services available during rollouts, node drains and upgrades
- Configure Pod and node autoscaling that reacts correctly to load
- Instrument workloads with metrics, logs and traces
- Debug production incidents with a repeatable, evidence based routine
Course content
Foundations of reliable workloads
Autoscaling
- Video: Horizontal Pod Autoscaler in depth 12 min
- Video: Scaling on custom and external metrics 11 min
- Article: Event driven scaling with KEDA 10 min
- Video: Node autoscaling: Cluster Autoscaler and Karpenter 12 min
- Video: Vertical sizing and in place resize 9 min
Observability
- Article: Metrics with Prometheus 11 min
- Video: Alerts based on symptoms 10 min
- Video: Logs that help during incidents 9 min
- Article: Tracing with OpenTelemetry 11 min
Debugging under pressure
- Video: An incident debugging routine 12 min
- Video: Ephemeral containers and kubectl debug 10 min
- Article: Node level problems 10 min
- Video: DNS and network debugging 11 min
Security and change management
- Video: NetworkPolicies for least privilege traffic 11 min
- Article: Pod security settings 9 min
- Video: Safe rollouts and progressive delivery 10 min
- Video: Cluster upgrades without drama 10 min
Cost and capacity
- Article: Understanding where the money goes 10 min
- Video: Right sizing without risking reliability 9 min
- Video: Spot capacity and workload placement 10 min
- Quiz: Final check 6 min
Requirements
- Solid Kubernetes basics: Deployments, Services, ConfigMaps, kubectl
- Comfortable reading YAML and container logs
- Docker and kind installed with at least 12 GB of memory available
Description
Getting an application onto Kubernetes is the easy part. Keeping it healthy through traffic spikes, node failures, cluster upgrades and the occasional bad release is where teams struggle. This course is about that second part.
What we cover
- Resource requests, limits and QoS classes, and how they decide who gets evicted
- Liveness, readiness and startup probes designed from real failure modes
- Graceful shutdown, PodDisruptionBudgets and topology spread for availability
- Horizontal Pod Autoscaling on CPU, memory and custom metrics, plus event driven scaling with KEDA
- Node autoscaling with Cluster Autoscaler and Karpenter
- Metrics, logs and traces with Prometheus and OpenTelemetry
- A structured debugging routine for incidents, including ephemeral debug containers
- NetworkPolicies, upgrades and cost awareness
How the course works
Each section starts with a failure: a memory leak that triggers evictions, a probe that restarts healthy Pods, a rollout that drops requests, a node drain that takes down a service. We reproduce it on a local multi node cluster, observe it, fix it and write down the rule that prevents it.
You should already be comfortable deploying applications with Deployments, Services and ConfigMaps. Examples use kind locally, with notes for EKS, GKE and AKS where behaviour differs.
Who this course is for
- Platform and SRE engineers running Kubernetes for other teams
- Backend developers on call for services on Kubernetes
- Engineers preparing a first production launch on Kubernetes
Instructor
Lena Fischer
Container and Kubernetes trainer. Docker, clusters and production operations without the jargon
- 4.4 instructor rating
- 23 reviews
- 7,770 students
- 3 courses
- Sample
I run Kubernetes clusters and help development teams move their services into containers. Before that I was a backend developer, so I remember how confusing images, volumes and networking felt the first time.
My courses start from what you already know, a process on your laptop, and add one idea at a time: an image, a container, a Compose file, a Deployment, a Service. Every lesson has commands you can type and an explanation of what changed.
The advanced material comes from real incidents: crash loops, memory limits, failing probes and slow rollouts. I teach the debugging habits that help when the dashboard is red and you need answers.
Student reviews
Bogdan R.
Sample The probe lesson prevented an outage
We had database checks in liveness probes. After this course we changed them, and a later database failover caused no restarts.
Eun-ji K.
Sample Graceful shutdown finally solved
The preStop delay and SIGTERM handling removed the errors we saw on every deploy. Clear explanation of why it happens.
Adaeze U.
Sample Debugging routine is the highlight
Practising simulated incidents with a written routine made me much calmer during real on call shifts.
Martin C.
Sample Excellent and demanding
Very strong content on autoscaling and debugging. The lab needs a powerful laptop, so plan for that.
Fernanda O.
Sample Advanced indeed, plan for it
Accurate and detailed, but I should have taken a fundamentals course first. The pace assumes daily Kubernetes work.
Tobias V.
Sample Good cost section
Requests versus usage per namespace was eye opening. I wanted a little more on Karpenter consolidation.
Keep exploring
All Docker and Kubernetes courses
More in Docker and Kubernetes
$79.99
Enroll now