Anyone in outreach and guest posting has heard the folklore: “links from big sites always work”, “longer is always better”, “send forty pitches a day”. Each sounds plausible, and each wastes someone’s month. Infrastructure has its folklore too. In container work, which the Ops Atlas groups under the name ContainerOps, a handful of repeated claims keep steering teams toward the wrong habits. Below are six of them, each one checked against the Atlas entry. No jargon for its own sake, and no hype: just the claim, the correction and what to do on Monday.
A quick orientation. The Atlas uses ContainerOps for the care of single containers beneath any orchestrator: images, tags and digests, registries, runtimes, limits and the logs they produce. It is candid that the name is its own and not a recognised standard. You can read the full scope on the Atlas’s ContainerOps entry. Now to the myths.
Myth 1: “Pinning to a digest means we never get security fixes”
This one is the most common objection to doing deploys properly. A digest identifies an exact image, so it cannot silently change, and people conclude that updates will stop. The Atlas says the claim is only true if you pin and then do nothing. Add a dependency bot that opens pull requests whenever the base image publishes a new build, and the pins move forward under review, with tests running before each change lands.
What to do: pin production to digests, keep human-readable release tags that are never reused, and let automation propose the updates. You gain repeatability and still get fixes.
Myth 2: “One process per container is a law”
People recite it like a commandment, yet the Atlas is milder, describing it as sound guidance without being an absolute requirement. The sensible reading is that each container should have one clear job, and that tangled bundles of unrelated programs make logging, stopping and updating harder. A main process plus a small helper that belongs to it is not a crime. A database, a web app and a cron job all stuffed into one image is.
One more angle: the guidance exists because a container’s main process is what receives stop requests and what the engine watches for failure. When three programs share that slot, a crash in one can go unnoticed, and a shutdown signal may reach only the first. Splitting by job gives each piece its own restart behaviour and its own log stream, which is easier to read at three in the morning.
What to do: ask whether the pieces start, stop and scale together. If so, one container may be fine. If not, split them.
Myth 3: “We scan our images, so we are secure”
Scanning is useful, and the Atlas says plainly that it belongs to a neighbouring discipline. But a scan alone produces a list of findings, and the entry puts it bluntly: a list, not a fix. If it takes you a month to rebuild and redeploy, the report is out of date before anyone acts. What counts is the elapsed time between a fix being published and that fix actually serving traffic, and a seven-day window for critical problems appears there as a sample policy.
What to do: invest in fast, boring rebuilds first. A scanner on top of a slow pipeline is a smoke detector in a building with no exits.
Myth 4: “A container is basically a small virtual machine”
It feels like one. You get your own process list, your own network view and your own files. But every container on a host leans on the same kernel, which the Atlas flags as a genuine exposure. A kernel flaw reaches every container on the machine. For code nobody can vouch for, it points to sandboxed runtimes. It also records a runtime flaw published in January 2024 involving leaked file descriptors, through which a malicious image could break out of its container and reach the host, and a later one in November 2025 where the recommended hardening included mapping container users so that host root stays out of reach.
What to do: treat containers as a convenient boundary, not a vault. Run as a non-administrator, drop capabilities, keep the runtime current, and use stronger isolation for anything you did not write.
Myth 5: “The program inside can see its own limits”
Many languages ask the system “how many processors do I have?” to size their thread pools. The Atlas warns that in a container this call can still report the host’s processors, not the cap you configured. A service limited to two processors on a thirty-two processor host may start thirty-two workers and then spend its life being throttled. The same entry mentions that one popular language only began sizing from the limit in release 1.25.
Teams usually find this by accident, when latency graphs show spikes that the average processor use cannot explain. The entry works through a case: a container capped at two processors used about one and a half on average over a minute, and yet 40 percent of its accounting periods were throttled. Averages looked healthy while users waited.
What to do: check how your runtime discovers its resources, set the pool sizes explicitly if needed, and track the throttle ratio. The entry suggests keeping it under five percent for latency-sensitive work.
Myth 6: “Deleting the secret in a later step removes it”
Build files look like a script, which tempts people to download a key, use it and then delete it with another line. But each step in a build becomes a layer, and layers are changesets. The deletion is recorded in a later layer while the earlier one still contains the file. Anybody who can pull the image can extract it. The Atlas recommends secret mounts that are present only during the step that needs them.
There is a practical wrinkle. Teams often discover the problem only when an old image is pulled from a registry for an unrelated reason and someone runs a history command out of curiosity. At that point the secret has been sitting in storage for months, copied to every mirror and cache that touched it. The fix is cheap now and expensive later, which is the usual shape of container hygiene.
What to do: search your build files for steps that fetch credentials, and move them to mounts. If a secret has already been baked into a published image, rotate it, since deleting the tag does not unshare the copies.
Why these claims keep circulating
Why do they stick? Each carries a kernel of truth. Pinning can freeze fixes without a bot. Some containers should be single-purpose. Scanning does find real problems. Isolation does exist. Reading from inside a container does give you a number, and a build file does let you delete a file. Good myth-busting keeps the grain and drops the overreach. The same pattern applies in link building, where the lesson in pitching niche-relevant guest content is that targeted, careful work beats volume, and where using content templates to structure drafts quickly saves time without lowering the bar.
A five-minute reality check
- Pick one production container.
- Find out whether the deploy references a digest and who updates it.
- Read its limits, and whether it runs as administrator.
- Look at its build file for any step that touches a credential.
- Time how long a rebuild and redeploy would take today.
Five answers, five minutes, and you will know which of the myths your own setup is quietly acting on. Fix the one that costs most, then come back to the next. That is how practical teams turn folklore into procedure.