Rootless Docker Networking: Limitations and Workarounds
Without root, port forwarding, host networking, and driver support all change. The real limits of rootless container networking and the workarounds that hold up.
Published on • November 19, 2026
AI Assistant

Rootless mode trades a privileged daemon for a user namespace, and most of that trade is invisible — until you care about packets. Published ports still work, containers still reach the internet, DNS still resolves names, but the machinery underneath is different enough that performance, source IPs, host networking, and driver support all behave unlike the rootful daemon you are used to. This post is about exactly those differences; the install steps and the general limits live in the rootless concepts post.
What actually changes without root
The dockerd-rootless.sh wrapper executes dockerd inside its own user, mount, and network namespace, set up by RootlessKit. Everything follows from that one fact:
- The daemon has no privileges over the host’s main network namespace, so it never touches your host firewall tables. Its rules live inside the RootlessKit namespace where it runs — which also means host-level
iptablespolicy and container traffic are no longer interacting the way they do on a rootful bridge host. - Outbound traffic is carried by a user-mode TCP/IP stack chosen at runtime:
slirp4netnswhen installed, otherwisegvisor-tap-vsock, withvpnkitlisted as legacy andpastaas experimental. The docs are candid: a stack running in user mode is slower than the kernel’s. - Everything the container owns — addresses, interfaces — is namespaced, so host-side tooling sees a different picture than
docker inspectdoes.
Port forwarding: the port driver matrix
Published ports are implemented by RootlessKit’s port driver, which forwards from the host network namespace into the child. The supported combinations and their characteristics, per the rootless troubleshooting docs:
| Network driver | Port driver | Net throughput | Port throughput | Source IP propagation |
|---|---|---|---|---|
gvisor-tap-vsock (default when slirp4netns absent) | builtin | Slow | Fast | Yes, since RootlessKit v3.0 |
slirp4netns (default when installed) | builtin | Slow | Fast | Yes, since RootlessKit v3.0 |
vpnkit (legacy) | builtin | Slow | Fast | Yes, since RootlessKit v3.0 |
pasta (experimental, needs pasta 2023_12_04+) | implicit | Slow | Fast | Yes |
lxc-user-nic (experimental) | builtin | Fast | Fast | Yes |
Pick drivers with a systemd override:
mkdir -p ~/.config/systemd/user/docker.service.d
cat <<'EOF' > ~/.config/systemd/user/docker.service.d/override.conf
[Service]
Environment="DOCKERD_ROOTLESS_ROOTLESSKIT_NET=slirp4netns"
Environment="DOCKERD_ROOTLESS_ROOTLESSKIT_PORT_DRIVER=slirp4netns"
EOF
systemctl --user daemon-reload
systemctl --user restart docker
The source-IP caveat is the one that bites in production. With RootlessKit v3.0+, builtin propagates source IPs — but only if Docker’s userland-proxy is disabled, because the userland proxy is incompatible with that propagation. Add this to ~/.config/docker/daemon.json and restart:
{"userland-proxy": false}
The docs add that you may also need the br_netfilter kernel module loaded. Without this, every connection in your logs appears to come from localhost, which quietly ruins allowlists and audit trails.
Host networking is not your host network
Historically (before Docker Engine v29.5) docker run --net=host shared a network namespace that was itself namespaced inside RootlessKit — containers listening there were not reachable from the real host network. Since Engine v29.5, --net=host shares the actual host network namespace. Either way, treat it as a security decision: the documented workaround for the old behaviour was to use docker run -p, and the documented speed workaround today is exactly the trade of --net=host against isolation.
Related: the IPAddress shown by docker inspect is namespaced inside RootlessKit’s namespace and is not reachable from the host without nsenter-ing into that namespace. From the host, ping 172.x.x.x fails for that reason alone — not because networking is broken. Use docker run -p to reach containers, and test container-to-container traffic from inside containers.
Ping, privileged ports, and exposure
Three sharp edges from the docs, each with a fix:
Ping may not work at all. If /proc/sys/net/ipv4/ping_group_range is 1 0, ICMP echo fails for unprivileged users:
$ cat /proc/sys/net/ipv4/ping_group_range
1 0
$ sudo sysctl -w net.ipv4.ping_group_range="0 2147483647"
Privileged ports cannot be exposed. docker run -p 80:80 fails with cannot expose privileged port 80. Your documented options: publish on 8080 instead, set net.ipv4.ip_unprivileged_port_start=0, or grant CAP_NET_BIND_SERVICE to the rootlesskit binary (sudo setcap cap_net_bind_service=ep $(which rootlesskit)).
Exposure behaves normally otherwise. Port-publishing semantics are unchanged: plain -p 8080:80 binds all interfaces, so a rootless service is LAN-reachable like any other — pin -p 127.0.0.1:8080:80 for local-only services (see the port binding post). Extra forwards outside Docker can be requested before the daemon starts, as the tips page shows for the API socket: DOCKERD_ROOTLESS_ROOTLESSKIT_FLAGS="-p 0.0.0.0:2376:2376/tcp". For manual ports at runtime, RootlessKit documents rootlessctl --socket=... add-ports 0.0.0.0:8080:80/tcp.
Drivers: what you cannot create
- Overlay networks are unsupported. The troubleshooting page lists “Overlay network” among features rootless mode does not support — no Swarm-style multi-host networks from a rootless daemon.
- macvlan is unsupported. The macvlan driver docs say it outright: “The macvlan driver is not supported in rootless mode.” It also needs a physical
parentinterface, which the rootless namespace cannot claim from the host. - ipvlan is not documented either way. It has the same parent-interface requirement, so treat it as unverified territory and test before designing around it.
- Bridge networks — including
--internal— and embedded DNS work normally. Name resolution is implemented by the daemon inside the namespace, so container-to-container discovery on user-defined bridges is unaffected by rootlessness.
Performance workarounds, in order
- Use the
builtinport driver (the default with slirp4netns/gvisor-tap-vsock). RootlessKit’s own benchmarks putbuiltinat ~29.9 Gbps for port forwarding versus ~8.03 Gbps for theslirp4netnsport driver — port forwarding is the fast path; it is the network driver that is slow. --net=hostfrom Engine v29.5+ bypasses the user-mode stack entirely, at the cost of sharing the host network namespace. The docs list it as a documented workaround for “Network is slow”.lxc-user-nicnetwork driver (experimental) removes the user-mode stack without giving up isolation, but needs/etc/lxc/lxc-usernetconfigured and the rootful daemon switched off so its iptables rules do not interfere. ADOCKERD_ROOTLESS_ROOTLESSKIT_MTUoverride lets you tune MTU alongside it.- Bigger buffers:
DOCKERD_ROOTLESS_ROOTLESSKIT_MTUexists precisely because the user-mode path is sensitive to MTU mismatches — worth setting when throughput stalls at odd sizes.
One thing not to confuse: vpnkit appears in rootless documentation as a legacy Linux network driver, while Docker Desktop on Mac/Windows does not use rootless networking at all — Desktop funnels everything through its backend process inside a VM.
The practical pattern: front it with root
For LAN-facing services, the pattern that keeps both properties is a root-level reverse proxy — nginx, Caddy, or Traefik running as a normal rootful service or systemd unit, bound to 80/443 — in front of rootless containers published on high ports. The privileged process holds the privileged socket, the rootless daemon holds the workload, and you sidestep ip_unprivileged_port_start entirely. The same shape covers VPN or overlay-tool access for remote networks: terminate the tunnel at the host, proxy into the published ports, and never depend on container IPs being visible outside the rootless namespace.
The bottom line
Rootless networking works — bridge networks, internal networks, embedded DNS, and published ports all behave as documented — but three things change: forwarding runs through RootlessKit’s port driver (fast ports, slow network, source IPs only with v3.0+ and userland-proxy disabled), container addresses and --net=host semantics live inside a namespace until Engine v29.5+, and overlay/macvlan simply are not available. Plan for high ports or a root-level proxy, expect user-mode-stack throughput until you take a documented workaround, and test ping, source IPs, and driver support before migrating anything real.