Newshot

单台虚拟机上的 1500 万台 Web 服务器:smoltcp、DPDK 与 AF_XDP

Translation(model translation, not the source's own text)

文章标题:一台虚拟机上跑 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 块新网卡。

network card
network card

一台虚拟机上运行 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 万,到底是多少?

wolfram
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
}
      

文章标题:一台虚拟机上运行 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 这些内存都去哪了:

StructsizeofDescription
struct tcp_sock2240BTCP 状态、队列、定时器、序列号、拥塞控制、重传与交付记账
struct socket_alloc768B一个 128 字节的 struct socket 内嵌等待队列,外加 608 字节的 sockfs inode 和填充
struct file184B打开文件操作、标志、凭据、引用计数,以及指回 socket 的指针
struct dentry192Bsockfs 伪名称、inode 指针,以及 VFS 查找与生命周期记账
Total3384B

土豆就是土豆,TLDR,内核把这些内存用在很多事情上。我本希望能看到某个 buffer: [u8; 3300],但看起来不重写半个内核是优化不了多少的。今天是周日,我剩下的 token 也不多了,所以我们只能动脑子想——怎么绕过内核?

我们有哪些选择?工程智慧告诉我们,如果一个任务解决不了,那说明我们在错误的抽象层级上工作。嗯……层级、层级、层。等等!我们从 HTTP 开始,往下走到了 TCP/IP。这让我想起了点什么!妈!妈!我大学课本都放哪了?我现在就要!

osi_model
osi_model

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

physical layer
physical layer

每一层都会把上一层的数椐包起来。

HTTP 应用 · L7TCP 传输 · L4IP 网络 · 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 概览

The translation is machine-generated and individual terms may be off. Nothing is rewritten or cut; the original is authoritative.

Published by Hacker News
This site only summarises and aggregates; copyright stays with the original author. Headlines and summaries follow the source — where they differ, the original wins.
Read the original ↗