Elasticsearch Reference [5.2] » Getting Started

Elasticsearch is a highly scalable open-source full-text search and analytics engine. It allows you to store, search, and analyze big volumes of data quickly and in near real time. It is generally used as the underlying engine/technology that powers applications that have complex search features and requirements.

Elasticsearch是可高度擴展的、開源的、全字段搜索與分析的引擎。允許快速的存儲、搜索以及分析大量的數據，性能接近實時。一般用來作爲進行復雜搜索特徵和需求的應用的解決方案。

Here are a few sample use-cases that Elasticsearch could be used for:

You run an online web store where you allow your customers to search for products that you sell. In this case, you can use Elasticsearch to store your entire product catalog and inventory and provide search and autocomplete suggestions for them.
You want to collect log or transaction data and you want to analyze and mine this data to look for trends, statistics, summarizations, or anomalies. In this case, you can use Logstash (part of the Elasticsearch/Logstash/Kibana stack) to collect, aggregate, and parse your data, and then have Logstash feed this data into Elasticsearch. Once the data is in Elasticsearch, you can run searches and aggregations to mine any information that is of interest to you.
You run a price alerting platform which allows price-savvy customers to specify a rule like "I am interested in buying a specific electronic gadget and I want to be notified if the price of gadget falls below $X from any vendor within the next month". In this case you can scrape vendor prices, push them into Elasticsearch and use its reverse-search (Percolator) capability to match price movements against customer queries and eventually push the alerts out to the customer once matches are found.
You have analytics/business-intelligence needs and want to quickly investigate, analyze, visualize, and ask ad-hoc questions on a lot of data (think millions or billions of records). In this case, you can use Elasticsearch to store your data and then use Kibana (part of the Elasticsearch/Logstash/Kibana stack) to build custom dashboards that can visualize aspects of your data that are important to you. Additionally, you can use the Elasticsearch aggregations functionality to perform complex business intelligence queries against your data.

以下是一些Elasticsearch可以支持的簡單用例：

經營在線網店時，允許用戶在線搜索商品。這種場景下，可以使用Elasticsearch存儲所有商品的特徵和分類，併爲上品提供搜索功能以及完全的建議。
可以用來蒐集日誌或者交易數據，然後分析或者挖掘這些數據以獲取購買趨勢、統計數據、彙總數據、或者異常。這種情況下，你可以使用Logstash（Elasticsearch/Logstash/Kibana技術棧的一部分）去收集、聚合或者分析數據，然後將Logstash數據傳輸給Elasticsearch。一旦數據存入Elasticsearch，可以搜索或者聚合數據以挖掘你感興趣的信息。
可以運行價格提醒平臺，支持客戶設定一些價格提醒規則：例如對某種商品比較感興趣，當此商品價格低於某個價格時，可以通知此客戶。這種情況下，你可以抓取買方價格，然後將它們推送到Elasticsearch，然後使用逆向搜索能力對價格變動和客戶需求相匹配，最終將找到的價格匹配的商品通知客戶。
有分析／商業智能需求，想快速調查、分析、可視化或者詢問大量數據的臨時問題（想象一下百萬或者十億級別的記錄）。這種情況下，你可以使用Elasticsearch存儲數據，然後使用Kibana來創建自定義的儀表盤，可以將你認爲重要的數據可視化顯示。另外，可以使用Elasticsearch聚合功能執行復雜的商業智能需求。

For the rest of this tutorial, I will guide you through the process of getting Elasticsearch up and running, taking a peek inside it, and performing basic operations like indexing, searching, and modifying your data. At the end of this tutorial, you should have a good idea of what Elasticsearch is, how it works, and hopefully be inspired to see how you can use it to either build sophisticated search applications or to mine intelligence from your data.

本文剩下的部分，將會引導你啓動Elasticsearch、運行、執行基本操作諸如索引、搜索以及修正數據。本文最後，你會發現Elasticsearch是什麼、怎樣工作、以及對你使用它創建搜索應用或者數據挖掘智能化方面是多麼有幫助。

1、Basic Conceptsedit

基本概念

There are a few concepts that are core to Elasticsearch. Understanding these concepts from the outset will tremendously help ease the learning process.

Elasticsearch有一些核心概念。理解這些概念有助於簡化學習過程。

Near Realtime (NRT)edit

接近實時

Elasticsearch is a near real time search platform. What this means is there is a slight latency (normally one second) from the time you index a document until the time it becomes searchable.

Elasticsearch是接近實時搜索的平臺。這就意味着從你開始索引文檔開始到文檔變爲可搜索狀態會有輕微的延遲（通常是1s）。

Clusteredit

集羣

A cluster is a collection of one or more nodes (servers) that together holds your entire data and provides federated indexing and search capabilities across all nodes. A cluster is identified by a unique name which by default is "elasticsearch". This name is important because a node can only be part of a cluster if the node is set up to join the cluster by its name.

Make sure that you don’t reuse the same cluster names in different environments, otherwise you might end up with nodes joining the wrong cluster. For instance you could use logging-dev, logging-stage, and logging-prod for the development, staging, and production clusters.

Note that it is valid and perfectly fine to have a cluster with only a single node in it. Furthermore, you may also have multiple independent clusters each with its own unique cluster name.

集羣是一個或者多個節點（servers）組成，共同存儲全部數據並提供索引和搜索能力。集羣通過唯一的名字區分，默認是elasticsearch。這個名字非常重要，因爲一個節點只能加入一個集羣，就是通過這個名字加入集羣的。

確保不會使用相同的集羣名字，否則節點將會加入錯誤的集羣。例如你可以使用logging-dev,logging-stage以及logging-prod用於開發、級連、以及生產環境。

注意：集羣只有一個節點是正確的。而且，你以後可能會有多個獨立的集羣，每個集羣都有自己獨一無二的集羣名字。

Nodeedit

節點

A node is a single server that is part of your cluster, stores your data, and participates in the cluster’s indexing and search capabilities. Just like a cluster, a node is identified by a name which by default is a random Universally Unique IDentifier (UUID) that is assigned to the node at startup. You can define any node name you want if you do not want the default. This name is important for administration purposes where you want to identify which servers in your network correspond to which nodes in your Elasticsearch cluster.

一個節點就是一個單獨的server，作爲集羣的一部分，存儲數據，參與集羣的索引以及搜索操作。就像集羣一樣，一個節點可以用一個唯一的名字標識，默認是UUID，首次啓動時分配。如果不想使用默認名字，可以使用任意節點名字。這個名字對於你確定哪些servers和Elasticsearch集羣中哪些節點相關是非常重要的。

A node can be configured to join a specific cluster by the cluster name. By default, each node is set up to join a cluster named elasticsearch which means that if you start up a number of nodes on your network and—assuming they can discover each other—they will all automatically form and join a single cluster named elasticsearch.

一個節點可以通過集羣名字配置爲加入一個特定的集羣。默認的，每個節點設定爲加入名爲elasticsearch的集羣，即如果啓動一些節點－假定它們可以發現對方－它們會自動形成並加入一個名爲elasticsearch的集羣。

In a single cluster, you can have as many nodes as you want. Furthermore, if there are no other Elasticsearch nodes currently running on your network, starting a single node will by default form a new single-node cluster named elasticsearch.

在一個單獨的集羣中，要多少節點就可以有多少節點。而且，如果沒有其他的Elasticsearch節點運行在你的網絡中，啓動一個單獨的節點將默認的創建一個名爲elasticsearch的集羣。

Indexedit

索引

An index is a collection of documents that have somewhat similar characteristics. For example, you can have an index for customer data, another index for a product catalog, and yet another index for order data. An index is identified by a name (that must be all lowercase) and this name is used to refer to the index when performing indexing, search, update, and delete operations against the documents in it.

In a single cluster, you can define as many indexes as you want.

索引是具有某些相似特徵的文檔的集合。例如，可以用一個索引存儲用戶數據，一個索引存儲生產目錄，以及另外一個索引存儲其他有序數據。一個索引用一個名字標識（必須是小寫字母），這個名字用來找到這個索引，當執行索引、搜索、更新以及刪除操作時，都會用到這個名字。

在一個單獨的集羣中，索引的個數可以要多少有多少。

Typeedit

類型

Within an index, you can define one or more types. A type is a logical category/partition of your index whose semantics is completely up to you. In general, a type is defined for documents that have a set of common fields. For example, let’s assume you run a blogging platform and store all your data in a single index. In this index, you may define a type for user data, another type for blog data, and yet another type for comments data.

索引內部，可以定義一種或者多種類型。一個類型就是一個邏輯上目錄，它的語義對於你來說是完整的。大體來說，一種類型可以定義爲包含一系列共同字段的文檔。例如，讓我們假定你運行了一個博客平臺，在一個單獨的索引中存儲你所有的數據。在這個索引中，你可以爲用戶數據定義一種類型，爲博文數據定義一種類型，爲評論數據定義一種類型。

Documentedit

文檔

A document is a basic unit of information that can be indexed. For example, you can have a document for a single customer, another document for a single product, and yet another for a single order. This document is expressed in JSON (JavaScript Object Notation) which is an ubiquitous internet data interchange format.

Within an index/type, you can store as many documents as you want. Note that although a document physically resides in an index, a document actually must be indexed/assigned to a type inside an index.

一個文檔是可以被索引的基礎信息單元。例如，你可以對每個單獨的客戶創建一個文檔，爲每個單獨的產品創建另一個文檔，爲一個單獨的命令創建一個文檔。這個文檔使用JSON格式表達，這是一種無處不在的互聯網數據交互方式。

在索引／類型內部，想要存儲多少文檔就可以存儲多少。注意：儘管文檔物理上必須存儲在索引中，但是實際上一個文檔必須索引到或者分配到索引內部的某個類型中。

Shards & Replicasedit

分片以及備份

An index can potentially store a large amount of data that can exceed the hardware limits of a single node. For example, a single index of a billion documents taking up 1TB of disk space may not fit on the disk of a single node or may be too slow to serve search requests from a single node alone.

一個索引可以存儲大量的數據，可以存儲超出單個節點的硬件限制。例如，一個索引包含十億個文檔，佔有1TB的磁盤空間，那麼一個單獨節點的磁盤是無法存放的，或者說對於單個節點來說，存儲這麼數據對於搜索來說也太慢了。

To solve this problem, Elasticsearch provides the ability to subdivide your index into multiple pieces called shards. When you create an index, you can simply define the number of shards that you want. Each shard is in itself a fully-functional and independent "index" that can be hosted on any node in the cluster.

爲了解決這個問題，Elasticsearch提供將索引劃分成多個稱謂shards的數據分片。當創建一個索引時，可以簡單的定義shards的數量。每個shard自己都是具有全功能並且獨立的“索引”，可以存放到集羣中的任何一個節點上。

Sharding is important for two primary reasons:

It allows you to horizontally split/scale your content volume
It allows you to distribute and parallelize operations across shards (potentially on multiple nodes) thus increasing performance/throughput

Sharding（分片）的重要性有以下兩個原因：

允許水平分割或者擴展數據
允許在shards之間進行分佈式或者並行操作，這樣可以提高性能或者吞吐量

The mechanics of how a shard is distributed and also how its documents are aggregated back into search requests are completely managed by Elasticsearch and is transparent to you as the user.

In a network/cloud environment where failures can be expected anytime, it is very useful and highly recommended to have a failover mechanism in case a shard/node somehow goes offline or disappears for whatever reason. To this end, Elasticsearch allows you to make one or more copies of your index’s shards into what are called replica shards, or replicas for short.

shard的分佈式機制以及文檔聚合機制是完全由Elasticsearch管理並對用戶來說是透明的。

在網絡或者雲環境下，任何時候都可能發生任何錯誤，因此高度建議採用備份機制以避免數據丟失。Elasticsearch允許對索引的shards備份一份或者多份。

Replication is important for two primary reasons:

It provides high availability in case a shard/node fails. For this reason, it is important to note that a replica shard is never allocated on the same node as the original/primary shard that it was copied from.
It allows you to scale out your search volume/throughput since searches can be executed on all replicas in parallel.

備份的重要性有兩個原因：

提供某個shard或者節點失效時的高可用性。出於這個原因，備份的shards之間不應當分佈在相同的節點上。
允許擴展搜索的數據量或者吞儲量，這樣可以並行搜索所有備份。

To summarize, each index can be split into multiple shards. An index can also be replicated zero (meaning no replicas) or more times. Once replicated, each index will have primary shards (the original shards that were replicated from) and replica shards (the copies of the primary shards). The number of shards and replicas can be defined per index at the time the index is created. After the index is created, you may change the number of replicas dynamically anytime but you cannot change the number of shards after-the-fact.

總的來說，每個索引可以劃分成多個shards。一個索引可以沒有備份或者有很多備份。一旦備份了，每個索引都會有主要shards（原始的shard，其他備份shard都是從這個shard上拷貝）和備份shard。shards和備份的數量可以在創建索引時指定。在索引創建之後，可以動態的改變備份數，但是無法更改shards的數量（備份數可改，但是主要shards數目不能改）

By default, each index in Elasticsearch is allocated 5 primary shards and 1 replica which means that if you have at least two nodes in your cluster, your index will have 5 primary shards and another 5 replica shards (1 complete replica) for a total of 10 shards per index.

默認情況下，每個Elasticsearch中的索引分配5個主shards，每個主shard都有一個備份，即集羣至少要有兩個節點，索引將會有5個主要shards和另外5個備份shards（一個完整的備份），即每個索引都會有10個shards。

Each Elasticsearch shard is a Lucene index. There is a maximum number of documents you can have in a single Lucene index. As of LUCENE-5843, the limit is 2,147,483,519(= Integer.MAX_VALUE - 128) documents. You can monitor shard sizes using the _cat/shards api.

每個Elasticsearch shard是一個Lucene索引。每個單獨的Lucene索引的文檔數都有最大值。就像Lucene-5843，限制是2，147，483，519（=整型的最大值－128)個文檔。你可以通過食用_cat/shards api來監控shard的尺寸。

2、Installationedit

安裝部署

Elasticsearch requires at least Java 8. Specifically as of this writing, it is recommended that you use

the Oracle JDK version 1.8.0_73. Java installation varies from platform to platform so we won’t go

into those details here. Oracle’s recommended installation documentation can be found on

Oracle’s website. Suffice to say, before you install Elasticsearch, please check your Java version

first by running (and then install/upgrade accordingly if needed):

Elasticsearch至少需要Java 8。本文推薦你使用Oracle JDK version 1.8.0_73。在不同的平臺上安裝Java

會有很大不同，這裏我們就不討論這些細節了。Oracle的推薦安裝文檔可以在Oracle網站上找到。在安裝

Elasticsearch之前，最好檢查一下java版本。

java -version
echo $JAVA_HOME

Once we have Java set up, we can then download and run Elasticsearch. The binaries are available

from www.elastic.co/downloads along with all the releases that have been made in the past.

For each release, you have a choice among a zip or tar archive, or a DEB or RPM package.

For simplicity, let’s use the tar file.

一旦安裝好Java，可以下載並運行Elasticsearch。從www.elastic.co/downloads可以找到二進制文件，

也可以在過去的下載列表中獲取之前所有的發佈版本。對於每個發佈版，可以選擇zip或者tar格式，也可以

選擇DEB或者RPM壓縮包。爲簡單起見，這裏使用tar格式文件。

Let’s download the Elasticsearch 5.2.0 tar as follows (Windows users should download the zip package):

像下面一樣下載Elasticsearch 5.2.0（Windows用戶可以下載zip壓縮包）：

curl -L -O https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-5.2.0.tar.gz

Then extract it as follows (Windows users should unzip the zip package):

然後解壓文件：

tar -xvf elasticsearch-5.2.0.tar.gz

It will then create a bunch of files and folders in your current directory. We then go into the bin directory as follows:

將會在當前目錄中創建大量的文件和文件夾。然後進入bin目錄：

cd elasticsearch-5.2.0/bin

And now we are ready to start our node and single cluster (Windows users should run the elasticsearch.bat file):

現在可以啓動程序，即啓動單節點集羣：

./elasticsearch

If everything goes well, you should see a bunch of messages that look like below:

如果所有事情都ok的話，你可以看到如下的信息：

[2016-09-16T14:17:51,251][INFO ][o.e.n.Node               ] [] initializing ...
[2016-09-16T14:17:51,329][INFO ][o.e.e.NodeEnvironment    ] [6-bjhwl] using [1] data paths, mounts [[/ (/dev/sda1)]], net usable_space [317.7gb], net total_space [453.6gb], spins? [no], types [ext4]
[2016-09-16T14:17:51,330][INFO ][o.e.e.NodeEnvironment    ] [6-bjhwl] heap size [1.9gb], compressed ordinary object pointers [true]
[2016-09-16T14:17:51,333][INFO ][o.e.n.Node               ] [6-bjhwl] node name [6-bjhwl] derived from node ID; set [node.name] to override
[2016-09-16T14:17:51,334][INFO ][o.e.n.Node               ] [6-bjhwl] version[5.2.0], pid[21261], build[f5daa16/2016-09-16T09:12:24.346Z], OS[Linux/4.4.0-36-generic/amd64], JVM[Oracle Corporation/Java HotSpot(TM) 64-Bit Server VM/1.8.0_60/25.60-b23]
[2016-09-16T14:17:51,967][INFO ][o.e.p.PluginsService     ] [6-bjhwl] loaded module [aggs-matrix-stats]
[2016-09-16T14:17:51,967][INFO ][o.e.p.PluginsService     ] [6-bjhwl] loaded module [ingest-common]
[2016-09-16T14:17:51,967][INFO ][o.e.p.PluginsService     ] [6-bjhwl] loaded module [lang-expression]
[2016-09-16T14:17:51,967][INFO ][o.e.p.PluginsService     ] [6-bjhwl] loaded module [lang-groovy]
[2016-09-16T14:17:51,967][INFO ][o.e.p.PluginsService     ] [6-bjhwl] loaded module [lang-mustache]
[2016-09-16T14:17:51,967][INFO ][o.e.p.PluginsService     ] [6-bjhwl] loaded module [lang-painless]
[2016-09-16T14:17:51,967][INFO ][o.e.p.PluginsService     ] [6-bjhwl] loaded module [percolator]
[2016-09-16T14:17:51,968][INFO ][o.e.p.PluginsService     ] [6-bjhwl] loaded module [reindex]
[2016-09-16T14:17:51,968][INFO ][o.e.p.PluginsService     ] [6-bjhwl] loaded module [transport-netty3]
[2016-09-16T14:17:51,968][INFO ][o.e.p.PluginsService     ] [6-bjhwl] loaded module [transport-netty4]
[2016-09-16T14:17:51,968][INFO ][o.e.p.PluginsService     ] [6-bjhwl] loaded plugin [mapper-murmur3]
[2016-09-16T14:17:53,521][INFO ][o.e.n.Node               ] [6-bjhwl] initialized
[2016-09-16T14:17:53,521][INFO ][o.e.n.Node               ] [6-bjhwl] starting ...
[2016-09-16T14:17:53,671][INFO ][o.e.t.TransportService   ] [6-bjhwl] publish_address {192.168.8.112:9300}, bound_addresses {{192.168.8.112:9300}
[2016-09-16T14:17:53,676][WARN ][o.e.b.BootstrapCheck     ] [6-bjhwl] max virtual memory areas vm.max_map_count [65530] likely too low, increase to at least [262144]
[2016-09-16T14:17:56,731][INFO ][o.e.h.HttpServer         ] [6-bjhwl] publish_address {192.168.8.112:9200}, bound_addresses {[::1]:9200}, {192.168.8.112:9200}
[2016-09-16T14:17:56,732][INFO ][o.e.g.GatewayService     ] [6-bjhwl] recovered [0] indices into cluster_state
[2016-09-16T14:17:56,748][INFO ][o.e.n.Node               ] [6-bjhwl] started

Without going too much into detail, we can see that our node named "6-bjhwl" (which will be a different set of characters in

your case) has started and elected itself as a master in a single cluster. Don’t worry yet at the moment what master means.

The main thing that is important here is that we have started one node within one cluster.

不需要仔細觀察細節，就可以看到名爲"6-bjhwl”（每個啓動的節點都會不同）的節點已經啓動並將自己選爲單節點集羣的

master節點。這時候不用着急知道master的含義。現在最重要的事情是我們已經啓動了單節點集羣。

As mentioned previously, we can override either the cluster or node name. This can be done from the command line when

starting Elasticsearch as follows:

就像前面提到的，我們可以自己命名集羣或者節點的名字。這個可以通過命令行實現，如下所示：

./elasticsearch -Ecluster.name=my_cluster_name -Enode.name=my_node_name

Also note the line marked http with information about the HTTP address (192.168.8.112) and port (9200) that our node is

reachable from. By default, Elasticsearch uses port 9200 to provide access to its REST API. This port is configurable if

necessary.

需要知道的是：可以通過http地址192.168.8.112，端口9200來訪問節點。默認情況下，Elasticsearch使用端口9200提供

REST API的訪問方式。如果需要，可以配置此端口。

3、Exploring Your Clusteredit

探索集羣

The REST APIedit

REST API

Now that we have our node (and cluster) up and running, the next step is to understand how to communicate with it. Fortunately, Elasticsearch provides a very comprehensive and powerful REST API that you can use to interact with your cluster. Among the few things that can be done with the API are as follows:

現在我們的節點（或者集羣）已經啓動並運行，下一步就是理解如何通信。幸運的是，Elasticsearch提供非常方便的REST API，可以用來和集羣進行交互，能夠做的事包括以下：

Check your cluster, node, and index health, status, and statistics
Administer your cluster, node, and index data and metadata
Perform CRUD (Create, Read, Update, and Delete) and search operations against your indexes
Execute advanced search operations such as paging, sorting, filtering, scripting, aggregations, and many others
檢查集羣、節點、索引健康、狀態、以及統計信息
管理集羣、節點，以及索引數據和元數據
執行CRUD（創建、讀取、更新、刪除）以及搜索操作
執行高級搜索操作例如分頁、排序、過濾、腳本執行、聚合以及很多其他的操作

4、Cluster Healthedit

集羣健康

Let’s start with a basic health check, which we can use to see how our cluster is doing. We’ll be using curl to do this but you can use any tool that allows you to make HTTP/REST calls. Let’s assume that we are still on the same node where we started Elasticsearch on and open another command shell window.

讓我們開始基本的集羣健康檢查，可以用來查看集羣是怎樣運行的。將使用curl命令來查看，但是你可以使用任何支持HTTP/REST調用的工具。假定我們在啓動Elasticsearch的節點上，並開啓另外一個命令行窗口。

To check the cluster health, we will be using the _cat API. You can run the command below in Kibana’s Console by clicking "VIEW IN CONSOLE" or with curl by clicking the "COPY AS CURL" link below and pasting it into a terminal.

想要檢查集羣健康，將使用_cat API。你可以在Kibana's控制檯運行這些命令，或者通過點擊"COPY AS CURL”鏈接來在終端發送命令：

GET /_cat/health?v

And the response:

返回信息如下：

epoch timestamp cluster status node.total node.data shards pri relo init unassign pending_tasks max_task_wait_time active_shards_percent

1475247709 17:01:49 elasticsearch green 1 1 0 0 0 0 0 0 - 100.0%

We can see that our cluster named "elasticsearch" is up with a green status.

Whenever we ask for the cluster health, we either get green, yellow, or red. Green means everything is good (cluster is fully functional), yellow means all data is available but some replicas are not yet allocated (cluster is fully functional), and red means some data is not available for whatever reason. Note that even if a cluster is red, it still is partially functional (i.e. it will continue to serve search requests from the available shards) but you will likely need to fix it ASAP since you have missing data.

Also from the above response, we can see a total of 1 node and that we have 0 shards since we have no data in it yet. Note that since we are using the default cluster name (elasticsearch) and since Elasticsearch uses unicast network discovery by default to find other nodes on the same machine, it is possible that you could accidentally start up more than one node on your computer and have them all join a single cluster. In this scenario, you may see more than 1 node in the above response.

可以看到集羣名字爲“elasticsearch”，啓動後狀態爲“green”

無論什麼時候查看集羣健康狀況，狀態只能是green，yellow，red三種之一。green意味着所有事情都很好（集羣功能良好），yellow意味着所有數據可用但是某些備份還沒有分配（集羣功能良好）。red意味着某些數據因爲某些原因不可用。注意，即使集羣是red，仍然部分可用（例如，集羣仍然可以提供可用shards的搜索功能），但是你需要修復集羣，因爲你可能丟失了某些數據。

We can also get a list of nodes in our cluster as follows:

通過以下命令，可以獲取集羣列表：

GET /_cat/nodes?v

And the response:

返回信息如下：

ip heap.percent ram.percent cpu load_1m load_5m load_15m node.role master name

127.0.0.1 10 5 5 4.46 mdi * PB2SGZY

Here, we can see our one node named "PB2SGZY", which is the single node that is currently in our cluster.

這裏可以看到節點名字爲“PB2SGZY”, 這就是我們集羣中的唯一的節點。

5、List All Indicesedit

Now let’s take a peek at our indices:

GET /_cat/indices?v

Elasticsearch Reference [5.2] » Getting Started

2、Installationedit

5、List All Indicesedit

11、Deleting Documentsedit