缓存时间:
2026/11/19 08:59
# 一台 VM 上跑 1500 万个 Web 服务器 - smoltcp、DPDK、AF_XDP
来源:https://kapteko.com/15-million-webservers/
2026 年 11 月 18 日
把一个 Web 服务器挂到网上,所有人都会来试图黑它。为什么?一条基本的经济学规律:供给少,需求大——Web 服务器不够分。那我们给地球上的每个人跑一个 Web 服务器吧,80 亿个。我没拉到投资,所以只能自力更生。目标是在一台只有 10GB 内存和 1 个 CPU 核心的 VM 上跑 1500 万个 Web 服务器。如果成功了,我就去家里旧微波炉上拆点内存出来,把规模再扩大,让每个人都拥有自己的 Web 服务器。届时需求会降到零,网络安全问题也就一劳永逸地解决了。
## Web 服务器
与其全程 vibe coding,不如用一种古老的技术叫 `学习`。首先,什么是 Web 服务器?有几个基本的 syscall。
1. `listen` - syscall,让内核在套接字上监听连接
2. `accept` - syscall,在套接字上接受一个连接
3. `recv` - 从套接字接收数据
4. `send` - 发送数据
5. `close` - 关闭
什么是 syscall?就是由操作系统内核执行的函数。不管你用什么花哨的语言或库来写 HTTP,最终都会归结到这些 syscall(好吧,是这样,但其实也不完全是)。我们用 C 来把这些都写清楚。先开始监听,然后在循环中从套接字读取数据,并始终回复 `OK`。
```c
int main(void)
{
// 我们使用端口 0,这会让 OS 返回任意可用端口
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 无法启动,因为你的 Firefox 打开了 example.com` 这种提示可太让人困惑了。
- 端口 `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 使用相同的端口。这也意味着我们可以用一堆不同的 IP 来跑我们的 Web 服务器。如果给服务器接 450 张网卡,我们就有 450 个唯一 IP 地址,可以监听 1500 万个唯一地址了!
**UPD。**有读者说,网卡是过去一年里唯一没有涨价 100 倍的硬件组件。我们能不能也别把这个搞砸,用软件来解决?
我们用一种优美的技术叫 `AnyIP`,它可以让我们监听整个子网。很多 VPS 和独立服务器供应商会常规地给你一整段 TCPv6 子网。我们只需运行 `sudo ip -6 route add local 2001:db8:1234:5678::/64 dev lo` 就能获得 18 千万亿个地址(大概吧,正负一个)来监听。IPv4 也可以这样做——买一段包含 15M 个地址的子网大约要 2.5 亿美元,所以请根据你的环境调整命令。我们把服务器改成从我们的范围中取第 n 个 IP:
```c
// 从 CLI 读取 IP 索引,将基础 IP 按它偏移
int i = read_cli_param(argv[1]);
const uint32_t base_ip = 0x0a400001; // 例如 10.64.0.1
addr.sin_addr.s_addr = htonl(first_ip + i); // 偏移,例如 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》(https://kapteko.com/running-10-million-codex-clis-on-one-server-lfi-processes) 中解释过为什么运行数百万个进程会造成太多开销。答案是在一个自定义运行时中把它们全部放进一个进程里运行,就像 V8 可以在一个进程中运行数百万个 guest 一样。在《Userland Linux scheduler in Rust》(https://kapteko.com/userland-linux-scheduler-in-rust) 中,我展示了如何构建一个专用的用户态调度器,以每任务绝对最小的内存量在任务之间切换。
> TLDR:我们使用 LFI (https://www.scs.stanford.edu/~zyedidia/docs/papers/lfi.pdf) 进行沙箱隔离。它为我们提供内存隔离,并将所有 syscall 替换为对宿主处理器的调用,这让我们可以按自己的意愿实现 I/O。为了调度多个 guest,我们把它们全部加载到主进程的内存中,让 CPU 不断地在 guest 之间切换——我们成了自己的微型操作系统。
由于我们需要节省每一字节和每一个 CPU 周期,我们注定要再构建一个专用运行时。开始吧。10GB 除以 15M,到底等于多少?
wolfram
十个大不列颠除以 1500 万,大约等于半个 kilo britain。不多。如果我们在运行时里跑所有的 guest,我们的自定义调度器需要在它们之间切换。每个 guest 我们需要保留的绝对最小状态是什么?我们可以忽略服务器初始化,假设切换只发生在主循环内。再看一遍这个循环。
```c
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`。都是简单的文件描述符。如果我们的调度器需要在这个循环中的任意 syscall 点挂起一个 guest,我们需要保存以下状态:
```rust
struct Context {
pc: u64, // 要返回的指令地址
fd_server: i32, // server 文件描述符
fd_client: i32, // client 文件描述符
}
```
每个 guest 只需 16 字节,所以在运行时中跑 15M 个 guest 并能挂起和切换它们,需要 220MB 内存。我们这里还算保守——我们不需要完整的 `u64` 或 `i32`,通过位打包,我们大概能压到每个 guest 8 字节。还需要什么?
```
$ codex "How much TCP connection takes?"
Idle connection takes zero, while active connection consumes around 5kb
```
如果我们假设任何时刻只有 1M 个连接是活跃的,我们得到的是:
- 1400 万个空闲连接 - 0 字节
- 1500 万个 guest 的调度状态 - 220MB
- 100 万个活跃连接,每个 5kb = 5GB
只用了内存预算的一半,耶!我不常超出自己的预期。让我们验证一下:
```c
int main(void) {
// 运行 1400 万个空闲连接 - 只监听,什么都不做
// 不应该消耗任何内存!
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 个 syscall 吗?我漏了一个就在眼前的。让我把它高亮出来:
```c
int main(void)
{
for (int i = 0; i < 10_000_000; ++i) {
socket(AF_INET, SOCK_STREAM, 0);
}
}
```
这段代码在 10GB 的 VM 中会 OOM。`socket` syscall 大约分配 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_model
OSI 模型是……嗯……我在大学学过的东西。对,这是个好定义。我们从应用层的应用程序和 HTTP 开始,然后降到了传输层的 TCP/IP。下面还有三层。我们能不能再往下走,获得完全控制权来解决内存问题?当然可以,这正是在网络层和数据链路层操作能做到的。那走到最底层呢?
physical layer
清楚。
每一层都包装了上层的数据。
**HTTP** 应用层 · L7 **TCP** 传输层 · L4 **IP** 网络层 · L3 **Ethernet** 数据链路层 · L2 **Physical** L1
**GET /** **载荷** **载荷** **载荷** **源端口** 50123 **目的端口** 80 **序列号** 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 (https://dunkels.com/adam/miniweb/)——它把一个自定义的 TCP/IP 实现和一个 HTTP 服务器组合在一起,总共只需要 28 字节(B-Y-T-E-S)就能工作。
不过有很多不那么极端、更成熟的实现:
- gVisor (https://github.com/google/gvisor) 本质上重新实现了整个操作系统,包括网络协议栈
- Seastar (https://github.com/scylladb/seastar) 是一个完整的运行时,自带网络协议栈,来自 ScyllaDB 背后那个很棒的团队
- lwIP (https://github.com/lwip-tcpip/lwip) 是一个流行的 C 语言 TCP/IP 实现
- F-Stack (https://github.com/F-Stack/f-stack) 使用 FreeBSD 的 TCP/IP 协议栈
Go、C++ 和 C 都是不错的语言(好吧,算是吧),但它们远远不如我们心爱的 Rust。所以我们就用 smoltcp (https://github.com/smoltcp-rs/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` 很贴心地开箱即提供了前两种选项,而且很容易使用。
```rust
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());
// 主网络循环
loop {
let now = Instant::now();
iface.poll(now, &mut device, &mut sockets);
wait(device.as_raw_fd(), iface.poll_delay(now, &sockets))?;
}
}
```
但第三个选项 `DPDK` 呢?当你非常在意延迟的时候,每个 syscall 都是一道血淋淋的伤口。syscall 本身可能要花 500ns,从内核拷贝数据到用户态可能还要 1000ns,取决于缓冲区大小。听起来微不足道,但举个例子:高频交易公司把 400Gbs 的网络接口打满是家常便饭。这意味着每秒处理多达 6 亿个数据包,大约每个包 1.7ns。
`DPDK` 让你的程序使用以太网帧直接与硬件网卡通信,绕过整个内核网络栈。你在内存映射的缓冲区上读写,没有 syscall:当你想发送数据时——直接写入缓冲区就完事了;当你想读取收到的内容时——它已经在那里了。
还有一个不太明显的优势——当一个新的数据包到达你的网络设备时会发生什么?触发一个中断,CPU 核心停止执行你的应用,切换到内核,处理中断,然后再回到你的应用。现在想象大量涌入的数据包,多到你的应用一直在被打断。它有个美丽的名字……