LockerGnomeTech news and nostalgia for today's technology professionals
Subscribe

Search

Hacks & Builds

Kube32 gives tiny ESP32 boards pods, kubectl and CrashLoopBackOff

An issue tracker spread across a devkit and a pocket computer shows what fits when the cluster has kilobytes to spare.

Ant farm of Chris Pirillo: he peers into an ant farm where tiny ESP32 boards
Illustration: LockerGnome

An ESP32-S3 can now participate in the familiar ritual of watching a pod fail and restart. Arterialist’s Kube32 brings kubectl and k9s to microcontrollers, including CrashLoopBackOff. A cluster can fit on the desk without making the desk into server furniture.

The project README describes one firmware image for all boards. A board with PSRAM runs the control plane and a local kubelet; workers can run without PSRAM. The listed control-plane requirement includes 8 MB flash and at least 2 MB PSRAM. The worker reference is an M5Stack Cardputer, complete with display, keypad and microSD storage.

Pods contain WebAssembly modules executed by wasm3. Its maintainers explain the interpreter tradeoff through executable size, memory use and startup latency. They also describe embedded WebAssembly as a way to separate the program’s toolchain from the device and give code a defined sandbox. A familiar deployment command can therefore send work to a board that has nothing resembling a desktop Linux installation.

Kube32 adds the cluster behavior around that runtime. A pod gets memory limits and an execution budget, while access to GPIO, I2C or a speaker depends on its declared capabilities. Restarts have exponential backoff, and the exit codes distinguish a trapped program from an exhausted execution budget or out-of-memory condition.

The demonstration goes further than an echo server. Tessera, the repository’s issue tracker, has four pods. Its web interface and search index run on the control-plane board. Its database and display controller run on the Cardputer, where an append-only log stores records on microSD. An Ingress routes traffic between them. That gives the abstract word “distributed” a visible consequence: the little keyboard and the records belong to one board while the website belongs to another.

The benchmark document supplies a more useful reality check than a miniature-cloud photo. Both boards run at 240 MHz. The comparison compiles the same C kernels natively and to WebAssembly, takes the fastest of five runs, and checks that their returned checksums match. These are project measurements, not independently reproduced results.

On the Cardputer, a bitwise CRC-32 calculation takes 880 microseconds natively and 74,191 microseconds in a metered pod. The document attributes the interpreter cost to native calls and returns for instruction dispatch; budget accounting adds more overhead. It recommends putting expensive computation in native host functions, which a pod can call across the sandbox boundary for about 1.5 microseconds of additional cost.

“Use a pod for control logic, protocol handling and glue code,” the benchmark’s author writes. A sensor that spends its time waiting for hardware could suit that arrangement; moving a calculation-heavy loop into a sandbox needs a different justification. Future demonstrations will have to show what becomes easier to maintain after the initial delight of deploying to a pocket computer wears off. How much useful application can those remaining kilobytes hold?

More Hacks & Builds

Every Hacks & Builds story →