The origins and development of Kubernetes

Kubernetes, an open-source container orchestration technology, simplifies containerized app and service deployment, administration, and scaling in modern IT infrastructure.

CNCF found that 71% of Fortune 100 companies use Kubernetes for container deployments. Linux is the most popular open-source OS. Explaining how Kubernetes defeated microservices and cloud computing requires context.

Evolution of Kubernetes

In 2013, Google engineers Craig McLuckie, Joe Beda, and Brendan Burns proposed an open-source container management system. Kubernetes, whose name comes from the Ancient Greek for “pilot or “helmsman” (the person at the helm who steers the ship), was born. These tech pioneers wanted to extend Google’s internal infrastructure expertise to large-scale cloud computing and help Google compete with Amazon Web Services (AWS), the cloud industry leader.

Traditional vs. virtual IT infrastructure

To understand the history of Kubernetes (also known as “Kube” or “K8s,” a “numeronym” (link exists outside ibm.com)), we must compare containers to traditional and virtual IT architecture.

Historically, companies operated their software on physical servers (bare metal servers). Keeping system resource boundaries for those apps was impossible. When a physical server ran numerous applications, one application may use all the processing power, memory, storage space, and other resources. Businesses would run each application on a separate physical server to avoid this. But running programs on several servers wastes resources and hinders scaling. Having many physical machines is pricey and takes up room.

Virtualization

Then came virtualization the cornerstone of cloud computing. Virtualization technology dates back to the late 1960s, although it wasn’t extensively utilized until the early 2000s.

Hypervisor software powers virtualization. Hypervisors are lightweight software that lets several virtual machines (VMs) run on a physical server’s CPU. A guest operating system (OS), a virtual duplicate of the OS’s hardware, and an application with its libraries and dependencies execute on each virtual machine.

While VMs use hardware resources more efficiently than real servers to execute software, they still need a lot. This is especially true when multiple VMs with their own guest operating systems share a physical server.

Containers

This is container technology. Chroot, part of Unix version 7, was developed in 1979, marking a milestone in container development. Chroot isolated processes by restricting file access to the root and its offspring.

Modern containers bundle application code with libraries and dependencies. This speeds up apps on desktops, private data centers, and public clouds.

Unlike VMs, containers virtualize the operating system (typically Linux or Windows). Containers are quicker, lighter, and more portable than VMs since they lack the guest OS.

Kubernetes precursor Borg

Google wanted to optimize its virtual server performance in the early 2000s to accommodate its increasing infrastructure and public cloud platform. This produced Borg, the first unified container management system. The 2003–2004 Borg system is named after a species of Star Trek aliens, the Borg, who are synthetic organisms that share a hive mind called “The Collective.”

The Borg name suits Google perfectly. Borg’s large-scale cluster management system runs containerized workloads across its data centers. Google built Gmail, Google Docs, Google Search, Google Maps, and YouTube using Borg, which ran alongside its search engine.

Borg let Google perform hundreds of thousands of jobs from many apps on many machines. This gave Google exceptional resource utilization, fault tolerance, and scalability for big workloads. Borg remains Google’s main internal container management system.

Google released Omega, its second-generation container management technology, in 2013. Omega expanded the Borg ecosystem with a flexible, scalable scheduling solution for big computer clusters. Docker, a prominent Kubernetes participant, debuted in 2013.

Docker introduces open-source containerization

In 2013, Platform-as-a-Service (PaaS) company dotCloud released Docker, an open-source platform enabling online software developers to build, deploy, and manage containerized applications.

Docker containers use Linux kernel features to partition programs for independent operation. Docker, Inc. (previously dotCloud, link lives outside ibm.com) provides productivity tools based on its open-source containerization platform, environment, and community.

Docker inspired Kubernetes’ founders by popularizing a lightweight container runtime and making it easy to build, distribute, and deploy applications. Googlers Craig McLuckie, Joe Beda, and Brendan Burns were excited by Docker’s ability to build and execute containers on individual machines.

Docker revolutionized cloud-native infrastructure, but its single-node architecture prevented automation. As programs were designed for thousands of containers, managing them across environments became onerous because each development had to be manually packaged. The Google team spotted a need and opportunity for a container orchestrator that could deploy and manage containers on numerous servers. Thus, Kubernetes, Google’s third-generation container management technology, was created.

Birth of Kubernetes

Kubernetes developers had worked on Borg and intended to create a simpler open-source container orchestrator with a user-friendly interface that included all they learned from Borg and Omega. The name Project Seven of Nine honors a former Borg drone from Star Trek: Voyager. Although the project name didn’t stick, the Kubernetes logo’s seven points honor it.

In a Kubernetes cluster, containers run across several machines and environments in running clusters. Nodes in each cluster fall into two categories:

• Worker nodes for containerized applications.
• Control plane nodes, cluster controllers.

The control plane orchestrates the Kubernetes cluster and includes the API server, control manager, cloud controller manager, and others. Docker-based worker nodes operate containers. One or more app containers exchange storage and networking information in pods, the smallest deployable units in a cluster.

Kubernetes goes public

Microsoft, RedHat, IBM, and Docker joined Kubernetes, an open-source version of Borg, in 2014. The software tool has basic container orchestration features:

• Application replication to deploy several instances
• Service discovery, load balancing
• Simple health checks and repairs
• Scheduling to assign tasks to many machines

At OSCON 2015, the Kubernetes founders announced Kubernetes 1.0, a more advanced version. Red Hat OpenShift developers joined Google soon after, bringing engineering and enterprise experience to the project.

Kubernetes and Cloud Native Computing Foundation history

The Linux Foundation’s Cloud Native Computing Foundation (CNCF) received Kubernetes 1.0 from Google in 2015. Docker, Google, Microsoft, IBM, and Red Hat founded CNCF. CNCF wants “to make cloud-native computing ubiquitous.”

Kubernetes was CNCF’s first hosted project in 2016 and its first graduation project in 2018. Kubernetes became one of the fastest-growing open-source projects in history with over 700 contributing firms. It outperformed Docker Swarm and Apache Mesos to become the container orchestration standard by 2017.

Cloud-native apps and Kubernetes

Software applications were tethered to hardware servers before cloud. Kubernetes and containers became the management standard for cloud vending enterprises in 2018, introducing cloud-native applications. Cloud-based software research and development began.

Kubernetes helps construct cloud-native microservices-based apps and containerizes existing apps, speeding up app development. Kubernetes automates and monitors many applications for effective management. The declarative, API-driven Kubernetes infrastructure lets cloud-native development teams work autonomously and efficiently.

Kubernetes’ influence continues

Kubernetes, a portable, adaptable, open-source platform for containerized workloads and microservices, continues to evolve.

Since Kubernetes joined the CNCF in 2016, contributors have increased 996% to 8,012. KubeCon + CloudNativeCon), the CNCF’s flagship global conference, draws thousands of engineers and users to learn about Kubernetes and other DevOps developments.

Kubernetes popularity is rising in cloud transformation and application modernization. The CTO’s Guide to Containers and Kubernetes from Gartner predicts that by 2027, over 90% of enterprises would operate containerized apps in production.

IBM/Kubernetes

In 2014, IBM was among the major corporations that adopted Kubernetes and container orchestration. To assist businesses in navigating their cloud journeys, IBM deploys cloud-based management solutions such as Kubernetes container orchestration.

IBM can help us use Kubernetes for cloud-native app development, large-scale app deployment, or microservice management.

Red Hat OpenShift on IBM Cloud lets developers containerize and deploy enterprise workloads in Kubernetes clusters quickly and securely.

IBM Cloud Code Engine, a fully managed serverless platform, runs container, application, and batch jobs on a container runtime.