VPP Data Plane
Status: the VPP component manages the VPP process lifecycle (startup,
crash recovery, DPDK NIC binding, GoVPP connection), the fib-vpp plugin
programs routes from ze's system RIB directly into VPP's FIB via the
GoVPP binary API, and the stats segment is polled for per-interface,
per-node and system-wide Prometheus metrics.
The FIB plugin also programs MPLS label stacks on IP routes. The VPP-native
interface backend is registered as vpp. The
SRv6 path creates a
single-Service-SID encapsulation policy before installing prefix steering.
Why VPP is in Ze
Ze is a BGP daemon. BGP produces forwarding decisions; something else has
to carry the packets. The default answer on Linux is the kernel route
table, programmed via netlink by the fib-kernel plugin. That works,
but it puts every packet through the kernel's software forwarding path,
which tops out at a few Mpps on commodity hardware and starts dropping
under bursty load.
VPP (the FD.io Vector Packet Processor) is a user-space software router built on DPDK. It takes the NICs away from the kernel, batches packets into vectors, and walks each vector through a graph of forwarding nodes with hot caches. On the same hardware where the kernel loses packets, VPP forwards at line rate: roughly 35 Mpps on a 4-core Xeon D-1518, with numbers like 18 Mpps per thread for MPLS and around 14 Mpps per thread for VXLAN. IPng Networks has run this stack in production on AS8298 for several years.
Adding VPP to ze is not about replacing BGP. It gives ze a forwarding-plane answer for IXP route servers, production edge routers, and gokrazy appliances on small hardware such as an N100 mini-PC. The control plane stays in ze (BGP, RIB, config, CLI, web UI). The forwarding plane becomes VPP. The two talk through a small, typed interface (GoVPP over a Unix socket).
How the two halves fit together
┌──────────────────────────────────────────────────────────┐
│ ze │
│ │
│ BGP reactor ──▶ protocol RIB ──▶ sysRIB │
│ │ │
│ ┌──────┴──────┐ │
│ │ │ │
│ fib-kernel fib-vpp │
│ (netlink) (GoVPP) │
│ │ │ │
│ ▼ ▼ │
│ Linux FIB VPP FIB │
│ (local) (transit) │
│ │
│ vpp component: starts VPP, binds NICs, watches health │
└──────────────────────────────────────────────────────────┘
Ze keeps two FIB backends and runs them side by side. fib-kernel
still programs the Linux route table so local services (SSH, the web
UI, BGP TCP sessions) keep working. fib-vpp pushes the same best
routes into VPP's FIB via the GoVPP binary API, so transit packets
are forwarded by VPP at DPDK speed. Both plugins subscribe to the
(system-rib, best-change) event on the EventBus and react
independently.
BGP sessions themselves still use Linux sockets. VPP's Linux Control
Plane (LCP) plugin mirrors every VPP interface as a TAP device, so ze's
BGP reactor bind()s and connect()s exactly as it does on a kernel
NIC. VPP is invisible to the BGP code path.
Which namespace those TAPs land in is a separate question, and it is
the one live limitation here. LCP creates them in the namespace named by
vpp.lcp.netns, which defaults to dataplane, following the IPng
production convention that isolates the forwarding plane from the
management plane. Ze's BGP reactor has no network-namespace
awareness: it binds in whatever namespace the ze process itself runs
in. So on the shipped default, ze's BGP cannot bind on an LCP-shadowed
interface unless ze is itself running in the dataplane namespace.
Setting vpp.lcp.netns to host or root does not work around
this. To VPP those are ordinary namespace names: it resolves the value
to the path /var/run/netns/<name>, and ze passes the same leaf to VPP
as its global default netns, which VPP falls back to for any pair that
carries no namespace of its own. So host asks VPP for a namespace
literally called host, which normally does not exist.
Two remedies work today. Leave vpp.lcp.netns empty: that clears VPP's
global default netns, and LCP then creates the TAPs in VPP's own
namespace, where ze runs. Or run ze's BGP in the namespace the leaf
names. Nothing else does, until BGP learns to bind inside a named
namespace (specced, not implemented).
ze doctor reports doctor-vpp-lcp-netns for any non-empty
vpp.lcp.netns, and a BGP stanza is not required to see it: host and
root get one warning of their own, because the value is wrong even
where nothing binds. On Linux the check also opens the namespace
directory, and reports a namespace that is absent (LCP pair creation
would fail at apply) separately from a probe that could not answer. Run
ze show diagnostic doctor-vpp-lcp-netns for the detail.
The accepted character set for the leaf is what VPP can carry through: printable,
no whitespace, no path separator, under 256 characters. VPP's own parser reads the
leaf with unformat(line_input, "netns %s", &ns), and %s ends at a space, tab,
newline, or carriage return rather than refusing the input. So netns my ns would
reach VPP as my, VPP would build /var/run/netns/my, that namespace would not
exist, and LCP pair creation would fail at apply on a config ze had accepted.
Config verify refuses the value instead.
A second check covers the plugin rather than the namespace. Enabling vpp.lcp
makes ze write a startup.conf that loads linux_cp_plugin.so. A VPP built
without it accepts the config and then fails the WHOLE apply at the binary-API
layer, with a raw VPP error that names the failing message rather than the missing
plugin. ze doctor reports doctor-vpp-lcp-plugin first. The probe reads the
RUNNING VPP with vppctl show plugins, not the filesystem: what matters is what
the loaded VPP has, not whether a copy exists on disk. An absent enabled leaf
reads as on, matching the YANG default.
Severity follows what the probe proved. A probe that answers and does not list
the plugin is an ERROR, and ze doctor reports the host as not ready. A probe
that cannot answer degrades to a WARNING and never claims the plugin is missing.
vppctl exits non-zero identically for an absent binary, an absent socket, and a
wedged VPP. A zero exit counts as an answer only when the output carries the
Plugin path is: line VPP prints ahead of the plugin rows: empty or truncated
output lists no plugin at all, so it is a WARNING too. None of those is evidence
about which plugins VPP loaded.
What ze does for you
When vpp.enabled is true, ze takes ownership of the whole VPP
lifecycle. You do not run systemd start vpp; you do not edit
/etc/vpp/startup.conf; you do not dpdk-devbind your NICs by hand.
Ze does the following, in order, every time it starts or VPP crashes:
| Step | What ze does | Code |
|---|---|---|
| 1 | Parses the vpp { ... } YANG section into VPPSettings |
internal/component/vpp/config.go |
| 2 | Validates PCI addresses, socket paths, netns names, size strings | config.go: Validate |
| 3 | Renders startup.conf (unix, api-segment, socksvr, cpu, buffers, dpdk, plugins, linux-cp, linux-nl, memory, statseg sections, some conditional) |
startupconf.go: GenerateStartupConf |
| 4 | Loads vfio, vfio_pci, vfio_iommu_type1 kernel modules |
dpdk.go: loadVFIOModules |
| 5 | For each configured PCI address: reads the current driver, saves it, unbinds, binds to vfio-pci | dpdk.go: bindPCI |
| 6 | Execs the VPP binary with -c <generated startup.conf> |
vpp.go: runOnce |
| 7 | AsyncConnects GoVPP to (10 attempts, 1 s apart). /run/vpp/api.sock |
conn.go: Connect |
| 8 | Emits ("vpp", "connected") on the EventBus |
vpp.go: emitEvent |
| 9 | Starts the stats poller (per-interface, per-node, system metrics) | telemetry.go |
| 10 | Waits for VPP to exit. On crash: emits ("vpp", "disconnected"), backs off (1 s, 2 s, 4 s, capped at 30 s), restarts, emits ("vpp", "reconnected"). fib-vpp replays the RIB on reconnect. |
vpp.go: Run loop, fibvpp.go: reconnect handler |
| 11 | On clean shutdown: SIGTERM VPP, triggers a PCI rescan, restores the original NIC drivers | vpp.go: defer, dpdk.go: UnbindAll |
The point is that VPP's system-level prerequisites (vfio module load, NIC unbind, driver save, rescan-on-teardown) are part of ze's job, not the operator's. This matters on a gokrazy appliance where there is no systemd and ze is PID 1 for the data plane.
The generator targets upstream VPP v26.06 grammar. In particular, it writes
buffers { default data-size 2048 ... }, linux-nl { nl-rx-buffer-size 67108864 },
and memory { main-heap-size ... }. The
deployment reference
maps every emitted directive to its release-pinned consumer. Grammar matching
and unit tests are not proof of native startup: the installed VPP plugins,
hugepage reservation, CPU affinity and device/namespace permissions must also
support the selected configuration.
Running against an externally supervised VPP
Set vpp.external true when something other than ze owns the VPP
process -- a systemd unit, a container sidecar, or the Python stub
the functional tests use. In this mode ze skips steps 3, 4, 5, 6 and 11
of the table above: no startup.conf generation, no vfio module load,
no NIC unbind, no exec vpp, no PCI rescan on shutdown. Ze still
connects via GoVPP at step 7, emits the same lifecycle events at step 8,
runs the stats poller at step 9, and blocks on context cancellation
instead of cmd.Wait at step 10.
Typical configurations:
vpp {
enabled true;
external true;
api-socket /run/vpp/api.sock;
}
The operator owns startup.conf, owns the systemd unit, owns the vfio
bind. Ze owns the API socket conversation and the FIB programming.
Use this for:
- Systemd deployments: the system VPP unit starts before ze, ze connects to its API socket on startup.
- Gokrazy containers: a sidecar image bundles
vppandze; the supervisor starts VPP first, then ze withexternal true. - Functional tests:
./le test functional vppdrives the compiled Go VPP stub instead of a real VPP. Seedocs/functional-tests.mdfor the harness.
The real-VPP deployment action, ./le test deployment vpp, stops each Ze
daemon by signalling its exact command inside the container, not the host
docker exec client. Each replacement must reach its own startup marker before
the harness inspects retained VPP state. A policer or ACL left by the previous
daemon therefore cannot make a failed replacement look like a successful restart.
A stop returns only once the daemon has exited, because a stopping ze still owns
its config store while it finishes recording its boot configuration, which on a
slow disk takes seconds. It waits up to two minutes after SIGTERM, then sends
SIGKILL. A daemon that needed SIGKILL, or that is still running after it, fails
the run with its command named, and no further daemon starts, since it may still
own the store the next one would open.
vpp and vpp-iface start their container through the lab Docker
wrapper, which labels it with the run that owns it. Ctrl-C or SIGTERM ends the
run and still removes the container. A scenario the interruption caught ends at
once with the interruption as the run's error, never a FAIL for a feature the
run did not finish probing. When the removal fails, the report's
container-removal-error names the reason and the verb exits 1; run
./le test integration clean to remove it. A run killed outright leaves a
labeled container that the next lab start or that cleanup removes.
Configuring VPP
The vpp { ... } container lives in the main ze config. Minimal example:
vpp {
enabled true;
dpdk {
interface 0000:03:00.0 {
name xe0;
}
interface 0000:03:00.1 {
name xe1;
}
}
}
This selects the default heap, buffer count, stats segment and LCP settings. Starting native VPP also requires the host prerequisites below and the selected plugins. Add cores, tune memory, or change the stats poll interval when the defaults do not fit the workload.
Every leaf, what it does, what it defaults to
| Path | Type | Default | What it controls |
|---|---|---|---|
vpp.enabled |
boolean | false |
Master switch. false means ze does not start VPP at all. |
vpp.external |
boolean | false |
When true, ze connects to an existing VPP via api-socket but does NOT generate startup.conf, bind DPDK NICs, or exec the VPP binary. Use this on systemd-managed hosts, container sidecars, or the le test vpp stub harness. Default false preserves the ze-owned-lifecycle behaviour. |
vpp.api-socket |
string | /run/vpp/api.sock |
GoVPP Unix socket. Ze validates it is absolute, has no .., and fits in 108 characters. |
vpp.cpu.main-core |
uint8 | auto | CPU core pinned to the VPP main thread. The core is excluded from the worker set. Omit for VPP default. A core the host does not hold online is refused at commit. |
vpp.cpu.workers |
uint8 | auto | Number of worker threads. Ze takes the cores from the kernel's isolated set (/sys/devices/system/cpu/isolated), lowest first, main-core excluded and any CPU no longer online excluded, and writes them as corelist-workers. On a host that isolated nothing, the list falls back to main-core+1 .. main-core+workers and ze doctor reports doctor-vpp-cpu-isolation. A count the host cannot satisfy is refused at commit. |
vpp.cpu.worker-cores |
CPU list | unset | Explicit worker cores in the kernel's isolcpus syntax (2-4, 2,4,6). Names the cores instead of deriving them, and MUST NOT be set beside workers. A core off the host, a core that is also main-core, and a core listed twice are each refused at commit. |
vpp.cpu.poll-sleep |
Nms (0ms–100ms) |
unset | Fixed sleep between VPP main-loop polls, expressed in whole milliseconds (ms is the only accepted unit, e.g. 10ms), emitted as unix { poll-sleep-usec N } (1ms = 1000µs). Omit for lowest latency (workers busy-poll at 100% CPU); set a non-zero value on shared or dev hosts to trade latency for idle CPU. An explicit 0ms is emitted and equals VPP's default. |
vpp.memory.main-heap |
size string | 1G |
Emitted as memory { main-heap-size ... }. Ze leaves the heap page size at VPP's OS-page default. Use 1536M for a full DFZ (approximately 958k IPv4 + 198k IPv6 routes). |
vpp.memory.hugepage-size |
2M or 1G |
2M |
Sets the buffers and stats page-size directives: 2M emits default-hugepage (the kernel default, commonly 2M); 1G emits 1G. Neither selects ordinary 4K pages. |
vpp.memory.buffers |
uint32 | 128000 |
buffers-per-numa, beside fixed default data-size 2048. 128k is proven for full DFZ at 10G; packet data needs 250 MiB per NUMA node plus metadata and alignment. |
vpp.dpdk.interface[pci-address].name |
string | (required) | Short interface name used in ze (e.g. xe0). Must start with a letter, max 15 chars. |
vpp.dpdk.interface[pci-address].rx-queues |
uint8 | VPP default | Receive queues. Omit unless the NIC needs more. |
vpp.dpdk.interface[pci-address].tx-queues |
uint8 | VPP default | Transmit queues. Omit unless the NIC needs more. |
vpp.stats.segment-size |
size string | 512M |
Stats segment shared memory size. |
vpp.stats.socket-path |
string | /run/vpp/stats.sock |
Stats Unix socket path. Separate from the API socket. |
vpp.stats.poll-interval |
uint16 seconds, 1..3600 | 30 |
How often ze reads the stats segment for Prometheus metrics. |
vpp.lcp.enabled |
boolean | true |
Whether ze asks VPP to load linux_cp_plugin.so and linux_nl_plugin.so. Leave on when BGP uses VPP-owned NICs. ze doctor reports doctor-vpp-lcp-plugin when this is on and the running VPP does not load the plugin. |
vpp.lcp.sync |
boolean | true |
Mirror VPP state changes (link, MTU, IP) into the Linux TAPs. |
vpp.lcp.auto-subint |
boolean | true |
Auto-create Linux TAPs for dot1q and QinQ sub-interfaces. |
vpp.lcp.netns |
string | dataplane |
Network namespace where LCP TAPs appear, also emitted as VPP's global default netns. Must be printable, carry no whitespace and no path separator, and stay under 256 characters. VPP resolves the value as a name under, so it must be a namespace that exists: host and root are not special to VPP and do not mean "the host namespace". Ze's BGP has no netns awareness and cannot bind on a TAP in this namespace unless ze itself runs there. An EMPTY value is the exception: it clears VPP's global default netns and the TAPs stay in VPP's own namespace. ze doctor reports doctor-vpp-lcp-netns for every other value. See "How the two halves fit together". /var/run/netns/ |
vpp.plugins.wireguard |
boolean | false |
Load wireguard_plugin.so so the vpp interface backend can program WireGuard tunnels (interface { backend vpp; wireguard ...; }). ze doctor warns (doctor-vpp-wireguard) if a wireguard interface is configured under vpp with this off. |
Enabling FIB programming
The VPP component starts VPP, but it does not program routes. That is
fib-vpp's job, and it has its own switch under the fib container:
fib {
vpp {
enabled true;
table-id 0;
}
}
| Path | Type | Default | What it controls |
|---|---|---|---|
fib.vpp.enabled |
boolean | false |
Enable route programming. Off means the plugin loads but does nothing. |
fib.vpp.table-id |
uint32 | 0 |
VRF table ID. 0 is the default VRF. |
fib.vpp.batch-size |
uint16 | 256 |
Max routes per GoVPP batch. |
fib.vpp.batch-interval-ms |
uint16 | 10 |
Max milliseconds to wait before dispatching a partial batch. |
fib-vpp depends on the vpp subsystem and on the RIB plugin. If VPP
is disabled or the GoVPP channel fails to open, the plugin programs no
route and logs an ERROR naming the cause; the rest of ze keeps running.
When VPP connects, the plugin opens its writer and asks the system RIB to
replay every route. Until then show fib vpp answers the cause as an
error, never an empty route list.
SRv6 service routes
The received egress Service SID is the policy's segment. Ze allocates a separate local BSID for steering and shares the policy across prefixes using that SID. Replacement installs new steering before releasing the old policy; withdrawal releases a policy only after its final reference. This does not allocate egress Service SIDs or install remote endpoint behaviors.
Provide the IPv6 underlay route, encapsulation source, and required tables.
fib.vpp.table-id selects the policy and outer IPv6 lookup table. A nonzero
per-route table override selects destination steering, not the underlay table.
The existing Service-SID resolvability check remains a prerequisite.
Ownership uses durable daemon keys under meta/fib-vpp/srv6/. Restore validates
confirmed policy contents and live steering references before mutation.
An unconfirmed creation found live fails closed with its BSID in the error;
matching contents alone do not authorize adoption or deletion. Preserve that
state for operator reconciliation. External writers must not race Ze's live
ownership checks: VPP has no conditional steering replacement.
The ownership namespace admits at most 4,096 keys in total, not 4,096 routes. Policy, steering, and temporary ordinary-route fallback records all count. A transition reserves its complete growth before the first state or hardware write; replay and withdrawal of existing keys remain possible at the limit.
IP/SRv6 transitions retain durable planned and confirmed ordinary-route ownership by prefix and table. Restart restores confirmed cleanup ownership; an uncertain IP mutation fails closed for operator reconciliation. This is installation history, not inspection of a hidden API-source route: VPP's dump can expose the winning SR steering source instead. Other writers must not replace Ze-owned ordinary API-source entries, even sequentially. Matching live routes are never adopted as proof of ownership.
Normal Ze restart can reuse confirmed live ownership. Managed-VPP reconnect retires the old consumer, restores ownership, and requests system-RIB replay. Replay is partial, not a snapshot: omitted owned live routes remain until explicit withdrawal. External-VPP process restart does not emit the managed reconnect event. The real VPP proof defines state, packet, and restart assertions; prepared code is not observed forwarding evidence.
System prerequisites
VPP is not a user-space toy; DPDK needs real kernel cooperation. On a
general-purpose host Ze cannot set kernel boot parameters, so you reserve
hugepages yourself. On the gokrazy appliance Ze owns the kernel cmdline: set
image.hugepages (and optionally image.memory-bytes) in appliance.json and
ze appliance build bakes default_hugepagesz/hugepagesz/hugepages into the
boot cmdline for you (see the appliance guide). ze doctor reports
doctor-vpp-hugepages when VPP is enabled but the reservation is missing,
insufficient, or clamped.
The boot-time reservation proof is ./le test qemu vpp-hugepages. Its invocation
root covers the native host build, appliance build and boot-time SSH assertions;
SIGINT, SIGTERM or SIGHUP ends the active owned command group and prevents a later
phase or renderable verdict payload. QEMU is joined before the work directory is
removed. Normal completion first sends QEMU SIGINT and preserves its existing
ten-second shutdown grace; cancellation or an error closes the owned group
immediately. Host process-fixture tests establish that lifetime contract only:
a hugepage reservation still needs the actual booted kernel's
show host kernel and show host memory answers.
Before enabling VPP:
| Requirement | How to provide it |
|---|---|
| Hugepages (approximately 6 GB for production 10G, 2 GB for lab) | Appliance: image.hugepages { page-size, count } in appliance.json. Non-appliance host: echo 3072 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages or via. . /etc/sysctl.d/ |
| IOMMU enabled | BIOS: enable VT-d / AMD-Vi. Kernel cmdline: intel_iommu=on iommu=pt |
| CPU isolation for VPP workers | Appliance: image.isolated-cpus in appliance.json, which writes isolcpus, nohz_full and rcu_nocbs for those cores. Non-appliance host: the same three kernel cmdline arguments. Ze then draws its worker cores from that set, and ze doctor reports doctor-vpp-cpu-isolation when it cannot. |
| Netlink buffer for route injection | sysctl net.core.rmem_default=67108864 |
| Minimum hardware | 4 CPU cores, 8 GB RAM, a DPDK-compatible NIC |
Supported NICs through DPDK include Intel i210/i350, X520/X540, X710/XL710 and E810 families, plus VirtIO for VMs. Mellanox ConnectX-5 and later use RDMA in a bifurcated driver mode; the current ze implementation is DPDK only and does not yet bind Mellanox NICs.
Observing what VPP is doing
Two places expose VPP state through ze:
- Prometheus metrics. The stats poller exports per-interface
counters (rx/tx packets, bytes, drops, errors), per-node clocks and
vectors-per-call, and system-wide vector and input rates. Poll
interval is configurable via
vpp.stats.poll-interval.
- The
show fib vppcommand. Dumps the routesfib-vppbelieves it has installed in VPP, as JSON[{"prefix": ..., "next-hop": ...}, ...]. Before the plugin has started, or while it has no VPP connection, it answers an error saying why instead.
Direct VPP introspection (vppctl show int, vppctl show ip fib) is
still available through the CLI socket ze writes to /run/vpp/cli.sock.
Implementation status
Configured interface names can differ from VPP's names: a VLAN named
qos0.100 may appear as loop1.100 in VPP. Link and address reads resolve
the configured name through the same registered interface index used by
writes, so a reload updates the existing VLAN. If that registered index
cannot be read, the reload refuses instead of treating the VLAN as absent
and creating it again. An unregistered name is looked up as an exact VPP
interface name.
The implementation status differs by subsystem:
| Phase | Scope | Status |
|---|---|---|
| vpp-3 | MPLS label stacks on IP routes | processMPLSChange dispatches labeled route installs and replacements to addMPLSRoute, and removals to delMPLSRoute. The GoVPP backend sends IPRouteAddDel with a label stack for installs, every label in uniform mode, so the label TTL is copied from the IP TTL. Transit swap and pop entries from LDP and RSVP-TE arrive as (mpls-fib, entry) events: fib-vpp creates MPLS table 0 and installs each entry as two MplsRouteAddDel routes, one per value of the S bit, never in fib.vpp.table-id. A pop imposes the Implicit NULL label; an egress pop with no next hop looks the packet up in IP table fib.vpp.table-id of its FEC's family. VPP has no per-route MTU, so an entry's path MTU is not installed and fib-vpp warns once. A push into a private table (an RSVP-TE facility-backup context) is refused, because VPP has no packet-mark context. mpls { enable true; } on a unit enables MPLS input on the VPP interface. |
| vpp-4 | VPP-native iface.Backend: managing interfaces directly via GoVPP instead of through the kernel |
In tree. Backend registers as "vpp" and loads cleanly under interface { backend vpp; }. Interface lifecycle (CreateDummy/Bridge/VLAN, Delete, SetAdminUp/Down, SetMTU), addressing, bridge port add/del, query (ListInterfaces, GetInterface, GetMACAddress, SetMACAddress), and monitor (WantInterfaceEvents -> EventBus) all wired against vendored GoVPP. Tunnels (GRE/GRETAP/IPIP + VXLAN as a new kind), mirror (SPAN), wireguard, and LCP TAP pairs are now implemented (spec-followup-vpp-iface, GoVPP binapi vendored). GRE tunnels and wireguard interfaces are proven against real VPP 25.10 by; LCP pairs are unit- and wiring-tested but their real-VPP proof needs a VPP build shipping linux_cp_plugin.so/linux_nl_plugin.so (the ligato/vpp-base image does not). An interface apply that runs before the vpp handshake completes is deferred whole and performed when EventConnected fires (VPP backend). . internal/le/test/deployment.Answerdocs/features/interfaces.md |
| vpp-5 | L2 cross-connect, bridge domains, policers, ACLs, SRv6, sFlow | Depends on vpp-4. Each feature is independent. (VXLAN tunnels landed with spec-followup-vpp-iface.) |
| (netns) | Netns-aware BGP listening: BGP binds inside a named network namespace | Not in tree. RealListenerFactory.Listen binds via net.ListenConfig in whatever namespace the ze process runs in; nothing in the BGP reactor references a network namespace. So with the default vpp.lcp.netns of dataplane, BGP reaches an LCP TAP only if ze itself runs in that namespace (see "How the two halves fit together"). Specced, not implemented; ze doctor reports doctor-vpp-lcp-netns meanwhile. |
The three-strategy framing in
docs/research/ze-vpp-analysis.md
explains the bigger picture: strategy 1 (IPng / VyOS style, netlink
intermediary) is the safe default, strategy 3 (direct FIB programming,
what ze does) is where ze differentiates by skipping the kernel entirely
and converging sub-second on a full table.
References and further reading
| Resource | What to look at |
|---|---|
| VPP deployment reference | startup.conf reference, NIC matrix, performance baselines, LCP details |
| Ze and VPP analysis | Three-strategy feasibility analysis (strategy 1 / 2 / 3, LOC estimates, risks) |
| VPP deployment notes | Consolidated notes from 83 IPng.ch articles (production architecture, article index by topic, key tools, upstream contributions) |
| IPng.ch blog, VPP + LCP series (2021-08 to 2021-09, 7 parts) | How the LCP plugin works, end to end |
| IPng.ch blog, VPP configuration series (2022-03 / 2022-04) | vppcfg's DAG-based declarative config (the non-ze way) |
| IPng.ch blog, VPP monitoring (2023-04) | Stats segment interpretation, vectors-per-call |
| IPng.ch blog, VPP MPLS series (2023-05, 4 parts) | MPLS label operations in VPP (context for vpp-3) |
| IPng.ch blog, VPP sFlow series (2024-09 to 2025-02, 3 parts) | Context for future vpp-5 sFlow feature |
| go.fd.io/govpp documentation | Binary API client, stats client, binapi code generation |
| VPP 25.02 documentation | API reference for the modules ze targets |