在一台虚拟机上跑 1500 万个 Web 服务器:smoltcp、DPDK、AF_XDP
15M web servers on one VM – smoltcp, DPDK, AF_XDP
作者尝试在 10GB 内存、1 核 CPU 的单台虚拟机上运行 1500 万个 Web 服务器。朴素 C 实现约 65k RPS,但端口上限 65535 使 1500 万监听地址无法实现,改用 AnyIP 在 IPv6 子网(如 /64)上监听可绕过端口限制。
2026年11月18日
把一台 Web 服务器放到网上,所有人都会开始尝试入侵它。为什么?一条基本的经济学规律:供给少,需求大——Web 服务器不够所有人分。让我们为地球上每一个人(全部 80 亿人)都运行一台 Web 服务器。我拿不到投资,所以我们自力更生。目标是在一台 10GB 内存、1 个 CPU 核心的虚拟机上运行 1500 万台 Web 服务器。如果成功,我就从家里的旧微波炉里找些内存,然后扩容,让每个人都能拥有自己的 Web 服务器。需求将降为零,网络安全问题将一劳永逸地解决。
Web 服务器
与其全靠 vibe coding,不如使用一种古老的技术,叫做 learning。首先,什么是 Web 服务器?有几个必不可少的系统调用。
listen- 系统调用,请求内核在套接字上监听连接accept- 系统调用,在套接字上接受连接recv- 从套接字接收数据send- 发送数据close- 关闭
什么是系统调用?由操作系统内核执行的函数。无论你用什么花哨的语言或库来处理 HTTP,最终都归结为这些系统调用(嗯,是的,但其实也不是)。让我们用 C 把它全部显式地写出来。我们开始监听,然后循环从套接字读取数据,并始终回复 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);
}
}再简单不过了:在套接字上监听、接受连接、读取数据、发送回复、关闭客户端连接,然后重复。这样我们能达到约 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来接收传入数据。mysql cannot start because you have example.com open in your Firefox会造成令人困惑的用户体验。 - 排除端口
60999 - 65535是出于可追溯到 IP Masquerading 的历史原因。
没有什么能阻止我们覆盖范围并使用 1-65535,但这仍然离 1500 万差一点。UDP 服务器和 TCP 服务器可以使用同一个端口,所以我们可以把它翻倍到 128k。我们可以在前面运行一个代理,把请求转发到正确的进程(虚拟主机,耶),但这些都是古老的技术——在 AI 时代,每当你有软件问题,你只需往硬件上砸钱。我们干脆给服务器接上 15M/32k=450 块新网卡。

65k 的限制来自 TCP 标准。端口是一个 u16,所以即使我们用 find '*.c' -exec sed -i 's/u16/u32/' \; 黑进内核以支持更大的端口号,普通客户端仍然无法连接。每个监听服务器由一个 (protocol, IP, port) 元组标识。这就解释了为什么我们可以对 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 的 RAM,所以运行那么多需要……20TB 的 RAM,这比我们 10GB 的预算多出几个字节。
运行时
纯属巧合(概率有多大?),我在 在一台服务器上运行 1000 万个 Codex CLI - LFI 进程 中解释了为什么运行数百万个进程会产生过多开销。答案是:在一个自定义运行时中把它们全部放在一个进程里运行,就像 V8 可以在单个进程中运行数百万个客户机一样。在 Rust 中的用户态 Linux 调度器 中,我展示了如何构建一个专门的用户态调度器,并以每个任务绝对最低的 RAM 量在任务之间切换。
TLDR:我们使用 LFI 进行沙箱化。它为我们提供内存隔离,并将所有系统调用替换为对我们的宿主处理程序的调用,这让我们可以按自己喜欢的方式实现 I/O。为了调度多个客户机,我们将它们全部加载到主进程的内存中,并让 CPU 不断在客户机之间切换——我们成为自己的微型操作系统。
由于我们需要节省每一个字节和每一个 CPU 周期,我们注定要构建另一个专门的运行时。让我们开始吧。10GB 除以 1500 万,究竟是多少?

十个大不列颠除以 1500 万,大约得到半个千不列颠。不多。如果我们在运行时中运行所有客户机,我们的自定义调度器需要在它们之间切换。每个客户机我们需要保留的绝对最低状态是什么?我们可以忽略服务器初始化,并假设切换只发生在主循环内。让我们再看一下这个循环。
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。两者都是简单的文件描述符。如果我们的调度器必须在这个循环中的任何系统调用点挂起一个客户机,我们需要保存以下状态:
struct Context {
pc: u64, // Instruction address to return to
fd_server: i32, // server file descriptor
fd_client: i32, // client file descriptor
}每个客户机我们只需要 16 字节,所以要在我们的运行时中运行 1500 万个客户机,并且能够挂起它们并在它们之间切换,我们需要 220MB 的 RAM。我们在这里保守行事——我们不需要完整的 u64 或 i32,而且通过位打包,我们可能可以降到每个客户机 8 字节。我们还需要什么?
$ codex "How much TCP connection takes?"
Idle connection takes zero, while active connection consumes around 5kb如果我们假设在任何给定时刻只有 100 万个连接处于活动状态,这就是我们得到的结果。
- 1400 万个空闲连接 - 0 字节
- 1500 万个客户机的调度状态 - 220MB
- 100 万个活动连接,每个 5kb = 5GB
只占我们 RAM 预算的一半,耶!我并不经常超出自己的预期。让我们验证一下:
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 显然是在内存又大又便宜的时代写的,唉。让我们问问 AI 内存都去哪了:
| 结构体 | sizeof | 描述 |
|---|---|---|
struct tcp_sock | 2240B | TCP 状态、队列、定时器、序列号、拥塞控制、重传与投递记账 |
struct socket_alloc | 768B | 一个 128 字节的 struct socket,内嵌等待队列,外加 608 字节的 sockfs inode 和填充 |
struct file | 184B | 打开文件操作、标志、凭据、引用计数,以及指回套接字的指针 |
struct dentry | 192B | sockfs 伪名称、inode 指针,以及 VFS 查找和生命周期记账 |
| 总计 | 3384B |
差不多就这意思,TLDR,内核把这些内存用于很多事情。我本希望能看到一些 buffer: [u8; 3300],但看起来不重写半个内核就没法优化多少。今天是周日,我的 token 也快用完了,所以我们只能动脑子想想——怎么绕过内核?
我们有哪些选择?工程智慧告诉我们,如果解决不了一个任务,说明我们在错误的抽象层级上工作。嗯……层级、层级、层。等等!我们从 HTTP 开始,一路下到 TCP/IP。这让我想起了什么!妈!妈!我大学课本都放哪了?我现在就要!

OSI 模型是……嗯……我大学学过的东西。对,这是个好定义。我们从应用和 HTTP 开始,在 application 层,然后下到 TCP/IP 的 transport 层。下面还有三层。我们能不能再往下,获得完全控制并解决内存问题?哦能,这正是工作在 network 和 data link 层能让我们做到的。那下到最低层呢?

清楚了。
每一层都封装来自上一层的数据。
| HTTP应用层 · L7 | TCP传输层 · L4 | IP网络层 · L3 | Ethernet数据链路层 · L2 | PhysicalL1 |
|---|---|---|---|---|
| GET / | 载荷 | 载荷 | 载荷 | |
| 源端口50123 | ||||
| 目的端口80 | ||||
| Seq1001 | ||||
| ACK7001 | ||||
| 标志ACK | ||||
| 源 IP192.0.2.10 | ||||
| 目的 IP198.51.100.20 | ||||
| TTL64 | ||||
| 协议6 (TCP) | ||||
| 目的 MAC02:00:00:00:00:fe | ||||
| 源 MAC02:00:00:00:00:01 | ||||
| EtherType0x0800 (IPv4) | ||||
| FCSCRC |
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 is a standalone, event-driven TCP/IP stack that is designed for
>bare-metal, real-time systems. smoltcp does not need heap allocation at all那么,用 cargo add smoltcp 就完事了?别急。smoltcp 本质上只是一个智能解析器,无法进行 I/O。它如何与你的网卡通信?有三种方式:
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,如果我们想要完全控制,只需要实现包含 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 字节,活跃服务器约 1 KB,我们达到了 1600 万个服务器。DPDK 在这个基准测试中显然是猛兽,AF_XDP 紧随其后:
为什么这如此令人兴奋?这意味着通过将网络栈移到用户空间,你可以完全控制 RAM 使用量并提升性能。而借助自定义运行时,你可以简单地让 guest 运行得更快。
Simply 有点牵强——构建概念验证很容易。构建一个兼容的 Linux 运行时并以 100% POSIX 兼容性重新实现所有系统调用需要更多思考。以及另一篇文章。
参考文献
- https://github.com/artemyarulin/AI10M/tree/main/poc/ten-million-webservers 源码
- 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 概述
来源:Hacker News · kapteko.com