Overview¶
BIG-IP Next for Kubernetes (BNK) on DPU is a cloud‑native traffic management solution for AI and other high‑throughput workloads that need hardware‑accelerated L4–L7 services. BNK runs the F5 Traffic Management Microkernel (TMM) directly on NVIDIA BlueField‑3 data processing units (DPUs). This design offloads all traffic processing from the host CPU and keeps host resources available for your applications.
BNK on DPU is Kubernetes‑native. You manage it with standard Kubernetes tools, including Custom Resource Definitions (CRDs), the Cloud Native Computing Foundation (CNCF) Gateway API, and the F5 Lifecycle Operator (FLO). FLO manages installation, upgrades, and rollbacks.
Note
BNK on host vs. BNK on DPU
F5 offers two deployment models for BIG-IP Next for Kubernetes. BNK on host runs TMM as a software pod on the host CPU. This model is designed for 5G and CoSP networks.
BNK on DPU runs TMM on NVIDIA BlueField‑3 hardware. This model is optimized for AI and cloud‑native workloads. Both models use the same TMM. The key difference is the deployment target and use case, not protocol capability.
For 5G and CoSP deployment guidance, see BIG-IP Next for Kubernetes (Host).
What BNK on DPU does¶
BNK on DPU manages all traffic entering and leaving your Kubernetes cluster. TMM handles data‑path processing, and the CNE Controller manages configuration. Together they provide:
Load balancing for TCP, UDP, HTTP/2, gRPC, and SCTP workloads at L4–L7
SSL/TLS termination with DPU crypto acceleration
Security enforcement with stateful firewall ACLs, DDoS mitigation, and intrusion prevention, all offloaded to DPU hardware
High‑speed logging (HSL) to external collectors
Egress control with per‑namespace source NAT (SNAT) and egress gateway policies
AI traffic management with GPU‑aware load balancing, token governance in the data path, and Model Context Protocol (MCP) traffic handling
Multi‑tenancy with namespace‑based and network‑based isolation, per‑tenant policies, and per‑tenant observability
Programmability with F5 iRules so you can attach business logic to any ingress or egress service
Why DPU instead of host¶
When BNK runs on the host CPU, TMM competes with your application workloads for compute resources. On GPU‑dense AI clusters, this reduces inference capacity.
BNK on DPU moves TMM to the DPU hardware. The host CPU handles no traffic‑processing tasks.
BNK on Host |
BNK on DPU |
|
|---|---|---|
Where TMM runs |
Host CPU (software pod) |
DPU hardware |
Host CPU impact |
TMM shares CPU with application workloads |
Host CPU stays fully available for applications |
Hardware offload |
None |
DOCA‑accelerated packet handling, ACLs, and DDoS |
Security enforcement |
Software‑based |
Hardware‑offloaded at line rate |
Target workloads |
5G/CoSP (SCTP, NGAP, Diameter, GTP) |
AI and cloud‑native (TCP, UDP, HTTP/2) |
Lifecycle management |
Helm or FLO |
FLO |
Use cases¶
AI inference clusters¶
BNK on DPU offloads all ingress and egress processing to the DPU, freeing host CPU capacity for AI workloads. BNK integrates with NVIDIA NIM telemetry to route inference requests to the least‑loaded GPU in real time. Token governance lets you enforce usage limits in the data path using iRules. For Model Context Protocol (MCP) deployments, BNK provides MCP proxy and security functions so you can manage and secure MCP traffic at scale without changes to your model‑serving infrastructure.
Multi‑tenant Kubernetes clusters¶
Large organizations often run several teams or customers on one Kubernetes cluster. Without per‑tenant isolation, a single misconfiguration or security event can affect all tenants. BNK on DPU gives each tenant its own firewall policies, logging stream, and egress identity, enforced on the DPU instead of the host. In version 2.2 and later, VRF‑based routing and VXLAN EVPN over BGP provide full L2/L3 network isolation. Per‑tenant ingress and egress ACL policies let you enforce different security rules per namespace without shared‑policy risk.
Per‑application egress control¶
By default, Kubernetes assigns the same outbound identity to all pods. This makes it hard to trace egress traffic to an application or enforce application‑specific rules. This is a common issue in AI environments where workloads such as model inference pods need isolated, auditable network paths to reach retrieval‑augmented generation (RAG) data sources. BNK on DPU assigns SNAT address pools per namespace, giving each application a unique outbound identity. Upstream firewalls, logging systems, and security tools get a clear, per‑application view of outbound traffic without changes to your applications.
Key components¶
Component |
Role |
|---|---|
TMM (Traffic Management Microkernel) |
Data‑plane component that processes all ingress and egress traffic at L4–L7. Runs as a DaemonSet on DPU nodes and uses NVIDIA DOCA to offload packet handling, ACLs, DDoS mitigation, and firewall enforcement. |
CNE Controller |
Control‑plane component that watches Gateway API and F5 custom resources, translates them to TMM configuration over gRPC, and sends configuration to TMM instances on DPUs. Runs on the host or on other cluster nodes. |
F5 Lifecycle Operator (FLO) |
Operator Lifecycle Manager (OLM)‑based operator that installs, scales, and upgrades BNK on DPU components. Installs CRDs, validates versions, discovers DPUs automatically, and handles automated rollbacks when upgrades fail. |
Cluster‑Wide Controller (CWC) |
Manages licensing, QKView generation, and debug REST APIs. Handles log‑level configuration across components and uses RabbitMQ for inter‑component communication. |
dSSM |
Distributed session state manager. Provides Redis Sentinel persistence for TMM session state. Runs as a StatefulSet with Sentinel for high availability across multiple DPU nodes. |
OTEL Collector |
Receives OpenTelemetry metrics from TMM via Observer pods and Distributed TODA, then exports metrics to Prometheus. Provides per‑tenant metrics, logs, and traces. Admins can view namespace‑scoped telemetry without crossing tenant boundaries. |
Fluentd |
Log aggregation component. Collects and forwards logs from BNK components to external systems. |
Gateway API |
Interface for defining ingress and egress services. Supports the CNCF Gateway API (TCPRoute, UDPRoute) and F5 extensions for iRules, firewall policies, DDoS profiles, and high‑speed logging (HSL). In version 2.2 and later, services are declared using the CNEInstance CR. |
F5 IPAM Controller (FIC) |
Automates VIP address allocation for Gateway resources and assigns virtual server addresses. Optional — required only when using F5BNKGateway for automated IP management. |
F5 License Proxy (FLP) |
Optional license management component for clusters without internet access. Deployable as a Helm chart or as a virtual machine (QCOW2 or OVA). |
f5-analyzer |
Optional pod that analyzes and routes LLM‑related traffic. It uses dynamic routing based on traffic complexity and load. You enable it in the CNEInstance ( |
F5-IPSD |
Optional deep packet inspection pod that validates configurations, compiles SNORT‑compatible signature blobs, and sends them to TMM for enforcement. You enable it in the CNEInstance ( |
CRDs (Custom Resource Definitions) |
Kubernetes resources for declaring networking, security, and lifecycle policies. Includes CRDs for firewalls, DDoS profiles, SNAT pools, egress gateways, and CNEInstance. |