← 文章 / 编程开发
Hacker News 3天前 · 2026-11-19 17:19:11 · 6 阅读

一台 VM 跑 1500 万个 Web 服务器:smoltcp、DPDK 与 AF_XDP 实践

Web 服务器一上线,就有人开始想方设法黑它。为什么?这是经济学的基本规律:供不应求——地球上的 Web 服务器不够所有人用。那就给全球 80 亿人每人搞一个 Web 服务器吧。我没拉到投资,只能白手起家。目标是在一台只有 10GB 内存和 1 个 CPU 核心的 VM 上跑 1500 万个 Web 服务器。要是成功了,我就从家里的旧微波炉里拆点内存条出来扩容,让每个人都有自己的服务器。到那时需求归零,网络安全问题也彻底解决了。

Web 服务器

与其全靠 vibe coding,不如用一门古老的技艺——学习。首先,Web 服务器是什么?它离不开几个关键的 syscall。

  1. listen - 系统调用,让内核在某个 socket 上监听连接
  2. accept - 系统调用,接受 socket 上的一个连接
  3. recv - 从 socket 接收数据
  4. send - 发送数据
  5. close - 关闭连接

什么是 syscall?由操作系统内核执行的函数。不管你用多花哨的语言或库来处理 HTTP,归根结底都是这些系统调用(嗯,话是这么说,但其实也不完全是)。我们用 C 把一切写得更直白些:开始监听,然后循环读取 socket 数据,一律回复 OK。

int main(void)
{
    // 使用端口 0,让操作系统自动分配一个可用端口
    int server = socket(AF_INET, SOCK_STREAM, 0); 
    if (listen(server, 128) < 0)
        return 1;
    const char reply[] = "HTTP/1.0 200 OK\r\nContent-Length: 2\r\n\r\nOK";
    for (int client; (client = accept(server, NULL, NULL)) >= 0;) {
        if (recv(client, NULL, 4096, MSG_TRUNC) > 0)
            send(client, reply, sizeof reply - 1, MSG_NOSIGNAL);
        close(client);
    }
}

再简单不过了:监听 socket,接受连接,读取数据,发送响应,关闭客户端连接,然后循环往复。这能跑出大约 6.5 万 RPS。既然已经学完了全部知识,那这篇文章就可以收尾了:

$ for i in $(seq 1 15_000_000); do echo $i; ./server &; done
...
...
28232
program exited with error 1

嗯,为什么 listen 失败了?啊,端口不够用了!由于我们使用的是 port=0,内核会从 ip_local_port_range 中选取一个可用端口。

$ sysctl net.ipv4.ip_local_port_range
net.ipv4.ip_local_port_range = 32768    60999
为什么跳过了这么多端口?从历史来看,端口 0 最初是为出站连接设计的。当你调用 connect('example.com', 80) 时,Linux 会先连接远程服务器(发送部分),然后在主机上从 ip_local_port_range 中分配一个随机端口来接收数据(接收部分)。默认范围较小的原因有几个。
  • 端口 0 很特殊,不能用于监听(其实可以——https://acid.vegas/blog/the-port-that-does-not-exist/)。
  • 端口 1-1024 需要 root 权限。
  • 为了动态分配的端口不与现有应用冲突,端口 1024-32768 被跳过了。你肯定不希望调用 connect('example.com') 后,系统恰好分配了 3306 端口来接收数据,导致“MySQL 无法启动,因为你在 Firefox 中打开了 example.com”。
  • 出于早期 IP Masquerading 的历史原因,端口 60999 - 65535 被排除在外。

其实没有什么能阻止我们突破这个范围,直接用 1-65535,但离 1500 万还是差得远。UDP 服务器和 TCP 服务器可以共用同一个端口,这样能翻倍到 12.8 万。也可以在前面架个代理,把请求转发到对应的进程(虚拟主机,多经典),但这些都是老掉牙的方案了——在 AI 时代,遇到软件问题就直接砸硬件。干脆给服务器接上 15M/32k=450 张新网卡吧。

network card

6.5 万的限制来自 TCP 标准。端口是一个 u16,就算我们用 find '*.c' -exec sed -i 's/u16/u32/' \; 强行魔改内核让它支持更大的端口号,普通客户端也连不上。每个监听中的服务器由 (协议, IP, 端口) 三元组标识。这解释了 UDP 和 TCP 为什么能共用端口,也意味着我们可以给 Web 服务器分配一堆不同的 IP。只要给服务器接上 450 张网卡,就能拿到 450 个不同的 IP,从而监听 1500 万个不同的地址!

UPD. 有读者告诉我,网卡是去年唯一没有涨价 100 倍的硬件。我们能不能别把它也毁了,用软件解决这个问题?

不妨用一个很棒的技术:AnyIP,它让我们可以监听整个子网。很多 VPS 和独立服务器提供商会直接给你一整个 TCPv6 子网。只需运行 sudo ip -6 route add local 2001:db8:1234:5678::/64 dev lo,就能拿到 18 万亿亿个地址(差不多这个数)可供监听。IPv4 也一样可以操作——不过买一个有 1500 万个地址的子网大概要花 2.5 亿美元,所以请根据自己的环境调整命令。我们把服务器改成从地址段中取第 n 个 IP:

// Read IP index from CLI, shift base IP by it
int i = read_cli_param(argv[1]);
const uint32_t base_ip = 0x0a400001;  // ex. 10.64.0.1
addr.sin_addr.s_addr = htonl(first_ip + i);  // shift, ex. 10.64.0.2

这下终于可以把文章写完了。

$ for i in $(seq 1 15_000_000); do echo $i; ./server $i &; done
...
...
Out of memory

嗯,一台服务器占用 1.5MB 内存,这意味着如果真跑这么多服务器,大概需要… 20TB 内存,这比我们 10GB 的预算多出了几个字节。

运行时

纯属巧合(这概率得有多小啊),我在《在一台服务器上跑 1000 万个 Codex CLI – LFI 进程》里解释了为什么运行数百万个进程会产生过多的开销。解决办法是把它们全部放在一个进程里,在自定义运行时中运行,就像 V8 可以在单个进程中运行数百万个 guest 一样。在《用 Rust 写用户态 Linux 调度器》中,我展示了如何构建一个专用的用户态调度器,并以每个任务最少的内存开销在任务之间切换。

简单说:我们用 LFI 做沙箱隔离。它提供内存隔离,并将所有系统调用替换为调用我们的宿主处理器,这让我们可以按自己想要的方式实现 I/O。为了调度多个 guest,我们把它们全部加载到主进程的内存中,让 CPU 持续在它们之间切换 —— 我们自己就成了一个微型操作系统。

既然我们要节省每一字节和每个 CPU 周期,我们注定得再打造一个专用的运行时。开干吧。10GB 除以 15M,到底是多少?

wolfram

一亿英国人除以 1500 万,大约相当于半个“kilo britain”(千英国人)。不多。如果我们在运行时里跑所有 guest,我们的自定义调度器就需要在它们之间切换。那么,为每个 guest 必须保留的最小状态集是什么?我们可以忽略服务器初始化,假设切换只发生在主循环内。让我们再看一下这个循环。

for (int client; (client = accept(server, NULL, NULL)) >= 0;) {
        if (recv(client, NULL, 4096, MSG_TRUNC) > 0)
            send(client, reply, sizeof reply - 1, MSG_NOSIGNAL);
        close(client);
    }
这段代码只有两个状态变量:server 和 client,都是简单的文件描述符。如果我们的调度器需要在循环中的任意系统调用点挂起一个 guest,就需要保存如下状态:
struct Context {
    pc: u64,        // Instruction address to return to
    fd_server: i32, // server file descriptor
    fd_client: i32, // client file descriptor
}

每个 guest 只需要 16 字节,要在我们的运行时中运行 1500 万个 guest,并能随时挂起和切换它们,总共需要 220MB 内存。这里我还留了余量——其实用不着完整的 u64 和 i32,通过位压缩,每个 guest 应该可以压到 8 字节。那还需要什么呢?

$ codex "How much TCP connection takes?"
Idle connection takes zero, while active connection consumes around 5kb

假设任意时刻只有 100 万个连接处于活跃状态,我们会得到:

  • 1400 万个空闲连接 - 0 字节
  • 1500 万个 guest 的调度状态 - 220MB
  • 100 万个活跃连接 × 5kb = 5GB

只用了内存预算的一半,太好了!我可不常超出自己的预期。来验证一下:

int main(void) {
    // Run 14M of idle connections - just listen and do nothing
    // SHOULD CONSUMER ZERO MEMORY!
    for (int i = 0; i < 14_000_000; i++) {
        int server = socket(AF_INET, SOCK_STREAM, 0); 
        listen(server, 1)
    }
}
$ ./run_15m_idle_servers
Out Of Memory
$ dmesg | tail -n 1
'SHOULD CONSUMER ZERO MEMORY' - what are you, stupid?

看来内核里还残留着 Linus 式的毒舌评论。我不蠢,但得承认这次表现低于平均水平。LLM 对学习是很大的助力,但太容易不加批判地接受它的答案,之后才追悔莫及。不过没关系,出糗是入场费——那就深入看看内核里的网络实现吧。

内核中的网络

还记得我说过这个简单的服务器只用了 5 个系统调用吗?其实我还漏了一个近在眼前、被我忽略的系统调用。让我把它标出来:

int main(void)
{
    for (int i = 0; i < 10_000_000; ++i) {
        socket(AF_INET, SOCK_STREAM, 0);
    }
}

这段代码会在一台 10GB 内存的虚拟机中触发 OOM(内存溢出)。socket 系统调用大约消耗 3300 字节,不管这个套接字是处于活动状态、监听状态,还是完全闲置。显然,Linux 内核是在 RAM 又大又便宜的年代写的,唉。让我们问问 AI 这些内存都花哪儿去了:

结构sizeof说明
struct tcp_sock2240BTCP 状态、队列、定时器、序列号、拥塞控制、重传与交付记录
struct socket_alloc768B一个 128 字节的 struct socket(含嵌入的等待队列),加上 608 字节的 sockfs inode 和填充
struct file184B打开文件的操作、标志、凭证、引用计数,以及指回套接字的指针
struct dentry192Bsockfs 伪文件名、inode 指针,以及 VFS 查找和生命周期管理
总计3384B

一言以蔽之,内核用这部分内存做了很多事。我本以为能看见某个 buffer: [u8; 3300] 这样的缓冲区,但看来不重写半个内核,想优化出多少空间并不容易。今天是周日,我的 token 余额也不多了,那就得换个思路——怎么绕过内核?

我们有哪些选择?工程直觉告诉我们:如果当前方法解不了问题,说明抽象层级不对。嗯……层级,层级,层。等等!我们从 HTTP 开始,往下走到 TCP/IP。这让我想起点什么!妈!妈!我的大学教材都在哪?我现在太需要它们了!

osi_model

OSI 模型是……呃……我大学里学过的东西。行,这定义够用。我们最初的应用和 HTTP 位于 application(应用)层,然后下探到 TCP/IP 所在的 transport(传输)层。下面还有三层。再往下一点,能拿到完全控制权、解决内存瓶颈吗?当然可以,这正是 network(网络)层和 data link(数据链路)层的优势。那最底层呢?

physical layer

一目了然。

每一层都会封装上一层的数据。

HTTP应用层 · L7TCP传输层 · L4IP网络层 · L3Ethernet数据链路层 · L2物理层L1
GET /载荷载荷载荷⚡
💩
源端口50123
目标端口80
Seq1001
ACK7001
FlagsACK
源 IP192.0.2.10
目标 IP198.51.100.20
TTL64
Protocol6 (TCP)
目标 MAC02:00:00:00:00:fe
源 MAC02:00:00:00:00:01
EtherType0x0800 (IPv4)
FCSCRC

TCP/IP 是有状态的,但它下面的一切都是无状态的。更底层的各层既不知道也不关心载荷内容,所以我们完全可以自己手工构造二进制数据,发送新的 IP 包甚至 Ethernet 帧——只需要自己重新实现 TCP 和 IP 协议栈。有没有现成的例子?嵌入式领域的开发者早就做过无数次了。最极端的案例是 Adam Dunkels 的 Miniweb——它把自定义的 TCP/IP 实现和 HTTP 服务器合二为一,总共只需 28 个字节就能跑起来。

当然还有不少不那么极端、更成熟的实现:

  • gVisor 基本上重新实现了整个操作系统,包括网络栈
  • Seastar 是 ScyllaDB 团队打造的一套完整运行时,自带网络栈
  • lwIP 是流行的 C 语言 TCP/IP 实现
  • F-Stack 使用 FreeBSD 的 TCP/IP 协议栈

Go、C++ 和 C 都是不错的语言(至少还凑合),但都比不上我们心爱的 Rust 好用。因此我们选用了 smoltcp,它堪称惊艳:>smoltcp 是一个独立的、事件驱动的 TCP/IP 协议栈,专为 >裸机和实时系统设计。smoltcp 完全不需要堆内存分配

那么,直接 cargo add smoltcp 就万事大吉了吗?没那么简单。smoltcp 本质上是一个智能解析器,无法执行 I/O 操作。它如何与网卡通信?有 3 种方式:

  • TUN 是内核提供的虚拟网络接口,工作在 IP 层
  • TAP 是另一项内核功能,工作在更下一层的以太网层
  • DPDK 让你使用以太网帧直接与网卡通信,完全绕过内核

smoltcp 贴心地内置了前两种选项,使用起来也很简单。

fn main() -> std::io::Result<()> {
    let (mut device, config) = match std::env::args().nth(1).as_deref() {
        Some("tun") => (
            TunTapInterface::new("smoltun", Medium::Ip)?,
            Config::new(HardwareAddress::Ip),
        ),
        Some("tap") => (
            TunTapInterface::new("smoltap", Medium::Ethernet)?,
            Config::new(EthernetAddress([0x02, 0, 0, 0, 0, 2]).into()),
        ),
        _ => panic!("pass tun or tap"),
    };
    let mut iface = Interface::new(config, &mut device, Instant::now());
    iface.update_ip_addrs(|addrs| {
        addrs.push(IpCidr::new(IpAddress::v4(192, 0, 2, 2), 24)).unwrap();
    });
    let mut sockets = SocketSet::new(Vec::new());
    
    // Main network loop
    loop {
        let now = Instant::now();
        iface.poll(now, &mut device, &mut sockets);
        wait(device.as_raw_fd(), iface.poll_delay(now, &sockets))?;
    }
}
那第三个方案 DPDK 呢?当你对延迟要求极其苛刻时,每一次系统调用都是一道伤口。系统调用本身可能耗时 500ns,把数据从内核拷贝到用户态又可能再花 1000ns,取决于缓冲区大小。听起来微不足道,但要知道:高频交易公司打满 400Gbs 网卡是常态,也就是每秒处理多达 6 亿个包,平均每个包只有约 1.7ns。 DPDK 让你的程序直接用以太网帧与硬件网卡通信,完全绕过内核网络栈。读写都通过一块内存映射缓冲区完成,无需任何系统调用:想发数据,直接写进缓冲区就完事;想读收到的数据,它已经在那里了。 还有一个不那么明显的优势——当新数据包到达网卡时会发生什么?会触发一个中断,CPU 核心停下你的应用,切换到内核处理中断,然后再切回来。现在想象一下海量数据包涌入,你的应用被中断得没完没了。这种情况有个好听的名字,叫 livelock(活锁),我猜在生产环境里调试它是地狱中的地狱。DPDK 能帮你避开这一切,但代价也不小。 DPDK 的工作方式是运行一个忙循环,独占一个完整的 CPU 核心,不停地在内存和网卡之间双向搬运数据,大致像这样:
loop {
    send_from_app_memory_to_network();
    receive_from_network_to_app_memory();
}

还有一个不太明显的细节。DPDK 需要独占网络设备的访问权限,因为它使用的驱动程序运行在硬件层面——两个驱动程序无法同时操作同一个设备。一旦为网卡启用 DPDK 驱动……这个网卡就会从操作系统中“消失”。没错,启用后在 ifconfig 里看不到它,如果你是通过 SSH 连接并启用它,SSH 连接也会随之断开。可以想象这会引发不少趣事。

实际上,现在有了第四个选项——Linux 新增了 AF_XDP 子系统,它实现了类似的功能。它允许绕过内核网络栈,并使用相同的内存映射缓冲区机制实现零拷贝 I/O。内核仍然拥有设备的控制权,中断也照常发生。当新数据报文到达时,内核运行一个简单的 eBPF 过滤器,决定是将其直接发送到用户空间缓冲区(绕过网络栈),还是按正常流程处理。这意味着 SSH 依然可用。AF_XDP 支持一种替代模式 SO_PREFER_BUSY_POLL,其行为更接近 DPDK:通过牺牲一个 CPU 核心的算力换取无中断的忙轮询。尽管 DPDK 因完全绕过内核而性能略胜一筹,但 AF_XDP 已经非常接近(且管理起来简单得多)。

为了在 smoltcp 中支持 DPDK 和 AF_XDP,如果我们想要完全的控制权,只需实现 Device trait 并编写 3 个方法即可。或者,我们可以使用现有的 rust-dpdk-net crate 来支持 DPDK,或使用 xsk-rs crate 来支持 AF_XDP。

最终的流程如下:

  1. 运行时将 1500 万个 Web 服务器 Guest 加载到内存中
  2. 运行时调度器开始逐个执行 Guest
  3. Guest 的系统调用被运行时拦截,并替换为 smoltcp 网络栈及其适配器
  4. 所有 1500 万个 Guest 开始监听,每个使用独立的地址
  5. 调度器轮询 smoltcp 适配器的入站数据,唤醒一个 Guest 处理数据,然后切换到下一个

至此,文章终于可以画上句号了。内核网络栈在大约 250 万个 web 服务器时就耗尽了所有内存,且随着服务器数量增加,RPS 性能随之下降。使用 smoltcp 后,内存占用增长更平缓——空闲服务器仅占 620 字节,活跃服务器约 1 KB,最终支撑到了 1600 万 个服务器。DPDK 在此基准测试中表现最强,AF_XDP 紧随其后:

这为何令人兴奋?因为将网络栈移入用户态,就能完全掌控内存使用并提升性能。配合自定义运行时,还能让 Guest 运行得更快。

说“简单”可能有点言过其实——搭建概念验证(POC)确实容易。但要构建一个兼容 Linux 的运行时,并以 100% POSIX 兼容性重新实现所有系统调用,则需要更多的考量。以及另一篇文章。

参考资料

原始来源: Hacker News

评论 (0)