Today is a special day: Kubernetes graduates from CNCF incubation, an important milestone in its maturity, and an even bigger milestone for all the organizations that have come to rely on it as a cornerstone of their IT operations.
Graduation is also an opportunity for us at Google to look back at the work accomplished over the years and say thank you and congratulations to a class that has accomplished so much. In this case, we would like to congratulate the Kubernetes project community that has worked with us sometimes as students, frequently as peers, and often as teachers. Kubernetes would not be where it is today without the attention and devotion so many have given it across the industry.
Congratulations are also due to the Cloud Native Computing Foundation (CNCF), which incubated our project and gave the community an independent home in which to grow and learn.
Forgive us as we walk down memory lane for a moment—Google released Kubernetes as open source code in June 2014 and it was an immediate success.
Actually, that’s not how it worked—not at all. We started with a Google technical team that had deep experience running globally-scalable applications on distributed systems. And a year and a half in, we were running into challenges of every sort. We were at risk of becoming a very successful disaster, wrestling with growing interest and contributions to an increasingly complex system. There were so many changes in every release that changes in one area would break another area, making it harder to get a release out the door on time.
Today, there are few open source projects the size of Kubernetes and almost none with Kubernetes’ level of sustained activity. There was only so much prior experience to rely on. To reach this day, it took a cross-industry group of technologists, program managers, product managers, documentation writers and advocates that were open to experimenting and maturing as a community. We’d like to share some of the best practices that helped us get through and overcome those growing pains, and get where we are today.
#1 Focus on the user
A successful project is a combination of great technology, product market fit and innovation that solves real problems. But ensuring adoption in the early stages of an unknown open source project is hard. To support adoption we set up a user rotation early on, and assigned Google engineers to answer user project questions on IRC, StackOverflow and Slack channels. The rotation grew user adoption directly and provided valuable feedback to engineers.
#2 Build a community
Collaborating with engineers from companies like RedHat and CoreOS was critical for shaping Kubernetes to meet the needs of a wide variety of users. Additionally, it was important for the community to welcome independent, individual contributors as much as experienced contributors from big companies. Diverse voices sharing different use cases, unusual perspectives and offering a counterpoint in discussions was the only path to a project that would scale up to the needs of large enterprises and scale down to be digestible by students and hobbyists.
#3 Invest in sustainability
To scale the project in a healthy, sustainable way, Google Cloud funded large investments in test infrastructure, change-review automation, issue-management automation, documentation, project management, contributor experience, mentorship programs and project governance. We also worked closely with the CNCF to develop devstats, a tool for visualizing GitHub organization and repository statistics so that we can regularly review the project’s health.
#4 Enable an ecosystem
It was clear we had the ingredients for a technological revolution on our hands, but turning that into a ubiquitous platform required additional elements. It needed a clear vision of the future that understood user needs and recognized that not every use case was the same. It needed hooks for an ecosystem of contributors to build from, broader capabilities to handle new types of applications and standards to ensure consistent user experience and streamline adoption. It needed advocates and champions from across the industry.
Kubernetes is a successful platform in part due to early decisions by maintainers to ensure a modular architecture with well-defined interfaces. As a result, Kubernetes runs everywhere, from all major cloud platforms to card-sized ARM-based devices, and supports meaningful choices from the ecosystem, including container runtimes, network plugins, ingress controllers and monitoring systems, to name a few. In order to give users an efficient platform for more diverse workloads, we invested in support for stateful workloads, storage plugins, and hardware accelerators. Additionally, Kubernetes extension mechanisms such as API aggregation and Custom Resource Definitions unlock innovation in the ecosystem by enabling developers to take Kubernetes in new directions.
Last but not least, to ensure Kubernetes avoids the risk of fragmentation, Google worked with the CNCF and the Kubernetes community to initiate the Certified Kubernetes Conformance Program that aims to cement the portability and ubiquity of this platform.
Even with years of experience developing Borg and the collective effort of hundreds of Googlers, we couldn’t have done this alone. For all the help making Kubernetes what it is today, we must thank our many contributors, collaborators, leaders, users, advocates, dissenters and challengers—those who helped us turn open-source code into an open source project and an industry ecosystem.
Like a school graduation, this isn’t an end unto itself, but just the beginning. We look forward to the future where Kubernetes is even more critical thanks to all of you who have helped get it this far, and all of you who will help continue to mature it in the future.
For more information on the Kubernetes graduation, take a look at the CNCF announcement.