Elasticsearch on 纪伟的个人博客

Elasticsearch 学习笔记（五）：集群与运维

Sat, 30 May 2026 10:00:00 +0800

写在前面

本文是 Elasticsearch 学习笔记系列的最后一篇，介绍集群架构、节点角色、分片分配、索引生命周期管理和运维监控。前置知识：进阶查询与优化（第四篇）。

一、集群架构

1.1 节点角色

Master 节点（master）
  - 管理集群元数据（索引、Mapping、分片位置）
  - 不参与数据存储和查询
  - 生产环境建议 3 个专用 Master 节点（避免脑裂）

Data 节点（data）
  - 存储数据和执行查询
  - 最核心的节点，IO 和 CPU 消耗最大
  - 根据数据量增加 Data 节点

Coordinating 节点
  - 接收客户端请求，分发到 Data 节点，汇总返回
  - 不存储数据，不做 Master
  - 适合做查询入口，减轻 Data 节点压力

Ingest 节点（ingest）
  - 数据预处理（Pipeline）
  - 类似 Logstash 的功能

ML 节点（ml）
  - 机器学习任务（异常检测等）

1.2 最小生产集群

1
2
3

3 Master 节点   — 高可用（2 个挂了还能选主）
3 Data 节点     — 数据存储和查询（副本需要 3 节点）
2 协调节点      — 查询入口（可选）

1.3 配置节点角色

# elasticsearch.yml

# Master 节点
node.roles: [master]

# Data 节点
node.roles: [data]

# 协调节点
node.roles: []

# Data + Master（小规模，合一部署）
node.roles: [data, master]

# Data Hot / Warm / Cold（冷热分层）
node.roles: [data_hot]
node.roles: [data_warm]
node.roles: [data_cold]

二、分片和副本

2.1 分片分配

创建索引时指定分片数：
  PUT /products
  {
    "settings": {
      "number_of_shards": 3,
      "number_of_replicas": 1
    }
  }

  3 个主分片 + 3 个副本分片 = 6 个分片

  分片分配规则：
  - 主分片和副本不在同一节点
  - 尽量均匀分布到各节点
  - 分片数创建后不能修改（只能 reindex）

2.2 副本的作用

1. 高可用    — 主分片挂了，副本自动提升为主
2. 负载均衡  — 查询可以命中主分片或副本（读性能翻倍）
3. 容灾      — 节点故障不影响数据完整性

副本数可以动态调整：
  PUT /products/_settings
  { "number_of_replicas": 2 }

2.3 分片数规划

经验值：
  每个分片 10-50GB
  每个节点不超过 20 个分片/GB 堆内存

计算：
  数据量 100GB，每分片 30GB → 4 个主分片
  3 节点集群 → 每个节点约 1-2 个主分片 + 副本

避免：
  - 分片太小（< 1GB）→ 集群管理开销大
  - 分片太大（> 50GB）→ 恢复慢，查询慢
  - 分片数过多（> 1000/节点）→ 内存压力

三、分片分配策略

3.1 分片过滤

// 节点级别打标签
// elasticsearch.yml
// node.attr.box_type: hot

// 索引分配到指定节点
PUT /products/_settings
{
  "index.routing.allocation.require.box_type": "hot"
}

3.2 冷热架构

// Hot 节点：SSD，存储近期热数据
// Warm 节点：HDD，存储较冷数据
// Cold 节点：低成本存储，归档数据

// 索引从热迁移到温
PUT /products-2026-03/_settings
{
  "index.routing.allocation.require.box_type": "warm"
}

四、索引生命周期管理（ILM）

4.1 ILM 策略

PUT /_ilm/policy/logs-policy
{
  "policy": {
    "phases": {
      "hot": {
        "min_age": "0ms",
        "actions": {
          "rollover": {
            "max_primary_shard_size": "30gb",
            "max_age": "7d"
          },
          "set_priority": { "priority": 100 }
        }
      },
      "warm": {
        "min_age": "7d",
        "actions": {
          "shrink": { "number_of_shards": 1 },
          "forcemerge": { "max_num_segments": 1 },
          "allocate": {
            "require": { "box_type": "warm" }
          },
          "set_priority": { "priority": 50 }
        }
      },
      "cold": {
        "min_age": "30d",
        "actions": {
          "allocate": {
            "require": { "box_type": "cold" }
          },
          "set_priority": { "priority": 0 }
        }
      },
      "delete": {
        "min_age": "90d",
        "actions": {
          "delete": {}
        }
      }
    }
  }
}

生命周期阶段：
  hot     — 活跃数据，频繁读写，SSD 存储
  warm    — 较少查询，只读，HDD 存储
  cold    — 极少查询，低成本存储
  delete  — 过期删除

触发条件（rollover）：
  max_primary_shard_size  — 主分片达到大小
  max_age                — 索引存在时间
  max_docs               — 文档数量

自动操作：
  rollover     — 滚动创建新索引
  shrink       — 减少分片数（冷数据不需要多分片）
  forcemerge   — 合并 Segment（减少文件数）
  allocate     — 迁移到指定节点
  delete       — 删除索引

4.2 使用 ILM

// 索引模板中关联 ILM 策略
PUT /_index_template/logs_template
{
  "index_patterns": ["logs-*"],
  "template": {
    "settings": {
      "number_of_shards": 3,
      "number_of_replicas": 1,
      "index.lifecycle.name": "logs-policy",
      "index.lifecycle.rollover_alias": "logs"
    }
  }
}

// 创建第一个索引
PUT /logs-000001
{
  "aliases": {
    "logs": { "is_write_index": true }
  }
}
// 写入 logs 别名 → 自动写入 logs-000001
// 7 天后或 30GB → 自动创建 logs-000002 → 切换写入
// 30 天后 → 迁移到 warm 节点
// 90 天后 → 自动删除

五、集群监控

5.1 集群健康

// 集群整体健康
GET /_cluster/health
// status: green / yellow / red
// green  — 所有主分片和副本都正常
// yellow — 所有主分片正常，部分副本缺失
// red    — 部分主分片不可用（数据丢失风险）

// 节点状态
GET /_cat/nodes?v
// 显示：name, ip, heap.percent, ram.percent, cpu, load_1m, node.role

// 分片状态
GET /_cat/shards?v
// 显示哪些分片在哪个节点，是否正常

// 未分配分片
GET /_cat/shards?v&h=index,shard,pristate,state,unassigned.reason&s=state

5.2 索引监控

// 索引大小和文档数
GET /_cat/indices?v&h=index,docs.count,store.size,pri.store.size&s=store.size:desc

// 索引健康
GET /_cluster/health?level=indices

// 分片详情
GET /_cat/shards/products?v

5.3 性能指标

// 搜索性能
GET /_stats/search?human

// 索引性能
GET /_stats/indexing?human

// 合并性能
GET /_stats/merges?human

// 段信息
GET /products/_segments

5.4 慢查询日志

// 开启慢查询日志
PUT /products/_settings
{
  "index.search.slowlog.threshold.query.warn": "5s",
  "index.search.slowlog.threshold.query.info": "2s",
  "index.search.slowlog.threshold.fetch.warn": "1s",
  "index.indexing.slowlog.threshold.index.warn": "10s"
}
// 超过阈值的查询会记录到慢查询日志

六、备份和恢复

6.1 创建快照仓库

// 注册仓库（文件系统）
PUT /_snapshot/my_backup
{
  "type": "fs",
  "settings": {
    "location": "/data/es_backup"
  }
}

6.2 创建快照

// 备份指定索引
PUT /_snapshot/my_backup/snapshot_20260530
{
  "indices": "products,orders",
  "ignore_unavailable": true,
  "include_global_state": false
}

// 备份所有索引
PUT /_snapshot/my_backup/snapshot_all

// 查看快照进度
GET /_snapshot/my_backup/snapshot_20260530/_status

// 查看所有快照
GET /_cat/snapshots/my_backup?v

6.3 恢复

// 从快照恢复
POST /_snapshot/my_backup/snapshot_20260530/_restore
{
  "indices": "products",
  "index_settings": {
    "index.number_of_replicas": 1
  }
}

// 恢复到新索引名
POST /_snapshot/my_backup/snapshot_20260530/_restore
{
  "indices": "products",
  "rename_pattern": "(.+)",
  "rename_replacement": "$1_restored"
}
// 恢复为 products_restored

七、常见运维操作

7.1 节点维护

// 排空节点上的分片（维护前）
PUT /_cluster/settings
{
  "transient": {
    "cluster.routing.allocation.exclude._ip": "192.168.1.100"
  }
}
// ES 会自动将该节点上的分片迁移到其他节点
// 迁移完成后可以安全停机

// 维护完成后恢复
PUT /_cluster/settings
{
  "transient": {
    "cluster.routing.allocation.exclude._ip": null
  }
}

7.2 索引操作

// 强制合并段（减少 Segment 数量，降低资源消耗）
POST /products/_forcemerge?max_num_segments=1
// 适合只读索引

// 清理缓存
POST /products/_cache/clear

// 刷新
POST /products/_refresh

// 刷盘
POST /products/_flush

7.3 Reindex（重建索引）

// 从旧索引重建到新索引（修改 Mapping 后常用）
POST /_reindex
{
  "source": { "index": "products-v1" },
  "dest":   { "index": "products-v2" }
}

// 带查询条件重建
POST /_reindex
{
  "source": {
    "index": "products-v1",
    "query": {
      "range": { "created_at": { "gte": "2026-01-01" } }
    }
  },
  "dest": { "index": "products-v2" }
}

// 远程集群重建（迁移数据）
POST /_reindex
{
  "source": {
    "remote": {
      "host": "http://old-cluster:9200"
    },
    "index": "products"
  },
  "dest": { "index": "products" }
}

八、常见问题排查

8.1 集群 Red

1. 查看哪个索引有问题
   GET /_cluster/health?level=indices

2. 查看未分配的分片
   GET /_cat/shards?v&h=index,shard,prirep,state,unassigned.reason

3. 查看未分配原因
   GET /_cluster/allocation/explain

4. 常见原因：
   - 节点宕机
   - 磁盘满了（水位超过 flood-stage）
   - 副本数超过节点数

8.2 磁盘水位

ES 磁盘水位阈值：
  cluster.routing.allocation.disk.watermark.low:    85%（默认）
    → 不再分配新分片到该节点

  cluster.routing.allocation.disk.watermark.high:    90%（默认）
    → 开始迁移该节点上的分片

  cluster.routing.allocation.disk.watermark.flood_stage: 95%（默认）
    → 所有索引设为只读

恢复方法：
  1. 清理磁盘空间
  2. 解除只读
     PUT /products/_settings
     { "index.blocks.read_only_allow_delete": null }

8.3 性能慢

排查思路：
1. 是写入慢还是查询慢？
   GET /_stats/indexing,search?human

2. 查看慢查询日志
   检查 ES 日志目录中的慢查询记录

3. 检查 JVM 堆内存
   GET /_cat/nodes?v&h=name,heap.percent,ram.percent,cpu
   堆使用 > 85% → 增加 JVM 内存或优化查询

4. 检查 GC 情况
   GET /_nodes/stats/jvm?filter_path=*.jvm.gc

5. 检查线程池
   GET /_cat/thread_pool?v&h=node_name,name,active,rejected,completed
   rejected > 0 → 请求被拒绝，需要优化或扩容

九、系列总结

9.1 知识体系回顾

第一篇：基础入门
  - 核心概念、倒排索引、索引管理、Mapping

第二篇：文档操作与搜索
  - CRUD、Bulk、全文搜索、精确搜索、bool 复合查询

第三篇：聚合分析
  - 指标聚合、桶聚合、嵌套聚合、实战场景

第四篇：进阶查询与优化
  - 深度分页、分词器、中文分词、评分调优、性能优化

第五篇：集群与运维
  - 节点角色、分片分配、ILM、监控、备份恢复

9.2 核心要点

1. ES 的核心是倒排索引，理解它就理解了搜索的本质
2. Mapping 要提前设计，生产环境不要依赖动态映射
3. text 字段做全文搜索，keyword 字段做精确匹配和聚合
4. 查询条件用 filter 不用 must（性能差距显著）
5. 中文场景必须用 IK 分词器
6. 深分页用 search_after，不要用 from/size
7. 日志类数据用 ILM 自动管理生命周期
8. 分片规划：每分片 10-50GB，不要太多也不要太少
9. 集群至少 3 个 Master 节点保证高可用
10. 磁盘水位和 JVM 堆内存是最常出问题的地方

Elasticsearch 学习笔记（四）：进阶查询与优化

Fri, 29 May 2026 10:00:00 +0800

写在前面

本文是 Elasticsearch 学习笔记系列的第四篇，介绍进阶查询技巧、分词器、中文分词、搜索调优和索引性能优化。前置知识：聚合分析（第三篇）。

一、深度分页问题

1.1 from/size 的问题

from + size 的工作方式：
  假设 5 个分片，请求 from=9990, size=10

  1. 协调节点向 5 个分片各请求前 10000 条
  2. 每个分片返回 10000 条（共 50000 条）
  3. 协调节点合并排序 50000 条
  4. 取第 9991-10000 条返回

  从 = 9990 时，实际处理了 50000 条数据
  from 越大，性能越差

  ES 默认限制 from + size <= 10000

1.2 解决方案

方案1：search_after（推荐，实时翻页）
  适合：UI 上的"加载更多"/"下一页"
  特点：基于排序值定位，性能恒定，不能跳页

方案2：scroll（适合批量导出）
  适合：全量数据导出、数据迁移
  特点：创建快照，不适合实时查询

方案3：增大 max_result_window（不推荐）
  PUT /products/_settings
  { "index.max_result_window": 50000 }
  只是提高上限，深分页性能问题没解决

1.3 search_after 详解

// 第1次查询
GET /products/_search
{
  "size": 100,
  "sort": [
    { "created_at": "desc" },
    { "_id": "asc" }
  ]
}
// 返回结果中最后一条的 sort 值：["2026-03-15", "42"]

// 第2次查询
GET /products/_search
{
  "size": 100,
  "sort": [
    { "created_at": "desc" },
    { "_id": "asc" }
  ],
  "search_after": ["2026-03-15", "42"]
}
// 基于上一页最后的排序值继续查

// 注意：sort 字段必须唯一（用 _id 兜底）

二、分词器详解

2.1 分词流程

输入文本 → Character Filters → Tokenizer → Token Filters → 倒排索引

Character Filters（字符过滤器）：
  - 去除 HTML 标签
  - 字符替换
  - 正则替换

Tokenizer（分词器）：
  - 按规则拆分为 Token（词元）
  - standard：按单词边界切分
  - whitespace：按空格切分

Token Filters（词元过滤器）：
  - 小写转换
  - 去停用词（the, a, is）
  - 词干提取（running → run）
  - 同义词替换

2.2 内置分词器

standard      — 标准分词器（默认），按单词边界切分 + 小写
simple        — 按非字母字符切分 + 小写
whitespace    — 按空格切分（不做小写）
keyword       — 不分词，整体作为一个 Token
pattern       — 按正则表达式切分
language      — 特定语言分词（english、french 等）

2.3 测试分词效果

// 使用 _analyze API 测试
GET /_analyze
{
  "analyzer": "standard",
  "text": "华为 Mate 60 Pro 手机"
}
// 返回分词结果：["华为", "mate", "60", "pro", "手", "机"]

// 指定索引的某个字段分析器
GET /products/_analyze
{
  "field": "name",
  "text": "华为 Mate 60 Pro"
}

// 查看索引字段的分词结果
GET /products/_doc/1/_termvectors?fields=name

三、中文分词

3.1 问题：standard 对中文效果差

standard 分词器处理中文：
  "华为旗舰手机" → ["华", "为", "旗", "舰", "手", "机"]

  问题：每个字作为一个词，无法按词搜索
  搜索 "旗舰" 时，"旗" 和 "舰" 分别在不同的文档中也会匹配

3.2 IK 分词器

安装（ES 8.15）：
  ./bin/elasticsearch-plugin install \
    https://github.com/infinilabs/analysis-ik/releases/download/v8.15.0/elasticsearch-analysis-ik-8.15.0.zip

  安装后重启 ES

3.3 IK 两种模式

ik_max_word   — 最细粒度切分（索引时用）
  "华为旗舰手机" → ["华为", "旗舰", "手机"]

ik_smart      — 最粗粒度切分（搜索时用）
  "华为旗舰手机" → ["华为", "旗舰", "手机"]

3.4 使用 IK 分词器

// 创建索引时指定
PUT /products
{
  "mappings": {
    "properties": {
      "name": {
        "type": "text",
        "analyzer": "ik_max_word",
        "search_analyzer": "ik_smart"
      },
      "description": {
        "type": "text",
        "analyzer": "ik_max_word",
        "search_analyzer": "ik_smart"
      }
    }
  }
}

// analyzer          — 索引时使用的分词器（细粒度，多建倒排索引）
// search_analyzer   — 搜索时使用的分词器（粗粒度，精确匹配）

3.5 自定义词库

// 扩展词典（添加新词）
// config/IKAnalyzer.cfg.xml
<properties>
  <entry key="ext_dict">custom.dic</entry>
</properties>

// custom.dic（每行一个词）
Mate60
鸿蒙
麒麟芯片

3.6 IK 分词测试

GET /_analyze
{
  "analyzer": "ik_max_word",
  "text": "华为旗舰手机搭载麒麟芯片"
}
// ["华为", "旗舰", "手机", "搭载", "麒麟", "芯片"]

GET /_analyze
{
  "analyzer": "ik_smart",
  "text": "华为旗舰手机搭载麒麟芯片"
}
// ["华为", "旗舰", "手机", "搭载", "麒麟芯片"]

四、相关性评分调优

4.1 评分机制（BM25）

ES 默认使用 BM25 算法计算相关性评分

影响因素：
  1. 词频（TF）     — 搜索词在文档中出现的次数越多，分数越高
  2. 文档频率（IDF） — 搜索词在整个索引中越罕见，分数越高
  3. 字段长度       — 字段越短，匹配到的词越重要

  搜索 "华为"：
  文档A："华为 Mate 60 Pro"（短字段，"华为" 占比高）→ 高分
  文档B："这是一款华为生产的旗舰手机，搭载麒麟芯片..."（长字段）→ 低分

4.2 function_score（自定义评分）

// 搜索 "手机"，价格低的排名靠前
GET /products/_search
{
  "query": {
    "function_score": {
      "query": {
        "match": { "name": "手机" }
      },
      "functions": [
        {
          "field_value_factor": {
            "field": "rating",
            "factor": 2,
            "modifier": "sqrt"
          }
        }
      ],
      "boost_mode": "multiply"
    }
  }
}

// modifier 选项：
//   none      — 不处理
//   log       — 取对数（压缩范围）
//   sqrt      — 平方根
//   square    — 平方
//   reciprocal — 1/x

4.3 boosting（提升/降低权重）

// 搜索 "手机"，华为品牌加权，小品牌降权
GET /products/_search
{
  "query": {
    "boosting": {
      "positive": {
        "bool": {
          "must": [
            { "match": { "name": "手机" } }
          ],
          "should": [
            { "term": { "brand": { "value": "华为", "boost": 2 } } }
          ]
        }
      },
      "negative": {
        "term": { "brand": "山寨" }
      },
      "negative_boost": 0.5
    }
  }
}
// positive 匹配的正常评分
// negative 匹配的评分 × 0.5

4.4 constant_score

// 不计算相关性评分，所有匹配的文档评分都一样（适合纯过滤）
GET /products/_search
{
  "query": {
    "constant_score": {
      "filter": {
        "term": { "category": "手机" }
      },
      "boost": 1.2
    }
  }
}

五、索引性能优化

5.1 Bulk 批量写入

最佳实践：
  - 每批 1000-5000 条文档
  - 批量大小 5-15MB
  - 多线程并发写入

// 批量写入示例
POST /_bulk
{"index":{"_index":"products","_id":"1"}}
{"name":"华为 Mate 60","price":6999}
{"index":{"_index":"products","_id":"2"}}
{"name":"小米 14","price":3999}

5.2 Refresh 和 Flush

写入流程：
  1. 写入 Index Buffer
  2. Refresh（默认 1 秒）→ Buffer 写入新的 Segment → 可搜索
  3. Flush → Segment 持久化到磁盘 + 清除 Translog

调优：
  - 提高刷新间隔（批量写入时）
    PUT /products/_settings
    { "index.refresh_interval": "30s" }

  - 批量写入完成后恢复
    PUT /products/_settings
    { "index.refresh_interval": "1s" }

  - 批量导入时可以设为 -1（关闭自动刷新）
    导入完成后手动刷新：POST /products/_refresh

5.3 Translog 配置

PUT /products/_settings
{
  "index.translog.durability": "async",
  "index.translog.sync_interval": "30s"
}
// async：异步刷盘，性能更好但有丢失风险
// request：每次请求都刷盘（默认，安全但慢）

5.4 索引设计优化

1. 合理设置分片数
   - 小索引（< 1GB）：1 个分片
   - 中等索引（1-50GB）：3-5 个分片
   - 大索引（> 50GB）：按 30-50GB/分片计算

2. 避免过多字段
   - 字段过多 → Mapping 膨胀 → 性能下降
   - 不需要搜索的字段设置 "index": false
   - 不需要聚合的字段设置 "doc_values": false

3. 使用 _source 过滤
   - 不需要返回的大字段可以用 store + _source excludes

4. 索引按时间滚动
   - logs-2026.05.01, logs-2026.05.02
   - 方便删除过期数据（直接删整个索引）

5.5 查询优化

1. 用 filter 代替 query（不评分，会缓存）
2. 避免深分页（用 search_after）
3. 只返回需要的字段（_source 过滤）
4. 避免用 wildcard/regexp 前缀通配符（如 *华为）
5. 控制返回的桶数量（terms 的 size）
6. 避免在高基数字段上做聚合

六、Kibana 使用技巧

6.1 Dev Tools

Kibana Dev Tools 快捷键：
  Ctrl + Enter    — 执行当前请求
  Ctrl + /        — 注释/取消注释
  Ctrl + Space    — 自动补全
  Ctrl + ↑/↓      — 跳转到上/下一个请求

6.2 Discover（数据浏览）

1. 选择索引模式（如 logs-*）
2. 设置时间范围
3. 用 KQL 或 Lucene 语法过滤
4. 添加字段列显示
5. 保存搜索条件

6.3 Dashboard（仪表盘）

1. 创建可视化（Visualization）
   - 柱状图、饼图、折线图、数据表格
   - 基于聚合结果展示

2. 组合到 Dashboard
   - 多个可视化组件排布
   - 全局时间过滤
   - 共享给团队

七、小结

本文学习了进阶查询与优化：

深度分页问题（search_after、scroll）
分词器详解（Analyzer、Tokenizer、Token Filter）
中文分词（IK 分词器、自定义词库）
相关性评分调优（BM25、function_score、boosting）
索引性能优化（Bulk、Refresh、Flush、分片设计）
查询优化技巧
Kibana 使用技巧

下一篇将学习集群运维：节点角色、分片分配、ILM 和监控排查。

Elasticsearch 学习笔记（三）：聚合分析

Thu, 28 May 2026 10:00:00 +0800

写在前面

本文是 Elasticsearch 学习笔记系列的第三篇，介绍 ES 的聚合分析框架：指标聚合、桶聚合、嵌套聚合和实战统计场景。前置知识：文档操作与搜索（第二篇）。

一、聚合分析概述

1.1 什么是聚合

聚合（Aggregation）是对数据进行统计计算和分析，类似 SQL 的 GROUP BY + 聚合函数。

SQL：
  SELECT brand, COUNT(*), AVG(price)
  FROM products
  WHERE category = '手机'
  GROUP BY brand
  ORDER BY COUNT(*) DESC

ES 聚合：
  "query": { "term": { "category": "手机" } },
  "aggs": {
    "by_brand": {
      "terms": { "field": "brand" },
      "aggs": {
        "avg_price": { "avg": { "field": "price" } }
      }
    }
  }

1.2 聚合分类

1
2
3

指标聚合（Metric）    — 计算数值指标（avg、sum、max、min）
桶聚合（Bucket）      — 按规则分组，每组一个桶（terms、date_histogram）
管道聚合（Pipeline）  — 基于其他聚合的结果再聚合

二、指标聚合（Metric）

2.1 基本统计

// 单个指标
GET /products/_search
{
  "size": 0,
  "aggs": {
    "avg_price": { "avg": { "field": "price" } },
    "max_price": { "max": { "field": "price" } },
    "min_price": { "min": { "field": "price" } },
    "sum_price": { "sum": { "field": "price" } }
  }
}

// stats 一次返回多个指标
GET /products/_search
{
  "size": 0,
  "aggs": {
    "price_stats": { "stats": { "field": "price" } }
  }
}
// 返回：count, min, max, avg, sum

2.2 去重计数

GET /products/_search
{
  "size": 0,
  "aggs": {
    "unique_brands": { "cardinality": { "field": "brand" } }
  }
}
// 类似 SQL 的 COUNT(DISTINCT brand)
// 注意：cardinality 是近似值（HyperLogLog 算法）
// precision_threshold 控制精度（默认 3000）

2.3 百分位统计

GET /products/_search
{
  "size": 0,
  "aggs": {
    "price_percentiles": {
      "percentiles": {
        "field": "price",
        "percents": [25, 50, 75, 95, 99]
      }
    }
  }
}
// 返回各百分位的价格值

2.4 文档计数

GET /products/_search
{
  "size": 0,
  "aggs": {
    "value_count": { "value_count": { "field": "price" } }
  }
}
// 有 price 字段的文档数量

三、桶聚合（Bucket）

3.1 terms（按字段值分组）

GET /products/_search
{
  "size": 0,
  "aggs": {
    "by_brand": {
      "terms": {
        "field": "brand",
        "size": 20
      }
    }
  }
}
// 按品牌分组，返回每个品牌的文档数
// size 控制返回多少个桶（默认 10）

// 排序
GET /products/_search
{
  "size": 0,
  "aggs": {
    "by_brand": {
      "terms": {
        "field": "brand",
        "size": 20,
        "order": { "_key": "asc" }       // 按品牌名排序
        // "order": { "_count": "desc" }  // 按文档数排序（默认）
      }
    }
  }
}

3.2 date_histogram（按时间分组）

// 按月统计商品数量
GET /products/_search
{
  "size": 0,
  "aggs": {
    "by_month": {
      "date_histogram": {
        "field": "created_at",
        "calendar_interval": "month",
        "format": "yyyy-MM"
      }
    }
  }
}

// 按天统计
GET /products/_search
{
  "size": 0,
  "aggs": {
    "by_day": {
      "date_histogram": {
        "field": "created_at",
        "calendar_interval": "day",
        "format": "yyyy-MM-dd",
        "min_doc_count": 0,
        "extended_bounds": {
          "min": "2026-01-01",
          "max": "2026-06-30"
        }
      }
    }
  }
}
// min_doc_count: 0     — 没有数据的日期也返回（补零）
// extended_bounds      — 扩展时间范围

时间间隔选项：
  calendar_interval:
    "minute", "hour", "day", "week", "month", "quarter", "year"

  fixed_interval:
    "30s", "1m", "5m", "1h", "12h", "1d"
    （固定时长，不考虑日历，适合精确间隔）

3.3 histogram（按数值区间分组）

// 按价格区间统计（每 2000 元一个区间）
GET /products/_search
{
  "size": 0,
  "aggs": {
    "price_ranges": {
      "histogram": {
        "field": "price",
        "interval": 2000,
        "min_doc_count": 0
      }
    }
  }
}
// 返回：0-2000, 2000-4000, 4000-6000, ...

3.4 range（自定义区间）

GET /products/_search
{
  "size": 0,
  "aggs": {
    "price_bands": {
      "range": {
        "field": "price",
        "ranges": [
          { "key": "低价位", "to": 2000 },
          { "key": "中低价位", "from": 2000, "to": 5000 },
          { "key": "中高价位", "from": 5000, "to": 10000 },
          { "key": "高价位", "from": 10000 }
        ]
      }
    }
  }
}

3.5 filter（过滤桶）

GET /products/_search
{
  "size": 0,
  "aggs": {
    "in_stock_count": {
      "filter": {
        "term": { "in_stock": true }
      }
    }
  }
}
// 统计有库存的商品数量

3.6 filters（多过滤桶）

GET /products/_search
{
  "size": 0,
  "aggs": {
    "stock_status": {
      "filters": {
        "filters": {
          "in_stock":  { "term": { "in_stock": true } },
          "out_of_stock": { "term": { "in_stock": false } }
        }
      }
    }
  }
}

四、嵌套聚合

4.1 桶内嵌套指标聚合

// 按品牌分组，每组计算平均价格和最高评分
GET /products/_search
{
  "size": 0,
  "aggs": {
    "by_brand": {
      "terms": { "field": "brand", "size": 20 },
      "aggs": {
        "avg_price": { "avg": { "field": "price" } },
        "max_rating": { "max": { "field": "rating" } },
        "product_count": { "value_count": { "field": "name.keyword" } }
      }
    }
  }
}

返回结果：

"buckets": [
  {
    "key": "华为",
    "doc_count": 3,
    "avg_price": { "value": 5765.67 },
    "max_rating": { "value": 4.8 },
    "product_count": { "value": 3 }
  },
  {
    "key": "苹果",
    "doc_count": 2,
    "avg_price": { "value": 11999.0 },
    "max_rating": { "value": 4.9 },
    "product_count": { "value": 2 }
  }
]

4.2 多级嵌套

// 按品牌分组 → 按分类再分组 → 计算平均价格
GET /products/_search
{
  "size": 0,
  "aggs": {
    "by_brand": {
      "terms": { "field": "brand" },
      "aggs": {
        "by_category": {
          "terms": { "field": "category" },
          "aggs": {
            "avg_price": { "avg": { "field": "price" } }
          }
        }
      }
    }
  }
}

4.3 按品牌分组 + 按月统计趋势

GET /products/_search
{
  "size": 0,
  "aggs": {
    "by_brand": {
      "terms": { "field": "brand" },
      "aggs": {
        "by_month": {
          "date_histogram": {
            "field": "created_at",
            "calendar_interval": "month",
            "format": "yyyy-MM"
          }
        }
      }
    }
  }
}

五、实战场景

5.1 电商数据分析

// 需求：手机分类的各品牌销量占比和平均价格
GET /products/_search
{
  "size": 0,
  "query": {
    "term": { "category": "手机" }
  },
  "aggs": {
    "brands": {
      "terms": { "field": "brand", "size": 10 },
      "aggs": {
        "avg_price": { "avg": { "field": "price" } },
        "price_distribution": {
          "histogram": {
            "field": "price",
            "interval": 1000
          }
        }
      }
    }
  }
}

5.2 日志分析

// 假设索引 logs-2026.05

// 1. 每个服务的错误数
GET /logs-*/_search
{
  "size": 0,
  "query": {
    "term": { "level": "ERROR" }
  },
  "aggs": {
    "by_service": {
      "terms": { "field": "service", "size": 20 }
    }
  }
}

// 2. 错误数时间趋势（每小时）
GET /logs-*/_search
{
  "size": 0,
  "query": {
    "term": { "level": "ERROR" }
  },
  "aggs": {
    "errors_over_time": {
      "date_histogram": {
        "field": "timestamp",
        "fixed_interval": "1h",
        "format": "yyyy-MM-dd HH:mm"
      }
    }
  }
}

// 3. 错误数 TOP 5 服务 + 每个服务的错误类型分布
GET /logs-*/_search
{
  "size": 0,
  "query": {
    "term": { "level": "ERROR" }
  },
  "aggs": {
    "top_services": {
      "terms": { "field": "service", "size": 5 },
      "aggs": {
        "by_error_type": {
          "terms": { "field": "error_type", "size": 10 }
        }
      }
    }
  }
}

5.3 用户行为分析

// 假设索引 user_actions

// 每天的活跃用户数
GET /user_actions/_search
{
  "size": 0,
  "aggs": {
    "daily_active": {
      "date_histogram": {
        "field": "timestamp",
        "calendar_interval": "day",
        "format": "yyyy-MM-dd"
      },
      "aggs": {
        "unique_users": {
          "cardinality": { "field": "user_id" }
        }
      }
    }
  }
}

// 各操作的占比
GET /user_actions/_search
{
  "size": 0,
  "aggs": {
    "by_action": {
      "terms": { "field": "action" }
    }
  }
}

六、聚合注意事项

6.1 text 字段不能直接聚合

text 字段会分词，无法用于聚合。
要对文本字段聚合，需要用它的 keyword 子字段：

错误：  "field": "name"
正确：  "field": "name.keyword"

或者在 Mapping 中定义多字段：
  "name": {
    "type": "text",
    "fields": {
      "keyword": { "type": "keyword" }
    }
  }

6.2 size 的影响

查询的 size 控制返回的文档数（文档级别的结果）
聚合的 size 控制返回的桶数（聚合级别的结果）

// size: 0 表示不返回文档，只返回聚合结果
GET /products/_search
{
  "size": 0,
  "aggs": { ... }
}

6.3 性能建议

1. 聚合查询加 size: 0（不需要文档只要统计结果）
2. 用 filter 代替 query 减少评分开销
3. 控制桶的数量（terms 的 size 不要太大）
4. 避免深度嵌套聚合（最多 2-3 层）
5. 对聚合字段开启 doc_values（keyword 默认开启）

七、小结

本文学习了聚合分析：

聚合分类（指标、桶、管道）
指标聚合（avg、sum、max、min、cardinality、percentiles）
桶聚合（terms、date_histogram、histogram、range、filter）
嵌套聚合（桶内嵌套指标和多级嵌套）
实战场景（电商分析、日志分析、用户行为分析）

下一篇将学习进阶查询与优化：深度分页、分词器、中文分词和搜索调优。

Elasticsearch 学习笔记（二）：文档操作与搜索

Wed, 27 May 2026 10:00:00 +0800

写在前面

本文是 Elasticsearch 学习笔记系列的第二篇，介绍文档 CRUD 操作和各种搜索查询。前置知识：基础入门（第一篇）。

一、文档 CRUD

1.1 准备测试数据

PUT /products
{
  "mappings": {
    "properties": {
      "name":        { "type": "text", "analyzer": "ik_max_word", "fields": { "keyword": { "type": "keyword" } } },
      "brand":       { "type": "keyword" },
      "price":       { "type": "float" },
      "category":    { "type": "keyword" },
      "in_stock":    { "type": "boolean" },
      "rating":      { "type": "float" },
      "created_at":  { "type": "date", "format": "yyyy-MM-dd" },
      "description": { "type": "text", "analyzer": "ik_max_word" },
      "tags":        { "type": "keyword" }
    }
  }
}

1.2 Index（创建/覆盖）

// 指定 ID 创建（如果已存在则覆盖）
PUT /products/_doc/1
{
  "name": "华为 Mate 60 Pro",
  "brand": "华为",
  "price": 6999,
  "category": "手机",
  "in_stock": true,
  "rating": 4.8,
  "created_at": "2026-01-15",
  "description": "华为旗舰手机，搭载麒麟芯片，支持卫星通信",
  "tags": ["5G", "旗舰", "国产"]
}

// 自动生成 ID
POST /products/_doc
{
  "name": "小米 14",
  "brand": "小米",
  "price": 3999,
  "category": "手机",
  "in_stock": true
}

1.3 Get（查询）

// 按 ID 查询
GET /products/_doc/1

// 只返回 source（不要元数据）
GET /products/_source/1

// 只要特定字段
GET /products/_doc/1?_source=name,price

// 检查文档是否存在（不返回内容）
HEAD /products/_doc/1

1.4 Update（更新）

// 部分更新（只更新指定字段）
POST /products/_update/1
{
  "doc": {
    "price": 6499,
    "in_stock": false
  }
}

// 脚本更新
POST /products/_update/1
{
  "script": {
    "source": "ctx._source.price -= params.discount",
    "params": {
      "discount": 500
    }
  }
}

// upsert（存在则更新，不存在则插入）
POST /products/_update/1
{
  "doc": { "price": 5999 },
  "upsert": {
    "name": "华为 Mate 60 Pro",
    "brand": "华为",
    "price": 5999,
    "category": "手机"
  }
}

1.5 Delete（删除）

// 按 ID 删除
DELETE /products/_doc/1

// 按查询删除
POST /products/_delete_by_query
{
  "query": {
    "match": {
      "brand": "已下架"
    }
  }
}

1.6 Bulk（批量操作）

// 批量操作（注意：每行之间不能有空行）
POST /_bulk
{"index":{"_index":"products","_id":"2"}}
{"name":"小米 14","brand":"小米","price":3999,"category":"手机","in_stock":true,"rating":4.5,"created_at":"2026-02-01","tags":["5G","性价比"]}
{"index":{"_index":"products","_id":"3"}}
{"name":"苹果 iPhone 15 Pro","brand":"苹果","price":8999,"category":"手机","in_stock":true,"rating":4.7,"created_at":"2026-01-20","tags":["5G","旗舰"]}
{"index":{"_index":"products","_id":"4"}}
{"name":"华为 MatePad Pro","brand":"华为","price":3299,"category":"平板","in_stock":true,"rating":4.6,"created_at":"2026-03-01","tags":["平板","办公"]}
{"index":{"_index":"products","_id":"5"}}
{"name":"MacBook Pro 14","brand":"苹果","price":14999,"category":"笔记本","in_stock":true,"rating":4.9,"created_at":"2026-02-15","tags":["办公","创作"]}
{"update":{"_index":"products","_id":"1"}}
{"doc":{"price":6499}}
{"delete":{"_index":"products","_id":"6"}}

Bulk 支持的操作：
  index   — 创建/覆盖文档
  create  — 创建（已存在则失败）
  update  — 更新
  delete  — 删除

性能建议：
  - 每批 1000-5000 条
  - 批量大小控制在 5-15MB
  - 不要太大，否则 ES 内存压力大

二、全文搜索

2.1 match（最常用）

// 全文搜索：对搜索词分词后匹配
GET /products/_search
{
  "query": {
    "match": {
      "name": "华为旗舰"
    }
  }
}
// "华为旗舰" 分词为 ["华为", "旗舰"]
// 匹配 name 中包含 "华为" 或 "旗舰" 的文档（OR 关系）

// AND 关系
GET /products/_search
{
  "query": {
    "match": {
      "name": {
        "query": "华为旗舰",
        "operator": "and"
      }
    }
  }
}
// 必须同时包含 "华为" 和 "旗舰"

2.2 match_phrase（短语匹配）

// 短语搜索：分词后必须按顺序连续出现
GET /products/_search
{
  "query": {
    "match_phrase": {
      "name": "华为 Mate"
    }
  }
}
// "华为 Mate" 必须连续出现，"Mate 华为" 不匹配

// 允许间隔（slop）
GET /products/_search
{
  "query": {
    "match_phrase": {
      "name": {
        "query": "华为 Pro",
        "slop": 2
      }
    }
  }
}
// 允许中间隔 2 个词

2.3 multi_match（多字段搜索）

// 在多个字段中搜索
GET /products/_search
{
  "query": {
    "multi_match": {
      "query": "华为旗舰",
      "fields": ["name", "description", "tags"]
    }
  }
}

// 指定字段权重（^ 后面是权重倍数）
GET /products/_search
{
  "query": {
    "multi_match": {
      "query": "华为旗舰",
      "fields": ["name^3", "description^2", "tags"]
    }
  }
}
// name 匹配的得分 × 3，description 匹配 × 2，tags 匹配 × 1

2.4 query_string

// 支持Lucene 语法的查询
GET /products/_search
{
  "query": {
    "query_string": {
      "query": "(华为 OR 苹果) AND 旗舰",
      "fields": ["name", "description"]
    }
  }
}

三、精确搜索

3.1 term（精确匹配）

// term：不分词，精确匹配（用于 keyword 字段）
GET /products/_search
{
  "query": {
    "term": {
      "brand": "华为"
    }
  }
}
// 注意：不要对 text 字段用 term（text 字段存储的是分词后的结果）

// terms：匹配多个值（类似 SQL 的 IN）
GET /products/_search
{
  "query": {
    "terms": {
      "brand": ["华为", "苹果"]
    }
  }
}

3.2 range（范围查询）

GET /products/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 3000,
        "lte": 7000
      }
    }
  }
}

// 日期范围
GET /products/_search
{
  "query": {
    "range": {
      "created_at": {
        "gte": "2026-01-01",
        "lt": "2026-04-01"
      }
    }
  }
}

操作符：
  gt    — 大于
  gte   — 大于等于
  lt    — 小于
  lte   — 小于等于

3.3 exists 和 missing

// 字段存在
GET /products/_search
{
  "query": {
    "exists": {
      "field": "description"
    }
  }
}

3.4 prefix、wildcard、regexp

// 前缀匹配
GET /products/_search
{
  "query": {
    "prefix": {
      "name.keyword": {
        "value": "华为"
      }
    }
  }
}

// 通配符匹配（性能差，慎用）
GET /products/_search
{
  "query": {
    "wildcard": {
      "brand": {
        "value": "华*"
      }
    }
  }
}

// 正则匹配（性能差，慎用）
GET /products/_search
{
  "query": {
    "regexp": {
      "brand": "华.*"
    }
  }
}

四、复合查询（bool）

4.1 bool 查询结构

GET /products/_search
{
  "query": {
    "bool": {
      "must": [],
      "should": [],
      "must_not": [],
      "filter": []
    }
  }
}

must      — 必须匹配，参与评分
should    — 至少匹配一个（或全部不匹配也行），参与评分
must_not  — 必须不匹配，不参与评分
filter    — 必须匹配，不参与评分（性能更好，会缓存）

4.2 实战组合

// 需求：华为品牌的手机，价格 3000-7000，有库存
GET /products/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "name": "华为" } }
      ],
      "filter": [
        { "term": { "category": "手机" } },
        { "range": { "price": { "gte": 3000, "lte": 7000 } } },
        { "term": { "in_stock": true } }
      ],
      "must_not": [
        { "term": { "brand": "已下架" } }
      ]
    }
  }
}

4.3 must vs filter 的区别

must：
  - 参与相关性评分（_score）
  - 匹配程度影响排序
  - 适合：用户搜索关键词

filter：
  - 不参与评分（_score = 0）
  - 只判断是/否
  - 性能更好（ES 会缓存 filter 结果）
  - 适合：精确过滤条件（品牌、分类、价格范围、日期范围）

最佳实践：
  用户搜索的关键词 → must
  过滤条件        → filter

4.4 should 的行为

// 有 must/filter 时：should 不强制匹配（加分项）
GET /products/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "name": "手机" } }
      ],
      "should": [
        { "term": { "brand": "华为" } },
        { "term": { "brand": "苹果" } }
      ]
    }
  }
}
// 必须匹配 "手机"，如果品牌是华为或苹果会排名更靠前

// 没有 must/filter 时：should 至少匹配一个
GET /products/_search
{
  "query": {
    "bool": {
      "should": [
        { "term": { "brand": "华为" } },
        { "term": { "brand": "苹果" } }
      ],
      "minimum_should_match": 1
    }
  }
}

五、排序

5.1 基本排序

// 按价格升序
GET /products/_search
{
  "query": { "match_all": {} },
  "sort": [
    { "price": "asc" }
  ]
}

// 多字段排序
GET /products/_search
{
  "query": { "match_all": {} },
  "sort": [
    { "in_stock": "desc" },
    { "price": "asc" }
  ]
}
// 先按是否有库存排，有库存的在前；再按价格升序

5.2 按相关性排序

// 默认按 _score 降序（相关性最高的在前）
GET /products/_search
{
  "query": {
    "match": {
      "name": "华为"
    }
  }
}

// 显式指定
GET /products/_search
{
  "query": {
    "match": {
      "name": "华为"
    }
  },
  "sort": [
    "_score",
    { "price": "asc" }
  ]
}

六、分页

6.1 from / size（基本分页）

// 第1页，每页10条
GET /products/_search
{
  "query": { "match_all": {} },
  "from": 0,
  "size": 10
}

// 第2页
GET /products/_search
{
  "query": { "match_all": {} },
  "from": 10,
  "size": 10
}

from  — 跳过前 N 条（0 开始）
size  — 返回条数（默认 10，最大 10000）

限制：from + size 不能超过 10000（index.max_result_window）
超过需要用 search_after 或 scroll

6.2 search_after（深度分页）

// 第1次查询
GET /products/_search
{
  "query": { "match_all": {} },
  "size": 10,
  "sort": [
    { "created_at": "desc" },
    { "_id": "asc" }
  ]
}

// 下一页：用上一页最后一条的 sort 值
GET /products/_search
{
  "query": { "match_all": {} },
  "size": 10,
  "sort": [
    { "created_at": "desc" },
    { "_id": "asc" }
  ],
  "search_after": ["2026-03-01", "4"]
}

6.3 分页方案对比

from/size     — 简单，适合浅分页（前100页）
                 深分页性能差（from=9990 需要跳过 9990 条）

search_after  — 适合深度分页和实时数据
                 每次请求都基于上一页最后一条
                 不能跳页，只能翻页

scroll        — 适合批量导出全量数据
                 创建快照，逐批拉取
                 不适合实时查询（数据不是最新的）

七、高亮

GET /products/_search
{
  "query": {
    "match": {
      "name": "华为旗舰"
    }
  },
  "highlight": {
    "pre_tags": ["<em>"],
    "post_tags": ["</em>"],
    "fields": {
      "name": {},
      "description": {}
    }
  }
}

返回结果中高亮字段：

"highlight": {
  "name": ["<em>华为</em> Mate 60 <em>旗舰</em> 手机"],
  "description": ["<em>华为</em><em>旗舰</em>手机，搭载麒麟芯片"]
}

八、_source 过滤

// 只返回指定字段
GET /products/_search
{
  "query": { "match_all": {} },
  "_source": ["name", "price", "brand"]
}

// 排除指定字段
GET /products/_search
{
  "query": { "match_all": {} },
  "_source": {
    "excludes": ["description", "tags"]
  }
}

// 通配符
GET /products/_search
{
  "query": { "match_all": {} },
  "_source": ["name", "price*"]
}

九、count（计数）

// 满足条件的文档数量
GET /products/_count
{
  "query": {
    "term": { "brand": "华为" }
  }
}

十、搜索查询速查

全文搜索：
  match             — 分词后搜索（最常用）
  match_phrase      — 短语匹配（必须连续）
  multi_match       — 多字段搜索

精确搜索：
  term              — 精确匹配（keyword 字段）
  terms             — 多值匹配（IN）
  range             — 范围查询
  exists            — 字段存在

复合查询：
  bool.must         — 必须匹配（参与评分）
  bool.filter       — 必须匹配（不参与评分，更快）
  bool.should       — 加分项
  bool.must_not     — 必须不匹配

排序：sort
分页：from/size, search_after
高亮：highlight
字段过滤：_source

十一、小结

本文学习了文档操作和搜索查询：

文档 CRUD（Index、Get、Update、Delete、Bulk）
全文搜索（match、match_phrase、multi_match）
精确搜索（term、terms、range、exists）
复合查询（bool：must/filter/should/must_not）
排序、分页和高亮
_source 过滤和计数

下一篇将学习聚合分析：指标聚合、桶聚合和实战统计。

Elasticsearch 学习笔记（一）：基础入门

Tue, 26 May 2026 10:00:00 +0800

写在前面

本文是 Elasticsearch 学习笔记系列的第一篇，介绍 ES 的核心概念、倒排索引原理和基本操作。基于 ES 8.15 版本。无论你是做搜索还是日志分析，这篇都是入门的基础。

一、Elasticsearch 是什么

1.1 定义

Elasticsearch 是一个基于 Lucene 的分布式搜索和分析引擎。

核心能力：
- 全文搜索       — 毫秒级从海量文本中找到匹配结果
- 结构化搜索      — 按字段精确过滤（数值、日期、枚举）
- 聚合分析        — 统计、分组、指标计算
- 分布式          — 水平扩展，处理 PB 级数据
- 近实时          — 数据写入后约 1 秒可搜索

1.2 典型应用场景

应用搜索          — 电商商品搜索、文档搜索
日志分析          — ELK 技术栈（ES + Logstash + Kibana）
监控告警          — 系统指标、业务指标聚合分析
安全分析          — SIEM，安全事件检索和关联
业务数据看板      — 实时统计报表

1.3 ELK 生态

Elasticsearch  — 存储和搜索引擎
Kibana         — 可视化和查询界面
Logstash       — 数据采集和转换
Beats          — 轻量级数据采集器（Filebeat、Metricbeat 等）

二、核心概念

2.1 与关系型数据库的类比

MySQL                Elasticsearch
─────────────────    ─────────────────
Database             Index（索引）
Table                Index（一个 Index 就是一张表）
Row                  Document（文档）
Column               Field（字段）
Schema               Mapping（映射）
SQL                  DSL（Query DSL / REST API）
PRIMARY KEY          _id

2.2 核心术语

Index（索引）        — 文档的集合，类似数据库
Document（文档）     — 一条数据，JSON 格式
Field（字段）        — 文档中的一个属性
Mapping（映射）      — 定义索引的字段类型和属性
Shard（分片）        — 索引的物理分片，分布式存储
Replica（副本）      — 分片的复制，提供高可用
Node（节点）         — 一个 ES 实例
Cluster（集群）      — 多个节点组成

2.3 文档结构

{
  "_index": "products",
  "_id": "1",
  "_source": {
    "name": "华为 Mate 60 Pro",
    "brand": "华为",
    "price": 6999,
    "category": "手机",
    "in_stock": true,
    "created_at": "2026-01-15"
  }
}

1
2
3

_index   — 文档所在的索引
_id      — 文档唯一标识（自动生成或指定）
_source  — 文档原始内容（业务数据）

三、倒排索引

3.1 正排索引 vs 倒排索引

正排索引（传统数据库）：
  Doc 1 → "华为 Mate 60 Pro"
  Doc 2 → "华为 Mate Pad"
  Doc 3 → "苹果 iPhone 15"

  查询 "华为" → 扫描每一条记录 → 慢

倒排索引（ES）：
  "华为" → [Doc 1, Doc 2]
  "mate" → [Doc 1, Doc 2]
  "60"   → [Doc 1]
  "pro"  → [Doc 1]
  "苹果" → [Doc 3]
  "iphone" → [Doc 3]
  "15"   → [Doc 3]

  查询 "华为" → 直接查倒排索引 → [Doc 1, Doc 2] → 快

3.2 倒排索引的构建过程

原文：  "华为 Mate 60 Pro"

1. 分词（Tokenization）
   → ["华为", "mate", "60", "pro"]

2. 归一化（Normalization）
   → 小写、去停用词、词干提取等
   → ["华为", "mate", "60", "pro"]

3. 建立倒排表
   Token    → Doc IDs
   "华为"   → [1]
   "mate"   → [1]
   "60"     → [1]
   "pro"    → [1]

3.3 为什么 ES 快

1. 倒排索引     — 直接定位文档，不需要全表扫描
2. 分片并行     — 查询分发到多个分片并行执行
3. 缓存         — 查询结果缓存、文件系统缓存
4. 列式存储     — Doc Values 支持高效的聚合和排序

四、安装和连接

4.1 Docker 安装（开发环境）

# 创建网络
docker network create elastic

# 启动 ES（单节点）
docker run -d \
  --name elasticsearch \
  --net elastic \
  -p 9200:9200 \
  -e "discovery.type=single-node" \
  -e "xpack.security.enabled=false" \
  -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
  docker.elastic.co/elasticsearch/elasticsearch:8.15.0

# 启动 Kibana
docker run -d \
  --name kibana \
  --net elastic \
  -p 5601:5601 \
  -e "ELASTICSEARCH_HOSTS=http://elasticsearch:9200" \
  docker.elastic.co/kibana/kibana:8.15.0

1
2
3

ES API：      http://localhost:9200
Kibana UI：   http://localhost:5601
Dev Tools：   http://localhost:5601/app/dev_tools

4.2 验证连接

# curl 方式
curl http://localhost:9200

# Kibana Dev Tools
GET /

{
  "name": "elasticsearch",
  "version": {
    "number": "8.15.0"
  }
}

五、索引管理

5.1 创建索引

// 显式创建索引 + Mapping
PUT /products
{
  "settings": {
    "number_of_shards": 1,
    "number_of_replicas": 1
  },
  "mappings": {
    "properties": {
      "name":        { "type": "text", "analyzer": "ik_max_word" },
      "brand":       { "type": "keyword" },
      "price":       { "type": "float" },
      "category":    { "type": "keyword" },
      "in_stock":    { "type": "boolean" },
      "created_at":  { "type": "date", "format": "yyyy-MM-dd" },
      "description": { "type": "text", "analyzer": "ik_max_word" },
      "tags":        { "type": "keyword" }
    }
  }
}

5.2 查看索引

// 查看索引信息
GET /products

// 查看索引 Mapping
GET /products/_mapping

// 查看索引 Settings
GET /products/_settings

// 查看所有索引
GET /_cat/indices?v

5.3 删除索引

`1`	`DELETE /products`

5.4 修改索引设置

// 修改副本数（可以动态修改）
PUT /products/_settings
{
  "index": {
    "number_of_replicas": 2
  }
}

// 注意：分片数（number_of_shards）创建后不能修改

六、Mapping 详解

6.1 字段类型

文本类型：
  text          — 全文搜索，会分词（用于搜索）
  keyword       — 精确匹配，不分词（用于过滤、排序、聚合）

数值类型：
  integer, long, float, double, scaled_float

日期类型：
  date          — 支持多种格式

布尔类型：
  boolean

复杂类型：
  object        — 嵌套对象
  nested        — 嵌套数组（独立查询）
  array         — 数组（ES 没有专门的 array 类型，任何字段都可以是数组）

特殊类型：
  geo_point     — 经纬度
  ip            — IP 地址
  completion    — 自动补全建议
  flattened     — 整个对象作为 keyword

6.2 text vs keyword

// text：分词后建立倒排索引
"name": { "type": "text" }
// "华为 Mate 60" → ["华为", "mate", "60"]
// 搜索 "华为" 可以匹配

// keyword：不分词，整体建立索引
"brand": { "type": "keyword" }
// "华为 Mate 60" → ["华为 Mate 60"]
// 必须完全匹配 "华为 Mate 60" 才能搜到

// 常见用法：同时支持全文搜索和精确匹配
"title": {
  "type": "text",
  "fields": {
    "keyword": { "type": "keyword" }
  }
}
// title 字段：text 模式用于全文搜索
// title.keyword 子字段：keyword 模式用于精确匹配、排序、聚合

6.3 动态映射

ES 默认启用动态映射：写入文档时，如果字段不存在，自动推断类型

自动推断规则：
  字符串     → text + keyword 子字段
  整数       → long
  浮点数     → float
  布尔值     → boolean
  日期       → date（如果格式匹配）
  对象       → object

问题：
  - 类型推断可能不准确
  - 一旦确定无法修改（只能 reindex）

建议：
  生产环境提前定义 Mapping，关闭动态映射或设为 strict

PUT /products
{
  "mappings": {
    "dynamic": "strict",
    "properties": {
      "name": { "type": "text" }
    }
  }
}
// 写入未定义的字段会报错

6.4 常用 Mapping 设置

PUT /products
{
  "mappings": {
    "properties": {
      "name": {
        "type": "text",
        "analyzer": "ik_max_word",
        "index": true
      },
      "description": {
        "type": "text",
        "analyzer": "ik_max_word",
        "index": true
      },
      "price": {
        "type": "scaled_float",
        "scaling_factor": 100
      },
      "is_active": {
        "type": "boolean"
      },
      "created_at": {
        "type": "date",
        "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
      },
      "metadata": {
        "type": "flattened"
      }
    }
  }
}

index: true/false    — 是否索引（false 则不能搜索但可以存储）
analyzer             — 分词器
format               — 日期格式（|| 分隔多种格式）
scaling_factor       — 浮点数缩放因子（scaled_float 存为 long，避免精度问题）

七、索引模板

7.1 创建模板

// 匹配 logs-* 的索引自动应用此模板
PUT /_index_template/logs_template
{
  "index_patterns": ["logs-*"],
  "priority": 100,
  "template": {
    "settings": {
      "number_of_shards": 3,
      "number_of_replicas": 1,
      "index.lifecycle.name": "logs-policy"
    },
    "mappings": {
      "properties": {
        "timestamp":  { "type": "date" },
        "level":      { "type": "keyword" },
        "service":    { "type": "keyword" },
        "message":    { "type": "text", "analyzer": "ik_max_word" },
        "trace_id":   { "type": "keyword" },
        "host":       { "type": "keyword" }
      }
    }
  }
}

7.2 组件模板

// 可复用的设置组件
PUT /_component_template/common_settings
{
  "template": {
    "settings": {
      "number_of_replicas": 1,
      "refresh_interval": "5s"
    }
  }
}

// 在索引模板中引用
PUT /_index_template/app_template
{
  "index_patterns": ["app-*"],
  "composed_of": ["common_settings"],
  "template": {
    "mappings": {
      "properties": {
        "name": { "type": "text" }
      }
    }
  }
}

八、索引别名

// 创建别名
POST /_aliases
{
  "actions": [
    {
      "add": {
        "index": "products-v1",
        "alias": "products"
      }
    }
  ]
}

// 通过别名操作（应用层不需要知道实际索引名）
GET /products/_search
{ "query": { "match_all": {} } }

// 无缝切换索引（零停机）
POST /_aliases
{
  "actions": [
    { "remove": { "index": "products-v1", "alias": "products" } },
    { "add":    { "index": "products-v2", "alias": "products" } }
  ]
}

九、_cat API 速查

# 集群健康
GET /_cat/health?v

# 节点信息
GET /_cat/nodes?v

# 索引列表
GET /_cat/indices?v

# 分片状态
GET /_cat/shards?v

# 别名
GET /_cat/aliases?v

# 已分配的分片
GET /_cat/allocation?v

# 恢复进度
GET /_cat/recovery?v

# 所有 ?v 参数表示显示列名
# ?format=json 输出 JSON 格式
# ?h=field1,field2 只显示指定列

十、小结

本文学习了 Elasticsearch 的基础：

ES 是什么和应用场景
核心概念（Index、Document、Mapping、Shard、Replica）
倒排索引原理
安装和连接
索引管理（创建、查看、删除、Settings）
Mapping 详解（字段类型、text vs keyword、动态映射）
索引模板和别名
_cat API 速查

下一篇将学习文档 CRUD 和搜索查询：全文搜索、精确搜索和复合查询。