IT小白

这个屌丝很懒，什么也没留下！

热门标签

elasticsearch-8.5.2快速入门和kibana-8.5.2的使用_elasticsearch8 kibana

作者：IT小白 | 2024-07-06 12:01:39

踩

elasticsearch8 kibana

全网付费课程欢迎咨询QQ：3388486286

一、安装

官方安装Elasticsearch，和ES可视化工具kibana。安装下载过程略。

二、启动Elasticsearch。

windows系统，直接进入到如图目录，然后启动elasticsearch.bat，这个就是ES服务。
在这里插入图片描述
启动后，我们可以访问https://127.0.0.1:9200/来查看 ES是否启动成功。

浏览器启动后，提示输入账号密码。
在这里插入图片描述
在安装的elasticsearch-8.5.2\bin 目录下，启动cmd命令，输入以下指令获取账号密码。
elasticsearch-reset-password -u elastic
输入完后出现如图，[用户名]和密码。

然后输入到浏览器中，就OK了。
出现该界面，表示ES启动成功。
在这里插入图片描述

三、启动kibana。

进入到如图目录。点击kibana.bat
在这里插入图片描述
等待服务启动。
启动完成后，访问如下地址：http://localhost:5601/
他会提示你配置token令牌。
进入如图目录elasticsearch-8.5.2\bin，执行一下命令获取令牌。
elasticsearch-create-enrollment-token.bat --scope kibana

在这里插入图片描述
然后进行配置即可。

配置完成后，会看到如图界面。
在这里插入图片描述
依次点击，就可以打开通信工具，按照ES的接口风格来和ES进行通信。

三、 Elasticsearch的基本使用。

ES是通过创建索引，去管理文档的。

1.创建文档。

ES中的文档就相当于面向对象中的对象，文档格式就是Json类型。
打开kibana找到Dev Tools，我们来使用PUT创建第一条数据。

//添加数据
PUT /megacorp/_doc/1
{

    "first_name" : "JC",

    "last_name" :  "W",

    "age" :        25,

    "about" :      "I love to go swiming！",

    "interests": [ "sports", "music" ]

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在这里插入图片描述
数据写完后，点击这个小三角形，即发生请求。
请求完，我们可以看到右边的返回结果。

{
  "_index": "megacorp",
  "_id": "4",
  "_version": 1,
  "result": "created",
  "_shards": {
    "total": 2,
    "successful": 1,
    "failed": 0
  },
  "_seq_no": 4,
  "_primary_term": 1
}
1
2
3
4
5
6
7
8
9
10
11
12
13

"successful": 1表示创建成功。

2.查询刚刚创建的文档。

//获取指定ID数据
GET /megacorp/_doc/1  

//获取所有数据，默认返回10条
GET /megacorp/_search

//尝试下搜索姓氏为 ``Smith`` 的雇员
GET /megacorp/_search?q=last_name:Smith
1
2
3
4
5
6
7
8

以上都是轻量搜索，Query-string 搜索通过命令非常方便地进行临时性的即席搜索，但它有自身的局限性.。
Elasticsearch 提供一个丰富灵活的查询语言叫做查询表达式，它支持构建更加复杂和健壮的查询。

3.使用查询表达式搜索

查询last_name为w的人。

//表达式查询
GET /megacorp/_search
{
  "query" : 
  {
    "match": {
      "last_name": "w"
    }
    
  }
  
}
1
2
3
4
5
6
7
8
9
10
11
12

返回结果：

{
  "took": 890,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 1,
      "relation": "eq"
    },
    "max_score": 1.2039728,
    "hits": [
      {
        "_index": "megacorp",
        "_id": "1",
        "_score": 1.2039728,
        "_source": {
          "first_name": "JC",
          "last_name": "W",
          "age": 25,
          "about": "I love to go swiming！",
          "interests": [
            "sports",
            "music"
          ]
        }
      }
    ]
  }
}
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

hits.value代表查询了几条数据，hits数组是数据源。

查询 "last_name": "w"并且年龄大于20

get /megacorp/_search 
{
  "query" : {
    "bool": {
      "must": [
        {
          "match": {
          "last_name": "w"
          }
        }
      ],
      "filter": [
        {
          "range": {
            "age": {
              "gte": 20
            }
          }
          
        }
      ]
    }
    
  }
  
}
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

这部分是一个 range 过滤器，它能找到年龄大于 20 的文档，其中 gt 表示_大于_。

4.全文搜索

搜索下所有喜欢攀岩（rock climbing）的员工：

//全文 搜索 

GET /megacorp/_search  
{
  "query":{
    "match": {
      "about": "rock climbing"
    }
    
  }
  
}
1
2
3
4
5
6
7
8
9
10
11
12

返回结果：

{
  "took": 0,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 2,
      "relation": "eq"
    },
    "max_score": 1.9032972,
    "hits": [
      {
        "_index": "megacorp",
        "_id": "5",
        "_score": 1.9032972,
        "_source": {
          "first_name": "John",
          "last_name": "Smith 1",
          "age": 25,
          "about": "I love to go rock climbing",
          "interests": [
            "sports",
            "music"
          ]
        }
      },
      {
        "_index": "megacorp",
        "_id": "6",
        "_score": 0.6682933,
        "_source": {
          "first_name": "Jane",
          "last_name": "Smith 2",
          "age": 32,
          "about": "I like to collect rock albums",
          "interests": [
            "music"
          ]
        }
      }
    ]
  }
}
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

Elasticsearch 默认按照相关性得分排序，即每个文档跟查询的匹配程度。第一个最高得分的结果很明显：John Smith 的 about 属性清楚地写着 “rock climbing” 。
但为什么 Jane Smith 也作为结果返回了呢？原因是她的 about 属性里提到了 “rock” 。因为只有 “rock” 而没有 “climbing” ，所以她的相关性得分低于 John 的。
这是一个很好的案例，阐明了 Elasticsearch 如何在全文属性上搜索并返回相关性最强的结果。

5.短语搜索

查询，仅匹配同时包含 “rock” 和 “climbing” ，并且二者以短语 “rock climbing” 的员工记录。
为此对 match 查询稍作调整，使用一个叫做 match_phrase 的查询：

GET /megacorp/_search
{
  "query":{
    "match_phrase": {
      "about": "rock climbing"
    }
    
  }
  
}
1
2
3
4
5
6
7
8
9
10

返回结果：

{
  "took": 0,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 1,
      "relation": "eq"
    },
    "max_score": 2.4450343,
    "hits": [
      {
        "_index": "megacorp",
        "_id": "5",
        "_score": 2.4450343,
        "_source": {
          "first_name": "John",
          "last_name": "Smith 1",
          "age": 25,
          "about": "I love to go rock climbing",
          "interests": [
            "sports",
            "music"
          ]
        }
      }
    ]
  }
}
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

可以看到只返回了包含rock climbing的数据。

6.高亮搜索

//高亮搜索

GET /megacorp/_search 
{
  "query":{
    "match_phrase": {
      "about": "rock climbing"
    }
    
  },
  "highlight":{
    "fields": {
      "about":{}
    }
    
  }
  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

当执行该查询时，返回结果与之前一样，与此同时结果中还多了一个叫做 highlight 的部分。这个部分包含了 about 属性匹配的文本片段，并以 HTML 标签 <em></em> 封装：

{
  "took": 593,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 1,
      "relation": "eq"
    },
    "max_score": 2.4450343,
    "hits": [
      {
        "_index": "megacorp",
        "_id": "5",
        "_score": 2.4450343,
        "_source": {
          "first_name": "John",
          "last_name": "Smith 1",
          "age": 25,
          "about": "I love to go rock climbing",
          "interests": [
            "sports",
            "music"
          ]
        },
        "highlight": {
          "about": [
            "I love to go <em>rock</em> <em>climbing</em>"
          ]
        }
      }
    ]
  }
}
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

7.数据聚合分析

Elasticsearch 有一个功能叫聚合（aggregations），允许我们基于数据生成一些精细的分析结果。聚合与 SQL 中的 GROUP BY 类似但更强大。

Elasticsearch 5.x版本以后，对排序和聚合等操作，用单独的数据结构(fielddata)缓存到内存里了，默认是不开启的，需要单独开启。
对对应字段执行聚合操作之前需要先开启fielddata

//添加fielddata
PUT megacorp/_mapping
{
  "properties":{
    
    "interests":{
      "type":"text",
      "fielddata":true
      
    }
    
  }
  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

fielddata开启后，我们再来使用聚合操作。

挖掘出员工中最受欢迎的兴趣爱好：

//聚合分析
GET /megacorp/_search?pretty
{

  "aggs": {

    "all_interests": {

      "terms": { "field": "interests" }

    }

  }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

聚合结果：

 "aggregations": {
    "all_interests": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [
        {
          "key": "music",
          "doc_count": 4
        },
        {
          "key": "sports",
          "doc_count": 3
        },
        {
          "key": "forestry",
          "doc_count": 1
        },
        {
          "key": "games",
          "doc_count": 1
        },
        {
          "key": "play",
          "doc_count": 1
        },
        {
          "key": "sing",
          "doc_count": 1
        }
      ]
    }
  }
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

可以看到，四位员工对音乐感兴趣，一位对林业感兴趣，三位对运动感兴趣…。这些聚合的结果数据并非预先统计，而是根据匹配当前查询的文档即时生成的。如果想知道叫 Smith 的员工中最受欢迎的兴趣爱好，可以直接构造一个组合查询：

//构造某个姓氏的兴趣爱好统计
GET megacorp/_search
{
  "query":{
    "match": {
      "last_name": "Smith"
    }
    
  },
  "aggs":
  {
    "all_interests":
    {
      "terms": {
        "field": "interests",
        "size": 10
      }
      
    }
    
  }
  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

结果：

 "aggregations": {
    "all_interests": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [
        {
          "key": "music",
          "doc_count": 3
        },
        {
          "key": "sports",
          "doc_count": 2
        }
      ]
    }
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

聚合还支持分级汇总。比如，查询特定兴趣爱好员工的平均年龄：

//查询特定爱好员工的平均年龄
GET /megacorp/_search
{

    "aggs" : {

        "all_interests" : {

            "terms" : { "field" : "interests" },

            "aggs" : {

                "avg_age" : {

                    "avg" : { "field" : "age" }

                }

            }

        }

    }

}
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

结果：

 "aggregations": {
    "all_interests": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [
        {
          "key": "music",
          "doc_count": 4,
          "avg_age": {
            "value": 26.75
          }
        },
        {
          "key": "sports",
          "doc_count": 3,
          "avg_age": {
            "value": 25
          }
        },
        {
          "key": "forestry",
          "doc_count": 1,
          "avg_age": {
            "value": 35
          }
        },
        {
          "key": "games",
          "doc_count": 1,
          "avg_age": {
            "value": 33
          }
        },
        {
          "key": "play",
          "doc_count": 1,
          "avg_age": {
            "value": 33
          }
        },
        {
          "key": "sing",
          "doc_count": 1,
          "avg_age": {
            "value": 33
          }
        }
      ]
    }
  }
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

四、 Elasticsearch集群。

1.了解集群。

一个运行中的 Elasticsearch 实例称为一个节点，而集群是由一个或者多个拥有相同 cluster.name 配置的节点组成，它们共同承担数据和负载的压力。当有节点加入集群中或者从集群中移除节点时，集群将会重新平均分布所有的数据。

当一个节点被选举成为主节点时，它将负责管理集群范围内的所有变更，例如增加、删除索引，或者增加、删除节点等。而主节点并不需要涉及到文档级别的变更和搜索等操作，所以当集群只拥有一个主节点的情况下，即使流量的增加它也不会成为瓶颈。任何节点都可以成为主节点。我们的示例集群就只有一个节点，所以它同时也成为了主节点。

作为用户，我们可以将请求发送到集群中的任何节点，包括主节点。每个节点都知道任意文档所处的位置，并且能够将我们的请求直接转发到存储我们所需文档的节点。无论我们将请求发送到哪个节点，它都能负责从各个包含我们所需文档的节点收集回数据，并将最终结果返回給客户端。 Elasticsearch 对这一切的管理都是透明的。

2.集群健康。

Elasticsearch 的集群监控信息中包含了许多的统计数据，其中最为重要的一项就是集群健康，它在 status 字段中展示为 green 、 yellow 或者 red 。

//查看集群健康状态
GET /_cluster/health
1
2

返回结果：

{
  "cluster_name": "elasticsearch",
  "status": "yellow",
  "timed_out": false,
  "number_of_nodes": 1,
  "number_of_data_nodes": 1,
  "active_primary_shards": 12,
  "active_shards": 12,
  "relocating_shards": 0,
  "initializing_shards": 0,
  "unassigned_shards": 1,
  "delayed_unassigned_shards": 0,
  "number_of_pending_tasks": 0,
  "number_of_in_flight_fetch": 0,
  "task_max_waiting_in_queue_millis": 0,
  "active_shards_percent_as_number": 92.3076923076923
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

status 字段是我们最关心的。

status 字段指示着当前集群在总体上是否工作正常。它的三种颜色含义如下：

green

所有的主分片和副本分片都正常运行。
yellow

所有的主分片都正常运行，但不是所有的副本分片都正常运行。
red
有主分片没能正常运行

3.添加索引。

我们往 Elasticsearch 添加数据时需要用到索引 —— 保存相关数据的地方。索引实际上是指向一个或者多个物理分片的逻辑命名空间。

我们只需知道一个分片是一个 Lucene 的实例，以及它本身就是一个完整的搜索引擎。我们的文档被存储和索引到分片内，但是应用程序是直接与索引而不是与分片进行交互。

一个分片可以是主分片或者副本分片。索引内任意一个文档都归属于一个主分片，所以主分片的数目决定着索引能够保存的最大数据量。

一个副本分片只是一个主分片的拷贝。副本分片作为硬件故障时保护数据不丢失的冗余备份，并为搜索和返回文档等读操作提供服务。

在索引建立的时候就已经确定了主分片数，但是副本分片数可以随时修改。

让我们在包含一个空节点的集群内创建名为 blogs 的索引。索引在默认情况下会被分配5个主分片。

//设置节点中分片数量 。表示设置了5个主分片，每个分配有一个备份。
PUT /blogs
{
  "settings":
  {
    "number_of_shards":5,
    "number_of_replicas":1
    
  }
  
}
1
2
3
4
5
6
7
8
9
10
11

简而言之，数据都存放在shard中，每个node可以自己设置shard数量，shard分为primary shard 和replicas shard replicas shard是primary shard的备份，并且同一个primary shard的replicas shard 不能放在同一个节点中，例如：P_A ,R_A不能在一个节点。但是P_A，R_B可以在同一个节点。如果相同数据和备份都在一个节点，那该节点如果宕机了，所有数据就会丢失。

4.水平扩容

主分片的数目在索引创建时就已经确定了下来。实际上，这个数目定义了这个索引能够存储的最大数据量。（实际大小取决于你的数据、硬件和使用场景。）但是，读操作——搜索和返回数据——可以同时被主分片或副本分片所处理，所以当你拥有越多的副本分片时，也将拥有越高的吞吐量。

在运行中的集群上是可以动态调整副本分片数目的，我们可以按需伸缩集群。让我们把副本数从默认的 1 增加到 2 ：

PUT /blogs/_settings
{
   "number_of_replicas" : 2
}
1
2
3
4

在这里插入图片描述

blogs 索引现在拥有9个分片：3个主分片和6个副本分片。这意味着我们可以将集群扩容到9个节点，每个节点上一个分片。相比原来3个节点时，集群搜索性能可以提升 3 倍。

5.Autogenerating IDs

如果你的数据没有自然的 ID， Elasticsearch 可以帮我们自动生成 ID 。请求的结构调整为：不再使用 PUT 谓词，而是使用 POST 谓词

POST /website/_doc
{
  "title":"My second blog entry",
  "text":"still trying this out ...",
  "date":"2022-01-01"
  
}

1
2
3
4
5
6
7
8

post后会自动生成一个GUID

{
  "_index": "website",
  "_id": "03HF8IQBM50g06X4YHbb",
  "_version": 1,
  "result": "created",
  "_shards": {
    "total": 2,
    "successful": 1,
    "failed": 0
  },
  "_seq_no": 0,
  "_primary_term": 1
}
1
2
3
4
5
6
7
8
9
10
11
12
13

6.文档的取回

取出刚刚创建的文档

get /website/_doc/03HF8IQBM50g06X4YHbb
1

返回文档的一部分

//请求某个文档中的某个字段
GET /website/_doc/03HF8IQBM50g06X4YHbb?_source=title,text
1
2

7.检查文档是否存在

如果只想检查一个文档是否存在–根本不想关心内容—那么用 HEAD 方法来代替 GET 方法。 HEAD 请求没有返回体，只返回一个 HTTP 请求报头：

//检查 文档 是否 存在 
HEAD /website/_doc/123
1
2

8.更新整个文档

在 Elasticsearch 中文档是不可改变的，不能修改它们。相反，如果想要更新现有的文档，需要重建索引或者进行替换。

//修改文档数据
PUT /website/_doc/123
{
  
    "title": "My second blog entry",
    "text": "still trying this out ...",
    "date": "2022-01-11"
}
1
2
3
4
5
6
7
8

9.创建新文档

方式1

POST /website/_doc/
{
  "title":"My second blog entry",
  "text":"still trying this out ...",
  "date":"2022-01-01"
  
}
1
2
3
4
5
6
7

然而，如果已经有自己的 _id ，那么我们必须告诉 Elasticsearch ，只有在相同的 _index 、 _type 和 _id 不存在时才接受我们的索引请求。这里有两种方式，他们做的实际是相同的事情。使用哪种，取决于哪种使用起来更方便。
第一种方法使用 op_type 查询-字符串参数：

//ID不存在时候才创建
PUT /website/_doc/1234?op_type=create
{
  
    "title": "My second blog entry",
    "text": "still trying this out ...",
    "date": "2022-01-11"
}
1
2
3
4
5
6
7
8

返回结果

{
  "error": {
    "type": "version_conflict_engine_exception",
    "reason": "[1234]: version conflict, document already exists (current version [2])",
    "index_uuid": "Dhq2F9QCR3G1DSWLM7niVA",
    "shard": "0",
    "index": "website"
  },
  "status": 409
}
1
2
3
4
5
6
7
8
9
10

返回409表示该ID已经存在。无法创建。

第二种方法是在 URL 末端使用 /_create :

PUT /website/_create/1
{
  
    "title": "My second blog entry",
    "text": "still trying this out ...",
    "date": "2022-01-11"
}
1
2
3
4
5
6
7

10. 删除文档

删除文档的语法和我们所知道的规则相同，只是使用 DELETE 方法：

//删除指定ID文档
DELETE /website/_doc/1
1
2

如果找到该文档，Elasticsearch 将要返回一个 200 ok 的 HTTP 响应码，和一个类似以下结构的响应体。注意，字段 _version 值已经增加:

{
  "found" :    true,
  "_index" :   "website",
  "_type" :    "blog",
  "_id" :      "123",
  "_version" : 2
}
1
2
3
4
5
6
7

如果文档没有找到，我们将得到 404 Not Found 的响应码和类似这样的响应体：

{
  "found" :    false,
  "_index" :   "website",
  "_type" :    "blog",
  "_id" :      "123",
  "_version" : 4
}
1
2
3
4
5
6
7

即使文档不存在（ Found 是 false ）， _version 值仍然会增加。这是 Elasticsearch 内部记录本的一部分，用来确保这些改变在跨多节点时以正确的顺序执行。

11.乐观并发控制

Elasticsearch 是分布式的。当文档创建、更新或删除时，新版本的文档必须复制到集群中的其他节点。Elasticsearch 也是异步和并发的，这意味着这些复制请求被并行发送，并且到达目的地时也许顺序是乱的。 Elasticsearch 需要一种方法确保文档的旧版本不会覆盖新的版本。

当我们之前讨论 index ， GET 和 delete 请求时，我们指出每个文档都有一个 _version （版本）号，当文档被修改时版本号递增。 Elasticsearch 使用这个 _version 号来确保变更以正确顺序得到执行。如果旧版本的文档在新版本之后到达，它可以被简单的忽略。

我们可以利用 _version 号来确保应用中相互冲突的变更不会导致数据丢失。我们通过指定想要修改文档的 version 号来达到这个目的。如果该版本不是当前版本号，我们的请求将会失败。

老版本是通过_version 进行控制，新版现在改为_seq_no和_primary_term进行控制，其中_primary_term相当于老版本中的_version。

假如此时是并发操作，2个机器同时请求了以下连接，如果第一个请求成功了，_version就加1，后者再发相同的请求就会失败。

//version=1的才修改
PUT /website/_doc/3?if_seq_no=15&if_primary_term=1
{
  
   "title": "My first blog entry",
  "text":  "Just trying this out11111"
}
1
2
3
4
5
6
7

返回结果：

{
  "_index": "website",
  "_id": "3",
  "_version": 2,
  "_seq_no": 16,
  "_primary_term": 1,
  "found": true,
  "_source": {
    "title": "My first blog entry",
    "text": "Just trying this out"
  }
}
1
2
3
4
5
6
7
8
9
10
11
12

可以看到此时 "_version":值为2。后面值为1的版本请求将会失败。

12.文档的部分更新

update 请求最简单的一种形式是接收文档的一部分作为 doc 的参数，它只是与现有的文档进行合并。对象被合并到一起，覆盖现有的字段，增加新的字段。例如，我们增加字段 tags 和 views 到我们的博客文章，如下所示：

//添加 字段
POST /website/_update/2/
{
  "doc":
  {
    "tags":["testing"],
    "views":0
    
  }
  
}
1
2
3
4
5
6
7
8
9
10
11

结果：

{
  "_index": "website",
  "_id": "2",
  "_version": 2,
  "_seq_no": 17,
  "_primary_term": 1,
  "found": true,
  "_source": {
    "title": "My first blog entry",
    "text": "Just trying this out...",
    "views": 0,
    "tags": [
      "testing"
    ]
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

这样就把新字段和老字段进行了合并。

另外ES还支持用 Groovy 脚本编程。

POST /website/_update/2/
{
  "script":"ctx._source.views+=1"
}
1
2
3
4

这样views的值就可以加1，具体用法可自行百度。

13.取回多个文档

mget API 要求有一个 docs 数组作为参数，每个元素包含需要检索文档的元数据，包括 _index 、 _id 。如果你想检索一个或者多个特定的字段，那么你可以通过 _source 参数来指定这些字段的名字：

//取回多个文档
GET /_mget
{
  "docs":[
    {"_index":"website",
      "_id":2
      
    },
    {
      "_index":"megacorp",
      "_id":2,
      "_source":"age"
      
    }
    ]
  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

结果：

{
  "docs": [
    {
      "_index": "website",
      "_id": "2",
      "_version": 4,
      "_seq_no": 19,
      "_primary_term": 1,
      "found": true,
      "_source": {
        "title": "My first blog entry",
        "text": "Just trying this out...",
        "views": 2,
        "tags": [
          "testing"
        ]
      }
    },
    {
      "_index": "megacorp",
      "_id": "2",
      "_version": 1,
      "_seq_no": 1,
      "_primary_term": 1,
      "found": true,
      "_source": {
        "age": 33
      }
    }
  ]
}
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

事实上，如果所有文档的 _index都是相同的，你可以只传一个 ids 数组，而不是整个 docs 数组：

//请求多id数据
GET /megacorp/_mget
{
   "ids" : [ "2", "1" ]
}
1
2
3
4
5

14.批量增删改。

与 mget 可以使我们一次取回多个文档同样的方式， bulk API 允许在单个步骤中进行多次 create 、 index 、 update 或 delete 请求。如果你需要索引一个数据流比如日志事件，它可以排队和索引数百或数千批次。

bulk 与其他的请求体格式稍有不同，如下所示：

POST /_bulk?pretty
{ "delete": { "_index": "website",  "_id": "2" }} 
{ "create": { "_index": "website", "_id": "2" }}
{ "title":    "My first blog post" }
{ "index":  { "_index": "website"}}
{ "title":    "My second blog post" }
{ "update": { "_index": "website",  "_id": "123"} }
{ "doc" : {"title" : "My updated blog post"} }
1
2
3
4
5
6
7
8

这种格式类似一个有效的单行 JSON 文档流，它通过换行符(\n)连接到一起。注意两个要点：

每行一定要以换行符(\n)结尾，包括最后一行。这些换行符被用作一个标记，可以有效分隔行。
这些行不能包含未转义的换行符，因为他们将会对解析造成干扰。这意味着这个 JSON 不能使用 pretty 参数打印。

这个 Elasticsearch 响应包含 items 数组，这个数组的内容是以请求的顺序列出来的每个请求的结果。

{
  "took": 93,
  "errors": false,
  "items": [
    {
      "delete": {
        "_index": "website",
        "_id": "2",
        "_version": 3,
        "result": "deleted",
        "_shards": {
          "total": 2,
          "successful": 1,
          "failed": 0
        },
        "_seq_no": 35,
        "_primary_term": 2,
        "status": 200
      }
    },
    {
      "create": {
        "_index": "website",
        "_id": "2",
        "_version": 4,
        "result": "created",
        "_shards": {
          "total": 2,
          "successful": 1,
          "failed": 0
        },
        "_seq_no": 36,
        "_primary_term": 2,
        "status": 201
      }
    },
    {
      "index": {
        "_index": "website",
        "_id": "L2ppV4UBxaYKjqkGJim4",
        "_version": 1,
        "result": "created",
        "_shards": {
          "total": 2,
          "successful": 1,
          "failed": 0
        },
        "_seq_no": 37,
        "_primary_term": 2,
        "status": 201
      }
    },
    {
      "update": {
        "_index": "website",
        "_id": "123",
        "_version": 4,
        "result": "noop",
        "_shards": {
          "total": 2,
          "successful": 1,
          "failed": 0
        },
        "_seq_no": 34,
        "_primary_term": 2,
        "status": 200
      }
    }
  ]
}
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

每个子请求都是独立执行，因此某个子请求的失败不会对其他子请求的成功与否造成影响。如果其中任何子请求失败，最顶层的 error 标志被设置为 true ，并且在相应的请求报告出错误明细。
这也意味着 bulk 请求不是原子的：不能用它来实现事务控制。每个请求是单独处理的，因此一个请求的成功或失败不会影响其他的请求。

15.路由一个文档到一个分片中

当索引一个文档的时候，文档会被存储到一个主分片中。 Elasticsearch 如何知道一个文档应该存放到哪个分片中呢？当我们创建文档时，它如何决定这个文档应当被存储在分片 1 还是分片 2 中呢？

首先这肯定不会是随机的，否则将来要获取文档的时候我们就不知道从何处寻找了。实际上，这个过程是根据下面这个公式决定的：

shard = hash(routing) % number_of_primary_shards
1

routing 是一个可变值，默认是文档的 _id ，也可以设置成一个自定义的值。 routing 通过 hash 函数生成一个数字，然后这个数字再除以 number_of_primary_shards （主分片的数量）后得到余数。这个分布在 0 到 number_of_primary_shards-1 之间的余数，就是我们所寻求的文档所在分片的位置。

这就解释了为什么我们要在创建索引的时候就确定好主分片的数量并且永远不会改变这个数量：因为如果数量变化了，那么所有之前路由的值都会无效，文档也再也找不到了。

16.空搜索

搜索API的最基础的形式是没有指定任何查询的空搜索，它简单地返回集群中所有索引下的所有文档：

GET /_search
1

17.多索引，多类型

我们可以通过在URL中指定特殊的索引和类型达到这种效果，如下所示：

/_search
在所有的索引中搜索所有的类型
/gb/_search
在 gb 索引中搜索所有的类型
/gb,us/_search
在 gb 和 us 索引中搜索所有的文档
/g*,u*/_search
在任何以 g 或者 u 开头的索引中搜索所有的类型
/gb/user/_search
//在 gb 索引中搜索 user 类型  5.0版本后不支持
/gb,us/user,tweet/_search   
在 gb 和 us 索引中搜索 user 和 tweet 类型   // 5.0版本后不支持
/_all/user,tweet/_search   // 5.0版本后不支持
在所有的索引中搜索 user 和 tweet 类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14

18.分页

size显示应该返回的结果数量，默认是 10
from显示应该跳过的初始结果数量，默认是 0
如果每页展示 5 条结果，可以用下面方式请求得到 1 到 3 页的结果：

GET /_search?size=5
GET /_search?size=5&from=10
GET /_search?size=10&from=15
1
2
3

19.轻量搜索

查询在所有类型中 Sponsor 字段包含李四单词的所有文档：

GET/_all/_search?q=Sponsor:李四
1

_all 字段

这个简单搜索返回包含 mary 的所有文档：

GET /_search?q=mary
1

之前的例子中，我们在 tweet 和 name 字段中搜索内容。然而，这个查询的结果在三个地方提到了 mary ：

有一个用户叫做 Mary
6条微博发自 Mary
一条微博直接 @mary
Elasticsearch 是如何在三个不同的字段中查找到结果的呢？

当索引一个文档的时候，Elasticsearch 取出所有字段的值拼接成一个大的字符串，作为 _all 字段进行索引。例如，当索引这个文档时：

{
    "tweet":    "However did I manage before Elasticsearch?",
    "date":     "2014-09-14",
    "name":     "Mary Jones",
    "user_id":  1
}
1
2
3
4
5
6

这就好似增加了一个名叫 _all 的额外字段：

"However did I manage before Elasticsearch? 2014-09-14 Mary Jones 1"
1

除非设置特定字段，否则查询字符串就使用 _all 字段进行搜索。

在刚开始开发一个应用时，_all 字段是一个很实用的特性。之后，你会发现如果搜索时用指定字段来代替 _all 字段，将会更好控制搜索结果。当 _all 字段不再有用的时候，可以将它置为失效，正如在元数据: _all 字段中所解释的。

精确值 VS 全文

Elasticsearch 中的数据可以概括的

参考：ES文档。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/792772

elasticsearch-8.5.2快速入门和kibana-8.5.2的使用_elasticsearch8 kibana

一、 安装

二、 启动Elasticsearch。

三、 启动kibana。

三、 Elasticsearch的基本使用。

1.创建文档。

2.查询刚刚创建的文档。

3.使用查询表达式搜索

4.全文搜索

5.短语搜索

6.高亮搜索

7.数据聚合分析

四、 Elasticsearch集群。

1.了解集群。

2.集群健康。

3.添加索引。

4.水平扩容

5.Autogenerating IDs

6.文档的取回

7.检查文档是否存在

8.更新整个文档

9.创建新文档

10. 删除文档

11.乐观并发控制

12.文档的部分更新

13.取回多个文档

14.批量增删改。

15.路由一个文档到一个分片中

16.空搜索

17.多索引，多类型

18.分页

19.轻量 搜索

_all 字段

精确值 VS 全文

一、安装

二、启动Elasticsearch。

三、启动kibana。

19.轻量搜索