Elasticsearch 快速指南

---

---

Elasticsearch - 基本概念

Elasticsearch 是一个基于 Apache Lucene 的搜索服务器。它由 Shay Banon 开发，于 2010 年发布。现在由 Elasticsearch BV 维护。其最新版本为 7.0.0。

Elasticsearch 是一个实时分布式、开源的全文搜索和分析引擎。它可以通过 RESTful Web 服务接口访问，并使用无模式 JSON（JavaScript 对象表示法）文档来存储数据。它基于 Java 编程语言构建，因此 Elasticsearch 可以在不同的平台上运行。它使用户能够以非常高的速度探索海量数据。

一般特性

Elasticsearch 的一般特性如下：

• Elasticsearch 可扩展到 PB 级结构化和非结构化数据。

• Elasticsearch 可用作 MongoDB 和 RavenDB 等文档存储的替代品。

• Elasticsearch 使用反规范化来提高搜索性能。

• Elasticsearch 是流行的企业搜索引擎之一，目前被许多大型组织使用，例如维基百科、卫报、StackOverflow、GitHub 等。

• Elasticsearch 是一个开源项目，根据 Apache 许可证 2.0 版发布。

关键概念

Elasticsearch 的关键概念如下：

节点 (Node)

它指的是 Elasticsearch 的单个运行实例。单个物理和虚拟服务器可以根据其物理资源（如 RAM、存储和处理能力）容纳多个节点。

集群 (Cluster)

它是一个或多个节点的集合。集群为所有节点提供整个数据的集体索引和搜索功能。

索引 (Index)

它是一组不同类型的文档及其属性的集合。索引还使用分片概念来提高性能。例如，一组文档包含社交网络应用程序的数据。

文档 (Document)

它是以 JSON 格式定义的特定方式排列的一组字段的集合。每个文档属于一个类型，并驻留在一个索引中。每个文档都与一个唯一的标识符（称为 UID）关联。

分片 (Shard)

索引水平地细分为分片。这意味着每个分片包含文档的所有属性，但包含的 JSON 对象数量少于索引。水平分离使分片成为一个独立的节点，可以存储在任何节点中。主分片是索引的原始水平部分，然后这些主分片被复制到副本分片中。

副本 (Replicas)

Elasticsearch 允许用户创建其索引和分片的副本。复制不仅有助于在发生故障时提高数据的可用性，而且还通过在这些副本中执行并行搜索操作来提高搜索性能。

优点

• Elasticsearch 基于 Java 开发，使其几乎兼容所有平台。

• Elasticsearch 是实时的，换句话说，添加的文档在一秒钟后即可在此引擎中搜索到。

• Elasticsearch 是分布式的，这使得它易于扩展并集成到任何大型组织中。

• 使用 Elasticsearch 中存在的网关概念可以轻松创建完整的备份。

• 与 Apache Solr 相比，Elasticsearch 中处理多租户非常容易。

• Elasticsearch 使用 JSON 对象作为响应，这使得可以使用大量不同的编程语言调用 Elasticsearch 服务器。

• Elasticsearch 支持几乎所有类型的文档，除了不支持文本渲染的文档。

缺点

• Elasticsearch 不支持处理请求和响应数据的多种语言（仅限于 JSON），这与 Apache Solr 不同，后者支持 CSV、XML 和 JSON 格式。

• 有时，Elasticsearch 会出现脑裂问题。

Elasticsearch 和 RDBMS 的比较

在 Elasticsearch 中，索引类似于 RDBMS（关系数据库管理系统）中的表。每个表都是行的集合，就像每个索引都是 Elasticsearch 中文档的集合一样。

下表给出了这些术语的直接比较：

Elasticsearch - 安装

在本章中，我们将详细了解 Elasticsearch 的安装过程。

要在本地计算机上安装 Elasticsearch，您需要按照以下步骤操作：

步骤 1 - 检查计算机上安装的 Java 版本。它应该是 Java 7 或更高版本。您可以通过执行以下操作来检查：

在 Windows 操作系统 (OS) 中（使用命令提示符）：

> java -version

在 UNIX OS 中（使用终端）：

$ echo $JAVA_HOME

步骤 2 - 根据您的操作系统，从 www.elastic.co 下载 Elasticsearch，如下所示：

• 对于 Windows OS，下载 ZIP 文件。

• 对于 UNIX OS，下载 TAR 文件。

• 对于 Debian OS，下载 DEB 文件。

• 对于 Red Hat 和其他 Linux 发行版，下载 RPN 文件。

• APT 和 Yum 实用程序也可用于在许多 Linux 发行版中安装 Elasticsearch。

步骤 3 - Elasticsearch 的安装过程很简单，以下是针对不同操作系统的说明：

• Windows OS - 解压缩 zip 包，Elasticsearch 就安装好了。

• UNIX OS - 将 tar 文件解压到任何位置，Elasticsearch 就安装好了。

$wget
https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch7.0.0-linux-x86_64.tar.gz

$tar -xzf elasticsearch-7.0.0-linux-x86_64.tar.gz

• 使用 APT 实用程序安装 Linux OS - 下载并安装公共签名密钥

$ wget -qo - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo
apt-key add -

保存如下所示的存储库定义：

$ echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" |
sudo tee -a /etc/apt/sources.list.d/elastic-7.x.list

使用以下命令运行更新：

$ sudo apt-get update

现在，您可以使用以下命令进行安装：

$ sudo apt-get install elasticsearch

• 使用此处提供的命令手动下载并安装 Debian 包：

$wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch7.0.0-amd64.deb
$sudo dpkg -i elasticsearch-7.0.0-amd64.deb0

• 对于 Debian Linux OS 使用 YUM 实用程序

下载并安装公共签名密钥：

$ rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch

• 将以下文本添加到您“/etc/yum.repos.d/”目录中带有 .repo 后缀的文件中。例如，elasticsearch.repo

elasticsearch-7.x]
name=Elasticsearch repository for 7.x packages
baseurl=https://artifacts.elastic.co/packages/7.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md

• 现在，您可以使用以下命令安装 Elasticsearch

sudo yum install elasticsearch

步骤 4 - 转到 Elasticsearch 主目录和 bin 文件夹内。在 Windows 系统中运行 elasticsearch.bat 文件，或者在 UNIX 系统中使用命令提示符和终端执行相同的操作来运行 Elasticsearch 文件。

在 Windows 中

> cd elasticsearch-2.1.0/bin
> elasticsearch

在 Linux 中

$ cd elasticsearch-2.1.0/bin
$ ./elasticsearch

注意 - 在 Windows 系统中，您可能会收到一条错误消息，指出未设置 JAVA_HOME，请在环境变量中将其设置为“C:\Program Files\Java\jre1.8.0_31”或您安装 Java 的位置。

步骤 5 - Elasticsearch Web 界面的默认端口为 9200，或者您可以通过更改 bin 目录中 elasticsearch.yml 文件内的 http.port 来更改它。您可以通过浏览https://:9200来检查服务器是否已启动并正在运行。它将返回一个 JSON 对象，其中包含以下方式安装的 Elasticsearch 的信息：

{
   "name" : "Brain-Child",
   "cluster_name" : "elasticsearch", "version" : {
      "number" : "2.1.0",
      "build_hash" : "72cd1f1a3eee09505e036106146dc1949dc5dc87",
      "build_timestamp" : "2015-11-18T22:40:03Z",
      "build_snapshot" : false,
      "lucene_version" : "5.3.1"
   },
   "tagline" : "You Know, for Search"
}

步骤 6 - 在此步骤中，让我们安装 Kibana。请按照以下给出的相应代码在 Linux 和 Windows 上安装：

在 Linux 上安装：

wget https://artifacts.elastic.co/downloads/kibana/kibana-7.0.0-linuxx86_64.tar.gz

tar -xzf kibana-7.0.0-linux-x86_64.tar.gz

cd kibana-7.0.0-linux-x86_64/

./bin/kibana

在 Windows 上安装：

从https://elastic.ac.cn/downloads/kibana下载 Windows 版 Kibana。单击链接后，您将看到如下所示的主页：

解压缩并转到 Kibana 主目录，然后运行它。

CD c:\kibana-7.0.0-windows-x86_64
.\bin\kibana.bat

Elasticsearch - 数据填充

在本章中，让我们学习如何向 Elasticsearch 添加一些索引、映射和数据。请注意，本教程中解释的一些示例将使用这些数据。

创建索引

您可以使用以下命令创建索引：

PUT school

响应

如果创建了索引，您可以看到以下输出：

{"acknowledged": true}

添加数据

Elasticsearch 将按照以下代码所示存储我们添加到索引中的文档。文档被赋予一些 ID，这些 ID 用于标识文档。

请求正文

POST school/_doc/10
{
   "name":"Saint Paul School", "description":"ICSE Afiliation",
   "street":"Dawarka", "city":"Delhi", "state":"Delhi", "zip":"110075",
   "location":[28.5733056, 77.0122136], "fees":5000,
   "tags":["Good Faculty", "Great Sports"], "rating":"4.5"
}

响应

{
   "_index" : "school",
   "_type" : "_doc",
   "_id" : "10",
   "_version" : 1,
   "result" : "created",
   "_shards" : {
      "total" : 2,
      "successful" : 1,
      "failed" : 0
   },
   "_seq_no" : 2,
   "_primary_term" : 1
}

在这里，我们正在添加另一个类似的文档。

POST school/_doc/16
{
   "name":"Crescent School", "description":"State Board Affiliation",
   "street":"Tonk Road",
   "city":"Jaipur", "state":"RJ", "zip":"176114","location":[26.8535922,75.7923988],
   "fees":2500, "tags":["Well equipped labs"], "rating":"4.5"
}

响应

{
   "_index" : "school",
   "_type" : "_doc",
   "_id" : "16",
   "_version" : 1,
   "result" : "created",
   "_shards" : {
      "total" : 2,
      "successful" : 1,
      "failed" : 0
   },
   "_seq_no" : 9,
   "_primary_term" : 7
}

这样，我们将继续添加我们在后续章节中工作所需的任何示例数据。

在 Kibana 中添加示例数据

Kibana 是一个用于访问数据和创建可视化的 GUI 驱动工具。在本节中，让我们了解如何向其中添加示例数据。

在 Kibana 首页，选择以下选项以添加示例电子商务数据：

下一个屏幕将显示一些可视化和一个添加数据的按钮：

单击“添加数据”将显示以下屏幕，确认数据已添加到名为 eCommerce 的索引中。

Elasticsearch - 版本迁移

在任何系统或软件中，当我们升级到较新版本时，我们需要遵循一些步骤来维护应用程序设置、配置、数据和其他内容。这些步骤是必要的，以便使应用程序在新系统中保持稳定或维护数据的完整性（防止数据损坏）。

您需要遵循以下步骤来升级 Elasticsearch：

• 从https://elastic.ac.cn/阅读升级文档

• 在非生产环境（例如 UAT、E2E、SIT 或 DEV 环境）中测试升级的版本。

• 请注意，如果没有数据备份，则无法回滚到以前的 Elasticsearch 版本。因此，建议在升级到更高版本之前备份数据。

• 我们可以使用完全集群重启或滚动升级进行升级。滚动升级适用于新版本。请注意，当您使用滚动升级方法进行迁移时，不会发生服务中断。

升级步骤

• 在升级生产集群之前，请在开发环境中测试升级。

• 备份您的数据。除非您有数据的快照，否则您无法回滚到早期版本。

• 在开始升级过程之前，请考虑关闭机器学习作业。虽然机器学习作业可以在滚动升级期间继续运行，但它会在升级过程中增加集群的开销。

• 按照以下顺序升级 Elastic Stack 的组件：

  • Elasticsearch
  • Kibana
  • Logstash
  • Beats
  • APM Server

从 6.6 或更早版本升级

要从 6.0-6.6 版本直接升级到 Elasticsearch 7.1.0，您必须手动重新索引需要继续使用的任何 5.x 索引，并执行完全集群重启。

完全集群重启

完全集群重启的过程包括关闭集群中的每个节点，将每个节点升级到 7x，然后重新启动集群。

以下是执行完整集群重启所需的高级步骤：

• 禁用分片分配
• 停止索引并执行同步刷新
• 关闭所有节点
• 升级所有节点
• 升级所有插件
• 启动每个已升级的节点
• 等待所有节点加入集群并报告黄色状态
• 重新启用分配

重新启用分配后，集群开始将副本分片分配给数据节点。此时，可以安全地恢复索引和搜索，但是如果您可以等到所有主分片和副本分片都已成功分配并且所有节点的状态都变为绿色，则您的集群恢复速度会更快。

Elasticsearch - API 约定

Web应用程序编程接口 (API) 是一组函数调用或其他编程指令，用于访问特定 Web 应用程序中的软件组件。例如，Facebook API 帮助开发者通过访问 Facebook 的数据或其他功能（例如生日或状态更新）来创建应用程序。

Elasticsearch 提供了一个 REST API，它通过 HTTP 上的 JSON 进行访问。Elasticsearch 使用一些约定，我们现在将讨论这些约定。

多个索引

API 中的大多数操作，主要是搜索和其他操作，都是针对一个或多个索引的。这有助于用户只需执行一次查询即可在多个位置或所有可用数据中进行搜索。许多不同的表示法用于在多个索引中执行操作。本章将讨论其中的一些。

逗号分隔表示法

POST /index1,index2,index3/_search

请求正文

{
   "query":{
      "query_string":{
         "query":"any_string"
      }
   }
}

响应

来自 index1、index2、index3 的 JSON 对象，其中包含 any_string。

_all 关键字用于所有索引

POST /_all/_search

请求正文

{
   "query":{
      "query_string":{
         "query":"any_string"
      }
   }
}

响应

来自所有索引的 JSON 对象，其中包含 any_string。

通配符 (* , + , –)

POST /school*/_search

请求正文

{
   "query":{
      "query_string":{
         "query":"CBSE"
      }
   }
}

响应

所有以 school 开头的索引中的 JSON 对象，其中包含 CBSE。

或者，您也可以使用以下代码：

POST /school*,-schools_gov /_search

请求正文

{
   "query":{
      "query_string":{
         "query":"CBSE"
      }
   }
}

响应

所有以“school”开头但不是 schools_gov 的索引中的 JSON 对象，其中包含 CBSE。

还有一些 URL 查询字符串参数：

• ignore_unavailable - 如果 URL 中存在的一个或多个索引不存在，则不会发生错误或不会停止操作。例如，schools 索引存在，但 book_shops 不存在。

POST /school*,book_shops/_search

请求正文

{
   "query":{
      "query_string":{
         "query":"CBSE"
      }
   }
}

请求正文

{
   "error":{
      "root_cause":[{
         "type":"index_not_found_exception", "reason":"no such index",
         "resource.type":"index_or_alias", "resource.id":"book_shops",
         "index":"book_shops"
      }],
      "type":"index_not_found_exception", "reason":"no such index",
      "resource.type":"index_or_alias", "resource.id":"book_shops",
      "index":"book_shops"
   },"status":404
}

考虑以下代码：

POST /school*,book_shops/_search?ignore_unavailable = true

请求正文

{
   "query":{
      "query_string":{
         "query":"CBSE"
      }
   }
}

响应（无错误）

所有以 school 开头的索引中的 JSON 对象，其中包含 CBSE。

allow_no_indices

此参数的true值将防止错误，如果带有通配符的 URL 没有产生任何索引。例如，没有以 schools_pri 开头的索引：

POST /schools_pri*/_search?allow_no_indices = true

请求正文

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

响应（无错误）

{
   "took":1,"timed_out": false, "_shards":{"total":0, "successful":0, "failed":0},
   "hits":{"total":0, "max_score":0.0, "hits":[]}
}

expand_wildcards

此参数决定是否需要将通配符扩展到打开的索引或关闭的索引，或同时执行两者。此参数的值可以是 open 和 closed 或 none 和 all。

例如，关闭索引 schools：

POST /schools/_close

响应

{"acknowledged":true}

考虑以下代码：

POST /school*/_search?expand_wildcards = closed

请求正文

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

响应

{
   "error":{
      "root_cause":[{
         "type":"index_closed_exception", "reason":"closed", "index":"schools"
      }],
      "type":"index_closed_exception", "reason":"closed", "index":"schools"
   }, "status":403
}

索引名称中的日期数学支持

Elasticsearch 提供了一种根据日期和时间搜索索引的功能。我们需要以特定的格式指定日期和时间。例如，accountdetail-2015.12.30 索引将存储 2015 年 12 月 30 日的银行账户详细信息。可以执行数学运算以获取特定日期或日期和时间范围的详细信息。

日期数学索引名称的格式：

<static_name{date_math_expr{date_format|time_zone}}>
/<accountdetail-{now-2d{YYYY.MM.dd|utc}}>/_search

static_name 是表达式的一部分，在每个日期数学索引（如 account detail）中保持不变。date_math_expr 包含动态确定日期和时间的数学表达式，例如 now-2d。date_format 包含索引中日期的写入格式，例如 YYYY.MM.dd。如果今天的日期是 2015 年 12 月 30 日，则 将返回 accountdetail-2015.12.28。

现在，我们将了解 Elasticsearch 中可用的某些常用选项，这些选项可用于以指定格式获取响应。

漂亮的结果

我们可以通过附加一个 URL 查询参数 pretty = true 来获取格式良好的 JSON 对象作为响应。

POST /schools/_search?pretty = true

请求正文

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

响应

……………………..
{
   "_index" : "schools", "_type" : "school", "_id" : "1", "_score" : 1.0,
   "_source":{
      "name":"Central School", "description":"CBSE Affiliation",
      "street":"Nagan", "city":"paprola", "state":"HP", "zip":"176115",
      "location": [31.8955385, 76.8380405], "fees":2000,
      "tags":["Senior Secondary", "beautiful campus"], "rating":"3.5"
   }
}
………………….

人类可读的输出

此选项可以将统计响应更改为人机可读形式（如果 human = true）或计算机可读形式（如果 human = false）。例如，如果 human = true，则 distance_kilometer = 20KM；如果 human = false，则 distance_meter = 20000，当响应需要由另一个计算机程序使用时。

响应过滤

我们可以通过在 field_path 参数中添加它们来过滤响应以减少字段。例如，

POST /schools/_search?filter_path = hits.total

请求正文

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

响应

{"hits":{"total":3}}

Elasticsearch - 文档 API

Elasticsearch 提供单文档 API 和多文档 API，其中 API 调用分别针对单个文档和多个文档。

索引 API

当向具有特定映射的相应索引发出请求时，它有助于在索引中添加或更新 JSON 文档。例如，以下请求会将 JSON 对象添加到 schools 索引和 school 映射下：

PUT schools/_doc/5
{
   name":"City School", "description":"ICSE", "street":"West End",
   "city":"Meerut",
   "state":"UP", "zip":"250002", "location":[28.9926174, 77.692485],
   "fees":3500,
   "tags":["fully computerized"], "rating":"4.5"
}

运行上述代码后，我们将得到以下结果：

{
   "_index" : "schools",
   "_type" : "_doc",
   "_id" : "5",
   "_version" : 1,
   "result" : "created",
   "_shards" : {
      "total" : 2,
      "successful" : 1,
      "failed" : 0
   },
   "_seq_no" : 2,
   "_primary_term" : 1
}

自动索引创建

当发出请求以将 JSON 对象添加到特定索引时，如果该索引不存在，则此 API 会自动创建该索引以及该特定 JSON 对象的基础映射。可以通过将 elasticsearch.yml 文件中以下参数的值更改为 false 来禁用此功能。

action.auto_create_index:false
index.mapper.dynamic:false

您还可以限制索引的自动创建，其中只允许具有特定模式的索引名称，方法是更改以下参数的值：

action.auto_create_index:+acc*,-bank*

注意 - 这里 + 表示允许，- 表示不允许。

版本控制

Elasticsearch 还提供版本控制功能。我们可以使用版本查询参数来指定特定文档的版本。

PUT schools/_doc/5?version=7&version_type=external
{
   "name":"Central School", "description":"CBSE Affiliation", "street":"Nagan",
   "city":"paprola", "state":"HP", "zip":"176115", "location":[31.8955385, 76.8380405],
   "fees":2200, "tags":["Senior Secondary", "beautiful campus"], "rating":"3.3"
}

运行上述代码后，我们将得到以下结果：

{
   "_index" : "schools",
   "_type" : "_doc",
   "_id" : "5",
   "_version" : 7,
   "result" : "updated",
   "_shards" : {
      "total" : 2,
      "successful" : 1,
      "failed" : 0
   },
   "_seq_no" : 3,
   "_primary_term" : 1
}

版本控制是一个实时过程，不受实时搜索操作的影响。

有两种最重要的版本控制类型：

内部版本控制

内部版本控制是默认版本，从 1 开始，每次更新（包括删除）都会递增。

外部版本控制

当文档的版本控制存储在外部系统（如第三方版本控制系统）中时使用。要启用此功能，我们需要将 version_type 设置为 external。在这里，Elasticsearch 将版本号存储为外部系统指定的版本号，并且不会自动递增它们。

操作类型

操作类型用于强制执行创建操作。这有助于避免覆盖现有文档。

PUT chapter/_doc/1?op_type=create
{
   "Text":"this is chapter one"
}

运行上述代码后，我们将得到以下结果：

{
   "_index" : "chapter",
   "_type" : "_doc",
   "_id" : "1",
   "_version" : 1,
   "result" : "created",
   "_shards" : {
      "total" : 2,
      "successful" : 1,
      "failed" : 0
   },
   "_seq_no" : 0,
   "_primary_term" : 1
}

自动 ID 生成

如果在索引操作中未指定 ID，则 Elasticsearch 会自动为该文档生成 ID。

POST chapter/_doc/
{
   "user" : "tpoint",
   "post_date" : "2018-12-25T14:12:12",
   "message" : "Elasticsearch Tutorial"
}

运行上述代码后，我们将得到以下结果：

{
   "_index" : "chapter",
   "_type" : "_doc",
   "_id" : "PVghWGoB7LiDTeV6LSGu",
   "_version" : 1,
   "result" : "created",
   "_shards" : {
      "total" : 2,
      "successful" : 1,
      "failed" : 0
   },
   "_seq_no" : 1,
   "_primary_term" : 1
}

获取 API

API 通过对特定文档发出获取请求来帮助提取类型 JSON 对象。

pre class="prettyprint notranslate" > GET schools/_doc/5

运行上述代码后，我们将得到以下结果：

{
   "_index" : "schools",
   "_type" : "_doc",
   "_id" : "5",
   "_version" : 7,
   "_seq_no" : 3,
   "_primary_term" : 1,
   "found" : true,
   "_source" : {
      "name" : "Central School",
      "description" : "CBSE Affiliation",
      "street" : "Nagan",
      "city" : "paprola",
      "state" : "HP",
      "zip" : "176115",
      "location" : [
         31.8955385,
         76.8380405
      ],
      "fees" : 2200,
      "tags" : [
         "Senior Secondary",
         "beautiful campus"
      ],
      "rating" : "3.3"
   }
}

• 此操作是实时的，不受索引刷新率的影响。

• 您也可以指定版本，然后 Elasticsearch 只会获取该版本的文档。

• 您也可以在请求中指定 _all，以便 Elasticsearch 可以在每种类型中搜索该文档 ID，并且它将返回第一个匹配的文档。

• 您还可以指定您想要从该特定文档中获取的结果中的字段。

GET schools/_doc/5?_source_includes=name,fees 

运行上述代码后，我们将得到以下结果：

{
   "_index" : "schools",
   "_type" : "_doc",
   "_id" : "5",
   "_version" : 7,
   "_seq_no" : 3,
   "_primary_term" : 1,
   "found" : true,
   "_source" : {
      "fees" : 2200,
      "name" : "Central School"
   }
} 

您也可以通过在获取请求中添加 _source 部分来获取结果中的源部分。

GET schools/_doc/5?_source 

运行上述代码后，我们将得到以下结果：

{
   "_index" : "schools",
   "_type" : "_doc",
   "_id" : "5",
   "_version" : 7,
   "_seq_no" : 3,
   "_primary_term" : 1,
   "found" : true,
   "_source" : {
      "name" : "Central School",
      "description" : "CBSE Affiliation",
      "street" : "Nagan",
      "city" : "paprola",
      "state" : "HP",
      "zip" : "176115",
      "location" : [
         31.8955385,
         76.8380405
      ],
      "fees" : 2200,
      "tags" : [
         "Senior Secondary",
         "beautiful campus"
      ],
      "rating" : "3.3"
   }
}

您还可以通过将 refresh 参数设置为 true 来在执行获取操作之前刷新分片。

删除 API

您可以通过向 Elasticsearch 发送 HTTP DELETE 请求来删除特定索引、映射或文档。

DELETE schools/_doc/4  

运行上述代码后，我们将得到以下结果：

{
   "found":true, "_index":"schools", "_type":"school", "_id":"4", "_version":2,
   "_shards":{"total":2, "successful":1, "failed":0}
}

可以指定文档的版本以删除该特定版本。可以指定路由参数以从特定用户那里删除文档，如果文档不属于该特定用户，则操作将失败。在此操作中，您可以指定与 GET API 相同的刷新和超时选项。

更新 API

脚本用于执行此操作，并且版本控制用于确保在获取和重新索引期间没有发生任何更新。例如，您可以使用脚本更新学校的费用：

POST schools/_update/4
{
   "script" : {
      "source": "ctx._source.name = params.sname",
      "lang": "painless",
      "params" : {
         "sname" : "City Wise School"
      }
   }
 }

运行上述代码后，我们将得到以下结果：

{
   "_index" : "schools",
   "_type" : "_doc",
   "_id" : "4",
   "_version" : 3,
   "result" : "updated",
   "_shards" : {
      "total" : 2,
      "successful" : 1,
      "failed" : 0
   },
   "_seq_no" : 4,
   "_primary_term" : 2
}

您可以通过向更新后的文档发送获取请求来检查更新。

Elasticsearch - 搜索 API

此 API 用于搜索 Elasticsearch 中的内容。用户可以通过发送带有查询字符串作为参数的获取请求来搜索，或者他们可以在发布请求的消息正文中发布查询。主要所有搜索 API 都是多索引、多类型的。

多索引

Elasticsearch 允许我们搜索所有索引或某些特定索引中存在的文档。例如，如果我们需要搜索名称包含 central 的所有文档，我们可以按如下所示进行操作：

GET /_all/_search?q=city:paprola 

运行上述代码后，我们将得到以下响应：

{
   "took" : 33,
   "timed_out" : false,
   "_shards" : {
      "total" : 7,
      "successful" : 7,
      "skipped" : 0,
      "failed" : 0
   },
   "hits" : {
      "total" : {
         "value" : 1,
         "relation" : "eq"
      },
      "max_score" : 0.9808292,
      "hits" : [
         {
            "_index" : "schools",
            "_type" : "school",
            "_id" : "5",
            "_score" : 0.9808292,
            "_source" : {
               "name" : "Central School",
               "description" : "CBSE Affiliation",
               "street" : "Nagan",
               "city" : "paprola",
               "state" : "HP",
               "zip" : "176115",
               "location" : [
                  31.8955385,
                  76.8380405
               ],
               "fees" : 2200,
               "tags" : [
                  "Senior Secondary",
                  "beautiful campus"
               ],
               "rating" : "3.3"
            }
         }
      ]
   }
}

URI 搜索

可以使用统一资源标识符 (URI) 在搜索操作中传递许多参数：

请求正文搜索

我们也可以使用请求正文中的查询 DSL 来指定查询，并且前面章节中已经给出许多示例。这里给出一个这样的例子：

POST /schools/_search
{
   "query":{
      "query_string":{
         "query":"up"
      }
   }
}

运行上述代码后，我们将得到以下响应：

{
   "took" : 11,
   "timed_out" : false,
   "_shards" : {
      "total" : 1,
      "successful" : 1,
      "skipped" : 0,
      "failed" : 0
   },
   "hits" : {
      "total" : {
         "value" : 1,
         "relation" : "eq"
      },
      "max_score" : 0.47000363,
      "hits" : [
         {
            "_index" : "schools",
            "_type" : "school",
            "_id" : "4",
            "_score" : 0.47000363,
            "_source" : {
               "name" : "City Best School",
               "description" : "ICSE",
               "street" : "West End",
               "city" : "Meerut",
               "state" : "UP",
               "zip" : "250002",
               "location" : [
                  28.9926174,
                  77.692485
               ],
               "fees" : 3500,
               "tags" : [
                  "fully computerized"
               ],
               "rating" : "4.5"
            }
         }
      ]
   }
}

Elasticsearch - 聚合

聚合框架收集搜索查询选择的所有数据，并包含许多构建块，这些构建块有助于构建数据的复杂摘要。聚合的基本结构如下所示：

"aggregations" : {
   "" : {
      "" : {

      }
 
      [,"meta" : { [] } ]?
      [,"aggregations" : { []+ } ]?
   }
   [,"" : { ... } ]*
}

有不同类型的聚合，每种聚合都有其自身的用途。本章将详细讨论它们。

指标聚合

这些聚合有助于从聚合文档的字段值计算矩阵，有时一些值可以从脚本生成。

数值矩阵或者是单值的，如平均值聚合，或者是多值的，如统计聚合。

平均值聚合

此聚合用于获取聚合文档中任何数值字段的平均值。例如，

POST /schools/_search
{
   "aggs":{
      "avg_fees":{"avg":{"field":"fees"}}
   }
}

运行上述代码后，我们将得到以下结果：

{
   "took" : 41,
   "timed_out" : false,
   "_shards" : {
      "total" : 1,
      "successful" : 1,
      "skipped" : 0,
      "failed" : 0
   },
   "hits" : {
      "total" : {
         "value" : 2,
         "relation" : "eq"
      },
      "max_score" : 1.0,
      "hits" : [
         {
            "_index" : "schools",
            "_type" : "school",
            "_id" : "5",
            "_score" : 1.0,
            "_source" : {
               "name" : "Central School",
               "description" : "CBSE Affiliation",
               "street" : "Nagan",
               "city" : "paprola",
               "state" : "HP",
               "zip" : "176115",
               "location" : [
                  31.8955385,
                  76.8380405
               ],
            "fees" : 2200,
            "tags" : [
               "Senior Secondary",
               "beautiful campus"
            ],
            "rating" : "3.3"
         }
      },
      {
         "_index" : "schools",
         "_type" : "school",
         "_id" : "4",
         "_score" : 1.0,
         "_source" : {
            "name" : "City Best School",
            "description" : "ICSE",
            "street" : "West End",
            "city" : "Meerut",
            "state" : "UP",
            "zip" : "250002",
            "location" : [
               28.9926174,
               77.692485
            ],
            "fees" : 3500,
            "tags" : [
               "fully computerized"
            ],
            "rating" : "4.5"
         }
      }
   ]
 },
   "aggregations" : {
      "avg_fees" : {
         "value" : 2850.0
      }
   }
}

基数聚合

此聚合给出特定字段的不同值的计数。

POST /schools/_search?size=0
{
   "aggs":{
      "distinct_name_count":{"cardinality":{"field":"fees"}}
   }
}

运行上述代码后，我们将得到以下结果：

{
   "took" : 2,
   "timed_out" : false,
   "_shards" : {
      "total" : 1,
      "successful" : 1,
      "skipped" : 0,
      "failed" : 0
   },
   "hits" : {
      "total" : {
         "value" : 2,
         "relation" : "eq"
      },
      "max_score" : null,
      "hits" : [ ]
   },
   "aggregations" : {
      "distinct_name_count" : {
         "value" : 2
      }
   }
}

注意 - 基数的值为 2，因为费用中有两个不同的值。

扩展统计聚合

此聚合生成关于聚合文档中特定数值字段的所有统计信息。

POST /schools/_search?size=0
{
   "aggs" : {
      "fees_stats" : { "extended_stats" : { "field" : "fees" } }
   }
}

运行上述代码后，我们将得到以下结果：

{
   "took" : 8,
   "timed_out" : false,
   "_shards" : {
      "total" : 1,
      "successful" : 1,
      "skipped" : 0,
      "failed" : 0
   },
   "hits" : {
      "total" : {
         "value" : 2,
         "relation" : "eq"
      },
      "max_score" : null,
      "hits" : [ ]
   },
   "aggregations" : {
      "fees_stats" : {
         "count" : 2,
         "min" : 2200.0,
         "max" : 3500.0,
         "avg" : 2850.0,
         "sum" : 5700.0,
         "sum_of_squares" : 1.709E7,
         "variance" : 422500.0,
         "std_deviation" : 650.0,
         "std_deviation_bounds" : {
            "upper" : 4150.0,
            "lower" : 1550.0
         }
      }
   }
}

最大值聚合

此聚合查找聚合文档中特定数值字段的最大值。

POST /schools/_search?size=0
{
   "aggs" : {
   "max_fees" : { "max" : { "field" : "fees" } }
   }
}

运行上述代码后，我们将得到以下结果：

{
   "took" : 16,
   "timed_out" : false,
   "_shards" : {
      "total" : 1,
      "successful" : 1,
      "skipped" : 0,
      "failed" : 0
   },
  "hits" : {
      "total" : {
         "value" : 2,
         "relation" : "eq"
      },
      "max_score" : null,
      "hits" : [ ]
   },
   "aggregations" : {
      "max_fees" : {
         "value" : 3500.0
      }
   }
}

最小值聚合

此聚合查找聚合文档中特定数值字段的最小值。

POST /schools/_search?size=0
{
   "aggs" : {
      "min_fees" : { "min" : { "field" : "fees" } }
   }
}

运行上述代码后，我们将得到以下结果：

{
   "took" : 2,
   "timed_out" : false,
   "_shards" : {
      "total" : 1,
      "successful" : 1,
      "skipped" : 0,
      "failed" : 0
   },
   "hits" : {
      "total" : {
         "value" : 2,
         "relation" : "eq"
      },
      "max_score" : null,
      "hits" : [ ]
   },
  "aggregations" : {
      "min_fees" : {
         "value" : 2200.0
      }
   }
}

总和聚合

此聚合计算聚合文档中特定数值字段的总和。

POST /schools/_search?size=0
{
   "aggs" : {
      "total_fees" : { "sum" : { "field" : "fees" } }
   }
}

运行上述代码后，我们将得到以下结果：

{
   "took" : 8,
   "timed_out" : false,
   "_shards" : {
      "total" : 1,
      "successful" : 1,
      "skipped" : 0,
      "failed" : 0
   },
   "hits" : {
      "total" : {
         "value" : 2,
         "relation" : "eq"
      },
      "max_score" : null,
      "hits" : [ ]
   },
   "aggregations" : {
      "total_fees" : {
         "value" : 5700.0
      }
   }
}

还有一些其他指标聚合用于特殊情况，例如用于地理位置的地理边界聚合和地理中心聚合。

统计聚合

一种多值指标聚合，它根据从聚合文档中提取的数值计算统计数据。

POST /schools/_search?size=0
{
   "aggs" : {
      "grades_stats" : { "stats" : { "field" : "fees" } }
   }
}

运行上述代码后，我们将得到以下结果：

{
   "took" : 2,
   "timed_out" : false,
   "_shards" : {
      "total" : 1,
      "successful" : 1,
      "skipped" : 0,
      "failed" : 0
   },
   "hits" : {
      "total" : {
         "value" : 2,
         "relation" : "eq"
      },
      "max_score" : null,
      "hits" : [ ]
   },
   "aggregations" : {
      "grades_stats" : {
         "count" : 2,
         "min" : 2200.0,
         "max" : 3500.0,
         "avg" : 2850.0,
         "sum" : 5700.0
      }
   }
}

聚合元数据

您可以使用 meta 标签在请求时添加有关聚合的一些数据，并且可以在响应中获取这些数据。

POST /schools/_search?size=0
{
   "aggs" : {
      "avg_fees" : { "avg" : { "field" : "fees" } ,
         "meta" :{
            "dsc" :"Lowest Fees This Year"
         }
      }
   }
}

运行上述代码后，我们将得到以下结果：

{
   "took" : 0,
   "timed_out" : false,
   "_shards" : {
      "total" : 1,
      "successful" : 1,
      "skipped" : 0,
      "failed" : 0
   },
   "hits" : {
      "total" : {
         "value" : 2,
         "relation" : "eq"
      },
      "max_score" : null,
      "hits" : [ ]
   },
   "aggregations" : {
      "avg_fees" : {
         "meta" : {
            "dsc" : "Lowest Fees This Year"
         },
         "value" : 2850.0
      }
   }
}

Elasticsearch - 索引 API

这些 API 负责管理索引的所有方面，例如设置、别名、映射、索引模板。

创建索引

此API帮助您创建索引。当用户将JSON对象传递到任何索引时，可以自动创建索引，也可以提前创建索引。要创建索引，您只需发送带有设置、映射和别名（或仅包含简单的请求体）的PUT请求。

PUT colleges

运行上述代码后，我们将得到如下所示的输出：

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

我们还可以向上述命令添加一些设置：

PUT colleges
{
  "settings" : {
      "index" : {
         "number_of_shards" : 3,
         "number_of_replicas" : 2
      }
   }
}

运行上述代码后，我们将得到如下所示的输出：

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

删除索引

此API帮助您删除任何索引。您只需要使用要删除的索引名称发送DELETE请求。

DELETE /colleges

您可以通过仅使用`_all`或`*`来删除所有索引。

获取索引

此API可以通过向一个或多个索引发送GET请求来调用。这将返回有关索引的信息。

GET colleges

运行上述代码后，我们将得到如下所示的输出：

{
   "colleges" : {
      "aliases" : {
         "alias_1" : { },
         "alias_2" : {
            "filter" : {
               "term" : {
                  "user" : "pkay"
               }
            },
            "index_routing" : "pkay",
            "search_routing" : "pkay"
         }
      },
      "mappings" : { },
      "settings" : {
         "index" : {
            "creation_date" : "1556245406616",
            "number_of_shards" : "1",
            "number_of_replicas" : "1",
            "uuid" : "3ExJbdl2R1qDLssIkwDAug",
            "version" : {
               "created" : "7000099"
            },
            "provided_name" : "colleges"
         }
      }
   }
}

您可以使用`_all`或`*`获取所有索引的信息。

索引是否存在

可以通过向该索引发送GET请求来确定索引是否存在。如果HTTP响应为200，则表示存在；如果为404，则表示不存在。

HEAD colleges

运行上述代码后，我们将得到如下所示的输出：

200-OK

索引设置

您可以通过在URL末尾附加`_settings`关键字来获取索引设置。

GET /colleges/_settings

运行上述代码后，我们将得到如下所示的输出：

{
   "colleges" : {
      "settings" : {
         "index" : {
            "creation_date" : "1556245406616",
            "number_of_shards" : "1",
            "number_of_replicas" : "1",
            "uuid" : "3ExJbdl2R1qDLssIkwDAug",
            "version" : {
               "created" : "7000099"
            },
            "provided_name" : "colleges"
         }
      }
   }
}

索引统计信息

此API帮助您提取有关特定索引的统计信息。您只需发送带有索引URL和`_stats`关键字的GET请求。

GET /_stats

运行上述代码后，我们将得到如下所示的输出：

………………………………………………
},
   "request_cache" : {
      "memory_size_in_bytes" : 849,
      "evictions" : 0,
      "hit_count" : 1171,
      "miss_count" : 4
   },
   "recovery" : {
      "current_as_source" : 0,
      "current_as_target" : 0,
      "throttle_time_in_millis" : 0
   }
} ………………………………………………

刷新

索引的刷新过程确保当前仅持久存储在事务日志中的任何数据也永久持久存储在Lucene中。这减少了恢复时间，因为在打开Lucene索引后，不需要从事务日志中重新索引该数据。

POST colleges/_flush

运行上述代码后，我们将得到如下所示的输出：

{
   "_shards" : {
      "total" : 2,
      "successful" : 1,
      "failed" : 0
   } 
}

Elasticsearch - Cat APIs

通常，各种Elasticsearch API的结果以JSON格式显示。但JSON并不总是容易阅读。因此，Elasticsearch 中提供了cat API功能，有助于提供更易于阅读和理解的打印结果格式。cat API中使用了各种参数，它们具有不同的用途，例如 - `v` 参数使输出更详细。

让我们在本章中更详细地了解cat APIs。

详细输出

详细输出提供了cat命令结果的清晰显示。在下面的示例中，我们获取集群中存在的各种索引的详细信息。

GET /_cat/indices?v

运行上述代码后，我们将得到如下所示的响应：

health status index uuid pri rep docs.count docs.deleted store.size pri.store.size
yellow open schools RkMyEn2SQ4yUgzT6EQYuAA 1 1 2 1 21.6kb 21.6kb
yellow open index_4_analysis zVmZdM1sTV61YJYrNXf1gg 1 1 0 0 283b 283b
yellow open sensor-2018-01-01 KIrrHwABRB-ilGqTu3OaVQ 1 1 1 0 4.2kb 4.2kb
yellow open colleges 3ExJbdl2R1qDLssIkwDAug 1 1 0 0 283b 283b

标题

`h`参数（也称为header）用于仅显示命令中提到的那些列。

GET /_cat/nodes?h=ip,port

运行上述代码后，我们将得到如下所示的响应：

127.0.0.1 9300

排序

sort命令接受查询字符串，该字符串可以按查询中指定的列对表进行排序。默认排序为升序，但可以通过向列添加`:desc`来更改此设置。

下面的示例给出了按字段索引模式降序排列的模板结果。

GET _cat/templates?v&s=order:desc,index_patterns

运行上述代码后，我们将得到如下所示的响应：

name index_patterns order version
.triggered_watches [.triggered_watches*] 2147483647
.watch-history-9 [.watcher-history-9*] 2147483647
.watches [.watches*] 2147483647
.kibana_task_manager [.kibana_task_manager] 0 7000099

计数

count参数提供整个集群中文档总数的计数。

GET /_cat/count?v

运行上述代码后，我们将得到如下所示的响应：

epoch timestamp count
1557633536 03:58:56 17809

Elasticsearch - 集群 API

集群API用于获取有关集群及其节点的信息以及对其进行更改。要调用此API，我们需要指定节点名称、地址或`_local`。

GET /_nodes/_local

运行上述代码后，我们将得到如下所示的响应：

………………………………………………
cluster_name" : "elasticsearch",
   "nodes" : {
      "FKH-5blYTJmff2rJ_lQOCg" : {
         "name" : "ubuntu",
         "transport_address" : "127.0.0.1:9300",
         "host" : "127.0.0.1",
         "ip" : "127.0.0.1",
         "version" : "7.0.0",
         "build_flavor" : "default",
         "build_type" : "tar",
         "build_hash" : "b7e28a7",
         "total_indexing_buffer" : 106502553,
         "roles" : [
            "master",
            "data",
            "ingest"
         ],
         "attributes" : {
………………………………………………

集群健康状况

此API用于通过附加“health”关键字来获取集群健康状况。

GET /_cluster/health

运行上述代码后，我们将得到如下所示的响应：

{
   "cluster_name" : "elasticsearch",
   "status" : "yellow",
   "timed_out" : false,
   "number_of_nodes" : 1,
   "number_of_data_nodes" : 1,
   "active_primary_shards" : 7,
   "active_shards" : 7,
   "relocating_shards" : 0,
   "initializing_shards" : 0,
   "unassigned_shards" : 4,
   "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" : 63.63636363636363
}

集群状态

此API用于通过附加“state”关键字URL来获取有关集群的状态信息。状态信息包含版本、主节点、其他节点、路由表、元数据和块。

GET /_cluster/state

运行上述代码后，我们将得到如下所示的响应：

………………………………………………
{
   "cluster_name" : "elasticsearch",
   "cluster_uuid" : "IzKu0OoVTQ6LxqONJnN2eQ",
   "version" : 89,
   "state_uuid" : "y3BlwvspR1eUQBTo0aBjig",
   "master_node" : "FKH-5blYTJmff2rJ_lQOCg",
   "blocks" : { },
   "nodes" : {
      "FKH-5blYTJmff2rJ_lQOCg" : {
      "name" : "ubuntu",
      "ephemeral_id" : "426kTGpITGixhEzaM-5Qyg",
      "transport
   }
………………………………………………

集群统计信息

此API通过使用“stats”关键字来帮助检索有关集群的统计信息。此API返回分片数量、存储大小、内存使用情况、节点数量、角色、操作系统和文件系统。

GET /_cluster/stats

运行上述代码后，我们将得到如下所示的响应：

………………………………………….
"cluster_name" : "elasticsearch",
"cluster_uuid" : "IzKu0OoVTQ6LxqONJnN2eQ",
"timestamp" : 1556435464704,
"status" : "yellow",
"indices" : {
   "count" : 7,
   "shards" : {
      "total" : 7,
      "primaries" : 7,
      "replication" : 0.0,
      "index" : {
         "shards" : {
         "min" : 1,
         "max" : 1,
         "avg" : 1.0
      },
      "primaries" : {
         "min" : 1,
         "max" : 1,
         "avg" : 1.0
      },
      "replication" : {
         "min" : 0.0,
         "max" : 0.0,
         "avg" : 0.0
      }
………………………………………….

更新集群设置

此API允许您使用“settings”关键字更新集群的设置。有两种类型的设置：持久性设置（在重启后应用）和临时设置（不会在集群完全重启后保留）。

节点统计信息

此API用于检索集群的一个或多个节点的统计信息。节点统计信息几乎与集群统计信息相同。

GET /_nodes/stats

运行上述代码后，我们将得到如下所示的响应：

{
   "_nodes" : {
      "total" : 1,
      "successful" : 1,
      "failed" : 0
   },
   "cluster_name" : "elasticsearch",
   "nodes" : {
      "FKH-5blYTJmff2rJ_lQOCg" : {
         "timestamp" : 1556437348653,
         "name" : "ubuntu",
         "transport_address" : "127.0.0.1:9300",
         "host" : "127.0.0.1",
         "ip" : "127.0.0.1:9300",
         "roles" : [
            "master",
            "data",
            "ingest"
         ],
         "attributes" : {
            "ml.machine_memory" : "4112797696",
            "xpack.installed" : "true",
            "ml.max_open_jobs" : "20"
         },
………………………………………………………….

节点热线程

此API帮助您检索集群中每个节点上当前热线程的信息。

GET /_nodes/hot_threads

运行上述代码后，我们将得到如下所示的响应：

:::{ubuntu}{FKH-5blYTJmff2rJ_lQOCg}{426kTGpITGixhEzaM5Qyg}{127.0.0.1}{127.0.0.1:9300}{ml.machine_memory=4112797696,
xpack.installed=true, ml.max_open_jobs=20}
 Hot threads at 2019-04-28T07:43:58.265Z, interval=500ms, busiestThreads=3,
ignoreIdleThreads=true:

Elasticsearch - 查询 DSL

在Elasticsearch中，搜索是使用基于JSON的查询进行的。查询由两类子句组成：

• 叶子查询子句 - 这些子句是匹配、术语或范围，它们查找特定字段中的特定值。

• 复合查询子句 - 这些查询是叶子查询子句和其他复合查询的组合，用于提取所需信息。

Elasticsearch支持大量的查询。查询以查询关键字开头，然后在JSON对象形式的内部包含条件和过滤器。下面描述了不同类型的查询。

匹配所有查询

这是最基本的查询；它返回所有内容，每个对象的得分均为1.0。

POST /schools/_search
{
   "query":{
      "match_all":{}
   }
}

运行上述代码后，我们将得到以下结果：

{
   "took" : 7,
   "timed_out" : false,
   "_shards" : {
      "total" : 1,
      "successful" : 1,
      "skipped" : 0,
      "failed" : 0
   },
   "hits" : {
      "total" : {
         "value" : 2,
         "relation" : "eq"
      },
      "max_score" : 1.0,
      "hits" : [
         {
            "_index" : "schools",
            "_type" : "school",
            "_id" : "5",
            "_score" : 1.0,
            "_source" : {
               "name" : "Central School",
               "description" : "CBSE Affiliation",
               "street" : "Nagan",
               "city" : "paprola",
               "state" : "HP",
               "zip" : "176115",
               "location" : [
                  31.8955385,
                  76.8380405
               ],
               "fees" : 2200,
               "tags" : [
                  "Senior Secondary",
                  "beautiful campus"
               ],
               "rating" : "3.3"
            }
         },
         {
            "_index" : "schools",
            "_type" : "school",
            "_id" : "4",
            "_score" : 1.0,
            "_source" : {
               "name" : "City Best School",
               "description" : "ICSE",
               "street" : "West End",
               "city" : "Meerut",
               "state" : "UP",
               "zip" : "250002",
               "location" : [
                  28.9926174,
                  77.692485
               ],
               "fees" : 3500,
               "tags" : [
                  "fully computerized"
               ],
               "rating" : "4.5"
            }
         }
      ]
   }
}

全文查询

这些查询用于搜索全文文本，例如章节或新闻文章。此查询根据与特定索引或文档关联的分析器工作。在本节中，我们将讨论不同类型的全文查询。

匹配查询

此查询将文本或短语与一个或多个字段的值匹配。

POST /schools*/_search
{
   "query":{
      "match" : {
         "rating":"4.5"
      }
   }
}

运行上述代码后，我们将得到如下所示的响应：

{
   "took" : 44,
   "timed_out" : false,
   "_shards" : {
      "total" : 1,
      "successful" : 1,
      "skipped" : 0,
      "failed" : 0
   },
   "hits" : {
      "total" : {
         "value" : 1,
         "relation" : "eq"
      },
      "max_score" : 0.47000363,
      "hits" : [
         {
            "_index" : "schools",
            "_type" : "school",
            "_id" : "4",
            "_score" : 0.47000363,
            "_source" : {
               "name" : "City Best School",
               "description" : "ICSE",
               "street" : "West End",
               "city" : "Meerut",
               "state" : "UP",
               "zip" : "250002",
               "location" : [
                  28.9926174,
                  77.692485
               ],
               "fees" : 3500,
               "tags" : [
                  "fully computerized"
               ],
               "rating" : "4.5"
            }
         }
      ]
   }
}

多字段匹配查询

此查询将文本或短语与多个字段匹配。

POST /schools*/_search
{
   "query":{
      "multi_match" : {
         "query": "paprola",
         "fields": [ "city", "state" ]
      }
   }
}

运行上述代码后，我们将得到如下所示的响应：

{
   "took" : 12,
   "timed_out" : false,
   "_shards" : {
      "total" : 1,
      "successful" : 1,
      "skipped" : 0,
      "failed" : 0
   },
   "hits" : {
      "total" : {
         "value" : 1,
         "relation" : "eq"
      },
      "max_score" : 0.9808292,
      "hits" : [
         {
            "_index" : "schools",
            "_type" : "school",
            "_id" : "5",
            "_score" : 0.9808292,
            "_source" : {
               "name" : "Central School",
               "description" : "CBSE Affiliation",
               "street" : "Nagan",
               "city" : "paprola",
               "state" : "HP",
               "zip" : "176115",
               "location" : [
                  31.8955385,
                  76.8380405
               ],
               "fees" : 2200,
               "tags" : [
                  "Senior Secondary",
                  "beautiful campus"
               ],
               "rating" : "3.3"
            }
         }
      ]
   }
}

查询字符串查询

此查询使用查询解析器和`query_string`关键字。

POST /schools*/_search
{
   "query":{
      "query_string":{
         "query":"beautiful"
      }
   }
}  

运行上述代码后，我们将得到如下所示的响应：

{
   "took" : 60,
   "timed_out" : false,
   "_shards" : {
      "total" : 1,
      "successful" : 1,
      "skipped" : 0,
      "failed" : 0
   },
   "hits" : {
      "total" : {
      "value" : 1,
      "relation" : "eq"
   },
………………………………….

术语级查询

这些查询主要处理结构化数据，例如数字、日期和枚举。

POST /schools*/_search
{
   "query":{
      "term":{"zip":"176115"}
   }
}

运行上述代码后，我们将得到如下所示的响应：

……………………………..
hits" : [
   {
      "_index" : "schools",
      "_type" : "school",
      "_id" : "5",
      "_score" : 0.9808292,
      "_source" : {
         "name" : "Central School",
         "description" : "CBSE Affiliation",
         "street" : "Nagan",
         "city" : "paprola",
         "state" : "HP",
         "zip" : "176115",
         "location" : [
            31.8955385,
            76.8380405
         ],
      }
   }
]   
…………………………………………..

范围查询

此查询用于查找具有给定值范围内的值的objects。为此，我们需要使用以下运算符：

• gte - 大于等于
• gt - 大于
• lte - 小于等于
• lt - 小于

例如，观察下面给出的代码：

POST /schools*/_search
{
   "query":{
      "range":{
         "rating":{
            "gte":3.5
         }
      }
   }
}

运行上述代码后，我们将得到如下所示的响应：

{
   "took" : 24,
   "timed_out" : false,
   "_shards" : {
      "total" : 1,
      "successful" : 1,
      "skipped" : 0,
      "failed" : 0
   },
   "hits" : {
      "total" : {
         "value" : 1,
         "relation" : "eq"
      },
      "max_score" : 1.0,
      "hits" : [
         {
            "_index" : "schools",
            "_type" : "school",
            "_id" : "4",
            "_score" : 1.0,
            "_source" : {
               "name" : "City Best School",
               "description" : "ICSE",
               "street" : "West End",
               "city" : "Meerut",
               "state" : "UP",
               "zip" : "250002",
               "location" : [
                  28.9926174,
                  77.692485
               ],
               "fees" : 3500,
               "tags" : [
                  "fully computerized"
               ],
               "rating" : "4.5"
            }
         }
      ]
   }
}

还存在其他类型的术语级查询，例如：

• 存在查询 - 如果某个字段具有非空值。

• 缺失查询 - 这与存在查询完全相反，此查询搜索缺少特定字段或字段值为null的objects。

• 通配符或正则表达式查询 - 此查询使用正则表达式查找objects中的模式。

复合查询

这些查询是使用布尔运算符（如and、or、not）或针对不同的索引或具有函数调用等将不同的查询组合在一起的集合。

POST /schools/_search
{
   "query": {
      "bool" : {
         "must" : {
            "term" : { "state" : "UP" }
         },
         "filter": {
            "term" : { "fees" : "2200" }
         },
         "minimum_should_match" : 1,
         "boost" : 1.0
      }
   }
}

运行上述代码后，我们将得到如下所示的响应：

{
   "took" : 6,
   "timed_out" : false,
   "_shards" : {
      "total" : 1,
      "successful" : 1,
      "skipped" : 0,
      "failed" : 0
   },
   "hits" : {
      "total" : {
         "value" : 0,
         "relation" : "eq"
      },
      "max_score" : null,
      "hits" : [ ]
   }
}

地理查询

这些查询处理地理位置和地理点。这些查询有助于查找靠近任何位置的学校或任何其他地理对象。您需要使用地理点数据类型。

PUT /geo_example
{
   "mappings": {
      "properties": {
         "location": {
            "type": "geo_shape"
         }
      }
   }
}

运行上述代码后，我们将得到如下所示的响应：

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

现在，我们将数据发布到上面创建的索引中。

POST /geo_example/_doc?refresh
{
   "name": "Chapter One, London, UK",
   "location": {
      "type": "point",
      "coordinates": [11.660544, 57.800286]
   }
}

运行上述代码后，我们将得到如下所示的响应：

{
   "took" : 1,
   "timed_out" : false,
   "_shards" : {
      "total" : 1,
      "successful" : 1,
      "skipped" : 0,
      "failed" : 0
   },
   "hits" : {
      "total" : {
         "value" : 2,
         "relation" : "eq"
      },
      "max_score" : 1.0,
      "hits" : [
         "_index" : "geo_example",
         "_type" : "_doc",
         "_id" : "hASWZ2oBbkdGzVfiXHKD",
         "_score" : 1.0,
         "_source" : {
            "name" : "Chapter One, London, UK",
            "location" : {
               "type" : "point",
               "coordinates" : [
                  11.660544,
                  57.800286
               ]
            }
         }
      }
   }

Elasticsearch - 映射

映射是存储在索引中的文档的轮廓。它定义了数据类型（如`geo_point`或`string`）以及文档中存在的字段的格式，以及控制动态添加字段的映射的规则。

PUT bankaccountdetails
{
   "mappings":{
      "properties":{
         "name": { "type":"text"}, "date":{ "type":"date"},
         "balance":{ "type":"double"}, "liability":{ "type":"double"}
      }
   }
 }

运行上述代码后，我们将得到如下所示的响应：

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

字段数据类型

Elasticsearch支持多种不同的文档字段数据类型。此处详细讨论了用于在Elasticsearch中存储字段的数据类型。

核心数据类型

这些是几乎所有系统都支持的基本数据类型，例如文本、关键字、日期、长整型、双精度浮点型、布尔型或IP地址。

复杂数据类型

这些数据类型是核心数据类型的组合。这些包括数组、JSON对象和嵌套数据类型。下面显示了嵌套数据类型的示例：

POST /tabletennis/_doc/1
{
   "group" : "players",
   "user" : [
      {
         "first" : "dave", "last" : "jones"
      },
      {
         "first" : "kevin", "last" : "morris"
      }
   ]
}

运行上述代码后，我们将得到如下所示的响应：

{
   "_index" : "tabletennis",
   "_type" : "_doc",
   "_id" : "1",
   _version" : 2,
   "result" : "updated",
   "_shards" : {
      "total" : 2,
      "successful" : 1,
      "failed" : 0
   },
   "_seq_no" : 1,
   "_primary_term" : 1
}

下面显示了另一个示例代码：

POST /accountdetails/_doc/1
{
   "from_acc":"7056443341", "to_acc":"7032460534",
   "date":"11/1/2016", "amount":10000
}

运行上述代码后，我们将得到如下所示的响应：

{  "_index" : "accountdetails",
   "_type" : "_doc",
   "_id" : "1",
   "_version" : 1,
   "result" : "created",
   "_shards" : {
      "total" : 2,
      "successful" : 1,
      "failed" : 0
   },
   "_seq_no" : 1,
   "_primary_term" : 1
}

我们可以使用以下命令检查上述文档：

GET /accountdetails/_mappings?include_type_name=false

移除映射类型

在Elasticsearch 7.0.0或更高版本中创建的索引不再接受`_default_`映射。在Elasticsearch 6.x中创建的6.x索引将继续像以前一样工作。7.0中的API已弃用类型。

Elasticsearch - 分析

在搜索操作期间处理查询时，任何索引中的内容都将由分析模块进行分析。此模块包含分析器、标记器、标记过滤器和字符过滤器。如果未定义分析器，则默认情况下，内置的分析器、标记、过滤器和标记器将与分析模块注册。

在以下示例中，我们使用标准分析器，该分析器在未指定其他分析器时使用。它将根据语法分析句子并生成句子中使用的词。

POST _analyze
{
   "analyzer": "standard",
   "text": "Today's weather is beautiful"
}

运行上述代码后，我们将得到如下所示的响应：

{
   "tokens" : [
      {
         "token" : "today's",
         "start_offset" : 0,
         "end_offset" : 7,
         "type" : "",
         "position" : 0
      },
      {
         "token" : "weather",
         "start_offset" : 8,
         "end_offset" : 15,
         "type" : "",
         "position" : 1
      },
      {
         "token" : "is",
         "start_offset" : 16,
         "end_offset" : 18,
         "type" : "",
         "position" : 2
      },
      {
         "token" : "beautiful",
         "start_offset" : 19,
         "end_offset" : 28,
         "type" : "",
         "position" : 3
      }
   ]
}

配置标准分析器

我们可以使用各种参数配置标准分析器以满足我们的自定义需求。

在以下示例中，我们将标准分析器的`max_token_length`配置为5。

为此，我们首先创建一个具有`max_length_token`参数的分析器的索引。

PUT index_4_analysis
{
   "settings": {
      "analysis": {
         "analyzer": {
            "my_english_analyzer": {
               "type": "standard",
               "max_token_length": 5,
               "stopwords": "_english_"
            }
         }
      }
   }
}

接下来，我们将分析器应用于如下所示的文本。请注意，标记没有出现，因为它开头有两个空格，结尾也有两个空格。对于单词“is”，它前面有一个空格，后面有一个空格。把它们加起来，它就变成了带有空格的4个字母，这并不能算作一个单词。至少开头或结尾必须有一个非空格字符，才能将其计为一个单词。

POST index_4_analysis/_analyze
{
   "analyzer": "my_english_analyzer",
   "text": "Today's weather is beautiful"
}

运行上述代码后，我们将得到如下所示的响应：

{
   "tokens" : [
      {
         "token" : "today",
         "start_offset" : 0,
         "end_offset" : 5,
         "type" : "",
         "position" : 0
      },
      {
         "token" : "s",
         "start_offset" : 6,
         "end_offset" : 7,
         "type" : "",
         "position" : 1
      },
      {
         "token" : "weath",
         "start_offset" : 8,
         "end_offset" : 13,
         "type" : "",
         "position" : 2
      },
      {
         "token" : "er",
         "start_offset" : 13,
         "end_offset" : 15,
         "type" : "",
         "position" : 3
      },
      {
         "token" : "beaut",
         "start_offset" : 19,
         "end_offset" : 24,
         "type" : "",
         "position" : 5
      },
      {
         "token" : "iful",
         "start_offset" : 24,
         "end_offset" : 28,
         "type" : "",
         "position" : 6
      }
   ]
}

下表列出了各种分析器及其说明：

标记器

标记器用于在Elasticsearch中从文本生成标记。通过考虑空格或其他标点符号，可以将文本分解成标记。Elasticsearch有很多内置标记器，这些标记器可以用于自定义分析器。

下面显示了一个标记器的示例，该标记器每当遇到非字母字符时就会将文本分解成术语，但它还会将所有术语小写：

POST _analyze
{
   "tokenizer": "lowercase",
   "text": "It Was a Beautiful Weather 5 Days ago."
}

运行上述代码后，我们将得到如下所示的响应：

{
   "tokens" : [
      {
         "token" : "it",
         "start_offset" : 0,
         "end_offset" : 2,
         "type" : "word",
         "position" : 0
      },
      {
         "token" : "was",
         "start_offset" : 3,
         "end_offset" : 6,
         "type" : "word",
         "position" : 1
      },
      {
         "token" : "a",
         "start_offset" : 7,
         "end_offset" : 8,
         "type" : "word",
         "position" : 2
      },
      {
         "token" : "beautiful",
         "start_offset" : 9,
         "end_offset" : 18,
         "type" : "word",
         "position" : 3
      },
      {
         "token" : "weather",
         "start_offset" : 19,
         "end_offset" : 26,
         "type" : "word",
         "position" : 4
      },
      {
         "token" : "days",
         "start_offset" : 29,
         "end_offset" : 33,
         "type" : "word",
         "position" : 5
      },
      {
         "token" : "ago",
         "start_offset" : 34,
         "end_offset" : 37,
         "type" : "word",
         "position" : 6
      }
   ]
}

下表列出了标记器及其说明：

Elasticsearch - 模块

Elasticsearch由许多模块组成，这些模块负责其功能。这些模块有两种类型的设置：

• 静态设置 - 这些设置需要在启动Elasticsearch之前在配置文件（elasticsearch.yml）中进行配置。您需要更新集群中的所有相关节点以反映这些设置的更改。

• 动态设置 - 这些设置可以在活动的Elasticsearch上设置。

我们将在本章的后续部分讨论Elasticsearch的不同模块。

集群级路由和分片分配

集群级设置决定了将分片分配给不同的节点以及重新分配分片以重新平衡集群。以下是控制分片分配的设置。

集群级分片分配

基于磁盘的分片分配

发现

此模块帮助集群发现并维护其所有节点的状态。当从集群中添加或删除节点时，集群状态会发生变化。集群名称设置用于创建不同集群之间的逻辑差异。有一些模块可以帮助您使用云供应商提供的 API，如下所示：

• Azure 发现
• EC2 发现
• Google Compute Engine 发现
• Zen 发现

网关

此模块维护集群状态和跨集群完全重启的分片数据。以下是此模块的静态设置：

HTTP

此模块管理 HTTP 客户端和 Elasticsearch API 之间的通信。可以通过将 http.enabled 的值更改为 false 来禁用此模块。

以下是控制此模块的设置（在 elasticsearch.yml 中配置）：

索引

此模块维护为每个索引全局设置的设置。以下设置主要与内存使用有关：

断路器

这用于防止操作导致 OutOfMemoryError。该设置主要限制 JVM 堆大小。例如，indices.breaker.total.limit 设置，默认为 JVM 堆的 70%。

字段数据缓存

这主要在对字段进行聚合时使用。建议有足够的内存来分配它。可以使用 indices.fielddata.cache.size 设置来控制字段数据缓存使用的内存量。

节点查询缓存

此内存用于缓存查询结果。此缓存使用最近最少使用 (LRU) 逐出策略。Indices.queries.cache.size 设置控制此缓存的内存大小。

索引缓冲区

此缓冲区存储索引中新创建的文档，并在缓冲区已满时刷新它们。诸如 indices.memory.index_buffer_size 之类的设置控制为此缓冲区分配的堆量。

分片请求缓存

此缓存用于存储每个分片的本地搜索数据。可以在创建索引期间启用缓存，也可以通过发送 URL 参数来禁用缓存。

Disable cache - ?request_cache = true
Enable cache "index.requests.cache.enable": true

索引恢复

它控制恢复过程中的资源。以下是设置：

TTL 间隔

生存时间 (TTL) 间隔定义文档的时间，在此时间之后文档将被删除。以下是控制此过程的动态设置：

节点 (Node)

每个节点可以选择是否为数据节点。您可以通过更改 **node.data** 设置来更改此属性。将值设置为 **false** 表示该节点不是数据节点。

Elasticsearch - 索引模块

这些是为每个索引创建的模块，它们控制索引的设置和行为。例如，索引可以使用多少分片，或者主分片可以为此索引有多少个副本等。索引设置有两种类型：

• **静态** - 这些只能在索引创建时或在关闭的索引上设置。
• **动态** - 这些可以在活动索引上更改。

静态索引设置

下表显示静态索引设置的列表：

动态索引设置

下表显示动态索引设置的列表：

Elasticsearch - Ingest 节点

有时我们需要在索引文档之前对其进行转换。例如，我们想从文档中删除一个字段或重命名一个字段，然后对其进行索引。这由 Ingest 节点处理。

集群中的每个节点都具有摄取能力，但也可以自定义为仅由特定节点处理。

涉及的步骤

Ingest 节点的运行涉及两个步骤：

• 创建管道
• 创建文档

创建管道

首先创建一个包含处理器的管道，然后执行该管道，如下所示：

PUT _ingest/pipeline/int-converter
{
   "description": "converts the content of the seq field to an integer",
   "processors" : [
      {
         "convert" : {
            "field" : "seq",
            "type": "integer"
         }
      }
   ]
}

运行上述代码后，我们将得到以下结果：

{
   "acknowledged" : true
}

创建文档

接下来，我们使用管道转换器创建一个文档。

PUT /logs/_doc/1?pipeline=int-converter
{
   "seq":"21",
   "name":"Tutorialspoint",
   "Addrs":"Hyderabad"
}

运行上述代码后，我们将得到如下所示的响应：

{
   "_index" : "logs",
   "_type" : "_doc",
   "_id" : "1",
   "_version" : 1,
   "result" : "created",
   "_shards" : {
      "total" : 2,
      "successful" : 1,
      "failed" : 0
   },
   "_seq_no" : 0,
   "_primary_term" : 1
}

接下来，我们使用GET命令搜索上面创建的文档，如下所示：

GET /logs/_doc/1

运行上述代码后，我们将得到以下结果：

{
   "_index" : "logs",
   "_type" : "_doc",
   "_id" : "1",
   "_version" : 1,
   "_seq_no" : 0,
   "_primary_term" : 1,
   "found" : true,
   "_source" : {
      "Addrs" : "Hyderabad",
      "name" : "Tutorialspoint",
      "seq" : 21
   }
}

您可以看到上面21已经变成了整数。

无管道

现在我们创建一个不使用管道的文档。

PUT /logs/_doc/2
{
   "seq":"11",
   "name":"Tutorix",
   "Addrs":"Secunderabad"
}
GET /logs/_doc/2

运行上述代码后，我们将得到以下结果：

{
   "_index" : "logs",
   "_type" : "_doc",
   "_id" : "2",
   "_version" : 1,
   "_seq_no" : 1,
   "_primary_term" : 1,
   "found" : true,
   "_source" : {
      "seq" : "11",
      "name" : "Tutorix",
      "Addrs" : "Secunderabad"
   }
}

您可以看到上面11在不使用管道的情况下是一个字符串。

Elasticsearch - 管理索引生命周期

索引生命周期管理涉及根据分片大小和性能要求等因素执行管理操作。索引生命周期管理 (ILM) API 使您可以自动化您希望如何随着时间的推移管理索引。

本章列出了 ILM API 及其用法。

策略管理 API

索引管理 API

操作管理 API

Elasticsearch - SQL 访问

它是一个组件，允许对 Elasticsearch 执行类似 SQL 的实时查询。您可以将 Elasticsearch SQL 视为一个转换器，它既了解 SQL 也了解 Elasticsearch，并且可以轻松地通过利用 Elasticsearch 的功能来实时、大规模地读取和处理数据。

Elasticsearch SQL 的优势

• 它具有原生集成 - 每个查询都根据底层存储有效地针对相关节点执行。

• 无需外部组件 - 无需额外的硬件、进程、运行时或库来查询 Elasticsearch。

• 轻量级且高效 - 它采用并公开 SQL 以允许实时进行适当的全文搜索。

示例

PUT /schoollist/_bulk?refresh
   {"index":{"_id": "CBSE"}}
   {"name": "GleanDale", "Address": "JR. Court Lane", "start_date": "2011-06-02",
   "student_count": 561}
   {"index":{"_id": "ICSE"}}
   {"name": "Top-Notch", "Address": "Gachibowli Main Road", "start_date": "1989-
   05-26", "student_count": 482}
   {"index":{"_id": "State Board"}}
   {"name": "Sunshine", "Address": "Main Street", "start_date": "1965-06-01",
   "student_count": 604}

运行上述代码后，我们将得到如下所示的响应：

{
   "took" : 277,
   "errors" : false,
   "items" : [
      {
         "index" : {
            "_index" : "schoollist",
            "_type" : "_doc",
            "_id" : "CBSE",
            "_version" : 1,
            "result" : "created",
            "forced_refresh" : true,
            "_shards" : {
               "total" : 2,
               "successful" : 1,
               "failed" : 0
            },
            "_seq_no" : 0,
            "_primary_term" : 1,
            "status" : 201
         }
      },
      {
         "index" : {
            "_index" : "schoollist",
            "_type" : "_doc",
            "_id" : "ICSE",
            "_version" : 1,
            "result" : "created",
            "forced_refresh" : true,
            "_shards" : {
               "total" : 2,
               "successful" : 1,
               "failed" : 0
            },
            "_seq_no" : 1,
            "_primary_term" : 1,
            "status" : 201
         }
      },
      {
         "index" : {
            "_index" : "schoollist",
            "_type" : "_doc",
            "_id" : "State Board",
            "_version" : 1,
            "result" : "created",
            "forced_refresh" : true,
            "_shards" : {
               "total" : 2,
               "successful" : 1,
               "failed" : 0
            },
            "_seq_no" : 2,
            "_primary_term" : 1,
            "status" : 201
         }
      }
   ]
}

SQL 查询

以下示例显示了我们如何构建 SQL 查询：

POST /_sql?format=txt
{
   "query": "SELECT * FROM schoollist WHERE start_date < '2000-01-01'"
}

运行上述代码后，我们将得到如下所示的响应：

Address             | name          | start_date             | student_count
--------------------+---------------+------------------------+---------------
Gachibowli Main Road|Top-Notch      |1989-05-26T00:00:00.000Z|482
Main Street         |Sunshine       |1965-06-01T00:00:00.000Z|604

注意 - 通过更改上面的 SQL 查询，您可以获得不同的结果集。

Elasticsearch - 监控

为了监控集群的健康状况，监控功能会从每个节点收集指标并将其存储在 Elasticsearch 索引中。与 Elasticsearch 中的监控相关的所有设置必须在每个节点的 elasticsearch.yml 文件中设置，或者在可能的情况下，在动态集群设置中设置。

为了启动监控，我们需要检查集群设置，可以通过以下方式完成：

GET _cluster/settings
{
   "persistent" : { },
   "transient" : { }
}

堆栈中的每个组件负责监控自身，然后将这些文档转发到 Elasticsearch 生产集群以进行路由和索引（存储）。Elasticsearch 中的路由和索引过程由称为收集器和导出器的组件处理。

收集器

收集器每隔一个收集间隔运行一次，以从它选择监控的 Elasticsearch 中的公共 API 获取数据。数据收集完成后，数据将批量交给导出器发送到监控集群。

每种收集的数据类型只有一个收集器。每个收集器可以创建零个或多个监控文档。

导出器

导出器获取从任何 Elastic Stack 源收集的数据并将其路由到监控集群。可以配置多个导出器，但常规和默认设置是使用单个导出器。导出器可以在节点和集群级别进行配置。

Elasticsearch 中有两种类型的导出器：

• 本地 - 此导出器将数据路由回同一集群

• HTTP - 首选的导出器，您可以使用它将数据路由到任何通过 HTTP 可访问的支持的 Elasticsearch 集群。

在导出器可以路由监控数据之前，它们必须设置某些 Elasticsearch 资源。这些资源包括模板和摄取管道

Elasticsearch - 数据汇总

汇总作业是一个定期任务，它会汇总索引模式指定的索引中的数据，并将其汇总到新的索引中。在下面的示例中，我们创建一个名为 sensor 的索引，其中包含不同的日期时间戳。然后，我们创建一个汇总作业，使用 cron 作业定期汇总这些索引中的数据。

PUT /sensor/_doc/1
{
   "timestamp": 1516729294000,
   "temperature": 200,
   "voltage": 5.2,
   "node": "a"
}

运行上述代码后，我们将得到以下结果：

{
   "_index" : "sensor",
   "_type" : "_doc",
   "_id" : "1",
   "_version" : 1,
   "result" : "created",
   "_shards" : {
      "total" : 2,
      "successful" : 1,
      "failed" : 0
   },
   "_seq_no" : 0,
   "_primary_term" : 1
}

现在，添加第二个文档，其他文档也如此。

PUT /sensor-2018-01-01/_doc/2
{
   "timestamp": 1413729294000,
   "temperature": 201,
   "voltage": 5.9,
   "node": "a"
}

创建汇总作业

PUT _rollup/job/sensor
{
   "index_pattern": "sensor-*",
   "rollup_index": "sensor_rollup",
   "cron": "*/30 * * * * ?",
   "page_size" :1000,
   "groups" : {
      "date_histogram": {
         "field": "timestamp",
         "interval": "60m"
      },
      "terms": {
         "fields": ["node"]
      }
   },
   "metrics": [
      {
         "field": "temperature",
         "metrics": ["min", "max", "sum"]
      },
      {
         "field": "voltage",
         "metrics": ["avg"]
      }
   ]
}

cron 参数控制作业何时以及多久激活一次。当汇总作业的 cron 计划触发时，它将从上次激活后停止的地方开始汇总。

作业运行并处理一些数据后，我们可以使用 DSL 查询进行一些搜索。

GET /sensor_rollup/_rollup_search
{
   "size": 0,
   "aggregations": {
      "max_temperature": {
         "max": {
            "field": "temperature"
         }
      }
   }
}

Elasticsearch - 冻结索引

频繁搜索的索引保存在内存中，因为重建它们需要时间，并且有助于高效搜索。另一方面，可能有一些我们很少访问的索引。这些索引不需要占用内存，可以在需要时重建。此类索引称为冻结索引。

Elasticsearch 在每次搜索冻结索引的每个分片时都会构建该分片的瞬态数据结构，并在搜索完成后立即丢弃这些数据结构。因为 Elasticsearch 不在内存中维护这些瞬态数据结构，所以冻结索引消耗的堆内存比普通索引少得多。这允许比否则可能更高的磁盘与堆比率。

冻结和解冻示例

以下示例冻结和解冻索引：

POST /index_name/_freeze
POST /index_name/_unfreeze

冻结索引上的搜索预计执行速度较慢。冻结索引并非用于高搜索负载。即使在索引未冻结时相同的搜索在几毫秒内完成，冻结索引的搜索也可能需要几秒钟或几分钟才能完成。

搜索冻结索引

每个节点并发加载的冻结索引数量受 search_throttled 线程池中的线程数限制，默认为 1。要包含冻结索引，必须使用查询参数执行搜索请求：_ignore_throttled=false。

GET /index_name/_search?q=user:tpoint&ignore_throttled=false

监控冻结索引

冻结索引是使用搜索限制和内存高效分片实现的普通索引。

GET /_cat/indices/index_name?v&h=i,sth

Elasticsearch - 测试

Elasticsearch 提供一个 jar 文件，可以添加到任何 Java IDE 中，并可用于测试与 Elasticsearch 相关的代码。可以使用 Elasticsearch 提供的框架执行一系列测试。在本章中，我们将详细讨论这些测试：

• 单元测试
• 集成测试
• 随机测试

前提条件

要开始测试，您需要将 Elasticsearch 测试依赖项添加到您的程序中。您可以为此目的使用 maven，并在 pom.xml 中添加以下内容。

<dependency>
   <groupId>org.elasticsearch</groupId>
   <artifactId>elasticsearch</artifactId>
   <version>2.1.0</version>
</dependency>

EsSetup 已初始化以启动和停止 Elasticsearch 节点以及创建索引。

EsSetup esSetup = new EsSetup();

带有 createIndex 的 esSetup.execute() 函数将创建索引，您需要指定设置、类型和数据。

单元测试

单元测试是使用 JUnit 和 Elasticsearch 测试框架进行的。可以使用 Elasticsearch 类创建节点和索引，并且可以在测试方法中用于执行测试。ESTestCase 和 ESTokenStreamTestCase 类用于此测试。

集成测试

集成测试在集群中使用多个节点。ESIntegTestCase 类用于此测试。有各种方法可以使准备测试用例的工作更容易。

测试集群方法

访问客户端

客户端用于访问集群中的不同节点并执行某些操作。ESIntegTestCase.client() 方法用于获取随机客户端。Elasticsearch 还提供其他访问客户端的方法，这些方法可以使用 ESIntegTestCase.internalCluster() 方法访问。

随机化测试

此测试用于使用所有可能的数据测试用户代码，以便将来不会出现任何类型的数据故障。随机数据是执行此测试的最佳选择。

生成随机数据

在此测试中，Random 类由 RandomizedTest 提供的实例实例化，并提供许多用于获取不同类型数据的方法。

断言

ElasticsearchAssertions 和 ElasticsearchGeoAssertions 类包含断言，这些断言用于在测试时执行一些常见的检查。例如，观察此处给出的代码：

SearchResponse seearchResponse = client().prepareSearch();
assertHitCount(searchResponse, 6);
assertFirstHit(searchResponse, hasId("6"));
assertSearchHits(searchResponse, "1", "2", "3", "4",”5”,”6”);

Elasticsearch - Kibana 仪表盘

Kibana 仪表板是可视化和搜索的集合。您可以安排、调整大小和编辑仪表板内容，然后保存仪表板以便共享。在本章中，我们将了解如何创建和编辑仪表板。

仪表板创建

在 Kibana 首页，从左侧控制栏中选择仪表板选项，如下所示。这将提示您创建一个新的仪表板。

要将可视化添加到仪表板，我们选择“添加”菜单，然后从可用的预构建可视化中进行选择。我们从列表中选择了以下可视化选项。

选择上述可视化后，我们将获得如下所示的仪表板。我们以后可以添加和编辑仪表板以更改元素和添加新元素。

检查元素

我们可以通过选择可视化面板菜单并选择“**检查**”来检查仪表板元素。这将显示元素背后的数据，这些数据也可以下载。

共享仪表板

我们可以通过选择“共享”菜单并选择获取超链接的选项来共享仪表板，如下所示：

Elasticsearch - 按字段过滤

Kibana 首页中提供的发现功能允许我们从各个角度探索数据集。您可以搜索和过滤所选索引模式的数据。数据通常以一段时间内值的分布形式提供。

要探索电子商务数据样本，我们点击下图所示的“**发现**”图标。这将显示数据以及图表。

按时间过滤

要按特定时间间隔过滤数据，我们使用如下所示的时间过滤器选项。默认情况下，过滤器设置为 15 分钟。

按字段过滤

也可以使用如下所示的“**添加过滤器**”选项按字段过滤数据集。在这里，我们添加一个或多个字段，并在应用过滤器后获得相应的结果。在我们的示例中，我们选择字段“day_of_week”，然后选择该字段的运算符为“is”，值为“Sunday”。

接下来，我们使用上述过滤器条件保存。包含已应用过滤器条件的结果集如下所示。

Elasticsearch - 数据表

数据表是一种可视化类型，用于显示组合聚合的原始数据。使用数据表呈现各种类型的聚合。为了创建数据表，我们应该详细了解此处讨论的步骤。

可视化

在 Kibana 主屏幕中，我们找到名为“可视化”的选项，它允许我们根据存储在 Elasticsearch 中的索引创建可视化和聚合。下图显示了该选项。

选择数据表

接下来，我们从各种可用的可视化选项中选择“数据表”选项。该选项显示在下图中：

选择指标

然后，我们选择创建数据表可视化所需的指标。此选择决定我们将使用的聚合类型。我们为此从电子商务数据集中选择以下特定字段。

运行上述数据表配置后，我们将获得如下所示的结果：

Elasticsearch - 区域地图

区域地图在地理地图上显示指标。它有助于查看锚定到不同地理区域的数据，强度各异。较深的阴影通常表示较高的值，较浅的阴影表示较低的值。

创建此可视化的步骤如下所述：

可视化

在此步骤中，我们转到 Kibana 主屏幕左侧栏中可用的“可视化”按钮，然后选择添加新可视化的选项。

以下屏幕显示了我们如何选择区域地图选项。

选择指标

下一个屏幕提示我们选择将用于创建区域地图的指标。在这里，我们选择平均价格作为指标，并将 country_iso_code 作为将用于创建可视化的桶中的字段。

应用选择后，最终结果（如下所示）显示了区域地图。请注意颜色的阴影及其在标签中提到的值。

Elasticsearch - 饼图

饼图是最简单和最著名的可视化工具之一。它将数据表示为圆的切片，每个切片颜色不同。标签以及百分比数据值可以与圆一起显示。圆也可以采用甜甜圈的形状。

可视化

在 Kibana 主屏幕中，我们找到名为“可视化”的选项，它允许我们根据存储在 Elasticsearch 中的索引创建可视化和聚合。我们选择添加新的可视化，并选择饼图作为如下所示的选项。

选择指标

下一个屏幕提示我们选择将用于创建饼图的指标。在这里，我们选择基本单位价格的数量作为指标，并将桶聚合作为直方图。此外，最小间隔选择为 20。因此，价格将显示为以 20 为范围的值块。

应用选择后，结果（如下所示）显示了饼图。请注意颜色的阴影及其在标签中提到的值。

饼图选项

转到饼图下的选项选项卡后，我们可以看到各种配置选项，可以更改饼图的外观以及数据显示的排列方式。在下面的示例中，饼图显示为甜甜圈，标签显示在顶部。

Elasticsearch - 面积图和条形图

面积图是折线图的扩展，其中折线图与轴之间的区域用某些颜色突出显示。条形图表示组织成一定范围的值的数据，然后相对于轴绘制。它可以包含水平条形或垂直条形。

在本章中，我们将看到所有这三种图表类型，这些图表类型是使用 Kibana 创建的。正如前面章节中所讨论的，我们将继续使用电子商务索引中的数据。

面积图

在 Kibana 主屏幕中，我们找到名为“可视化”的选项，它允许我们根据存储在 Elasticsearch 中的索引创建可视化和聚合。我们选择添加新的可视化，并选择面积图作为下图所示的选项。

选择指标

下一个屏幕提示我们选择将用于创建面积图的指标。在这里，我们选择 sum 作为聚合指标的类型。然后，我们选择 total_quantity 字段作为要用作指标的字段。在 X 轴上，我们选择 order_date 字段，并以 5 的大小分割带有给定指标的序列。

运行上述配置后，我们将获得以下面积图作为输出：

水平条形图

同样，对于水平条形图，我们从 Kibana 主屏幕选择新的可视化，然后选择水平条形图的选项。然后，我们选择如下图像所示的指标。在这里，我们选择 Sum 作为名为 product quantity 的字段的聚合。然后，我们为 order date 字段选择带有日期直方图的桶。

运行上述配置后，我们可以看到如下所示的水平条形图：

垂直条形图

对于垂直条形图，我们从 Kibana 主屏幕选择新的可视化，然后选择垂直条形的选项。然后，我们选择如下图像所示的指标。

在这里，我们选择 Sum 作为名为 product quantity 的字段的聚合。然后，我们为 order date 字段选择带有日期直方图的桶，间隔为每周。

运行上述配置后，将生成如下所示的图表：

Elasticsearch - 时间序列

时间序列是在特定时间序列中表示数据序列的表示。例如，从月份的第一天到最后一天的每天数据。数据点之间的间隔保持不变。任何包含时间成分的数据集都可以表示为时间序列。

在本章中，我们将使用示例电子商务数据集并绘制每天订单数量以创建时间序列。

选择指标

首先，我们选择将用于创建时间序列的索引模式、数据字段和间隔。从示例电子商务数据集中，我们选择 order_date 作为字段，并将 1d 作为间隔。我们使用“面板选项”选项卡来做出这些选择。此外，我们将此选项卡中的其他值保留为默认值，以便获得时间序列的默认颜色和格式。

在“数据”选项卡中，我们选择 count 作为聚合选项，将 group by 选项设置为 everything，并为时间序列图表添加标签。

结果

此配置的最终结果如下所示。请注意，我们在此图表中使用的是“本月至今”的时间段。不同的时间段将给出不同的结果。

Elasticsearch - 标签云

标签云以视觉上吸引人的形式表示文本，这些文本主要是关键字和元数据。它们以不同的角度排列，并以不同的颜色和字体大小表示。它有助于找出数据中最突出的术语。突出程度可以由一个或多个因素决定，例如术语的频率、标签的唯一性或附加到特定术语的权重等。下面我们将看到创建标签云的步骤。

可视化

在 Kibana 主界面，我们找到名为“可视化”的选项，它允许我们根据 Elasticsearch 中存储的索引创建可视化和聚合。我们选择添加一个新的可视化，并选择“标签云”作为选项，如下所示：

选择指标

下一个屏幕提示我们选择用于创建标签云的指标。在这里，我们选择“计数”作为聚合指标的类型。然后，我们选择“productname”字段作为要用于标签的关键字。

应用选择后，此处显示的结果为饼图。请注意颜色阴影及其在标签中提到的值。

标签云选项

在标签云下的“选项”选项卡中，我们可以看到各种配置选项，可以更改标签云中数据显示的外观和排列方式。在下面的示例中，标签云中的标签横向和纵向分布。

Elasticsearch - 热力图

热力图是一种可视化类型，其中不同的颜色阴影代表图表中的不同区域。值可能连续变化，因此颜色的阴影会随着值的变化而变化。它们非常有用，可以表示连续变化的数据和离散数据。

在本章中，我们将使用名为 sample_data_flights 的数据集来构建热力图。在其中，我们考虑航班的“出发国家”和“到达国家”变量并进行计数。

在 Kibana 主界面，我们找到名为“可视化”的选项，它允许我们根据 Elasticsearch 中存储的索引创建可视化和聚合。我们选择添加一个新的可视化，并选择“热力图”作为选项，如下所示：

选择指标

下一个屏幕提示我们选择用于创建热力图的指标。在这里，我们选择“计数”作为聚合指标的类型。然后对于 Y 轴的桶，我们为“OriginCountry”字段选择“Terms”作为聚合。对于 X 轴，我们选择相同的聚合，但使用“DestCountry”作为字段。在这两种情况下，我们都将桶的大小选择为 5。

运行上述配置后，我们将生成如下所示的热力图。

注意 - 您必须将日期范围设置为“今年”，以便图表收集一年的数据以生成有效的热力图。

Elasticsearch - Canvas

Canvas 应用程序是 Kibana 的一部分，它允许我们创建动态的、多页面的、像素完美的数 据显示。它能够创建信息图表，而不仅仅是图表和指标，这使其独一无二且引人注目。在本章中，我们将了解 Canvas 的各种功能以及如何使用 Canvas 工作区。

打开 Canvas

转到 Kibana 首页，选择如下所示的选项。它将打开您拥有的 Canvas 工作区列表。我们选择“电商收入追踪”用于我们的研究。

克隆工作区

我们克隆“[电商]收入追踪”工作区以用于我们的研究。要克隆它，我们突出显示此工作区名称的行，然后使用克隆按钮，如下面的图表所示：

通过上述克隆操作，我们将获得一个名为“[电商]收入追踪 - 副本”的新工作区，打开后将显示下面的信息图表。

它描述了按类别划分的总销售额和收入，以及精美的图片和图表。

修改工作区

我们可以使用右侧选项卡中提供的选项来更改工作区中的样式和图形。在这里，我们旨在通过选择不同的颜色来更改工作区的背景颜色，如下面的图表所示。颜色选择会立即生效，我们得到的结果如下所示：

Elasticsearch - 日志 UI

Kibana 还可以帮助可视化来自各种来源的日志数据。日志是分析基础设施健康状况、性能需求和安全漏洞分析等的重要来源。Kibana 可以连接到各种日志，例如 Web 服务器日志、Elasticsearch 日志和 CloudWatch 日志等。

Logstash 日志

在 Kibana 中，我们可以连接到 Logstash 日志进行可视化。首先，我们从 Kibana 主屏幕选择“日志”按钮，如下所示：

然后，我们选择“更改源配置”选项，这将使我们能够选择 Logstash 作为源。下面的屏幕还显示了我们作为日志源的其他类型的选项。

您可以流式传输数据以进行实时日志尾随，或暂停流式传输以关注历史日志数据。当您流式传输日志时，最新的日志将显示在控制台底部。

如需更多参考，您可以参考我们的 Logstash 教程。