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:
- Why does this component need host networking?
- Which node pools may run it?
- Which destinations must it reach?
- Which control enforces that narrower connectivity?
- 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.