Container Security

• Containers multiply your workloads — a tiny image flaw multiplies into thousands of identical incidents.
• Misconfigured runtime (root user, privileged, host mounts) is how 'container' becomes 'host compromise'.
• The security of 'Nginx in a box' depends on the image's base OS and the runtime's sandbox, not the Nginx config alone.

The shipping box is great until you realize the cargo came from an unvetted packer with root.

• Base image: minimal, pinned, and scanned — every layer is a supply-chain claim you inherit.
• Content: signatures (cosign/Sigstore) and digests pin what runs; a floating tag can silently swap the image.
• Runtime: non-root user, read-only root filesystem, seccomp/AppArmor profiles drop privileges further.
• Capabilities: drop ALL and add only what the workload truly needs — not a namesake of CAP_SYS_ADMIN.

• A platform team enforces 'no root user' and 'read-only rootfs' in admission policy; red-team pods die at policy time.
• A startup signs every image and verifies in CI, killing backdoor-image supply-chain swaps.
• A chip vendor runs seccomp profiles generated per process, dropping syscalls the binary never uses.

• Start from minimal slims (alpine/distroless) pinned to a digest, never floating tags.
• Run as a non-root UID with drop-all/cap-add-whats-needed capabilities.
• Set read-only root filesystem and a tmpfs for writes only where required.
• Scan every image and gate on high/critical findings with a signed SBOM in the artifact.

• Copying a 1GB 'full' image for a 5MB utility — the attack surface travels with the fat.
• Running as root 'because the app needs it', skipping the three-line non-root fix.
• Mounting host paths or docker.sock into containers; one exploit becomes host-admin instantly.
• Pulling from public registries on the production kubelet, untagged and unsigned.

• When a container misbehaves under read-only root, find the write path ('touch /srv/x' error) and give it a tmpfs.
• Test capabilities with capsh or a scratch container that prints its bounding set.
• Scan the recursive layers: an inherited vulnerable base keeps failing scans even after your own layers are clean.

• Images are code too — treat them like any dependency: reviewed, pinned, and patched on a cadence.
• Signing is a trust decision: know exactly which keys bind to which images before trusting a trust framework.