Kubernetes learning roadmap
This track is organized so you can build confidence in the right order: start with container and cluster basics, move through workloads and networking, then learn security, packaging, operations, and managed Kubernetes on AWS and Google Cloud.
Phase 1: Containers, cluster basics, and architecture
- Start with Docker basics so Kubernetes manifests make sense in terms of images, containers, networking, and runtime behavior.
- Start with what Kubernetes solves and how the cluster is structured.
- Learn the control plane, worker nodes, the API server, scheduler, kubelet, kube-proxy, and etcd.
- Learn namespaces, node selection, taints and tolerations, and pod affinity so scheduling decisions feel concrete.
- Use the architecture diagram to connect concepts before moving into manifests.
Phase 2: Pods, deployments, and day-one workloads
- Learn what a pod is and how Kubernetes runs one or more containers together.
- Review readiness and liveness probes so you can model healthy application behavior.
- Study deployments, rollout behavior, and practical workload manifests before moving into more advanced controllers.
Phase 3: Services, ingress, and cluster networking
- Understand ClusterIP, NodePort, LoadBalancer, and headless services.
- Move into ingress and gateway-style routing once service discovery makes sense.
- Add network policy basics so service exposure and pod-to-pod communication are understood together.
- Compare application-facing traffic patterns and the YAML used to express them.
Phase 4: Configuration, secrets, and access control
- Learn ConfigMaps and Secrets so application configuration is separated from container images.
- Study RBAC basics, roles, and users to understand how Kubernetes controls access to cluster resources.
- Treat security and configuration as part of application design, not an afterthought.
Phase 5: Storage and stateful systems
- Learn when ephemeral storage is not enough.
- Use persistent volumes and claims to connect workloads to durable storage.
- Continue into StatefulSets for databases such as MySQL and MongoDB.
Phase 6: Packaging, templating, and reuse
- Learn Helm fundamentals and chart structure so you can package repeatable Kubernetes applications.
- Compare raw manifests with Helm-based templating for multi-environment deployments.
- Study Kustomize basics to understand overlays and environment-specific customization without rewriting YAML.
Phase 7: Operations, scaling, and best practices
- Study rolling updates, horizontal scaling, and cluster autoscaling.
- Review manifest examples that show how deployments evolve safely in production.
- Review operational and platform best practices for security, observability, rollout safety, and resource management.
- Treat the example YAML files as reference material you can adapt to your own cluster.
Phase 8: Managed Kubernetes platforms
- Finish with AWS EKS so the core Kubernetes concepts map cleanly to a managed control plane.
- Add Google Kubernetes Engine so you see how cluster provisioning and operations vary across cloud providers.
- Use the recipes and troubleshooting examples as a bridge from theory to platform-specific practice.
How to use this track
- Read section overview lessons before opening raw YAML manifests.
- Use manifest lessons as working examples, not just reading material.
- Add future topics by dropping new markdown or YAML files into the relevant section folder and updating this roadmap so the learning order stays intentional.