An architecture for running Kubernetes at the edge on low-power utility nodes, using k3s, local autonomy and periodic sync.
Running Kubernetes at the edge, across hundreds or thousands of low-power field nodes, is a different problem from running it in a data center. Bandwidth is scarce and often metered, links drop for hours at a time, and the hardware is sized for the workload rather than for the orchestrator. A control plane that assumes every node is always reachable will spend its life reconciling churn.
Why k3s Suits Field Hardware
k3s packages Kubernetes as a single small binary, drops components a field node does not need and, in single-server setups, replaces etcd with an embedded SQLite datastore. An agent runs in a few hundred megabytes of memory, which is roughly what a well-specified gateway can spare beside its main workload.
For field work, two further properties matter as much as footprint. Nodes keep running their workloads through a network partition, so a lost uplink degrades reporting rather than operations. And the API is standard Kubernetes, so manifests, CI pipelines and operational tooling built for the cloud carry over without a parallel toolchain.
Decentralized Orchestration
Rather than one central control plane polling every node, each edge cluster aggregates and filters its data locally and sends summaries to the hub over a secure tunnel. The hub receives what it needs for fleet-level decisions, while raw telemetry stays close to where it was produced. The design grows by adding clusters, without the bandwidth cliff that central polling hits as the fleet expands.
resources:
limits:
cpu: "500m"
memory: 256Mi
tolerations:
- key: "node.kubernetes.io/unreachable"
operator: "Exists"
effect: "NoExecute"
tolerationSeconds: 3600The manifest shows two of the controls involved. Resource limits stop the agent from competing with the metering workload. A long toleration for the unreachable taint stops Kubernetes from evicting pods during a short outage, which for a field node is normal behavior rather than a failure.
With local autonomy and periodic sync, nodes ride out outages and reconcile when the link returns, sending buffered data once they are back online. Stagger reconnects with a random delay, so that a regional outage does not end with every node calling the hub in the same second.
Tagged Under

KoderTroop Systems Squad
Technical Authors
Articles are written by KoderTroop specialists and architects who design and deliver embedded systems, cloud platforms, edge computing and applied AI for our clients.