文章标题:一台虚拟机上跑 1500 万个 Web 服务器——smoltcp、DPDK、AF_XDP
正文: 把一台 Web 服务器放到网上,所有人都会开始试图黑它。为什么?一条基本的经济学规律。供给少、需求大——Web 服务器不够所有人用。让我们为地球上的每个人各跑一台 Web 服务器,全部 80 亿人。我没能拿到融资,所以我们只能自举。目标是在一台 10GB 内存、1 个 CPU 核心的虚拟机上跑 1500 万台 Web 服务器。如果成功了,我就从家里翻出几台旧微波炉里的内存条,然后扩展规模,让每个人都能拥有自己的 Web 服务器。需求将降为零,网络安全也将一劳永逸地得到解决。
Web 服务器
与其全靠 vibe coding,不如使用一种名为“学习”的古老技术。首先,什么是 Web 服务器?有几个必不可少的系统调用。
- listen——系统调用,请求内核在某个 socket 上监听连接
- accept——系统调用,在某个 socket 上接受一个连接
- recv——从 socket 接收数据
- send——发送数据
- close——关闭
什么是系统调用?由操作系统内核执行的函数。无论你用什么花哨的语言或库来做 HTTP,最终都归结为这些系统调用(嗯,是的,但实际上不是)。我们用 C 把它全部显式写出来。我们开始监听,然后在循环中从 socket 读取,并且总是回复 OK。
int main(void)
{
// We use port 0 which makes OS return any available port
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 上监听、接受连接、读取数据、发送回复、关闭客户端连接,然后重复。这能给我们带来大约 65k 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 端口来接收传入数据。你在 Firefox 里开着 example.com,结果 mysql 启动不了,这会造成令人困惑的用户体验。
- 端口 60999 - 65535 被排除是出于可追溯到 IP Masquerading 的历史原因。
没有什么阻止我们覆盖这个范围并使用 1-65535,但这距离 1500 万还是差了点。UDP 服务器和 TCP 服务器可以使用同一个端口,所以我们可以把它翻倍到 128k。我们可以在前面跑一个代理,把请求转发到正确的进程(虚拟主机,耶),但这些都是古老的技术——在 AI 时代,每当你有软件问题,你只需往硬件上砸钱。我们干脆给服务器接上 15M/32k=450 块新网卡。

一台虚拟机上运行 1500 万台 Web 服务器 – smoltcp、DPDK、AF_XDP
65k 的限制来自 TCP 标准。端口是一个 u16,所以即使我们用 find '*.c' -exec sed -i 's/u16/u32/' \; 来修改内核以支持更大的端口号,普通客户端仍然无法连接。每个监听服务器都由一个 (协议, IP, 端口) 元组标识。这就解释了为什么我们可以为 UDP 和 TCP 使用同一个端口。这也意味着我们可以为 Web 服务器使用一堆不同的 IP。如果我们把 450 块网卡连接到服务器上,我们就会得到 450 个唯一 IP 地址,并能够监听 1500 万个唯一地址!
更新。我从读者那里听说,网卡是过去一年里唯一没有涨价 100 倍的硬件组件。我们能不能避免把这一点也毁掉,而是在软件层面解决这个问题?
让我们使用一种叫做 AnyIP 的漂亮技术,它让我们可以监听整个子网。许多 VPS 和独立服务器提供商通常会给你一整个 TCPv6 子网。我们可以直接运行 sudo ip -6 route add local 2001:db8:1234:5678::/64 dev lo,从而获得 1800 亿亿个地址(正负一个)用于监听。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 的预算多了几个字节。
运行时
纯属巧合(概率有多大?),我在 Running 10 million Codex CLIs on one server - LFI processes 中解释了为什么运行数百万个进程会产生过多开销。答案是让它们全部运行在一个自定义运行时中的单个进程里,就像 V8 可以在单个进程中运行数百万个 guest 一样。在 Userland Linux scheduler in Rust 中,我展示了如何构建一个专门的用户态调度器,并以每个任务绝对最少的内存在不同任务之间切换。
TLDR:我们使用 LFI 进行沙箱隔离。它为我们提供内存隔离,并将所有系统调用替换为对宿主处理器的调用,这让我们可以按自己喜欢的方式实现 I/O。为了调度多个 guest,我们把它们全部加载到主进程的内存中,并让 CPU 不断在 guest 之间切换——我们成为自己的微型 OS。
由于我们需要尽可能节省每一个字节和每一个 CPU 周期,我们注定要构建另一个专门的运行时。让我们开始吧。10GB 除以 1500 万,到底是多少?

十个英国除以 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
}
文章标题:一台虚拟机上运行 1500 万个 Web 服务器 —— smoltcp、DPDK、AF_XDP
正文: 每个 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 字节,无论这个 socket 是活跃的、正在监听,还是什么都不做。Linux 显然是在内存又大又便宜的时代写出来的,唉。让我们问问 AI 这些内存都去哪了:
| Struct | sizeof | Description |
|---|---|---|
| struct tcp_sock | 2240B | TCP 状态、队列、定时器、序列号、拥塞控制、重传与交付记账 |
| struct socket_alloc | 768B | 一个 128 字节的 struct socket 内嵌等待队列,外加 608 字节的 sockfs inode 和填充 |
| struct file | 184B | 打开文件操作、标志、凭据、引用计数,以及指回 socket 的指针 |
| struct dentry | 192B | sockfs 伪名称、inode 指针,以及 VFS 查找与生命周期记账 |
| Total | 3384B |
土豆就是土豆,TLDR,内核把这些内存用在很多事情上。我本希望能看到某个 buffer: [u8; 3300],但看起来不重写半个内核是优化不了多少的。今天是周日,我剩下的 token 也不多了,所以我们只能动脑子想——怎么绕过内核?
我们有哪些选择?工程智慧告诉我们,如果一个任务解决不了,那说明我们在错误的抽象层级上工作。嗯……层级、层级、层。等等!我们从 HTTP 开始,往下走到了 TCP/IP。这让我想起了点什么!妈!妈!我大学课本都放哪了?我现在就要!

OSI 模型是……呃……我大学学过的东西。对,这是个好定义。我们从应用层的应用和 HTTP 开始,然后下到传输层的 TCP/IP。那下面还有三层。我们能不能再往下,获得完全控制并解决内存问题?哦能,这正是工作在网络层和数据链路层能让我们做到的事。那再往下到最底层呢?

每一层都会把上一层的数椐包起来。
| HTTP 应用 · L7 | TCP 传输 · L4 | IP 网络 · L3 | 以太网数据链路 · L2 | 物理层 L1 |
|---|---|---|---|---|
| GET / | 载荷 | 载荷 | 载荷 | ⚡ 💩 |
| 源端口 50123 | ||||
| 目的端口 80 | ||||
| Seq 1001 | ||||
| ACK 7001 | ||||
| 标志 ACK | ||||
| 源 IP 192.0. 2.10 | ||||
| 目的 IP 198.51. 100.20 | ||||
| TTL 64 | ||||
| 协议 6 (TCP) | ||||
| 目的 MAC 02:00:00: 00:00:fe | ||||
| 源 MAC 02:00:00: 00:00:01 | ||||
| EtherType 0x0800 (IPv4) | ||||
| FCS CRC |
TCP/IP 是有状态的,但它下面的一切都是无状态的。底层各层都不关心也不了解载荷,所以没有什么阻止我们发送新的 IP 包,甚至用自己手工构造的二进制数据发送以太网帧。我们只需要自己重新实现 TCP 和 IP 协议栈。有这样的例子吗?嵌入式开发者已经解决过这个问题数百万次了。最极端的例子是 Adam Dunkels 的 Miniweb —— 它把自定义的 TCP/IP 实现和一个 HTTP 服务器结合在一起,总共只需要 28 个字节(B-Y-T-E-S)就能工作。
不过,也有大量没那么极端、更成熟的实现:
- gVisor 基本上重新实现了整个操作系统,包括网络协议栈
- Seastar 是一个完整的运行时,自带网络协议栈,出自 ScyllaDB 背后那支了不起的团队
- lwIP 是一个流行的 TCP/IP 的 C 实现
- 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。
单台虚拟机上的 1500 万 Web 服务器 —— smoltcp、DPDK、AF_XDP
DPDK 让你的程序使用以太网帧直接与硬件网卡通信,绕过整个内核网络栈。你读写一块内存映射缓冲区,无需系统调用:想发送数据时——只需把它写入缓冲区就完成了;想读取已接收的数据时——它已经在那里了。
还有另一个不那么明显的优势——当新数据包到达你的网络设备时会发生什么?中断触发,CPU 核心停止执行你的应用,切换到内核,处理中断,然后回到你的应用。现在想象大量的传入数据包,多到你的应用 constantly 被打断。它有一个好听的名字,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,如果我们想要完全控制,只需要实现带有 3 个方法的 Device trait。或者,我们可以使用现有的 crate rust-dpdk-net 用于 DPDK,xsk-rs 用于 AF_XDP 来帮助我们。
现在最终的流程是:
- 运行时将 1500 万个 Web 服务器 guest 加载到其内存中
- 运行时调度器开始逐个执行 guest
- guest 的系统调用被运行时拦截,并由 smoltcp 网络栈及其适配器替代
- 所有 1500 万个 guest 开始监听,每个都有自己的地址
- 调度器轮询来自 smoltcp 适配器的传入数据,唤醒一个 guest,让它处理数据,然后切换到下一个
现在我们终于可以结束这篇文章了。内核网络栈在大约 250 万个 Web 服务器时耗尽所有 RAM,而且随着我们运行更多服务器,RPS 会下降。使用 smoltcp,RAM 使用增长更慢——每个空闲服务器 620 字节,活跃服务器约一千字节,我们达到了 1600 万个服务器。DPDK 显然是这个基准测试中的猛兽,AF_XDP 紧随其后:
为什么这如此令人兴奋?这意味着通过将网络栈移到用户态,你可以完全控制 RAM 使用并提升性能。而借助自定义运行时,你可以简单地让 guest 跑得更快。
“简单地”有点夸张——构建一个概念验证很容易。构建一个兼容的 Linux 运行时并以 100% POSIX 兼容性重新实现所有系统调用需要多费些心思。那是另一篇文章了。
参考资料
- https://github.com/artemyarulin/AI15M/tree/main/poc/ten-million-webservers 源代码
文章标题:单台虚拟机上 1500 万 web 服务器 – smoltcp、DPDK、AF_XDP
正文:
- https://medium.com/beyond-localhost/how-we-handle-15M-websocket-connections-on-a-single-server-8917c3952f59 DPDK 的优秀概览
- https://doc.dpdk.org/guides/index.html DPDK 主要文档站点
- https://docs.kernel.org/networking/af_xdp.html AF_XDP 概览