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:
- Alpha and non-default features: Stripping unproven upstream features and legacy compatibility layers shrinks both binary footprint and attack surface.
- 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:
- Container runtime: containerd and runc
- CNI plugin: Flannel (default)
- Cluster DNS: CoreDNS
- Resource monitoring: metrics-server
- Ingress controller: Traefik
- Load balancer implementation: Klipper LoadBalancer (ServiceLB)
- Local storage: local-path-provisioner
- Package management: helm-controller
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.
- kube-apiserver
- etcd v3 gRPC APIKine (Datastore Shim)
- SQL (Prepared Statements)SQLite / MySQL / PostgreSQL
Datastore Rules and Operational Constraints
- Default SQLite for single-node setups: A single Server node defaults to embedded SQLite, completely eliminating external storage dependencies.
- High-availability options: Multi-Server deployments can leverage built-in embedded etcd, external etcd, or external SQL databases (officially certified versions: MySQL 8.0/8.4, MariaDB 10.11/11.4, and PostgreSQL 15/16/17).
- Strict monotonic sequence constraint: The Watch mechanism and cache synchronization in
kube-apiserverstrictly rely on a globally monotonicresourceVersion. To satisfy this contract, Kine requires the database revision to begin at 0 and increment by exactly 1 per mutation. - Connection pooling limitations: Kine requires the database backend to support prepared statements, necessitating careful configuration when placing connection poolers like PgBouncer in front of it.
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.
NOTE
Further reading: An Introduction to etcd: The Memory of a Kubernetes Cluster
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 Aspect | K3s Distribution | Vanilla kubeadm Cluster |
|---|---|---|
| Installation & Deployment | Single-line shell script, bundled k3s kubectl | Manual package installation, manual init, and manual CNI setup |
| Control Plane Model | Single process via Goroutines, containerd as child process | Static Pods supervised by kubelet, separate processes |
| Datastore Storage | Embedded SQLite by default; HA via embedded etcd, external etcd, or external SQL | Stacked or external etcd |
| Client Certificates | 365-day validity; auto-renewed upon service restart within 120 days of expiry | 365-day validity; renewed only during upgrades, otherwise manual |
| Upgrades | Drop in a new binary or automate fleet-wide upgrades via CRDs | Sequential kubeadm upgrade workflow; CNI compatibility managed manually |
| HA Load Balancing | Agent-side WebSocket client load balancing; no external LB required | External 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:
- 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.
- Network backend selection: Default Flannel supports
vxlan,host-gw, andwireguard-native. Integrating advanced CNIs like Cilium requires starting K3s with--flannel-backend=none, and it is recommended to also set--disable-network-policyto avoid conflicts with the CNI’s own network policy engine. - 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. - 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
- Need custom control-plane flags or 1000+ nodes?
- YESkubeadm / Managed K8s
- NOEdge, CI/CD, homelab, or limited etcd SRE capacity?
- YESK3s distribution
- NOCompare operational needs
- When to choose K3s: Edge compute nodes, IoT devices, ephemeral CI/CD testing clusters, homelabs, or small-to-medium teams without dedicated SRE capacity to operate and debug etcd clusters.
- When to choose kubeadm: Deployments requiring fine-grained control over control plane component flags and runtime arguments, deep integration with custom hardware or Device Plugins, or enterprise-scale footprints spanning thousands of nodes.
- A pragmatic lens: The kubeadm workflow is an essential foundation for mastering Kubernetes internals and passing CKA certifications; K3s is an exceptional tool for rapid prototyping, edge rollouts, and slashing operational friction.