【一次 Elasticsearch 高基数聚合慢查询的定位与优化】

一次 Elasticsearch 高基数聚合慢查询的定位与优化

本文重点不是某个具体业务,而是记录一种比较通用的排查思路:当一个聚合查询第一次执行很慢,后续却恢复正常时,应该怎样拆解问题、定位瓶颈,并评估 eager_global_ordinals 是否值得开启。

一、实际场景:一个统计查询突然变慢

这次排查来自一个比较常见的场景:系统把用户作答明细数据写入 Elasticsearch,再通过聚合查询生成分组统计结果。

查询流程可以理解为:先筛选一个分组,再按照 itemId 聚合子项,最后按照 userId 统计用户维度的成绩和耗时。

平时接口查询很快,通常几十毫秒就能返回。但在某些时刻,用户第一次打开统计页面,接口会突然变慢,需要一到两秒;紧接着再次刷新页面,耗时又恢复到几十毫秒。

这个问题比较容易被忽略。因为它不是每次都慢,监控里看到的平均耗时可能还不错,但真实用户恰好会在第一次访问时遇到延迟。

二、慢查询现象和查询结构

一个通用的统计场景,索引名称为:

text 复制代码
answer

索引中保存一类明细数据,每条文档包含分组、子项、用户和多个数值指标。查询先按照 groupId 过滤,再按照 itemId 和 userId 进行两层聚合,最后计算成绩和耗时等指标。

聚合结构如下:

text 复制代码
itemId
  └── userId
       ├── scoreRate 平均值
       ├── score 求和
       ├── sourceScore 平均值
       ├── totalScore 平均值
       ├── answerDate 最大值
       └── createAt 最小值

相关字段的 mapping 可以简化为:

json 复制代码
{
  "properties": {
    "groupId": {
      "type": "keyword"
    },
    "itemId": {
      "type": "keyword"
    },
    "userId": {
      "type": "keyword"
    },
    "score": {
      "type": "double"
    },
    "scoreRate": {
      "type": "double"
    },
    "sourceScore": {
      "type": "double"
    },
    "totalScore": {
      "type": "double"
    },
    "answerDate": {
      "type": "date"
    },
    "createAt": {
      "type": "date"
    }
  }
}

当时索引规模已经比较大,约有一亿级文档,索引大小达到几十 GB,主分片数据量也比较集中。一次具体查询虽然只匹配约 300 条文档,但聚合字段的全局词典是建立在整个分片数据之上的

查询使用了两个过滤条件:

text 复制代码
groupId = example-group-id
answerDate >= 最近一段时间

实际观测到的耗时大致如下:

请求次数 接口耗时
第 1 次 约 1,500ms
第 2 次 约 35ms
第 3 次 约 30ms
第 4 次 约 30ms

这个结果有两个值得注意的地方:

  1. 第一次查询明显慢,后续查询很快;
  2. 查询只命中了约 300 条文档,最终只有 1 个 itemId 桶和约 50 个 userId 桶。

如果只看命中文档数和实际桶数量,很难解释为什么第一次要花一秒多。所以,问题大概率不只是"这次查询处理的数据太多"。

请求中已经关闭了不需要的 _source,也没有要求返回完整命中数。也就是说,基础优化其实已经做过了,但第一次聚合仍然会慢。

三、排查前的基础信息

遇到 ES 慢查询时,第一反应往往是调参数。比如降低 terms.size、增加线程池、执行 force merge,或者直接给字段加 eager_global_ordinals。

这些做法有时有用,但如果没有先弄清楚慢在哪里,很容易把问题越改越复杂。

这次排查先确认了几件事。

1. 过滤字段类型正确

groupId、itemId 和 userId 都是 keyword,可以用于精确查询和聚合。成绩、耗时等字段也已经是数值类型。

因此不存在以下常见问题:

  • 对 text 字段直接做 terms 聚合;
  • 数值字段被当成字符串处理;
  • 没有使用 .keyword 子字段;
  • 因为 fielddata 导致大量内存占用。

2. 不是 Fielddata 加载问题

检查节点统计:

bash 复制代码
export ES=http://127.0.0.1:9200

curl -s "$ES/_nodes/stats/indices/fielddata?human&pretty"

如果返回类似:

text 复制代码
fielddata.memory_size_in_bytes: 0
fielddata.evictions: 0

对于 keyword 字段来说是正常的。keyword 聚合主要使用 Doc Values,并不意味着查询没有使用字段数据。

3. 搜索线程池没有明显排队

bash 复制代码
curl -s "$ES/_nodes/stats/thread_pool/search,refresh,write?human&pretty"

需要重点关注:

text 复制代码
search.active
search.queue
search.rejected
refresh.active
refresh.queue
write.active
write.queue
write.rejected

本次观察中搜索线程池没有明显排队和拒绝,因此暂时排除了"请求只是排队等待执行"的可能。

4. 查看索引规模和 Segment

bash 复制代码
curl -s "$ES/_cat/shards/answer?v&s=store:desc"

curl -s "$ES/answer/_stats/search,segments,store,docs?human&pretty"

curl -s "$ES/_nodes/stats/indices/segments,refresh?human&pretty"

这些信息不能直接告诉我们根因,但能帮助判断问题发生在小索引还是大索引,以及当前 Segment 和 Refresh 是否异常。

四、第一轮排查:使用 Profile 定位慢点

原始查询只保留关键结构,脱敏后的示例如下:

bash 复制代码
curl -s -X POST "$ES/answer/_search" \
  -H 'Content-Type: application/json' \
  -d @- <<'JSON'
{
  "profile": true,
  "size": 1,
  "track_total_hits": false,
  "_source": false,
  "query": {
    "bool": {
      "filter": [
        {
          "term": {
            "groupId": "example-group-id"
          }
        },
        {
          "range": {
            "answerDate": {
              "gte": "now-6M",
              "time_zone": "Asia/Shanghai"
            }
          }
        }
      ]
    }
  },
  "aggs": {
    "items": {
      "terms": {
        "field": "itemId",
        "size": 65535
      },
      "aggs": {
        "users": {
          "terms": {
            "field": "userId",
            "size": 65535,
            "order": {
              "score_rate_avg": "desc"
            }
          },
          "aggs": {
            "score_rate_avg": {
              "avg": {
                "field": "scoreRate",
                "missing": 0
              }
            },
            "score_sum": {
              "sum": {
                "field": "score",
                "missing": 0
              }
            },
            "source_score_avg": {
              "avg": {
                "field": "sourceScore",
                "missing": 0
              }
            },
            "total_score_avg": {
              "avg": {
                "field": "totalScore",
                "missing": 0
              }
            },
            "answer_date_max": {
              "max": {
                "field": "answerDate"
              }
            }
          }
        }
      }
    }
  }
}
JSON

Profile 中可以看到类似结果:

text 复制代码
匹配文档:约 300 条
itemId 桶:1 个
userId 桶:约 50 个
query:约 1~2ms
itemId aggregation:约 30~40ms
userId aggregation:约 3~5ms

这里会出现一个让人有点困惑的地方:Profile 中的聚合执行时间只有几十毫秒,但请求返回的 took 却可能超过一秒。

这说明 Profile 的明细不能简单等同于请求的全部耗时。聚合器初始化、全局词典构建、Segment 相关操作等成本,可能不会以一个直观的"某个聚合器耗时 1,000ms"形式出现在结果里。

但 Profile 中出现的这类聚合器名称值得重点关注:

text 复制代码
GlobalOrdinalsStringTermsAggregator

这时还不能直接下结论,只能先提出一个假设:

第一次执行 itemId 或 userId 的 terms 聚合时,ES 可能正在构建或加载 Global Ordinals。

接下来需要用实验验证,而不是靠猜。

五、第二轮排查:分阶段拆解查询

5.1 只执行过滤查询

先去掉所有聚合,只保留过滤条件:

bash 复制代码
curl -s -X POST "$ES/answer/_search?filter_path=took,timed_out,_shards" \
  -H 'Content-Type: application/json' \
  -d @- <<'JSON'
{
  "size": 0,
  "track_total_hits": false,
  "query": {
    "bool": {
      "filter": [
        {
          "term": {
            "groupId": "example-group-id"
          }
        },
        {
          "range": {
            "answerDate": {
              "gte": "now-6M",
              "time_zone": "Asia/Shanghai"
            }
          }
        }
      ]
    }
  }
}
JSON

连续执行多次,结果稳定在:

text 复制代码
第 1 次:约 1ms
第 2 次:约 1ms
第 3 次:约 1ms
第 4 次:约 1ms

结论比较明确:groupId term 和 answerDate range 不是这次秒级延迟的主要来源。

5.2 只保留第一层 itemId 聚合

bash 复制代码
curl -s -X POST "$ES/answer/_search?filter_path=took,timed_out,_shards,aggregations" \
  -H 'Content-Type: application/json' \
  -d @- <<'JSON'
{
  "size": 0,
  "track_total_hits": false,
  "query": {
    "bool": {
      "filter": [
        {
          "term": {
            "groupId": "example-group-id"
          }
        },
        {
          "range": {
            "answerDate": {
              "gte": "now-6M",
              "time_zone": "Asia/Shanghai"
            }
          }
        }
      ]
    }
  },
  "aggs": {
    "items": {
      "terms": {
        "field": "itemId",
        "size": 65535
      }
    }
  }
}
JSON

连续执行的结果类似:

text 复制代码
第 1 次:约 1,224ms
第 2 次:约 37ms
第 3 次:约 34ms
第 4 次:约 33ms
第 5 次:约 33ms

这一步很关键。只保留第一层 itemId 聚合,首次慢的问题仍然可以复现。

因此可以先排除:

  • 第二层 userId 聚合不是唯一原因;
  • Painless 指标脚本不是当前首次延迟的首要原因;
  • 当前实际桶数量过多不是必要条件;
  • 过滤查询也不是主要问题。

5.3 再执行完整聚合

完整查询的结果一般是:

text 复制代码
第 1 次:约 1,300~1,500ms
第 2 次:约 35ms
第 3 次:约 30ms
第 4 次:约 30ms

将结果放在一起看:

查询类型 第一次 后续查询
只有过滤条件 约 1ms 约 1ms
只有 itemId 聚合 约 1,224ms 约 33~37ms
完整两层聚合 约 1,300~1,500ms 约 30~40ms

到这里,定位范围已经缩小到 terms 聚合的初始化阶段。

六、定位到 Global Ordinals

要理解这个问题,得先知道 Lucene Segment 是怎么回事。

一个 Elasticsearch 分片并不是把所有文档放在一个不可变的大文件里。数据会不断写入,经过 Refresh 后形成新的 Segment,之后还会发生 Segment Merge。

每个 Segment 都可能维护自己的 term 字典和局部 ordinal。例如:

text 复制代码
Segment A:
  alpha -> 0
  beta  -> 1

Segment B:
  alpha -> 0
  gamma -> 1

这里两个 Segment 中的 0 并不是同一个全局编号。它们只是各自 Segment 内部的局部编号。

为了让跨 Segment 的 terms 聚合更高效,Elasticsearch 可以建立一套全局映射:

text 复制代码
alpha -> Global Ordinal 0
beta  -> Global Ordinal 1
gamma -> Global Ordinal 2

聚合过程可以简化成:

text 复制代码
文档中的字符串值
    ↓
Segment 局部 ordinal
    ↓
Global Ordinal
    ↓
按整数进行桶收集和计数
    ↓
最终结果阶段还原为字符串

相比在多个 Segment 中反复处理字符串,使用统一的整数 ordinal 通常更高效,特别是 keyword 字段频繁参与 terms 聚合时。

所以,Global Ordinals 本身不是问题。恰恰相反,它是为了加速聚合而存在的优化结构。

问题在于:这套结构什么时候构建。

七、理解根因:为什么第一次慢、后续快

默认情况下,Global Ordinals 往往是按需构建的,也就是 Lazy 模式。

流程大致如下:

text 复制代码
索引 Refresh
    ↓
Segment 发生变化
    ↓
第一次执行相关 terms 聚合
    ↓
读取 Segment 的 term 信息
    ↓
构建 Global Ordinals
    ↓
执行聚合
    ↓
第一次查询出现延迟尖峰

构建完成后,后续查询可以复用当前结构:

text 复制代码
第二次及后续查询
    ↓
直接复用已构建的 Global Ordinals
    ↓
聚合恢复到几十毫秒

这就解释了本次问题中最显眼的现象:

text 复制代码
第一次:约 1,200~1,500ms
后续:约 30~40ms

Global Ordinals 没有一个固定的 TTL。它的生命周期更接近当前分片的 Segment 和相关内存状态,而不是"创建后保存十分钟"。

以下情况都可能导致它重新构建或更新:

  • Refresh 产生新的 Segment;
  • Segment Merge;
  • 节点重启;
  • 相关内存结构被回收;
  • 索引结构发生变化。

因此,如果一个索引持续写入且 Refresh 很频繁,高基数字段可能反复遇到类似的初始化成本。

八、优化方案:使用 eager_global_ordinals 把成本前移

eager_global_ordinals 的作用,是把 Global Ordinals 的构建时机从第一次查询提前到 Refresh 阶段。

配置示例:

json 复制代码
{
  "properties": {
    "itemId": {
      "type": "keyword",
      "eager_global_ordinals": true
    },
    "userId": {
      "type": "keyword",
      "eager_global_ordinals": true
    }
  }
}

配置生效后,流程变为:

text 复制代码
索引 Refresh
    ↓
提前构建 Global Ordinals
    ↓
查询阶段直接使用
    ↓
第一次 terms 聚合不再承担主要初始化成本

这里有一个容易误解的地方:

eager_global_ordinals 不是让这部分成本消失,而是把成本从查询阶段转移到了 Refresh 阶段。

可以这样对比:

模式 查询阶段 Refresh 阶段
Lazy 第一次聚合承担构建成本 相对轻一些
Eager 首次聚合更稳定 承担 Global Ordinals 构建成本

所以它不是所有场景都适合。查询端更快了,并不代表系统总成本一定降低了。

九、优化过程:分别验证 itemId 和 userId

这次实验没有直接把两个字段一起改掉,而是分阶段验证。这样做稍微麻烦一点,但结论更清楚。

9.1 只开启 itemId

先给 itemId 开启 eager_global_ordinals,然后手动执行 Refresh:

bash 复制代码
curl -s -X PUT "$ES/answer/_mapping" \
  -H 'Content-Type: application/json' \
  -d '{
    "properties": {
      "itemId": {
        "type": "keyword",
        "eager_global_ordinals": true
      }
    }
  }'

curl -s -X POST "$ES/answer/_refresh?pretty"

验证第一层聚合:

text 复制代码
itemId-only 第 1 次:约 35ms
itemId-only 第 2 次:约 14ms
itemId-only 第 3 次:约 1ms
itemId-only 第 4 次:约 1ms

这说明 itemId 第一层聚合的首次延迟已经明显下降。

9.2 两层聚合仍然出现首次延迟

接下来执行:

text 复制代码
itemId -> userId

结果仍然可能是:

text 复制代码
第 1 次:约 1,582ms
第 2 次:约 1ms

这个结果说明,只优化 itemId 并不能自动解决第二层 userId 聚合。完整查询中的剩余延迟,很可能来自 userId 的 Global Ordinals 初始化。

9.3 再开启 userId

bash 复制代码
curl -s -X PUT "$ES/answer/_mapping" \
  -H 'Content-Type: application/json' \
  -d '{
    "properties": {
      "userId": {
        "type": "keyword",
        "eager_global_ordinals": true
      }
    }
  }'

curl -s -X POST "$ES/answer/_refresh?pretty"

再次执行两层聚合:

text 复制代码
itemId -> userId 第 1 次:约 35ms
itemId -> userId 第 2 次:约 1ms
itemId -> userId 第 3 次:约 1ms

通过这种拆分可以确认:

  • itemId 是第一层聚合首次延迟的主要来源;
  • userId 是第二层聚合剩余延迟的重要来源;
  • 两个字段都参与高频 terms 聚合时,需要分别评估;
  • 不能只因为一个字段优化成功,就认为完整聚合已经解决。

十、完整聚合的最终验证

两个字段都配置完成后,重新执行完整的 itemId -> userId -> 指标 聚合。

为了减少动态 now-6M 对实验的干扰,测试时使用固定时间范围。查询文件中的时间条件类似:

json 复制代码
{
  "range": {
    "answerDate": {
      "gte": "2026-01-01T00:00:00+08:00",
      "time_zone": "Asia/Shanghai"
    }
  }
}

连续执行多次:

bash 复制代码
for i in 1 2 3 4 5 6 7 8 9 10; do
  echo "===== full aggregation $i ====="
  date
  curl -s -X POST \
    "$ES/answer/_search?filter_path=took,timed_out,_shards" \
    -H 'Content-Type: application/json' \
    -d @/tmp/answer-full-aggregation.json
  echo
  sleep 2
done

验证结果:

text 复制代码
第 1 次:39ms
第 2 次:36ms
第 3 次:35ms
第 4 次:35ms

优化前的同类查询:

text 复制代码
首次约 1,564ms
后续约 30~40ms

优化后的完整聚合查询满足:

text 复制代码
timed_out=false
分片执行成功
itemId 桶数量一致
userId 桶数量一致
文档数量一致
统计指标一致

最终结果可以概括为:

场景 优化前首次查询 优化后首次查询
itemId 第一层聚合 约 1,224ms 约 35ms
itemId -> userId 两层聚合 约 1,582ms 约 35ms
完整指标聚合 约 1,564ms 约 39ms

首次查询耗时下降约 97.5%。

这里需要特别说明:本次优化没有降低 terms.size,也没有删除统计指标,因此结果变快不是因为少统计了一部分数据。

十一、开启 Eager 后,要观察哪些资源

前面说过,eager_global_ordinals 只是把成本换了一个地方支付。因此配置之后不能只看查询耗时。

1. CPU

Refresh 时需要提前构建 ordinal 映射,CPU 使用率可能增加。可以观察:

bash 复制代码
curl -s "$ES/_nodes/hot_threads?threads=10&type=cpu"

也可以结合系统层面的 CPU 监控观察 Refresh 时段是否出现明显抬升。

2. JVM Heap 和 GC

Global Ordinals 主要是内存结构,高基数字段的唯一 term 越多,潜在内存成本越高。

bash 复制代码
curl -s "$ES/_nodes/stats/jvm?human&pretty"

重点关注:

text 复制代码
heap_used_percent
old collection count
old collection time
heap_used_in_bytes

本次采样中 Heap 使用率曾从约 37% 上升到约 47%,但只有少量采样点,不能据此判断存在持续性内存增长。需要继续看完整 GC 周期和长期趋势。

3. Refresh

bash 复制代码
curl -s "$ES/_nodes/stats/indices/segments,refresh?human&pretty"

重点关注:

text 复制代码
segments.count
refresh.total
refresh.total_time_in_millis

本次短时间采样中,Refresh 次数增加了几次,累计耗时只增加了几十毫秒,没有观察到明显异常。但这只能说明采样窗口内没有明显问题,不能替代长期监控。

4. 写入线程池

bash 复制代码
curl -s "$ES/_nodes/stats/thread_pool/search,refresh,write?human&pretty"

重点查看:

text 复制代码
write.active
write.queue
write.rejected
refresh.active
refresh.queue
refresh.rejected

如果开启后写入队列持续上涨,说明查询性能收益可能是以写入链路为代价换来的,需要重新评估。

5. 磁盘 IO

Global Ordinals 不是把原始文档再写一份到磁盘,但构建过程中可能需要读取 Segment 的 term 字典和 Doc Values。如果数据不在操作系统 Page Cache 中,就可能产生磁盘读取。

Linux 环境可以观察:

bash 复制代码
iostat -xz 1

重点关注:

text 复制代码
await
%util
r/s
rkB/s
iowait

本次观察期间 CPU idle 较高,iowait 接近 0,磁盘 await 也很低,没有观察到明显 IO 等待。

十二、哪些情况下适合开启

eager_global_ordinals 比较适合下面这些场景:

  • Keyword 字段频繁用于 terms 聚合;
  • 已经通过实验确认首次聚合存在明显初始化延迟;
  • 查询延迟稳定性比 Refresh 延迟更重要;
  • 系统读多写少,或者写入以批次方式发生;
  • JVM Heap 有足够余量;
  • 可以在测试索引或低峰期完成验证。

不建议直接开启的场景包括:

  • 字段基数极高并且持续增长;
  • 索引写入非常频繁,Refresh 也很频繁;
  • JVM 堆内存余量不足;
  • 字段很少参与 terms 聚合;
  • 还没有确认慢点来自 Global Ordinals;
  • 写入实时性比查询首请求延迟更重要。

简单说,不要把它当成 Keyword 字段的默认配置。只有经常参与聚合、确实存在首次延迟的字段,才值得评估。

十三、几个容易走偏的优化方向

1. 不要先全局降低 terms.size

本次实验中,实际只有一个 itemId 桶,但第一次聚合仍然需要一秒多。说明降低 size 未必能解决 Global Ordinals 的初始化成本。

更重要的是,terms.size 直接影响返回结果。全局调小可能导致高基数场景缺桶,最后得到的统计结果就不完整了。

2. 不要直接执行 force merge

Force merge 可能改变 Segment 结构,但它不是解决所有聚合首次延迟的通用方法,而且会带来额外磁盘和 IO 压力。没有明确证据之前,不建议把它作为第一选择。

3. 不要盲目扩大搜索线程池

如果问题发生在聚合初始化,增加搜索线程数并不能消除初始化成本,反而可能让 CPU 竞争更激烈。

4. 不要把所有问题都归因于 Painless

Painless 脚本确实可能增加聚合成本,特别是扫描大量文档时。但本次实验中,只有几百条匹配文档,去掉第二层和指标聚合后,第一层 itemId 聚合仍然可以复现秒级首次延迟。

所以,脚本应该优化,但不是本次问题的首要证据。

十四、数值字段聚合:脚本能不用就不用

虽然 Painless 不是本次首次慢查询的主要原因,但原始查询中数值字段使用了类型转换脚本,这类写法仍然值得改进。

如果字段已经是数值类型:

text 复制代码
score: double
scoreRate: double
sourceScore: double
totalScore: double

优先使用字段聚合:

json 复制代码
{
  "sum": {
    "field": "score",
    "missing": 0
  }
}

而不是每条文档执行字符串转换:

json 复制代码
{
  "sum": {
    "script": {
      "source": "try { ... } catch (...) { ... }"
    }
  }
}

两种方式解决的问题不完全一样:

  • eager_global_ordinals 主要解决高基数 terms 聚合的首次初始化延迟;
  • 字段聚合主要减少每条文档上的脚本执行成本。

如果查询范围扩大到几十万或几百万条文档,去掉不必要的 Painless 脚本通常会更有价值。

十五、长期治理:Eager 不是终点

eager_global_ordinals 解决的是一个比较具体的问题:高频 terms 聚合的首次初始化延迟。

如果索引继续增长,长期还是需要处理数据规模问题。

1. 按时间拆分索引

可以按月或季度拆分:

text 复制代码
answer-2026-01
answer-2026-02
answer-2026-03

再通过别名查询最近时间范围的数据。

这样做可以限制单个索引和单个分片的规模,降低 Segment、聚合初始化和维护成本。

2. 历史统计结果预计算

对于很少变化的历史数据,可以提前计算统计结果:

text 复制代码
近期数据:实时查询原始明细
历史数据:查询预计算的统计快照

这样不需要每次都扫描多年以前的原始文档。

3. 分离实时数据和历史数据

可以根据访问频率,将数据划分为:

  • 热数据:保留在实时索引;
  • 温数据:保留在低频访问索引;
  • 冷数据:归档到历史索引或其他存储。

4. 重新评估分片和副本

一个很大的主分片会让聚合和 Segment 管理变得更集中。与此同时,副本分片如果处于 UNASSIGNED 状态,还会带来高可用问题。

这些问题和 Global Ordinals 不完全是一回事,但都属于线上统计系统需要持续关注的基础设施问题。

十六、一套可以复用的排查流程

以后遇到"ES 聚合第一次慢、后面快"的问题,可以按下面的顺序排查:

text 复制代码
1. 记录连续多次真实耗时
   ↓
2. 查看 mapping、索引规模和分片布局
   ↓
3. 检查是否使用 text、Fielddata 或错误字段类型
   ↓
4. 执行 Profile 查询
   ↓
5. 只执行过滤条件
   ↓
6. 只保留第一层 terms 聚合
   ↓
7. 增加第二层 terms 聚合
   ↓
8. 最后再加入指标聚合和脚本
   ↓
9. 检查是否出现 GlobalOrdinalsStringTermsAggregator
   ↓
10. 只针对目标字段评估 eager_global_ordinals
   ↓
11. 同时对比 Refresh、JVM、GC、写入队列和磁盘 IO
   ↓
12. 验证结果数量和统计口径没有变化

这套方法的好处是,每一步都能排除一部分可能性。虽然过程不算特别快,但比直接改一堆配置更容易得到可靠结论。

十七、最终结论

这次高基数聚合慢查询的关键结论有以下几点:

  1. "第一次慢、后续快"是重要线索,但不能直接等同于普通查询缓存命中。
  2. 过滤查询只有约 1ms,说明慢点不在 term 和 range 条件本身。
  3. 只保留第一层 itemId terms 聚合,仍然能够复现首次秒级延迟。
  4. GlobalOrdinalsStringTermsAggregator 是定位 Global Ordinals 的重要证据。
  5. eager_global_ordinals 可以把构建成本从第一次查询转移到 Refresh 阶段。
  6. itemId 和 userId 应该分字段、分层级验证,不能一次性凭经验修改。
  7. 优化后必须检查 timed_out、分片状态、桶数量、文档数量和统计结果。
  8. 开启 Eager 后需要继续观察 Heap、Old GC、Refresh、写入队列和磁盘 IO。
  9. terms.size、Painless、时间范围、索引拆分和历史归档,解决的是不同层面的问题。
  10. eager_global_ordinals 适合做针对性优化,不应该变成所有 Keyword 字段的默认配置。

附录一:常用排查命令

以下命令中的地址、索引名和标识符均为脱敏示例。

1. 查看分片和索引规模

bash 复制代码
export ES=http://127.0.0.1:9200

curl -s "$ES/_cat/shards/answer?v&s=store:desc"

curl -s "$ES/answer/_stats/search,segments,store,docs?human&pretty"

2. 查看 mapping

bash 复制代码
curl -s "$ES/answer/_mapping?pretty"

curl -s "$ES/answer/_mapping/field/itemId?pretty"

curl -s "$ES/answer/_mapping/field/userId?pretty"

3. 查看节点和线程池

bash 复制代码
curl -s "$ES/_nodes/stats/indices/search?human&pretty"

curl -s "$ES/_nodes/stats/thread_pool/search,refresh,write?human&pretty"

curl -s "$ES/_nodes/hot_threads?threads=10&type=cpu"

4. 查看 Refresh、Segment、Fielddata 和 JVM

bash 复制代码
curl -s "$ES/_nodes/stats/indices/segments,refresh?human&pretty"

curl -s "$ES/_nodes/stats/indices/fielddata?human&pretty"

curl -s "$ES/_nodes/stats/jvm?human&pretty"

5. 检查 eager 配置

bash 复制代码
curl -s "$ES/answer/_settings?include_defaults=true&pretty" \
  | grep -i -A 5 -B 5 "global_ordinals"

curl -s "$ES/answer/_mapping?pretty" \
  | grep -i -A 15 -B 5 "eager_global_ordinals"

没有查到显式配置,不代表字段不能聚合,通常只是说明字段仍然使用默认的延迟构建方式。

附录二:配置变更前的注意事项

在测试或经过审批的环境中,可以使用下面的 mapping 更新方式:

bash 复制代码
curl -s -X PUT "$ES/answer/_mapping" \
  -H 'Content-Type: application/json' \
  -d '{
    "properties": {
      "itemId": {
        "type": "keyword",
        "eager_global_ordinals": true
      }
    }
  }'

如果还需要验证 userId:

bash 复制代码
curl -s -X PUT "$ES/answer/_mapping" \
  -H 'Content-Type: application/json' \
  -d '{
    "properties": {
      "userId": {
        "type": "keyword",
        "eager_global_ordinals": true
      }
    }
  }'

执行后手动 Refresh:

bash 复制代码
curl -s -X POST "$ES/answer/_refresh?pretty"

正式环境建议按下面的顺序操作:

text 复制代码
测试索引验证
  ↓
固定查询重复测试
  ↓
观察 Refresh 和写入指标
  ↓
低峰期灰度
  ↓
持续观察 JVM、GC 和线程池
  ↓
再决定是否长期保留

不要直接把测试命令复制到生产环境执行。特别是数据量很大、写入频繁的索引,配置修改前最好先确认当前 Refresh 和 JVM 的资源余量。

参考资料

本文基于实际排查记录整理,并对业务名称、索引名称、标识符、主机信息和时间信息进行了脱敏处理。

相关推荐
Elasticsearch1 小时前
Elasticsearch:如何使用 Connectors 接入数据到 Elastic Agent builder 里进行企业搜索
elasticsearch
wuyk5554 小时前
Spider-第11讲-工程化改造与可维护性
大数据·爬虫·elasticsearch·搜索引擎
新*5 小时前
Elasticsearch 索引别名入门:创建、路由、原子切换与几个常见误解
运维·后端·elasticsearch·索引别名
wuyk5556 小时前
Spider-第12讲-asyncio异步并发爬取
大数据·爬虫·elasticsearch·搜索引擎
筑梦之人6 小时前
Elasticsearch 9.x 从入门到精通(5/7):集群、分布式与运维
运维·分布式·elasticsearch
筑梦之人7 小时前
Elasticsearch 9.x 从入门到精通(4/7):聚合分析与文本分析
大数据·elasticsearch·jenkins
Elasticsearch2 天前
过犹不及:为什么搜索结果重排序时,20 个候选结果胜过 200 个
elasticsearch
wno7042 天前
常用的Git命令清单
大数据·git·elasticsearch
YIN_尹3 天前
【git原理与使用】git基本操作及底层原理(二)
大数据·git·elasticsearch