Containerization on Edge Devices: Docker and Kubernetes (K3s)

Historically, updating software on an industrial gateway meant "flashing firmware." It was risky, slow, and monolithic. If you wanted to change one line of code, you had to replace the whole OS. Today, the revolution of Containerization has reached the edge. This guide explains how technologies like Docker and K3s (Lightweight Kubernetes) allow developers to package applications in isolated environments. We explore how an edge device can run complex microservices—combining databases, brokers, and logic—without dependency conflicts, turning the hardware into a flexible software platform.

For decades, embedded development was rigid. You wrote C code, compiled it for a specific chip, and flashed it as firmware. If you wanted to update the application, you had to reboot the entire system.

Cloud developers looked at this and said, "There must be a better way."

That way is Containerization.

Originally built for massive cloud servers, containers have now shrunk down to fit on the edge device. This shift is massive. It allows you to treat a rugged industrial router exactly like a mini-server, deploying updates in seconds without disrupting the core operating system.

This guide explains how Docker and Kubernetes are redefining what is possible on edge hardware.

A container is a lightweight, standalone, executable package of software. It includes everything needed to run an application: code, runtime, system tools, system libraries, and settings.

The Problem: You write a Python script that works on your laptop. You upload it to an edge device, and it crashes because the device has Python 3.5, but you used Python 3.9 syntax. This is "Dependency Hell."

The Solution: You package your script and Python 3.9 inside a Docker container. You ship the container to the edge device. It runs perfectly because it brought its own environment with it. This "Write Once, Run Anywhere" capability drastically speeds up IoT development.

Docker is the industry standard for creating and running containers. Modern industrial edge devices (like those running RobustOS Pro) come with the Docker Engine pre-installed.

How it works:

1. Build: You create a Dockerfile on your PC.
2. Push: You upload the image to a registry (like Docker Hub).
3. Pull: The edge device downloads the image.
4. Run: The device spins up the container in an isolated sandbox.

Because containers share the host's Linux kernel (unlike heavy Virtual Machines), they start instantly and use very little RAM. You can easily run a MySQL database and a Node.js server simultaneously on a single gateway.

The biggest advantage of Docker on an edge device is the ability to break applications into pieces.

The Old Way (Monolith): One giant C++ program handles Modbus reading, data processing, and cloud uploading. If the cloud uploader crashes, the whole device stops reading Modbus.

The New Way (Microservices):

• Container A: Modbus Reader (Reads sensors).
• Container B: Data Processor (Filters noise).
• Container C: Cloud Uploader (Talks to AWS).

If Container C crashes, Containers A and B keep working. The edge device remains stable, and you only need to restart the specific service that failed.

Docker is great for running one container. But what if you have 5 containers across 1,000 devices? How do you update them all? How do you ensure they restart if they crash?

This is the job of Kubernetes (K8s). However, standard Kubernetes is too heavy for an edge device. It needs Gigabytes of RAM.

Enter K3s. K3s is a certified Kubernetes distribution built for IoT. It is stripped down to a binary of less than 100MB. It runs efficiently on ARM processors. With K3s, you can treat your fleet of edge devices as a single cluster. You push a deployment file to the master node, and K3s ensures that the correct containers are running on every edge device automatically.

Containerization comes with a cost: overhead. You cannot run Docker on a simple microcontroller (Tier 1 Sensor).

To support a containerized environment, your edge device typically needs:

• Architecture: ARM v7/v8 or x86.
• RAM: Minimum 512MB (1GB+ recommended for K3s).
• Storage: 8GB+ Flash (to store container images).
• OS: A Linux distribution with cgroups and namespaces enabled.

If you try to force Docker onto underpowered hardware, the edge device will become unresponsive. Always size your hardware for the software stack you intend to run.

The line between a "Server" and a "Gateway" is blurring. By adopting containerization, you unlock the ability to use modern CI/CD pipelines for your hardware. You can push code to an industrial edge device as easily as pushing to a web server.

This flexibility allows your IoT infrastructure to evolve. You can deploy a gateway today for simple connectivity and, next year, deploy a Docker container to it that adds AI capabilities—without ever visiting the site.