Multus — give a Kubernetes pod more than one network interface.

TL;DR — Multus CNI is a meta-plugin that lets you attach multiple network interfaces to a single Kubernetes pod. For AI workloads this is essential: the primary interface handles cluster networking (via Cilium/Calico), while secondary interfaces connect directly to high-speed RDMA/InfiniBand fabrics for GPU-to-GPU collective communication — separate data and control planes in one pod.

What it is

Multus is a CNI meta-plugin — it doesn't provide networking itself, but lets you attach multiple CNI plugins to a single pod, each providing a separate network interface. It's the standard way to give a pod both a regular cluster network (eth0) and additional high-speed interfaces (e.g., an SR-IOV VF for RDMA). In the AI Native landscape it's in AI Native Infra › Network.

Why it exists

Kubernetes gives every pod exactly one network interface by default. But GPU training pods need two networks: the cluster network for API calls, health checks, and metrics — and a separate high-bandwidth, low-latency network (InfiniBand, RoCE) for NCCL all-reduce and parameter sync. Without Multus, you can't attach both to the same pod.

How it works

Multus runs as a DaemonSet and intercepts CNI calls from the kubelet. For each pod, it first invokes the primary CNI (e.g., Cilium) to create eth0, then iterates over any NetworkAttachmentDefinition annotations on the pod to invoke secondary CNIs — each one creates an additional interface inside the pod's network namespace. The pod sees multiple NICs, each with its own IP and routes.

Key features

• Multiple interfaces — attach any number of secondary NICs to a pod.
• CNI-agnostic — works with any primary CNI (Cilium, Calico, Flannel).
• NetworkAttachmentDefinition CRD — declarative config for secondary networks.
• SR-IOV integration — the primary use case for AI: attach SR-IOV VFs for RDMA.
• Thick plugin mode — v4.x supports a thick plugin (client/server) for reliability and event-driven attachment.

Quick start

Install Multus, then define a secondary network and annotate your pod:

# install Multus
kubectl apply -f https://raw.githubusercontent.com/k8snetworkplumbingwg/multus-cni/master/deployments/multus-daemonset-thick.yml

# NetworkAttachmentDefinition for SR-IOV
apiVersion: k8s.cni.cncf.io/v1
kind: NetworkAttachmentDefinition
metadata:
  name: sriov-rdma
  annotations:
    k8s.v1.cni.cncf.io/resourceName: intel.com/sriov_rdma
spec:
  config: '{"type":"sriov","vlan":100,"ipam":{"type":"whereabouts","range":"10.56.0.0/16"}}'
---
# pod annotation to attach it
metadata:
  annotations:
    k8s.v1.cni.cncf.io/networks: sriov-rdma

The pod gets eth0 (primary CNI) + net1 (SR-IOV RDMA interface).

When to use, when to skip

Use it whenever a pod needs more than one network — the primary scenario for AI is attaching RDMA/InfiniBand interfaces alongside the cluster network for GPU training. Also used for storage networks, management networks, or telco NFV workloads.

Skip it if your pods only need one network interface — single-NIC is the Kubernetes default and requires no extra tooling.

vs / alongside

Tool	Role	Note
Multus	Multi-NIC meta-plugin	The orchestrator for multiple interfaces
Cilium	Primary CNI	Handles eth0 / cluster networking
SR-IOV CNI	SR-IOV interface plugin	Invoked by Multus for RDMA VFs
RDMA	GPU data plane protocol	Runs over the SR-IOV interface

References

• multus-cni — source and docs.
• Quick start guide — installation and first attachment.
• Thick plugin — v4 architecture.

Extra reads

• Kubernetes networking with Multus — Red Hat walkthrough.
• NVIDIA networking + Multus — GPU cluster networking.

Verified against Multus CNI docs (github.com/k8snetworkplumbingwg), May 2026.