Elasticsearch学习使用

Elasticsearch入门学习

1.什么是Elasticsearch
  • elasticsearch是一款非常强大的开源搜索引擎，可以帮助我们从海量数据中快速找到需要的内容。
  • elasticsearch结合kibana、Logstash、Beats，也就是elastic stack（ELK）。被广泛应用在日志数据分析、实时监控等领域。
  • elasticsearch是elastic stack的核心，负责存储、搜索、分析数据。
2.正向索引和倒排索引

1.正向索引
基于文档（每一条数据就是一个文档 ）id创建索引。查询词条时必须先找到文档，而后判断是否包含词条

2.倒排索引
对文档内容分词，对词条（对文档中的内容分词，得到的词语就是词条）创建索引，并记录词条所在文档的信息。查询时先根据词条查询到文档id，而后获取到文档

elasticsearch是面向文档存储的，可以是数据库中的一条商品数据，一个订单信息。文档数据会被序列化为json格式后存储在elasticsearch中。

3.ES与MySQL基本概念的对比

MySQL：擅长事务类型操作，可以确保数据的安全和一致性
Elasticsearch：擅长海量数据的搜索、分析、计算

将数据写入MySQL后，通过某种方法将数据同步到ES，以后从ES搜索数据，这样达到了ES和MySQL互补的效果

3.安装ES

3.1 创建网络
因为我们还需要部署kibana容器，因此需要让es和kibana容器互联。这里先创建一个网络：

1
docker network create es-net

3.2 拉取镜像并部署单点ES

1
2
3
4
5
6
7
8
9
10
11
12
13
docker pull elasticsearch:8.17.0 # 版本自己选择，不同版本有差异

docker run -d \
  --name es \
    -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
    -e "discovery.type=single-node" \
    -v es-data:/usr/share/elasticsearch/data \
    -v es-plugins:/usr/share/elasticsearch/plugins \
    --privileged \
    --network es-net \
    -p 9200:9200 \
    -p 9300:9300 \
elasticsearch:8.17.0

命令解释：

  • -e "cluster.name=es-docker-cluster"：设置集群名称
  • -e "http.host=0.0.0.0"：监听的地址，可以外网访问
  • -e "ES_JAVA_OPTS=-Xms512m -Xmx512m"：内存大小
  • -e "discovery.type=single-node"：非集群模式
  • -v es-data:/usr/share/elasticsearch/data：挂载逻辑卷，绑定es的数据目录
  • -v es-logs:/usr/share/elasticsearch/logs：挂载逻辑卷，绑定es的日志目录
  • -v es-plugins:/usr/share/elasticsearch/plugins：挂载逻辑卷，绑定es的插件目录
  • --privileged：授予逻辑卷访问权
  • --network es-net ：加入一个名为es-net的网络中
  • -p 9200:9200：端口映射配置，供用户访问

访问IP:9200，可以看到ES安装成功。

4.安装Kibana

kibana可以给我们提供一个elasticsearch的可视化界面，便于我们学习

4.1 拉取kibana镜像并创建容器

1
2
3
4
5
6
7
8
docker pull kibana:8.17.0   # 具体版本支持需要去dockerhub官网查询是否支持你的电脑系统

docker run -d \
  --name kibana \
  -e ELASTICSEARCH_HOSTS=http://localhost:9200 \
  --network=es-net \
  -p 5601:5601  \
  kibana:8.17.0
  • --network es-net ：加入一个名为es-net的网络中，与elasticsearch在同一个网络中
  • -e ELASTICSEARCH_HOSTS=http://es:9200"：设置elasticsearch的地址，因为kibana已经与elasticsearch在一个网络，因此可以用容器名直接访问elasticsearch
  • -p 5601:5601：端口映射配置

4.2 访问IP:5601

kibana中提供了一个DevTools界面，这个界面中可以编写DSL来操作elasticsearch。并且对DSL语句有自动补全功能。

5.安装IK分词器
1
2
3
4
5
6
7
8
9
10
# 进入容器内部
docker exec -it es /bin/bash

# 在线下载并安装
./bin/elasticsearch-plugin  install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.12.1/elasticsearch-analysis-ik-7.12.1.zip

#退出
exit
#重启容器
docker restart es

IK分词器包含两种模式：

  • ik_smart：最少切分
  • ik_max_word：最细切分

或者直接将解压好的ik文件上传到 /var/lib/docker/volumes/es-plugins/_data目录下，然后重启es即可！

1
2
3
4
5
POST /_analyze
{
  "text": "广州大学冲双一流！",
  "analyzer": "ik_max_word/ik_smart"
}

二.索引库操作

1
索引库，类似于数据库的表，各种字段都定义好了属性，类似于一张空表
1.创建索引库

mapping是对索引库中文档的约束，常见的mapping属性包括：
type：字段数据类型，常见的简单类型有：
字符串：text（可分词的文本）、keyword（精确值，例如：品牌、国家、ip地址）
数值：long、integer、short、byte、double、float、
布尔：boolean
日期：date
对象：object
index：是否创建索引，默认为true
analyzer：使用哪种分词器，若类型为text，要指定分词器
properties：该字段的子字段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
PUT /索引库名称
{
  "mappings": {
    "properties": {
      "字段名":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "字段名2":{
        "type": "keyword",
        "index": "false"
      },
      "字段名3":{
        "properties": {
          "子字段": {
            "type": "keyword"
          }
        }
      },
      // ...略
    }
  }
}

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
PUT /gzhu
{
  "mappings": {
    "properties": {
      "name":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "email":{
        "type": "keyword",
        "index": "false"
      },
      "admin":{
        "properties": {
          "firstName": {
            "type": "keyword"
          },
          "lasttName": {
            "type": "keyword"
          }
        }
      }
    }
  }
}
2.查询索引库

查询索引库：GET /索引库名

3.删除索引库

删除索引库：DELETE /索引库名

4.添加新字段

添加字段：PUT /索引库名/_mapping

1
2
3
4
5
6
7
8
PUT /索引库名/_mapping
{
  "properties": {
    "新字段名":{
      "type": "integer"
    }
  }
}

三.文档操作

1.新增文档
1
2
3
4
5
6
7
8
9
10
POST /索引库名/_doc/文档id
{
    "字段1": "值1",
    "字段2": "值2",
    "字段3": {
        "子属性1": "值3",
        "子属性2": "值4"
    },
    // ...
}

示例：

1
2
3
4
5
6
7
8
9
POST /gzhu/_doc/1
{
  "name":"计算机科学与网络工程学院",
  "email":"gzhucom@edu.com",
  "admin":{
    "firstName":"张",
    "lastName":"三"
  }
}
2.查询文档

GET /索引库名/_doc/文档id

3.删除文档

DELETE /索引库名/_doc/文档id

4.修改文档

4.1 全量修改：删除旧文档，添加新文档，若文档不存在，也可以添加文档

1
2
3
4
5
6
PUT /索引库名/_doc/文档id
{
    "字段1": "值1",
    "字段2": "值2",
    // ... 略
}

4.2 局部修改文档：

1
2
3
4
5
6
POST /索引库名/_update/文档id
{
    "doc": {
         "字段名": "新的值",
    }
}

四.RestClient操作索引库

1
ES官方提供了各种不同语言的客户端，用来操作ES。这些客户端的本质就是组装DSL语句，通过http请求发送给ES。

官方库：elastic/go-elasticsearch‌ https://github.com/elastic/go-elasticsearch

著名三方库：olivere/elastic https://github.com/olivere/elastic

Go-elasticsearch客户端对比

五.DSL查询文档

1.查询基本语法

Elasticsearch提供了基于JSON的DSL（Domain Specific Language）来定义查询。常见的查询类型包括：

  • 查询所有：查询出所有数据，一般测试用。例如：match_all
  • 全文检索（full text）查询：利用分词器对用户输入内容分词，然后去倒排索引库中匹配。例如：
    match_query
    multi_match_query
  • 精确查询：根据精确词条值查找数据，一般是查找keyword、数值、日期、boolean等类型字段。例如：
    ids
    range
    term
  • 地理（geo）查询：根据经纬度查询。例如：
    geo_distance
    geo_bounding_box
  • 复合（compound）查询：复合查询可以将上述各种查询条件组合起来，合并查询条件。例如：
    bool
    function_score

1.1 查询所有文档

1
2
3
4
5
6
GET /order/_search
{
  "query":{
    "match_all":{}
  }
}

1.2 全文检索（full text）查询

  • match查询，查询字段name中包含5G的文档
1
2
3
4
5
6
7
8
GET /order/_search
{
  "query":{
    "match": {
      "name": "5G"
    }
  }
}
  • multi_match查询，返回字段name或者user.address.keyword包含天津市的文档
1
2
3
4
5
6
7
8
9
GET /order/_search
{
  "query":{
    "multi_match": {
      "query": "天津市",
      "fields": ["user.address.keyword","name"]
   }
  }
}

1.3 精确查询

精确查询一般是查找keyword、数值、日期、boolean等类型字段。所以不会对搜索条件分词。

  • term：根据词条精确值查询，不会分词
    查询价格字段为359900的文档，多一块少一块都查不到
1
2
3
4
5
6
7
8
9
10
GET /order/_search
{
  "query":{
    "term": {
      "price": {
        "value": "359900"
      }
    }
  }
}
  • range：根据值的范围查询，比如日期，数字
    查询字段价格在0-1000000的文档
1
2
3
4
5
6
7
8
9
10
11
12
GET /order/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 0,
        "lte": 10000000
      }
    }
  }
}
gte包含等于，gt不包含等于。

1.4 Function score query详解
https://segmentfault.com/a/1190000037700644

示例：查询所有文档中name中包含Apple关键字的，并且将name中包含6s中的文档分数加权10（默认关系是乘法）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
GET /order/_search
{
  "query": {
   "function_score": {
     "query": {
       "match": {
         "name": "Apple"
       }
     },
     "functions": [
       {"filter": {
         "term": {
           "name": "6s"
         }
       },
         "weight": 10
       }
     ]
   }
  }
}

1.5 复合查询 Boolean Query

  • must：必须匹配的条件，可以理解为“与”
  • should：选择性匹配的条件，可以理解为“或”
  • must_not：必须不匹配的条件，不参与打分
  • filter：必须匹配的条件，不参与打分
2.搜索结果处理（排序、分页、高亮）

2.1 排序

查询所有name包含Apple的文档，按照价格降序，数量升序的规则输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
GET /order/_search
{
  "query":{
    "match": {
      "name": "Apple"
    }
  },
  "sort": [
    {
      "price":"desc"
    },
    {
      "num":"asc"
    }
  ]
}

2.2 分页

从第一个开始，每页查询13条文档

1
2
3
4
5
6
7
8
9
10
11
12
13
GET /order/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0, //分页的开始，默认为0
  "size":13, //每页的文档数
  "sort":[
    {
      "price":"asc"
    }
  ]
}

from+size原理：如果要查询第990-1000条文档，则先查询前1000条，再截取990-1000条文档。

但在实际环境中ES是集群部署的，数据分布在不同的ES服务器中，如果查询页数太深，对内存要求会很高。

首先在每个数据分片上都排序并查询前1000条文档。
然后将所有节点的结果聚合，在内存中重新排序选出前1000条文档。
最后从这1000条中，选取从990开始的10条文档。

1
ES限制查询分页总数必须小于等于10000，例如京东、淘宝、百度等他们的查询结果也不会超过10000。

如果真要查询10000以上的数据怎么办？
可以使用after search：
优点：没有查询上限（单次查询的size不超过10000）
缺点：只能向后逐页查询，不支持随机翻页
场景：没有随机翻页需求的搜索，例如手机向下滚动翻页

2.3 高亮

默认情况下，搜索字段必须和高亮字段一致，“require_field_match”: “false”可以取消此设定 name和name要一样（下面的示例一样，不用加false也可以高亮）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
GET /order/_search
{
  "query": {
    "match": {
      "name": "Apple"
    }
  },
  "highlight": {
    "fields": {
      "name": {
        "require_field_match": "false"
      }
    }
  }
}

六.数据聚合

1.聚合的分类

聚合（aggregations）可以实现对文档数据的统计、分析、运算。聚合常见的有三类：

  • 桶（Bucket）聚合：用来对文档做分组
    TermAggregation：按照文档字段值分组
    Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组
  • 度量（Metric）聚合：用以计算一些值，比如：最大值、最小值、平均值等
    Avg：求平均值
    Max：求最大值
    Min：求最小值
    Stats：同时求max、min、avg、sum等
  • 管道（pipeline）聚合：其它聚合的结果为基础做聚合
1
参与聚合的字段类型必须是：
  • keyword
  • 数值
  • 日期
  • 布尔
2.Bucket聚合与Metrics聚合

2.1 Bucket聚合（几组，每组几个）
需求：查询索引库中有几个用户下过订单，分别下了几次订单

1
2
3
4
5
6
7
8
9
10
11
12
GET /order/_search
{
  "size": 0, //不显示文档
  "aggs": {
    "userCount": { // 聚合的名字，自定义
      "terms": { 
        "field": "userId", // 聚合的关键字
        "size": 5 // 显示的聚合数，假如有10个用户，只会显示5个
      }
    }
  }
}

1
默认情况下，Bucket聚合会统计Bucket内的文档数量，记为_count，并且按照_count降序排序。

默认情况下，Bucket聚合是对索引库的所有文档做聚合，我们可以限定要聚合的文档范围，只要添加query条件即可

需求：查询索引库中有几个用户下过订单，分别下了几次订单，只统计订单数目为1的文档

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
GET /order/_search
{
  "query": {
    "term": {
      "num": 1
    }
  }, 
  "size": 0, 
  "aggs": {
    "userCount": {
      "terms": {
        "field": "userId",
        "size": 5
      }
    }
  }
}

aggs代表聚合，与query同级，此时query的作用是限定聚合的的文档范围
聚合必须的三要素：

  • 聚合名称
  • 聚合类型
  • 聚合字段

聚合可配置属性有：

  • size：指定聚合结果数量
  • order：指定聚合结果排序方式
  • field：指定聚合字段

2.2 Metrics聚合
需求：求每个用户消费的最大值、最小值、平均值、总金额

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
GET /order/_search
{
  "size": 0, 
  "aggs": {
    "userCount": {
      "terms": {
        "field": "userId",
        "size": 6
      },
      "aggs": {
        "price_stats": {  //聚合名字
          "stats": {    //聚合类型
            "field": "price"  //聚合字段
          }
        }
      }
    }
  }
}

七.自动补全

1.安装拼音分词器

①下载并解压：https://github.com/medcl/elasticsearch-analysis-pinyin/tags

②将解压文件上传到目录/var/lib/docker/volumes/es-plugins/_data

③重启es容器
④测试

2.自定义分词器

默认的拼音分词器会将每个汉字单独分为拼音，而我们希望的是每个词条形成一组拼音，需要对拼音分词器做个性化定制，形成自定义分词器

elasticsearch中分词器（analyzer）的组成包含三部分：

  • character filters：在tokenizer之前对文本进行处理。例如删除字符、替换字符
  • tokenizer：将文本按照一定的规则切割成词条（term）。例如keyword，就是不分词；还有ik_smart
  • tokenizer filter：将tokenizer输出的词条做进一步处理。例如大小写转换、同义词处理、拼音处理等

自定义分词器要在创建索引库时定义，例如，创建order索引库。为了避免搜索到同音字，搜索时不要使用拼音分词器，创建倒排索引时才使用自定义分词器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
PUT /order
{
  "settings": {
    "analysis": {
      "analyzer": { // 自定义分词器
        "my_analyzer": {  // 分词器名称
          "tokenizer": "ik_max_word",
          "filter": "py"
        }
      },
      "filter": { // 自定义tokenizer filter
        "py": { // 过滤器名称
          "type": "pinyin", // 过滤器类型，这里是pinyin
      "keep_full_pinyin": false,
          "keep_joined_full_pinyin": true,
          "keep_original": true,
          "limit_first_letter_length": 16,
          "remove_duplicated_term": true,
          "none_chinese_pinyin_tokenize": false
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "name": {
        "type": "text",
        "analyzer": "my_analyzer",
        "search_analyzer": "ik_smart"
      }
    }
  }
}
3.实现自动补全

3.1 控制台实现
elasticsearch提供了Completion Suggester查询来实现自动补全功能。这个查询会匹配以用户输入内容开头的词条并返回。为了提高补全查询的效率，对于文档中字段的类型有一些约束：

  • 参与补全查询的字段必须是completion类型
  • 字段的内容一般是用来补全的多个词条形成的数组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
PUT /order
{
  "settings": {
    "analysis": {
      "analyzer": {
        "text_anlyzer": {
          "tokenizer": "ik_max_word",
          "filter": "py"
        },
        "completion_analyzer": {
          "tokenizer": "keyword",
          "filter": "py"
        }
      },
      "filter": {
        "py": {
          "type": "pinyin",
          "keep_full_pinyin": false,
          "keep_joined_full_pinyin": true,
          "keep_original": true,
          "limit_first_letter_length": 16,
          "remove_duplicated_term": true,
          "none_chinese_pinyin_tokenize": false
        }
      }
    }
  },
    
  "mappings" : {
      "properties" : {
        "id" : {
          "type" : "keyword"
        },
        "name" : {
          "type" : "text",
          "analyzer" : "text_anlyzer",
          "search_analyzer": "ik_smart"
        },
        "num" : {
          "type" : "integer"
        },
        "price" : {
          "type" : "long"
        },
        "user" : {
          "properties" : {
            "address" : {
              "type" : "text",
              "fields" : {
                "keyword" : {
                  "type" : "keyword",
                  "ignore_above" : 256
                }
              }
            },
            "id" : {
              "type" : "long"
            },
            "username" : {
              "type" : "text",
              "fields" : {
                "keyword" : {
                  "type" : "keyword",
                  "ignore_above" : 256
                }
              }
            }
          }
        },
        "userId" : {
          "type" : "keyword"
        },
        "suggestion":{
          "type": "completion",
          "analyzer": "completion_analyzer"
      }
      }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
GET /order/_search
{
  "suggest": {
    "my_suggestions": {
      "text": "b",
      "completion": {
        "field": "suggestion",
        "skip_duplicates": true, // 跳过重复的
        "size":10
      }
    }
  }
}

八.数据同步

采用MQ异步通知的方式完成数据同步，即当对数据库进行操作时，发送一条消息到队列，对ES的相关操作监听这个队列，有消息就完成ES的修改。

九.ES集群

数据备份可以保证高可用，但是每个分片备份一份，所需要的节点数量就会翻一倍，成本实在是太高了！

为了在高可用和成本间寻求平衡，我们可以这样做：

  • 首先对数据分片，存储到不同节点
  • 然后对每个分片进行备份，放到对方节点，完成互相备份
1.搭建ES集群环境

首先准备三台服务器，每台服务器先要有ES的镜像

重要设置

1
2
3
4
5
6
7
8
9
10
#创建conf
grep vm.max_map_count /etc/sysctl.conf
#文件里设置参数
vim /etc/sysctl.conf
#设置
vm.max_map_count=262144
#永久生效
echo vm.max_map_count=262144>>/etc/sysctl.conf
#查看
sysctl -p

否则部署的ES会报78错误码，如果设置了此参数依旧78错误码，重启服务器

在根目录下创建文件
/es/config/esX.yml（其中X=1、2、3，对应三台服务器，下同），配置信息如下

1
2
3
4
5
6
7
8
9
10
11
12
13
cluster.name: elasticsearch-cluster
node.name: es-nodeX
network.host: 0.0.0.0
network.publish_host: 192.168.10.131
http.port: 9200
transport.tcp.port: 9300
http.cors.enabled: true
http.cors.allow-origin: "*"
cluster.initial_master_nodes: ["es-node1","es-node2","es-node3"]
node.master: true
node.data: true
discovery.zen.ping.unicast.hosts: ["192.168.10.129:9300","192.168.10.130:9300"]
discovery.zen.minimum_master_nodes: 2
  • cluster.name必须一致，代表一个集群
  • node.name必须不一致，代表三个节点
  • network.publish_host代表本机IP
  • cluster.initial_master_nodes: [“es-nodeX”]和node.name必须一致

节点角色：

  • node.master：备选主节点，主节点可以管理和记录集群状态、决定分片在哪个节点、处理创建和删除索引库的请求
  • node.data：数据节点，存储数据、搜索、聚合、CRUD
  • node.ingest：数据存储之前的预处理
  • coordinating：路由请求到其他节点，合并其他节点处理的结果，返回给用户

运行容器

1
docker run -e ES_JAVA_OPTS="-Xms256m -Xmx256m" -d -p 9200:9200 -p 9300:9300 -v /es/config/es3.yml:/usr/share/elasticsearch/config/elasticsearch.yml  --name es03 elasticsearch:7.12.1

如果以上无误，其实包含三个节点的es集群已经搭建起来了！

2.集群状态监控

利用cerebro进行监控

  • 拉取镜像
1
docker pull lmenezes/cerebro
  • 运行容器
1
docker run -d --name cerebro -p 9100:9000 lmenezes/cerebro
  • 访问IP:9100
  • 输入 http://127.0.0.1:9200 （任意节点服务器即可），可以看到刚才部署的es集群的3个节点信息
3.脑裂及解决

脑裂是因为集群中的节点失联导致的
例如一个集群中，主节点与其它节点失联

此时，node2和node3认为node1宕机，就会重新选主

当node3当选后，集群继续对外提供服务，node2和node3自成集群，node1自成集群，两个集群数据不同步，出现数据差异

当网络恢复后，因为集群中有两个master节点，集群状态的不一致，出现脑裂的情况

解决脑裂的方案是，要求选票超过 ( eligible节点数量 + 1 )/ 2 才能当选为主，因此eligible节点数量最好是奇数。对应配置项是discovery.zen.minimum_master_nodes，在es7.0以后，已经成为默认配置，因此一般不会发生脑裂问题

例如：3个节点形成的集群，选票必须超过 （3 + 1） / 2 ，也就是2票。node3得到node2和node3的选票，当选为主。node1只有自己1票，没有当选。集群中依然只有1个主节点，没有出现脑裂

4.集群新增数据及查询流程
  • 新增流程：

    当用户新增一条文档时，首先要经过某种哈希运算计算要分配到哪个分片上，shard=hash(_routing)%number_of_shards，_routing默认是文档的id，可见，算法与分片数量有关，所以索引库一旦创建，分片数量不可以修改！确定好哪个分片后，路由节点到相应的节点，相应的分片保存数据，并将数据同步到副本节点，以上完成后，返回成功的信息给路由节点，路由节点再返回给用户成功的信息
  • 查询流程：

    协调节点会把请求分发到每一个分片，称为分散阶段。协调节点汇总data node的结果，称为聚集阶段，并处理结果集返回给用户
5.故障转移

集群的master节点会监控集群中的节点状态，如果发现有节点宕机，会立即将宕机节点的分片数据迁移到其它节点，确保数据安全，这个叫做故障转移




以上es会自动完成故障转移操作，特别注意的是，如果宕机的节点又恢复正常了，则当前的主节点会把相应的分片再分发回去，十分强大！

云原生
#学习 #分布式 #搜索
Elasticsearch学习使用
https://zty-f.github.io/2024/10/30/Elasticsearch入门学习/
作者
ZTY
发布于
2024年10月30日
更新于
2025年1月2日
许可协议