Talos Linux is a minimal, immutable, API-driven operating system built specifically for Kubernetes — no SSH, no shell, no package manager. That design is great for security and reliability, but it also means installing a CNI like Cilium works a little differently than on a regular Ubuntu node. In this guide we show you exactly how to install Cilium on a Kubernetes cluster running Talos Linux, including the Talos-specific machine-config changes and Helm values — with real output from a cluster we built while writing this article.

By the end you will have Cilium running as your CNI, kube-proxy fully replaced by Cilium’s eBPF data path, and Hubble giving you live network observability.

What is Cilium, and why run it on Talos?

Cilium is a CNI (Container Network Interface) built on eBPF, the Linux kernel technology that lets you run sandboxed programs directly in the kernel. Instead of relying on iptables and kube-proxy for service routing, Cilium handles networking, load balancing and network policy in eBPF — which is faster, scales better, and unlocks deep observability through Hubble.

Talos ships with Flannel as its default CNI. Flannel is fine for basic networking, but production clusters usually want more: network policy enforcement, transparent encryption, BGP, and the observability that Cilium + Hubble provide. Because Talos is a locked-down, immutable operating system, you configure all of this declaratively — there is no node to log into and tweak by hand, and even the CNI is chosen by name rather than installed manually. Everything about the system is driven through the Talos API.

Prerequisites

  • talosctl, kubectl and Helm 3 installed
  • The Cilium CLI (optional, but great for verification and Hubble)
  • A Talos cluster you are about to bootstrap (VMs, bare metal, or a local Docker cluster for testing)
  • Cilium 1.16+ (this guide uses 1.18)

Step 1 — Disable the default CNI and kube-proxy

This is the key Talos-specific step. Before you bootstrap the cluster, you tell Talos not to install Flannel and not to run kube-proxy — because Cilium will provide both. You do this with a small machine-config patch:

# patch.yaml
cluster:
  network:
    cni:
      name: none        # do not install the default Flannel CNI
  proxy:
    disabled: true      # Cilium replaces kube-proxy using eBPF
Talos machine config patch setting cni name none and kube-proxy disabled
The whole trick on Talos: set cni.name: none and proxy.disabled: true before bootstrap.

Step 2 — Bootstrap the cluster (NotReady is expected)

Apply the patch when you create the cluster. For a real cluster you would generate the config with the patch and bootstrap the nodes; for local testing you can spin up a Docker-based cluster in one command:

# Local test cluster (Docker) — great for trying this out
talosctl cluster create docker --config-patch @patch.yaml

# Real cluster (VMs / bare metal)
talosctl gen config my-cluster https://<CONTROLPLANE-IP>:6443 --config-patch @patch.yaml
talosctl apply-config --insecure -n <NODE-IP> --file controlplane.yaml
talosctl bootstrap -n <CONTROLPLANE-IP>
talosctl cluster create docker output bootstrapping a Talos Kubernetes cluster
Talos boots and bootstraps etcd and the control plane — then waits, because there is no CNI yet.

Now fetch the kubeconfig and look at your nodes:

talosctl -n <CONTROLPLANE-IP> kubeconfig .
export KUBECONFIG=$PWD/kubeconfig
kubectl get nodes
kubectl get nodes showing Talos nodes NotReady before a CNI is installed
Nodes are NotReady — this is normal. Without a CNI, the kubelet cannot report the node as ready. Cilium fixes this in the next step.

Tip: with cni: none, talosctl cluster create docker will pause on “waiting for nodes to be ready”. That is expected — fetch the kubeconfig from a second terminal and continue with the Cilium install; the node goes Ready as soon as Cilium is up.

Step 3 — Install Cilium with Helm

Add the Helm repository and install Cilium — the release name is cilium — into the kube-system namespace with the Talos-specific values:

helm repo add cilium https://helm.cilium.io/
helm repo update

helm install cilium cilium/cilium --version 1.18.0 \
  --namespace kube-system \
  --set ipam.mode=kubernetes \
  --set kubeProxyReplacement=true \
  --set k8sServiceHost=<CONTROLPLANE-IP> \
  --set k8sServicePort=6443 \
  --set cgroup.autoMount.enabled=false \
  --set cgroup.hostRoot=/sys/fs/cgroup \
  --set securityContext.capabilities.ciliumAgent="{CHOWN,KILL,NET_ADMIN,NET_RAW,IPC_LOCK,SYS_ADMIN,SYS_RESOURCE,DAC_OVERRIDE,FOWNER,SETGID,SETUID}" \
  --set securityContext.capabilities.cleanCiliumState="{NET_ADMIN,SYS_ADMIN,SYS_RESOURCE}" \
  --set hubble.enabled=true \
  --set hubble.relay.enabled=true \
  --set hubble.ui.enabled=true

Local Docker cluster? Use Talos KubePrism instead of the API IP: set --set k8sServiceHost=localhost --set k8sServicePort=7445. Everything else stays the same.

Understanding the Talos-specific values

  • kubeProxyReplacement=true — Cilium handles all service routing in eBPF, since we disabled that component in Talos.
  • k8sServiceHost / k8sServicePort — with no kube-proxy, Cilium needs to reach the API server directly. Use the control-plane IP/VIP and 6443 (or localhost:7445 on Docker).
  • cgroup.autoMount.enabled=false + cgroup.hostRoot=/sys/fs/cgroup — Talos already mounts cgroup v2; we tell Cilium not to remount it.
  • securityContext.capabilities.* — Talos is locked down, so Cilium needs these Linux capabilities declared explicitly.
  • ipam.mode=kubernetes — allocate pod IPs from the PodCIDR that Kubernetes assigns to each node.

Step 4 — Verify the installation

Give the Cilium pods a minute to pull their images and start, then check the status:

cilium status --wait
cilium status output showing Cilium, Operator, Envoy and Hubble Relay all OK on Talos
Cilium, the operator, Envoy and Hubble Relay all report OK, with all pods managed by Cilium.

The moment Cilium is running, the CNI is in place and the nodes flip to Ready:

kubectl get nodes showing Talos control-plane and worker nodes Ready after installing Cilium
Both the control-plane and worker node are now Ready — compare with the NotReady output from Step 2.

Finally, confirm that Cilium really did replace kube-proxy:

kubectl -n kube-system exec ds/cilium -- cilium-dbg status | grep -i kubeproxy
cilium-dbg status confirming KubeProxyReplacement True with Direct Routing on Talos
KubeProxyReplacement: True — service routing is now handled entirely by Cilium’s eBPF data path.

Step 5 — Enable Hubble observability

We enabled Hubble during the install, so the UI is ready to go. Open it with:

cilium hubble ui

Pick a namespace (for example kube-system) and Hubble draws a live service map of who is talking to whom, with per-flow verdicts — one of the biggest reasons teams choose Cilium in the first place.

Hubble UI service map showing network flows between pods in the kube-system namespace
Hubble’s service map: live, eBPF-powered visibility into every network flow in the cluster.

Common mistakes to avoid

  • Forgetting cni: none — if Talos installs Flannel first, you end up with two CNIs fighting. Set it before bootstrap.
  • Wrong k8sServiceHost — with kube-proxy disabled, a wrong API address means Cilium never connects and pods stay pending.
  • Leaving kube-proxy enabled while setting kubeProxyReplacement=true — pick one; on Talos, disable kube-proxy and let Cilium own it.
  • Skipping the cgroup values — without cgroup.autoMount.enabled=false Cilium may try to remount cgroups that Talos already manages.
  • Panicking at NotReady nodes — that state is expected until the CNI is installed.

Running Cilium on Talos in production

A local cluster is perfect for learning, but a production setup adds more: a highly-available control plane with a VIP, network policies, transparent encryption, Hubble metrics wired into Prometheus and Grafana, and a safe upgrade path for both the operating system and Cilium. Because Talos treats the whole system as immutable, those upgrades are far more predictable than patching a traditional OS by name-and-version. We run exactly this kind of stack for our own workloads. If you would like a hand designing or operating a Talos + Cilium cluster, take a look at our DevOps consulting and support — and if you are new to the wider picture, our guide on what a DevOps pipeline is puts CNIs like Cilium in context.

Frequently asked questions

Does Talos Linux support Cilium?
Yes. Talos fully supports Cilium as a CNI. You just disable the default Flannel CNI (cni.name: none) in the machine configuration before bootstrap, then install Cilium with Helm using a few Talos-specific values (cgroup and securityContext settings, and the API server address for kube-proxy replacement).
Do I need to disable kube-proxy to use Cilium on Talos?
Not strictly, but it is recommended. Setting proxy.disabled: true in the Talos config and kubeProxyReplacement=true in Cilium lets Cilium handle all service routing in eBPF, which is faster and removes iptables overhead. If you prefer, you can keep kube-proxy and set kubeProxyReplacement=false.
Why are my Talos nodes NotReady after bootstrap?
Because there is no CNI yet. When you set cni.name: none, the kubelet cannot mark nodes Ready until a network plugin is installed. As soon as Cilium is running, the nodes turn Ready automatically. This is expected behaviour, not an error.
What is the difference between installing Cilium on Talos and on Ubuntu?
The Cilium install itself — Helm, verification, Hubble — is almost identical. The differences are Talos-specific: there is no SSH or package manager, you disable the default CNI and kube-proxy declaratively in the machine configuration, and you pass a few extra Helm values (cgroup and securityContext) because Talos is immutable and locked down.
Is Cilium free to use?
Yes. Cilium is open source (a CNCF graduated project) and free to run, including Hubble for observability. Commercial support and an enterprise edition are available from Isovalent, but the core project covers the setup described in this guide.

Conclusion

Installing Cilium on a Talos Linux Kubernetes cluster comes down to two Talos-specific things: disable Flannel and kube-proxy in the machine config, then install Cilium with the right Helm values. Everything after that — cilium status, kube-proxy replacement, Hubble — is standard Cilium. The payoff is an eBPF-powered network with better performance, network policy and real observability, all managed declaratively the way Talos intends. If you want help taking this from a test cluster to production, get in touch for a free consultation.

Once Cilium is running, the next step on the same cluster is to replace Ingress NGINX with the Cilium Gateway API on Talos.

Expert view — from our cluster

We run this exact stack — Talos, Cilium, kube-proxy replacement — in production, not just in a lab, and the biggest operational lesson is to treat the machine config as your single source of truth. Because Talos is immutable, the instinct to “SSH in and fix it” is gone; that feels limiting for a day, then you realize it’s exactly why the clusters are reproducible. If we had to flag one thing: enable kube-proxy replacement from day one rather than retrofitting it, and bring up Hubble early — the eBPF data path is fast, but the observability you get for free is what actually saves you at 3 a.m.

— Milan Petrović, Senior Cloud/DevOps Engineer · CKA, RHCE, RHCSA

MP
Milan Petrović
Senior Cloud / DevOps Engineer · CKA, RHCE, RHCSA

Milan designs and operates production Kubernetes, Cilium and HashiCorp Vault platforms at Synapps Consulting. Every guide here comes from a real cluster he runs, not theory.

Connect on LinkedIn →