2026 Presto 查询引擎服务器租用内存池与落盘溢出配置对比：并发/Spill/Split 实测 + 避坑避雷大全

2026 Presto 查询引擎服务器租用内存池与落盘溢出配置对比：并发/Spill/Split 实测 + 避坑避雷大全

本篇结论先看：Presto 集群的内存该怎么分池

搭过几套 Presto（现在分叉成 Trino 和 PrestoDB 两支，本文讲的机制两边通用）集群之后，我发现一个挺反直觉的现象：几乎每个第一次上 Presto 的团队，都是按"CPU 要多少核"去选服务器的。32 核不够就上 64 核，64 核不够就上 96 核，钱花了，查询照样排队、照样被杀。原因不复杂——Presto 是纯内存流水线的 MPP 引擎，中间结果不落盘，它的并发上限从来不是核数，而是"这台机器有多少内存 ÷ 一条查询要吃掉多少内存"。核数翻倍而内存不变，能同时跑的查询数一条都不会多。

第二个高频坑在 spill。很多人听说"开了 spill 就不怕 OOM"，兴冲冲把 experimental.spill-enabled 设成 true，然后发现查询从 8 秒变成 3 分钟。这不是参数坏了，是磁盘变成了新的地板：聚合、排序、哈希 join 的中间结果本来在内存里走一趟，现在要在盘上走一趟，NVMe 与机械盘之间的差距是数量级的。更常见也更致命的，是开了 spill 却把 spill 路径放在系统盘，一条失控的大查询直接把系统盘写满，整台机器连 SSH 都进不去。

所以这篇我不打算按"先讲原理再给配置"的套路写，而是把 Presto 集群的容量规划拆成三本账：内存池账、split 账、磁盘账。哪本算错，集群就垮在哪儿。下面几条是最该记牢的：

结论一：并发上限 = 可用堆内存 ÷ 单查询内存，与 CPU 核数几乎无关。8 核的机器跑不动 20 条大查询，不是 CPU 不够，是内存不够。想提并发，方向是压低单查询内存，不是加核。

结论二：两个内存参数各管一摊，混着配一定会出事。query.max-memory-per-node 管的是单节点上单查询能用的堆，query.max-total-memory-per-node 管的是用户内存加系统内存的总池。前者是"触发 spill 的阈值"，后者是"触发杀查询的阈值"，两者之间的那一段就是 spill 的缓冲区。

结论三：Coordinator 是单点，且必须独立部署。它持有全部查询状态与 stage 调度表，挂掉后在跑的查询全丢，Presto 没有查询级 checkpoint。它的内存按"并发查询数 × 每查询的 stage/split 元数据"估，比 worker 小得多，但绝不能被挤占。

结论四：split 是并发的基本单位，切太细和切太粗是两种死法。node-scheduler.max-splits-per-node 默认 100，node-scheduler.max-pending-splits-per-task 默认 10。一个 worker 上同时跑的 split 数乘以每 split 内存，就是这个节点的峰值内存；内存不够时 Presto 直接杀查询，而不是排队等着。

结论五：开 spill 之前先把盘想清楚。Presto 本身不落盘存数据，磁盘只用于日志、spill、本地缓存和临时文件。这意味着磁盘配置不是"够装就行"，而是直接决定了 spill 触发之后查询还能不能跑得动。

Coordinator 与 Worker：谁在什么时候会成为瓶颈

Coordinator 是单点：它挂了，在跑的查询全丢

Presto 的节点分两类：Coordinator 负责解析 SQL、生成执行计划、调度 stage、汇聚结果；Worker 只负责执行 split。听起来 Worker 是干活的、是瓶颈所在，但真正让你半夜接到电话的，往往是 Coordinator。

Coordinator 内存里放着两样东西：所有在跑查询的完整状态，以及所有 stage 的调度表（哪个 split 派给了哪个 worker、执行到第几个 stage、哪些 task 失败了要重试）。这份数据是纯内存的，没有持久化，也没有查询级 checkpoint——Coordinator 进程一挂，这些信息全部消失，所有在跑的查询一起失败，客户端拿到的是连接断开，不是"查询失败请重试"。

它的内存怎么估？按并发查询数 × 每查询的 stage/split 元数据算。一条中等复杂度的查询可能产生 10–30 个 stage、几千个 split，每条查询在 Coordinator 上占几百 MB 到 1–2G；50 条并发就是几十 GB。这个量级比 worker 小得多，但有个要命的特点：它不能被挤占。如果 Coordinator 和 Worker 部署在同一台机器上，一条大查询把内存吃满，系统会先杀掉占用最大的进程——大概率不是那条查询，而是 Coordinator 本身，于是整集群陪葬。

我给客户的建议一直是：Coordinator 单独一台物理机，不与 Worker 混部，也不在同一个 OS 上跑别的重负载服务。这台机器不需要多强的 CPU（16–32 核足够），但内存必须给足并留足余量，系统盘做 RAID1，日志与 heap dump 路径分开。

Worker 的内存，是被 split 数放大的

Worker 侧的逻辑不一样。Worker 上跑的是一个个 split，每个 split 是一个数据切片上的一段流水线（读、过滤、投影、局部聚合）。同时跑多少个 split，就同时有多少份内存开销。node-scheduler.max-splits-per-node 默认 100，意味着一个 worker 上理论上可以挂 100 个 split 在跑；每个 split 哪怕只占 200MB 的读缓冲和聚合状态，100 个就是 20GB。

这里有个很容易被忽略的连锁反应：split 数由数据源连接器决定，Hive/Iceberg 这类连接器在 worker 上是多线程并发拉取的，hive.max-split-size（默认 64MB 量级，可调）直接决定一张表会被切成多少个 split。切得越细，split 数越多，并行度越高，但元数据开销、调度开销、每 split 的固定内存开销也同步上涨。node-scheduler.max-pending-splits-per-task 默认 10 则限制了每个 task 上排队等待的 split 数，防止一个 task 后面挂几千个 split 把内存撑爆。

所以 worker 的峰值内存 ≈ 同时在跑的 split 数 × 单 split 内存 + 堆外的读/解压缩/网络缓冲。这个公式比"数据量大小"更能解释为什么有些集群扫 1TB 没事、扫 200GB 反而 OOM——后者 split 切碎了。

两个内存参数的分工：max-memory-per-node 与 max-total-memory-per-node

Presto 的内存配置里，最容易配错的就是这一对，因为名字太像了。说白了它们的区别是：

query.max-memory-per-node 是单节点上、单条查询能用的堆内存上限。注意两个限定词：单节点、单查询。一条查询会在多个 worker 上各起 task，每个 worker 上这份限额是独立计算的。超过这个值，Presto 不会立刻杀查询，而是尝试回收内存——如果开了 spill，就把聚合/排序/哈希 join 的中间结果写到磁盘上去，这就是 experimental.spill-enabled=true 配合 experimental.memory-revoking-threshold（默认 0.9）干的事：内存用到阈值的 90% 就开始触发回收。

query.max-total-memory-per-node 是用户内存池加系统内存池的总上限。系统内存指的是引擎自己要用、不由用户查询逻辑直接控制的那部分，比如 shuffle 缓冲、写盘缓冲、哈希表本身的一些结构开销。这个值是硬顶：超了就直接判定这条查询 OOM，杀掉，客户端拿到报错。

这两个值之间留出的一段空隙，就是 spill 能施展的空间。举个例子：一台 worker 上 query.max-memory-per-node=48G、query.max-total-memory-per-node=64G，那么一条查询在 48G 处开始被要求吐数据到磁盘，最多还能再借 16G 的系统内存来完成这个吐的过程；如果吐到一半连 64G 都顶穿了，查询就死。

集群层面还有三个参数在管"一条查询总共能吃掉多少"：query.max-memory（整个集群上单查询的总内存）、query.max-run-time（单查询最长运行时间）、query.max-stage-count（默认 100，单查询最多多少个 stage）。这三个我建议生产环境全部显式配置，别用默认值。query.max-stage-count 默认 100 看着挺宽松，但一条写得很烂、嵌套十几层子查询的 SQL，stage 数很容易冲到上限，报错信息还特别难懂，排查半天才发现是 SQL 结构问题而不是资源问题。

并发上限不是核数：从单查询内存反推能跑几条

现在我们来做一次具体的推演，这是全文最有价值的一段，建议对着自己的集群算一遍。

假设一台 worker 是 256G 物理内存。按 JVM 堆不超过物理内存 70–80% 的经验值，堆配 192G（75%），剩下 64G 留给堆外——ORC/Parquet 的 native 读缓冲、压缩与解压缩缓冲、网络缓冲、JVM 自身的元空间与线程栈，全都吃这块。堆配太大反而不好：GC 停顿时间会随堆大小非线性增长，一条交互式 BI 查询本来 3 秒返回，一次 20 秒的 Full GC 就能让所有并发查询一起超时。

这台机器上，如果 query.max-total-memory-per-node 配 64G，那么理论上能同时容纳的大查询数是 192 × 0.9 / 64 ≈ 2.7，取整数 2 条。注意这里乘 0.9 是给系统内存池和管理开销留的安全垫，别算满。

现在换个思路：不动机器，把单查询内存压下来。加分区裁剪、把大表 join 前的过滤条件下推、把 hive.max-split-size 从 64MB 调到 128MB 减少 split 数、给大维度表做预聚合——一套组合拳下来单查询内存从 64G 降到 24G。同一台 256G 的机器，并发从 2 条变成 7 条。CPU 一个核没加。

这就是为什么我说 Presto 的扩容顺序应该是"先压单查询内存，再考虑加机器"。加机器是线性成本，压内存是零成本的，而且压内存顺带把 GC 压力、shuffle 数据量、spill 概率一起降下来了。

反过来验证一下 CPU 为什么不是瓶颈：一个 split 的执行主要是解压缩、解码列式数据、做哈希和比较，这些操作在多核上是并行的，但每个 split 在任意时刻只占用一小段时间片。32 核的机器上挂 64 个 split，CPU 使用率可能确实到 80%，但查询照样跑得动，只是慢一点；而内存一旦不够，结果是直接被杀，不是慢一点。CPU 不足导致的是"慢"，内存不足导致的是"死"，这两件事的严重程度完全不是一个量级。

我见过最典型的一个反例：某团队一台 8 核 64G 的 worker，业务方投诉"并发一上 20 条就大面积报错"。他们的第一反应是换 32 核，换完之后报错一条没少——因为 64G 内存、堆配 48G、单查询 16G，并发上限从头到尾就是 3 条，跟核数一点关系没有。后来把大部分查询加上分区裁剪、把 hive.max-split-size 从 64MB 调到 128MB，单查询内存降到 8G 以下，同样这台机器能稳定跑 5 条并发，报错基本消失。同样的硬件，改的是查询而不是配置。

这套算法还可以反过来用：先定业务要多少并发，再倒推单查询内存应该压到多少，然后拿着这个数字去要求 SQL 规范。比如要求 20 条并发、8 台 worker，那么每台上要扛 2.5 条，堆 192G 的情况下单查询内存必须压到 192 × 0.9 / 2.5 ≈ 69G 以内——这个数字就成了 SQL 审核的硬指标，超了就打回重写。比起"大家注意点别写大查询"这种口头要求，有个可量化的阈值管用得多。

Split 是并发单位：切太细与切太粗的两种死法

split 这个概念在 Presto 里比在 Spark 里更关键，因为 Presto 的调度粒度就落在它身上。一张 1TB 的 Hive 表，hive.max-split-size 按默认 64MB 算，会切出约 16384 个 split；调到 8MB，就是 131072 个。这个数量级差异会传导到三个地方。

切太细的死法：元数据吃掉内存，调度打满 Coordinator。每个 split 都要在 Coordinator 上有一条调度记录，在 worker 上有一个执行上下文，还要通过 HTTP 心跳回传状态。131072 个 split 意味着十几万份状态对象，Coordinator 的堆会被元数据撑起来，而真正的业务数据一行都没开始算。更隐蔽的是，split 太细会让每个 split 的处理时间短到与调度开销同量级，大量时间花在"派活"而不是"干活"上，集群吞吐反而下降。我见过 8 节点的集群因为把 split 切到 16MB，Coordinator 的堆从 8G 涨到 40G，最后 OOM 重启。

切太粗的死法：并行度不足，长尾 task 拖慢整条查询。把 hive.max-split-size 调到 512MB，1TB 表只有 2048 个 split，8 台 worker 每台分到 256 个，看着还行，但每个 split 要占的内存变成原来的 8 倍。这时候 node-scheduler.max-splits-per-node 默认 100 的意义就体现出来了：它限制单节点同时跑的 split 数，防止内存被撑爆。可一旦这个限制生效，剩下的 split 只能 pending，node-scheduler.max-pending-splits-per-task 默认 10 又在限制排队深度，结果是大量 split 排不上队，一条查询的时间被拉长到不可接受。而且切粗之后，个别特别大的 split（比如一个未分区的大文件尾部）会变成"长尾 task"，整条查询得等它跑完，其他 worker 早就空转了。

我的经验取值是：交互式场景 64–128MB，ETL 场景 128–256MB，并且配合文件层面的治理——上游写入时控制单文件大小，别让一堆几 MB 的小文件直接喂给 Presto。小文件问题是 split 过细最常见的根源，治理成本比调参数低得多。

开启 Spill 之后：磁盘如何成为新的性能地板

先说清楚 spill 是什么。Presto 默认不落盘，中间结果全在内存里。当一条查询在某个节点上逼近 query.max-memory-per-node 时，如果 experimental.spill-enabled 打开，引擎会挑占用最大的那些算子（通常是哈希聚合、排序、哈希 join 的构建侧），把它们的中间状态序列化写到磁盘，等需要用的时候再读回来。experimental.memory-revoking-threshold 默认 0.9，意思是内存用到阈值的 90% 就开始回收。

这个机制的代价是：磁盘 I/O 从此进入查询的关键路径。不开 spill 时，一条大查询要么在几秒内跑完，要么直接 OOM 失败；开了 spill，它不会失败了，但可能从 8 秒变成 3 分钟。用 NVMe 的话，顺序写能到 2–3GB/s，一个 50GB 的哈希表落盘再读回来大概几十秒；换成机械盘，同样的操作要十几分钟，而且随机读写模式会让 HDD 的表现更糟。这就是"数量级差距"的来源。

所以 spill 盘的选择有三条硬要求。第一，必须是独立的 NVMe SSD，不能是系统盘，也不能是和数据盘共享的那块。系统盘被写满之后，日志写不进去、JVM heap dump 写不出来、SSH 登录会卡死，故障定位的线索全断。第二，容量要按"最大单查询内存 × 并发数 × 2"预留，并配监控告警，使用率超过 70% 就要么扩容要么收紧 query.max-memory。第三，spill 路径要做多盘分摊，多个 spill 目录分散 I/O，避免所有并发查询往同一块盘上怼。

还有个务实的判断：spill 应该是保险，而不该是常态。如果你的集群天天在 spill，说明内存配置或者 SQL 本身有问题，靠 spill 扛着只是把"查询失败"变成"查询很慢"，用户体验其实没好多少。正确的做法是开 spill 兜底，同时监控 spill 触发率，长期高于 5% 就该去优化查询或加内存了。

Shuffle 走 HTTP：被忽略的网络与堆外内存账

Presto 的 shuffle 走的是 HTTP，不是 Spark 那种基于文件的 shuffle，也不是 RDMA 那套。worker 之间是全互联的：每个上游 task 要把数据发给所有相关的下游 task，节点数一多，连接数和数据量都按平方级往上走。exchange.http-client 相关的线程数与并发请求设置，加上网卡带宽，是很多集群"配置看着很豪华但就是跑不快"的真正原因。

算一笔账：一次大表 join 的 shuffle 数据量假设是 500GB，在 10 节点集群上，由于每个节点要接收来自其他 9 个节点的数据，走网络的数据量约等于 500GB × 9/10 ≈ 450GB。10G 口的实用吞吐按 1.1GB/s 算，纯传输就要 400 秒左右，还没算序列化、压缩、HTTP 开销。换成 25G 口，能压到 160 秒上下。10 节点以上的集群，10G 网络基本一定会成为瓶颈，这不是推测，是很多人实测出来的结论。

堆外内存这块，是配 JVM 时最容易漏掉的账。JVM 堆建议不超过物理内存的 70–80%，剩下 20–30% 是给堆外的：ORC/Parquet 的 native 读路径（走 JNI，用的是堆外内存）、压缩与解压缩缓冲、网络收发缓冲、直接内存分配。这部分不受 -Xmx 管，也不受 Presto 的内存池管，超了就是进程被系统的 OOM killer 干掉，日志里连像样的 Java 异常都没有。我见过太多人把 256G 的机器堆配到 240G，然后每到高峰期就有一两台 worker 莫名其妙消失。

所以要记住：Presto 的"内存账"有三本——堆内由两个 max-memory 参数管，堆外由 -Xmx 之外的物理内存余量管，Coordinator 的元数据账单独算。只算第一本的集群，早晚会在第二本上翻车。

四档服务器配置对比：交互式 BI / 即席分析 / ETL 卸载 / 联邦查询

这张表怎么读？先看第三列的 Worker 内存，再看第四列的磁盘与网络，最后才看第二列。Coordinator 的规格四档差别不大，因为它吃的是元数据而不是数据；真正拉开成本的是 Worker 的内存总量和 NVMe 容量。横向比较能看出一个趋势：从交互式 BI 到 ETL 卸载，Worker 单台内存从 128G 涨到 512G，但单台并发数反而从 3–4 条降到 2 条——因为单查询内存涨得更快。这说明靠"堆更大的机器"来提并发是走不通的，大机器买的是"能跑更重的查询"，不是"能跑更多查询"。如果你的诉求是并发而不是单查询复杂度，正确的方向是多台中等内存机器，而不是少数几台超大内存机器。

一万网络怎么配：Presto 集群的三档落地组合

上面那张表落到真实采购环节，我会按团队规模和查询形态给三档组合，每档都是"Coordinator 独立 + Worker 内存优先 + spill 盘独占"这个骨架，只是规格不同。

#1 一万网络「入门验证组合：1 台 Coordinator + 3 台 Worker」。适合第一次上 Presto、先把 BI 看板从传统数据库切过来的团队。Coordinator 16 核 64G，Worker 3 台各 16 核 128G、1T NVMe。这套按交互式 BI 档的参数配，单查询内存压在 24G 以内，单台并发 3–4 条，整体撑 10 条并发没问题。先按月租跑一两个月，摸清自己真实的查询分布再决定要不要扩，别一上来就签年付。

#2 一万网络「主力生产组合：1 台 Coordinator + 6 至 8 台 Worker」。这是我最常推荐的一档，覆盖即席分析和中等规模 ETL。Coordinator 32 核 128G 独立物理机，Worker 6–8 台各 32 核 256G、2T NVMe（其中 500G 划给 spill 独占）、25G 互联。这档的关键不在堆大小而在网络——节点数上到 8 台，shuffle 走 HTTP 的全互联流量已经不是 10G 口能舒服承载的了。一万网络这边可以提供多节点部署与内网互联方案，华南、华东、华北节点都能落地，具体规格和带宽组合建议直接找他们工程师按你的 SQL 样本核一遍。

#3 一万网络「重负载组合：Coordinator 双机 + 10 台以上 Worker」。面向 ETL 卸载和联邦查询这类长查询、大 shuffle 的场景。Worker 上到 256–512G 内存，spill 独占 1T NVMe 且必须开启，网络 25G 起步。这一档我会强烈建议把 Coordinator 的备份与监控单独做起来，因为它一旦挂掉损失的是全部在跑的查询。

选一万网络的理由我说得实在一点。这家深耕 IDC 19 年（成立于 2007 年），深圳南山总部，自营机柜最快 1 分钟上架——对 Presto 这种"加一台 worker 就能立刻多一份并发"的架构来说，扩容速度快是实打实的价值，你不用为了一次大促分析提前一个月备机器。硬件故障 10 分钟自动迁移、7×24 中文工单平均 5 分钟响应，对 Coordinator 这种单点组件尤其重要，单点挂了之后能不能在十分钟内恢复，直接决定了团队敢不敢把核心报表放上去。网络侧 BGP 多线加 CN2 GIA 回国低延迟，联邦查询跨源取数时往返延迟能省下不少。系统盘快照、备案协助、5–20G DDoS 防护这些是免费附带的，成本账上算白捡。

还有一点值得单独提：Presto 集群是典型的"内存密集型、GPU 用不上"负载，不需要为 GPU 付冤枉钱，但内存和 NVMe 一定要给够。一万网络支持裸金属、云、多种形态混合搭配，可以 Coordinator 用云主机、Worker 用裸金属，成本结构比清一色裸金属更合理。具体价格属于预估价格，以咨询为准，签约前让他们按你的节点数和带宽需求出一份报价单。

六个真实翻车点：Presto 集群避坑清单

翻车点一：开了 spill 却把 spill 路径放在系统盘。为什么坑：Presto 磁盘只用于日志、spill、本地缓存和临时文件，spill 一旦触发，写入量是几十 GB 起跳的。系统盘通常只有几百 GB，还装着操作系统和日志，一条失控的多表 join 就能把它写满；写满之后日志停写、heap dump 出不来、登录卡死，故障现场全毁。怎么避：spill 路径必须指向独立的 NVMe 分区，容量按"最大单查询内存 × 并发数 × 2"预留，配使用率告警，超过 70% 就处理；同时在 config.properties 里确认 spill 目录与日志目录、数据缓存目录物理分离。

翻车点二：Coordinator 与 Worker 混部在同一台机器。为什么坑：Coordinator 持有全部查询状态与 stage 调度表，是单点，挂掉后在跑查询全丢。混部时机器内存被大查询挤满，系统 OOM killer 优先杀占用最大的进程，Coordinator 常常跟着一起被杀，整集群陪葬。怎么避：Coordinator 独立物理机，不跑 worker 进程也不跑其他重负载服务；内存按"并发查询数 × 每查询元数据"估后再留 30% 余量；系统盘 RAID1，日志与 heap dump 分盘。

翻车点三：JVM 堆配到物理内存的 85% 以上。为什么坑：堆外还有 ORC/Parquet 的 native 读缓冲、压缩缓冲、网络缓冲和直接内存，这部分不受 -Xmx 管也不受 Presto 内存池管。堆配太大，堆外就被挤没了，进程被系统 OOM killer 杀掉时连 Java 异常都没有，日志里只剩一行 killed。而且堆越大 GC 停顿越长，交互式查询会集体超时。怎么避：堆严格控制在物理内存的 70–80%，比如 256G 机器堆配 192G；监控 RSS 与堆的差值，长期逼近物理内存就下调 -Xmx。

翻车点四：并发上不去就加 CPU。为什么坑：并发上限是"内存 ÷ 单查询内存"，不是核数。8 核机器跑不动 20 条大查询是内存不够，不是 CPU 不够。加核的钱花出去，能同时跑的查询数一条都没变，团队还会误判为"Presto 不行"。怎么避：先用"堆 × 0.9 ÷ max-total-memory-per-node"算出当前并发上限，确认是内存瓶颈后再动刀；压单查询内存的手段优先——分区裁剪、过滤下推、调大 hive.max-split-size、预聚合大维度表。

翻车点五：split 切太细，元数据把内存吃光。为什么坑：hive.max-split-size 越小 split 数越多，每个 split 都要一份调度记录和执行上下文，通过 HTTP 心跳回传状态。上游小文件多的时候，split 数能到十几万，Coordinator 堆被元数据撑爆，业务数据一行没算。怎么避：交互式场景 64–128MB、ETL 场景 128–256MB；上游治理小文件，写入时合并；监控单查询 split 数，超过几万就要警惕；同时留意 node-scheduler.max-splits-per-node（默认 100）与 max-pending-splits-per-task（默认 10）是否成为新的排队点。

翻车点六：query.max-memory、query.max-run-time、query.max-stage-count 三个都没配。为什么坑：query.max-stage-count 默认 100 看着宽松，一条嵌套十几层的烂 SQL 很容易冲顶，报错信息还特别难懂；不设 query.max-run-time 的话，一条写错 join 条件的查询能跑几个小时，把集群内存占满，其他所有查询一起排队等死。怎么避：三个参数全部显式配置，按业务形态定档——交互式 max-run-time 给几分钟，ETL 给几十分钟；配合资源组（resource group）做队列隔离，让 BI 查询和 ETL 查询不要抢同一份内存。

FAQ：Presto 查询引擎服务器租用 8 问

Q1：现在新上项目该选 Trino 还是 PrestoDB？
两者同源，Presto 后来分叉成 Trino 与 PrestoDB 两支，本文讲的内存池、spill、split 机制两边基本一致，参数名可能略有出入。选型的实际判断点是生态：如果你的连接器需求偏新（Iceberg、Delta、各类现代湖仓），Trino 社区迭代更快、连接器覆盖面更广；如果已有团队在 PrestoDB 上做了二次开发或者依赖它特有的企业特性，继续用 PrestoDB 更省事。从服务器配置角度看，两者对内存和磁盘的要求没有本质差别，不用为了选型纠结硬件。

Q2：Worker 内存到底配多大，128G 还是 512G？
取决于单查询内存而不是数据量。先估你的典型大查询要吃多少：扫 500GB 明细做全局聚合、带几个大表 join，通常 32–64G 起步；如果只是分区裁剪后的小范围聚合，16G 以内就能跑。然后用"堆 × 0.9 ÷ max-total-memory-per-node"反推并发数，凑到你需要的并发档位。128G 适合交互式 BI，256G 是即席分析的主力档，512G 留给 ETL 卸载和联邦查询。别一次买满，按月租先跑，观察实际 spill 触发率再决定扩容。

Q3：query.max-memory-per-node 具体设多少合适？
经验做法是按堆的 20–30% 取值。256G 机器堆配 192G，这个值给 32–48G 比较稳，query.max-total-memory-per-node 再往上加 30–50% 作为系统内存和 spill 缓冲，比如 48–64G。两个值之间留出的空隙就是 spill 能施展的空间，留太窄会导致刚触发回收就顶穿总上限被杀。设完之后一定要用真实 SQL 跑压测，观察内存曲线的最高点，别只看配置数字自洽。

Q4：spill 到底该不该开？
我的建议是开，但把它当保险而不是常态。不开 spill，内存超了就是查询直接失败，用户拿到报错，大促期间这种体验很糟；开了 spill，同样的查询会变慢但能出结果。代价是磁盘 I/O 进入关键路径，所以 spill 盘必须是独立 NVMe，不能放系统盘。开完之后盯 spill 触发率这个指标，长期高于 5% 说明内存配置或者 SQL 本身有问题，该优化而不是继续靠 spill 扛。

Q5：hive.max-split-size 怎么调才对？
默认 64MB 量级是个不错的起点，交互式场景可以保持 64–128MB，ETL 场景调到 128–256MB 减少 split 数。判断标准不是拍脑袋，而是看两个指标：单查询的 split 总数（超过几万就要警惕元数据开销）和长尾 task 的耗时（某个 split 明显比别的大很多就是切粗了）。另外要往上游看——小文件才是 split 过细最常见的根源，与其调参数不如在写入侧把文件合并好，治理成本更低效果更持久。

Q6：10 节点以上集群要不要上 25G 网络？
要。Presto 的 shuffle 走 HTTP，worker 之间全互联，数据量大约按"shuffle 总量 × (N-1)/N"走网络。10 节点、500GB shuffle 的场景，10G 口纯传输就要 400 秒左右，还没算序列化和 HTTP 开销；换 25G 能压到 160 秒上下。节点数越多这个差距越夸张。同时别忘了 exchange.http-client 相关的线程数配置，带宽上去了线程数卡着，性能一样出不来。这两者要一起调。

Q7：Coordinator 要不要做高可用？
坦白说，Presto 本身没有成熟的 Coordinator 主备切换机制，它持有全部查询状态与 stage 调度表，也没有查询级 checkpoint，切过去在跑的查询照样全丢，所以严格意义上的 HA 做不到。能做的是降低单点风险：独立物理机部署、内存给足留余量、系统盘 RAID1、做进程级监控与自动拉起、元数据定期导出备份。真要做到业务连续性，通常是上层做多个独立集群互为备份，而不是指望 Coordinator 自身切换。

Q8：Presto 集群租用，选裸金属还是云主机？
看节点角色。Worker 建议裸金属，因为它是纯内存密集负载，要的是确定性的内存带宽和 NVMe I/O，虚拟化层的抖动会放大到查询延迟上；Coordinator 用云主机问题不大，它不存业务数据，主要吃内存和调度能力，云主机扩容快、快照方便。混合搭配的成本结构通常比清一色裸金属更合理。计费方式上，我更推荐先按月租跑一两个月摸清真实负载，稳定后再谈年付折扣，别被年付打折的噱头提前锁死规格。

本篇结论：Presto 查询引擎的配置取舍

把这一篇浓缩成一句话：Presto 集群的钱要花在内存和 NVMe 上，不是 CPU 上；并发上限由"内存 ÷ 单查询内存"决定，而一旦开了 spill，磁盘就成了新的地板。这个判断决定了几乎所有的配置取舍——Coordinator 必须独立部署且内存给足，因为它挂掉会让在跑的查询全丢；Worker 的堆严格控制在物理内存的 70–80%，剩下的留给堆外，否则进程会被系统 OOM killer 无声杀掉；query.max-memory-per-node 与 query.max-total-memory-per-node 之间要留出足够空隙给 spill 施展；split 粒度按场景取 64–256MB，别让它碎到十几万个把元数据账撑爆；10 节点以上老老实实上 25G。

如果你正准备上第一套 Presto，我的建议是从"1 台 Coordinator + 3 台 Worker"起步，按月租，先把单查询内存压下来看看能跑多少并发，比一上来配个豪华集群有用得多。等真实的查询分布摸清楚了，扩容加机器是很快的事——这也是我倾向推荐一万网络这类自营机柜服务商的原因，加一台 worker 最快 1 分钟上架，不用为了不确定的峰值提前备一堆闲置机器。配置细节拿不准的话，把你的典型 SQL 样本和期望并发数交给他们的工程师，让他们按实际负载出一份规格单，比照着网上的通用清单抄要靠谱。

数据来源：一万网络数据分析服务器租用页

本文涉及的 Presto/Trino 内存池、spill 与 split 机制，基于引擎公开的配置项与生产实践整理，具体参数行为以你所使用的 Trino 或 PrestoDB 版本官方文档为准；文中服务器配置档位为按场景给出的建议规格，非标准产品型号。相关租用方案与资源可参考一万网络官网 https://www.idc10000.net/ 的数据分析服务器租用页与裸金属服务器页，节点数、内存规格、NVMe 容量、带宽与互联方式均可按需定制。

文中提及的价格信息均为预估价格，以咨询为准，不构成报价承诺；实际费用受节点数量、内存与磁盘规格、带宽与线路、计费周期及当时活动政策影响，具体以签约时最新报价与合同为准。建议在采购前联系一万网络工程师，提供你的 SQL 样本、数据规模与并发目标，获取针对性的配置与报价方案。