Cilium Service Mesh 2026: Sidecarless eBPF Deep-Dive

Cilium Service Mesh 2026: Sidecarless eBPF Deep-Dive

Cilium Service Mesh 2026: Sidecarless eBPF Deep-Dive

Last Updated: November 19, 2026

For years the pitch for a sidecarless mesh was simple: move the proxy’s job into the Linux kernel and delete thousands of per-pod Envoy containers. In 2026 the Cilium service mesh quietly conceded part of that argument. Its kernel-side mutual authentication is now deprecated, and pod-to-pod mTLS runs through ztunnel, a per-node userspace proxy that Istio built first. That matters now because Cilium 1.20 is the current stable line, the old install guides on the web still enable the deprecated feature, and the Cilium-versus-Istio-ambient debate has shifted under everyone’s feet. This rewrite gives you an accurate 2026 model of how the mesh actually works. You get its three separate planes (eBPF, Envoy and ztunnel), what each costs and where each breaks. You also get a way to decide between Cilium alone, Istio ambient, or a hybrid.

What this covers: the sidecar tax, the three-plane architecture, packet walk-throughs, a version-pinned setup for Cilium 1.20, the ztunnel mTLS flow, the real Istio ambient comparison, failure modes, and a rollout checklist.

Context and Background

A service mesh gives every workload three things it would otherwise have to build itself: encrypted and authenticated connections, traffic policy, and telemetry. The classic implementation, popularised by Istio and Linkerd, injects a proxy container next to each application container. That proxy terminates mTLS, enforces Layer 7 (L7, application protocol) rules and emits metrics for every request.

The sidecar model works, and it defined the category for half a decade. Its costs are structural, though. Every request between two meshed services crosses two extra userspace proxies. Every pod carries a proxy that uses memory even when idle. A proxy upgrade means restarting every workload, because the proxy lives inside the workload pod. Startup ordering and Job shutdown needed special handling for years, and Kubernetes only addressed them properly with native sidecar containers, which we cover in our guide to Kubernetes native sidecar containers and startup ordering.

Two projects set out to remove the per-pod proxy. Cilium, the eBPF-based CNI (Container Network Interface) plugin, argued that most mesh work is really networking work and belongs in the kernel datapath it already owns. Istio answered with ambient mode, which splits the mesh into a per-node L4 proxy called ztunnel and optional per-namespace L7 “waypoint” proxies. Cilium graduated from the CNCF on 11 October 2023, and by its tenth anniversary release in early 2026 it reported more than 2,900 commits from over 1,000 developers in that cycle, per InfoQ’s Cilium 1.19 coverage.

The 2026 twist is convergence. Cilium 1.19 added a beta integration with the same upstream ztunnel that Istio created. Cilium 1.20, the current stable line, made ztunnel more operable and deprecated the older mutual-authentication design. The two sidecarless meshes now share a component on the mTLS path. Their real differences have moved to the L7 plane, the CNI coupling and the policy model. That is the lens this post uses. For the decision-record view of eBPF versus sidecars in general, see our eBPF vs sidecar service mesh ADR.

How the Cilium Service Mesh Works: Three Planes, No Sidecars

The Cilium service mesh is a sidecarless mesh built into the Cilium CNI. L3 and L4 routing, load balancing and network policy run as eBPF programs in the kernel. L7 policy and traffic management use a shared Envoy proxy per node. Pod-to-pod mTLS, still beta in Cilium 1.20, runs through a per-node ztunnel proxy. No proxy lives inside your pods.

Cilium service mesh node architecture showing the eBPF datapath, cilium-envoy, ztunnel, agent and Hubble

Figure 1: The components of a Cilium service mesh on a single Kubernetes node in Cilium 1.20.

Figure 1 shows one node. Application pods contain only their own containers. The Cilium agent watches the Kubernetes API, compiles services and policies into eBPF programs and maps, and configures two node-level proxies. The cilium-envoy DaemonSet handles traffic that needs L7 parsing. The ztunnel DaemonSet handles traffic in namespaces enrolled for mTLS. Hubble exports flow records from the datapath, and the cluster-scoped Cilium operator handles IP address management (IPAM), identity garbage collection and similar global work.

The most useful mental model is that a Cilium service mesh is not one mesh. You are running three planes that you can switch on independently, each with its own cost and failure domain. Most confusion in Cilium mesh discussions comes from treating them as one thing.

Plane 1: the eBPF datapath does the bulk of the work

eBPF (extended Berkeley Packet Filter) lets the kernel run small, verified programs at hook points. Cilium attaches programs at the traffic-control (TC) ingress and egress hooks on each pod’s network device, at socket hooks for connect-time load balancing, and optionally at XDP (eXpress Data Path) on the physical NIC. These programs perform service load balancing, NAT, connection tracking and identity-based policy decisions as packets move through the stack.

Policy in Cilium is identity-based rather than IP-based. Each set of pods with the same security-relevant labels gets a numeric security identity. The agent distributes the IP-to-identity mapping to every node, and the eBPF policy maps are keyed by identity. A pod can restart with a new IP and keep its policy, because the policy never referenced the IP.

The practical payoff is that plain L3 and L4 traffic never touches a userspace proxy. The Cilium L7 policy documentation is explicit that only traffic matching an L7 rule is redirected to Envoy. Everything else is forwarded or dropped in the kernel. The same machinery can replace kube-proxy entirely (kubeProxyReplacement=true), removing iptables-based service routing. For the load-balancing internals, including Maglev consistent hashing, see our XDP and eBPF Layer 4 load balancer deep-dive.

This plane is also why Cilium blurs CNI and mesh. In a sidecar mesh, the CNI and the mesh are separate layers you install and upgrade separately. In Cilium they are the same eBPF datapath. That is an operational simplification, and it is also a coupling: choosing Cilium’s mesh means choosing Cilium as your CNI.

Plane 2: one shared Envoy per node for L7

Parsing HTTP, gRPC or DNS inside a verified kernel program is impractical. Cilium therefore redirects only matching flows to a node-local Envoy. In older releases this Envoy ran embedded inside the agent pod. Since Cilium 1.16, Envoy as a DaemonSet is the default for new installations, which separates the proxy’s lifecycle from the agent’s. The embedded mode still exists, and the docs warn that in that mode L7 enforcement depends on the agent pod being available.

Two Cilium features use this Envoy. L7 network policy restricts HTTP methods, paths, hosts and headers, and filters DNS queries by name. L7 traffic management, through Gateway API and the lower-level CiliumEnvoyConfig CRDs, adds path rewriting, traffic shifting, circuit breaking and L7 load balancing, according to the Cilium L7 traffic management docs. East-west routing uses the Gateway API mesh profile, known as GAMMA, where an HTTPRoute or GRPCRoute attaches to a Service instead of a Gateway.

The cost model is the key insight. A sidecar mesh pays one proxy per pod. A Cilium service mesh pays one proxy per node, and only flows with L7 rules pass through it. On a node with 60 pods, that is one Envoy instead of 60. The trade is a larger blast radius per proxy, which we return to in the failure-modes section.

Plane 3: ztunnel for inline mTLS

The third plane is the newest and the one most posts get wrong. Cilium’s original “mutual authentication” design, beta since 1.14, performed an out-of-band mTLS handshake between agents and then let WireGuard or IPsec encrypt node-to-node traffic. Critics pointed out that the handshake and the data path were decoupled. The first packets of a new flow were dropped until authentication completed, and same-node pod traffic was not encrypted. Cilium 1.19 disabled that feature by default, and Cilium 1.20 formally deprecated it with removal planned for a later release, according to the Cilium 1.20 release post.

Its successor is ztunnel. When you label a namespace io.cilium/mtls-enabled=true, the agent enters each pod’s network namespace and installs iptables rules that redirect outbound TCP to the node’s ztunnel. ztunnel holds the connection while it establishes a TLS 1.3 session to the destination node’s ztunnel, then tunnels the bytes over HBONE (HTTP-Based Overlay Network Environment, HTTP/2 CONNECT) on port 15008. Per the Cilium ztunnel documentation, this also encrypts enrolled pod-to-pod traffic on the same node, which WireGuard and IPsec do not.

This is the architectural concession. mTLS that is genuinely inline needs a userspace TLS stack, and Cilium chose to reuse the one Istio built rather than force it into the kernel. The “everything in eBPF” story is now “L3 and L4 in eBPF, and userspace proxies wherever cryptographic identity or protocol parsing is required.”

Walk-Through: Cilium Service Mesh Packet Paths, Setup and Policy on Cilium 1.20

Understanding which plane handles a given flow is the single most valuable debugging skill for the Cilium service mesh. Figure 2 traces the decision for one TCP connection leaving a pod.

Decision flow for a packet through the Cilium service mesh eBPF, Envoy and ztunnel planes

Figure 2: Which Cilium plane handles a flow, and what a denial looks like at each step.

If both the source and destination namespaces are enrolled for mTLS, the flow goes to ztunnel and crosses the network inside HBONE. If not, the eBPF datapath evaluates L3 and L4 policy against security identities. A denial here is a kernel drop, visible in Hubble with a DROPPED verdict. If the port carries an L7 rule, eBPF redirects the flow to the node-local Envoy. A denied HTTP request returns HTTP 403, and a denied DNS query returns REFUSED, rather than a silent packet drop. Everything else is load-balanced and routed in the kernel.

Notice the asymmetry in that diagram. The ztunnel path bypasses most of the L4 policy evaluation that normally happens on the pod’s traffic, because the traffic is encrypted before it leaves the pod. We will come back to that, because it is the most consequential limitation of the current beta.

Version check before you start

As of 19 November 2026, Cilium 1.20 is the current stable minor. The stable documentation is published for 1.20.5, while the GitHub README still listed 1.20.4 as the latest image at the time of writing. The community maintains the last three minor lines, which today are 1.20, 1.19 and 1.18. A 1.21 pre-release was published on 2 November 2026. Pin an exact patch version that you have tested, and never install “latest” into a production cluster.

The base requirement is Linux kernel 5.10 or later, or 4.18 on RHEL 8.10, per the Cilium system requirements. Some features need more. The netkit device mode, for example, needs kernel 6.8 or later, and Cilium 1.20 added bpf.datapathMode=auto so each node can choose netkit or veth on its own.

Option A: eBPF policy plus WireGuard, the conservative baseline

This is the configuration most production clusters should start with. It gives kernel-speed L3 and L4 policy, the node-local Envoy for L7 rules, node-to-node WireGuard encryption, and Hubble. It does not give you per-workload mTLS identity.

# Option A: stable baseline (pin the patch you have validated)
cilium install \
  --version 1.20.5 \
  --set kubeProxyReplacement=true \
  --set l7Proxy=true \
  --set encryption.enabled=true \
  --set encryption.type=wireguard \
  --set hubble.relay.enabled=true \
  --set hubble.ui.enabled=true

cilium status --wait
cilium config view | grep -E "kube-proxy-replacement|enable-l7-proxy|enable-wireguard"

Cilium 1.19 introduced a strict mode for WireGuard and IPsec in which unencrypted inter-node traffic is dropped. That is the setting regulated environments usually want, because it turns “encryption is configured” into “plaintext cannot leave the node.” Check the encryption docs for the exact strict-mode values in your pinned version before you enable it, since a misconfigured strict mode will cut cross-node traffic.

Option B: ztunnel mTLS, the identity-first beta

If you need cryptographic workload identity on pod-to-pod connections, the 1.20 path is ztunnel. The legacy authentication.mutual.spire.enabled setting and the authentication.mode: required policy field that older guides recommend belong to the deprecated design. Do not build new clusters on them.

# Option B: ztunnel transparent encryption (beta in Cilium 1.20)
# Prerequisite: create the cilium-ztunnel-secrets Secret in kube-system
# using the generation script referenced in the Cilium ztunnel docs.
cilium install \
  --version 1.20.5 \
  --set kubeProxyReplacement=true \
  --set encryption.enabled=true \
  --set encryption.type=ztunnel \
  --set hubble.relay.enabled=true

# Enroll a namespace; existing and new pods join automatically
kubectl label namespace shop io.cilium/mtls-enabled=true

# Verify that cross-node traffic is now HBONE on port 15008
# (run on a node, or in a debug pod with host networking)
tcpdump -ni any tcp port 15008 -c 20

Note what changes in this mode. encryption.type takes one value, so you are choosing ztunnel instead of WireGuard, not adding to it. Microsoft’s AKS documentation for the same integration states that enabling mTLS and WireGuard together is not supported. Cluster Mesh must be disabled. Only TCP is redirected, so UDP and other protocols stay outside the tunnel. Host-network pods cannot be enrolled.

Cilium 1.20 added a choice of certificate authority for ztunnel. The default internal mode needs no SPIRE. The spire mode issues SPIFFE (Secure Production Identity Framework for Everyone) identities through a SPIRE server that also rotates them. If you already operate SPIRE, our SPIFFE and SPIRE workload identity architecture guide explains the trust-domain design that the spire mode plugs into.

An L7 policy that actually enforces something

Whichever option you choose for encryption, L7 policy uses the same CiliumNetworkPolicy resource. This example lets pods labelled app=frontend call only GET /api/products and GET /healthz on the backend, and sends its DNS lookups through Cilium’s DNS proxy so every query is visible and policy-controlled.

apiVersion: cilium.io/v2
kind: CiliumNetworkPolicy
metadata:
  name: frontend-to-backend-l7
  namespace: shop
spec:
  endpointSelector:
    matchLabels:
      app: frontend
  egress:
    - toEndpoints:
        - matchLabels:
            app: backend
      toPorts:
        - ports:
            - port: "8080"
              protocol: TCP
          rules:
            http:
              - method: "GET"
                path: "/api/products"
              - method: "GET"
                path: "/healthz"
    - toEndpoints:
        - matchLabels:
            k8s:io.kubernetes.pod.namespace: kube-system
            k8s-app: kube-dns
      toPorts:
        - ports:
            - port: "53"
              protocol: ANY
          rules:
            dns:
              - matchPattern: "*"

As soon as this policy lands, the agent programs eBPF to redirect frontend traffic on port 8080 to the node’s Envoy. A POST or a request to /api/admin gets an HTTP 403 from Envoy, not a TCP reset. That detail matters for client retry logic, because a 403 is a definitive answer while a dropped packet causes retries and timeouts. Also note that the policy turns the frontend’s egress into default-deny for everything not listed, which is why the DNS rule is there. Forgetting DNS is the most common first-day outage with L7 egress policy.

Observe the result directly from the datapath with Hubble:

cilium hubble port-forward &
hubble observe --namespace shop --protocol http --follow
hubble observe --namespace shop --verdict DROPPED --follow

Cilium 1.20 also improved audit mode. Flows with an audit verdict now carry the ingress_allowed_by and ingress_denied_by policy fields, so you can see which policy would have denied a flow before you enforce it. Roll out new policies in audit, watch Hubble for a few days of real traffic, then switch to enforcing.

East-west routing with GAMMA

For traffic management rather than policy, Cilium uses Gateway API. Cilium 1.20 moved from Gateway API v1.4 to v1.6, adding ExternalAuth, TCPRoute, UDPRoute, ListenerSets and a CORS filter. For mesh traffic, a GAMMA route binds to a Service. This example sends 10 percent of in-cluster calls to a canary backend.

apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: backend-canary
  namespace: shop
spec:
  parentRefs:
    - group: ""
      kind: Service
      name: backend
      port: 8080
  rules:
    - backendRefs:
        - name: backend-stable
          port: 8080
          weight: 90
        - name: backend-canary
          port: 8080
          weight: 10

Two constraints from the Cilium GAMMA documentation apply. Only “producer” routes are supported, meaning the route must live in the same namespace as the Service it binds to. Consumer routes, which let a calling namespace override routing for itself, are not supported. GAMMA also requires kube-proxy replacement and the L7 proxy. For the wider Gateway API picture, see our Gateway API 1.6 TCPRoute and UDPRoute guide and our analysis of Cilium 1.20 ExternalAuth versus oauth2-proxy and Istio.

Inside the ztunnel mTLS Flow

The ztunnel integration deserves its own section because it changes the security properties of the Cilium service mesh, and because it is the part most likely to surprise teams migrating from older guides. Figure 3 shows one connection between two enrolled pods on different nodes.

Sequence of a Cilium ztunnel mTLS connection over HBONE between two nodes

Figure 3: A Cilium ztunnel mTLS connection, from certificate issuance to the HBONE tunnel.

Each ztunnel obtains short-lived workload certificates from the configured CA. When Pod A opens a TCP connection, iptables rules inside Pod A’s network namespace redirect it to the local ztunnel. Microsoft’s AKS Cilium mTLS concepts page describes this redirect target as port 15001. ztunnel holds the application’s connection, completes a TLS 1.3 handshake with the destination node’s ztunnel on port 15008, verifies the peer identity, and then opens an HBONE tunnel. Only then do application bytes flow.

Why inline beats out-of-band

The difference from the deprecated design is not cosmetic. In the old model, authentication happened beside the data path. The agent cached “these two identities have authenticated,” and eBPF consulted that cache. Critics, including an analysis published by The New Stack, argued that this made security depend on eventually consistent IP-to-identity caches on every node. A stale cache entry could apply the wrong policy, and the encryption, done by WireGuard or IPsec between nodes, was not bound to the authenticated identity.

With ztunnel, the TLS session is the transport. Identity and encryption are the same handshake, there is no plaintext window, and the first packet is not dropped. Same-node traffic between enrolled pods is also encrypted, which closes the gap where WireGuard protected only node-to-node hops.

The enrollment matrix

Enrollment is per namespace and only fully protects flows where both ends are enrolled. The AKS documentation spells out the four cases. Enrolled to enrolled is mTLS over HBONE. Enrolled to non-enrolled is plaintext passthrough. Non-enrolled to enrolled is plaintext captured by ztunnel but not encrypted. Non-enrolled to non-enrolled uses the normal Cilium datapath with no ztunnel at all.

That matrix has a migration consequence. You cannot get end-to-end mTLS by enrolling just the sensitive namespace. You must enrol both sides of every flow you care about, and you need a way to find flows that are still in plaintext. Hubble’s encryption-status filters, added in 1.19, are the natural tool for that inventory.

Policy interaction is the catch

The Cilium ztunnel documentation states plainly that ztunnel interferes with Cilium network policy because traffic is encrypted before it leaves the pod. L4 policies only work when they target the HBONE port 15008. Microsoft’s AKS page goes further for its managed preview, stating that L4 and L7 network policy enforcement is not supported with mTLS in the current phase.

In practice this means you cannot yet have both of Cilium’s headline features on the same flow at full strength. You can have kernel-enforced, port-precise identity policy, or you can have inline mTLS, but combining them requires rethinking policy around port 15008. This is the most important fact to carry into a design review in late 2026, and it is the main reason the decision framework later in this post keeps WireGuard as a first-class option.

Cilium Service Mesh vs Istio Ambient: What Actually Differs in 2026

The honest comparison for a Cilium sidecarless service mesh is Istio’s ambient mode, because both removed the per-pod proxy. Istio 1.31.0, announced on 31 August 2026, focused its ambient work on multi-cluster fixes, weighted canaries for waypoints and CPU-aware ztunnel worker threads. Our Istio 1.31 ambient mesh upgrade guide covers that release in detail.

Here is the 2026 comparison, built from each project’s documentation.

Dimension Cilium 1.20 mesh Istio ambient, 1.31
L3/L4 policy eBPF, identity-based, in kernel Kubernetes NetworkPolicy via your CNI, plus ztunnel L4 authorization
Pod-to-pod mTLS ztunnel, beta, namespace enrollment ztunnel, generally available
Node-to-node encryption without mTLS WireGuard or IPsec, strict mode available Not the model; mTLS is the encryption
L7 proxy placement One shared Envoy per node Waypoint Envoy per namespace or service, optional
L7 feature depth Policy, GAMMA producer routes, CiliumEnvoyConfig Full Istio traffic API, authorization, waypoints
CNI relationship Mesh and CNI are the same product Runs on most CNIs, including Cilium
Cluster Mesh with mTLS Not supported with ztunnel today Ambient multicluster supported
Observability Hubble from eBPF, L7 when proxied Istio telemetry from ztunnel and waypoints

The table reveals the thesis of this post. On the mTLS plane the two meshes have converged on the same component, so “kernel mTLS versus userspace mTLS” is no longer the right frame. The real differences are three. Cilium’s L7 proxy is shared per node, while Istio’s waypoint is scoped to a namespace or service and can be scaled independently. Cilium’s L4 policy is kernel-enforced and identity-aware, which Istio does not try to replace. And Cilium’s mesh cannot be separated from Cilium the CNI.

The benchmark everyone cites, read carefully

The most cited performance comparison is Istio’s October 2024 “ambient vs Cilium” test. It ran on a 1,000-node AKS cluster with 11,000 cores, 500 services and roughly 50,000 pods, with heavy churn. Cilium had WireGuard, L7 proxies and an HTTP path policy in every namespace. Istio reported 56 percent more queries, 20 percent lower tail latency, and 2,178 queries per core versus Cilium’s 1,815. Cilium used 30 percent less measured CPU, but that measurement excluded kernel-side encryption work. Istio also reported that Cilium’s idle CPU and memory stayed high, and that churn frequently crashed the API server.

Three caveats apply. The test was run by the Istio project about a competitor. It predates Cilium’s ztunnel integration and the Envoy changes since, so it compares a configuration that new 2026 designs would not choose. And it stressed the scenario where Cilium is weakest: L7 policy plus encryption everywhere, at extreme scale and churn. Istio’s own conclusion was that Cilium is cost-effective for pure L3 and L4 needs, and that many users combine Cilium’s L3/L4 features with Istio’s L7 and encryption features.

The defensible reading is about shape, not numbers. Kernel paths win when most traffic is L4. Shared per-node L7 proxies are cheaper at rest but concentrate load. Dedicated waypoints cost more but isolate it. Run your own test before believing any chart, including that one.

Capacity and Cost: Reasoning About the Per-Node Model

Because the Cilium service mesh replaces per-pod proxies with per-node ones, the cost model changes shape. It is worth doing the arithmetic for your own cluster rather than relying on generic savings claims.

Start with the multiplier. Take an illustrative cluster of 40 nodes running 2,400 pods. A sidecar mesh runs 2,400 Envoy instances. A Cilium service mesh runs 40 cilium-envoy pods and, if ztunnel is enabled, 40 ztunnel pods. Even if each per-node proxy is several times larger than a sidecar, the count difference dominates. These numbers are illustrative, not measurements, and you should replace them with your own node and pod counts.

Next, consider where the CPU goes. In the kernel path, policy and load balancing cost a few map lookups per packet, and the CPU shows up as softirq time on the node rather than inside any container. That makes it easy to miss in Prometheus dashboards that only measure container usage, which is exactly the caveat the Istio benchmark raised. Budget for it by watching node-level CPU, not just pod CPU.

Then size the shared proxies. A node-local Envoy handles the L7 traffic of every pod on that node. If one noisy tenant pushes a large HTTP volume through an L7 rule, it competes with every other L7-policed workload on that node. Set resource requests and limits on the cilium-envoy DaemonSet deliberately, and alert on its CPU throttling. For the mechanics of throttling under CFS quotas, see our Kubernetes CPU throttling and cgroup v2 guide.

Finally, account for the agent’s own footprint. The agent holds identity, endpoint and policy state for the cluster. Its memory grows with the number of identities and policies, not with traffic. That explains the “high idle usage” observation in the Istio test: the agent’s state is the same whether or not packets flow. Label hygiene helps. Every unique combination of security-relevant labels creates an identity, so high-cardinality labels such as build hashes on pod templates inflate identity counts. Cilium lets you restrict which labels count toward identity, and large clusters should use that.

On releases, Cilium 1.20 also shrank the cilium-cni plugin binary from 76 MB in 1.19 to 16 MB, a 79 percent cut. That helps node image size and pull time, but it is the CNI plugin binary, not the agent’s runtime memory.

Trade-offs, Gotchas, and What Goes Wrong With Cilium Service Mesh

The Cilium service mesh is strong, but its failure modes differ from sidecar meshes, and teams get hurt when they assume otherwise.

ztunnel and policy do not fully compose yet. As covered above, ztunnel encrypts before traffic leaves the pod, so L4 policy has to target port 15008. AKS’s managed preview does not support L4 or L7 policy alongside mTLS at all. If your security model depends on both port-precise policy and mTLS on the same flows, treat ztunnel as a pilot, not a default.

ztunnel excludes Cluster Mesh, UDP and host-network pods. Multi-cluster users cannot enable it today. UDP workloads, including many DNS-heavy and telemetry paths, stay outside the tunnel. Plan for a mixed state, and use Hubble to measure it.

Deprecated settings live on in tutorials. Many 2024 and 2025 guides, including the previous version of this article, enable authentication.mutual.spire.enabled and add authentication.mode: required to policies. In Cilium 1.20 that feature is deprecated and slated for removal. Building on it now creates a forced migration later.

The shared Envoy concentrates the blast radius. If cilium-envoy on a node is unhealthy, every L7-policed flow on that node is affected at once. That is usually a fair trade against thousands of sidecars, but you should test it. Kill the cilium-envoy pod on one node in staging and measure what your L7-policed clients see.

Kernel heterogeneity causes inconsistent behaviour. Mixed node pools with different kernels can silently get different feature sets. Netkit needs 6.8 or later, and some L7 IPv6 SNAT cases need specific kernel fixes listed in the docs. Treat kernel version as part of each node pool’s contract and check it in CI.

Debugging moves from logs to the datapath. When the kernel drops a packet, there is no access log line. Your tools become hubble observe, cilium-dbg monitor, and occasionally bpftool to inspect maps. Hubble is excellent, but the team needs practice before the first incident, not during it.

Upgrades are CNI upgrades. Because mesh and CNI are one product, a Cilium service mesh upgrade is also a networking upgrade for every pod. Cilium 1.19, for example, changed Cluster Mesh policy defaults so that selectors without a cluster now match only the local cluster. Read the upgrade notes for every minor version, and run the pre-flight checks.

L7 feature depth still trails Istio. Fine-grained retries, fault injection, consumer-side routing overrides and rich authorization are deeper in Istio. Cilium’s CiliumEnvoyConfig can express much of it, but the docs warn it gets minimal validation and no conflict resolution, so it is a power tool for cluster administrators.

Decision framework for choosing Cilium only, Cilium with ztunnel, or a hybrid with Istio ambient

Figure 4: A decision framework for Cilium service mesh adoption in late 2026.

Figure 4 turns these trade-offs into a decision path. If Cilium is not already your CNI and you need rich L7 behaviour, a hybrid or Istio ambient is the stronger fit. If Cilium is your CNI and you do not need workload mTLS, eBPF policy plus strict WireGuard covers most compliance needs. If you need mTLS and can accept the beta and the policy constraints, ztunnel is the path. If you need mTLS, port-precise policy and heavy L7 shaping together, the hybrid of Cilium as CNI and Istio ambient as mesh remains the most mature option in 2026.

Practical Recommendations

Adopt the Cilium service mesh as three features, not one product. Turn on the eBPF plane first, because it is mature and it is what you are already running if Cilium is your CNI. Add L7 policy only where a specific flow needs method, path or DNS-name control. Treat ztunnel as a planned pilot with a clear exit, not a checkbox at install time.

For most production clusters in late 2026, the strongest Cilium service mesh default is Cilium 1.20 with kube-proxy replacement, identity-based default-deny policy, targeted L7 rules, strict-mode WireGuard, and Hubble everywhere. Our default-deny microsegmentation rollout guide covers the policy side step by step. Pilot ztunnel in one or two namespace pairs where mTLS identity is a hard requirement and Cluster Mesh is not in use. If L7 traffic management is central to your platform, run Istio ambient on top of Cilium rather than stretching CiliumEnvoyConfig.

Use this checklist before production:

  • Pin an exact Cilium patch release and read the upgrade notes for every minor you cross.
  • Confirm kernel versions across all node pools against the system requirements page.
  • Remove any authentication.mutual.* settings and authentication.mode fields from new designs.
  • Decide explicitly between WireGuard and ztunnel per cluster, since they cannot be combined.
  • Start every new policy in audit mode and promote it after Hubble shows clean traffic.
  • Always include a DNS egress rule in L7 egress policies.
  • Set resources and alerts on the cilium-envoy and ztunnel DaemonSets.
  • Kill a node’s Envoy in staging and record the blast radius.
  • Train at least two engineers on Hubble and cilium-dbg before go-live.
  • Rehearse a rollback path for every Cilium minor upgrade.

Frequently Asked Questions

Is Cilium service mesh really sidecarless?

Yes. No proxy runs inside your application pods. L3 and L4 policy, load balancing and routing run as eBPF programs in the kernel. L7 policy and traffic management use one shared Envoy per node, deployed as the cilium-envoy DaemonSet by default since Cilium 1.16. Pod-to-pod mTLS, beta in Cilium 1.20, uses one ztunnel per node. So there are still userspace proxies, but they scale with nodes rather than pods, and only flows that need them pass through them.

Does Cilium support mTLS without sidecars in 2026?

Yes, through its ztunnel integration, which arrived as a beta in Cilium 1.19 and remains beta in 1.20. You label a namespace io.cilium/mtls-enabled=true, and enrolled pods’ TCP traffic is tunnelled over HBONE with TLS 1.3 on port 15008. The certificate authority can be Cilium’s internal CA or SPIRE. The older out-of-band mutual authentication feature is deprecated in 1.20. Note the current limits: TCP only, no Cluster Mesh, no host-network pods, and L4 policy must target port 15008.

Which is faster, Cilium or Istio ambient?

It depends on the workload, and no published benchmark settles it. Istio’s 2024 test at 1,000 nodes found ambient delivered 56 percent more queries and 20 percent lower tail latency when Cilium ran L7 policy plus WireGuard everywhere. The same test noted Cilium used less measured CPU, though kernel encryption work was excluded. For mostly L4 traffic, Cilium’s kernel path is typically very efficient. Benchmark your own traffic mix on your own hardware before choosing.

What is the latest Cilium version in November 2026?

Cilium 1.20 is the current stable minor release. The stable documentation is published for 1.20.5, and GitHub listed 1.20.4 as the latest stable image when we checked, so verify the newest patch before installing. The community maintains the last three minor lines, currently 1.20, 1.19 and 1.18. A 1.21 pre-release appeared on 2 November 2026. Cilium 1.20 moved to Gateway API v1.6 and deprecated legacy mutual authentication.

Can I run Cilium and Istio together?

Yes, and it is a common production pattern. Cilium serves as the CNI, providing eBPF L3 and L4 policy, kube-proxy replacement and Hubble. Istio ambient provides the mesh layer with ztunnel mTLS and waypoint proxies for advanced L7. Istio’s own 2024 benchmark write-up noted that many users combine the two this way. Do not enable Cilium’s ztunnel mTLS and Istio’s at the same time; Microsoft’s AKS documentation lists that combination as unsupported.

What Linux kernel does the Cilium service mesh need?

Cilium’s base requirement is Linux kernel 5.10 or later, or 4.18 on RHEL 8.10. Individual features need more, such as kernel 6.8 for the netkit device mode, and some L7 IPv6 SNAT cases need specific kernel fixes. ztunnel mode additionally needs iptables support in the kernel, because enrollment installs iptables rules inside each pod’s network namespace. Keep kernel versions consistent across node pools to avoid features silently differing between nodes.

Further Reading

From this site:

Primary sources:

By Riju — about

1 Comment

Leave a Reply

Your email address will not be published. Required fields are marked *