ContainerOps FAQ: Answers Framed Like a Mission Briefing

Readers of a space site tend to think in terms of payloads, launch windows and what happens when something goes wrong far from the ground crew. That habit of mind turns out to be a good fit for ContainerOps, the day-to-day care of individual software containers running on one machine. No coding is needed to follow along, so grab a coffee and let us work through the most common questions in turn.

A quick orientation first. According to the Ops Atlas, ContainerOps is its own label for the work that sits below a cluster manager: building container images you can trace, keeping track of where they live, and running them in a predictable way. The Atlas is also candid that this is not an official industry term, so treat it as a handy name rather than a standard. The original wording lives in the Ops Atlas entry on ContainerOps.

What is a container, in plain words?

Think of a sealed payload bay. Everything the program needs, its libraries and settings and the program itself, travels together in one package, and the machine that carries it does not need to know what is inside. The package is called an image, and a running copy of it is a container. Because the contents are fixed, the same image behaves the same way on a laptop, a test server or a production box.

Anyone who read our newcomer’s introduction to low Earth orbit already knows why that matters: predictable conditions make everything downstream easier to plan.

Why does ContainerOps care about “layers”?

An image is built from stacked layers, and each layer records the changes made on top of the one before. Picture a mission log where every entry adds to the earlier ones and nothing is ever erased. That detail has a sharp consequence. If a password is written into an early layer and a later step deletes the file, the password still sits in the earlier entry for anyone who inspects the image. The Atlas points to secret mounts at build time as the cleaner route, so the sensitive value never lands in a layer at all.

The takeaway is simple: a delete command in a later step hides a file from view, but it does not remove it from history.

What is the difference between a tag and a digest?

A tag is a friendly name, such as a version label, that can be moved to point at a different image tomorrow. A digest is a long fingerprint computed from the image contents, and it only ever points at one exact build. Using a tag is like saying “send the latest satellite bus”; using a digest is like quoting the serial number on the hardware.

The Atlas recommends deploying and promoting by digest, while keeping release tags immutable so nobody can quietly repoint them. It lists floating tags in production as an anti-pattern, since you cannot say afterwards which build was actually running when a problem appeared.

Does pinning to a digest mean we never get fixes?

This is a popular worry, and the Atlas treats it as a myth. A pinned reference only stays frozen when nothing is updating it. Teams pair digests with a bot that opens pull requests when a newer base image appears, so the fingerprint moves on purpose, after review, rather than by surprise. Fixes still arrive; they just arrive through a door you can see.

Why do containers need limits?

Every spacecraft has a power budget. Without one, a single hungry instrument can starve the rest. Containers share a machine in the same way, so the Atlas advises always setting memory and process-count limits. It is more careful about processor limits, because a cap can cause short bursts of waiting that hurt response times even when the average usage looks comfortable.

The Atlas offers a worked example. A container capped at two processors used ninety seconds of processor time over sixty seconds, an average of one and a half, yet 240 of 600 scheduling periods were throttled. That is 40 percent of the time spent waiting, which would feel like lag to a user. The ratio of throttled periods to total periods is one number worth watching, with a target below five percent for latency-sensitive services.

What does “exit 137” mean?

It is the code you see when a container was stopped with a hard kill. The number is 128 plus 9, where 9 is the kill signal. A few things can cause it: the container ran out of memory, or it was asked politely to shut down, ignored the request, and was cut off once the grace period ended. Compose waits ten seconds by default before it gets forceful.

The ignoring part is the classic trap. If the start command is written in shell form, a small shell wrapper sits in front of your program and does not pass the polite request along. The Atlas suggests the exec form, a program that handles the stop signal, and an init flag. Think of it as making sure the shutdown command actually reaches the crew member who needs to hear it.

Is a published port really private?

Not necessarily, and this one surprises plenty of people. The Atlas notes that published ports are routed before the common host firewall tools get a look at them, and that a port mapping without an address binds to every network interface. Docker itself describes this default as insecure. The remedy is to bind to the local loopback address when a service should only be reached from the same machine, and to use internal networks for container-to-container traffic.

For a space analogy, it is the difference between an antenna aimed at one ground station and one broadcasting to the whole sky.

How do small teams keep from drowning in images?

Storage grows quietly. The Atlas sketches a thought experiment with forty services, twenty-five builds a week, two platforms and fifteen mebibytes per image, which comes to roughly 29 gibibytes added every week. With a retention policy and garbage collection the steady state it describes settles near 185 gibibytes instead of growing forever. Housekeeping is part of the job, and so is remembering that a pull-through cache is a convenience, not a backup.

What should a newcomer do first?

Start by counting. Make a list of what is running, where each image came from and who looks after it. The Atlas calls estates nobody owns the ones that quietly age. Then choose a few habits from the list above: digests for the biggest services, a non-root user, memory limits, and log rotation, since the default json-file logging has none and can fill a disk.

If you like to see progress in stages, the Atlas describes five maturity levels, from ad hoc laptop builds up to automated rebuilds in sandboxed runtimes. Most small projects will be happy to reach the third rung: digests, a non-root user and limits in place.

Is ContainerOps the same as running a whole fleet?

No. Managing a large fleet, with schedulers and admission rules, is a different job that the Atlas keeps outside this scope. ContainerOps is the craft underneath, the care of the single container. It is somewhat like mastering one capsule before you design a space station. If you are curious about the higher orbits of operations later, the post on geostationary orbits made easy is a gentle reminder that stable positions are chosen deliberately, not stumbled into.

One last question: where do I start reading?

Begin with the Atlas entry linked above, then try one small experiment of your own. Build an image, note its digest, run it with a memory limit, and stop it on purpose to see how it behaves. Ten minutes of that will teach more than another page of theory, and you will be ready to ask better questions of whoever runs your systems.