Welcome to click the button below 👇 to follow me, and remember to star it~

There will be huge benefits at the end of the article

Recently, I spent some time organizing my Kubernetes learning process.Through several stages of learning, we can gradually deepen our understanding from the basics of Kubernetes to source code analysis and open source contributions, ultimately gaining the ability to independently solve complex problems in production environments.

In the new year, let’s learn together!!

Stage One: Basic Introduction

Learning Objectives:

1. Master the basic concepts, architecture, and core component operating mechanisms of Kubernetes.
2. Be able to set up and maintain a simple K8S cluster.
3. Complete the CKA certification (Certified Kubernetes Administrator).

Learning Plan

1. Theory Part

• Read the official Kubernetes documentation (focus on core resource objects such as Node, Pod, Deployment, Service, etc.).
• Learn from the Geek Time course “In-Depth Analysis of Kubernetes” (focus on container orchestration, job management, networking, and storage chapters).
• Prepare for the CKA Certification exam, reinforcing foundational knowledge.
• Read “Kubernetes Chinese Guide: Cloud Native Application Architecture Practice Handbook”.

Practice Part

• Build your own Kubernetes cluster (recommended using kubeadm or Minikube).
• Follow the practical sections of “In-Depth Analysis of Kubernetes” and operate the content of each chapter.
• Practice command operations through the CKA certification simulation exam platform.

Knowledge Summary

• Organize the Kubernetes knowledge map (reference K8S Learning Knowledge Map).
• Read the K8S series articles from the public account “Cloud Native SRE” to supplement theoretical knowledge.

Time Planning

Learning Content	Time Period
Theoretical Learning: K8S Basic Concepts, Networking, Storage Chapters	1 week
Practice: Set up K8S cluster, complete CKA certification course exercises	2 weeks
Practical Project: Build a simple K8S cluster and deploy applications	1 week

Stage Two: Advanced + Practical Work Projects

Learning Objectives:

1. Deeply understand the advanced features of Kubernetes (resource scheduling, scaling, security, etc.).
2. Master Kubernetes’ continuous integration and deployment capabilities (Helm, ArgoCD).
3. Master troubleshooting and performance tuning methods for Kubernetes clusters.
4. Be able to use Kubernetes in actual work projects to complete complex scenario deployments and management.

Learning Plan

1. Theory Part

• Resource Management and Scheduling
  
  : Resource quotas, priority and preemption, HPA/VPA.
• Networking and Storage Advanced
  
  : CNI plugins (such as Flannel, Calico, Cilium)
• Security
  
  : RBAC permission management, Pod security policies.
• Container Runtime
  
  : Understand CRI, POD lifecycle, etc.

• Continuous Integration and Deployment Related
• Logging and Monitoring Related
• Service Mesh Related (Istio)
• Learn other advanced features of Kubernetes (see notion link for specifics)
• Read “Kubernetes in Action” to learn more advanced knowledge.

Practice Part

• Simulate common fault scenarios and troubleshoot:

• Control plane issues (e.g. API Server, etcd exceptions).
• Node issues (e.g. kubelet exceptions, Node NotReady).
• Network issues (e.g. Pod communication failure).
• Storage issues (e.g. PVC binding failure).

• Deploy Prometheus + Thanos, create custom monitoring metrics.
• Integrate Fluentd or Loki to collect and analyze logs.

• Use Helm and Kustomize to deploy applications.
• Use ArgoCD or FluxCD to implement GitOps processes.
• Deploy Istio or Linkerd, configure traffic governance (such as circuit breaking, rate limiting, gray release).

Practical Projects

• Develop a simple Kubernetes Operator (e.g. automate application deployment).
• Build a complete monitoring system (Prometheus + Thanos + Grafana).
• Deploy a simple microservices architecture project (including Service Mesh, such as Istio).

Time Planning

Learning Content	Time Period
Theoretical Learning: Resource Management, Scheduling, Security
Practice: Continuous Integration and Deployment, Logging and Monitoring
Practice: Cluster Troubleshooting and Performance Tuning
Practical Project: Develop Operator, Build Monitoring System

Stage Three: In-Depth Kubernetes and Related Development

Learning Objectives:

1. Deeply understand the source code and extension mechanisms of core Kubernetes modules.
2. Master the design and implementation capabilities of complex cloud-native projects.
3. Participate in contributions to the Kubernetes and related open source communities, enhancing technical depth and influence.
4. Independently solve complex problems in production environments.

Learning Plan

1. Theory Part

• CRD (Custom Resource Definition) and Controller.
• Admission Webhooks.
• Operator pattern and its implementation principles.

• Scheduler (kube-scheduler)
  
  : Task scheduling algorithms, priority and preemption mechanisms.
• Controller (kube-controller-manager)
  
  : Implementation of resource control loops.
• API Server
  
  : Design and implementation of Kubernetes API.
• etcd
  
  : Core principles of distributed storage and consistency algorithms (Raft).

• Read the source code of core Kubernetes modules:
• Learn about Kubernetes’ extension mechanisms:
• Follow other open source projects (like Prometheus, Thanos) to understand their architectural design.

Practice Part

• Design and implement a multi-cluster deployment solution.
• Simulate production environment issues, practice troubleshooting and performance tuning.

• Submit PRs for Kubernetes or related projects (like Prometheus, Thanos).
• Participate in community SIG (Special Interest Group) groups to understand community development processes.

• Open Source Community Contributions
• Complex Cloud-Native Projects

Recommended Reading

• “Kubernetes Source Code Analysis”: Deeply understand core modules.
• “Programming Kubernetes”: Learn about Kubernetes API and extension mechanisms.

Time Planning

Learning Content	Time Period
Theoretical Learning: Source Code Reading and Extension Mechanisms
Practice: Open Source Community Contributions and Complex Project Development
Reading and Summarizing: Technical Article Output

Stage Four: Job Interviews and Summary

Learning Objectives:

1. Sort out the core knowledge points of Kubernetes and prepare for technical interviews.
2. Summarize learning outcomes and form a systematic knowledge system.

Learning Plan

1. Knowledge Point Sorting

• Reference the Kubernetes Knowledge Map.
• Organize core modules, extension mechanisms, troubleshooting, and other knowledge points of Kubernetes.

Interview Question Summary

• Kubernetes core components (API Server, Scheduler, Controller Manager).
• Scheduling and Resource Management.
• Networking and Storage.
• Troubleshooting and Performance Tuning.
• Kubernetes Extension Mechanisms (CRD, Operator).

• Collect and organize Kubernetes interview questions for promotions and salary increases.

Summary and Sharing

• Output blogs or technical articles to summarize learning experiences.
• Share learning outcomes in technical communities or open source conferences.

Time Planning

Learning Content	Time Period
Knowledge Point Sorting and Interview Question Summary
Technical Article Output and Sharing

For specific learning steps, I created a Kubernetes learning path template on Notion that includes a detailed learning plan, learning materials, and resource recommendations, which can help friends systematically start Kubernetes. If anyone needs it, feel free to message me to get it!

Join the knowledge circle to explore the cloud-native learning journey together!

For more cloud architecture, K8S learning materials, and SRE learning manuals, join the circle for free to receive them!

Friends who are interested can add me on WeChat:sre_k8s, note:Cloud Native Communication