ElasticSearch入门【基本概念，安装，常用操作】

最新推荐文章于 2022-09-13 17:22:09 发布

专注网赚的程序员

最新推荐文章于 2022-09-13 17:22:09 发布

阅读量258

点赞数

分类专栏： ElasticSearch 文章标签： ElasticSearch

本文链接：https://blog.csdn.net/wangpengzhi19891223/article/details/80690527

版权

ElasticSearch 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

ElasticSearch是目前全文搜索的最佳选择，底层基于Lucene。

基本概念

Elasticsearch有几个核心概念。从一开始理解这些概念会对整个学习过程有莫大的帮助。
- 接近实时（NRT）
Elasticsearch是一个接近实时的搜索平台。这意味着，从索引一个文档直到这个文档能够被搜索到有一个轻微的延迟（通常是1秒）。
- 集群（cluster）
一个集群就是由一个或多个节点组织在一起，它们共同持有你整个的数据，并一起提供索引和搜索功能。一个集群由一个唯一的名字标识，这个名字默认就是“elasticsearch”。这个名字是重要的，因为一个节点只能通过指定某个集群的名字，来加入这个集群。在产品环境中显式地设定这个名字是一个好习惯，但是使用默认值来进行测试/开发也是不错的。
- 节点（node）
一个节点是你集群中的一个服务器，作为集群的一部分，它存储你的数据，参与集群的索引和搜索功能。和集群类似，一个节点也是由一个名字来标识的，默认情况下，这个名字是一个随机的漫威漫画角色的名字，这个名字会在启动的时候赋予节点。这个名字对于管理工作来说挺重要的，因为在这个管理过程中，你会去确定网络中的哪些服务器对应于Elasticsearch集群中的哪些节点。
一个节点可以通过配置集群名称的方式来加入一个指定的集群。默认情况下，每个节点都会被安排加入到一个叫做“elasticsearch”的集群中，这意味着，如果你在你的网络中启动了若干个节点，并假定它们能够相互发现彼此，它们将会自动地形成并加入到一个叫做“elasticsearch”的集群中。
在一个集群里，只要你想，可以拥有任意多个节点。而且，如果当前你的网络中没有运行任何Elasticsearch节点，这时启动一个节点，会默认创建并加入一个叫做“elasticsearch”的集群。

索引（index）
一个索引就是一个拥有几分相似特征的文档的集合。比如说，你可以有一个客户数据的索引，另一个产品目录的索引，还有一个订单数据的索引。一个索引由一个名字来标识（必须全部是小写字母的），并且当我们要对对应于这个索引中的文档进行索引、搜索、更新和删除的时候，都要使用到这个名字。
在一个集群中，如果你想，可以定义任意多的索引。
类型（type）
在一个索引中，你可以定义一种或多种类型。一个类型是你的索引的一个逻辑上的分类/分区，其语义完全由你来定。通常，会为具有一组共同字段的文档定义一个类型。比如说，我们假设你运营一个博客平台并且将你所有的数据存储到一个索引中。在这个索引中，你可以为用户数据定义一个类型，为博客数据定义另一个类型，当然，也可以为评论数据定义另一个类型。
文档（document）
一个文档是一个可被索引的基础信息单元。比如，你可以拥有某一个客户的文档，某一个产品的一个文档，当然，也可以拥有某个订单的一个文档。文档以JSON（Javascript Object Notation）格式来表示，而JSON是一个到处存在的互联网数据交互格式。
在一个index/type里面，只要你想，你可以存储任意多的文档。注意，尽管一个文档，物理上存在于一个索引之中，文档必须被索引/赋予一个索引的type。
分片和复制（shards & replicas）
一个索引可以存储超出单个结点硬件限制的大量数据。比如，一个具有10亿文档的索引占据1TB的磁盘空间，而任一节点都没有这样大的磁盘空间；或者单个节点处理搜索请求，响应太慢。
为了解决这个问题，Elasticsearch提供了将索引划分成多份的能力，这些份就叫做分片。当你创建一个索引的时候，你可以指定你想要的分片的数量。每个分片本身也是一个功能完善并且独立的“索引”，这个“索引”可以被放置到集群中的任何节点上。
分片之所以重要，主要有两方面的原因
- 允许你水平分割/扩展你的内容容量
- 允许你在分片（潜在地，位于多个节点上）之上进行分布式的、并行的操作，进而提高性能/吞吐量
至于一个分片怎样分布，它的文档怎样聚合回搜索请求，是完全由Elasticsearch管理的，对于作为用户的你来说，这些都是透明的。
在一个网络/云的环境里，失败随时都可能发生，在某个分片/节点不知怎么的就处于离线状态，或者由于任何原因消失了，这种情况下，有一个故障转移机制是非常有用并且是强烈推荐的。为此目的，Elasticsearch允许你创建分片的一份或多份拷贝，这些拷贝叫做复制分片，或者直接叫复制。
复制之所以重要，有两个主要原因：
- 在分片/节点失败的情况下，提供了高可用性。因为这个原因，注意到复制分片从不与原/主要（original/primary）分片置于同一节点上是非常重要的。
- 扩展你的搜索量/吞吐量，因为搜索可以在所有的复制上并行运行
总之，每个索引可以被分成多个分片。一个索引也可以被复制0次（意思是没有复制）或多次。一旦复制了，每个索引就有了主分片（作为复制源的原来的分片）和复制分片（主分片的拷贝）之别。分片和复制的数量可以在索引创建的时候指定。在索引创建之后，你可以在任何时候动态地改变复制的数量，但是你事后不能改变分片的数量。
默认情况下，Elasticsearch中的每个索引被分片5个主分片和1个复制，这意味着，如果你的集群中至少有两个节点，你的索引将会有5个主分片和另外5个复制分片（1个完全拷贝），这样的话每个索引总共就有10个分片。

安装

ES的安装依赖于java8

wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-5.5.1.zip

启动

cd elasticsearch-5.5.1
./elasticsearch

遇到错误：

Java HotSpot(TM) 64-Bit Server VM warning: INFO: os::commit_memory(0x0000000085330000, 2060255232, 0) failed; error='Cannot allocate memory' (errno=12)
#
# There is insufficient memory for the Java Runtime Environment to continue.
# Native memory allocation (mmap) failed to map 2060255232 bytes for committing reserved memory.
# An error report file with more information is saved as:
# /home/wangpengzhi/elasticsearch-5.5.1/bin/hs_err_pid2744.log

这个是本地虚拟机内存不够，在虚拟机设置中，增加内存大小即可，或者重试重启虚拟机。

增加内存为2G后启动【你的不一定要这么多】
es5.5提高了安全级别，不能使用Root用户启动，在root和自建用户（开机用户即可，不用新建）之间切换。
正常启动之后如图：
如果一切正常，Elastic 就会在默认的9200端口运行。这时，打开另一个命令行窗口，请求该端口

curl localhost:9200

会得到类似输出如下

{
  "name" : "6ctia-o",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "XGpn6R8RRUmrmsN1RwtwHg",
  "version" : {
    "number" : "5.5.1",
    "build_hash" : "19c13d0",
    "build_date" : "2017-07-18T20:44:24.823Z",
    "build_snapshot" : false,
    "lucene_version" : "6.6.0"
  },
  "tagline" : "You Know, for Search"
}

直到这里，ES就完全安装完了。

基础操作

查看集群是否运作正常

   curl 'localhost:9200/_cat/health?v'

输出

epoch      timestamp cluster       status node.total node.data shards pri relo init unassign pending_tasks max_task_wait_time active_shards_percent
1528938937 18:15:37  elasticsearch green           1         1      0   0    0    0        0             0                  -                100.0%

其中green代表完全正常，黄色意味着所有的数据都是可用的，但是某些复制没有被分配（集群功能齐全），红色则代表因为某些原因，某些数据不可用。注意，即使是集群状态是红色的，集群仍然是部分可用的（它仍然会利用可用的分片来响应搜索请求），但是可能你需要尽快修复它，因为你有丢失的数据。
也是从上面的响应中，我们可以看到，一共有一个节点，由于里面没有数据，我们有0个分片。注意，由于我们使用默认的集群名字（elasticsearch），并且由于Elasticsearch默认使用网络多播（multicast）发现其它节点，如果你在你的网络中启动了多个节点，你就已经把她们加入到一个集群中了。在这种情形下，你可能在上面的响应中看到多个节点。

获取集群中的节点列表

 curl 'localhost:9200/_cat/nodes?v'

输出

ip        heap.percent ram.percent cpu load_1m load_5m load_15m node.role master name
127.0.0.1            3          97   1    0.03    0.35     0.36 mdi       *      6ctia-o

可以看出只有一个节点。

列出所有的索引

curl 'localhost:9200/_cat/indices?v'

输出

 health index pri rep docs.count docs.deleted store.size pri.store.size

这可以看出，我们还没有建立任何索引。

索引创建

现在让我们创建一个叫做“customer”的索引，然后再列出所有的索引：

curl -XPUT 'localhost:9200/customer?pretty'
curl 'localhost:9200/_cat/indices?v'

输出：

{
  "acknowledged" : true,
  "shards_acknowledged" : true
}

“acknowledged” : true 证明索引创建成功。

health status index    uuid                   pri rep docs.count docs.deleted store.size pri.store.size
yellow open   customer UdPCkDfrSiWT441ueUg4WQ   5   1          0            0       324b           324b

可以看出目前只有一个索引。

索引一个文档

curl -XPUT 'localhost:9200/customer/external/1?pretty' -d '
        {
          "name": "John Doe"
        }'

解释：

文档索引到customer  
类型是：external
ID是：1

输出如下：

{
  "_index" : "customer",
  "_type" : "external",
  "_id" : "1",
  "_version" : 1,
  "result" : "created",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "created" : true
}

查询刚刚创建的文档

curl -XGET 'localhost:9200/customer/external/1?pretty'

输出：

{
  "_index" : "customer",
  "_type" : "external",
  "_id" : "1",
  "_version" : 1,
  "found" : true,
  "_source" : {
    "name" : "John Doe"
  }
}

删除一个索引
删除一个索引【customer】

   curl -XDELETE 'localhost:9200/customer?pretty'

输出：

{
  "acknowledged" : true
}

删除成功：

验证：查看所有索引。

 curl 'localhost:9200/_cat/indices?v'

输出同上面，无任何索引。

health status index uuid pri rep docs.count docs.deleted store.size pri.store.size

如果我们仔细研究以上的命令，我们可以发现访问Elasticsearch中数据的一个模式。这个模式可以被总结为：

     curl -<REST Verb> <Node>:<Port>/<Index>/<Type><ID>

这个REST访问模式普遍适用于所有的API命令，如果你能记住它，你就会为掌握Elasticsearch开一个好头。

修改文档数据
Es通过覆盖的方式修改数据：
插入一条数据：

  curl -XPUT 'localhost:9200/customer/external/1?pretty' -d '
            {
              "name": "John Doe"
            }'

通过覆盖修改

  curl -XPUT 'localhost:9200/customer/external/1?pretty' -d '
            {
              "name": "Jane Doe"
            }'

输出：

{
  "_index" : "customer",
  "_type" : "external",
  "_id" : "1",
  "_version" : 5,
  "result" : "updated",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "created" : false
}

查看刚刚的修改结果：

curl -XPOST 'localhost:9200/customer/external?pretty' -d '
            {
              "name": "Jane Doe"
            }'

这种方式不用使用ID属性，值得注意的是，用的是XPOST方式。

更新文档
除了可以索引、替换文档之外，我们也可以更新一个文档。但要注意，Elasticsearch底层并不支持原地更新。在我们想要做一次更新的时候，Elasticsearch先删除旧文档，然后在索引一个更新过的新文档。
下面的例子展示了怎样将我们ID为1的文档的name字段改成“Jane Doe”：

  curl -XPOST 'localhost:9200/customer/external/1/_update?pretty' -d '
        {
          "doc": { "name": "Jane Doe" }
        }'

下面的例子展示了怎样将我们ID为1的文档的name字段改成“Jane Doe”的同时，给它加上age字段：

     curl -XPOST 'localhost:9200/customer/external/1/_update?pretty' -d '
        {
          "doc": { "name": "Jane Doe", "age": 20 }
        }'

更新也可以通过使用简单的脚本来进行。这个例子使用一个脚本将age加5：

      curl -XPOST 'localhost:9200/customer/external/1/_update?pretty' -d '
        {
          "script" : "ctx._source.age += 5"
        }'

删除文档
删除文档是相当直观的。以下的例子展示了我们怎样删除ID为2的文档

curl -XDELETE 'localhost:9200/customer/external/2?pretty'

我们也能够一次删除符合某个查询条件的多个文档。以下的例子展示了如何删除名字中包含“John”的所有的客户：

    curl -XDELETE 'localhost:9200/customer/external/_query?pretty' -d '
        {
          "query": { "match": { "name": "John" } }
        }'

批处理
除了能够对单个的文档进行索引、更新和删除之外，Elasticsearch也提供了以上操作的批量处理功能，这是通过使用_bulk API实现的。这个功能之所以重要，在于它提供了非常高效的机制来尽可能快的完成多个操作，与此同时使用尽可能少的网络往返。
作为一个快速的例子，以下调用在一次bulk操作中索引了两个文档（ID 1 - John Doe and ID 2 - Jane Doe）:

curl -XPOST 'localhost:9200/customer/external/_bulk?pretty' -d '
        {"index":{"_id":"1"}}
        {"name": "John Doe" }
        {"index":{"_id":"2"}}
        {"name": "Jane Doe" }'

以下例子在一个bulk操作中，首先更新第一个文档（ID为1），然后删除第二个文档（ID为2）：

 curl -XPOST 'localhost:9200/customer/external/_bulk?pretty' -d '
        {"update":{"_id":"1"}}
        {"doc": { "name": "John Doe becomes Jane Doe" } }
        {"delete":{"_id":"2"}}'

实战之加载文档数据
从https://github.com/bly2k/files/blob/master/accounts.zip?raw=true 下载文档，解压后放在任意目录下。
执行：

curl -XPOST 'localhost:9200/bank/account/_bulk?pretty' --data-binary @accounts.json
curl 'localhost:9200/_cat/indices?v'

加载到集群中。

输出：

wangpengzhi@ubuntu:~$  curl 'localhost:9200/_cat/indices?v'
health status index    uuid                   pri rep docs.count docs.deleted store.size pri.store.size
yellow open   bank     jVi1NHmVS_agTQKd51qctQ   5   1       1000            0    656.9kb        656.9kb
yellow open   customer mMzX2OIiStyhOLcoYQDraQ   5   1          4            0     17.6kb         17.6kb

看第一个索引，意味着加载了1000个索引到ES中了。

检索

返回索引为bank的所有文档：

 curl 'localhost:9200/bank/_search?q=*&pretty'

或者：

  curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
            {
              "query": { "match_all": {} }
            }'

Elasticsearch提供一种JSON风格的特定领域语言，利用它你可以执行查询。这杯称为查询DSL。这个查询语言相当全面，类似于mongodb的查询方式。

对上面的查询做修改，除了这个query参数之外，我们也可以通过传递其它的参数来影响搜索结果。比如，下面做了一次match_all并只返回第一个文档：

     curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": { "match_all": {} },
          "size": 1
        }'

注意，如果没有指定size的值，那么它默认就是10。

返回特定区间数据

     curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": { "match_all": {} },
          "from": 10,
          "size": 10
        }'

结果集排序

    curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": { "match_all": {} },
          "sort": { "balance": { "order": "desc" } }
        }'

返回指定字段：

     curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": { "match_all": {} },
          "_source": ["account_number", "balance"]
        }'

返回固定查询结果：where account_number = 20

    curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": { "match": { "account_number": 20 } }
        }'

must组合查询 or where address = “mill” and address = “lane”

curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": {
            "bool": {
              "must": [
                { "match": { "address": "mill" } },
                { "match": { "address": "lane" } }
              ]
            }
          }
        }'

should组合查询 or where address = “mill” or address = “lane”

    curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": {
            "bool": {
              "should": [
                { "match": { "address": "mill" } },
                { "match": { "address": "lane" } }
              ]
            }
          }
        }'

must_not组合查询 not in where address != “mill” and address != “lane”

     curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": {
            "bool": {
              "must_not": [
                { "match": { "address": "mill" } },
                { "match": { "address": "lane" } }
              ]
            }
          }
        }'

must 与 must not组合使用

     curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": {
            "bool": {
              "must": [
                { "match": { "age": "40" } }
              ],
              "must_not": [
                { "match": { "state": "ID" } }
              ]
            }
          }
        }'

以下内容5.0以上不适用。

执行过滤器：返回一个范围数据
这个例子使用一个被过滤的查询，其返回值是越在20000到30000之间（闭区间）的账户。换句话说，我们想要找到越大于等于20000并且小于等于30000的账户。

      curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": {
            "filtered": {
              "query": { "match_all": {} },
              "filter": {
                "range": {
                  "balance": {
                    "gte": 20000,
                    "lte": 30000
                  }
                }
              }
            }
          }
        }'

执行聚合：作为开始的一个例子，我们按照state分组，按照州名的计数倒序排序：

     curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "size": 0,
          "aggs": {
            "group_by_state": {
              "terms": {
                "field": "state"
              }
            }
          }
        }'

在先前聚合的基础上，现在这个例子计算了每个州的账户的平均余额（还是按照账户数量倒序排序的前10个州）：

      curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "size": 0,
          "aggs": {
            "group_by_state": {
              "terms": {
                "field": "state"
              },
              "aggs": {
                "average_balance": {
                  "avg": {
                    "field": "balance"
                  }
                }
              }
            }
          }
        }'

基于前面的聚合，现在让我们按照平均余额进行排序：

      curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "size": 0,
          "aggs": {
            "group_by_state": {
              "terms": {
                "field": "state",
                "order": {
                  "average_balance": "desc"
                }
              },
              "aggs": {
                "average_balance": {
                  "avg": {
                    "field": "balance"
                  }
                }
              }
            }
          }
        }'

下面的例子显示了如何使用年龄段（20-29，30-39，40-49）分组，然后在用性别分组，然后为每一个年龄段的每一个性别计算平均账户余额：

    curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "size": 0,
          "aggs": {
            "group_by_age": {
              "range": {
                "field": "age",
                "ranges": [
                  {
                    "from": 20,
                    "to": 30
                  },
                  {
                    "from": 30,
                    "to": 40
                  },
                  {
                    "from": 40,
                    "to": 50
                  }
                ]
              },
              "aggs": {
                "group_by_gender": {
                  "terms": {
                    "field": "gender"
                  },
                  "aggs": {
                    "average_balance": {
                      "avg": {
                        "field": "balance"
                      }
                    }
                  }
                }
              }
            }
          }
        }'