Elasticsearch 简明教程

Elasticsearch - Quick Guide

Elasticsearch - Basic Concepts

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

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

General Features

Elasticsearch 的一般特性如下 −

Elasticsearch 可扩展到 PB 级的结构化和非结构化数据。
Elasticsearch 可以用作 MongoDB 和 RavenDB 等文档存储器的替代品。
Elasticsearch 使用非规范化来改进搜索性能。
Elasticsearch 是流行的企业搜索引擎之一，目前已被维基百科、卫报、StackOverflow、GitHub 等许多大型组织使用。
Elasticsearch 是一个开源软件，并根据 Apache 许可证版本 2.0 提供。

Key Concepts

Elasticsearch 的主要概念如下 −

Node

这是指 Elasticsearch 的单个运行实例。单个物理和虚拟服务器可容纳多个节点，具体取决于其物理资源（如 RAM、存储和处理能力）的功能。

Cluster

这是由一个或多个节点组成的。群集为所有节点提供跨整个数据的集体索引和搜索功能。

Index

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

Document

这是按照 JSON 格式定义的特定方式中的字段集合。每个文档都属于一个类型并且驻留在索引中。每个文档都与一个称为 UID 的唯一标识符关联。

Shard

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

Replicas

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

Advantages

Elasticsearch 是基于 Java 开发的，这使其几乎与所有平台兼容。
Elasticsearch 是实时的，换句话说，添加的文档在这一秒之后就可以用此引擎搜索。
Elasticsearch 是分布式的，这使得它易于扩展和集成到任何大型组织中。
利用 Elasticsearch 中存在的网关概念，可以轻松创建完整备份。
与 Apache Solr 相比，在 Elasticsearch 中处理多租户非常容易。
Elasticsearch 使用 JSON 对象作为响应，这使得可以使用大量的不同编程语言调用 Elasticsearch 服务器。
Elasticsearch 支持几乎所有文档类型，但不支持不支持文本渲染的文档类型。

Disadvantages

Elasticsearch 在处理请求和响应数据方面（仅在 JSON 中可行）不支持多语言，这与 Apache Solr 不同，Apache Solr 中可以使用 CSV、XML 和 JSON 格式。
有时，Elasticsearch 存在 split brain 情况问题。

Comparison between Elasticsearch and RDBMS

在 Elasticsearch 中，索引类似于 RDBMS（关系数据库管理系统）中的表。每个表都是一组行，正如每个索引都是 Elasticsearch 中一组文档。

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

Elasticsearch

RDBMS

Cluster

Database

Shard

Index

Table

Field

Column

Document

Row

Elasticsearch - Installation

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

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

Step 1 - 检查计算机上安装的 Java 版本。它应为 Java 7 或更高版本。您可以通过执行以下操作进行检查 -

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

> java -version

在 UNIX OS 中（使用终端）-

$ echo $JAVA_HOME

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

对于 Windows 操作系统，下载 ZIP 文件。
对于 UNIX 操作系统，下载 TAR 文件。
对于 Debian 操作系统，下载 DEB 文件。
对于 Red Hat 和其他 Linux 发行版，下载 RPM 文件。
还可以使用 APT 和 Yum 实用程序在许多 Linux 发行版中安装 Elasticsearch。

Step 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

Using APT utility for 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

Download and install the Debian package manually using the command given here −

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

Using YUM utility for Debian Linux OS

$ 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

Step 4 - 转到 Elasticsearch 主目录，然后进入 bin 文件夹。针对 Windows 系统，请运行 elasticsearch.bat 文件，或者针对 UNIX 系统，您可以通过命令提示符和终端运行同样的文件。

In Windows

> cd elasticsearch-2.1.0/bin
> elasticsearch

In Linux

$ cd elasticsearch-2.1.0/bin
$ ./elasticsearch

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

Step 5 − Elasticsearch Web 界面使用的默认端口是 9200，或者你可以通过修改 bin 目录中 elasticsearch.yml 文件中的 http.port 来更改。你可以通过浏览 http://localhost: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"
}

Step 6 − 在此步骤中，让我们安装 Kibana。按照下面给出的相应代码在 Linux 和 Windows 上进行安装 −

For Installation on 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

For Installation on Windows −

从 https://www.elastic.co/downloads/kibana 下载适用于 Windows 的 Kibana 一旦你单击该链接，你将看到如下所示的主页 −

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

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

Elasticsearch - Populate

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

Create Index

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

PUT school

Response

如果创建索引，您会看到以下输出 -

{"acknowledged": true}

Add data

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

Request Body

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

Response

{
   "_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"
}

Response

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

这样，我们将继续添加我们将在即将到来的章节中为工作添加的任何示例数据。

Adding Sample Data in Kibana

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

在 Kibana 主页中，选择以下选项以添加示例电子商务数据 -

下一个屏幕将显示一些可视化和一个“添加数据”按钮 -

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

Elasticsearch - Migration between Versions

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

你需要按照以下步骤来升级 Elasticsearch −

阅读 https://www.elastic.co/ 中的升级文档
在非生产环境（如 UAT、E2E、SIT 或 DEV 环境）中测试升级后的版本。
请注意，如果没有数据备份，就不可能回滚到之前的 Elasticsearch 版本。因此，在升级到较高版本之前建议进行数据备份。
我们可以使用完整集群重启或滚动升级升级。滚动升级适用于新版本。请注意，当你使用滚动升级方法进行迁移时，不会出现服务中断。

Steps for Upgrade

在升级生产集群之前，先在开发环境中测试升级。
备份数据。除非你对数据进行了快照，否则无法回滚至早期版本。
在开始升级进程之前，请考虑关闭机器学习作业。尽管机器学习作业可以在滚动升级期间继续运行，但这会增加升级进程期间集群的开销。
按以下顺序升级 Elastic Stack 的组件：Elasticsearch、Kibana、Logstash、Beats、APM 服务器

Upgrading from 6.6 or Earlier

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

Full Cluster Restart

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

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

Disable shard allocation

停止编制索引并执行同步刷新

Shutdown all nodes

Upgrade all nodes

Upgrade any plugins

Start each upgraded node

等待所有节点加入集群并报告黄色状态

Re-enable allocation

重新启用分配后，集群开始将副本分片分配到数据节点。此时，恢复编制索引和搜索是安全的，但如果你可以等到所有主分片和副本分片都已成功分配且所有节点的状态都为绿色，那么集群将恢复得更快。

Elasticsearch - API Conventions

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

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

Multiple Indices

API 中的大多数操作（主要是搜索和其他操作）面向一个或多个索引。这使用户只需执行一次查询即可在多个位置或所有可用数据中进行搜索。使用许多不同的符号在多个索引中执行操作。我们将在本章中讨论其中的几个。

Comma Separated Notation

POST /index1,index2,index3/_search

Request Body

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

Response

包含 any_string 的 index1、index2、index3 中的 JSON 对象。

_all Keyword for All Indices

POST /_all/_search

Request Body

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

Response

包含 any_string 的所有索引中的 JSON 对象。

Wildcards ( * , + , –)

POST /school*/_search

Request Body

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

Response

在所有索引中包含“school”开头的包含 CBSE 的 JSON 对象。

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

POST /school*,-schools_gov /_search

Request Body

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

Response

所有索引中包含“school”开头的但不包含 schools_gov 并且包含 CBSE 的 JSON 对象。

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

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

POST /school*,book_shops/_search

Request Body

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

Request Body

{
   "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

Request Body

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

Response (no error)

在所有索引中包含“school”开头的包含 CBSE 的 JSON 对象。

allow_no_indices

true 此参数的值可防止错误，如果带通配符的 URL 导致没有索引。例如，没有以 schools_pri 开头的索引

POST /schools_pri*/_search?allow_no_indices = true

Request Body

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

Response (No errors)

{
   "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。

例如，关闭索引学校：

POST /schools/_close

Response

{"acknowledged":true}

考虑以下代码：-

POST /school*/_search?expand_wildcards = closed

Request Body

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

Response

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

Date Math Support in Index Names

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 是表达的一部分，在每个日期数学索引（如帐户详细信息）中保持不变。date_math_expr 包含确定日期和时间（如 now-2d）的数学表达式。date_format 包含日期在索引中写入的格式，如 YYYY.MM.dd。如果今天的日期是 2015 年 12 月 30 日，那么 <accountdetail-{now-2d{YYYY.MM.dd}}> 将返回 accountdetail-2015.12.28。

Expression

Resolves to

<accountdetail-{now-d}>

accountdetail-2015.12.29

<accountdetail-{now-M}>

accountdetail-2015.11.30

<accountdetail-{now{YYYY.MM}}>

accountdetail-2015.12

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

Pretty Results

只需追加 URL 查询参数（即 pretty = true）即可获得格式良好的 JSON 对象中的响应。

POST /schools/_search?pretty = true

Request Body

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

Response

……………………..
{
   "_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 Readable Output

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

Response Filtering

我们可以通过将字段添加到 field_path 参数中来过滤响应到更少的字段。例如，

POST /schools/_search?filter_path = hits.total

Request Body

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

Response

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

Elasticsearch - Document APIs

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

Index API

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

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
}

Automatic Index Creation

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

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

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

action.auto_create_index:+acc*,-bank*

Note - 此处 + 表示允许，- 表示不允许。

Versioning

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

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
}

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

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

Internal Versioning

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

External Versioning

当文档版本存储在第三方版本控制系统等外部系统中时，它会被使用。要启用此功能，我们需要将 version_type 设置为 external。此处，Elasticsearch 会将由外部系统指定的版本号存储起来，且不会自动增加它们。

Operation Type

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

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
}

Automatic ID generation

当在索引操作中未指定 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
}

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

您只需在 get 请求中添加 _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"
   }
}

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

Delete 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}
}

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

Update API

脚本用于执行此操作，版本控制用于确保在 get 和重新索引期间没有更新发生。例如，您可以使用脚本更新学校费用 −

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
}

您可以通过向更新的文档发送 get 请求检查更新。

Elasticsearch - Search APIs

此 API 用于在 Elasticsearch 中搜索内容。用户可以通过使用查询字符串作为参数发送 GET 请求或在 POST 请求的信息主体中发布查询来进行搜索。基本上，所有搜索 API 都是多索引多类型。

Multi-Index

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

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 Search

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

S.No	Parameter & Description
1	Q 此参数用于指定查询字符串。
2	lenient 此参数用于指定查询字符串。只要将此参数设置为 true，就可以忽略基于格式的错误。默认情况下为 false。
3	fields 此参数用于指定查询字符串。
4	sort 我们可以使用此参数获得已排序的结果，此参数的可能值为 fieldName，fieldName:asc/fieldname:desc
5	timeout 我们可以使用此参数限制搜索时间，且响应仅包含该指定时间段内的点击量。默认情况下，没有超时。
6	terminate_after 我们可以将响应限制为每个分片的特定数量的文档，达到该数量时，查询会提前终止。默认情况下，没有 terminate_after。
7	from 从要返回的点击量的索引开始。默认为 0。
8	size 表示要返回的点击量数。默认为 10。

Request Body Search

我们还可以在请求正文中使用查询 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

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

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

      }

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

有不同类型的聚合，每种聚合都有自己的目的。本章将详细讨论它们。

Metrics Aggregations

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

数字矩阵要么是单值的（如平均聚合），要么是多值的（如统计信息）。

Avg Aggregation

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

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

Cardinality Aggregation

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

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

Note − 基数的值为 2，因为费用中有两个不同的值。

Extended Stats Aggregation

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

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

Max Aggregation

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

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

Min Aggregation

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

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

Sum Aggregation

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

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

还有一些其他度量聚合在特殊情况下使用，它们包括用于地理位置的地理边界聚合和地理中心聚合。

Stats Aggregations

多值度量聚合，它对从聚合文档中提取的数字值计算统计数据。

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

Aggregation Metadata

您可以通过使用元标记在请求时添加一些有关聚合的数据，并可以在响应中获取它。

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 - Index APIs

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

Create Index

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

Delete Index

此 API 可帮助您删除任何索引。您只需传递一个带有特定索引名称的删除请求。

DELETE /colleges

您只需使用 _all 或 * 即可删除所有索引。

Get Index

只需向一个或多个索引发送获取请求即可调用此 API。这将返回有关索引的信息。

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 或 * 您可以获取所有索引的信息。

Index Exist

只需向该索引发送获取请求即可确定索引是否存在。如果 HTTP 响应为 200，则表示索引存在；如果为 404，则表示索引不存在。

HEAD colleges

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

200-OK

Index Settings

您只需在 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"
         }
      }
   }
}

Index Stats

此 API 可帮助您提取特定索引的统计信息。您只需发送一个带有索引 URL 和 _stats 关键字的获取请求（位于最后）。

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
   }
} ………………………………………………

Flush

索引的刷新过程确保当前仅保存在事务日志中的任何数据也永久保存在 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 API。

Verbose

详细输出对 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

Headers

h 参数，也称为标题，用于仅显示该命令中提到的那些列。

GET /_cat/nodes?h=ip,port

在运行以上代码时，我们得到响应，如下所示：-

127.0.0.1 9300

Sort

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

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

GET /_cat/count?v

在运行以上代码时，我们得到响应，如下所示：-

epoch timestamp count
1557633536 03:58:56 17809

Elasticsearch - Cluster APIs

群集 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" : {
………………………………………………

Cluster Health

此 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
}

Cluster State

此 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
   }
………………………………………………

Cluster Stats

此 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
      }
………………………………………….

Cluster Update Settings

此 API 允许您通过使用“settings”关键字更新群集的设置。有两种类型的设置 - 持久性（在重启后应用）和瞬态（无法在完全群集重启后依然存在）。

Node Stats

此 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"
         },
………………………………………………………….

Nodes hot_threads

此 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 - Query DSL

在 Elasticsearch 中，通过基于 JSON 的查询执行搜索。查询由两个子句组成 −

Leaf Query Clauses − 这些子句是 match、term 或 range，用于在特定字段中查找特定值。
Compound Query Clauses − 这些查询是叶查询子句和其他复合查询的组合，用于提取所需信息。

Elasticsearch 支持大量查询。查询以查询关键字开头，然后以 JSON 对象的形式在其中具有条件和过滤器。不同类型的查询已在下面进行描述。

Match All Query

这是最基本的查询；它返回所有内容，并且每个对象的得分均为 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"
            }
         }
      ]
   }
}

Full Text Queries

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

Match query

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

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

Multi Match Query

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

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 Query

此查询使用查询解析器和 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"
   },
………………………………….

Term Level Queries

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

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
         ],
      }
   }
]
…………………………………………..

Range Query

此查询用于查找在给定值范围内具有值的那些对象。为此，我们需要使用操作符，如 −

gte − 大于等于
gt − greater-than
lte - 小于或等于
lt − less-than

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

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

还存在其他类型的期限级别查询，例如 -

Exists query - 如果某个字段有非空值。
Missing query - 这与 exists 查询完全相反，此查询搜索没有特定字段或字段带有空值的对象。
Wildcard or regexp query - 此查询使用正则表达式查找对象中的模式。

Compound Queries

这些查询是通过使用布尔运算符（如与运算符、或运算符、非运算符或不同索引的运算符或有函数调用等的运算符）合并到一起的不同查询的集合。

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" : [ ]
   }
}

Geo Queries

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

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 - Mapping

映射是存储在索引中的文档的概要。它定义了数据类型（如 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"
}

Field Data Types

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

Core Data Types

这些数据类型为 text、keyword、date、long、double、boolean 或 ip 等基本数据类型，几乎所有系统都支持。

Complex Data Types

这些数据类型组合了核心数据类型。其中包括数组、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

Removal of Mapping Types

在 Elasticsearch 7.0.0 或更高版本中创建的索引不再接受 default 映射。在 Elasticsearch 6.x 中创建的索引将继续在 Elasticsearch 6.x 中像以前一样运行。Elasticsearch 7.0 中不再提供 API 类型的支持。

Elasticsearch - Analysis

在搜索操作过程中处理查询时，分析模块会分析任何索引中的内容。该模块由分析器、分词器、分词器过滤器和字符过滤器组成。如果没有定义分析器，则默认情况下，内置的分析器、标记、过滤器和分词器会向分析模块注册。

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

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
      }
   ]
}

Configuring the Standard analyzer

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

在以下示例中，我们配置标准分析器让 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
      }
   ]
}

各种分析器及其描述的列表在以下所示的表中给出 −

S.No	Analyzer & Description
1	Standard analyzer (standard) 为此分析器可以设置停用词和 max_token_length。默认情况下，停用词列表为空，而 max_token_length 为 255。
2	Simple analyzer (simple) 此分析器由小写标记化程序组成。
3	Whitespace analyzer (whitespace) 此分析器由空格标记化程序组成。
4	Stop analyzer (stop) 可以配置 stopwords 和 stopwords_path。默认情况下，stopwords 初始化为英语停用词，stopwords_path 包含包含停用词的文本文件的路径。

Tokenizers

标记化程序用于从 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
      }
   ]
}

下表列出了标记化程序及其说明 −

S.No	Tokenizer & Description
1	Standard tokenizer (standard) 这构建在基于语法的标记化程序上，可以为此标记化程序配置 max_token_length。
2	Edge NGram tokenizer (edgeNGram) 可以为此标记化程序设置 min_gram、max_gram、token_chars 等设置。
3	Keyword tokenizer (keyword) 这将整个输入作为输出生成，并且可以为此设置 buffer_size。
4	Letter tokenizer (letter) 这捕获整个单词，直到遇到非字母字符为止。

Elasticsearch - Modules

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

Static Settings − 在启动 Elasticsearch 之前，需要在 config (elasticsearch.yml) 文件中配置这些设置。您需要更新集群中所有相关节点才能反映这些设置的更改。
Dynamic Settings − 可以在活动的 Elasticsearch 上设置这些设置。

我们将在本章的以下部分中讨论 Elasticsearch 的不同模块。

Cluster-Level Routing and Shard Allocation

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

Cluster-Level Shard Allocation

Setting

Possible value

Description

cluster.routing.allocation.enable

all

此默认值允许为所有种类的分片分配分片。

primaries

此选项仅允许为主分片分配分片。

new_primaries

此选项仅允许为新索引的主分片分配分片。

none

此选项不允许分配任何分片。

cluster.routing.allocation .node_concurrent_recoveries

数值（默认值为 2）

此选项限制同时分片恢复的数量。

cluster.routing.allocation .node_initial_primaries_recoveries

数值（默认值为 4）

此选项限制并行的初始主恢复的数量。

cluster.routing.allocation .same_shard.host

布尔值（默认值为 false）

此选项限制在同一个物理节点中分配超过一个相同分片的副本。

indices.recovery.concurrent _streams

数值（默认值为 3）

此选项控制分片从对等分片恢复期间每个节点的打开网络流的数量。

indices.recovery.concurrent _small_file_streams

数值（默认值为 2）

此选项控制分片恢复期间每个节点针对小文件（大小小于 5MB）打开的流数量。

cluster.routing.rebalance.enable

all

此默认值允许为所有种类的分片分配分片。

primaries

此选项仅允许为主分片分配分片。

replicas

此选项仅允许为副本分片分配分片。

none

此选项不允许分配任何种类的分片。

cluster.routing.allocation .allow_rebalance

always

此默认值始终允许重新平衡。

indices_primaries _active

这允许重新平衡，届时群集中的所有主分片都已分配。

Indices_all_active

这允许重新平衡，届时所有主分片和从属分片都已分配。

cluster.routing.allocation.cluster _concurrent_rebalance

数值（默认值为 2）

这限制了群集中并发切分平衡的数量。

cluster.routing.allocation .balance.shard

浮点数（默认值为 0.45f）

这定义了每个节点分配的切片权重因子。

cluster.routing.allocation .balance.index

浮点数（默认值为 0.55f）

这定义了分配给特定节点的每个索引切片数量的比率。

cluster.routing.allocation .balance.threshold

非负浮点数（默认值为 1.0f）

Disk-based Shard Allocation

Setting

Possible value

Description

cluster.routing.allocation.disk.threshold_enabled

布尔值（默认值为真）

这启用和禁止磁盘分配决策器。

cluster.routing.allocation.disk.watermark.low

String value(by default 85%)

这表示磁盘的最大使用量；在这一点之后，无法将任何其他切片分配到该磁盘。

cluster.routing.allocation.disk.watermark.high

字符串值（默认值为 90%）

这表示分配时的最大使用量；如果在分配时达到此点，则 Elasticsearch 将把该切片分配到另一个磁盘。

cluster.info.update.interval

字符串值（默认值为 30 秒）

这是磁盘使用量检查之间的间隔。

cluster.routing.allocation.disk.include_relocations

布尔值（默认值为真）

这决定了在计算磁盘使用量时是否考虑当前正在分配的切片。

Discovery

该模块帮助群集发现和维护其中所有节点的状态。当向群集中添加或从群集中删除某个节点时，群集状态将会发生更改。群集名称设置用于在不同群集之间创建逻辑差异。以下是一些帮助你使用云供应商提供的 API 的模块：

Azure discovery
EC2 discovery
Google compute engine discovery
Zen discovery

Gateway

该模块在整个群集重启过程中维护群集状态和切片数据。该模块的静态设置如下：

Setting

Possible value

Description

gateway.expected_nodes

数字值（默认值为 0）

为本地分片恢复而预期的集群节点数量。

gateway.expected_master_nodes

数字值（默认值为 0）

开始恢复前预期的集群主节点数量。

gateway.expected_data_nodes

数字值（默认值为 0）

开始恢复前预期的数据节点数量。

gateway.recover_after_time

字符串值（默认值为 5m）

这是磁盘使用量检查之间的间隔。

cluster.routing.allocation. disk.include_relocations

布尔值（默认值为真）

此设置指定了无论群集中加入了多少节点，恢复进程都将等待启动的时间。gateway.recover_after_nodes gateway.recover_after_master_nodes gateway.recover_after_data_nodes

HTTP

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

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

S.No	Setting & Description
1	http.port 此端口用于访问 Elasticsearch，范围为 9200-9300。
2	http.publish_port 此端口专为 http 客户端设计，在防火墙环境中也很有用。
3	http.bind_host 此项为 http 服务的主机地址。
4	http.publish_host 此项为 http 客户端的主机地址。
5	http.max_content_length 此项为 http 请求中的最大内容大小。其默认值为 100mb。
6	http.max_initial_line_length 此项为 URL 的最大大小，其默认值为 4kb。
7	http.max_header_size 此项为最大的 http 标头大小，其默认值为 8kb。
8	http.compression 此项启用或禁用对压缩的支持，其默认值为 false。
9	http.pipelinig 此项启用或禁用 HTTP 管道化。
10	http.pipelining.max_events 此项限制在关闭 HTTP 请求之前要排队的事件数量。

Indices

该模块维护设置，这些设置全局针对每个索引进行设置。以下设置主要与内存使用相关：

Circuit Breaker

此项用于防止操作导致 OutOfMemroyError。此项设置主要限制 JVM 堆大小。例如，indices.breaker.total.limit 设置的默认值是 JVM 堆的 70%。

Fielddata Cache

这主要是用于在一个字段中聚合时使用的。建议有足够的内存分配给它。使用索引中用于字段数据缓存的内存量可以得到 indices.fielddata.cache.size 设置的控制。

Node Query Cache

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

Indexing Buffer

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

Shard Request Cache

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

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

Indices Recovery

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

Setting

Default value

indices.recovery.concurrent_streams

indices.recovery.concurrent_small_file_streams

indices.recovery.file_chunk_size

512kb

indices.recovery.translog_ops

1000

indices.recovery.translog_size

512kb

indices.recovery.compress

true

indices.recovery.max_bytes_per_sec

40mb

TTL Interval

生存期 (TTL) 间隔定义了一个文档的时间，之后将删除该文档。以下动态设置用于控制这一过程−

Setting

Default value

indices.ttl.interval

60s

indices.ttl.bulk_size

1000

Node

每个节点都可以选择为数据节点，也可以不为数据节点。您可以通过更改 node.data 设置来更改此属性。将该值设定为 false 来确定节点不是数据节点。

Elasticsearch - Index Modules

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

Static – 它们仅可在索引创建期间或在关闭的索引上进行设置。
Dynamic – 它们可以在实时索引上进行更改。

Static Index Settings

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

Setting

Possible value

Description

index.number_of_shards

默认为 5，最大值为 1024

一个索引应具有的主分片数量。

index.shard.check_on_startup

默认为 false。可以为 True

在打开分片之前是否应检查分片的损坏情况。

index.codec

LZ4 compression.

用于存储数据的压缩类型。

index.routing_partition_size

自定义路由值可以进入的分片数量。

index.load_fixed_bitset_filters_eagerly

false

指示是否为嵌套查询预加载缓存的过滤器

Dynamic Index Settings

下表列出了动态索引的设置列表−

Setting

Possible value

Description

index.number_of_replicas

Defaults to 1

每个主分片具有的复制品数量。

index.auto_expand_replicas

带有破折号的分隔符下界和上界（0-5）

根据群集中的数据节点数量自动扩展复制品数量。

index.search.idle.after

30seconds

分片在被视为搜索空闲之前不能接收搜索或获取请求的时间长度。

index.refresh_interval

1 second

执行刷新操作的频率，该操作使对索引的最新更改对搜索可见。

Elasticsearch - IngestNode

index.blocks.read_only

1 true/false

设置为真以使索引和索引元数据只读，设置为假以允许写入和元数据更改。

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

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

Steps Involved

摄取节点的工作涉及两个步骤 −

Creating a pipeline
Creating a doc

Create a Pipeline

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

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

运行以上代码时，我们得到以下结果：-

{
   "acknowledged" : true
}

Create a Doc

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

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 已经变成一个整数。

Without Pipeline

现在，我们不用管道创建文档。

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 - Managing Index Lifecycle

管理索引生命周期涉及基于碎片大小和性能要求等因素执行管理操作。指数生命周期管理 (ILM) API 让你可以自动化管理你的索引的方式。

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

Policy Management APIs

API Name

Purpose

Example

Create lifecycle policy.

创建生命周期策略。如果指定策略存在，则将替换该策略并对策略版本进行增量。

PUT_ilm/policy/policy_id

Get lifecycle policy.

返回指定的策略定义。包括策略版本和上次修改日期。如果没有指定策略，则返回所有已定义的策略。

GET_ilm/policy/policy_id

Delete lifecycle policy

删除指定的生命周期策略定义。你无法删除当前正在使用的策略。如果正在使用该策略管理任何索引，则请求将失败并返回错误。

DELETE_ilm/policy/policy_id

Index Management APIs

API Name

Purpose

Example

移至生命周期步骤 API。

手动将索引移至指定步骤并执行该步骤。

POST_ilm/move/index

Retry policy.

将策略设置回出现错误的步骤并执行该步骤。

POST index/_ilm/retry

从索引 API 编辑中删除策略。

删除已分配生命周期策略并停止管理指定的索引。如果指定了索引模式，则将从所有匹配索引中删除已分配的策略。

POST index/_ilm/remove

Operation Management APIs

API Name

Purpose

Example

获取索引生命周期管理状态 API。

返回 ILM 插件的状态。响应中的 operation_mode 域显示三个状态之一：STARTED、STOPPING 或 STOPPED。

GET /_ilm/status

启动索引生命周期管理 API。

如果 ILM 插件当前已停止，则启动它。在形成群集时会自动启动 ILM。

POST /_ilm/start

停止索引生命周期管理 API。

停止所有生命周期管理操作并停止 ILM 插件。在对群集执行维护并需要防止 ILM 对索引执行任何操作时，这非常有用。

POST /_ilm/stop

Explain lifecycle API.

检索有关索引当前生命周期状态的信息，例如当前执行的阶段、操作和步骤。显示索引输入每一个阶段的时间、正在运行阶段的定义以及有关任何故障的信息。

GET index/_ilm/explain

Elasticsearch - SQL Access

它是一个组件，允许在实时中针对 Elasticsearch 执行类似于 SQL 的查询。你可以将 Elasticsearch SQL 视为一个翻译器，它既了解 SQL 也了解 Elasticsearch，并且可以轻松地按比例利用 Elasticsearch 的功能，实时读取和处理数据。

Advantages of Elasticsearch SQL

It has native integration − 根据底层存储，每个查询根据相关节点有效执行。
No external parts − 不需要额外的硬件、流程、运行时或库来查询 Elasticsearch。
Lightweight and efficient − 它引入并公开 SQL 来允许适当的全文本搜索，并支持实时功能。

Example

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 Query

以下示例显示了构造 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

Note − 通过更改上述 SQL 查询，你可以获得不同的结果集。

Elasticsearch - Monitoring

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

为了开始监控，我们需要检查集群设置，这可以使用以下方式完成 −

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

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

Collectors

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

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

Exporters

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

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

local − 此导出器将数据路由回同一集群
http − 首选导出器，可用于将数据路由到任何可通过 HTTP 访问的支持的 Elasticsearch 集群。

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

Elasticsearch - Rollup Data

汇总作业是一项周期性任务，它汇总索引模式指定的索引中的数据，然后将其汇总到新索引中。在以下示例中，我们创建了一个名为传感器的索引，其中包含不同的日期时间戳。然后，我们会创建一个汇总作业，以便使用 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"
}

Create a Rollup Job

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 - Frozen Indices

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

Elasticsearch 在每次搜索冻结索引的每个分片时都会构建分片的瞬态数据结构，并在搜索完成后立即丢弃这些数据结构。由于 Elasticsearch 不在内存中维护这些瞬态数据结构，因此冻结索引消耗的堆比普通索引少得多。这允许比其他可能的情况更高的磁盘到堆的比率。

Example for Freezing and Unfreezing

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

POST /index_name/_freeze
POST /index_name/_unfreeze

预期对冻结索引的搜索将缓慢执行。冻结索引不适用于高搜索负载。冻结索引的搜索可能需要几秒或几分钟才能完成，即使在索引未冻结时，相同的搜索可以在几毫秒内完成。

Searching a Frozen Index

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

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

Monitoring Frozen Indices

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

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

Elasticsearch - Testing

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

Unit testing
Integration testing
Randomized testing

Prerequisites

要开始测试，你需要将 Elasticsearch testing 依赖项添加到你的程序中。你可以为此目的使用 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() 函数将创建索引，你需要指定设置、类型和数据。

Unit Testing

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

Integration Testing

集成测试在集群中使用多个节点。ESIntegTestCase 类用于此测试。有很多方法可以简化测试用例的准备工作。

S.No	Method & Description
1	refresh() 刷新群集中的所有索引
2	ensureGreen() 确保一个绿色的群集运行状态
3	ensureYellow() 确保黄色健康群集状态
4	createIndex(name) 使用传递到该方法的名称创建索引
5	flush() 群集中的所有索引都已刷新
6	flushAndRefresh() flush() and refresh()
7	indexExists(name) 验证指定索引的存在性
8	clusterService() 返回群集服务 Java 类
9	cluster() 返回测试群集类

Test Cluster Methods

S.No	Method & Description
1	ensureAtLeastNumNodes(n) 确保群集中启动的最小节点数大于或等于指定数字。
2	ensureAtMostNumNodes(n) 确保群集中启动的最大节点数小于或等于指定数字。
3	stopRandomNode() 在群集中停止一个随机节点
4	stopCurrentMasterNode() 停止主节点
5	stopRandomNonMaster() 停止群集中非主节点的随机节点。
6	buildNode() Create a new node
7	startNode(settings) Start a new node
8	nodeSettings() 覆盖该方法以更改节点设置。

Accessing Clients

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

S.No	Method & Description
1	iterator() 它有助于访问所有可用客户端。
2	masterClient() 它返回与主节点通信的客户端。
3	nonMasterClient() 它返回不与主节点通信的客户端。
4	clientNodeClient() 它返回当前在客户端节点上启用的客户端。

Randomized Testing

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

Generating Random Data

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

Method

Return value

getRandom()

Instance of random class

randomBoolean()

Random boolean

randomByte()

Random byte

randomShort()

Random short

randomInt()

Random integer

randomLong()

Random long

randomFloat()

Random float

randomDouble()

Random double

randomLocale()

Random locale

randomTimeZone()

Random time zone

randomFrom()

Random element from array

Assertions

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

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

Elasticsearch - Kibana Dashboard

Kibana 仪表盘是可视化和搜索的集合。你可以布置、调整和编辑仪表盘内容，然后保存仪表盘以供共享。在本章中，我们将了解如何创建和编辑仪表盘。

Dashboard Creation

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

若要向仪表盘添加可视化，我们选择“添加”菜单，然后从提供的预置可视化中选择。我们从列表中选择了以下可视化选项。

在选择上述可视化后，我们得到的仪表盘如下所示。我们稍后可以添加并编辑仪表盘，更改元素和添加新元素。

Inspecting Elements

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

Sharing Dashboard

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

Elasticsearch - Filtering by Field

Kibana 主页中可用的发现功能使我们能够从各个角度探索数据集。你可以搜索和筛选选定索引模式的数据。数据通常以一段时间内值的分布形式存在。

要探索电子商务数据样本，我们会单击 Discover 图标，如下面图片所示。这将会调出数据和图表。

Filtering by Time

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

Filtering by Fields

还可以使用 Add Filter 选项按字段筛选数据集，如下所示。在此，我们添加一个或多个字段并在应用筛选器后获取相应的结果。在我们的示例中我们选择字段 day_of_week ，然后选择该字段的操作符为 is ，值则为 Sunday 。

接下来，我们会单击使用以上筛选条件保存。应用了筛选条件的结果集如下所示。

Elasticsearch - Data Tables

数据表是一种用于显示已组合聚合的原始数据的可视化类型。数据表可用于显示各种类型的聚合。为了创建数据表，我们应该仔细了解这里讨论的步骤。

Visualize

在 Kibana 主屏幕中，我们找到了可视化名称选项，可视化名称选项使我们能够从 Elasticsearch 中存储的指标创建可视化和聚合。下图显示了此选项。

Select Data Table

接下来，我们在各种可用的可视化选项中选择数据表选项。该选项显示在以下图像 &miuns;

Select Metrics

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

在对数据表运行上述配置后，我们得到的结果如下图所示 −

Elasticsearch - Region Maps

区域地图在地理地图中显示指标。它对于观察不同地理区域中具有不同强度的锚定数据非常有用。较暗的阴影通常表示较高的值，较浅的阴影表示较低的值。

创建此可视化的步骤如下所示 −

Visualize

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

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

Choose the Metrics

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

以下最终结果显示了我们在应用选择后得到的区域地图。请注意标签中提到的颜色阴影及其值。

Elasticsearch - Pie Charts

饼图是最简单、最著名的可视化工具之一。它将数据表示为不同颜色的圆圈切片。可以将标签与百分比数据值一起显示在圆圈内。圆圈也可以变成甜甜圈的形状。

Visualize

在 Kibana 主屏幕中，我们找到可视化选项名称，该选项允许我们从 Elasticsearch 中存储的索引创建可视化和聚合。我们选择添加一个新的可视化，并选择如下所示的选项，即饼图。

Choose the Metrics

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

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

Pie Chart Options

移动到饼状图下的选项选项卡上，我们可以看到各种配置选项，以更改饼状图中数据的显示外观和排列。在以下示例中，饼状图显示为甜甜圈状，且标签显示在顶部。

Elasticsearch - Area and Bar Charts

面积图是折线图的扩展，其中折线图和坐标轴之间的面积会突出显示为某种颜色。条形图表示成一系列值的组织数据，然后沿坐标轴绘制。它可以由水平条或垂直条组成。

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

Area Chart

在 Kibana 主屏幕中，我们找到了可视化名称选项，可视化名称选项使我们能够从 Elasticsearch 中存储的指标创建可视化和聚合。我们选择添加一个新的可视化，并选择下图所示的图像中的面积图选项。

Choose the Metrics

下一个屏幕会提示我们选择用于创建面积图的指标。此处，我们选择总和作为聚合指标的类型。然后我们选择 total_quantity 字段作为要作为指标使用的字段。在 X 轴上，我们选择了 order_date 字段并以 5 的大小用给定的指标拆分序列。

运行上述配置之后，我们将得到如下所示的面积图作为输出 −

Horizontal Bar Chart

同样，对于水平条形图，我们从 Kibana 主屏幕选择新的可视化效果，然后选择水平条形图选项。然后，我们选择如下图所示的指标。在此处，我们选择求和作为名为产品数量的字段的聚合。然后，我们选择带有日期直方图的存储桶作为字段订单日期。

在运行上述配置时，我们可看到一个如下所示的水平条形图 −

Vertical Bar Chart

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

在此处，我们选择求和作为名为产品数量的字段的聚合。然后，我们选择带有日期直方图的存储桶作为字段订单日期，间隔为每周。

在运行上述配置时，将生成如下图所示的图表 −

Elasticsearch - Time Series

时间序列是对特定时间序列中数据序列的表示。例如，从当月第一天到最后一天的每一天的数据。数据点之间的间隔保持恒定。任何包含时间组件的数据集都可以表示为时间序列。

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

Choose Metrics

首先，我们需要选择将用于创建时间序列的索引模式、数据字段和间隔。从样本电子商务数据集中，我们将 order_date 选为字段，将 1d 选为间隔。我们使用 Panel Options 选项卡进行这些选择。我们还将此选项卡中的其他值保留为默认值，以获取时间序列的默认颜色和格式。

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

Result

此配置的最终结果如下所示。请注意，我们正在为此图形使用 Month to Date 的时间段。不同的时间段将产生不同的结果。

Elasticsearch - Tag Clouds

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

Visualize

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

Choose the Metrics

下一屏提示我们选择将用于创建标签云的指标。在此，我们将数量选择为聚合指标的类型。然后，我们将 productName 字段选择为用作标签的关键字。

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

Elasticsearch - Heat Maps

热图是一种可视化类型，其中不同色调的颜色代表图表中的不同区域。值可能是连续变化的，因此颜色的细微差别会随着值而变化。它们对于表示连续变化的数据以及离散数据都非常有用。

在本章中，我们将使用名为 sample_data_flights 的数据集来构建热图图表。在其中，我们考虑名为航班始发国和目的国的变量并进行计数。

在 Kibana 主屏幕上，我们找到了名为可视化选项，它允许我们从存储在 Elasticsearch 中的索引创建可视化和聚合。我们选择添加一个新的可视化并选择热图作为如下所示的选项：

Choose the Metrics

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