Elasticsearch 全方位教程 – wiki基地

作者： /

This is the complete article on “Elasticsearch 全方位教程” (Comprehensive Elasticsearch Tutorial):

“`markdown
Elasticsearch 全方位教程

引言：拥抱 Elasticsearch 的强大功能

在当今数据爆炸的时代，快速、高效地存储、检索和分析海量数据已成为企业和开发者面临的核心挑战。传统关系型数据库在处理全文本搜索和复杂聚合分析方面往往力不从心。Elasticsearch 应运而生，它作为一个高度可伸缩、分布式、近实时的搜索与分析引擎，为这些挑战提供了强大的解决方案。

本教程旨在提供一个全面的 Elasticsearch 学习路径，无论您是初学者还是希望深化理解的资深用户，都能从中获益。我们将从基础概念讲起，逐步深入到数据建模、高级查询、聚合分析、集群管理以及与其他工具的集成，最终助您掌握 Elasticsearch 的精髓。

一、Elasticsearch 简介

A. 什么是 Elasticsearch？

Elasticsearch 是一个基于 Apache Lucene 的开源、分布式、RESTful 风格的搜索和分析引擎。它以其卓越的速度、可伸缩性和强大的全文本搜索能力而闻名。其核心优势在于：

  • 分布式与高可用： 可以在多个节点上分布数据和查询，实现水平扩展和故障恢复。
  • 近实时： 索引数据后，几乎可以立即进行搜索。
  • RESTful API： 通过简单的 HTTP 请求进行交互，易于开发和集成。
  • 强大的搜索能力： 提供丰富的查询 DSL (Domain Specific Language) 支持复杂的全文本搜索、结构化搜索和地理空间搜索。
  • 分析能力： 内置强大的聚合框架，可以对数据进行复杂的统计、分组和指标计算。

B. Elasticsearch 的主要应用场景

Elasticsearch 的灵活性使其适用于多种场景，包括但不限于：

  • 应用内搜索： 为网站、电商平台或移动应用提供快速、相关的搜索结果。
  • 网站搜索： 驱动企业内部或外部网站的内容搜索功能。
  • 日志和指标分析 (ELK Stack 核心)： 配合 Logstash 收集、处理日志，Kibana 进行可视化，形成强大的日志管理和监控解决方案。
  • 业务智能 (BI)： 对业务数据进行实时分析和洞察。
  • 安全信息和事件管理 (SIEM)： 实时监控安全事件，检测异常行为。
  • 地理空间数据搜索： 存储和查询地理位置信息。

C. 核心概念

理解以下核心概念是掌握 Elasticsearch 的基石：

  • 文档 (Document)： Elasticsearch 中可搜索的最小单位。它是一个 JSON 格式的数据结构，可以包含任意复杂的数据。每个文档都有一个唯一的 ID。
    • 类比： 关系型数据库中的一行记录。
  • 索引 (Index)： 具有相似特征的文档集合。一个索引定义了其中文档的共同结构（通过映射）。
    • 类比： 关系型数据库中的一个数据库。
  • 类型 (Type)： （在 Elasticsearch 7.x 及更高版本中已弃用并移除） 在早期版本中，类型是索引内部的一个逻辑分区，用于存储结构略有不同的文档。现在推荐每个索引只包含一种类型。
    • 类比： 关系型数据库中的一张表。
  • 分片 (Shard)： 一个索引被分成多个分片，每个分片都是一个独立的 Lucene 索引。分片是 Elasticsearch 实现分布式存储和水平扩展的最小单位。
    • 主分片 (Primary Shard)： 负责存储原始数据。
    • 副本分片 (Replica Shard)： 主分片的精确副本，用于提高查询性能和提供高可用性。
  • 节点 (Node)： 运行着一个 Elasticsearch 实例的服务器。一个集群可以由一个或多个节点组成。节点有不同的角色，如数据节点、主节点、协调节点等。
  • 集群 (Cluster)： 由一个或多个节点组成的集合，它们共同存储您的数据并提供索引和搜索能力。集群通过一个唯一的名称来标识。
  • 映射 (Mapping)： 定义了索引中文档及其字段的数据类型、如何被索引以及如何被存储的规则。它类似于关系型数据库中的表结构定义（Schema）。
  • 倒排索引 (Inverted Index)： 这是 Elasticsearch 实现快速全文本搜索的底层机制。它将每个词映射到包含该词的文档列表，而不是将文档映射到其包含的词。

二、部署 Elasticsearch

要开始使用 Elasticsearch，您首先需要将其安装并运行起来。本节将指导您完成基本的安装、配置以及如何与 Elasticsearch 进行交互。

A. 安装

Elasticsearch 提供了多种安装方式，您可以根据自己的操作系统和偏好选择最合适的方式。

  1. 直接下载安装包：
    访问 Elastic 官方网站 下载适用于您操作系统的最新版压缩包（ZIP 或 TAR.GZ）。解压后即可使用。

  2. 使用包管理器安装：
    对于 Linux 系统，可以使用 apt 或 yum 等包管理器进行安装。

    • Debian/Ubuntu:
      bash
      wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -
      sudo apt-get install apt-transport-https
      echo "deb https://artifacts.elastic.co/packages/8.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-8.x.list
      sudo apt-get update && sudo apt-get install elasticsearch
    • CentOS/RHEL:
      bash
      sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
      cat <<EOF | sudo tee /etc/yum.repos.d/elasticsearch.repo
      [elasticsearch-8.x]
      name=Elasticsearch repository for 8.x packages
      baseurl=https://artifacts.elastic.co/packages/8.x/yum
      gpgcheck=1
      gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
      enabled=1
      autorefresh=1
      type=rpm-md
      EOF
      sudo yum install elasticsearch

  3. 使用 Docker：
    Docker 是最推荐的部署方式之一，尤其是对于开发和测试环境。
    bash
    docker pull docker.elastic.co/elasticsearch/elasticsearch:8.x.x
    docker run -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" docker.elastic.co/elasticsearch/elasticsearch:8.x.x

    • -p 9200:9200: 将容器的 9200 端口（HTTP API 端口）映射到主机的 9200 端口。
    • -p 9300:9300: 将容器的 9300 端口（节点间通信端口）映射到主机的 9300 端口。
    • -e "discovery.type=single-node": 告诉 Elasticsearch 以单节点模式运行，这适用于开发和测试，生产环境需要更复杂的配置。

B. 运行 Elasticsearch

  1. 启动 Elasticsearch：

    • 对于直接安装：
      进入 Elasticsearch 的安装目录，然后运行：
      “`bash
      # Linux/macOS
      ./bin/elasticsearch

      Windows

      .\bin\elasticsearch.bat
      * **对于包管理器安装：**bash
      sudo systemctl start elasticsearch
      sudo systemctl enable elasticsearch # 设置开机自启动
      ``
      * **对于 Docker：**
      上一步的      docker run` 命令已经启动了容器。

  2. 检查集群健康：
    Elasticsearch 启动后，您可以通过访问其 REST API 来检查其健康状态。在浏览器中访问 http://localhost:9200 或使用 curl 命令：
    bash
    curl http://localhost:9200
    您应该会看到类似以下的 JSON 响应，其中包含有关集群、版本和节点的信息：
    json
    {
    "name" : "your-node-name",
    "cluster_name" : "elasticsearch",
    "cluster_uuid" : "...",
    "version" : {
    "number" : "8.x.x",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "...",
    "build_date" : "...",
    "build_snapshot" : false,
    "lucene_version" : "...",
    "minimum_wire_compatibility_version" : "...",
    "minimum_index_compatibility_version" : "..."
    },
    "tagline" : "You Know, for Search"
    }
    要检查更详细的健康状态，可以使用 _cluster/health API：
    bash
    curl http://localhost:9200/_cluster/health?pretty
    status 字段会显示集群的健康状况：green (一切正常), yellow (所有主分片可用，但部分副本分片不可用), red (部分主分片不可用，数据丢失风险)。

C. 与 Elasticsearch 交互

与 Elasticsearch 交互主要通过其 RESTful API。您可以使用多种工具来发送 HTTP 请求：

  1. cURL (命令行工具)：
    是最直接、最通用的方式。例如，创建一个索引：
    bash
    curl -X PUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d'
    {
    "settings": {
    "number_of_shards": 1,
    "number_of_replicas": 1
    },
    "mappings": {
    "properties": {
    "title": { "type": "text" },
    "author": { "type": "keyword" },
    "pages": { "type": "integer" }
    }
    }
    }
    '

  2. Kibana Dev Tools Console：
    Kibana 是 Elastic Stack 的一个组件，提供了一个强大的 Web 界面来管理和查询 Elasticsearch。其中的 “Dev Tools” 控制台是编写和执行 Elasticsearch API 请求的绝佳工具。

    • 如果您尚未安装 Kibana，可以参考官方文档进行安装，通常与 Elasticsearch 版本对应。
    • 启动 Kibana 后，访问 http://localhost:5601 (默认端口)，然后在左侧导航栏中找到 “Management” -> “Dev Tools”。

  3. 编程语言客户端：
    Elasticsearch 提供了多种官方和社区维护的客户端库，支持 Java、Python、JavaScript、Go 等主流编程语言，方便在应用程序中集成。

三、索引数据

将数据存储到 Elasticsearch 中称为“索引数据”。本节将详细介绍如何创建索引、执行文档操作以及管理映射。

A. 创建索引

在向 Elasticsearch 存储文档之前，通常需要创建一个或多个索引。索引可以显式创建，也可以在第一次索引文档时由 Elasticsearch 自动创建（动态创建）。建议显式创建索引，并定义好其设置和映射，以更好地控制数据存储方式。

1. 显式创建索引

使用 PUT 请求向 /index_name 端点发送请求来创建索引，并在请求体中指定 settings 和 mappings。

bash
PUT /books_index?pretty
{
"settings": {
"number_of_shards": 3, // 主分片的数量
"number_of_replicas": 1 // 每个主分片对应的副本分片数量
},
"mappings": {
"properties": { // 定义文档字段的映射
"title": { "type": "text" }, // 全文搜索字段
"author": { "type": "keyword" }, // 精确值字段
"publish_date": { "type": "date", "format": "yyyy-MM-dd" }, // 日期字段
"pages": { "type": "integer" }, // 整数字段
"description": { "type": "text" }
}
}
}
* number_of_shards：主分片的数量。一旦创建，不能更改。
* number_of_replicas：每个主分片的副本分片数量。可以在索引创建后更改。
* mappings：定义了索引中每个字段的数据类型以及如何处理这些字段。

2. 动态索引创建

如果您在索引文档时指定了一个尚不存在的索引名称，Elasticsearch 会自动创建该索引，并尝试根据文档内容推断字段类型（动态映射）。虽然这很方便，但可能无法满足所有场景的需求，因此在生产环境中推荐显式创建索引。

B. 文档操作

文档是 Elasticsearch 中的基本信息单元。以下是常见的文档操作：

1. 索引文档（添加/更新）

您可以通过 POST 或 PUT 请求将文档索引到 Elasticsearch 中。

  • 自动生成 ID (POST):
    当您使用 POST 请求向 /{index_name}/_doc 发送数据时，Elasticsearch 会自动为您的文档生成一个唯一的 ID。
    bash
    POST /books_index/_doc?pretty
    {
    "title": "深入理解 Elasticsearch",
    "author": "张三",
    "publish_date": "2023-01-15",
    "pages": 500,
    "description": "一本关于Elasticsearch原理和实践的书籍。"
    }
    响应会包含文档的 _index (索引名), _id (文档ID), _version (版本号), result (操作结果，如 created)。

  • 指定 ID (PUT):
    当您使用 PUT 请求向 /{index_name}/_doc/{document_id} 发送数据时，您可以自己指定文档的 ID。如果指定 ID 的文档已存在，则会更新该文档；如果不存在，则会创建新文档。
    bash
    PUT /books_index/_doc/1?pretty
    {
    "title": "Elasticsearch 入门与实战",
    "author": "李四",
    "publish_date": "2022-05-20",
    "pages": 350,
    "description": "详细介绍Elasticsearch基础概念和实践案例。"
    }

2. 更新文档（局部更新）

通常，您不需要重新索引整个文档来更改单个字段。Elasticsearch 允许进行局部更新。

bash
POST /books_index/_update/1?pretty
{
"doc": {
"pages": 380,
"rating": 4.5
}
}
此操作会将 ID 为 1 的文档的 pages 字段更新为 380，并添加一个新的 rating 字段。

您也可以使用脚本进行更复杂的更新操作：
bash
POST /books_index/_update/1?pretty
{
"script": {
"source": "ctx._source.pages += params.increment",
"lang": "painless",
"params": {
"increment": 50
}
}
}
这会将文档 ID 为 1 的 pages 字段增加 50。

3. 删除文档

使用 DELETE 请求可以删除指定 ID 的文档：
bash
DELETE /books_index/_doc/1?pretty

4. 批量操作 (Bulk API)

对于大量文档的索引、更新或删除，使用 _bulk API 可以显著提高效率，因为它减少了网络往返次数。

bash
POST _bulk?pretty
{"index": {"_index": "books_index", "_id": "2"}}
{"title": "分布式系统原理", "author": "王五", "publish_date": "2021-11-01", "pages": 600}
{"create": {"_index": "books_index", "_id": "3"}}
{"title": "数据结构与算法", "author": "赵六", "publish_date": "2023-03-10", "pages": 420}
{"update": {"_index": "books_index", "_id": "2"}}
{"doc": {"pages": 620}}
{"delete": {"_index": "books_index", "_id": "3"}}
_bulk 请求体中的每一行都必须以换行符 \n 结束。

C. 映射 (Mappings)

映射定义了索引中文档及其字段的数据类型和如何被索引。它对于确保正确的搜索行为和数据存储至关重要。

1. 理解数据类型

Elasticsearch 支持多种数据类型：

  • text： 用于全文本字段，例如文章内容、产品描述。会被分析器处理，分词后进行倒排索引。
  • keyword： 用于精确值字段，例如标签、ID、用户名。不会被分析，作为单个词条进行索引。适用于聚合和过滤。
  • 数值 (long, integer, short, byte, double, float)： 用于数字。
  • date： 用于日期和时间。Elasticsearch 可以解析多种日期格式。
  • boolean： 布尔值 (true/false)。
  • geo_point： 经纬度坐标，用于地理空间搜索。
  • object： 用于存储 JSON 对象。
  • nested： 一种特殊的 object 类型，用于处理独立的对象数组，确保数组中的每个对象都可以被独立查询。

2. 动态映射 vs. 显式映射

  • 动态映射 (Dynamic Mapping)：
    当您索引一个新文档，并且其中包含 Elasticsearch 尚未见过的字段时，Elasticsearch 会根据字段值的类型自动推断其映射。例如，如果字段值是数字，它可能被映射为 long。

    • 优点： 方便快捷，无需预先定义所有字段。
    • 缺点： 自动推断可能不总是符合预期，例如，可能将您希望作为 keyword 的字段推断为 text，或者日期格式推断错误。

  • 显式映射 (Explicit Mapping)：
    通过 PUT /index_name 或 PUT /index_name/_mapping 手动定义字段的映射。这提供了对数据如何存储和索引的精确控制。
    bash
    PUT /my_explicit_index
    {
    "mappings": {
    "properties": {
    "email": {
    "type": "keyword"
    },
    "bio": {
    "type": "text",
    "analyzer": "ik_smart" // 使用自定义分词器
    },
    "join_date": {
    "type": "date",
    "format": "yyyy/MM/dd HH:mm:ss||yyyy/MM/dd"
    }
    }
    }
    }

3. 自定义分析器 (Analyzers)

text 字段在索引时会经过“分析”过程，包括字符过滤、分词和词元过滤。您可以自定义分析器来更好地适应特定语言或需求。

一个分析器由三部分组成：
* 字符过滤器 (Character Filters)： 在文本分词前，对原始文本进行处理，例如去除 HTML 标签、替换特殊字符。
* 分词器 (Tokenizer)： 将文本分解成单个词条（tokens）。例如，标准分词器会根据空格和标点符号分词。
* 词元过滤器 (Token Filters)： 对分词器输出的词条进行处理，例如转换为小写、去除停用词、添加同义词、词干提取。

例如，创建一个自定义分析器：
bash
PUT /my_custom_analyzer_index
{
"settings": {
"analysis": {
"analyzer": {
"my_custom_analyzer": {
"type": "custom",
"tokenizer": "standard",
"char_filter": ["html_strip"],
"filter": ["lowercase", "stop", "english_stemmer"]
}
}
}
},
"mappings": {
"properties": {
"content": {
"type": "text",
"analyzer": "my_custom_analyzer"
}
}
}
}

4. 多字段 (Multi-fields)

多字段允许您以不同的方式索引同一个字段。例如，一个字段可以同时被索引为 text 用于全文本搜索，以及 keyword 用于聚合和精确匹配。
bash
PUT /products
{
"mappings": {
"properties": {
"product_name": {
"type": "text",
"fields": {
"keyword": {
"type": "keyword",
"ignore_above": 256 // 超过256字符不索引为keyword
}
}
}
}
}
}
这样，您可以对 product_name 字段进行模糊搜索，也可以对 product_name.keyword 进行精确匹配和聚合。

四、搜索数据

Elasticsearch 的核心功能是搜索。本节将深入探讨如何在 Elasticsearch 中进行数据检索，包括基础搜索、强大的 Query DSL 以及高级搜索功能，并区分过滤和查询的概念。

A. 基础搜索

Elasticsearch 提供了多种方式来执行搜索请求。

1. URI 搜索 (URI Search)

最简单的搜索方式是通过 URI 参数进行查询。这适用于快速测试或简单查询。
bash
GET /books_index/_search?q=title:Elasticsearch&pretty
这将搜索 books_index 索引中 title 字段包含 “Elasticsearch” 的文档。
* q=field:value：指定字段和搜索值。
* q=value：搜索所有字段中包含 value 的文档。
* &pretty：格式化 JSON 响应使其更具可读性。

2. 请求体搜索 (Request Body Search)

更强大、更灵活的搜索方式是使用请求体（Request Body）中的 Query DSL (Domain Specific Language)。这是进行复杂搜索、排序、分页和聚合的标准方法。
bash
GET /books_index/_search?pretty
{
"query": {
"match": {
"title": "Elasticsearch"
}
}
}
所有后续的搜索示例都将使用请求体搜索。

B. Query DSL 基础

Query DSL 是 Elasticsearch 中用于构建复杂查询的 JSON 格式的查询语言。它允许您组合不同的查询类型以实现精确的搜索逻辑。

1. match 查询：全文本搜索

match 查询用于对 text 类型的字段进行全文本搜索。它会分析查询字符串，然后根据结果进行匹配。
bash
GET /books_index/_search?pretty
{
"query": {
"match": {
"description": "Elasticsearch 原理"
}
}
}
这会搜索 description 字段中包含 “Elasticsearch” 或 “原理” 或两者都包含的文档。

2. term 查询：精确匹配

term 查询用于查找精确匹配的值。它不会分析查询字符串，因此适用于 keyword、numeric 或 date 类型的字段。
bash
GET /books_index/_search?pretty
{
"query": {
"term": {
"author.keyword": "张三"
}
}
}
注意：通常对 keyword 类型的字段使用 term 查询，或者 text 字段的 keyword 子字段。

3. range 查询：范围过滤

range 查询用于查找某个字段值在指定范围内的文档。适用于数字和日期字段。
bash
GET /books_index/_search?pretty
{
"query": {
"range": {
"publish_date": {
"gte": "2022-01-01", // 大于等于
"lt": "2023-01-01" // 小于
}
}
}
}
* gt: 大于
* gte: 大于等于
* lt: 小于
* lte: 小于等于

4. exists 查询：检查字段是否存在

exists 查询用于查找包含特定字段的文档（字段值不为 null）。
bash
GET /books_index/_search?pretty
{
"query": {
"exists": {
"field": "rating"
}
}
}

5. bool 查询：组合多个查询

bool 查询是 Query DSL 中最重要的查询之一，它允许您组合多个查询条件，并指定它们之间的逻辑关系（与、或、非）。

  • must：文档必须匹配这些查询，并且会影响文档的得分。相当于 AND。
  • filter：文档必须匹配这些查询，但不会影响文档的得分。通常用于过滤结果，且可缓存。相当于 AND。
  • should：文档应该匹配这些查询中的一个或多个。对得分有影响。相当于 OR。
  • must_not：文档不能匹配这些查询。不会影响得分。相当于 NOT。

bash
GET /books_index/_search?pretty
{
"query": {
"bool": {
"must": [
{ "match": { "title": "Elasticsearch" } }
],
"filter": [
{ "term": { "author.keyword": "张三" } },
{ "range": { "pages": { "gte": 400 } } }
],
"should": [
{ "match": { "description": "入门" } }
],
"must_not": [
{ "term": { "publish_date": "2021-11-01" } }
]
}
}
}

6. constant_score 查询：固定得分

constant_score 查询包装一个过滤器（filter），并为所有匹配的文档分配一个相同的分数，而不考虑文档与过滤器的匹配程度。这在您只关心文档是否匹配，而不关心其相关性得分时非常有用。
bash
GET /books_index/_search?pretty
{
"query": {
"constant_score": {
"filter": {
"term": {
"author.keyword": "李四"
}
},
"boost": 1.2
}
}
}

C. 高级搜索功能

Elasticsearch 提供了丰富的高级搜索功能，以满足更复杂的搜索需求。

1. 词语搜索 (Phrase Search)

使用 match_phrase 查询来搜索一个精确的短语，而不是独立的词语。
bash
GET /books_index/_search?pretty
{
"query": {
"match_phrase": {
"description": "原理与实践"
}
}
}

2. 前缀、通配符、正则表达式查询 (Prefix, Wildcard, Regexp Queries)

  • prefix 查询： 匹配字段以指定前缀开头的文档。
    bash
    GET /books_index/_search?pretty
    {
    "query": {
    "prefix": {
    "author.keyword": "张"
    }
    }
    }
  • wildcard 查询： 使用通配符 (* 匹配零个或多个字符, ? 匹配单个字符)。性能开销较大，应谨慎使用。
    bash
    GET /books_index/_search?pretty
    {
    "query": {
    "wildcard": {
    "title": "*Elast*"
    }
    }
    }
  • regexp 查询： 使用正则表达式进行匹配。性能开销最大，仅在必要时使用。
    bash
    GET /books_index/_search?pretty
    {
    "query": {
    "regexp": {
    "title": ".*search$"
    }
    }
    }

3. 模糊搜索 (Fuzzy Search)

fuzzy 查询用于处理拼写错误或近似匹配。它通过莱文斯坦距离 (Levenshtein distance) 来计算词语之间的相似度。
bash
GET /books_index/_search?pretty
{
"query": {
"match": {
"title": {
"query": "Elastisearch", // 故意拼错
"fuzziness": "AUTO"
}
}
}
}
fuzziness 参数可以设置为 AUTO 或具体的数字。

4. 更多相似查询 (More Like This Query)

more_like_this 查询允许您根据一个或多个文档的内容，查找与之相似的其他文档。这在推荐系统或查找相关内容时非常有用。
bash
GET /books_index/_search?pretty
{
"query": {
"more_like_this": {
"fields": ["title", "description"],
"like": [
{
"_index": "books_index",
"_id": "1"
},
"Elasticsearch 的进阶用法" // 也可以直接提供文本
],
"min_term_freq": 1,
"max_query_terms": 12
}
}
}

5. 复合查询 (Compound Queries)

通过组合 bool 查询和各种其他查询，您可以构建任意复杂的搜索逻辑。

D. 过滤 (Filtering) 与 查询 (Querying)

理解过滤和查询的区别至关重要，因为它直接影响性能和相关性。

  • 查询 (Query)：

    • 作用： 决定文档是否匹配查询条件，并计算文档的相关性得分 (_score)。
    • 场景： 适用于需要根据相关性排序的搜索，如全文本搜索。
    • 性能： 查询结果不会被缓存。
    • 示例： match 查询。

  • 过滤 (Filter)：

    • 作用： 决定文档是否匹配条件，但 不计算相关性得分。
    • 场景： 适用于只需要精确匹配而不需要排序的场景，如根据价格范围、日期范围、分类进行筛选。
    • 性能： 过滤结果可以被缓存，显著提高重复查询的性能。
    • 示例： term、range、exists 查询，以及 bool 查询中的 filter 子句。

最佳实践： 尽可能使用 filter 上下文来缩小搜索范围，然后使用 query 上下文对剩余文档进行相关性排序。

bash
GET /books_index/_search?pretty
{
"query": {
"bool": {
"filter": [
{ "term": { "author.keyword": "张三" } },
{ "range": { "publish_date": { "gte": "2023-01-01" } } }
],
"must": [
{ "match": { "description": "原理" } }
]
}
}
}
这个例子中，首先会快速过滤出作者是“张三”且出版日期在 2023 年之后的文档，然后只对这些文档计算 description 字段中包含“原理”的相关性得分。

E. 相关性与得分

Elasticsearch 默认根据文档与查询的相关性来对搜索结果进行排序。相关性得分 (_score) 是一个浮点数，表示文档与查询的匹配程度。

  • TF/IDF (Term Frequency-Inverse Document Frequency)：
    Elasticsearch 早期版本和 Lucene 的经典算法，用于衡量一个词在文档中的重要性。

    • 词频 (Term Frequency, TF)： 词在文档中出现的次数越多，越相关。
    • 逆文档频率 (Inverse Document Frequency, IDF)： 词在所有文档中出现的次数越少（越独特），越相关。

  • BM25 (Okapi BM25)：
    Elasticsearch 8.x 默认使用的相关性算法。它是 TF/IDF 的改进版本，在处理文档长度和词频饱和度方面有更好的表现。

  • 提升查询和字段 (Boosting queries and fields)：
    您可以通过 boost 参数手动调整特定查询或字段的重要性，以影响文档的得分。
    bash
    GET /books_index/_search?pretty
    {
    "query": {
    "bool": {
    "should": [
    { "match": { "title": { "query": "Elasticsearch", "boost": 2 } } },
    { "match": { "description": "教程" } }
    ]
    }
    }
    }
    这里，匹配 title 字段的文档比匹配 description 字段的文档得分更高。

  • 自定义得分 (function_score query)：
    function_score 查询允许您通过各种函数（如 field_value_factor、random_score、weight 等）和脚本来完全控制文档的得分计算，从而实现非常灵活的相关性模型。

五、聚合 (Aggregations) – 数据分析的利器

除了强大的搜索功能，Elasticsearch 另一个杀手级特性是其聚合框架。聚合允许您对查询结果进行分组、计算、统计等操作，从而从海量数据中提取有价值的分析结果和业务洞察。这在商业智能、日志分析和度量指标监控等场景中至关重要。

A. 聚合简介

1. 什么是聚合？
聚合是 Elasticsearch 提供的一种机制，用于对搜索返回的数据进行汇总和分析。它可以回答诸如“最畅销的产品是什么？”、“过去一周的平均销售额是多少？”、“哪些用户群体最活跃？”等问题。

2. 聚合类型
Elasticsearch 的聚合框架非常丰富，主要分为以下几类：

  • 指标聚合 (Metric Aggregations)： 计算字段的统计信息，如最大值、最小值、平均值、求和等。
  • 桶聚合 (Bucket Aggregations)： 将文档分组到不同的“桶”中，每个桶代表一个分类或范围。例如，按国家、按年龄段分组。
  • 管道聚合 (Pipeline Aggregations)： 对其他聚合的结果进行再次聚合。例如，计算不同桶之间指标的差值、移动平均值等。

B. 指标聚合 (Metric Aggregations)

指标聚合用于计算字段的统计信息。

1. 基本统计聚合：sum, avg, min, max, count
这些聚合分别计算字段的总和、平均值、最小值、最大值和文档计数。
bash
GET /products/_search?pretty
{
"size": 0, // 不返回搜索结果，只返回聚合结果
"aggs": {
"total_sales": {
"sum": {
"field": "price"
}
},
"average_price": {
"avg": {
"field": "price"
}
},
"max_price": {
"max": {
"field": "price"
}
},
"min_price": {
"min": {
"field": "price"
}
}
}
}

2. cardinality (基数) – 统计去重数量
计算字段的唯一值数量，近似值，适用于大数据集以节省内存。
bash
GET /orders/_search?pretty
{
"size": 0,
"aggs": {
"unique_customer_count": {
"cardinality": {
"field": "customer_id"
}
}
}
}

3. stats 和 extended_stats – 综合统计
stats 提供 min, max, avg, sum, count 等基本统计。
extended_stats 在 stats 的基础上增加了 sum_of_squares, variance, std_deviation 等更高级的统计指标。
bash
GET /logs/_search?pretty
{
"size": 0,
"aggs": {
"response_time_stats": {
"extended_stats": {
"field": "response_time_ms"
}
}
}
}

C. 桶聚合 (Bucket Aggregations)

桶聚合用于将文档分组到多个“桶”中，每个桶代表一组符合特定条件的文档。

1. terms – 按字段值分组
最常用的桶聚合，根据字段的唯一值创建桶，并返回每个桶中的文档数量。
bash
GET /products/_search?pretty
{
"size": 0,
"aggs": {
"products_by_category": {
"terms": {
"field": "category.keyword", // 必须是keyword类型字段
"size": 10 // 返回前10个分类
},
"aggs": {
"avg_price_per_category": { // 可以嵌套聚合
"avg": {
"field": "price"
}
}
}
}
}
}
这个查询会按产品类别分组，并计算每个类别的平均价格。

2. range – 自定义范围分组
根据数值范围将文档分组。
bash
GET /products/_search?pretty
{
"size": 0,
"aggs": {
"price_ranges": {
"range": {
"field": "price",
"ranges": [
{ "to": 50 },
{ "from": 50, "to": 100 },
{ "from": 100 }
]
}
}
}
}

3. date_range – 日期范围分组
根据日期范围将文档分组。
bash
GET /logs/_search?pretty
{
"size": 0,
"aggs": {
"access_by_date_range": {
"date_range": {
"field": "timestamp",
"format": "yyyy-MM-dd",
"ranges": [
{ "to": "now-7d/d" }, // 过去7天
{ "from": "now-7d/d", "to": "now/d" } // 最近7天
]
}
}
}
}

4. histogram 和 date_histogram – 间隔分组
* histogram： 按数值间隔（如每 10 个单位）将文档分组。
bash
GET /products/_search?pretty
{
"size": 0,
"aggs": {
"price_histogram": {
"histogram": {
"field": "price",
"interval": 20 // 每20元一个桶
}
}
}
}
* date_histogram： 按日期或时间间隔（如每天、每月）将文档分组。常用于时间序列数据分析。
bash
GET /logs/_search?pretty
{
"size": 0,
"aggs": {
"logs_per_day": {
"date_histogram": {
"field": "timestamp",
"fixed_interval": "1d",
"format": "yyyy-MM-dd"
}
}
}
}

5. geohash_grid 和 geo_distance – 地理空间分组
* geohash_grid： 将地理位置数据聚合到网格中，适用于热力图或区域分析。
* geo_distance： 根据与某个地理位置的距离将文档分组。

D. 管道聚合 (Pipeline Aggregations)

管道聚合是在其他聚合结果之上运行的聚合。它们不直接操作文档，而是操作现有聚合的输出。

1. sum_bucket, avg_bucket 等 – 对桶指标求和/求平均
计算所有桶中某个指标的总和或平均值。
bash
GET /orders/_search?pretty
{
"size": 0,
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "order_date",
"fixed_interval": "30d",
"format": "yyyy-MM-dd"
},
"aggs": {
"monthly_revenue": {
"sum": {
"field": "total_amount"
}
}
}
},
"total_monthly_revenue": {
"sum_bucket": {
"buckets_path": "sales_per_month>monthly_revenue"
}
}
}
}

2. derivative – 计算时间序列的导数
计算相邻桶之间指标的变化率。
bash
GET /metrics/_search?pretty
{
"size": 0,
"aggs": {
"requests_per_hour": {
"date_histogram": {
"field": "timestamp",
"fixed_interval": "1h"
},
"aggs": {
"total_requests": {
"sum": {
"field": "request_count"
}
},
"requests_rate": {
"derivative": {
"buckets_path": "total_requests"
}
}
}
}
}
}

3. moving_avg – 移动平均
计算时间序列数据的移动平均值，用于平滑数据趋势。

E. 结合查询与聚合

您可以将查询 (Query) 和聚合 (Aggregations) 结合使用。查询用于过滤掉不相关的文档，然后聚合只对这些符合条件的文档进行分析。

bash
GET /products/_search?pretty
{
"size": 0,
"query": {
"match": {
"description": "电子产品"
}
},
"aggs": {
"price_ranges_for_electronics": {
"range": {
"field": "price",
"ranges": [
{ "to": 500 },
{ "from": 500, "to": 1000 },
{ "from": 1000 }
]
}
}
}
}
这个例子会先筛选出描述中包含“电子产品”的商品，然后对这些商品的价格进行范围聚合。

六、管理您的集群

有效管理 Elasticsearch 集群对于确保其稳定性、性能和数据安全至关重要。本节将涵盖集群健康监控、索引管理、节点角色、分片分配以及快照与恢复等关键管理任务。

A. 集群健康和监控

了解集群的运行状况是日常管理的首要任务。

1. _cluster/health API
这是最常用的 API，用于获取集群的总体健康状态。
bash
GET /_cluster/health?pretty
* status：
* green：所有主分片和副本分片都已分配。集群处于完全正常状态。
* yellow：所有主分片都已分配，但至少有一个副本分片未分配。搜索功能正常，但存在数据冗余风险。
* red：至少有一个主分片未分配。部分数据不可用，集群功能受限。

2. _cat APIs
_cat API 是一组以人类可读格式（而非 JSON）返回信息的接口，非常适合在命令行中快速查看集群状态。
* 查看所有索引：
bash
GET /_cat/indices?v
* 查看所有节点：
bash
GET /_cat/nodes?v
* 查看分片分配：
bash
GET /_cat/shards?v
* 查看集群健康概览：
bash
GET /_cat/health?v

3. Kibana Monitoring
Kibana 提供了一个强大的 Web 界面来管理和查询 Elasticsearch。其中的 “Dev Tools” 控制台是编写和执行 Elasticsearch API 请求的绝佳工具。

B. 索引管理

随着数据量的增长和业务需求的变化，索引的管理变得日益复杂。

1. 删除索引
谨慎操作，删除后数据不可恢复。
bash
DELETE /my_index

2. 关闭和打开索引
关闭索引可以释放内存和 CPU 资源，但无法对其进行读写操作。
bash
POST /my_index/_close
POST /my_index/_open

3. Shrink 和 Split API
* Shrink (收缩)： 将一个现有索引收缩成一个新的索引，新索引的分片数量是原索引分片数量的因子。例如，将 8 个分片的索引收缩成 4 个或 2 个分片。这有助于优化小索引的资源使用。
bash
POST /my_large_index/_shrink/my_small_index
* Split (分裂)： 将一个现有索引分裂成一个新的索引，新索引的分片数量是原索引分片数量的倍数。例如，将 4 个分片的索引分裂成 8 个分片。适用于需要增加索引容量的情况。
bash
POST /my_small_index/_split/my_large_index

4. Rollover API (滚动索引)
对于时间序列数据（如日志），当一个索引达到一定大小或时间后，可以使用 Rollover API 自动创建一个新索引，并将写入操作切换到新索引。这有助于保持索引大小适中，提高查询性能。
“`bash

假设有一个名为 logs-000001 的索引，并设置了别名 logs-alias

写入操作都通过 logs-alias 进行

POST /logs-alias/_rollover
{
“conditions”: {
“max_age”: “7d”, // 索引存在超过7天
“max_docs”: 1000000, // 文档数量超过100万
“max_size”: “50gb” // 索引大小超过50GB
}
}
``
当任何一个条件满足时，Elasticsearch 会创建一个新的索引（例如logs-000002），并将logs-alias` 切换指向新索引。

5. Index Lifecycle Management (ILM)
ILM 策略允许您定义索引在不同生命周期阶段（hot, warm, cold, delete）如何管理，例如自动执行 Rollover、Shrink、将数据移动到更便宜的存储、最终删除等。这对于长期数据存储和成本优化非常关键。
您可以在 Kibana 中配置和管理 ILM 策略。

C. 节点角色

Elasticsearch 集群中的节点可以承担不同的角色，以优化资源利用和职责分离。
* master 节点： 负责集群元数据管理，如创建/删除索引、管理节点加入/离开等。不参与文档索引和搜索。
* data 节点： 存储数据和分片，并执行数据相关的操作（索引、搜索、聚合）。
* ingest 节点： 负责文档的预处理（通过 ingest pipelines）。
* coordinating 节点： 接收客户端请求，将请求转发给适当的数据节点，并汇总结果。所有节点都可以充当协调节点。
* machine learning 节点： 运行机器学习作业。

在小型集群中，一个节点可能承担多个角色。在大型集群中，建议将这些角色分离到不同的节点上，以提高稳定性和性能。

D. 分片分配

分片是 Elasticsearch 实现分布式和高可用的基础。理解其分配机制对于故障恢复和负载均衡至关重要。
* 主分片和副本分片： 主分片负责数据的写入，副本分片是主分片的精确拷贝。
* 分配感知 (Allocation Awareness)： 配置 Elasticsearch 知道您的物理拓扑（如机架、区域），以避免将主分片和副本分片分配到同一个故障域，从而提高可用性。
* 分片重平衡： 当节点加入或离开集群时，Elasticsearch 会自动重新平衡分片，以确保数据均匀分布和最佳性能。

E. 快照和恢复 (Snapshots and Restore)

数据备份是任何生产系统不可或缺的一部分。Elasticsearch 提供了快照功能，可以将集群的状态和数据备份到远程仓库。

1. 注册仓库
首先，您需要注册一个快照仓库。可以支持多种存储类型，如共享文件系统、HDFS、Amazon S3、Google Cloud Storage 等。
bash
PUT /_snapshot/my_backup_repo
{
"type": "fs",
"settings": {
"location": "/mnt/backups/es_data", // 文件系统路径，必须在所有主节点上可访问
"compress": true
}
}

2. 创建快照
您可以为整个集群或指定的索引创建快照。
bash
PUT /_snapshot/my_backup_repo/snapshot_1?wait_for_completion=true
wait_for_completion=true 会使请求阻塞，直到快照完成。

3. 恢复数据
当需要恢复数据时，您可以选择恢复整个集群、特定的索引或甚至只恢复集群元数据。
* 恢复指定索引：
bash
POST /_snapshot/my_backup_repo/snapshot_1/_restore
{
"indices": "my_index_1,my_index_2",
"ignore_unavailable": true,
"include_global_state": false
}
* 恢复所有索引：
bash
POST /_snapshot/my_backup_repo/snapshot_1/_restore

七、高级主题

Elasticsearch 提供了许多高级功能和概念，可以帮助您构建更强大、更安全、性能更好的搜索和分析解决方案。

A. 安全 (X-Pack Security)

Elasticsearch 的 X-Pack Security 模块（在 Elastic Stack 中通常捆绑提供）提供了全面的安全功能，确保您的数据得到保护。

  1. 用户和角色： 定义不同用户，并为其分配角色。
  2. 认证 (Authentication)： 支持多种认证方式，如原生用户、LDAP、SAML、Active Directory 等。
  3. 授权 (Authorization)： 基于角色的访问控制 (RBAC)，精确控制用户对索引、文档、字段以及 API 的访问权限。
  4. TLS/SSL 加密： 加密节点间通信和客户端与集群之间的通信，防止数据泄露和窃听。

B. 性能调优

优化 Elasticsearch 集群的性能是一个持续的过程，涉及多个层面。

  1. 硬件考量：

    • CPU： 对高吞吐量的索引和复杂查询至关重要。
    • RAM： 足够的内存对于 Lucene 缓存、操作系统文件系统缓存和 JVM 堆大小都非常重要。
    • Disk (磁盘)： SSD 硬盘通常是必须的，尤其是对于写入密集型或 IO 密集型应用。选择具有高 IOPS 的磁盘。
    • Network (网络)： 高带宽、低延迟的网络对于分布式集群的节点间通信至关重要。

  2. 分片大小和数量：

    • 分片过小： 导致管理开销大，资源浪费。
    • 分片过大： 恢复时间长，单个分片压力大。
    • 最佳实践： 建议每个分片大小在 10GB-50GB 之间。分片数量应与数据节点数量匹配，避免过多或过少。

  3. JVM 设置：

    • Elasticsearch 运行在 Java 虚拟机 (JVM) 上，JVM 堆内存 (-Xms, -Xmx) 的设置至关重要。通常建议将堆内存设置为物理内存的一半，但不超过 30.5GB (JVM 压缩指针限制)。

  4. 缓存：

    • 文件系统缓存： 操作系统会自动缓存 Lucene 段文件，这是最重要的缓存。
    • 请求缓存 (Request Cache)： 缓存聚合和查询结果，对重复的查询很有帮助。

  5. 强制合并 (Force Merging)：
    对于不写入的只读索引，可以执行强制合并，将小段合并成大段，减少文件句柄和提高查询性能。
    bash
    POST /my_read_only_index/_forcemerge?max_num_segments=1

C. Ingest Node 和 Pipelines (摄入节点与管道)

Ingest Node 允许在文档被索引之前对其进行预处理和转换。Ingest Pipeline 是一系列处理器 (Processor) 的集合，按顺序执行。

  1. 处理器 (Processors)：
    • grok：从非结构化日志中解析结构化字段。
    • dissect：基于分隔符将字段分解。
    • date：将日期字符串转换为日期类型。
    • set：设置字段值。
    • remove：删除字段。
    • rename：重命名字段。
    • split：将字符串字段拆分为数组。

示例：创建并使用 Ingest Pipeline
“`bash

1. 创建一个 Ingest Pipeline

PUT /_ingest/pipeline/my_timestamp_pipeline
{
“description”: “Extract timestamp from log_line”,
“processors”: [
{
“grok”: {
“field”: “log_line”,
“patterns”: [“%{TIMESTAMP_ISO8601:timestamp_str}”]
}
},
{
“date”: {
“field”: “timestamp_str”,
“target_field”: “event_timestamp”,
“formats”: [“yyyy-MM-dd’T’HH:mm:ss.SSSZ”]
}
},
{
“remove”: {
“field”: “timestamp_str”
}
}
]
}

2. 索引文档时使用该 Pipeline

PUT /my_logs/_doc/1?pipeline=my_timestamp_pipeline
{
“log_line”: “2024-01-13T10:30:00.123+0800 This is a test log message.”
}
``
这样，原始log_line中的时间戳会被解析并存储到event_timestamp` 字段中。

D. Reindex API (重新索引)

Reindex API 允许您将文档从一个或多个源索引移动到目标索引。这在以下场景中非常有用：
* 改变映射 (Mapping)： 新版本的索引需要新的映射。
* 改变索引设置 (Settings)： 修改分片数量等。
* 版本升级： 在 Elasticsearch 主版本升级时迁移数据。
* 数据清理或转换： 在重新索引过程中对数据进行修改。

bash
POST /_reindex
{
"source": {
"index": "old_index"
},
"dest": {
"index": "new_index"
}
}

E. Cross-Cluster Search (CCS) (跨集群搜索)

CCS 允许您在多个独立的 Elasticsearch 集群上执行搜索请求。这对于在不同地理位置或不同安全域中拥有多个集群的组织非常有用，无需将所有数据都复制到一个集群中。

F. Cross-Cluster Replication (CCR) (跨集群复制)

CCR 允许您将索引从一个集群复制到另一个集群，提供灾难恢复和异地读取功能。一个集群作为“领导者”，另一个集群作为“追随者”，追随者集群会实时复制领导者集群的更改。

G. Machine Learning (机器学习)

Elasticsearch 的 X-Pack Machine Learning 功能提供了一系列开箱即用的机器学习能力，主要用于时间序列数据中的异常检测和预测。
* 异常检测： 自动识别数据中的异常模式，例如突然的流量高峰、系统故障等。
* 预测： 根据历史数据预测未来的趋势。

H. Graph Analytics (图分析)

图分析功能允许您探索 Elasticsearch 索引中的数据关系。通过构建图，您可以可视化和分析实体之间的连接，发现隐藏的模式和洞察。

八、与其他工具集成 (ELK Stack)

Elasticsearch 不仅是一个独立的搜索和分析引擎，更是 Elastic Stack（以前称为 ELK Stack）的核心。Elastic Stack 是一个由 Elasticsearch、Kibana、Logstash 和 Beats 组成的强大工具集，提供端到端的数据摄入、存储、分析和可视化解决方案。

A. Kibana

Kibana 是一个开源的数据可视化和探索工具，专为与 Elasticsearch 协同工作而设计。它提供了一个用户友好的界面，用于查询、分析和可视化 Elasticsearch 中的数据。

  1. 数据探索 (Discover)： 允许您在 Elasticsearch 索引中搜索、过滤和探索数据。
  2. 数据可视化 (Visualize)： 创建各种图表、图形和地图，将复杂的数据以直观的方式呈现。支持的图表类型包括：折线图、柱状图、饼图、热力图、地理地图等。
  3. 仪表板 (Dashboard)： 将多个可视化图表组合成一个交互式仪表板，提供数据的全面视图，方便监控和分析。
  4. 开发工具 (Dev Tools Console)： 一个内置的控制台，允许您直接向 Elasticsearch 发送 REST API 请求，非常适合调试和学习。
  5. 监控 (Monitoring)： 提供了对 Elasticsearch 集群和 Kibana 实例本身的性能和健康状况的实时监控。

B. Logstash

Logstash 是一个开源的服务器端数据处理管道，用于实时摄入、转换和传输数据。它支持从各种来源（文件、数据库、消息队列等）收集数据，通过过滤器进行处理，然后输出到各种目的地，其中最常见的是 Elasticsearch。

Logstash 管道由三个主要阶段组成：

  1. 输入 (Inputs)： 从数据源读取事件。Logstash 提供了丰富的输入插件，如 file (读取文件)、beats (接收 Beats 传输的数据)、jdbc (从数据库读取)、kafka (从 Kafka 消息队列读取) 等。
  2. 过滤器 (Filters)： 在将数据发送到输出之前，对事件进行解析和增强。常见的过滤器包括：
    • grok：从非结构化文本中解析结构化字段（如日志）。
    • mutate：对字段进行修改、重命名、删除等操作。
    • date：解析日期字符串并转换为 Elasticsearch 接受的日期格式。
    • geoip：根据 IP 地址查找地理位置信息。
  3. 输出 (Outputs)： 将处理后的事件发送到目的地。最常用的输出是 elasticsearch，但也支持 file、stdout、kafka 等。

Logstash 配置示例：
input {
file {
path => "/var/log/nginx/access.log"
start_position => "beginning"
}
}
filter {
grok {
match => { "message" => "%{COMBINEDAPACHELOG}" }
}
date {
match => [ "timestamp", "dd/MMM/yyyy:HH:mm:ss Z" ]
}
}
output {
elasticsearch {
hosts => ["http://localhost:9200"]
index => "nginx-access-logs-%{+YYYY.MM.dd}"
}
stdout { codec => rubydebug }
}

C. Beats

Beats 是一组轻量级的、单一用途的数据采集器，用于将不同类型的数据从边缘机器传输到 Logstash 或 Elasticsearch。它们设计得非常轻量，对系统资源占用极小。

主要的 Beats 类型包括：

  • Filebeat： 用于收集日志文件。它可以监控指定路径下的文件，并在新行添加到文件时将其发送到 Logstash 或 Elasticsearch。
  • Metricbeat： 用于收集系统和服务的指标数据，如 CPU 使用率、内存、磁盘 IO、网络流量等。它有各种模块，可以监控操作系统、Docker、Kubernetes、MySQL、Redis 等。
  • Packetbeat： 用于捕获网络流量数据，分析协议（如 HTTP、DNS、MySQL）并将其发送到 Elasticsearch。
  • Winlogbeat： 用于收集 Windows 事件日志。
  • Heartbeat： 用于定期检查服务的可用性（Uptime Monitoring）。

Beats 通常直接将数据发送到 Elasticsearch 或通过 Logstash 进行进一步处理。它们是 Elastic Stack 数据摄入层的最前端，负责高效、可靠地收集各种类型的数据。

九、最佳实践与故障排除

高效地使用 Elasticsearch 需要遵循一些最佳实践，并在遇到问题时能够快速定位和解决。

A. 索引策略

  1. 合理规划分片和副本：

    • 分片数量： 根据数据量和集群节点数合理规划。一个分片是一个 Lucene 实例，过多会增加管理开销，过少可能限制扩展性。通常建议每个分片大小在 10GB-50GB 之间。
    • 副本数量： 至少设置为 1，以保证高可用性。副本越多，读性能越好，但写入开销也越大。
    • 避免超多分片： 单个节点管理的分片数量不宜过多（例如，不应超过几十到几百个，取决于硬件）。

  2. 选择正确的字段数据类型：

    • text vs. keyword： 需要进行全文搜索的用 text，需要精确匹配、聚合、排序的用 keyword。不确定的字段可以同时映射为 text 和 keyword（多字段）。
    • 数值和日期类型： 确保数字和日期字段映射为正确的类型，以便进行范围查询和聚合。

  3. 使用别名 (Aliases)：

    • 将索引操作指向别名而非实际索引名称。当需要重建索引、更改映射或版本升级时，可以平滑地切换别名指向新索引，而无需修改应用程序代码。
    • 示例：PUT /my_index_v1 -> POST /_aliases { actions: [ { add: { index: "my_index_v1", alias: "my_app_index" } } ] }。当创建 my_index_v2 后，只需更新别名指向 my_index_v2。

  4. 利用 ILM (Index Lifecycle Management)：

    • 为时间序列数据（日志、指标）配置 ILM 策略，自动管理索引的生命周期，包括滚动 (Rollover)、收缩 (Shrink)、冻结 (Frozen)、删除等，优化存储成本和性能。

B. 查询优化

  1. 优先使用 filter 上下文进行过滤：

    • filter 上下文不计算相关性得分，结果可缓存，性能优于 query 上下文。
    • 在 bool 查询中，将不影响相关性得分的条件放在 filter 子句中。

  2. 避免在 text 字段上使用 term 查询：

    • term 查询不会分析，如果用于 text 字段，可能会因为分词不匹配而得不到预期结果。应使用 match 或 match_phrase。

  3. 谨慎使用通配符和正则表达式查询：

    • wildcard 和 regexp 查询通常效率较低，因为它们需要扫描倒排索引中大量的词条。尽量避免在字段开头使用通配符。
    • 如果可能，考虑使用 prefix 查询或 NGram 映射。

  4. 控制查询结果大小：

    • size 参数限制返回的文档数量。对于只需要统计而不需要具体文档的请求，将 size 设置为 0。
    • 对于深度分页，应优先使用 search_after 或 Scroll API，而不是 from 和 size 组合。

  5. 优化聚合查询：

    • 使用 keyword 字段进行 terms 聚合。
    • 对不影响聚合结果的查询，使用 post_filter 而非 query。

C. 常见陷阱

  1. JVM OOM (内存溢出)：

    • JVM 堆内存设置不当（过大或过小）。
    • 大批量文档一次性摄入。
    • 不合理的大范围聚合查询。

  2. 分片分配失败：

    • 磁盘空间不足。
    • 集群节点失联。
    • 分片损坏。

  3. 数据丢失或不一致：

    • 没有足够的副本分片或副本分配不当。
    • 在不安全的情况下强制重启节点。

  4. 写入性能下降：

    • 过多的小文件或不必要的刷新操作。
    • 索引速率过快，导致 I/O 饱和。
    • 过多的分析器或复杂的映射导致索引开销大。

D. 故障排除

  1. 检查集群健康：

    • 使用 GET /_cluster/health?pretty 和 GET /_cat/shards?v 快速查看集群和分片状态。

  2. 查看日志：

    • Elasticsearch 的日志文件 (logs/elasticsearch.log) 是故障排除的重要来源。查找 WARN、ERROR 或 DEBUG 级别的消息。

  3. 监控系统资源：

    • 检查 CPU 使用率、内存、磁盘 I/O 和网络流量，找出瓶颈。Kibana Monitoring 或 Prometheus/Grafana 是很好的选择。

  4. 使用 _cluster/stats 和 _nodes/stats：

    • 获取集群和节点的详细统计信息，包括 JVM 使用、文件系统、段信息等。

  5. 分析慢查询：

    • Elasticsearch 日志中会记录慢查询。
    • Kibana 的 Profile API 可以在查询级别进行详细的性能分析。

  6. 强制刷新和合并：

    • 在进行性能测试或解决某些问题时，有时需要手动触发 _refresh 或 _forcemerge 操作。但请注意 _forcemerge 对资源消耗较大。

总结

本教程带您全面了解了 Elasticsearch，从基本概念到高级功能，从数据索引到集群管理，再到与其他 Elastic Stack 工具的集成。掌握 Elasticsearch 及其生态系统，将极大地提升您处理和分析海量数据的能力，为您的应用程序和业务提供强大的搜索和分析支持。持续学习和实践是精通 Elasticsearch 的关键。

希望本教程能为您在 Elasticsearch 的学习和使用之路上提供坚实的指导。

“`

滚动至顶部