Build1 publisher3 min readPublished
Cilium 1.19 replaces the per-pod Envoy with one eBPF program per node
Cilium 1.19 puts routing, mTLS and observability in one eBPF program per node, with a single Envoy per node for Layer 7. The 100 GB of RAM the post says that frees assumes 1,000 pods at the top of the sidecar range.
The Engineer · Build desk

What happened
- A dev.to writeup puts 67 percent of Kubernetes teams on at least one eBPF-based tool in production, citing the CNCF Annual Cloud Native Survey 2026.
- It reports Cilium, the eBPF-based CNI, as the standard network plugin on GKE, EKS and AKS, replacing kube-proxy with eBPF packet processing.
- Tetragon enforces policy inside the kernel, and the published example kills a shell launched in a pod without CAP_SYS_ADMIN using SIGKILL.
Compiled by The EngineerSomething wrong?How this is made
Why it matters
- cost The RAM saving accrues where pods are packed densely; a cluster running ten pods per node still needs an Envoy and an eBPF program on every node, and pays the migration cost regardless.
- constraint The kernel verifier becomes part of the release path: an eBPF program that cannot be proved to terminate does not load, and fixing it means changing the program.
- exposure Path-matched kernel enforcement gives one YAML selector the power to terminate processes across a node, and the kill lands before any application-level handler can respond.
- contradiction The post's two descriptions of Cilium's status on the managed services do not agree, so a team cannot tell from this account whether it inherits the CNI by default or chooses it from a menu.
The kube-proxy replacement is where the post's biggest number sits: up to 100 times the performance of iptables with thousands of services [7]. The post explains this as a data structure swap. Cilium keeps service state in BPF maps, which are hash tables with O(1) lookup, while iptables walks its rules linearly [8]. Linear cost scales with the rule count, so the ratio between the two closes as the Service count falls [9]. For the figure to transfer you need thousands of Services in one cluster and enough packet rate that service lookup sits on the hot path.
What a platform team takes on is the loader. Every eBPF program passes a kernel verifier before it runs, and only programs guaranteed not to crash or loop forever are JIT-compiled to native machine code [5]. Kernel side and userspace side share state through BPF maps, which both can read and write at once [6]. Verification happens at load, so an agent or policy that fails, fails at rollout.
The mTLS change is the one the post puts numbers on. Cilium 1.19, presented at KubeCon EU 2026 in Amsterdam, drops the injected Envoy per pod (roughly 50 to 100 MB of RAM each) and runs one eBPF program per node covering routing, mTLS and observability for every pod on it [12][13]. Layer 7 features still need a proxy, so one Envoy runs per node [14]. That per-node Envoy is what enforces a CiliumNetworkPolicy written down to HTTP method and path, such as GET on /api/.* [11]. The post's saving is 1,000 pods times 100 MB, or 100 GB reserved for proxy infrastructure [15]. At the bottom of its own range the same cluster is 50 GB [1]. The replacement cost tracks node count: 1,000 pods at 50 per node needs 20 node-level Envoys, and the same 1,000 pods at 10 per node needs 100 [2].
OpenTelemetry eBPF Instrumentation, released in beta by Splunk at the same event, reads telemetry out of the kernel with no code change, no service restart and no sidecar agent [16]. That is aimed at Go, Rust and C++ binaries and at legacy applications where changing the source is hard or impossible [17]. The post says evaluations typically uncover 15 to 40 percent of cluster traffic that distributed tracing could not see [19]. That range is traffic nobody instrumented. OBI integrates with existing OpenTelemetry SDKs and does not duplicate data from services already instrumented [18], so a fleet already emitting spans from everything has nothing for it to find.
Tetragon detects policy violations and enforces them in the kernel. The post's example detects /bin/bash or /bin/sh running in pods without CAP_SYS_ADMIN and terminates the process with SIGKILL in real time [20]. The published TracingPolicy attaches a kprobe to security_bprm_check, reads argument 0 as a linux_binprm, and matches binaries with an In operator over /usr/bin/sudo and /bin/su [21]. Matching is on the binary path. Any process whose executable sits at a listed path is a match, so an image that ships a legitimate tool at that path gets killed by the kernel before userspace sees anything [3].
On how much of this arrives whether or not you picked it: the 67 percent figure is attributed to the CNCF Annual Cloud Native Survey 2026, and the post does not give the sample or the question wording [22]. Its account of Cilium's status is not consistent either. One paragraph calls Cilium the standard network plugin for GKE, EKS and AKS [2]; another describes it as "shipped as a standard option or even as the default in GKE, EKS, and AKS" [3].
What to watch
- Whether GKE, EKS and AKS documentation lists Cilium as the default CNI or as a selectable option, by cluster version, which would settle the post's two descriptions.
- Publication of the CNCF Annual Cloud Native Survey 2026 sample and question wording behind the 67 percent figure.
- Whether Cilium 1.19's sidecar-free mTLS reaches a stable release, and whether one Envoy per node holds Layer 7 throughput at high pod density.