Which Windows versions are supported?
Windows Server and Windows desktop editions, using kernel-level flow capture where it is available and a snapshot-diff collector where it is not. Enforcement is through Windows Defender Firewall.
Platforms
Every host you run,
under the same policy.
Two operating systems, containers governed individually, Kubernetes workloads enforced by NetworkPolicy, and security groups provisioned in both clouds. Hosts you can't install on are fenced by their neighbours.
Coverage
What observes, and what enforces.
Segmenta separates seeing from enforcing, because they fail differently. This is which mechanism does which, per platform.
| Platform | How it observes | How it enforces |
|---|---|---|
| Windows Server & desktop | Kernel-level capture, with the owning process on every connection. Snapshot-diff fallback where kernel capture is unavailable. | Windows Defender Firewall rules, compiled from intent and applied in a safe order. |
| Windows domain workstations | A separate, lightweight workstation agent reports which addresses the PC holds. Identity only: no flows, no firewall work on the PC. | On your servers. Their rules name the workstations' Role, and its address list follows each PC across DHCP, Wi-Fi and VPN. |
| Linux servers & VMs | Connection tracking and listener inventory, attributed to the owning process. | nftables, applied as a delta so a policy change never rewrites a live ruleset wholesale. |
| Docker containers | Container inventory plus per-container flow attribution, so a container is a first-class peer on the map — not a blur behind the host's IP. | Per-container rules on the host's own filter chain. |
| Kubernetes & OpenShift | Connections read by a connector inside the cluster, from Hubble on Cilium or from each node's connection table elsewhere (Calico, OpenShift, Amazon EKS, Google GKE and Azure AKS), attributed to the Deployment, StatefulSet or DaemonSet behind each pod. | One NetworkPolicy per workload, inbound and outbound, compiled from its Role's rules and applied by the connector. |
| Azure | NSG flow logs read back as evidence alongside agent-observed traffic. | Network security groups provisioned from the same rules you author everywhere else. |
| AWS | VPC flow logs read back as evidence alongside agent-observed traffic. | Security groups provisioned from the same rules. |
| Un-agented hosts | Seen from the other side — by every managed host that talks to them. | Fenced by those neighbours. Nothing is installed on the host itself. |
Containers
A host is a host.
Containers aren't a second licence. We enforce inside Docker on the server you already pay for, and a container host counts once, however many containers it runs.
Containers are peers, not noise
Each container appears on the dependency map in its own right, with its own flows and its own rules — rather than every container on a box collapsing into one host-shaped blob.
Rules follow the container
Policy is written against the role a container plays, so it survives the container being recreated with a new address on the next deploy.
Host-network containers are handled honestly
A container sharing the host's network stack has no address of its own to fence. Segmenta says so rather than emitting a rule that would silently match nothing.
Published ports are not a bypass
Ports published from a container are governed like any other listener, including when a host is quarantined.
Kubernetes
A workload is a member, like a container.
A Deployment, StatefulSet or DaemonSet joins a Role on the same Applications board as your servers and containers. Its rules are written once and compiled to a NetworkPolicy, so pods that come and go keep the same policy.
- A connector in the cluster dials out. Nothing reaches in, and no cluster credential leaves
- Read-only until you protect it; it can write only network policies, never pods or secrets
- See what protecting would refuse before the connector applies anything
- Policies another tool manages are reported as conflicts, never overwritten
- What the cluster itself needs, DNS and the API server, is proposed as a required rule, so protecting never cuts it off unannounced
- Cilium, Calico or OpenShift's OVN-Kubernetes, on Kubernetes 1.31 to 1.37
- Amazon EKS, Google GKE and Azure AKS, enforced by the network policy each one runs
Workload · shop/api
NetworkPolicy · applied
shop/frontend → shop/api tcp/8080allowed
monitoring/uptime → shop/api tcp/8080allowed
SRV-BATCH-01 → shop/api tcp/8080allowed
everything else → shop/apirefused by policy
Role: API · the same rules as the API servers
Legacy & appliances
Ring-fence what you can't touch.
There is always a box you cannot install on: the appliance under support, the machine running the thing nobody understands, the server whose vendor voids the warranty. Those hosts still get a fence — enforced by the managed hosts around them.
- Allow only the flows the host actually needs
- Deny the rest at every managed neighbour
- No agent, no reboot, no change to the fragile host
- Same intent model and the same audit trail as everywhere else
Un-agented host · SCADA-HMI-02
fenced by 4 neighbours
SRV-APP-01 → SCADA-HMI-02 tcp/502allowed
SRV-APP-02 → SCADA-HMI-02 tcp/502allowed
SRV-HIST-01 → SCADA-HMI-02 tcp/1433allowed
everything else → SCADA-HMI-02denied at the peer
Enforced on the neighbours, not on the appliance
Questions
Platform questions.
The ones that decide whether Segmenta fits your estate.
Which Linux distributions?
Any distribution using nftables. Enforcement is applied as a delta against the existing ruleset rather than a wholesale rewrite, so rules you manage yourself are not clobbered.
Do containers cost extra?
No. Containers on a host you already pay for are included, and a container host is billed as one host — not as several workloads.
Is Kubernetes supported?
Yes, on Kubernetes 1.31 to 1.37 and on OpenShift, with Cilium, Calico or OVN-Kubernetes, and on Amazon EKS, Google GKE and Azure AKS. A small connector runs inside the cluster and dials out to Segmenta, so nothing reaches in. It reads connections from Hubble on Cilium, or from each node's connection table elsewhere, and attributes them to the workload. A Deployment, StatefulSet or DaemonSet joins a Role like a Docker container does, and that Role's rules become a NetworkPolicy, inbound and outbound, that the connector applies once you protect the workload. It starts read-only: writing NetworkPolicies is a permission you grant. Segmenta won't protect a cluster where nothing would enforce the policy, such as one on flannel alone, or EKS before its VPC CNI's network policy agent is switched on. On AKS with Azure's network policy manager, connections the policy blocks can't be shown, because it logs none. Block rules are enforced as a deny that wins over any allow on Cilium, Calico, OpenShift's OVN-Kubernetes, the Amazon VPC CNI and GKE's Dataplane V2; on Azure's network policy manager a Block rule is shown as not enforced.
What happens to a host you can't install on?
It is protected by the managed hosts around it. You allow the flows it needs and every managed neighbour denies the rest. Nothing is installed on the host itself, and it is not billable.
Does the cloud support replace my agent?
No — it complements it. On a cloud instance running the agent you get process-level detail; the security-group provisioning governs the instances and services where an agent cannot run.
Start with the hosts you already have.
Install on a handful and watch the map draw itself. Nothing is enforced until you say so.