Often described as the “operating system for the cloud,” Kubernetes is an open source platform for managing clusters of containerized applications and services. Developed by Google engineers Joe Beda, Brendan Burns, and Craig McLuckie in 2014 and open sourced shortly thereafter, Kubernetes soon became a thriving, cloud native ecosystem in its own right. Today, Kubernetes—which means “helmsman” or “pilot” in ancient Greek—is managed by the Cloud Native Computing Foundation (CNCF), an arm of the Linux Foundation.
Kubernetes was the first graduated project for the CNCF, and it became one of the fastest growing open source projects in history. Kubernetes now has more than 2,300 contributors, and has been widely adopted by companies large and small, including half of the Fortune 100.
To begin with, here are a few key terms related to Kubernetes. There is a more exhaustive list available on the Kubernetes Standardized Glossary page. You can also leverage the Kubernetes Cheat Sheet, which contains a list of commonly used kubectl commands and flags.
Is a set of machines individually referred to as nodes used to run containerized applications managed by Kubernetes.
Is either a virtual or physical machine. A cluster consists of a master node and a number of worker nodes.
Is an image that contains software and its dependencies.
Is a single container or a set of containers running on your Kubernetes cluster.
Is an object that manages replicated applications represented by pods. Pods are deployed onto the nodes of a cluster.
Ensures that a specified number of pod replicas are running at one time.
Describes how to access applications represented by a set of pods. Services typically describe ports and load balancers, and can be used to control internal and external access to a cluster.
KubeCon is the annual conference for Kubernetes developers and users. Since the first KubeCon in 2015 with 500 attendees, KubeCon has grown to become an important event for the cloud native community. In 2019, the San Diego, California edition of KubeCon drew 12,000 developers and site reliability engineers who were celebrating the open source ecosystem blossoming around the Kubernetes cloud orchestration platform.
As developers increasingly deploy software for a diverse set of computing environments with different clouds, test environments, laptops, devices, operating systems, and platforms, the issue of making the software run reliably is of paramount importance. That’s where containers come in: They bundle an application with its entire runtime environment. In this sense, containers are a form of virtualization because they provide a “bubble” in which the application can run by including the correct libraries, dependencies, and operating systems. But containers are smaller than virtual machines because they contain only the resources the application needs, and nothing more.
While Linux containers have existed since 2008, it took the emergence of Docker containers in 2013 to make them famous. Similarly, the explosion of interest in deploying containerized applications—applications that contained everything they needed to run—ultimately created a new problem: managing thousands of containers. Kubernetes automatically orchestrates the container lifecycle, distributing the containers across the hosting infrastructure. Kubernetes scales resources up or down, depending on demand. It provisions, schedules, deletes, and monitors the health of the containers.
The key components of Kubernetes are clusters, nodes, and the control plane. Clusters contain nodes. Each node comprises a set of at least one worker machine. The nodes host pods that contain elements of the deployed application. The control plane manages nodes and pods in the cluster, often across many computers, for high availability.
The control plane contains the following:
The node components include:
With containers, you can be confident that your applications are bundled with everything they need to run. But as you add containers—which often contain microservices—you can automatically manage and distribute them using Kubernetes.
With Kubernetes, organizations can:
|Scale automatically||Dial deployments up or down, depending on demand.|
|Discover services||Find containerized services via the DNS or IP address.|
|Balance loads||Stabilize deployment by distributing network traffic.|
|Manage storage||Choose local or cloud storage.|
|Control versions||Choose the kinds of containers you want to run, and which ones to replace using a new image or container resources.|
|Maintain security||Securely update passwords, OAuth tokens, and SSH keys related to specific container images.|
While Kubernetes is highly composable and can support any type of application, it can be difficult to understand and use. Kubernetes is not always the correct solution for a given workload, as a number of CNCF members have commented on. Which is why the Kubernetes ecosystem contains a number of related cloud native tools that organizations have created to solve specific workload issues.
Kubernetes deploys containers, not source code, and does not build applications. For logging, middleware, monitoring, configuration, CI/CD, and many other production activities, you’ll need additional tools. That said, Kubernetes is extensible, and has proven to be adept for a wide variety of use cases from jet planes to machine learning. In fact, cloud vendors including Oracle, Google, Amazon Web Services, and others have used Kubernetes’ own extensibility to build managed Kubernetes, which are services that reduce complexity and increase developer productivity.
Our Cloud Infrastructure Container Engine for Kubernetes is a developer-friendly, managed service that you can use to deploy your containerized applications to the cloud. Use Container Engine for Kubernetes when your development team wants to reliably build, deploy, and manage cloud native applications. You specify the compute resources that your applications require, and Container Engine for Kubernetes provisions them within an existing Cloud Infrastructure tenancy.
While you don’t need to use a managed Kubernetes service, our Cloud Infrastructure Container Engine for Kubernetes is an easy way to run highly available clusters with the control, security, and predictable performance of Oracle Cloud Infrastructure. Container Engine for Kubernetes supports both bare metal and virtual machines as nodes, and is certified as conformant by the CNCF. You also get all Kubernetes updates and stay compatible with the CNCF ecosystem without any extra work on your part.
Oracle is a Platinum member of the Cloud Native Computing Foundation (CNCF), an open source community that supports several dozen software development projects organized by maturity level. The graduated projects (Kubernetes, Prometheus, Envoy, CoreDNS, containerd, Fluentd, Jaeger, Vitess, TUF, and Helm) have all proven invaluable for aspects of cloud native development.
Kubernetes has a large ecosystem of supporting projects that have sprung up around it. The landscape can be daunting, and looking for answers to simple questions can lead you down a rabbit hole. But the first few steps down this path are simple, and from there you can explore advanced concepts as your needs dictate. Learn how to:
Developers who are eager to start their first Kubernetes project can check out our developer portal where they can learn how to build their first Arm app on Kubernetes or deploy a Kubernetes cluster using cloud shell.