What is Kubernetes?
Kubernetes is an open source platform for deploying, scaling, and managing containerized applications. It automates much of the operational work involved in running modern software, allowing teams to focus on building and improving applications instead of manually managing infrastructure.
Modern applications are rarely a single program running on a single server; instead, they are composed of many, small, specialized components packaged as containers and deployed across fleets of machines. These components must be started in the right order, connected to one another, kept running when failures occur, and scaled as demand changes. This is where Kubernetes comes in. It provides a unified system that can:
Run containerized workloads using shared compute, storage, and networking resources
Continuously monitor applications and maintain them in a desired state
Adapt automatically to failures, traffic spikes, and infrastructure changes
How Does Kubernetes Work?
At a high level, Kubernetes works by separating what you want your application to look like from the mechanics of making it happen. You describe the desired state of your application, and Kubernetes continuously works to ensure reality matches that description.
Defining the Desired State
Developers and operators describe an application using declarative configuration files, typically written in YAML. These files specify things like:
Which container images should run
How many copies of each component are needed
What resources each component requires (CPU, memory, GPUs, storage)
How components should communicate with each other and external users
Rather than issuing step-by-step instructions, you describe the end result you want.
Applying the Configuration
Once the configuration is submitted to Kubernetes, the platform evaluates it alongside everything else already running in the cluster. Kubernetes determines where each container should run, based on available resources and constraints. It then:
Pulls container images from a registry
Starts containers on appropriate nodes
Connected containers to networking and storage resources
Exposes services so components can communicate reliably
Maintaining the Desired State
Kubernetes continuously monitors the system and responds when reality diverges from the desired state. For example:
If a container crashes, Kubernetes restarts it
If a node fails, Kubernetes reschedules workloads elsewhere
If traffic increases, Kubernetes can scale applications automatically
If demand drops, Kubernetes can scale applications back down to conserve resources
This ongoing reconciliation loop is what allows Kubernetes to manage applications reliably at scale.
Why Do We Use Kubernetes?
One of the benefits of Kubernetes is that it makes building and running complex applications much simpler. Here’s a handful of the many Kubernetes features:
Standard services like local DNS and basic load-balancing that most applications need, and are easy to use.
Standard behaviors (e.g., restart this container if it dies) that are easy to invoke, and do most of the work of keeping applications running, available, and performant.
A standard set of abstract “objects” (called things like “pods,” “replicasets,” and “deployments”) that wrap around containers and make it easy to build configurations around collections of containers.
A standard API that applications can call to easily enable more sophisticated behaviors, making it much easier to create applications that manage other applications.
The simple answer to “what is Kubernetes used for” is that it saves developers and operators a great deal of time and effort, and lets them focus on building features for their applications, instead of figuring out and implementing ways to keep their applications running well, at scale.
By keeping applications running despite challenges (e.g., failed servers, crashed containers, traffic spikes, etc.) Kubernetes also reduces business impacts, reduces the need for fire drills to bring broken applications back online, and protects against other liabilities, like the costs of failing to comply with Service Level Agreements (SLAs).
Where Can I Run Kubernetes?
Kubernetes can run almost anywhere. It supports a wide range of Linux operating systems, and worker nodes can also run on Windows Server. With the right architecture and tooling, Kubernetes can provide a consistent application platform across:
Bare-metal servers
Virtual machines
Private data centers
Public cloud environments
Developer laptops and desktops
Edge locations and resource-constrained systems
This consistency allows teams to develop and test applications locally, then move them through staging and into production with minimal changes. As a result, Kubernetes is a key enabler of hybrid and multi-cloud strategies, helping organizations scale capacity without being locked into a single infrastructure provider.
What is a Kubernetes Cluster?
A Kubernetes cluster is the set of machines and software that run Kubernetes and the applications it manages. It consists of two main parts: the control plane and the worker nodes.
The Control Plane
The control plane is responsible for managing the cluster as a whole. It exposes the Kubernetes API, stores configuration and state, and makes decisions about scheduling and lifecycle management. Core control plane components include:
API server: serves as the front end for all cluster interactions
Scheduler: decides where new workloads should run
Controller Managers: enforce desired state through control loops
etcd: a distributed key-value store that holds cluster configuration and state
Users and automation tools interact with the cluster exclusively through the Kubernetes API, typically using command-line tools such as kubectl or higher-level platforms.
Worker Nodes
Worker nodes are the machines that actually run application workloads. Each node runs:
A container runtime, which executes containers
The kubelet, which communicates with the control plane and manages containers on the node
Networking components, which enable service discovery and traffic routing
Applications run inside Pods, Kubernetes’ smallest deployable unit, which can contain one or more tightly coupled containers.
What is “Enterprise Kubernetes?”
Kubernetes provides a powerful core framework for running containerized applications, but on its own, it is not a complete production platform. Upstream Kubernetes focuses on orchestration and extensibility, deliberately leaving many critical capabilities to be provided through integrations and add-ons. To run real-world applications at scale, Kubernetes must be combined with additional components, including:
A container runtime to execute workloads
Networking solutions to enable secure, reliable communication between services
Persistent storage systems for stateful applications
Ingress and traffic management to control how external users access applications
Load balancing, security, observability, and policy enforcement
Kubernetes is designed to integrate with these capabilities through well-defined interfaces — but someone still has to choose, integrate, validate, and maintain them. Free and community Kubernetes distributions often assemble these components from open source projects.
These solutions are excellent for learning, development, and small-scale environments, and they play a vital role in the Kubernetes ecosystem.
However, running Kubernetes in production, especially across multiple environments, introduces additional requirements that go beyond basic functionality. Organizations typically need Kubernetes that is:
Hardened and secure by default
Validated as a complete, interoperable stack
Integrated with enterprise systems such as identity management, monitoring, logging, and incident response
Easy to deploy, upgrade, and operate consistently over time
Supported by a vendor that can take responsibility for the full platform
“Enterprise Kubernetes” refers to Kubernetes platforms and product suites that address these operational and organizational needs. The goal of enterprise Kubernetes is not just to run containers, but to make Kubernetes a reliable, repeatable foundation for business-critical applications.
Start Using Kubernetes With Mirantis
Kubernetes provides a powerful foundation for running modern applications, but operating Kubernetes reliably in production can quickly become complicated. k0s is a lightweight, fully conformant Kubernetes distribution designed to simplify cluster operations without compromising enterprise requirements. It delivers upstream Kubernetes with less operational complexity, making it easier for platform teams to deploy, manage, and scale clusters across cloud, data center, and edge environments.
Key capabilities include:
Single-Binary Kubernetes Distribution: Core Kubernetes control plane components are packaged into a single binary, reducing installation complexity, configuration sprawl, and operational overhead
Flexible Deployment Across Environments: Supports a wide range of deployment models, from centralized data centers and public cloud to edge and resource-constrained environments
Fully Conformant Upstream Kubernetes: Delivers certified Kubernetes without vendor lock-in, ensuring full compatibility with standard tools, APIs, and workloads.
Designed for Operational Simplicity: Fewer moving parts and opinionated defaults make clusters easier to deploy, upgrade, and maintain over time.
If you’re looking to reduce Kubernetes operational complexity while maintaining control and flexibility, k0s provides a clean, production-ready foundation for running Kubernetes at scale.
Start exploring k0s today!
