Dev.to Security πŸ” Cybersecurity πŸ‘ 0 πŸ“– 6 min read

Container Security Fundamentals: What Compliance Certifications Actually Require (and What They Don't)

Ask an enterprise IT buyer why they chose their cloud container platform and the answer is often a list of acronyms: SOC 2 Type II, ISO 27001, PCI DSS, HIPAA, FedRAMP, FIPS 140. Those certifications matter. In most regu

Container Security Fundamentals: What Compliance Certifications Actually Require (and What They Don't)

Ask an enterprise IT buyer why they chose their cloud container platform and the answer is often a list of acronyms: SOC 2 Type II, ISO 27001, PCI DSS, HIPAA, FedRAMP, FIPS 140.

Those certifications matter. In most regulated industries, a platform without them is a non-starter.

But there is a misunderstanding that keeps catching engineering teams off guard:

A compliant cloud platform does not make your containerized application compliant.

A compliance badge confirms that the provider secured its data centers, hypervisors, and managed control plane during an audit window. It says nothing about the container image a developer shipped this morning that runs as root with a database password hardcoded in it. You can pass an audit in March and still fail an audit, or have an incident, by November.

The numbers suggest this gap is common. In Red Hat's 2024 State of Kubernetes Security survey of 600 DevOps, engineering, and security professionals, 40% reported a misconfiguration incident in the previous 12 months and 26% reported a failed audit, per ARMO's tabulation of the report data. An auditor's PDF does not patch a drifted worker node (one of the servers your containers run on) or block an unencrypted connection.

So what do the frameworks actually ask of you, and who owns each piece?

Who owns what: the three-layer model

Compliance obligations for containers split across three layers. The failures cluster in the middle one.

The 3-Layer Container Compliance Model

Layer 1: Infrastructure and managed control plane (provider owned)

This is the layer the certification badges actually describe. Your provider runs the data centers, the hypervisors, and the Kubernetes control plane. For SOC 2 and ISO 27001, they evidence that:

  • Physical access to hardware is logged and restricted.
  • Control plane data, including the etcd database that holds every cluster setting and secret, runs on provider-managed masters and is encrypted in transit and in backups. On IBM Cloud Kubernetes Service (the platform I work on), encrypting the live copy with your own key (IBM Key Protect) is an option you turn on yourself.
  • Customer environments are separated at the hypervisor.

Layer 2: Platform and cluster configuration (shared)

This is where audits most often go wrong, because the split is easy to misread. The provider hands you a hardened starting point. Keeping it hardened is your job:

  • Worker node patching. A published patch protects nothing until you apply it. IBM provides patched worker node images for IBM Cloud Kubernetes Service and Red Hat OpenShift on IBM Cloud, and you apply them by updating, reloading, or replacing your nodes. IBM's documentation suggests doing it monthly on IBM Cloud Kubernetes Service.
  • Benchmark alignment. Staying within the Center for Internet Security (CIS) Kubernetes and OpenShift benchmarks as configuration changes over time.
  • Cluster access. Least-privilege roles (RBAC) and service accounts with no more reach than they need.

Layer 3: Application and workload runtime (customer owned)

Whatever cloud you use, the workload is yours:

  • One compromised app shouldn't hand an attacker the machine underneath it, which means containers should run as a non-root user.
  • Known vulnerabilities in base images (the starting-point images containers are built from) and dependencies should be caught in the build pipeline, before they reach production.
  • A single compromised pod (the smallest unit that runs your containers) shouldn't be able to reach every other pod, which takes network policies that limit who can talk to whom.
  • Passwords and keys belong in a key management service, not in plaintext configuration files.

What the major frameworks look for in containers

Each framework views your container estate through a different lens. This matrix is my mapping of each framework onto Kubernetes controls, not a list the frameworks themselves prescribe:

Table mapping SOC 2, PCI DSS, HIPAA, and CIS Benchmarks to their core mandate, the Kubernetes controls that enforce it, and the common gap where teams fail audits. Author's mapping, not framework-prescribed.

Passing the annual audit with a folder of console screenshots is the easy part. Staying passed is the work.

Where compliance breaks down in practice

In the platform teams I talk to, failures rarely come from forgetting a regulation. They come from operational drift that nobody decided on.

1. Configuration drift and unpatched nodes

A cluster launched on January 1st may be fully hardened. Over the next six months, engineers ship emergency hotfixes, grant temporary full-admin access (cluster-admin) for troubleshooting, or switch off deploy-time safety checks to get a release out. Nobody plans to leave those in place. Without automated drift detection, the live cluster can wander away from the baseline you were audited against.

Even on IBM Cloud Kubernetes Service, you apply the worker patches yourself. A managed service shrinks your checklist. It doesn't empty it.

2. The default-root problem

Some popular public container images run as root out of the box. If an attacker breaks out of the container runtime through a flaw in the operating system kernel, root inside the container makes that escape far more damaging. PCI DSS requires application and system accounts to hold only the least privileges necessary (Requirement 7.2.5), so "it's just the image default" is a hard answer to defend.

3. Plaintext traffic between services

Teams often assume that a private network makes service-to-service traffic safe. The frameworks are less absolute than people think. As the rule stands today, HIPAA treats transmission encryption as an "addressable" safeguard: assess whether it's reasonable and appropriate, and if not, document why and use an equivalent alternative. PCI DSS requires strong cryptography for cardholder data crossing open, public networks. Neither spells out mutual TLS between pods (both sides of a connection verifying each other). But "it's inside our VPC" (our private cloud network) is an answer an auditor will ask you to defend, and plaintext HTTP carrying sensitive data is a tough one to defend.

The honest tradeoff: guardrails versus developer velocity

Here's the tension every platform leader runs into:

The stricter your enforcement, the more friction developers feel.

Strict enforcement breaks software you bought. Turn on Kubernetes' strictest built-in profile (the restricted Pod Security Standard), or OpenShift's equivalent rules (Security Context Constraints) that forbid root and privilege escalation, and some off-the-shelf vendor packages simply won't start. Friction is already the norm: Red Hat's survey found that 67% of respondents had delayed or slowed application development because of security concerns, and strict enforcement adds its own.

The team that gets hurt most is a small platform group supporting mostly vendor-packaged software. For them, strict enforcement from the first week mostly produces exemption tickets. Developers then wait days for approvals, or quietly spin up unmanaged clusters where nobody is watching.

The way out isn't weaker controls. Start in audit mode (Kubernetes' Pod Security Admission can warn and log without blocking), fix the worst offenders, then tighten. Pair that with paved paths: certified internal base images, pipeline scanning that catches misconfigurations before deployment, and self-service secrets management. The secure option has to be the easy one.

How the gap gets closed in practice

Capability matters more than brand here. Three kinds of capability help with parts of the gap, and each has open-source or other-cloud equivalents (policy engines such as Kyverno and OPA Gatekeeper, which block or flag non-compliant configurations at deploy time, and other providers' security posture tools). On IBM Cloud, they look like this:

  1. Continuous posture checking. IBM Cloud Security and Compliance Center Workload Protection validates configurations against frameworks such as the IBM Cloud Framework for Financial Services, DORA, and NIST, and gives remediation instructions when a control fails. The Financial Services policy includes Kubernetes and Docker controls that run through an agent in your cluster. The frameworks it lists aren't SOC 2, PCI, or HIPAA, and IBM's documentation doesn't describe drift detection for it, so check what it covers before you rely on it.
  2. Hardened platform defaults. IBM Cloud Kubernetes Service ships worker nodes on an operating system image built to the CIS benchmarks, and IBM applies patch updates to the managed cluster master. That shrinks your starting gap; it does nothing about drift six months later.
  3. Hardware-enforced isolation, for a narrow set of workloads. IBM Cloud Confidential Containers use hardware-based memory encryption (Intel TDX) to protect data while it's in use. It is currently an experimental feature on Red Hat OpenShift on IBM Cloud, so treat it as something to evaluate, not something to build a compliance program on. Most workloads don't need it, and it won't fix a root container or a forgotten cluster-admin binding. It addresses a different threat.

The takeaway

A certified cloud gives you a secure foundation. Staying compliant on top of it takes continuous hygiene: drift detection, patched nodes, non-root containers, and paved paths that make the secure choice the easy one.

But you tell me: if you ran a live drift check on your "compliant" clusters today, how many would pass? And where do you think I've got the split wrong?

πŸ“° Read the original article on Dev.to Security

Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes β€” full credit and traffic to the original publisher.