Step into the IT office of a busy heart hospital and a handful of confident one-liners about containers will reach you within minutes. “We pinned the image, so we are frozen.” “One process per box, always.” “The scanner is green, so we are safe.” Each sentence sounds tidy, and each is only partly true. This post takes six of them and sorts the myth from the useful rule. The subject is ContainerOps, meaning the daily handling of individual containers on one host, upstream of any orchestrator. Nothing here touches clinical practice; it is all about the software that runs scheduling screens, reminder services and internal portals.
A word about the label. The page called ContainerOps in the Ops Atlas openly admits the name is its own invention rather than anything an industry body has defined, and it concedes that several unrelated projects share the name. Read it as a handy bucket for building, tagging, storing and running containers with care.
Myth 1: “A pinned digest locks out every future patch”
The worry is understandable. A digest is a content hash, so an image referenced by digest can never change underneath you. If nobody ever moves that reference, you really would be running the same old bytes for years, which is the opposite of what a hospital wants from a system that holds patient appointment data.
The Atlas observes that the worry holds only when nothing automated is watching. Pair the pinned digest with an update bot that raises a proposal each time the base image is rebuilt, and the pin becomes a reviewed, deliberate step forward instead of a silent drift. Think of a pharmacy shelf with labelled lot numbers: the label does not stop a new lot arriving, it just makes every swap visible and traceable.
What to do instead: pin everything in production, then let a bot propose the updates, and review them the way you would review any other change.
Myth 2: “One process per container is the law”
You will hear this one in every meeting. The Atlas treats it as sensible guidance rather than a rule written in stone, and that framing is worth keeping. A small web service with a helper that rotates its own cache can sensibly live together. The trouble starts when a container becomes a miniature server with a process manager, a shell session and four unrelated jobs, because then nobody can say what it is for.
A workable test: can you state the container’s purpose in one sentence, and does restarting it disturb only that purpose? If both answers are yes, a second helper process is not a sin.
One more reason to be relaxed about this rule: logs. If the second process writes to the same output stream, you still get a single place to read what happened. The Atlas does caution that the stock json-file logging setup never rotates, so a chatty container will slowly eat the disk unless a size cap is configured from the start.
Myth 3: “A green scan means we are safe”
Scanners are useful, but for scanning without the ability to rebuild fast, the Atlas has a blunt verdict: you hold a list, not a fix. A report naming forty outdated packages helps nobody if the build waits a week for approval, or if the image was built by a laptop three years ago and nobody remembers how.
Picture a hospital that audits its fire extinguishers monthly but has no process to replace an expired one. The audit is real and the safety is not. In container terms, the figure worth watching is the elapsed time between an upstream release and the patched image running in production, not the count of findings on a dashboard.
- Keep the build reproducible so a rebuild is a button press.
- Measure the elapsed time from a published fix to the running container.
- Treat the scan as an input to that pipeline, not as the pipeline.
Myth 4: “Containers are tiny virtual machines”
They are not. Namespaces and control groups isolate what a process can see and consume, but every container on the host shares one kernel. The Atlas stresses that this shared kernel is a genuine risk, which is why sandboxed runtimes exist for code you do not trust. For a hospital’s own, reviewed services that is rarely a daily concern, but it changes how you treat anything arriving from outside, such as a vendor-supplied reporting tool.
Two habits follow from this. Do not run containers as the root user unless you can state a reason, and do not hand a container the keys to the host, for instance by mounting the container engine’s control socket into it. The Atlas lists both the socket mount and privileged mode among the anti-patterns because either one gives a compromised container the same reach as an administrator.
Myth 5: “If I delete the secret in a later step, it is gone”
This one catches experienced people. An image is built from layers, and each layer is a record of changes. Copy a credentials file in one step and delete it in the next, and the earlier layer still holds the file; anyone who pulls the image can unpack that layer. The Atlas’s advice is to rebuild using build-time secret mounts so the value is never written into any layer in the first place.
If you suspect a credential was ever baked into an image, assume it leaked, rotate it, and rebuild. Deleting the file in a new layer is the equivalent of crossing out a name in a printed directory that has already been handed out.
Myth 6: “The program will see the limits I set”
Set a CPU limit for a container and many runtimes will still look at the whole machine. The Atlas notes that a common call for the processor count inside a container reports the host’s CPUs, so thread pools get sized for a much larger machine than the container is allowed to use. One example it gives is that the Go runtime only began deriving its parallelism from the limit with version 1.25.
The result is a service that spawns too many workers, gets throttled, and looks slow for no visible reason. Check how your language runtime behaves, and set parallelism by hand wherever it ignores limits. Memory and process-count limits deserve the same attention: the Atlas suggests always setting both, while treating CPU limits more cautiously because they can throttle bursts.
What links the six
All of them grow out of a shortcut that blurs who is accountable. The pin, the scan, the single process and the limit all feel like decisions that someone else has already made. Hospital IT teams are used to the opposite approach in other areas: a checklist, an owner and a date. If you want a gentle place to start, look at how telehealth fits into follow-up after cardiac procedures, which is a good reminder of how much of a modern patient journey runs on software that somebody has to keep tidy. For the administrative side of recovery programmes, the piece on the way rehabilitation supports recovery shows the sort of service a patient portal might link to, and those portals are exactly the kind of workload containers carry.
It also helps to separate the myths from the real hazards. Publishing a port with only a number, such as 8080:8080, binds it on every network interface of the host, and the Atlas notes that such published ports bypass the host firewall rules most administrators assume are protecting them. Binding to the loopback address, or using an internal-only network, is the grown-up version of closing a door you never meant to leave open.
A short, practical checklist
- List every container running on each host, and write down who owns it.
- Check that production references use digests, and that a bot proposes updates to them.
- Run services as a non-root user with a read-only filesystem where possible.
- Set memory and process limits everywhere, and test CPU limits before enforcing them.
- Rebuild from clean sources whenever a credential or base image changes.
- Track the time between an upstream fix and its arrival in production.
Closing thought
The myths are not stupid; each is a compressed version of a real lesson that lost its caveat on the way. Put the caveats back, and the discipline becomes ordinary housekeeping: know what you run, know where it came from, know what it may consume, and know who answers when it misbehaves. That is as dull as a well-kept supply cupboard, and just as valuable when a busy shift begins.