Course Overview
9 phases · 56 modules · 321 lab steps · 272 quiz questions
How this course works
The Learning Loop (inside every module)
Science-backed constraints used to order the course
How to know you should move on
Mental Model Foundation
Build the right mental model before touching a cluster. Understand WHY Kubernetes exists and HOW it is structured.
Learning role: Build the mental model before adding object complexity.
Set Up Your Local Cluster
Install kubectl and minikube, start a local cluster, and verify you can run commands before tackling anything else.
Why Kubernetes Exists
The problem Kubernetes solves and why it matters.
Cluster Architecture
Deep-dive into control plane and node components.
kubectl & kubeconfig
Master the CLI and configuration file that connect you to any Kubernetes cluster.
Core Primitives
Master the essential building blocks: Pods, Deployments, and Services. These three resources are the foundation of everything in Kubernetes.
Learning role: Learn the smallest Kubernetes primitives and how reconciliation behaves.
Pods — The Atomic Unit
The smallest deployable unit in Kubernetes.
Deployments — Managing Pod Lifecycle
The right way to run applications: automatic restarts, rolling updates, and rollbacks.
Services — Stable Networking
Give your Pods a stable address and load balance traffic between them.
Init Containers & Lifecycle Hooks
Run setup tasks before your app starts and handle graceful shutdown with preStop hooks.
ReplicaSets — Self-Healing Guarantees
Understand how ReplicaSets maintain a desired pod count and why Deployments exist on top of them.
CronJobs — Scheduled Work
Run Jobs on a time schedule using standard cron syntax. Essential for backups, cleanups, and reports.
Multi-Container Patterns
Sidecar, init, adapter, and ambassador patterns: when to use multiple containers in one Pod.
Container Images — Build, Tag & Load
Build container images with Dockerfiles, use multi-stage builds, and load images into minikube for local development.
Configuration & Reliability
Configure your apps correctly with ConfigMaps and Secrets, then make them production-reliable with health probes and resource management.
Learning role: Add configuration, identity, health, and resource constraints to make workloads reliable.
Namespaces
Isolate workloads into virtual clusters for teams, environments, and access control.
Labels & Selectors
Tag resources with key-value metadata and use selectors to wire Services, Deployments, and queries together.
ConfigMaps
Externalise non-sensitive configuration from container images using ConfigMaps.
Secrets
Store and consume sensitive data like passwords, tokens, and TLS certificates safely.
Health Probes
Tell Kubernetes when your app is alive, ready to serve traffic, and finished starting up.
Resource Requests & Limits
Reserve capacity for your pods and cap their resource consumption to prevent noisy-neighbor problems.
Service Types Deep Dive
ClusterIP, NodePort, LoadBalancer, ExternalName, and Headless — when to use each and how they work.
DNS & CoreDNS
How Kubernetes DNS works, the FQDN format, CoreDNS configuration, and how to debug DNS failures.
LimitRange & ResourceQuota
Control resource consumption per namespace: set defaults per container and total budgets per namespace.
Storage, Ingress & Advanced Workloads
Persist data with Volumes and PersistentVolumes, expose apps externally with Ingress, and run stateful and node-level workloads.
Learning role: Handle persistence, traffic entry, network isolation, and specialized workload patterns.
Volumes & PersistentVolumes
Understand ephemeral vs persistent storage and provision durable disks with PVCs and StorageClasses.
StatefulSets
Run databases and clustered apps that need stable identities, ordered startup, and per-Pod persistent storage.
DaemonSets
Run exactly one Pod on every node for cluster-wide infrastructure like log collectors and monitoring agents.
Ingress
Route external HTTP/HTTPS traffic to multiple services with a single entry point and path-based rules.
NetworkPolicies
Implement namespace-level firewall rules to control which Pods can communicate with each other.
PersistentVolumes — Storage Lifecycle
Decouple storage from pods: PersistentVolumes, PersistentVolumeClaims, and StorageClasses for dynamic provisioning.
Gateway API — Next-Generation Ingress
Replace classic Ingress with the role-oriented Gateway API: GatewayClass, Gateway, and HTTPRoute.
Security, Scheduling & Reliability
Secure your cluster with RBAC, autoscale workloads with HPA, control scheduling with taints and affinity, and protect availability with PodDisruptionBudgets.
Learning role: Operate safer clusters with authorization, scheduled work, autoscaling, placement, and disruption control.
RBAC (Role-Based Access Control)
Secure your cluster with Roles, ClusterRoles, and ServiceAccounts — granting only the permissions each workload actually needs.
Jobs & CronJobs
Run batch tasks to completion with Jobs and schedule recurring work with CronJobs.
Horizontal Pod Autoscaler (HPA)
Automatically scale replica counts based on CPU, memory, or custom metrics — without manual intervention.
Taints, Tolerations & Node Affinity
Control where Pods land with node labels, taints, tolerations, and affinity rules.
PodDisruptionBudgets & Cluster Maintenance
Protect application availability during node drains and cluster upgrades with PodDisruptionBudgets.
SecurityContext — Pod & Container Hardening
Run containers as non-root, drop Linux capabilities, enforce read-only filesystems, and prevent privilege escalation.
Node Management — Cordon, Drain & Maintenance
Safely remove nodes from rotation for maintenance without disrupting running workloads.
Admission Controllers — Request Validation & Mutation
Understand how admission controllers intercept API requests to enforce policies and inject configuration before resources are persisted.
Advanced Kubernetes: Helm, CRDs & Observability
Package and deploy with Helm, extend Kubernetes with CRDs and Operators, and build observability into your cluster with metrics, logging, and tracing.
Learning role: Move from primitives to production delivery: packaging, customization, APIs, observability, GitOps, and service mesh.
Helm: Kubernetes Package Manager
Package, version, and deploy Kubernetes applications with Helm charts — the apt/brew for your cluster.
Kustomize: Environment-Specific Config
Manage per-environment configuration without templating — using overlays and patches built into kubectl.
Custom Resource Definitions (CRDs)
Extend the Kubernetes API with your own resource types and understand the Operator pattern.
Observability: Metrics, Logging & Tracing
Build the three pillars of observability into your cluster — metrics with Prometheus, logs with Loki, and traces with OpenTelemetry.
Production Readiness Checklist
Apply everything from the course — a comprehensive checklist for running Kubernetes workloads safely in production.
GitOps with ArgoCD
Automate deployments by treating Git as the single source of truth for your cluster state.
Service Mesh with Istio
Add mutual TLS, traffic management, and deep observability to service-to-service communication without changing application code.
API Deprecations — Staying Current Across Upgrades
Detect deprecated Kubernetes APIs in manifests and Helm charts, understand the deprecation policy, and migrate before upgrades break things.
Certification Prep (KCNA, CKA, CKAD)
Prepare for KCNA, CKA, and CKAD certifications with domain-focused practice, speed drills, and exam-level troubleshooting scenarios.
Learning role: Convert knowledge into timed performance for KCNA, CKA, and CKAD-style tasks.
KCNA: Kubernetes & Cloud Native Associate
Understand cloud-native architecture, CNCF projects, observability, and container orchestration basics for the entry-level certification.
CKA: Certified Kubernetes Administrator
Master cluster installation, troubleshooting nodes, etcd maintenance, imperative operations, storage, and complex networking scenarios under time pressure.
CKAD: Certified Kubernetes Application Developer
Design and build multi-container pods, deploy update strategies (canaries/blue-green), configure config injection, configure probes, and establish job structures.
Cluster Operations
Master day-2 Kubernetes operations: bootstrap clusters with kubeadm, safeguard cluster state with etcd backup/restore, perform zero-downtime version upgrades, and manage PKI certificates before they expire.
Learning role: Practice Cluster Operations with retrieval, spacing, and transfer exercises.
Bootstrapping a Cluster with kubeadm
Learn how kubeadm automates the complex PKI and static-pod setup required to stand up a production-grade control plane, then join worker nodes using bootstrap tokens.
etcd — Backup, Restore & Health
Understand etcd as the cluster's single source of truth, then master the snapshot backup and restore procedure that appears on every CKA exam.
Upgrading a Cluster with kubeadm
Execute a safe, one-minor-version-at-a-time cluster upgrade: control plane first, then workers — with zero application downtime.
PKI & Certificate Management
Understand the Kubernetes PKI hierarchy, inspect certificate expiry dates, renew certificates before they expire, and trace how kubeconfig files embed certificates for component authentication.
HA Control Plane — High Availability with kubeadm
Design and configure a highly available Kubernetes control plane using stacked or external etcd topology.
Troubleshooting Mastery
Master the systematic debugging workflow that accounts for ~30% of the CKA exam. Diagnose Pod failures, network breakdowns, node problems, and control plane issues with confidence.
Learning role: Practice Troubleshooting Mastery with retrieval, spacing, and transfer exercises.
Troubleshooting Pods
Diagnose and fix the five most common Pod failure modes: CrashLoopBackOff, OOMKilled, ImagePullBackOff, Pending, and Init container failures.
Troubleshooting Networking
Fix "connection refused", DNS lookup failures, and NetworkPolicy blocks using kubectl exec, port-forward, and endpoint inspection.
Troubleshooting Nodes
Diagnose NotReady nodes by reading kubelet logs, inspecting node conditions, and safely cordoning and draining problem nodes.
Troubleshooting the Control Plane
Diagnose kube-apiserver, kube-scheduler, kube-controller-manager, and etcd failures. Fix broken static pod manifests and verify control plane health.