How K3s Packs the Kubernetes Control Plane into a Single Process

K3s is a lightweight Kubernetes distribution that packages the control plane, container runtime, networking, and storage into a single binary under 100 MB. By comparing it against a standard cluster bootstrapped with kubeadm, this article breaks down what K3s modifies, strips away, and streamlines.

kubeadm is strictly a bootstrap tool. As the official kubeadm documentation states:

kubeadm performs the actions necessary to get a minimum viable cluster up and running. By design, it cares only about bootstrapping, not about provisioning machines.

kubeadm does not provision nodes, install a Container Network Interface (CNI), or set up Ingress controllers and load balancers. Even the CNI plugin must be manually applied after cluster initialization.

K3s, by contrast, is a full distribution with these components preselected and bundled out of the box. Comparing clusters built by both tools reveals that nearly every architectural difference stems from this fundamental divide: distribution vs. bootstrap tool.


Origins and CNCF Positioning

K3s was created and open-sourced by Darren Shepherd at Rancher Labs in February 2019 (with version v0.1.0 released on February 26, 2019). Its original vision was to provide a featherweight Kubernetes with a fully compliant API, tailored for edge computing, IoT, ARM devices, and CI environments.

A “fully compliant API” means that all stable upstream Kubernetes APIs remain completely accessible in K3s. Deployments, Services, CRDs, and RBAC policies work as expected, requiring no modifications to existing kubectl commands, Helm charts, or Operators. In other words, K3s trims down how components are packaged and executed, without compromising API fidelity.

SUSE acquired Rancher Labs in 2020 and subsequently donated K3s to the Cloud Native Computing Foundation (CNCF) in August of that year, making it the first Kubernetes distribution accepted into the CNCF.

The CNCF categorizes projects into three maturity tiers: Sandbox, Incubating, and Graduated. As of October 2026, K3s remains an entry-level Sandbox project. Given K3s’s widespread adoption, this tier might seem surprising; however, CNCF maturity assesses project governance rather than deployment scale, and the two do not always move in tandem.

In terms of compatibility, K3s holds CNCF Certified Kubernetes conformance certification. The official documentation highlights:

K3s is a CNCF-certified Kubernetes distribution, and can do everything required of a standard Kubernetes cluster.

Achieving this certification requires passing upstream conformance test suites verified by the CNCF, providing an objective basis for the API compatibility described above.


Architectural Simplification: What Was Stripped and What Was Bundled

The lightweight design of K3s boils down to two core strategies: stripping out redundant components and bundling the essentials, batteries included.

Stripped Components and Design Rationale

K3s primarily removes two categories of code:

  1. Alpha and non-default features: Stripping unproven upstream features and legacy compatibility layers shrinks both binary footprint and attack surface.
  2. In-tree cloud and storage plugins: Early Kubernetes releases compiled drivers for public clouds and storage vendors directly into core binaries (in-tree). K3s strips out these bulky plugins, aligning with two major upstream shifts: offloading cloud integrations to external Cloud Controller Managers (CCMs) and standardizing storage drivers via CSI. K3s can still seamlessly attach external CCMs and standard CSI drivers when needed.

Bundled Ecosystem: Batteries Included

Inside a single binary under 100 MB, K3s bundles a turnkey operational environment:

Because Flannel lacks native NetworkPolicy enforcement, K3s embeds the netpol controller library from kube-router. Meanwhile, it’s a common misconception in the community that kube-proxy was dropped; in reality, it remains present, running as an embedded Goroutine inside the K3s Agent (and can be toggled off via the --disable-kube-proxy flag).


Execution Model: Single-Process Goroutines vs. Static Pods

The most fundamental structural distinction between K3s and a vanilla kubeadm cluster lies in their execution models.

In a kubeadm-deployed cluster, control plane components (kube-apiserver, kube-scheduler, kube-controller-manager, and etcd) run as static Pods defined in /etc/kubernetes/manifests, supervised by the local kubelet and running on the host network.

K3s takes a radically different approach: all control plane components run as concurrent Goroutines within a single K3s process.

 kubeadm Vanilla Cluster:
 +-------------------------------+
 | kubelet                       |
 | Static Pods (Processes):      |
 | - kube-apiserver              |
 | - kube-controller-manager     |
 | - kube-scheduler              |
 | - etcd                        |
 +-------------------------------+

 K3s Distribution:
 +-------------------------------+
 | K3s Server (Single Process)   |
 | Goroutines:                   |
 | - API Server                  |
 | - Controller Manager          |
 | - Scheduler                   |
 | - Embedded etcd / Kine Engine |
 +-------------------------------+
    | (supervises child process)
    v
 +-------------------------------+
 | containerd (Process)          |
 +-------------------------------+

Under the hood, the API Server is invoked via apiapp.NewAPIServerCommand(), the Scheduler via sapp.NewSchedulerCommand(), and the Controller Manager, kubelet, and kube-proxy are all scheduled under the same Go runtime. Meanwhile, another critical node-level component, containerd, adopts a distinct execution strategy: it runs as a child process supervised by K3s.

Troubleshooting Entry Points and Blast Radii

This architectural difference directly shifts where you look during troubleshooting. In a kubeadm cluster, operators inspect control plane status and logs by querying Pods in the kube-system namespace. In K3s, the API Server and Scheduler have no dedicated control plane Pods. The absence of these Pods in kubectl get pods -n kube-system does not mean the components failed to start—they simply aren’t running as Pods.

On a systemd-managed Server node, for example, start by checking the system service status and service logs:

# Inspect service status and control plane logs on the K3s Server host
sudo systemctl status k3s
sudo journalctl -u k3s -b --no-pager

# containerd maintains its own separate log file
sudo tail -n 100 /var/lib/rancher/k3s/agent/containerd/containerd.log

Packaged add-ons such as CoreDNS, Traefik, and metrics-server still run as standard Pods, allowing you to troubleshoot them using familiar kubectl logs workflows. Packaging everything into a single binary does not mean every component runs in the same process. The control plane, containerd, and add-ons each have distinct execution contexts and log destinations.

A shared process also reshapes the blast radius during restarts. Restarting the k3s system service restarts all control plane components on that Server node simultaneously; you cannot restart just the Scheduler the way you would bounce an individual static Pod. Consequently, maintaining a single component requires planning for a brief interruption to all control plane services on that specific Server.

That said, running Pod containers continue executing when K3s stops. A control plane pause is decoupled from workload execution; while existing containers keep running, the cluster cannot process API requests or schedule new Pods during the downtime.

NOTE

Logging level constraints: Because Kubernetes components share the same process-level klog configuration, log levels and destinations cannot be configured independently. While K3s provides a --debug flag to increase verbosity, passing granular flags like -v= or --vmodule= to individual components may not yield the expected results.


Datastore Abstraction: Kine and Storage Alternatives

Standard Kubernetes relies exclusively on etcd as its state store. K3s breaks this dependency through Kine (Kine Is Not etcd), an in-house database translation layer.

Kine implements the etcd v3 gRPC interface and translates etcd operations into standard SQL queries, enabling the API Server to communicate directly with relational databases.

  1. kube-apiserver
  2. etcd v3 gRPC APIKine (Datastore Shim)
  3. SQL (Prepared Statements)SQLite / MySQL / PostgreSQL

Datastore Rules and Operational Constraints

WARNING

Multi-master write incompatibility: Because Kine relies on strictly monotonic (+1) revision semantics, it is incompatible with multi-master database clusters (such as Galera) that use non-contiguous sequence jumping for conflict avoidance.

Transitioning from Single-Server to High Availability

An existing SQLite cluster can be migrated by restarting the Server node with the --cluster-init flag to convert the datastore to embedded etcd. Once the conversion finishes, additional Server nodes can join the cluster using the matching Server token via --server https://<existing-server>:6443.

Converting the datastore is only step one; fault tolerance is determined by the number of etcd members. The official embedded etcd HA topology requires an odd number of Server nodes, with a minimum of three. etcd needs majority consensus to keep functioning: a two-Server setup must have both nodes online, while a three-Server cluster needs only two. Expanding from one to two Servers yields zero fault tolerance; a minimum of three is required to withstand a single node failure.

Adding Agent worker nodes does not improve control plane resiliency, as Agents do not participate in etcd quorum. When scaling from a personal lab to a production-ready cluster, capacity planning must focus on Server node count and fault domain distribution, rather than raw node totals.

All Server nodes must also maintain identical critical flags, including --cluster-cidr, --service-cidr, DNS settings, disabled component lists, and --secrets-encryption. These parameters define shared cluster networking and features; managing them through a single, unified configuration prevents drift across Servers over time.

Snapshots and Restores Remain an Operational Mandate

Embedded etcd supports automated scheduled snapshots as well as manual snapshots via k3s etcd-snapshot save, complete with built-in export to S3-compatible object storage. For small teams, this eliminates the friction of rolling your own etcd backup tooling.

However, snapshots must be archived alongside the Server token. The token is used to encrypt database secrets at rest; attempting to restore a snapshot without the matching original token will render the backup unusable. For external SQL datastores, backup and disaster recovery remain the responsibility of native database tooling—K3s will not handle it for you.

When deploying HA, off-site backups and disaster recovery drills remain indispensable. Multi-Server setups protect against hardware node failures, but only verified backups protect against data loss; the two address different failure modes.


Day-to-Day Operations: Certificates, Upgrades, and Load Balancing

By capitalizing on its curated distribution model, K3s substantially streamlines day-to-day cluster operations.

Operational AspectK3s DistributionVanilla kubeadm Cluster
Installation & DeploymentSingle-line shell script, bundled k3s kubectlManual package installation, manual init, and manual CNI setup
Control Plane ModelSingle process via Goroutines, containerd as child processStatic Pods supervised by kubelet, separate processes
Datastore StorageEmbedded SQLite by default; HA via embedded etcd, external etcd, or external SQLStacked or external etcd
Client Certificates365-day validity; auto-renewed upon service restart within 120 days of expiry365-day validity; renewed only during upgrades, otherwise manual
UpgradesDrop in a new binary or automate fleet-wide upgrades via CRDsSequential kubeadm upgrade workflow; CNI compatibility managed manually
HA Load BalancingAgent-side WebSocket client load balancing; no external LB requiredExternal load balancer required in front of control plane nodes

In certificate lifecycle management, if a kubeadm cluster runs without upgrades for an extended period, administrators must routinely run kubeadm certs renew all and restart the static Pods. With K3s, restarting the service within 120 days of expiration (90 days in earlier versions) triggers automatic certificate renewal.

What Upgrades Solve—and What They Leave Behind

K3s maintains the matrix of Kubernetes core and bundled components as a unified release. Teams relying on default configurations avoid part of the component version-matching work. Nonetheless, reviewing release notes remains essential to verify that changes to APIs, networking, and Ingress behaviors do not disrupt existing workloads.

Manual upgrades can be performed by re-executing the installation script or by dropping a replacement binary into /usr/local/bin/k3s and restarting the service. When re-running the script, any flags or environment variables passed during initial installation must be supplied again to avoid losing your configuration; managing flags through dedicated configuration files decouples cluster configuration from installation scripts.

The installation script also does not automatically cordon or drain nodes. Workloads sensitive to transient API interruptions require an operator-directed maintenance sequence and graceful eviction plan. A single binary makes the upgrade mechanics trivial, but workload impact still depends on your cluster topology and application architecture.

Packaged add-ons also have distinct configuration boundaries. K3s regenerates the packaged component manifests on every startup, meaning direct edits to these files on disk will be overwritten. If you decide on an alternative Ingress controller, you must explicitly disable the built-in Traefik instance using --disable=traefik before deploying your preferred solution.

Similarly, a custom CNI can be deployed after disabling default Flannel networking. Once you swap in a custom CNI or Ingress controller, you take on the burden of tracking upstream versions, security patches, and Kubernetes compatibility. K3s gives you an escape hatch; your team absorbs the operational ownership.

Agent-Side Load Balancing

In a multi-node high-availability architecture, K3s Agents register with Servers via WebSockets and synchronize the live control plane node list in real time. This grants them native client-side load balancing capabilities, removing the need for an external HAProxy instance or cloud load balancer in front of the API Servers.


Known Limitations and Architectural Boundaries

Choosing K3s means buying into an opinionated set of architectural choices. Operators must account for the following edge cases and boundary conditions:

  1. Windows node constraints: K3s Server nodes must run on Linux; the official FAQ currently states that K3s does not natively support Windows. Earlier docs described joining Windows nodes as experimental Worker Agents with the Calico network plugin, but that page has since been removed—verify before relying on it.
  2. Network backend selection: Default Flannel supports vxlan, host-gw, and wireguard-native. Integrating advanced CNIs like Cilium requires starting K3s with --flannel-backend=none, and it is recommended to also set --disable-network-policy to avoid conflicts with the CNI’s own network policy engine.
  3. ServiceLB port conflicts: The bundled ServiceLB relies on HostPort mappings, occupying physical host ports directly. If multiple Services within the cluster request the same port (such as port 80), only one Service can bind; the remaining Services fail to bind.
  4. Dual-stack networking constraints: IPv4/IPv6 dual-stack networking must be configured during initial cluster bootstrapping; it cannot be toggled on dynamically after creation.

Selection Criteria and Architectural Guidance

  1. Need custom control-plane flags or 1000+ nodes?
  2. YESkubeadm / Managed K8s
  3. NOEdge, CI/CD, homelab, or limited etcd SRE capacity?
  4. YESK3s distribution
  5. NOCompare operational needs