Walk through a modern automation cell and you will find robot arms, conveyors, cameras, a small industrial computer and a stack of software on that computer: motion planning, vision, a fleet agent, a dashboard. More and more of that software is delivered as containers, because a container lets the vision team and the controls team ship their parts without fighting over library versions. Somebody has to look after those containers. The Ops Atlas labels that single-container care ContainerOps, and this explainer translates it for people who think in sensors and actuators.
The Atlas notes that the term is its own coinage, so do not expect it on a vendor datasheet. The practices matter more than the name, and you can read them in the Atlas entry that scopes ContainerOps. This article restricts itself to that scope: containers, images, registries and runtime settings on a single host, not fleet-wide scheduling.
One box, many programs
Think of the industrial computer as a workcell and each container as a station inside it. Each station has its own tools and its own bench, and the stations share the building. That sharing is where trouble starts. Containers use the host’s kernel, so a runaway station can still use up the building’s power and heat.
The Atlas stresses this point: namespaces make a container look separate, but they do not turn it into a separate machine. For code you do not fully trust, such as a third-party perception module, it points to sandboxed runtimes. For your own code, the answer is good limits and least privilege.
The software equivalent of a bill of materials entry
Manufacturing teams already know the value of exact part numbers. A drawing that says use a bolt is not enough; you need the grade, the length and the supplier lot. Images have the same problem. A tag such as latest is a loose description, and a digest is the exact lot number: a fingerprint computed from the image content.
Deploy by digest and write it into the cell’s commissioning record. When a robot misbehaves after an update, you can say which build was running and reproduce it on a bench machine. The Atlas also advises that release tags stay fixed once published, and that an update bot can propose newer base images for review, so exact part numbers need not mean frozen software.
Limits: giving each station its share
Vision programs love memory, and planners love processor time. Without limits, a vision container that leaks memory will eventually push the host to start killing programs, possibly the one that talks to the drives. Set a memory ceiling and a process-count ceiling for every container, as the Atlas insists.
When a container is killed for exceeding memory, it exits with code 137, the sum of 128 and the kill signal 9. If you see 137 in the logs of a perception container, the memory limit is the first place to look.
Processor caps need more care. The Atlas notes that a cap can pause a program in short bursts even when average usage looks modest, and that the share of paused periods should stay under 5 percent where timing matters. Control loops are the classic latency-sensitive case. Our look at the key robotic performance indicators for factory managers covers the hardware-side measures; the throttle ratio is the software-side counterpart to add beside them.
Stopping politely
An important caution first: nothing in a container setting replaces the hardware safety functions of a robot. Emergency stops, safety controllers and guarding are separate engineered systems. What this section covers is software hygiene, such as saving state and closing connections when a service is told to stop.
When a container receives a stop request, it first gets a termination signal and, after a grace period, a forced kill. Compose waits ten seconds by default, according to the Atlas. If your fleet agent ignores the signal, it is simply cut off. The common reason is a start command written in shell form, which puts a shell between the runtime and your program so the signal is lost. Use exec form, handle the signal in code to flush logs and release resources, and add the init option if the program launches helpers.
Ports: who can talk to your cell
The next surprise is about networks. If a dashboard container publishes a port without naming a host address, it listens on every interface, and the Atlas warns that the host firewall does not see such traffic, since the engine installs its own forwarding rules ahead of it. A service meant for the local technician laptop may be visible to the whole plant network.
Bind internal services to the loopback address, put a reverse proxy in front of anything that must be reachable, and use internal-only networks for containers that need to talk to each other and nobody else. Treat the factory network as hostile by default.
Logs and disks on small machines
Industrial computers often have modest storage. Container logs written with the default json-file driver do not rotate, so a chatty sensor driver can fill the disk over a few weeks and the cell stops for a reason unrelated to the robot. Set a size and a file count in the logging options, and check free space as part of routine maintenance.
Where sensors come into it
Many perception faults that look like hardware turn out to be software drift: a driver library updated underneath the program, a calibration file replaced by a default. Our overview of sensor integration in industrial robots explains the hardware side of the chain. On the software side, pinned images and read-only root filesystems keep the environment the sensor driver sees identical from one shift to the next.
Similarly, the guide to automated guided vehicles in warehouses describes fleets in which each vehicle carries its own computer. A repeatable image and a documented stop behaviour are what keep a fleet of such computers consistent when updates roll out.
A short worked picture
Suppose a cell computer runs three containers: a vision service, a planner and a small web dashboard for operators. The vision service gets a 6 GB memory ceiling after the team measures its peak. The planner gets a CPU cap but a generous one, because its loop is timing-sensitive. The dashboard binds only to the loopback address and is reached through a proxy that requires a login.
Each is pinned by digest, each runs as an unprivileged user and each writes rotating logs to a volume of fixed size. When the vision team ships a new build, the cell gets a new digest in a commissioning note, a test run on the bench and a scheduled switch-over during a planned stoppage. If the new build misbehaves, rolling back means returning to the previous digest, which is written down.
A starter routine for an automation team
- List every container on each cell computer, with its image digest and an owner.
- Set memory and process limits, and note the values in the commissioning record.
- Check start commands for shell form and fix them.
- Bind every non-public port to the loopback address.
- Configure log rotation and check disk headroom monthly.
- Schedule a monthly review of base-image age and update proposals.
None of these steps needs new equipment. They take a few hours per cell, and they replace the vague hope that the software is fine with a short list of facts. That, in the end, is what ContainerOps offers an automation team: fewer surprises from the part of the system that is easiest to forget.