Epilogue Is it an End or a New Beginning #

Hello, I am Chrono.

After nearly three months of hard work, our Kubernetes learning journey has reached its “end” today.

Three months may seem long or short, but as they say, “every encounter is a once-in-a-lifetime opportunity.” I truly cherish the time we have spent together and I am grateful for your support and enthusiastic comments on this column. It is thanks to our mutual help and encouragement that this period of time has become more meaningful and exciting.

As we part ways, let me share a bit about my own learning experiences and suggestions. Consider it a simple “retrospective.”

My Kubernetes Learning Experience #

In the “Preface” section, I mentioned my learning process of Kubernetes. However, as a “lesson learned,” I think it’s necessary to review it again. I believe many students would be interested in how I learned Kubernetes, and this experience also has some reference value.

First of all, I come from a development background with expertise in C/C++/Nginx. Therefore, during the learning process, I naturally select knowledge points from this perspective, focusing on application development and deployment, while paying less attention to system installation, operation, and management.

Here, let me give you a reminder: when learning Kubernetes, it’s best to combine it with your own situation and set a “small goal”. For example, “I want to learn how to develop cloud-native applications in Kubernetes,” “I want to manage the monitoring system for Kubernetes,” “I want to build a highly available Kubernetes production system,” and so on. In my case, my initial goal was to “understand the usage of Nginx Ingress Controller.”

With such clear goals, you would have direction and focus on studying Kubernetes, facilitating checking your learning progress and making it easier to concentrate. Otherwise, learning aimlessly can easily make you lost in the sea of Kubernetes knowledge (Image source). It is also challenging to build a complete knowledge system.

Like most people, I encountered many difficulties when I first started learning Kubernetes. The main reason was that Kubernetes is a completely new system, and I had to deal with a bunch of “mysterious” concepts right from the start (Pod, ConfigMap, Deployment, etc.). I had no previous experience to rely on, so I had to start from scratch.

For beginners who want to overcome this “mountain,” it is necessary to put in a lot of effort. In my opinion, there is no shortcut in this process. It requires repeated reading, thinking, and experimentation to deepen the understanding. Once you get through this “dangerous period,” understand the underlying knowledge, and lay a solid foundation, the subsequent learning becomes easier.

Speaking of experimentation, I believe it is also a crucial means of learning Kubernetes. After all, Kubernetes is an “operating system.” Merely reading text materials and discussing theories will not give you a clear understanding of how it works and operates without real hands-on practice.

Initially, I used minikube, which was simple, convenient, and provided comprehensive functionality, making it suitable for beginners to quickly get started with Kubernetes.

However, because minikube is based on Docker virtualization, there are still some differences from the real environment in terms of nodes and networking. Therefore, I recommend that once you have a deeper understanding of Kubernetes, you should switch to kubeadm. This way, you can study and research Kubernetes in a more thorough manner.

During the learning process, I also have two “best practices.” One is taking notes diligently, and the other is creating mind maps.

As the saying goes, “A short pencil is better than a long memory.” With so much information to absorb, it is impossible for our brains to remember everything. Therefore, it is important to write down our thoughts and experiences while reading.

However, you don’t have to demand that your notes are complete and detailed. Even short sentences or simple links are valuable. When the number of notes accumulates, you can spend some time summarizing and condensing them. This is when mind maps come into play.

I believe you are familiar with mind maps. Its tree-like and divergent structure perfectly matches our natural thinking pattern. You can write down whatever comes to mind without any mental burden. Moreover, we can add various small marks to items, reference items to each other, and use visual effects to enhance learning.

By combining fragmented notes with structured mind maps, we can organize our thoughts more smoothly, summarize experiences, and gradually grasp a systematic and comprehensive knowledge.

As an example, I created a mind map for what I just talked about. You see, with graphics and visualization, isn’t it easier to absorb knowledge points?

How to Continue Learning Kubernetes in the Future #

Although the course is about to end, the world of Kubernetes has just begun to unfold before you, beyond the “finish line.” This world is vast and magnificent, and our Kubernetes course has taken only “the first step on a long journey.” Your future path will depend on your own grasp.

Next, let me talk about four possible directions. You can consider them as “strategy guides” for learning Kubernetes to help you find your own path.

The first direction is to read the documentation on the Kubernetes official website.

The Kubernetes official website (https://kubernetes.io/docs/home/) provides very rich and detailed information, including getting started, installation guides, basic concepts, application tutorials, operations tasks, reference manuals, and more.

Of course, the official documentation is not completely aimed at beginners. Unlike our course, it is not “progressive” and may not be easy to understand without a certain foundation. However, its advantage lies in its comprehensiveness and authority. It covers every feature of Kubernetes, and you can find answers to any doubts or questions you have about Kubernetes in these documents.

However, the abundance and complexity of the official documentation also pose challenges to our learning. It can be cumbersome to search for knowledge points in a systematic manner. This is where the search function comes in handy, allowing us to quickly locate articles and pages with keywords, saving us time and effort.

The second learning direction is to read the Kubernetes blog.

The documentation on the official website describes the current state of Kubernetes, but not its history. To understand how the API objects in Kubernetes are designed and how they have developed to their present state, you need to read its technical blog articles.

Here, I recommend that you read the English blog (https://kubernetes.io/blog/). Although there is also a Chinese blog on the official website, it is incomplete and relatively limited. Starting from 2015, the English blog has articles introducing almost every important feature change. Additionally, the blog focuses more on ordinary users, explaining the thought process behind technical decisions, making it easier to understand.

If conditions allow, I suggest starting from the first blog article in 2015 and briefly going through each one. By reading all these blog articles and “learning from history,” you will gain an understanding of the evolution of Kubernetes and a deeper insight into its current state.

The third direction is to visit the CNCF website (https://www.cncf.io/) and explore its landscape. Find projects that interest you, deploy applications on a Kubernetes environment, and learn Kubernetes through practice.

There are many projects in CNCF’s landscape. The projects hosted by CNCF can be classified as graduated projects, incubating projects, and sandbox projects.

In fact, these projects are of relatively high quality once they enter CNCF, with differences mainly in their maturity. Graduated projects are the most mature and widely recognized and can be used in production environments. Incubating projects are not as widely used, with fewer contributors and only a few production practices. Sandbox projects are experimental and have not undergone sufficient testing and validation.

Here, we can briefly introduce some graduated and incubating projects. You can choose to further research ones that interest you after class.

This image shows all 16 graduated projects in CNCF:

Among them, we have already comprehensively studied Kubernetes, briefly introduced containerd and Prometheus, and I am personally interested in Harbor, Helm, and Vitess.

CNCF currently has 39 incubating projects. Compared to graduated projects, they are slightly less well-known. The screenshot below shows some of them, and I am particularly interested in gRPC, SPIRE, NATS, and OpenTelemetry:

The fourth learning direction is to attend Kubernetes training and obtain certification (https://kubernetes.io/training/).

Like many other computer technologies, Kubernetes also has official training courses and qualifications. The one that is well-known in China is the CKA (Certified Kubernetes Administrator), and there is also a more advanced certification called CKS (Certified Kubernetes Security Specialist).

CKA mainly tests your understanding of Kubernetes concepts and your ability to manage and maintain clusters. The focus is on hands-on operations, solving various practical problems using kubectl. Although it is not too difficult, the exam covers a wide range of topics, and the exam duration is 2 hours (it used to be 3 hours), posing a significant challenge to both mental and physical stamina.

As Kubernetes has become dominant in the cloud-native field, CKA certification has gained popularity in recent years. There are many exam materials available, which you can easily find on various websites. After completing our course, you can reinforce your training appropriately and obtaining the CKA certification should not be too difficult.

However, it is worth noting that CKA has a validity period due to the frequent updates in Kubernetes. After three years (previously two years), you will need to reattempt the certification. You should carefully evaluate the benefits of the exam before making a decision.

Farewell Remarks #

After discussing my learning experience and summarizing four study directions for further exploration, I would like to share some of my thoughts with you as we approach the end of our three-month journey.

Although this is already my third column on Geek Time, the challenge remains significant. From the research I conducted in the cold winter to the completion of this column in the scorching summer, it has been a continuous effort for nearly half a year, with a considerable amount of my spare time devoted to it. However, I believe it has been worthwhile.

Compared to the previous two columns, which covered the HTTP protocol and C++ language, my experience with Kubernetes is relatively short. Therefore, my knowledge and expertise in this area are not as profound. Writing articles is no longer as effortless as before. I have to repeatedly consult documentation and conduct experiments to ensure accuracy. The whole process has had its ups and downs. Now that the course is over, looking back, it serves as both a reflection on my own Kubernetes abilities and a summary of what I have gained.

However, due to the depth and breadth of Kubernetes knowledge, even though I have tried my best to explain everything clearly, each lesson in the course is only about 15 minutes long, significantly longer than the 10-minute lessons in the previous two columns. This has increased the workload considerably, but I still feel that only a small portion of the knowledge has been fully covered. Other useful and relevant content can only be briefly mentioned, which is somewhat regrettable.

In the future, if there is an opportunity, I would like to periodically add some “extra content” just like I did with the previous two columns. This way, I can share my latest understanding and insights on Kubernetes, allowing us to continue learning and progressing together.

Additionally, I have noticed that some students have repeatedly mentioned “production systems” in their comments. This requirement might be too high for me, as I am not directly involved in system operations. Setting up a Kubernetes environment is only for the convenience of my own development and testing. When it comes to deploying applications to production, I would seek the assistance of dedicated operations colleagues. Real-world production environments are much more complex than virtual machine environments, and I simply don’t have the time or ability to fully understand all of it. For that, I apologize.

I wonder if you have been silently learning all this time. On this day when the column is coming to an end, I really hope to see your presence in the comments section, to hear about your thoughts and gains from studying this column. If you have any feedback or suggestions for the course, please feel free to fill out this questionnaire.

With that being said, let us bid farewell and say “goodbye” here.

I wish you consider this as the starting point of a new journey, full of confidence and hope, marching confidently towards the Kubernetes new world full of endless possibilities, and forging your own path to success!