microsegment.io

segment all the things

Your application namespace has default-deny policies. What stops a process on its worker node from reaching the next worker, the management network, or an unrelated database?

That needs a separate answer.

In the earlier GPU monitoring article, I touched on host-network enforcement. This is the implementation follow-through: give the node its own containment contract, rather than treating pod policy coverage as cluster coverage.

Read The Boundary Literally

The Kubernetes NetworkPolicy documentation makes several important distinctions. Enforcement requires a supporting network plugin. Ingress isolation still permits traffic from the pod’s own node. Handling of hostNetwork pods depends on the implementation; a common behavior treats their traffic as node traffic. Standard NetworkPolicy also cannot select nodes by their Kubernetes identities.

None of that means pod policies are useless. It means a successful pod-to-pod denial is evidence about that path, not every path through the cluster.

My recommendation: review three boundaries separately. Ordinary pods, host-network workloads, and the node operating system should each have an explicit policy owner and acceptance tests.

Start With A Node Connectivity Contract

Before choosing rules, write down which node-originated connections are actually required. Use observed flows as input, not automatic approval.

For each node pool, document:

  • Control-plane destinations and required ports.
  • Image registry, DNS, time, telemetry, and update dependencies.
  • Any node-to-node traffic required by the deployed network and storage implementation.
  • Management access sources, including emergency administration.
  • External application dependencies that genuinely originate from the host.

For every entry, record direction, destination, protocol, business reason, owner, and enforcement point. Do not put “cluster traffic” in the destination column and call the design finished.

A useful review question is: if this node were compromised, which destinations on this list would still be acceptable?

Separate what is necessary to operate the node from what merely happened during the observation window. A temporary troubleshooting connection should not become permanent architecture.

Treat Host Networking As An Exception With An Owner

Kubernetes Pod Security Standards prohibit host namespace sharing, including hostNetwork, in the Baseline profile; Restricted builds on that baseline. Those are admission requirements, not a replacement for traffic enforcement.

For ordinary application namespaces, my starting point would be enforced admission controls that disallow host networking. Where a platform component needs it, require a documented exception rather than an informal exemption for everything in a system namespace.

The exception record should answer:

  1. Why does this component need host networking?
  2. Which node pools may run it?
  3. Which destinations must it reach?
  4. Which control enforces that narrower connectivity?
  5. Who retests it after a platform upgrade?

Dedicated nodes can make the policy easier to reason about. I would not count placement alone as a network deny rule.

Add Host Enforcement Without Breaking The Cluster

There are implementation-specific ways to enforce the host boundary. For example, Cilium documents a host firewall whose policies select nodes and cover the host namespace, including host-networking pods. It does not replace ordinary pod policy. Its guide recommends auditing impact before enforcement and warns that audit mode does not persist across agent restarts.

That is a useful example, not a universal configuration recipe. Validate support, interfaces, traffic coverage, and behavior for your deployed version. Do not copy a demonstration allowlist into a production cluster and assume it represents your control-plane dependencies.

My rollout sequence would be:

  • Pick a non-critical canary node pool with a representative workload.
  • Establish a tested recovery route that does not depend on the connection being restricted.
  • Observe proposed denies and have the platform owner classify required dependencies.
  • Move the canary into enforcement and verify both required traffic and forbidden paths.
  • Repeat on the next pool only after the evidence is clear.

Audit output is useful preparation. A denied connection under enforcement is the acceptance evidence.

Test The Paths That Pod Tests Miss

Use disposable workloads and approved test destinations. Avoid probing production management services just to demonstrate a point.

Build a small test matrix with separate source identities:

Source Destination Intended result
Ordinary application pod Unrelated application backend Deny
Approved host-network test workload Unrelated database test endpoint Deny
Node-originated test process Management-network test listener Deny
Worker node Required control-plane endpoint Allow
Approved administrator Designated node management service Allow
Unapproved administration source Same management service Deny

For each row, collect the connection result and the relevant enforcement verdict. A timeout without policy evidence could be a routing failure. An authentication rejection proves that the service was reachable, not that segmentation blocked it.

Repeat representative tests after rescheduling the workload to another node pool. Include node replacement and network-agent restart in the change-validation plan. Record the platform and policy versions with the results so the next team can reproduce them.

These are proposed acceptance tests, not results from a particular cluster.

Measure Coverage By Boundary

I would report ordinary pod coverage and host coverage separately. For each node pool, show whether its connectivity contract is approved, enforcement is active, and negative tests have passed. Mark unknowns as unknowns.

The useful question is not how many YAML files exist.

It is whether a compromised workload or host still has an unnecessary route into the next trust zone, and which tested control stops it.

Sources