DEVELOPMENT TECHNOLOGIES

What Is Kubernetes Used For? Architecture and Kubernetes vs Docker Swarm

How Kubernetes orchestrates containers across clusters, what teams use it for, and how it compares with Docker Swarm, Docker Compose, and HashiCorp Nomad.
Kubernetes logo

What Is Kubernetes?

Kubernetes (K8s) is an open-source platform for managing containerized workloads and services through declarative configuration and automation across multi-node clusters. Its main job is orchestrating container deployment, scaling, networking, and self-healing without manual work on each server.

Google open-sourced Kubernetes in 2014, based on its internal Borg system, and the Cloud Native Computing Foundation (CNCF) now hosts the project. It is free software under the Apache License 2.0. Instead of running a fixed workflow, its independent control processes continuously drive the cluster’s current state toward the state you declare. Architecture and API references are in the official Kubernetes documentation.

Kubernetes is not a traditional all-inclusive Platform as a Service. It does not build applications, deploy source code, or include databases or message buses. It provides the orchestration layer on which those services run.

The project ships a new minor version roughly three times a year and maintains the three most recent ones, so each gets about 14 months of patches. Version 1.37, released in August 2026, made KYAML and Pod Certificates for native mTLS identity stable and added beta support for scaling workloads down to zero.

How Kubernetes Works

A Kubernetes cluster has a control plane that stores state and makes scheduling decisions, and worker nodes that run containerized applications inside Pods. Together these processes watch cluster health and reconcile running containers against your declarative manifests. The main components are listed in the table below.

Pods are the smallest deployable units. Each Pod holds one or more tightly coupled containers that share network and storage. The control plane schedules and monitors Pods across worker nodes rather than managing individual containers.

You rarely create Pods directly. Controllers such as Deployments, StatefulSets, and Jobs create and replace them, roll out new versions, and roll back failed ones. Services give a stable address and load balancing for a changing set of Pods, while ConfigMaps and Secrets hold configuration and credentials.

Kubernetes scales to thousands of machines within documented limits, summarized in the FAQ below.

ComponentLayerRole
kube-apiserverControl planeExposes the Kubernetes API and is the front end of the control plane.
etcdControl planeStores all cluster state and configuration, including Secrets.
kube-schedulerControl planeAssigns new Pods to nodes based on resources and constraints.
kube-controller-managerControl planeRuns the controllers that move current state toward desired state.
kubeletWorker nodeAgent that makes sure containers are running in their Pods.
Container runtimeWorker nodeSoftware such as containerd or CRI-O that runs the containers.
kube-proxyWorker nodeMaintains network rules that implement Services.
Engineer's Take

We recommend Kubernetes when services run across many hosts and you need automated bin packing, self-healing, and declarative rollouts, and when utilization and uptime matter more than single-server simplicity. Common production pitfalls are naked Pods that are never rescheduled when their node fails, memory limits set higher than requests that put whole nodes at risk of OOM, CPU limits so tight they throttle workloads, and cluster add-ons left at small-cluster defaults. We run every workload under a controller, match memory requests to limits, and budget time for minor version upgrades.

Diatom Enterprises favicon
Diatom engineering team
Kubernetes at a Glance
Type

Container orchestration platform

License

Apache 2.0, hosted by the CNCF

Managed options

Amazon EKS, Azure AKS, Google GKE

Strengths

Self-healing, autoscaling, declarative rollouts

Compared with
Need a reliable tech partner?
20+

Years in business

80+

Senior engineers

200+

Projects delivered

What Kubernetes Is Used For

Software teams use Kubernetes to run distributed microservices, ship zero-downtime releases, scale fluctuating workloads, and make better use of cloud infrastructure.

Microservices and Service Networking

Kubernetes gives each Pod and Service its own address and balances traffic across containers. With Pod Certificates now stable, workloads can also get native X.509 identities for mutual TLS between services.

Zero-Downtime Rollouts and Self-Healing

You declare the desired state and Kubernetes rolls out new versions, rolls back failed ones, and restarts or reschedules Pods automatically when a container crashes or a node fails.

Autoscaling Variable Workloads

The Horizontal and Vertical Pod Autoscalers and the Cluster Autoscaler adjust capacity to traffic. Version 1.37 added beta support for scaling idle services down to zero replicas.

Batch Jobs and Infrastructure Consolidation

Teams run batch and CI jobs that release capacity when they finish, and the scheduler packs containers onto nodes by CPU and memory requests. Dynamic Resource Allocation helps schedule GPUs and other special hardware.

Kubernetes vs Docker Swarm and HashiCorp Nomad

Comparing Kubernetes vs Docker Swarm, Kubernetes offers full-scale automation while Swarm offers simpler clustering built into Docker. HashiCorp Nomad schedules containers and non-container workloads from a single binary. For a single host, Docker Compose is usually enough.

Criteriontech logo kubernetesKubernetestech logo dockerDocker Swarmtech logo nomadHashiCorp Nomad
ScopeMulti-node container orchestration with separate control plane and worker processes.Multi-node orchestrator built into Docker Engine, with faster setup.Single-binary scheduler for containers and non-container applications.
Cluster stateetcd, managed with the API server, scheduler, and controllers.Internal Raft store, no external datastore.Built into the server agent, no etcd required.
Workload typesContainers described in YAML manifests.Docker services.Containers plus Java, exec, and QEMU workloads through task drivers.
ScaleUp to 5,000 nodes and 300,000 containers.Smaller clusters; up to seven manager nodes recommended.Multi-node clustering with lightweight agents.
AutoscalingHorizontal and Vertical Pod Autoscalers and Cluster Autoscaler.No built-in autoscaling.Scheduling from job specifications; autoscaling through add-ons.
Service discoveryPod and Service networks with built-in Services.Built-in Docker service networking.Built-in service discovery since 1.3; Consul for advanced service mesh.
Swipe the table to compare →

When to Choose Kubernetes

Choose Kubernetes when your architecture spans multiple servers and needs built-in autoscaling, isolated Pod and Service networks, and room to grow to thousands of nodes. It fits purely containerized workloads that benefit from automated bin packing, self-healing controllers, and native mTLS identity for Pods.

When Kubernetes Is Not the Right Fit

Kubernetes is not the right fit when everything runs on one server or developer machine; Docker Compose runs multi-container apps from one YAML file without cluster overhead. Docker Swarm suits small teams that want clustering inside Docker without autoscaling. HashiCorp Nomad is better when you must schedule legacy Java, exec, or VM workloads next to containers without running etcd.

How We Approach Kubernetes Projects

We harden Kubernetes clusters with strict resource governance, automated security policies, and repeatable manifests, so teams avoid common day-two operational traps. See also our article on Kubernetes and Docker deployments.

Resilient Workloads and Sizing

Every workload runs under a Deployment, StatefulSet, or Job, never as a naked Pod. We avoid unnecessary hostPort bindings, match memory requests to limits, keep CPU limits realistic, and raise add-on limits as clusters grow.

Secrets, Identity, and Admission Control

Secrets are encrypted at rest in etcd and mounted as memory-backed volumes instead of environment variables. Namespaces enforce Pod Security Standards, and service account tokens are disabled for Pods that do not need API access.

Network Isolation and Upgrades

The API server, kubelet API, and etcd stay off the public internet, each namespace starts with deny-all NetworkPolicies, and Pods cannot reach cloud metadata endpoints. Minor version upgrades are scheduled within the support window.

Sound like the right partner?

Tell us about your project. We'll get back to you within 1 business day.

Frequently Asked Questions

Direct answers to common architectural, licensing, and operational questions when evaluating Kubernetes.

Is Kubernetes free and open source?

Yes. Kubernetes is free, open-source software under the Apache License 2.0. Google open-sourced it in 2014 based on its internal Borg system, and the Cloud Native Computing Foundation now hosts and maintains it. Managed services such as Amazon EKS, Azure AKS, and Google GKE charge for worker nodes, and most add a control-plane fee; the AKS Free tier has none.

What is the maximum number of nodes and Pods a cluster can support?

As of Kubernetes 1.37, a single cluster supports up to 5,000 nodes, 150,000 Pods in total, and 300,000 containers, with up to 110 Pods per node.

How does Kubernetes differ from a traditional PaaS?

Kubernetes works at the container level, not the source-code level. It does not build applications, deploy source code, or bundle databases and message buses, so you choose and integrate your own backing services and CI pipelines.

When should I use Docker Compose instead of Kubernetes?

Use Docker Compose when a multi-container application runs on a single host, such as a local development environment or a single-server deployment. Compose defines the whole application in one YAML file and avoids the control plane overhead of Kubernetes when you do not need cross-server orchestration or autoscaling.

What are the most important Kubernetes security best practices?

Encrypt Secrets at rest in etcd, mount secrets as memory-backed volumes instead of environment variables, and enforce Pod Security Standards with the built-in admission controller. Disable service account tokens for Pods that do not need the API, avoid the system:masters group after bootstrapping, keep the API server, kubelet, and etcd off the internet, apply default deny-all NetworkPolicies, and block access to cloud metadata endpoints.

How long is each Kubernetes minor version supported?

About 14 months. The project maintains release branches for the three most recent minor versions at the same time, and managed services such as EKS, AKS, and GKE publish their own support windows, sometimes with paid extended support.

The People Behind

A team of skilled engineers, architects, and delivery managers, dedicated to making every engagement a success.

Let's discuss your project