Elasticsearch基础教程

时间 2021-08-13

标签 html java node git github shell json ubuntu 缓存服务器栏目日志分析繁體版

原文原文链接

基础概念html

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个分片。

    这些问题搞清楚以后，咱们就要进入好玩的部分了...

安装java

Elasticsearch依赖Java 7。在本文写做的时候，推荐使用Oracle JDK 1.7.0_55版本。Java的安装，在各个平台上都有差别，因此咱们不想在这里深刻太多细节。我只想说，在你安装Elasticsearch以前，你能够经过如下命令来检查你的Java版本（若是有须要，安装或者升级）：

    java -version
    echo $JAVA_HOME

一旦咱们将Java安装完成，咱们就能够下载并安装Elasticsearch了。其二进制文件能够从www.elasticsearch.org/download这里下载，你也能够从这里下载之前发布的版本。对于每一个版本，你能够在zip、tar、DEB、RPM类型的包中选择下载。简单起见，咱们使用tar包。

咱们像下面同样下载Elasticsearch 1.1.1 tar包（Windows用户应该下载zip包）：

    curl -L -O https://download.elasticsearch.org/elasticsearch/elasticsearch/elasticsearch-1.1.1.tar.gz

而后，以下将其解压（Windows下须要unzip响应的zip包）：

    tar -xzvf elasticsearch-1.1.1.tar.gz

这将在你的当前目录下建立不少文件和目录。而后，咱们进入到bin目录下：

    cd elasticsearch-1.1.1/bin

至此，咱们已经准备好开启咱们的节点和单节点集群（Windows用户应该运行elasticsearch.bat文件）：

    ./elasticsearch

若是一切顺利，你将看到大量的以下信息：

    ./elasticsearch
    [2014-03-13 13:42:17,218][INFO ][node           ] [New Goblin] version[1.1.1], pid[2085], build[5c03844/2014-02-25T15:52:53Z]
    [2014-03-13 13:42:17,219][INFO ][node           ] [New Goblin] initializing ...
    [2014-03-13 13:42:17,223][INFO ][plugins        ] [New Goblin] loaded [], sites []
    [2014-03-13 13:42:19,831][INFO ][node           ] [New Goblin] initialized
    [2014-03-13 13:42:19,832][INFO ][node           ] [New Goblin] starting ...
    [2014-03-13 13:42:19,958][INFO ][transport      ] [New Goblin] bound_address {inet[/0:0:0:0:0:0:0:0:9300]}, publish_address {inet[/192.168.8.112:9300]}
    [2014-03-13 13:42:23,030][INFO ][cluster.service] [New Goblin] new_master [New Goblin][rWMtGj3dQouz2r6ZFL9v4g][mwubuntu1][inet[/192.168.8.112:9300]], reason: zen-disco-join (elected_as_master)
    [2014-03-13 13:42:23,100][INFO ][discovery      ] [New Goblin] elasticsearch/rWMtGj3dQouz2r6ZFL9v4g
    [2014-03-13 13:42:23,125][INFO ][http           ] [New Goblin] bound_address {inet[/0:0:0:0:0:0:0:0:9200]}, publish_address {inet[/192.168.8.112:9200]}
    [2014-03-13 13:42:23,629][INFO ][gateway        ] [New Goblin] recovered [1] indices into cluster_state
    [2014-03-13 13:42:23,630][INFO ][node           ] [New Goblin] started

不去涉及太多细节，咱们能够看到，一叫作“New Goblin”（你会见到一个不一样的漫威漫画角色）的节点启动而且将本身选作单结点集群的master。如今不用关心master是什么东西。这里重要的就是，咱们在一个集群中开启了一个节点。

正如先前提到的，咱们能够覆盖集群或者节点的名字。咱们能够在启动Elasticsearch的时候经过命令行来指定，以下：

    ./elasticsearch --cluster.name my_cluster_name --node.name my_node_name

也要注意一下有http标记的那一行，它提供了有关HTTP地址（192.168.8.112）和端口（9200）的信息，经过这个地址和端口咱们就能够访问咱们的节点了。默认状况下，Elasticsearch使用9200来提供对其REST API的访问。若是有必要，这个端口是能够配置的。

探索你的集群node

rest接口

    如今咱们已经有一个正常运行的节点（和集群）了，下一步就是要去理解怎样与其通讯了。幸运的是，Elasticsearch提供了很是全面和强大的REST API，利用这个REST API你能够同你的集×××互。下面是利用这个API，能够作的几件事情：

        - 检查你的集群、节点和索引的健康状态、和各类统计信息
        - 管理你的集群、节点、索引数据和元数据
        - 对你的索引进行CRUD（建立、读取、更新和删除）和搜索操做
        - 执行高级的查询操做，像是分页、排序、过滤、脚本编写（scripting）、小平面刻画（faceting）、聚合（aggregations）和许多其它操做

集群健康

    让咱们以基本的健康检查做为开始，咱们能够利用它来查看咱们集群的状态。此过程当中，咱们使用curl，固然，你也可使用任何能够建立HTTP/REST调用的工具。咱们假设咱们还在咱们启动Elasticsearch的节点上并打开另一个shell窗口。

    要检查集群健康，咱们将使用_cat API。须要事先记住的是，咱们的节点HTTP的端口是9200：

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

    相应的响应是：

        epoch      timestamp cluster       status node.total node.data shards pri relo init unassign
        1394735289 14:28:09  elasticsearch green           1         1      0   0    0    0        0

    能够看到，咱们集群的名字是“elasticsearch”，正常运行，而且状态是绿色。

    当咱们询问集群状态的时候，咱们要么获得绿色、×××或红色。绿色表明一切正常（集群功能齐全），×××意味着全部的数据都是可用的，可是某些复制没有被分配（集群功能齐全），红色则表明由于某些缘由，某些数据不可用。注意，即便是集群状态是红色的，集群仍然是部分可用的（它仍然会利用可用的分片来响应搜索请求），可是可能你须要尽快修复它，由于你有丢失的数据。

    也是从上面的响应中，咱们能够看到，一共有一个节点，因为里面没有数据，咱们有0个分片。注意，因为咱们使用默认的集群名字（elasticsearch），而且因为Elasticsearch默认使用网络多播（multicast）发现其它节点，若是你在你的网络中启动了多个节点，你就已经把她们加入到一个集群中了。在这种情形下，你可能在上面的响应中看到多个节点。

    咱们也能够得到节集群中的节点列表：

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

    对应的响应是:

        curl 'localhost:9200/_cat/nodes?v'
        host         ip        heap.percent ram.percent load node.role master name
        mwubuntu1    127.0.1.1            8           4 0.00 d         *      New Goblin

    这儿，咱们能够看到咱们叫作“New Goblin”的节点，这个节点是咱们集群中的惟一节点。

列出全部的索引
    让咱们看一下咱们的索引：

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

    响应是：

        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'

    第一个命令使用PUT建立了一个叫作“customer”的索引。咱们简单地将pretty附加到调用的尾部，使其以美观的形式打印出JSON响应（若是有的话）。
    响应以下：

        curl -XPUT 'localhost:9200/customer?pretty'
        {
          "acknowledged" : true
        }

        curl 'localhost:9200/_cat/indices?v'
        health index    pri rep docs.count docs.deleted store.size pri.store.size
        yellow customer   5   1          0            0       495b           495b

    第二个命令的结果告知咱们，咱们如今有一个叫作customer的索引，而且它有5个主分片和1份复制（都是默认值），其中包含0个文档。

    你可能也注意到了这个customer索引有一个×××健康标签。回顾咱们以前的讨论，×××意味着某些复制没有（或者还未）被分配。这个索引之因此这样，是由于Elasticsearch默认为这个索引建立一份复制。因为如今咱们只有一个节点在运行，那一份复制就分配不了了（为了高可用），直到当另一个节点加入到这个集群后，才能分配。一旦那份复制在第二个节点上被复制，这个节点的健康状态就会变成绿色。

索引并查询一个文档
如今让咱们放一些东西到customer索引中。首先要知道的是，为了索引一个文档，咱们必须告诉Elasticsearch这个文档要到这个索引的哪一个类型（type）下。git

让咱们将一个简单的客户文档索引到customer索引、“external”类型中，这个文档的ID是1，操做以下：

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

响应以下：

    curl -XPUT 'localhost:9200/customer/external/1?pretty' -d '
    {
      "name": "John Doe"
    }'
    {
      "_index" : "customer",
      "_type" : "external",
      "_id" : "1",
      "_version" : 1,
      "created" : true
    }

从上面的响应中，咱们能够看到，一个新的客户文档在customer索引和external类型中被成功建立。文档也有一个内部id 1， 这个id是咱们在索引的时候指定的。

有一个关键点须要注意，Elasticsearch在你想将文档索引到某个索引的时候，并不强制要求这个索引被显式地建立。在前面这个例子中，若是customer索引不存在，Elasticsearch将会自动地建立这个索引。

如今，让咱们把刚刚索引的文档取出来：

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

响应以下：

    curl -XGET 'localhost:9200/customer/external/1?pretty'
    {
      "_index" : "customer",
      "_type" : "external",
      "_id" : "1",
      "_version" : 1,
      "found" : true, "_source" : { "name": "John Doe" }
    }

除了一个叫作found的字段来指明咱们找到了一个ID为1的文档，和另一个字段——_source——返回咱们前一步中索引的完整JSON文档以外，其它的都没有什么特别之处。

删除一个文档github

如今让咱们删除咱们刚刚建立的索引，并再次列出全部的索引：

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

响应以下：

    curl -XDELETE 'localhost:9200/customer?pretty'
    {
      "acknowledged" : true
    }
    curl 'localhost:9200/_cat/indices?v'
    health index pri rep docs.count docs.deleted store.size pri.store.size

这代表咱们成功地删除了这个索引，如今咱们回到了集群中空无全部的状态。

在更进一步以前，咱们再细看一下一些咱们学过的API命令：

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

若是咱们仔细研究以上的命令，咱们能够发现访问Elasticsearch中数据的一个模式。这个模式能够被总结为：

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

这个REST访问模式广泛适用于全部的API命令，若是你能记住它，你就会为掌握Elasticsearch开一个好头。

修改你的数据shell

Elasticsearch提供了近乎实时的数据操做和搜索功能。默认状况下，从你索引/更新/删除你的数据动做开始到它出如今你的搜索结果中，大概会有1秒钟的延迟。这和其它相似SQL的平台不一样，数据在一个事务完成以后就会当即可用。

索引/替换文档

    咱们先前看到，怎样索引一个文档。如今咱们再次调用那个命令：
        curl -XPUT 'localhost:9200/customer/external/1?pretty' -d '
        {
          "name": "John Doe"
        }'

    再次，以上的命令将会把这个文档索引到customer索引、external类型中，其ID是1。若是咱们对一个不一样（或相同）的文档应用以上的命令，Elasticsearch将会用一个新的文档来替换（从新索引）当前ID为1的那个文档。

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

    以上的命令将ID为1的文档的name字段的值从“John Doe”改为了“Jane Doe”。若是咱们使用一个不一样的ID，一个新的文档将会被索引，当前已经在索引中的文档不会受到影响。

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

    以上的命令，将会索引一个ID为2的新文档。

    在索引的时候，ID部分是可选的。若是不指定，Elasticsearch将产生一个随机的ID来索引这个文档。Elasticsearch生成的ID会做为索引API调用的一部分被返回。

    如下的例子展现了怎样在没有指定ID的状况下来索引一个文档：

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

    注意，在上面的情形中，因为咱们没有指定一个ID，咱们使用的是POST而不是PUT。

更新文档json

除了能够索引、替换文档以外，咱们也能够更新一个文档。但要注意，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"
    }'

在上面的例子中，ctx._source指向当前要被更新的文档。

注意，在写做本文时，更新操做只能一次应用在一个文档上。未来，Elasticsearch将提供同时更新符合指定查询条件的多个文档的功能（相似于SQL的UPDATE-WHERE语句）。

删除文档ubuntu

删除文档是至关直观的。如下的例子展现了咱们怎样删除ID为2的文档：

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

咱们也可以一次删除符合某个查询条件的多个文档。如下的例子展现了如何删除名字中包含“John”的全部的客户：

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

注意，以上的URI变成了/_query，以此来代表这是一个“查询删除”API，其中删除查询标准放在请求体中，可是咱们仍然使用DELETE。如今先不要担忧查询语法，咱们将会在本教程后面的部分中涉及。

批处理：缓存

除了可以对单个的文档进行索引、更新和删除以外，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"}}
    '

注意上面的delete动做，因为删除动做只须要被删除文档的ID，因此并无对应的源文档。

bulk API按顺序执行这些动做。若是其中一个动做由于某些缘由失败了，将会继续处理它后面的动做。当bulk API返回时，它将提供每一个动做的状态（按照一样的顺序），因此你可以看到某个动做成功与否。

探索你的数据服务器

样本数据集
    如今咱们对于基本的东西已经有了一些感受，如今让咱们尝试使用一些更加贴近现实的数据集。我已经准备了一些假想的客户的银行帐户信息的JSON文档的样本。文档具备如下的模式（schema）：

        {
            "account_number": 0,
            "balance": 16623,
            "firstname": "Bradshaw",
            "lastname": "Mckenzie",
            "age": 29,
            "gender": "F",
            "address": "244 Columbus Place",
            "employer": "Euron",
            "email": "bradshawmckenzie@euron.com",
            "city": "Hobucken",
            "state": "CO"
        }

    我是在http://www.json-generator.com/上生成这些数据的。

载入样本数据

    你能够从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'

    响应是：
        curl 'localhost:9200/_cat/indices?v'
        health index pri rep docs.count docs.deleted store.size pri.store.size
        yellow bank    5   1       1000            0    424.4kb        424.4kb

    这意味着咱们成功批量索引了1000个文档到银行索引中（account类型）。

搜索API

    如今，让咱们以一些简单的搜索来开始。有两种基本的方式来运行搜索：一种是在REST请求的URI中发送搜索参数，另外一种是将搜索参数发送到REST请求体中。请求体方法的表达能力更好，而且你可使用更加可读的JSON格式来定义搜索。咱们将尝试使用一次请求URI做为例子，可是教程的后面部分，咱们将仅仅使用请求体方法。

    搜索的REST　API能够经过_search端点来访问。下面这个例子返回bank索引中的全部的文档：

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

    咱们仔细研究一下这个查询调用。咱们在bank索引中搜索（_search端点），而且q=*参数指示Elasticsearch去匹配这个索引中全部的文档。pretty参数，和之前同样，仅仅是告诉Elasticsearch返回美观的JSON结果。

    如下是响应（部分列出）：

        curl 'localhost:9200/bank/_search?q=*&pretty'
        {
          "took" : 63,
          "timed_out" : false,
          "_shards" : {
            "total" : 5,
            "successful" : 5,
            "failed" : 0
          },
          "hits" : {
            "total" : 1000,
            "max_score" : 1.0,
            "hits" : [ {
              "_index" : "bank",
              "_type" : "account",
              "_id" : "1",
              "_score" : 1.0, "_source" : {"account_number":1,"balance":39225,"firstname":"Amber","lastname":"Duke","age":32,"gender":"M","address":"880 Holmes Lane","employer":"Pyrami","email":"amberduke@pyrami.com","city":"Brogan","state":"IL"}
            }, {
              "_index" : "bank",
              "_type" : "account",
              "_id" : "6",
              "_score" : 1.0, "_source" : {"account_number":6,"balance":5686,"firstname":"Hattie","lastname":"Bond","age":36,"gender":"M","address":"671 Bristol Street","employer":"Netagy","email":"hattiebond@netagy.com","city":"Dante","state":"TN"}
            }, {
              "_index" : "bank",
              "_type" : "account",

    对于这个响应，咱们看到了如下的部分：
      - took —— Elasticsearch执行这个搜索的耗时，以毫秒为单位
      - timed_out —— 指明这个搜索是否超时
      - _shards —— 指出多少个分片被搜索了，同时也指出了成功/失败的被搜索的shards的数量
      - hits —— 搜索结果
      - hits.total —— 可以匹配咱们查询标准的文档的总数目
      - hits.hits —— 真正的搜索结果数据（默认只显示前10个文档）
      - _score和max_score —— 如今先忽略这些字段

    使用请求体方法的等价搜索是：

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

    这里的不一样之处在于，并非向URI中传递q=*，取而代之的是，咱们在_search API的请求体中POST了一个JSON格式请求体。咱们将在下一部分中讨论这个JSON查询。

    响应是：

        curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": { "match_all": {} }
        }'
        {
          "took" : 26,
          "timed_out" : false,
          "_shards" : {
            "total" : 5,
            "successful" : 5,
            "failed" : 0
          },
          "hits" : {
            "total" : 1000,
            "max_score" : 1.0,
            "hits" : [ {
              "_index" : "bank",
              "_type" : "account",
              "_id" : "1",
              "_score" : 1.0, "_source" : {"account_number":1,"balance":39225,"firstname":"Amber","lastname":"Duke","age":32,"gender":"M","address":"880 Holmes Lane","employer":"Pyrami","email":"amberduke@pyrami.com","city":"Brogan","state":"IL"}
            }, {
              "_index" : "bank",
              "_type" : "account",
              "_id" : "6",
              "_score" : 1.0, "_source" : {"account_number":6,"balance":5686,"firstname":"Hattie","lastname":"Bond","age":36,"gender":"M","address":"671 Bristol Street","employer":"Netagy","email":"hattiebond@netagy.com","city":"Dante","state":"TN"}
            }, {
              "_index" : "bank",
              "_type" : "account",
              "_id" : "13",

    有一点须要重点理解一下，一旦你取回了你的搜索结果，Elasticsearch就完成了使命，它不会维护任何服务器端的资源或者在你的结果中打开游标。这是和其它相似SQL的平台的一个鲜明的对比， 在那些平台上，你能够在前面先获取你查询结果的一部分，而后若是你想获取结果的剩余部分，你必须继续返回服务端去取，这个过程使用一种有状态的服务器端游标技术。

介绍查询语言

Elasticsearch提供一种JSON风格的特定领域语言，利用它你能够执行查询。这杯称为查询DSL。这个查询语言至关全面，第一眼看上去可能有些咄咄逼人，可是最好的学习方法就是以几个基础的例子来开始。

回到咱们上一个例子，咱们执行了这个查询：

    {
      "query": { "match_all": {} }
    }

分解以上的这个查询，其中的query部分告诉我查询的定义，match_all部分就是咱们想要运行的查询的类型。match_all查询，就是简单地查询一个指定索引下的全部的文档。

除了这个query参数以外，咱们也能够经过传递其它的参数来影响搜索结果。好比，下面作了一次match_all并只返回第一个文档：

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

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

下面的例子，作了一次match_all而且返回第11到第20个文档：

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

其中的from参数（0-based）从哪一个文档开始，size参数指明从from参数开始，要返回多少个文档。这个特性对于搜索结果分页来讲很是有帮助。注意，若是不指定from的值，它默认就是0。

下面这个例子作了一次match_all而且以帐户余额降序排序，最后返前十个文档：

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

执行搜索

如今咱们已经知道了几个基本的参数，让咱们进一步发掘查询语言吧。首先咱们看一下返回文档的字段。默认状况下，是返回完整的JSON文档的。这能够经过source来引用（搜索hits中的_sourcei字段）。若是咱们不想返回完整的源文档，咱们能够指定返回的几个字段。

下面这个例子说明了怎样返回两个字段account_number和balance（固然，这两个字段都是指_source中的字段），如下是具体的搜索：

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

注意到上面的例子仅仅是简化了_source字段。它仍将会返回一个叫作_source的字段，可是仅仅包含account_number和balance来年改革字段。

若是你有SQL背景，上述查询在概念上有些像SQL的SELECT FROM。

如今让咱们进入到查询部分。以前，咱们看到了match_all查询是怎样匹配到全部的文档的。如今咱们介绍一种新的查询，叫作match查询，这能够当作是一个简单的字段搜索查询（好比对应于某个或某些特定字段的搜索）。

下面这个例子返回帐户编号为20的文档：

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

下面这个例子返回地址中包含“mill”的全部帐户：

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

下面这个例子返回地址中包含“mill”或者包含“lane”的帐户：

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

下面这个例子是match的变体（match_phrase），它会去匹配短语“mill lane”：

    curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
    {
      "query": { "match_phrase": { "address": "mill lane" } }
    }'

如今，让咱们介绍一下布尔查询。布尔查询容许咱们利用布尔逻辑将较小的查询组合成较大的查询。

如今这个例子组合了两个match查询，这个组合查询返回包含“mill”和“lane”的全部的帐户：

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

在上面的例子中，bool must语句指明了，对于一个文档，全部的查询都必须为真，这个文档才可以匹配成功。

相反的，下面的例子组合了两个match查询，它返回的是地址中包含“mill”或者“lane”的全部的帐户:

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

在上面的例子中，bool should语句指明，对于一个文档，查询列表中，只要有一个查询匹配，那么这个文档就被当作是匹配的。

如今这个例子组合了两个查询，它返回地址中既不包含“mill”，同时也不包含“lane”的全部的帐户信息：

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

在上面的例子中， bool must_not语句指明，对于一个文档，查询列表中的的全部查询都必须都不为真，这个文档才被认为是匹配的。

咱们能够在一个bool查询里一块儿使用must、should、must_not。此外，咱们能够将bool查询放到这样的bool语句中来模拟复杂的、多等级的布尔逻辑。

下面这个例子返回40岁以上而且不生活在ID（daho）的人的帐户：

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

执行过滤器

在先前的章节中，咱们跳过了文档得分的细节（搜索结果中的_score字段）。这个得分是与咱们指定的搜索查询匹配程度的一个相对度量。得分越高，文档越相关，得分越低文档的相关度越低。

Elasticsearch中的全部的查询都会触发相关度得分的计算。对于那些咱们不须要相关度得分的场景下，Elasticsearch以过滤器的形式提供了另外一种查询功能。过滤器在概念上相似于查询，可是它们有很是快的执行速度，这种快的执行速度主要有如下两个缘由

    - 过滤器不会计算相关度的得分，因此它们在计算上更快一些
    - 过滤器能够被缓存到内存中，这使得在重复的搜索查询上，其要比相应的查询快出许多。

为了理解过滤器，咱们先来介绍“被过滤”的查询，这使得你能够将一个查询（像是match_all，match，bool等）和一个过滤器结合起来。做为一个例子，咱们介绍一下范围过滤器，它容许咱们经过一个区间的值来过滤文档。这一般被用在数字和日期的过滤上。

这个例子使用一个被过滤的查询，其返回值是越在20000到30000之间（闭区间）的帐户。换句话说，咱们想要找到越大于等于20000而且小于等于30000的帐户。

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

分解上面的例子，被过滤的查询包含一个match_all查询（查询部分）和一个过滤器（filter部分）。咱们能够在查询部分中放入其余查询，在filter部分放入其它过滤器。在上面的应用场景中，因为全部的在这个范围以内的文档都是平等的（或者说相关度都是同样的），没有一个文档比另外一个文档更相关，因此这个时候使用范围过滤器就很是合适了。

一般状况下，要决定是使用过滤器仍是使用查询，你就须要问本身是否须要相关度得分。若是相关度是不重要的，使用过滤器，不然使用查询。若是你有SQL背景，查询和过滤器在概念上相似于SELECT WHERE语句， although more so for filters than queries。

除了match_all, match, bool,filtered和range查询，还有不少其它类型的查uxn/过滤器，咱们这里不会涉及。因为咱们已经对它们的工做原理有了基本的理解，将其应用到其它类型的查询、过滤器上也不是件难事。

执行聚合

聚合提供了分组并统计数据的能力。理解聚合的最简单的方式是将其粗略地等同为SQL的GROUP BY和SQL聚合函数。在Elasticsearch中，你能够在一个响应中同时返回命中的数据和聚合结果。你可使用简单的API同时运行查询和多个聚合，并以一次返回，这避免了来回的网络通讯，这是很是强大和高效的。

做为开始的一个例子，咱们按照state分组，按照州名的计数倒序排序：

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

在SQL中，上面的聚合在概念上相似于：
   SELECT COUNT(*) from bank GROUP BY state ORDER BY COUNT(*) DESC

响应（其中一部分）是：

"hits" : {
        "total" : 1000,
        "max_score" : 0.0,
        "hits" : [ ]
      },
      "aggregations" : {
        "group_by_state" : {
          "buckets" : [ {
            "key" : "al",
            "doc_count" : 21
          }, {
            "key" : "tx",
            "doc_count" : 17
          }, {
            "key" : "id",
            "doc_count" : 15
          }, {
            "key" : "ma",
            "doc_count" : 15
          }, {
            "key" : "md",
            "doc_count" : 15
          }, {
            "key" : "pa",
            "doc_count" : 15
          }, {
            "key" : "dc",
            "doc_count" : 14
          }, {
            "key" : "me",
            "doc_count" : 14
          }, {
            "key" : "mo",
            "doc_count" : 14
          }, {
            "key" : "nd",
            "doc_count" : 14
          } ]
        }
      }
    }

咱们能够看到AL（abama）有21个帐户，TX有17个帐户，ID（daho）有15个帐户，依此类推。

注意咱们将size设置成0，这样咱们就能够只看到聚合结果了，而不会显示命中的结果。

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

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

注意，咱们把average_balance聚合嵌套在了group_by_state聚合之中。这是全部聚合的一个经常使用模式。你能够任意的聚合之中嵌套聚合，这样你就能够从你的数据中抽取出想要的概述。

基于前面的聚合，如今让咱们按照平均余额进行排序：

    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"
                  }
                }
              }
            }
          }
        }
      }
    }'

有不少关于聚合的细节，咱们没有涉及。若是你想作更进一步的实验，http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations.html是一个很是好的起点。

总结

Elasticsearch既是一个简单的产品，也是一个复杂的产品。咱们如今已经学习到了基础部分，它的一些原理，以及怎样用REST API来作一些工做。我但愿这个教程已经使你对Elasticsearch是什么有了一个更好的理解，跟重要的是，可以激发你继续实验Elasticsearch的其它特性。

1. elasticsearch基础教程
2. Elasticsearch基础教程
3. Elasticsearch 基础入门教程
4. Elasticsearch通关教程（一）：基础入门
5. 最完整的Elasticsearch 基础教程
6. ELK(elasticsearch+kibana+logstash)搜索引擎(二)： elasticsearch基础教程
7. ElasticSearch-基础
8. ElasticSearch基础
9. Elasticsearch基础
10. elasticsearch之基础
更多相关文章...
• Kotlin 基础语法 - Kotlin 教程
• Scala 基础语法 - Scala教程
• Java 8 Stream 教程
• YAML 入门教程