【ES实战】 索引模板「可追溯、可校验」:一种模板治理的工程化思路

文章目录

    • 一、从一个告警说起
    • 二、三个原生解决不了的问题
    • 三、核心思路:给索引和模板之间加一条「版本化的绳子」
      • [3.1 模板表:加一个版本号,再加一个「上次检查时间」](#3.1 模板表:加一个版本号,再加一个「上次检查时间」)
      • [3.2 索引表:把「是不是模板建的」升级成「是哪个模板、哪个版本建的」](#3.2 索引表:把「是不是模板建的」升级成「是哪个模板、哪个版本建的」)
      • [3.3 打标:在创建索引的地方顺手记一笔](#3.3 打标:在创建索引的地方顺手记一笔)
    • 四、分片误数率:低频、异步、先看模板再看索引
      • [4.1 校验谁:只看「近期由模板生成的索引」](#4.1 校验谁:只看「近期由模板生成的索引」)
      • [4.2 怎么判:分片太大 / 太小都算不合理](#4.2 怎么判:分片太大 / 太小都算不合理)
      • [4.3 告警前,先反查模板------这一步能砍掉一半误报](#4.3 告警前,先反查模板——这一步能砍掉一半误报)
      • [4.4 用 `last_check_time` 做节流,而不是靠人肉记](#4.4 用 last_check_time 做节流,而不是靠人肉记)
    • 五、应用率:别让过期模板的正则「误伤」判定
      • [5.1 最隐蔽的坑:过期模板的宽泛 pattern 会「误命中」](#5.1 最隐蔽的坑:过期模板的宽泛 pattern 会「误命中」)
      • [5.2 解法:用「正向绑定」取代「pattern 反推」](#5.2 解法:用「正向绑定」取代「pattern 反推」)
      • [5.3 两者不是一回事,别混了](#5.3 两者不是一回事,别混了)
      • [5.4 一个边界情况:pattern 更宽的新模板](#5.4 一个边界情况:pattern 更宽的新模板)
    • 六、把关键取舍说清楚
    • 七、还没想透的几个点
    • 八、小结

一、从一个告警说起

ES会有一类告警:某个集群新建索引时,索引结构不满足预期,或者分片数据不满足预期,如果索引又恰好建得多、分片开得大,节点资源会被持续吃掉,最终拖垮整个集群的稳定性。

排查起来其实有一条很清晰的路径:

shell 复制代码
# 1. 看每个索引的分片数量
GET _cat/indices?v&s=index
#    pri = 主分片数,rep = 副本分片数

# 2. 看每个分片实际占用的存储
GET _cat/shards?v&s=index
#    store = 该分片的存储大小

分片「过大」会成为读写热点,查询变慢;分片「过小」又会导致碎片化,元数据和内存开销占比畸高。两种都是不合理的。

出现这种问题的其中一种场景:出问题的索引往往不是孤立的,它们大多出自同一个索引模板。

shell 复制代码
# 3. 看集群里有哪些模板
GET _cat/templates?v&s=name
#    template = 索引名匹配模式(ES 6.0 之后为 index_patterns)

# 4. 看单个模板的详细配置(重点看分片数)
GET _template/{模板名称}

到这里,真正的根因才浮出水面:模板是批量生成索引的规则源头,只要模板里 number_of_shards 配得不合理,它就会像流水线一样,把「坏配置」源源不断地复制到后续每一个索引上。

于是治理的诉求很自然地变成了三件事,而它们恰恰是 ES 原生能力覆盖不到的地方。

二、三个原生解决不了的问题

把诉求抽象一下,其实就三个问题:

问题 原生能力的局限
P1 如何识别某个索引是哪个模板生成的? 只能拿索引名对模板的 pattern 做通配匹配「反推」,没有正向的绑定关系
P2 如何关联模板的版本 与它生成的索引? 模板会随时间和修改而变化,但 ES 不保留模板历史,无法追溯「某个索引是哪个版本的模板生成的」
P3 程序化检测的收益和成本怎么平衡? 索引数据量变化很慢,周期往往是半年甚至一年,高频检测收益很低

这三个问题的本质,是 ES 的索引模板体系天生不记录「模板 → 索引」和「模板版本 → 索引」的双向追溯关系------它只关心「新建一个索引时该套用哪套配置」,从不关心「事后如何反向定位和审计」。

而 P3 则反过来框定了方案该长什么样:它必须是低频、异步、幂等的,而不是一个实时、高频的检测器。

下面给出的思路,就是围绕这三个缺口逐一把它们补上。补上之后,会顺势长出两个治理维度 :一个是「分片误数率」(模板分片配得对不对),另一个是「应用率」(模板到底还有没有人用)。后者正是用来对付过期模板的正则 pattern 被错误复用这个隐蔽问题的。

三、核心思路:给索引和模板之间加一条「版本化的绳子」

一句话概括:在模板侧引入版本号,在索引侧记录「来源模板 + 来源版本」,再基于这条关系长出两个治理维度------分片误数率和应用率。
#mermaid-svg-OFsVwEfhQtOBW02c{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-OFsVwEfhQtOBW02c .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-OFsVwEfhQtOBW02c .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-OFsVwEfhQtOBW02c .error-icon{fill:#552222;}#mermaid-svg-OFsVwEfhQtOBW02c .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-OFsVwEfhQtOBW02c .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-OFsVwEfhQtOBW02c .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-OFsVwEfhQtOBW02c .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-OFsVwEfhQtOBW02c .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-OFsVwEfhQtOBW02c .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-OFsVwEfhQtOBW02c .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-OFsVwEfhQtOBW02c .marker{fill:#333333;stroke:#333333;}#mermaid-svg-OFsVwEfhQtOBW02c .marker.cross{stroke:#333333;}#mermaid-svg-OFsVwEfhQtOBW02c svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-OFsVwEfhQtOBW02c p{margin:0;}#mermaid-svg-OFsVwEfhQtOBW02c .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-OFsVwEfhQtOBW02c .cluster-label text{fill:#333;}#mermaid-svg-OFsVwEfhQtOBW02c .cluster-label span{color:#333;}#mermaid-svg-OFsVwEfhQtOBW02c .cluster-label span p{background-color:transparent;}#mermaid-svg-OFsVwEfhQtOBW02c .label text,#mermaid-svg-OFsVwEfhQtOBW02c span{fill:#333;color:#333;}#mermaid-svg-OFsVwEfhQtOBW02c .node rect,#mermaid-svg-OFsVwEfhQtOBW02c .node circle,#mermaid-svg-OFsVwEfhQtOBW02c .node ellipse,#mermaid-svg-OFsVwEfhQtOBW02c .node polygon,#mermaid-svg-OFsVwEfhQtOBW02c .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-OFsVwEfhQtOBW02c .rough-node .label text,#mermaid-svg-OFsVwEfhQtOBW02c .node .label text,#mermaid-svg-OFsVwEfhQtOBW02c .image-shape .label,#mermaid-svg-OFsVwEfhQtOBW02c .icon-shape .label{text-anchor:middle;}#mermaid-svg-OFsVwEfhQtOBW02c .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-OFsVwEfhQtOBW02c .rough-node .label,#mermaid-svg-OFsVwEfhQtOBW02c .node .label,#mermaid-svg-OFsVwEfhQtOBW02c .image-shape .label,#mermaid-svg-OFsVwEfhQtOBW02c .icon-shape .label{text-align:center;}#mermaid-svg-OFsVwEfhQtOBW02c .node.clickable{cursor:pointer;}#mermaid-svg-OFsVwEfhQtOBW02c .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-OFsVwEfhQtOBW02c .arrowheadPath{fill:#333333;}#mermaid-svg-OFsVwEfhQtOBW02c .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-OFsVwEfhQtOBW02c .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-OFsVwEfhQtOBW02c .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-OFsVwEfhQtOBW02c .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-OFsVwEfhQtOBW02c .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-OFsVwEfhQtOBW02c .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-OFsVwEfhQtOBW02c .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-OFsVwEfhQtOBW02c .cluster text{fill:#333;}#mermaid-svg-OFsVwEfhQtOBW02c .cluster span{color:#333;}#mermaid-svg-OFsVwEfhQtOBW02c div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-OFsVwEfhQtOBW02c .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-OFsVwEfhQtOBW02c rect.text{fill:none;stroke-width:0;}#mermaid-svg-OFsVwEfhQtOBW02c .icon-shape,#mermaid-svg-OFsVwEfhQtOBW02c .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-OFsVwEfhQtOBW02c .icon-shape p,#mermaid-svg-OFsVwEfhQtOBW02c .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-OFsVwEfhQtOBW02c .icon-shape .label rect,#mermaid-svg-OFsVwEfhQtOBW02c .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-OFsVwEfhQtOBW02c .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-OFsVwEfhQtOBW02c .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-OFsVwEfhQtOBW02c :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 创建索引时打标
索引模板

(加版本号 version)
模板当前版本
索引

(加来源模板ID + 来源版本)
索引元数据
应用率

识别废弃模板
分片误数率

分片合理性校验
正向绑定 source_template_id

取代 pattern 反推,杜绝误命中
低频校验

告警前先反查模板

新增的概念只有两个:模板版本号 ,以及索引上的「来源模板 + 版本」双字段。它们分别解决 P2 和 P1,而校验的触发策略解决 P3。这两个字段共同构成一个「正向绑定」的数据底座,分片误数率和应用率两个治理维度都长在它上面。

3.1 模板表:加一个版本号,再加一个「上次检查时间」

模板表(示例里叫 index_template,你自己的表名随意)补两个字段:

sql 复制代码
ALTER TABLE index_template
    ADD COLUMN version INT NOT NULL DEFAULT 1
        COMMENT '模板版本号,每次配置变更自增',
    ADD COLUMN last_check_time DATETIME DEFAULT NULL
        COMMENT '最近一次分片校验时间';
  • version:模板每次发生实质变更(改 mapping、改分片数等)时 +1,初始为 1。
  • last_check_time:记录最近一次分片校验时间,这是后面「低频校验」节流的关键。

3.2 索引表:把「是不是模板建的」升级成「是哪个模板、哪个版本建的」

很多管理平台的索引元数据表里,其实已经有一个类似「来源」的字段,但通常只存了布尔语义,比如 create_by_template。它只能回答「是不是模板建的」,回答不了「是哪个模板建的」。

把它升级成两个字段:

sql 复制代码
ALTER TABLE index_info
    ADD COLUMN source_template_id BIGINT DEFAULT NULL
        COMMENT '来源模板ID,仅由模板创建时有值',
    ADD COLUMN source_template_version INT DEFAULT NULL
        COMMENT '创建该索引时的模板版本号';
  • source_template_id:解决 P1,建立「索引 → 模板」的正向绑定;
  • source_template_version:解决 P2,建立「索引 → 模板版本」的追溯。

关键在于:这两个字段要在「创建索引」的那一刻一次性写进去,而不是事后靠 pattern 反推。写入时机比字段本身更重要。

3.3 打标:在创建索引的地方顺手记一笔

这一步是整套方案的「数据底座」。以 Java 为例,模板创建索引的逻辑里,原来大概是这样的:

java 复制代码
// 简化示例:按模板创建索引后,写入索引元数据
void persistIndexByTemplate(Template template, String indexName) {
    IndexInfo info = new IndexInfo();
    info.setIndexName(indexName);
    info.setMapping(template.getMapping());
    // ... 其他字段省略

    // 原来:只标记「来源是模板」,是一个布尔语义
    info.setSource("create_by_template");

    // 新增:把「是哪个模板、哪个版本」也一并落库
    info.setSourceTemplateId(template.getId());
    info.setSourceTemplateVersion(template.getVersion());

    indexInfoMapper.insert(info);
}

版本号的自增则放在模板更新的入口,用一个原子操作保证并发安全:

java 复制代码
// 模板配置变更时,版本号 +1
@Update("UPDATE index_template SET mapping = #{mapping}, " +
        "version = version + 1, update_time = NOW() " +
        "WHERE id = #{id}")
int updateTemplateWithVersionBump(@Param("id") long id,
                                  @Param("mapping") String mapping);

到这里,P1 和 P2 的元数据缺口就补上了。剩下的 P3,才是真正有工程味道的部分。

四、分片误数率:低频、异步、先看模板再看索引

有了绑定关系,就能做「分片误数率」这个维度了------校验模板生成出来的索引,分片数量到底合不合理。但要克制------每天多次全量扫一遍索引分片的任务,那既耗资源又没意义(P3 说的就是这件事)。

4.1 校验谁:只看「近期由模板生成的索引」

模板生成的索引,数据量变化慢,太老的索引分片数早已固化、也趋于稳定,校验价值很低,其实旧的索引应该删除了。真正能反映「模板当前配置是否合理」的,是近期新建/滚动的索引。

所以先做一个过滤:只取由模板生成、且创建时间落在 {当前月, 当前日, 前一月, 前一日} 这几个窗口内的索引。

java 复制代码
// 校验对象筛选:由模板生成 + 近期创建
List<IndexInfo> candidates = indexInfoMapper.selectBySourceAndWindow(
        /* sourceTemplateIdNotNull = */ true,
        /* since = */ 最近一个月,
        /* until = */ now);

4.2 怎么判:分片太大 / 太小都算不合理

判定分片数是否合理,不直接看 number_of_shards 这个数字本身,而是看单分片的实际存储大小,因为它才反映「真实负载 vs 分片划分」是否匹配:

  • 单分片 store 过大 (比如 > 30GB)→ 分片数过少,热点分片,读写劣化;
  • 单分片 store 过小 (比如 < 5GB)→ 分片数过多,碎片化,元数据/内存开销占比过高。

阈值做成可配置,不同业务集群的合理区间本来就不一样。

java 复制代码
// 阈值建议外置配置,不要写死
@Value("${governance.shard-size-too-large-gb:30}")
private double shardTooLargeGb;

@Value("${governance.shard-size-too-small-gb:5}")
private double shardTooSmallGb;

boolean isShardCountReasonable(double singleShardSizeGb) {
    return singleShardSizeGb >= shardTooSmallGb
        && singleShardSizeGb <= shardTooLargeGb;
}

4.3 告警前,先反查模板------这一步能砍掉一半误报

这是整套逻辑里我最想强调的一环:索引分片不合理,不等于要立刻告警。

因为索引分片不合理有两种可能:

  1. 模板配置错了------那确实该告警,而且该提示去改模板;
  2. 索引是历史遗留------比如模板后来已经改对了,但这个索引是很久以前用旧配置建的,它一直没变,现在分片才显得不合理。

区分这两种情况的方法很简单:通过 source_template_id 反查出模板当前的分片设置,再看它合不合理。

java 复制代码
void checkShardReasonableness(IndexInfo index) {
    // 1. 取该索引的单分片实际大小
    double shardSize = fetchSingleShardSize(index.getClusterId(), index.getIndexName());

    // 2. 分片合理,直接跳过
    if (isShardCountReasonable(shardSize)) {
        return;
    }

    // 3. 分片不合理 → 反查来源模板的当前设置
    Template template = templateMapper.selectById(index.getSourceTemplateId());
    boolean templateReasonable = isShardCountReasonable(
            estimateSingleShardSize(template.getShardCount(), template.getExpectedSize()));

    // 4. 只有「模板本身也配置不合理」才告警
    if (!templateReasonable) {
        alert("索引 %s 分片不合理,且其来源模板 %s 配置需调整主分片数",
              index.getIndexName(), template.getName());
    }
    // 模板已经改对了 → 这是历史遗留索引,不告警(或另走低优先级提示)
}

这一步的收益是实打实的:把「模板配置错误」和「历史索引遗留」切开,告警的准确率会明显上一个台阶,也避免运维被一堆历史遗留问题淹没。

4.4 用 last_check_time 做节流,而不是靠人肉记

数据半年一年才变一次,校验就没必要天天跑。用模板上的 last_check_time 字段做节流即可:只有当「距上次校验超过半年(或一年,可配)」的模板,才参与本轮校验,校验完回写时间。

java 复制代码
// 节流:只处理「上次检查距今超过阈值」的模板
LocalDateTime threshold = now.minusMonths(checkIntervalMonths);

List<Template> due = templateMapper.selectByLastCheckBefore(threshold);

for (Template t : due) {
    checkTemplateGeneratedIndices(t);
    // 校验完回写 last_check_time
    templateMapper.updateLastCheckTime(t.getId(), now);
}

整个校验由一个低频定时任务驱动(月度跑一次足够),而不是请求时实时计算。这样既控制了成本,又不会遗漏「该复查的老模板」。

五、应用率:别让过期模板的正则「误伤」判定

分片校验解决的是「模板配得对不对」,但它回答不了另一个同样要命的问题:这个模板到底还有没有人用?

这就引出了「应用率」这个维度------真正有索引命中的模板数 / 模板总数。它的用途是识别「废弃模板」:一个模板早已没人维护、也没有索引在用它了,就该被清理,否则它就像房间里没人认领的旧家具一样,持续占着位置、制造噪音。

5.1 最隐蔽的坑:过期模板的宽泛 pattern 会「误命中」

判断「一个模板有没有被应用」,最直接的办法是拿它的 pattern 去匹配集群里的索引,命中就认为「已应用」。但这里藏着一个非常容易踩的坑:

过期模板的 pattern 往往写得非常宽泛 (比如 log-*、app-*、甚至 *)。当这个模板废弃之后,集群里新出现的索引------哪怕跟这个模板的业务毫无关系------依然会被这个宽泛的 pattern 命中,于是它被错误地判成「已应用」。

结果就是:应用率虚高,废弃模板被长期掩盖,正则 pattern 被错误复用而不自知。

用一个具体例子说清楚:
#mermaid-svg-G9eZcdTbuML4KKVu{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-G9eZcdTbuML4KKVu .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-G9eZcdTbuML4KKVu .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-G9eZcdTbuML4KKVu .error-icon{fill:#552222;}#mermaid-svg-G9eZcdTbuML4KKVu .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-G9eZcdTbuML4KKVu .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-G9eZcdTbuML4KKVu .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-G9eZcdTbuML4KKVu .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-G9eZcdTbuML4KKVu .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-G9eZcdTbuML4KKVu .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-G9eZcdTbuML4KKVu .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-G9eZcdTbuML4KKVu .marker{fill:#333333;stroke:#333333;}#mermaid-svg-G9eZcdTbuML4KKVu .marker.cross{stroke:#333333;}#mermaid-svg-G9eZcdTbuML4KKVu svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-G9eZcdTbuML4KKVu p{margin:0;}#mermaid-svg-G9eZcdTbuML4KKVu .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-G9eZcdTbuML4KKVu .cluster-label text{fill:#333;}#mermaid-svg-G9eZcdTbuML4KKVu .cluster-label span{color:#333;}#mermaid-svg-G9eZcdTbuML4KKVu .cluster-label span p{background-color:transparent;}#mermaid-svg-G9eZcdTbuML4KKVu .label text,#mermaid-svg-G9eZcdTbuML4KKVu span{fill:#333;color:#333;}#mermaid-svg-G9eZcdTbuML4KKVu .node rect,#mermaid-svg-G9eZcdTbuML4KKVu .node circle,#mermaid-svg-G9eZcdTbuML4KKVu .node ellipse,#mermaid-svg-G9eZcdTbuML4KKVu .node polygon,#mermaid-svg-G9eZcdTbuML4KKVu .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-G9eZcdTbuML4KKVu .rough-node .label text,#mermaid-svg-G9eZcdTbuML4KKVu .node .label text,#mermaid-svg-G9eZcdTbuML4KKVu .image-shape .label,#mermaid-svg-G9eZcdTbuML4KKVu .icon-shape .label{text-anchor:middle;}#mermaid-svg-G9eZcdTbuML4KKVu .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-G9eZcdTbuML4KKVu .rough-node .label,#mermaid-svg-G9eZcdTbuML4KKVu .node .label,#mermaid-svg-G9eZcdTbuML4KKVu .image-shape .label,#mermaid-svg-G9eZcdTbuML4KKVu .icon-shape .label{text-align:center;}#mermaid-svg-G9eZcdTbuML4KKVu .node.clickable{cursor:pointer;}#mermaid-svg-G9eZcdTbuML4KKVu .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-G9eZcdTbuML4KKVu .arrowheadPath{fill:#333333;}#mermaid-svg-G9eZcdTbuML4KKVu .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-G9eZcdTbuML4KKVu .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-G9eZcdTbuML4KKVu .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-G9eZcdTbuML4KKVu .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-G9eZcdTbuML4KKVu .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-G9eZcdTbuML4KKVu .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-G9eZcdTbuML4KKVu .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-G9eZcdTbuML4KKVu .cluster text{fill:#333;}#mermaid-svg-G9eZcdTbuML4KKVu .cluster span{color:#333;}#mermaid-svg-G9eZcdTbuML4KKVu div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-G9eZcdTbuML4KKVu .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-G9eZcdTbuML4KKVu rect.text{fill:none;stroke-width:0;}#mermaid-svg-G9eZcdTbuML4KKVu .icon-shape,#mermaid-svg-G9eZcdTbuML4KKVu .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-G9eZcdTbuML4KKVu .icon-shape p,#mermaid-svg-G9eZcdTbuML4KKVu .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-G9eZcdTbuML4KKVu .icon-shape .label rect,#mermaid-svg-G9eZcdTbuML4KKVu .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-G9eZcdTbuML4KKVu .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-G9eZcdTbuML4KKVu .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-G9eZcdTbuML4KKVu :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 真实生成
pattern 误命中
拿 log-* 匹配 log-order
模板 A

pattern = log-*

(早已废弃)
模板 B

(真实创建者)
索引 log-order
判断 A 是否应用
命中 → 误判「已应用」❌

A 其实已经废弃了,但因为它的 pattern 太宽,被 log-order 误命中,应用率就多算了一个「假阳性」。

根因:ES 的模板匹配是「按 pattern 正向匹配」的,它天然无法区分「这个索引是被这个模板生成 的」还是「碰巧名字撞上了这个模板的 pattern」。

5.2 解法:用「正向绑定」取代「pattern 反推」

要根治「pattern 误命中」,就不能再靠「拿 pattern 去匹配索引」来判定应用与否,而是要反过来:看这个模板到底「真正生成过」哪些索引。

而这,恰好是前面第三节埋下的伏笔------索引上已经有 source_template_id 了。应用率的判定因此可以改成基于「正向绑定」:

java 复制代码
// 应用率 = 真正生成过索引的模板数 / 模板总数
long applied = templateMapper.countTemplateThatCreatedIndex(); // 存在 source_template_id 指向它的模板
long total   = templateMapper.countAll();
double applyRate = (double) applied / total;

判定「某个模板是否应用」时,不再问「它的 pattern 命中了几个索引」,而是问「有没有索引的 source_template_id 指向它」:

java 复制代码
boolean isTemplateApplied(long templateId) {
    // 正向绑定:有索引声明「我是由这个模板生成的」
    int createdCount = indexInfoMapper.countBySourceTemplateId(templateId);
    return createdCount > 0;
}

这样,模板 A 的 pattern 再宽、再能误命中 log-order,只要没有任何索引的 source_template_id 指向 A,它就会被正确地判成「未应用」。

5.3 两者不是一回事,别混了

到这里,可能会有一个疑惑:「应用率」和前面第三节讲的「是否应用」是不是同一个东西?

不是,或者说------旧做法把「是否应用」简化成了「pattern 是否命中」,而新做法把它升级成了「是否有正向绑定」。它们的差异正是本文想强调的:

靠 pattern 反推(旧) 靠正向绑定(新)
判定依据 pattern 是否命中任意索引 是否有索引的 source_template_id 指向它
过期宽泛模板 ❌ 被误命中,判「已应用」 ✅ 正确判「未应用」
准确性 有「假阳性」,应用率虚高 精确反映真实使用情况
依赖 每次都要实时匹配 pattern 索引落库时已打标,读 source_template_id 即可

所以,应用率要准,前提就是第三节的「打标」必须做扎实 ------没有 source_template_id 的正向绑定,应用率就退回到了「pattern 反推」的老路上,过期模板的宽泛正则依然会继续误伤。

5.4 一个边界情况:pattern 更宽的新模板

正向绑定还会顺带暴露一类「反向」的误命中,值得一并处理:

当新模板的 pattern 比老模板更宽时,新模板会「吞掉」本该由老模板生成的索引。这时老模板虽然没有「假阳性」,却会出现「假阴性」------它确实还在用,但因为新模板抢了先,它的索引数量骤减,应用率被低估。
#mermaid-svg-Sm0mjswMaZ31wC6I{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-Sm0mjswMaZ31wC6I .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-Sm0mjswMaZ31wC6I .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-Sm0mjswMaZ31wC6I .error-icon{fill:#552222;}#mermaid-svg-Sm0mjswMaZ31wC6I .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-Sm0mjswMaZ31wC6I .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-Sm0mjswMaZ31wC6I .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-Sm0mjswMaZ31wC6I .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-Sm0mjswMaZ31wC6I .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-Sm0mjswMaZ31wC6I .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-Sm0mjswMaZ31wC6I .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-Sm0mjswMaZ31wC6I .marker{fill:#333333;stroke:#333333;}#mermaid-svg-Sm0mjswMaZ31wC6I .marker.cross{stroke:#333333;}#mermaid-svg-Sm0mjswMaZ31wC6I svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-Sm0mjswMaZ31wC6I p{margin:0;}#mermaid-svg-Sm0mjswMaZ31wC6I .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-Sm0mjswMaZ31wC6I .cluster-label text{fill:#333;}#mermaid-svg-Sm0mjswMaZ31wC6I .cluster-label span{color:#333;}#mermaid-svg-Sm0mjswMaZ31wC6I .cluster-label span p{background-color:transparent;}#mermaid-svg-Sm0mjswMaZ31wC6I .label text,#mermaid-svg-Sm0mjswMaZ31wC6I span{fill:#333;color:#333;}#mermaid-svg-Sm0mjswMaZ31wC6I .node rect,#mermaid-svg-Sm0mjswMaZ31wC6I .node circle,#mermaid-svg-Sm0mjswMaZ31wC6I .node ellipse,#mermaid-svg-Sm0mjswMaZ31wC6I .node polygon,#mermaid-svg-Sm0mjswMaZ31wC6I .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-Sm0mjswMaZ31wC6I .rough-node .label text,#mermaid-svg-Sm0mjswMaZ31wC6I .node .label text,#mermaid-svg-Sm0mjswMaZ31wC6I .image-shape .label,#mermaid-svg-Sm0mjswMaZ31wC6I .icon-shape .label{text-anchor:middle;}#mermaid-svg-Sm0mjswMaZ31wC6I .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-Sm0mjswMaZ31wC6I .rough-node .label,#mermaid-svg-Sm0mjswMaZ31wC6I .node .label,#mermaid-svg-Sm0mjswMaZ31wC6I .image-shape .label,#mermaid-svg-Sm0mjswMaZ31wC6I .icon-shape .label{text-align:center;}#mermaid-svg-Sm0mjswMaZ31wC6I .node.clickable{cursor:pointer;}#mermaid-svg-Sm0mjswMaZ31wC6I .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-Sm0mjswMaZ31wC6I .arrowheadPath{fill:#333333;}#mermaid-svg-Sm0mjswMaZ31wC6I .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-Sm0mjswMaZ31wC6I .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-Sm0mjswMaZ31wC6I .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-Sm0mjswMaZ31wC6I .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-Sm0mjswMaZ31wC6I .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-Sm0mjswMaZ31wC6I .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-Sm0mjswMaZ31wC6I .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-Sm0mjswMaZ31wC6I .cluster text{fill:#333;}#mermaid-svg-Sm0mjswMaZ31wC6I .cluster span{color:#333;}#mermaid-svg-Sm0mjswMaZ31wC6I div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-Sm0mjswMaZ31wC6I .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-Sm0mjswMaZ31wC6I rect.text{fill:none;stroke-width:0;}#mermaid-svg-Sm0mjswMaZ31wC6I .icon-shape,#mermaid-svg-Sm0mjswMaZ31wC6I .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-Sm0mjswMaZ31wC6I .icon-shape p,#mermaid-svg-Sm0mjswMaZ31wC6I .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-Sm0mjswMaZ31wC6I .icon-shape .label rect,#mermaid-svg-Sm0mjswMaZ31wC6I .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-Sm0mjswMaZ31wC6I .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-Sm0mjswMaZ31wC6I .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-Sm0mjswMaZ31wC6I :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 更宽 pattern 抢先命中
本该生成,却被抢占
老模板

pattern = log-order-*
新模板

pattern = log-*

(更宽)
索引 log-order-2026
老模板应用率被低估

出现「假阴性」

这个问题的解法是识别「pattern 重叠」:在回填/校验时,对 pattern 之间存在包含关系的模板做一次比对,把「疑似被更宽 pattern 抢占」的模板单独提示出来,而不是直接判废弃。

这一步属于进阶优化,可以在「是否应用」的回填任务里顺带做,也可以先只做正向绑定、等遇到真实案例再补。

六、把关键取舍说清楚

决策点 选型 理由
模板版本号 自增整数 version 简单、可排序,能直接比较版本新旧;ES 的 _version 是并发控制语义,不适用
索引侧冗余来源字段 source_template_id + source_template_version 写入时一次性打标,读取时无需 pattern 反推,同时解决正向绑定和版本追溯
校验节奏 低频 + last_check_time 节流 数据变化慢,高频检测收益低;半年/一年一次足够
告警策略 先反查模板配置,模板合理则不告警 切开「模板配错」和「历史遗留」,减少误报
打标时机 创建索引时写入,而非事后反推 事后反推只能靠 pattern 匹配,无法确定版本,且不可靠
应用率判定 基于 source_template_id 正向绑定,而非 pattern 反推 过期宽泛 pattern 会误命中索引,导致应用率虚高、废弃模板被掩盖

七、还没想透的几个点

这套思路落地前,还有几个开放问题值得提前想清楚,分享出来供参考:

  1. 要不要保留模板的历史快照? 上面只记了「当前版本号」和「索引创建时的版本号」,并没有保留每个版本的完整配置。如果业务需要「回看某个索引当初的分片数到底配的多少」,就得额外引入一张模板版本历史表,那成本和收益需要单独评估。
  2. 存量索引怎么回填? 方案上线前就已经由模板创建的历史索引,没有 source_template_id。是要做一次性回填(靠 pattern 匹配补绑),还是干脆只对上线后的新索引生效?前者有匹配误差,后者有数据真空期。
  3. 「没有模板来源」的索引怎么处理? 总有那么一些索引不是模板建的,分片不合理时没有模板可反查,告警该往哪走,也需要明确。
  4. 阈值和窗口的具体取值。 分片大小的 30GB / 5GB、节流的半年还是半年/一年、时间窗口的四档,都是经验值,需要结合自家集群的实际规模标定。
  5. 应用率与「正向绑定」的回填成本。 应用率要准,依赖所有「由模板生成的索引」都打上 source_template_id;存量索引不打标,应用率就只能覆盖新索引,老模板的真实应用情况仍会失真。

八、小结

回头看,这件事的核心其实只有一句话:ES 的索引模板只做了「正向应用」,没做「反向追溯」,而治理恰恰需要的是反向追溯。

所以解决方案也不复杂------给模板加版本号,给索引记上「来源模板 + 版本」,于是两个治理维度就都立得住了:

  • 分片误数率:靠「索引 → 模板」的绑定,低频校验分片是否合理,告警前先反查模板,切开「配错」和「遗留」;
  • 应用率:靠「索引 → 模板」的正向绑定取代 pattern 反推,杜绝过期宽泛 pattern 的误命中,让废弃模板无处遁形。

三个原生缺口(绑定、版本、节奏)各用一个字段或一个策略补齐,两个治理维度(分片误数、应用率)共用了同一个数据底座------source_template_id 的正向绑定。剩下的,都是工程细节。

如果你的平台也正在被「模板配置错误导致批量索引分片不合理」这类问题困扰,希望这条思路能给你一个起点。

相关推荐
Decay__1 小时前
SQLServer 监控体系构建 —— sql_exporter + Prometheus + Grafana 全栈实战
运维·数据库·sql·mysql·架构
玄昌盛不会编程1 小时前
LeetCode——2243. 计算字符串的数字和
java·算法·leetcode
文丑颜不良啊2 小时前
LeetCode3061~3080题目解析
java·leetcode
tianyuanwo2 小时前
NocoDB 系统手册:PostgreSQL 主机资产管理的界面层实施方案
数据库·postgresql·oracle
装不满的克莱因瓶2 小时前
【AI时代必学】一篇文章教会你从零搭建Serverless架构
java·人工智能·ai·云原生·架构·serverless
Umi·2 小时前
MySQL之多表关联查询练习
数据库·mysql
实泽有之,无泽虚之2 小时前
Windows环境bat脚本自动备份MySQL数据库并清理旧备份文件
数据库·mysql
索西引擎3 小时前
MySQL 进阶:锁机制
数据库·mysql