Skip to content

All posts

Kubernetes

NIST SP 800-204 microservices and Kubernetes: which controls policy can enforce

Ritesh Patel

Kubernetes: NIST SP 800-204 microservices and Kubernetes: which controls policy can enforce

NIST SP 800-204 never names Kubernetes. Its 13 security strategies, MS-SS-1 to MS-SS-13, cover gateways, tokens, registries and monitoring. An admission policy can check parts of two of them: infrastructure quotas and the resource limits and role bindings of mesh components. A CI check can cover one more. The other ten need runtime controls or a documented process.

What SP 800-204 asks for

NIST Special Publication 800-204, Security Strategies for Microservices-based Application Systems, was published in August 2019 and is listed as final. It covers the architecture of microservice applications: API gateways, service meshes, service registries and the traffic between services. Section 4 discusses each area, and Table 6 lists the strategies with their identifiers.

The document calls these items strategies, not controls, so this guide uses the same word. It does not assign them to a platform. The only reference to an “orchestrator platform” is in the segmentation strategy. The Kubernetes objects in the table below are our reading of the text, not NIST guidance.

Which strategies policy can enforce

The table pairs each strategy with the Kubernetes object it would touch and says where a check can run. The three labels match the ones used in our SP 800-218 post, so the two mappings can be compared row by row. The strategy column is paraphrased. Quoted wording comes from Table 6.

Strategy What it asks, paraphrased Kubernetes object Where a check can run
MS-SS-1 Sensitive APIs need signed or verified tokens, not bare API keys. The token key stays out of code Pod env, Secret, ConfigMap Enforceable in CI only. A scan of manifests can find key material. Token checks run at request time
MS-SS-2 Access policies are provisioned to an access server, coarse at the gateway and fine near the service Gateway and access server config Not enforceable by policy. Decisions happen per request
MS-SS-3 Registries run on dedicated servers or in a mesh, over TLS, with validated registrations Registry servers Not enforceable by policy
MS-SS-4 Clients call a single gateway URL, and traffic uses mutual TLS Service, Ingress, mesh config Not enforceable by policy. The handshake happens at runtime
MS-SS-5 Monitoring at gateway and service, with validation errors and crashes logged Logs, dashboards, IDS Not enforceable by policy
MS-SS-6 A circuit breaker in the proxy Proxy config Not enforceable by policy
MS-SS-7 Health checks run in the background to feed load balancing Load balancer Not enforceable by policy
MS-SS-8 Quotas and limits based on infrastructure and application requirements ResourceQuota Enforceable at admission for the infrastructure quota. Application usage plans and replay detection are not
MS-SS-9 Canary and blue/green traffic routed through a central node and monitored Traffic routing Not enforceable by policy
MS-SS-10 Session data stored securely, and internal authorization tokens not passed back to users Session store, gateway Not enforceable by policy
MS-SS-11 Run-time prevention of credential abuse, and scanning of uploads for malware IDS, file scanners Not enforceable by policy
MS-SS-12 API gateway connected to an identity provider, with token exchange between gateways Gateway config Not enforceable by policy
MS-SS-13, resource limits Mesh components have configured resource usage limits Pods in the mesh namespace Enforceable at admission. A ResourceQuota makes the API server require requests or limits on new pods
MS-SS-13, role bindings Avoid configurations that lead to privilege escalation RoleBinding, ClusterRoleBinding Enforceable at admission. A policy can reject bindings to cluster-admin
MS-SS-13, segmentation Layer 3 segmentation configured in the orchestrator platform for sensitive applications NetworkPolicy Enforceable in CI only. A default-deny policy per namespace is a check across a set of objects

The admission rows

Three rows can be checked when the object is created. The quota row is the strongest, because the API server already refuses a request that breaks a quota. The role binding row is a stricter rule than Kubernetes applies by default. The resource limit row depends on whether your mesh components run as pods in a namespace that has a quota. Check on your own cluster whether injected mesh sidecars go through the same checks as the pods you write.

The CI row

Segmentation is a property of a namespace, not of one object. An admission rule sees each NetworkPolicy as it arrives, so it cannot easily confirm that every namespace has one. A check that runs on rendered manifests in the pipeline can confirm that. It can fail the build when a namespace has no default-deny policy. The MS-SS-1 row works the same way: a scan can flag key material in code or config, but nothing in the admission path can see whether a token is signed.

Strategies outside policy

Ten strategies describe how a request is authenticated, routed, monitored or throttled while the system runs. A pod spec does not show any of that. Record each one with the gateway, identity provider, monitoring tool or process that covers it, and name an owner. An assessor will ask who holds each of these, and the answer should not be “the cluster policy.”

Kubernetes settings behind the admission rows

The three admission rows rely on specific Kubernetes behaviour. Read these before you write the rule, because each one changes what gets blocked.

Quotas and the resources they require

A ResourceQuota limits aggregate consumption in a namespace, and the Kubernetes page says a request that violates it is rejected with 403 Forbidden. For CPU and memory, the quota also requires every new pod in the namespace to set requests or limits. The page says the control plane “may reject admission” for a pod that does not, so a namespace with a quota fails loudly, not silently.

Workload controllers behave differently. The docs say that creating a Deployment that exceeds available resources “succeeds”, and the Deployment may then fail to create all of its pods. A policy that checks only the Deployment will pass it, so check the pods as well, or check the Deployment’s status.

Role bindings and cluster-admin

Kubernetes already stops users from escalating through roles. You can create or update a role only if you hold all the permissions in it, or if you have the escalate verb. For role bindings, the rule is similar: you need every permission in the referenced role, or the bind verb on that role. The API enforces this whether or not the RBAC authorizer is in use.

The gap is deliberate grants. The cluster-admin role gives full control over every resource in the cluster when it is bound with a ClusterRoleBinding, and full control within a namespace when bound with a RoleBinding. A rule that rejects a binding to cluster-admin in an application namespace is stricter than the default, and it is the kind of check MS-SS-13 describes.

Network isolation for the CI check

By default a pod accepts all inbound connections. A NetworkPolicy changes that for the pods it selects. The default-deny policy below selects every pod in the namespace and allows no ingress. Apply it in each namespace, because the example file sets no namespace.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-ingress
spec:
  podSelector: {}
  policyTypes:
  - Ingress

A CI check can look for this shape in every namespace. It should confirm that a policy with an empty podSelector lists Ingress in policyTypes. It should also record that the check says nothing about egress.

Gotchas from the fine print

A few details in the Kubernetes and NIST text change what a mapping can claim.

The NIST segmentation strategy says Layer 3, while the Kubernetes NetworkPolicy page says NetworkPolicy “is defined for layer 4” connections. The two are not the same. A policy that isolates a pod at layer 4 does not show that the network is segmented at layer 3, and an assessor may expect you to say which layer your controls cover.

The default-deny example affects ingress only. Its docs say that it “does not affect isolation for egress from any pod.” A mapping that counts it toward outbound segmentation is wrong.

A quota violation fails the request with 403 Forbidden, and the error text names the constraint. A pipeline that applies manifests will see a failed apply, not a passing one with a warning.

A checklist for mapping SP 800-204

  1. Read Table 6 and list the strategies that apply to your architecture. Mark the ones for components you do not run, such as a mesh or a gateway, and say why.
  2. For each remaining strategy, write the Kubernetes object it touches, or mark it as outside the cluster.
  3. For quota, role binding and pod resource rows, write an admission rule. Run it in a non-blocking mode first, and read the results per workload.
  4. For the segmentation and key-material rows, add a CI check that fails the build when a namespace lacks a default-deny policy or a manifest contains key material.
  5. Record each outside-policy strategy with an owner and the tool or process that covers it. Store the mapping in version control, with the Kubernetes and NIST versions it was checked against.

Enforcing this with Kyverno

Kyverno’s documentation says it can validate, mutate, generate, or cleanup (remove) any Kubernetes resource and that it uses YAML and CEL to author policies, so admission rules such as the three rows above are written in that form. The CI rows need a check that reads rendered manifests, and a policy engine that runs at admission does not replace that. The Kyverno project page covers the tool, and the continuous compliance hub covers the wider approach to evidence and standards.

For the same control-by-control method on other frameworks, read the SP 800-190 controls post, the NIST CSF 2.0 post and the SP 800-218 post.

Sources checked on 2026-11-20: the NIST SP 800-204 publication page and its PDF, the Kubernetes NetworkPolicy, ResourceQuota and RBAC pages, and the Pod Security Admission page.

Frequently asked questions

Does NIST SP 800-204 mention Kubernetes?

No. SP 800-204, Security Strategies for Microservices-based Application Systems, describes API gateways, service registries, service meshes and tokens. It refers to an orchestrator platform only when it discusses network segmentation. Any mapping to Kubernetes objects, including the one in this guide, is a reading of the text, and an assessor should be told that.

Which SP 800-204 strategies can an admission policy enforce?

Two of the 13 strategies have parts an admission policy can check. MS-SS-8 covers infrastructure quotas, which the API server enforces through ResourceQuota. MS-SS-13 covers resource limits on mesh components and role bindings that could escalate privileges. Token handling, access decisions, monitoring and the other strategies need gateways, runtime tools or a documented process.

Does a default-deny NetworkPolicy satisfy the SP 800-204 segmentation strategy?

Only in part. The strategy asks for Layer 3 segmentation configured in the orchestrator platform, and Kubernetes documents NetworkPolicy as a layer 4 control. A default-deny ingress policy isolates every pod in its namespace for ingress, but it does not restrict egress. Count it as evidence for one part of MS-SS-13, and record the mesh and egress controls separately.

Should SP 800-204 admission rules block pods or only report them at first?

Report first. Run a new rule in whatever non-blocking mode your policy engine offers, read the results for each workload, and record exceptions with an owner. Pod Security Admission has audit and warn modes for this, but it covers only pod security, not quotas or role bindings. Switch to blocking only when the namespaces the rule covers have no open failures.

Ritesh Patel, Founder & VP Product, Nirmata

Ritesh Patel is a founder of Nirmata and leads its products. He writes about governing AI coding agents, MCP security and Kubernetes policy as code.

LinkedIn

Nirmata Control HubOne control plane for Kyverno policies.
Share

Stay up-to-date with the latest in AI, governance, and infrastructure

Subscribe to our free monthly newsletter to get industry news, DevOps tips, and articles right to your inbox on Kyverno, containerization, Kubernetes deployment & management and more.