« Compact and aligned text (CAT) APIs Cross-cluster replication APIs »

› ›

集群API

edit

集群API

edit

节点规格

edit

一些集群级别的API可能对节点的子集进行操作，这些子集可以通过节点过滤器来指定。例如，任务管理、节点统计和节点信息API都可以从过滤后的节点集合中报告结果，而不是从所有节点中报告。

节点过滤器是以逗号分隔的单个过滤器列表，每个过滤器都会从选定的子集中添加或删除节点。每个过滤器可以是以下之一：

_all，将所有节点添加到子集中。
_local，将本地节点添加到子集中。
_master，将当前选中的主节点添加到子集中。
一个节点ID或名称，将此节点添加到子集中。
一个IP地址或主机名，将所有匹配的节点添加到子集中。
一个模式，使用*通配符，将所有名称、地址或主机名与模式匹配的节点添加到子集中。
master:true、data:true、ingest:true、voting_only:true、ml:true或coordinating_only:true，分别将所有符合主节点资格的节点、所有数据节点、所有摄取节点、所有仅投票节点、所有机器学习节点和所有仅协调节点添加到子集中。
master:false、data:false、ingest:false、voting_only:false、ml:false或coordinating_only:false，分别从子集中移除所有符合主节点资格的节点、所有数据节点、所有摄取节点、所有仅投票节点、所有机器学习节点和所有仅协调节点。
一对模式，使用*通配符，形式为attrname:attrvalue，将所有具有自定义节点属性且名称和值与各自模式匹配的节点添加到子集中。自定义节点属性通过在配置文件中设置形式为node.attr.attrname: attrvalue的属性来配置。

节点过滤器按照给定的顺序运行，这在使用移除节点的过滤器时非常重要。例如，_all,master:false 表示除主节点外的所有节点，但 master:false,_all 表示与 _all 相同，因为 _all 过滤器在 master:false 过滤器之后运行。

如果没有给出过滤器，默认情况下会选择所有节点。然而，如果给出了任何过滤器，它们将从一个空的已选子集开始运行。这意味着像master:false这样的过滤器，它们从已选子集中移除节点，只有在它们之后有其他过滤器时才有用。当单独使用时，master:false不会选择任何节点。

以下是一些在使用节点信息API时使用节点过滤器的示例。

# If no filters are given, the default is to select all nodes
GET /_nodes
# Explicitly select all nodes
GET /_nodes/_all
# Select just the local node
GET /_nodes/_local
# Select the elected master node
GET /_nodes/_master
# Select nodes by name, which can include wildcards
GET /_nodes/node_name_goes_here
GET /_nodes/node_name_goes_*
# Select nodes by address, which can include wildcards
GET /_nodes/10.0.0.3,10.0.0.4
GET /_nodes/10.0.0.*
# Select nodes by role
GET /_nodes/_all,master:false
GET /_nodes/data:true,ingest:true
GET /_nodes/coordinating_only:true
GET /_nodes/master:true,voting_only:false
# Select nodes by custom attribute (e.g. with something like `node.attr.rack: 2` in the configuration file)
GET /_nodes/rack:2
GET /_nodes/ra*:2
GET /_nodes/ra*:2*

集群分配解释 API

edit

提供了一个分片当前分配的解释。

GET _cluster/allocation/explain
{
  "index": "my-index-000001",
  "shard": 0,
  "primary": false,
  "current_node": "my-node"
}

请求

edit

GET _cluster/allocation/explain

POST _cluster/allocation/explain

先决条件

edit

如果启用了Elasticsearch安全功能，您必须拥有monitor或manage 集群权限才能使用此API。

描述

edit

集群分配解释API的目的是为集群中的分片分配提供解释。对于未分配的分片，解释API提供了分片未分配的原因。对于已分配的分片，解释API提供了分片为何留在当前节点而未移动或重新平衡到另一个节点的原因。当你试图诊断为何一个分片未分配或为何一个分片在你预期的情况下仍留在当前节点时，此API非常有用。

查询参数

edit

include_disk_info: (可选，布尔值) 如果为true，则返回有关磁盘使用情况和分片大小的信息。默认为false。
include_yes_decisions: (可选，布尔值) 如果 true，在解释中返回 YES 决策。默认为 false。

请求体

edit

current_node: (可选，字符串) 指定当前持有分片的节点的ID或名称。要解释未分配的分片，请省略此参数。
index: (可选，字符串) 指定您希望解释的索引名称。
primary: (可选，布尔值) 如果 true，返回给定分片ID的主分片的解释。
shard: （可选，整数）指定您希望解释的分片的ID。

以下请求获取未分配主分片的分配解释。

GET _cluster/allocation/explain
{
  "index": "my-index-000001",
  "shard": 0,
  "primary": true
}

API 响应表明分片只能分配到一个不存在的节点。

{
  "index" : "my-index-000001",
  "shard" : 0,
  "primary" : true,
  "current_state" : "unassigned",                 
  "unassigned_info" : {
    "reason" : "INDEX_CREATED",                   
    "at" : "2017-01-04T18:08:16.600Z",
    "last_allocation_status" : "no"
  },
  "can_allocate" : "no",                          
  "allocate_explanation" : "Elasticsearch isn't allowed to allocate this shard to any of the nodes in the cluster. Choose a node to which you expect this shard to be allocated, find this node in the node-by-node explanation, and address the reasons which prevent Elasticsearch from allocating this shard there.",
  "node_allocation_decisions" : [
    {
      "node_id" : "8qt2rY-pT6KNZB3-hGfLnw",
      "node_name" : "node-0",
      "transport_address" : "127.0.0.1:9401",
      "roles" : ["data", "data_cold", "data_content", "data_frozen", "data_hot", "data_warm", "ingest", "master", "ml", "remote_cluster_client", "transform"],
      "node_attributes" : {},
      "node_decision" : "no",                     
      "weight_ranking" : 1,
      "deciders" : [
        {
          "decider" : "filter",                   
          "decision" : "NO",
          "explanation" : "node does not match index setting [index.routing.allocation.include] filters [_name:\"nonexistent_node\"]"  
        }
      ]
    }
  ]
}

	分片的当前状态。
	分片最初变为未分配的原因。
	是否分配分片。
	是否将分片分配给特定节点。
	导致节点决策为`否`的决定因素。
	关于决策者返回`否`决定的原因的解释，并提供了一个有用的提示，指向导致该决定的设置。在这个例子中，一个新创建的索引有一个索引设置，要求它只能分配给一个名为`nonexistent_node`的节点，而该节点不存在，因此该索引无法分配。

超过最大重试次数

edit

以下响应包含一个未分配主分片的分配解释，该分片已达到最大分配重试次数。

{
  "index" : "my-index-000001",
  "shard" : 0,
  "primary" : true,
  "current_state" : "unassigned",
  "unassigned_info" : {
    "at" : "2017-01-04T18:03:28.464Z",
    "failed shard on node [mEKjwwzLT1yJVb8UxT6anw]: failed recovery, failure RecoveryFailedException",
    "reason": "ALLOCATION_FAILED",
    "failed_allocation_attempts": 5,
    "last_allocation_status": "no",
  },
  "can_allocate": "no",
  "allocate_explanation": "cannot allocate because allocation is not permitted to any of the nodes",
  "node_allocation_decisions" : [
    {
      "node_id" : "3sULLVJrRneSg0EfBB-2Ew",
      "node_name" : "node_t0",
      "transport_address" : "127.0.0.1:9400",
      "roles" : ["data_content", "data_hot"],
      "node_decision" : "no",
      "store" : {
        "matching_size" : "4.2kb",
        "matching_size_in_bytes" : 4325
      },
      "deciders" : [
        {
          "decider": "max_retry",
          "decision" : "NO",
          "explanation": "shard has exceeded the maximum number of retries [5] on failed allocation attempts - manually call [POST /_cluster/reroute?retry_failed] to retry, [unassigned_info[[reason=ALLOCATION_FAILED], at[2024-07-30T21:04:12.166Z], failed_attempts[5], failed_nodes[[mEKjwwzLT1yJVb8UxT6anw]], delayed=false, details[failed shard on node [mEKjwwzLT1yJVb8UxT6anw]: failed recovery, failure RecoveryFailedException], allocation_status[deciders_no]]]"
        }
      ]
    }
  ]
}

当 Elasticsearch 无法分配分片时，它将尝试重试分配，直到达到允许的最大重试次数。在此之后，Elasticsearch 将停止尝试分配该分片，以防止可能影响集群性能的无限重试。运行 cluster reroute API 以重试分配，如果阻止分配的问题已解决，则将分配该分片。

没有有效的分片副本

edit

以下响应包含一个未分配主分片的分配解释，该分片之前已被分配。

{
  "index" : "my-index-000001",
  "shard" : 0,
  "primary" : true,
  "current_state" : "unassigned",
  "unassigned_info" : {
    "reason" : "NODE_LEFT",
    "at" : "2017-01-04T18:03:28.464Z",
    "details" : "node_left[OIWe8UhhThCK0V5XfmdrmQ]",
    "last_allocation_status" : "no_valid_shard_copy"
  },
  "can_allocate" : "no_valid_shard_copy",
  "allocate_explanation" : "Elasticsearch can't allocate this shard because there are no copies of its data in the cluster. Elasticsearch will allocate this shard when a node holding a good copy of its data joins the cluster. If no such node is available, restore this index from a recent snapshot."
}

如果一个分片处于未分配状态，并且分配状态为 no_valid_shard_copy，那么你应该确保所有节点都在集群中。如果包含分片同步副本的所有节点都丢失了，那么你可以恢复该分片的数据。

未分配的副本分片

edit

分配延迟

edit

以下响应包含由于延迟分配而未分配的副本的分配解释。

{
  "index" : "my-index-000001",
  "shard" : 0,
  "primary" : false,
  "current_state" : "unassigned",
  "unassigned_info" : {
    "reason" : "NODE_LEFT",
    "at" : "2017-01-04T18:53:59.498Z",
    "details" : "node_left[G92ZwuuaRY-9n8_tc-IzEg]",
    "last_allocation_status" : "no_attempt"
  },
  "can_allocate" : "allocation_delayed",
  "allocate_explanation" : "The node containing this shard copy recently left the cluster. Elasticsearch is waiting for it to return. If the node does not return within [%s] then Elasticsearch will allocate this shard to another node. Please wait.",
  "configured_delay" : "1m",                      
  "configured_delay_in_millis" : 60000,
  "remaining_delay" : "59.8s",                    
  "remaining_delay_in_millis" : 59824,
  "node_allocation_decisions" : [
    {
      "node_id" : "pmnHu_ooQWCPEFobZGbpWw",
      "node_name" : "node_t2",
      "transport_address" : "127.0.0.1:9402",
      "roles" : ["data_content", "data_hot"],
      "node_decision" : "yes"
    },
    {
      "node_id" : "3sULLVJrRneSg0EfBB-2Ew",
      "node_name" : "node_t0",
      "transport_address" : "127.0.0.1:9400",
      "roles" : ["data_content", "data_hot"],
      "node_decision" : "no",
      "store" : {                                 
        "matching_size" : "4.2kb",
        "matching_size_in_bytes" : 4325
      },
      "deciders" : [
        {
          "decider" : "same_shard",
          "decision" : "NO",
          "explanation" : "a copy of this shard is already allocated to this node [[my-index-000001][0], node[3sULLVJrRneSg0EfBB-2Ew], [P], s[STARTED], a[id=eV9P8BN1QPqRc3B4PLx6cg]]"
        }
      ]
    }
  ]
}

	配置的延迟时间，用于在持有副本分片的节点离开集群后分配不存在的副本分片。
	分配副本分片之前的剩余延迟。
	关于在节点上找到的分片数据的详细信息。

分配受限

edit

以下响应包含一个副本的分配解释，该副本已排队等待分配，但目前正在等待其他排队分片的处理。

{
  "index" : "my-index-000001",
  "shard" : 0,
  "primary" : false,
  "current_state" : "unassigned",
  "unassigned_info" : {
    "reason" : "NODE_LEFT",
    "at" : "2017-01-04T18:53:59.498Z",
    "details" : "node_left[G92ZwuuaRY-9n8_tc-IzEg]",
    "last_allocation_status" : "no_attempt"
  },
  "can_allocate": "throttled",
  "allocate_explanation": "Elasticsearch is currently busy with other activities. It expects to be able to allocate this shard when those activities finish. Please wait.",
  "node_allocation_decisions" : [
    {
      "node_id" : "3sULLVJrRneSg0EfBB-2Ew",
      "node_name" : "node_t0",
      "transport_address" : "127.0.0.1:9400",
      "roles" : ["data_content", "data_hot"],
      "node_decision" : "no",
      "deciders" : [
        {
          "decider": "throttling",
          "decision": "THROTTLE",
          "explanation": "reached the limit of incoming shard recoveries [2], cluster setting [cluster.routing.allocation.node_concurrent_incoming_recoveries=2] (can also be set via [cluster.routing.allocation.node_concurrent_recoveries])"
        }
      ]
    }
  ]
}

这是一个可能会在大批量分片分配时出现的瞬时消息。

已分配的分片

edit

无法停留在当前节点

edit

以下响应包含一个分配解释，用于说明已分配的分片。该响应表明该分片不允许保留在其当前节点上，必须重新分配。

{
  "index" : "my-index-000001",
  "shard" : 0,
  "primary" : true,
  "current_state" : "started",
  "current_node" : {
    "id" : "8lWJeJ7tSoui0bxrwuNhTA",
    "name" : "node_t1",
    "transport_address" : "127.0.0.1:9401",
    "roles" : ["data_content", "data_hot"]
  },
  "can_remain_on_current_node" : "no",            
  "can_remain_decisions" : [                      
    {
      "decider" : "filter",
      "decision" : "NO",
      "explanation" : "node does not match index setting [index.routing.allocation.include] filters [_name:\"nonexistent_node\"]"
    }
  ],
  "can_move_to_other_node" : "no",                
  "move_explanation" : "This shard may not remain on its current node, but Elasticsearch isn't allowed to move it to another node. Choose a node to which you expect this shard to be allocated, find this node in the node-by-node explanation, and address the reasons which prevent Elasticsearch from allocating this shard there.",
  "node_allocation_decisions" : [
    {
      "node_id" : "_P8olZS8Twax9u6ioN-GGA",
      "node_name" : "node_t0",
      "transport_address" : "127.0.0.1:9400",
      "roles" : ["data_content", "data_hot"],
      "node_decision" : "no",
      "weight_ranking" : 1,
      "deciders" : [
        {
          "decider" : "filter",
          "decision" : "NO",
          "explanation" : "node does not match index setting [index.routing.allocation.include] filters [_name:\"nonexistent_node\"]"
        }
      ]
    }
  ]
}

	分片是否允许保留在当前节点上。
	影响决定为何不允许分片保留在当前节点上的决策因素。
	分片是否允许被分配到另一个节点。

必须保持在当前节点

edit

以下响应包含一个分片分配解释，该分片必须保留在其当前节点上。将分片移动到另一个节点不会改善集群平衡。

{
  "index" : "my-index-000001",
  "shard" : 0,
  "primary" : true,
  "current_state" : "started",
  "current_node" : {
    "id" : "wLzJm4N4RymDkBYxwWoJsg",
    "name" : "node_t0",
    "transport_address" : "127.0.0.1:9400",
    "roles" : ["data_content", "data_hot"],
    "weight_ranking" : 1
  },
  "can_remain_on_current_node" : "yes",
  "can_rebalance_cluster" : "yes",                
  "can_rebalance_to_other_node" : "no",           
  "rebalance_explanation" : "Elasticsearch cannot rebalance this shard to another node since there is no node to which allocation is permitted which would improve the cluster balance. If you expect this shard to be rebalanced to another node, find this node in the node-by-node explanation and address the reasons which prevent Elasticsearch from rebalancing this shard there.",
  "node_allocation_decisions" : [
    {
      "node_id" : "oE3EGFc8QN-Tdi5FFEprIA",
      "node_name" : "node_t1",
      "transport_address" : "127.0.0.1:9401",
      "roles" : ["data_content", "data_hot"],
      "node_decision" : "worse_balance",          
      "weight_ranking" : 1
    }
  ]
}

	是否允许在集群上进行重新平衡。
	分片是否可以重新平衡到另一个节点。
	无法将分片重新平衡到该节点的原因是，在这种情况下，它提供的平衡并不比当前节点更好。

无参数

edit

如果你在没有参数的情况下调用API，Elasticsearch会获取一个任意未分配的主分片或副本分片的分配解释，首先返回任何未分配的主分片。

GET _cluster/allocation/explain

如果集群中没有未分配的分片，API将返回一个400错误。

集群获取设置 API

edit

返回集群范围内的设置。

GET /_cluster/settings

前提条件

edit

如果启用了Elasticsearch安全功能，您必须拥有monitor或manage 集群权限才能使用此API。

请求

edit

GET /_cluster/settings

描述

edit

默认情况下，此API调用仅返回已明确定义的设置，但也可以通过调用include_defaults参数来包含默认设置。

查询参数

edit

flat_settings: (可选，布尔值) 如果 true，返回设置为扁平格式。默认为 false。
include_defaults: (可选，布尔值) 如果为true，则从本地节点返回默认的集群设置。默认为false。
master_timeout: (可选，时间单位) 等待主节点的时间段。如果在超时到期之前主节点不可用，请求将失败并返回错误。默认为30s。也可以设置为-1，表示请求不应超时。

集群健康状况 API

edit

返回集群的健康状态。

请求

edit

GET /_cluster/health/

先决条件

edit

如果启用了Elasticsearch安全功能，您必须拥有monitor或manage 集群权限才能使用此API。

描述

edit

集群健康 API 返回一个关于集群健康状况的简单状态。您还可以使用 API 来获取仅指定数据流和索引的健康状态。对于数据流，API 检索流的后备索引的健康状态。

集群健康状态为：绿色、黄色 或 红色。在分片级别，红色 状态表示特定分片未在集群中分配，黄色 表示主分片已分配但副本未分配，而 绿色 表示所有分片均已分配。索引级别的状态由最差的分片状态控制。集群状态由最差的索引状态控制。

API的主要优点之一是能够等待集群达到某个高水位健康水平。例如，以下代码将等待50秒，直到集群达到黄色级别（如果在50秒内达到绿色或黄色状态，它将在那时返回）：

GET /_cluster/health?wait_for_status=yellow&timeout=50s

路径参数

edit

<target>

(可选, 字符串) 用于限制请求的逗号分隔的数据流、索引和索引别名列表。支持通配符表达式 (*)。

要定位集群中的所有数据流和索引，请省略此参数或使用_all或*。

查询参数

edit

level: (可选，字符串) 可以是 cluster、indices 或 shards。控制返回的健康信息的详细程度。默认为 cluster。
local: (可选，布尔值) 如果 true，请求仅从本地节点检索信息。默认为 false，这意味着信息从主节点检索。
master_timeout: (可选，时间单位) 等待主节点的时间段。如果在超时到期之前主节点不可用，请求将失败并返回错误。默认为30s。也可以设置为-1，表示请求不应超时。
timeout: (可选，时间单位) 在更新集群元数据后，等待集群中所有相关节点响应的时间段。如果在超时到期之前未收到响应，集群元数据更新仍然适用，但响应将表明它未被完全确认。默认为 30s。也可以设置为 -1 以指示请求不应超时。
wait_for_active_shards: (可选，字符串) 控制等待多少个活跃分片，all 表示等待集群中所有分片都处于活跃状态，或者 0 表示不等待。默认为 0。
wait_for_events: (可选, 字符串) 可以是以下之一 immediate, urgent, high, normal, low, languid。等待直到所有当前队列中具有给定优先级的事件被处理。
wait_for_no_initializing_shards: (可选，布尔值) 一个布尔值，用于控制是否等待（直到提供的超时时间）集群中没有分片初始化。默认为 false，表示它不会等待初始化分片。
wait_for_no_relocating_shards: (可选, 布尔值) 一个布尔值，用于控制是否等待（直到提供的超时时间）集群没有分片重新分配。默认为false，这意味着它不会等待重新分配的分片。
wait_for_nodes: (可选，字符串) 请求等待直到指定的节点数 N 可用。它还接受 >=N、<=N、>N 和 。或者，也可以使用 ge(N)、le(N)、gt(N) 和 lt(N) 表示法。
wait_for_status: (可选，字符串) 可以是 green、yellow 或 red 之一。将等待（直到提供的超时时间）直到集群状态变为所提供的状态或更好，即 green > yellow > red。默认情况下，不会等待任何状态。

响应体

edit

cluster_name

(字符串) 集群的名称。

status

(字符串) 集群的健康状态，基于其主分片和副本分片的状态。状态包括：

green: 所有分片都已分配。
yellow: 所有主分片都已分配，但一个或多个副本分片未分配。如果集群中的一个节点发生故障，某些数据在修复该节点之前将不可用。
red: 一个或多个主分片未分配，因此某些数据不可用。这可能在集群启动期间短暂发生，因为主分片正在分配。

timed_out

(布尔值) 如果为false，则在指定的时间段内返回响应，该时间段由timeout参数指定（默认为30s）。

number_of_nodes

(整数) 集群中的节点数量。

number_of_data_nodes

(整数) 专用的数据节点的数量。

active_primary_shards

(整数) 活动的主分片数量。

active_shards

(整数) 活动的主分片和副本分片的总数。

relocating_shards

(整数) 正在重新定位的分片数量。

initializing_shards

(整数) 正在初始化的分片数量。

unassigned_shards

(整数) 未分配的分片数量。

unassigned_primary_shards

(整数) 未分配的主分片数量。注意：如果您的集群包含运行版本低于8.16的节点，此数字可能低于实际值。在这种情况下，请使用集群健康API以获得更准确的计数。

delayed_unassigned_shards

(整数) 由于超时设置而被延迟分配的分片数量。

number_of_pending_tasks

(整数) 尚未执行的集群级别更改的数量。

number_of_in_flight_fetch

(整数) 未完成的获取数量。

task_max_waiting_in_queue_millis

(整数) 自最早发起的任务等待执行以来所经过的时间，以毫秒为单位表示。

active_shards_percent_as_number

(float) 集群中活动分片的百分比。

示例

edit

GET _cluster/health

在静默单节点集群中，API返回以下响应，该集群包含一个具有一个分片和一个副本的索引：

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

以下是在分片级别获取集群健康状况的示例：

GET /_cluster/health/my-index-000001?level=shards

健康 API

edit

一个报告 Elasticsearch 集群健康状态的 API。

请求

edit

GET /_health_report

GET /_health_report/

先决条件

edit

如果启用了Elasticsearch安全功能，您必须拥有monitor或manage 集群权限才能使用此API。

描述

edit

健康 API 返回一个包含 Elasticsearch 集群健康状态的报告。该报告包含组成 Elasticsearch 功能的指标列表。

每个指标都有一个健康状态：绿色、未知、黄色 或 红色。该指标将提供一个解释和元数据，描述其当前健康状态的原因。

集群的状态由最差的指示器状态控制。

如果某个指标的状态为非绿色，指标结果中可能会列出一些影响，这些影响详细说明了健康问题对哪些功能产生了负面影响。每个影响都附带一个严重性级别、受影响的系统区域以及对系统影响的简单描述。

一些健康指标可以确定健康问题的根本原因，并开出一组可以执行的步骤，以改善系统的健康状况。根本原因和补救步骤被封装在一个诊断中。一个诊断包含一个详细说明根本原因分析的原因，一个包含修复问题步骤简要描述的动作，受影响资源的列表（如果适用），以及一个详细的逐步故障排除指南来修复诊断出的问题。

健康指标执行非绿色健康状态的根本原因分析。当频繁调用时，这可能会计算成本较高。在设置API健康状态的自动轮询时，将verbose设置为false以禁用更昂贵的分析逻辑。

路径参数

edit

<indicator>

（可选，字符串）将返回的信息限制为特定指标。支持的指标包括：

master_is_stable: 报告与处理健康请求的节点视为主节点的稳定性相关的健康问题。如果在短时间内观察到足够多的主节点变化，此指示器将旨在诊断并报告有关其检测到的集群形成问题的有用信息。
shards_availability: 报告与分片分配相关的健康问题。
disk: 报告由磁盘空间不足引起的健康问题。
ilm: 报告与索引生命周期管理相关的健康问题。
repository_integrity: 跟踪存储库完整性并报告如果存储库损坏、未知或无效时出现的健康问题。
slm: 报告与快照生命周期管理相关的健康问题。
shards_capacity: 报告与集群分片容量相关的健康问题。

查询参数

edit

verbose: (可选，布尔值) 如果为true，响应将包含额外的详细信息，以帮助解释每个非绿色指标的状态。这些详细信息包括额外的故障排除指标，有时还包括健康状态的根本原因分析。默认为true。
size: (可选，整数) 返回的最大受影响资源数量。由于诊断可以返回多种类型的受影响资源，此参数将限制每种类型返回的资源数量为配置的值（例如，诊断可能返回 1000 个受影响的索引和 1000 个受影响的节点）。默认为 1000。

响应体

edit

cluster_name

(字符串) 集群的名称。

status

（可选，字符串）集群的健康状态，基于集群中所有指标的聚合状态。如果请求了特定指标的健康状态，则此顶级状态将被省略。状态包括：

green: 集群是健康的。
unknown: 无法确定集群的健康状况。
yellow: 集群的功能处于降级状态，可能需要修复以避免健康状况变为red。
red: 集群正在经历中断或某些功能不可用。

indicators

(对象) 关于集群指标健康状况的信息。

Properties of indicators

(对象) 包含某个指标的健康结果。

Properties of

status

(字符串) 指标的健康状态。状态包括：

green: 指标是健康的。
unknown: 无法确定指标的健康状况。
yellow: 指标的功能处于降级状态，可能需要修复以避免健康状态变为red。
red: 指标正在经历中断或某些功能不可用。

symptom

(字符串) 提供当前健康状态信息的描述。

details

(可选, 对象) 包含导致当前健康状态结果的集群额外信息的对象。此数据是非结构化的，每个指标返回一组独特的详细信息。如果verbose属性设置为false，则不会计算详细信息。

impacts

(可选, 数组) 如果返回非健康状态，指标可能包括此健康状态将对集群产生的影响列表。

Properties of impacts

severity

(整数) 此影响对集群功能的重要性。值为1表示最高严重性，较大的值表示较低的严重性。

description

(字符串) 对集群影响的描述。

impact_areas

(字符串数组) 此影响所涉及的集群功能区域。可能的值包括：

search
ingest
backup
deployment_management

diagnosis

(可选, 数组) 如果返回了非健康状态, 指标可能包括一个诊断列表, 这些诊断封装了健康问题的成因以及解决问题的行动。如果 verbose 属性为 false, 则不会计算诊断。

Properties of diagnosis

cause: (字符串) 健康问题的根本原因描述。
action: (字符串) 应采取的步骤的简要描述，以解决问题。更详细的逐步指南由help_url字段提供。
affected_resources: (可选, 对象) 一个对象，其中键表示资源类型（例如，索引、分片），值是受问题影响的特定资源的列表。
help_url: (字符串) 指向故障排除指南的链接，该指南将解决健康问题。

指标详情

edit

健康API中的每个健康指标都会返回一组详细信息，这些详细信息进一步解释了系统的状态。这些详细信息的内容和结构对于每个指标都是独特的。

master_is_stable

edit

current_master

(对象) 关于当前选举的主节点的信息。

Properties of current_master

node_id: (字符串) 当前选举的主节点的节点ID，如果没有选举出主节点则为null。
name: (字符串) 当前选举的主节点的节点名称，如果没有选举出主节点则为null。

recent_masters

(可选，数组) 在最近的时间窗口内被选举或替换为主节点的节点列表。如果主节点变化频繁到引起问题，或者在指示器为绿色时作为附加信息，此字段会出现。此数组仅包括被选举的主节点，并且不包括在无被选举主节点期间的无内容条目。

Properties of recent_masters

node_id: (字符串) 最近活跃的主节点的节点ID。
name: (字符串) 最近活跃的主节点的节点名称。

exception_fetching_history

（可选，对象）如果正在查询的节点发现选定的主节点反复下台，为了诊断目的，会从最近选定的主节点请求主历史记录。如果获取此远程历史记录失败，异常信息将在此详细字段中返回。

Properties of exception_fetching_history

message: (字符串) 历史记录获取操作失败的异常消息。
stack_trace: (字符串) 历史记录获取操作失败的堆栈跟踪。

cluster_formation

(可选，数组) 如果最近没有选举出主节点，被查询的节点会尝试收集信息，说明集群为何无法形成，或者如果集群已经形成，被查询的节点为何无法加入集群。此数组可能包含每个符合主节点资格的节点对集群形成情况的任何条目。

Properties of cluster_formation

node_id: (字符串) 一个符合主节点资格的节点的节点ID
name: (可选，字符串) 一个符合主节点资格的节点的节点名称
cluster_formation_message: (字符串) 一个详细描述，解释集群形成过程中出了什么问题，或者如果集群已经形成，为什么这个节点无法加入集群。

分片可用性

edit

unassigned_primaries: (int) 由于非初始化或重定位原因而未分配的主分片数量。
initializing_primaries: (整数) 正在初始化或恢复的主分片的数量。
creating_primaries: (int) 由于它们是最近创建的，因此未分配的主分片数量。
creating_replicas: (int) 由于这些副本分片是最近创建的，因此它们处于未分配状态的数量。
restarting_primaries: (int) 由于节点关闭操作而正在重新定位的主分片数量。
started_primaries: (整数) 系统中活跃且可用的主分片的数量。
unassigned_replicas: (int) 未分配副本分片的数量，原因不是初始化或重新定位。
initializing_replicas: (整数) 正在初始化或恢复的副本分片的数量。
restarting_replicas: (整数) 由于节点关闭操作而正在重新定位的副本分片的数量。
started_replicas: (整数) 系统中活跃且可用的副本分片的数量。

磁盘

edit

indices_with_readonly_block: (整数) 系统强制执行只读索引块（index.blocks.read_only_allow_delete）的索引数量，因为集群空间不足。
nodes_with_enough_disk_space: (int) 有足够可用磁盘空间以正常运行的节点数量。
nodes_over_high_watermark: (整数) 磁盘空间不足的节点数量，这些节点很可能很快就会耗尽空间。它们的磁盘使用量已经触发了高水位线阈值。
nodes_over_flood_stage_watermark: (int) 磁盘已满的节点数量。它们的磁盘使用量已触发洪水阶段水位线阈值。
unknown_nodes: (整数) 无法确定其磁盘健康状况的节点数量。

仓库完整性

edit

total_repositories: (可选, 整数) 系统上当前配置的存储库数量。如果没有配置存储库，则省略此详细信息。
corrupted_repositories: (可选, 整数) 系统中被确定为损坏的仓库数量。如果没有检测到损坏的仓库，则省略此细节。
corrupted: （可选，字符串数组）如果在系统中检测到损坏的存储库，最多十个存储库的名称将显示在此字段中。如果未发现损坏的存储库，则省略此详细信息。
unknown_repositories: (可选, 整数) 已被至少一个节点确定为未知的仓库数量。如果没有检测到未知的仓库，则省略此详细信息。
invalid_repositories: (可选, 整数) 已被至少一个节点判定为无效的仓库数量。如果没有检测到无效的仓库，则省略此详细信息。

ilm

edit

ilm_status

(字符串) 索引生命周期管理功能的当前状态。可以是 STOPPED、STOPPING 或 RUNNING。

policies

(整数) 系统正在管理的索引生命周期策略的数量。

stagnating_indices

(int) 索引生命周期管理所管理的索引数量，这些索引已经停滞超过预期时间。

stagnating_indices_per_action

(可选, 映射) 按操作分组的索引数量的摘要，这些索引已经停滞超过预期时间。

Properties of stagnating_indices_per_action

downsample: (int) downsample 操作中停滞索引的数量。
allocate: (int) allocate 操作中停滞索引的数量。
shrink: (int) shrink 操作中停滞索引的数量。
searchable_snapshot: (int) searchable_snapshot 操作中停滞索引的数量。
rollover: (int) rollver 操作中停滞索引的数量。
forcemerge: (int) forcemerge 操作中停滞索引的数量。
delete: (int) delete 操作中停滞索引的数量。
migrate: (int) migrate 操作中停滞索引的数量。

slm

edit

slm_status: (字符串) 快照生命周期管理功能的当前状态。可以是 STOPPED、STOPPING 或 RUNNING。
policies: (整数) 系统正在管理的快照策略数量。
unhealthy_policies: (map) 由于连续多次调用失败而被视为不健康的策略的详细视图。 count 键表示不健康的策略数量（整数）。 invocations_since_last_success 键将报告一个映射，其中不健康的策略名称是键，其对应的失败调用次数是值。

分片容量

edit

data

(map) 一个显示不属于冻结层的数据节点的分片当前容量信息的视图。

Properties of data

max_shards_in_cluster: (int) 表示集群可以容纳的最大分片数量。
current_used_shards: (可选, int) 集群持有的分片总数。仅在指标状态为red或yellow时显示。

frozen

(地图) 一个显示属于冻结层的数据节点的分片当前容量的视图。

属性 frozen

max_shards_in_cluster: (整数) 指示集群可以为部分挂载索引持有的最大分片数。
current_used_shards: (可选, 整数) 部分挂载索引在集群中的总分片数。仅在指示器状态为 red 或 yellow 时显示。

示例

edit

GET _health_report

API返回一个包含所有指标的响应，无论当前状态如何。

GET _health_report/shards_availability

API 仅返回分片可用性指示器的响应。

GET _health_report?verbose=false

API返回包含所有健康指标的响应，但不会计算详细信息或根本原因分析。如果您希望监控健康API并且不希望每次调用都计算额外的故障排除详细信息，这将非常有用。

集群重路由 API

edit

更改集群中分片的分配。

请求

edit

POST /_cluster/reroute

先决条件

edit

如果启用了Elasticsearch安全功能，您必须拥有manage 集群权限才能使用此API。

描述

edit

reroute 命令允许手动更改集群中各个分片的分配。例如，可以将分片从一个节点显式移动到另一个节点，可以取消分配，并且可以将未分配的分片显式分配到特定节点。

需要注意的是，在处理任何重定向命令后，Elasticsearch将正常执行重新平衡（尊重诸如cluster.routing.rebalance.enable等设置的值）以保持平衡状态。例如，如果请求的分配包括将分片从node1移动到node2，那么这可能会导致分片从node2移回node1以平衡情况。

可以通过设置 cluster.routing.allocation.enable 来禁用集群的分配。如果分配被禁用，那么唯一会执行的分配是使用 reroute 命令显式指定的分配，以及由于重新平衡而导致的后续分配。

可以通过使用?dry_run URI 查询参数，或者在请求体中传递"dry_run": true来以“干运行”模式运行reroute命令。这将计算将命令应用于当前集群状态的结果，并在命令（和重新平衡）应用后返回结果集群状态，但不会实际执行请求的更改。

如果包含 ?explain URI 查询参数，则响应中会包含一个详细的解释，说明为什么这些命令可以或不可以执行。

集群将尝试连续分配一个分片最多 index.allocation.max_retries 次（默认为 5），然后放弃并保持分片未分配。这种情况可能是由于结构问题引起的，例如使用了一个在所有节点上都不存在的停用词文件的分析器。

一旦问题得到纠正，可以通过调用带有?retry_failed URI查询参数的reroute API来手动重试分配，这将尝试为这些分片进行一次重试轮次。

查询参数

edit

dry_run

(可选, 布尔值) 如果 true, 则请求仅模拟操作并返回结果状态。

explain

(可选，布尔值) 如果 true，则响应包含有关命令可以或不可以执行的原因的解释。

metric

(可选，字符串) 将返回的信息限制为指定的指标。除了 none 之外的所有选项都已弃用，应避免在此参数中使用。默认为所有但元数据。以下选项可用：

Options for metric

_all: 显示所有指标。
blocks: 显示响应中的 blocks 部分。
master_node: 显示响应中选定的 master_node 部分。
metadata: 显示响应中的 metadata 部分。如果你提供一个逗号分隔的索引列表，返回的输出将只包含这些索引的元数据。
nodes: 显示响应中的 nodes 部分。
none: 从响应中排除整个 state 字段。
routing_table: 显示响应中的 routing_table 部分。
version: 显示集群状态版本。

retry_failed

(可选，布尔值) 如果 true，则重试分配因过多连续分配失败而被阻塞的分片。

master_timeout

(可选，时间单位) 等待主节点的时间段。如果在超时到期之前主节点不可用，请求将失败并返回错误。默认为30s。也可以设置为-1，表示请求不应超时。

timeout

(可选，时间单位) 在更新集群元数据后，等待集群中所有相关节点响应的时间段。如果在超时到期之前未收到响应，集群元数据更新仍然适用，但响应将表明它未被完全确认。默认为 30s。也可以设置为 -1 以指示请求不应超时。

请求体

edit

commands

（必需，对象数组）定义要执行的命令。支持的命令包括：

Properties of commands

move: 将一个已启动的分片从一个节点移动到另一个节点。接受index和shard用于索引名称和分片编号，from_node用于要移动分片的节点，to_node用于要移动分片到的节点。
cancel: 取消分片（或恢复）的分配。接受index和shard用于索引名称和分片编号，以及node用于要取消分片分配的节点。这可以用于通过取消它们并允许它们通过标准恢复过程重新初始化来强制重新同步现有副本从主分片。默认情况下，只能取消副本分片的分配。如果需要取消主分片的分配，则必须在请求中包含allow_primary标志。
allocate_replica: 将未分配的副本分片分配到一个节点。接受index和shard用于索引名称和分片编号，以及node用于要分配分片的节点。考虑到分配决策器。

还有两个命令可用于将主分片分配给节点。然而，这些命令应极其谨慎地使用，因为主分片分配通常完全由Elasticsearch自动处理。主分片无法自动分配的原因包括以下几点：

创建了一个新索引，但没有节点满足分配决策器。
无法在集群中的当前数据节点上找到数据的最新分片副本。为了防止数据丢失，系统不会自动将陈旧的分片副本提升为主分片。

以下两个命令是危险的，可能会导致数据丢失。它们适用于原始数据无法恢复且集群管理员接受损失的情况。如果您遇到的是可以修复的临时问题，请参阅上述retry_failed标志。强调一下：如果执行了这些命令，然后有一个节点加入集群并持有受影响分片的副本，那么新加入节点上的副本将被删除或覆盖。

allocate_stale_primary: 将主分片分配到一个持有陈旧副本的节点。接受index和shard用于索引名称和分片编号，以及node用于要分配分片的节点。使用此命令可能会导致所提供分片编号的数据丢失。如果稍后有节点加入集群并持有数据的良好副本，该数据将被删除或覆盖为通过此命令强制分配的陈旧副本的数据。为了确保充分理解这些影响，此命令要求将标志accept_data_loss显式设置为true。
allocate_empty_primary: 将空的主分片分配到一个节点。接受index和shard用于索引名称和分片编号，以及node用于要分配分片的节点。使用此命令会导致如果之前已启动，则完全丢失索引到此分片的所有数据。如果稍后有节点加入集群并持有数据的副本，该数据将被删除。为了确保充分理解这些影响，此命令要求将标志accept_data_loss显式设置为true。

示例

edit

这是一个简单的重定向API调用的简短示例：

POST /_cluster/reroute
{
  "commands": [
    {
      "move": {
        "index": "test", "shard": 0,
        "from_node": "node1", "to_node": "node2"
      }
    },
    {
      "allocate_replica": {
        "index": "test", "shard": 1,
        "node": "node3"
      }
    }
  ]
}

集群状态 API

edit

返回集群状态的内部表示，用于调试或诊断目的。

请求

edit

GET /_cluster/state//

先决条件

edit

如果启用了Elasticsearch安全功能，您必须拥有monitor或manage 集群权限才能使用此API。

描述

edit

The cluster state 是一个内部数据结构，用于跟踪每个节点所需的各种信息，包括：

集群中其他节点的身份和属性
集群范围的设置
索引元数据，包括每个索引的映射和设置
集群中每个分片副本的位置和状态

当选的主节点确保集群中的每个节点都具有相同的集群状态副本。集群状态API允许您检索此内部状态的表示，以用于调试或诊断目的。您可能需要查阅Elasticsearch源代码以确定响应的确切含义。

默认情况下，集群状态 API 会将请求路由到选举出的主节点，因为该节点是集群状态的权威来源。您还可以通过添加查询参数 ?local=true 来检索处理 API 请求的节点上保存的集群状态。

Elasticsearch 在较大的集群中可能需要花费大量精力来计算此 API 的响应，并且响应可能包含大量数据。如果您重复使用此 API，您的集群可能会变得不稳定。

响应是内部数据结构的表示。其格式不像其他更稳定的API那样受到相同的兼容性保证，并且可能随版本变化而变化。不要使用外部监控工具查询此API。相反，使用其他更稳定的集群API获取所需信息。

路径参数

edit

集群状态有时可能非常大，Elasticsearch在计算对此API的响应时可能会消耗大量资源。为了减小响应的大小，您可以仅请求您感兴趣的集群状态部分：

<metrics>

(可选, 字符串) 以下选项的逗号分隔列表:

_all: 显示所有指标。
blocks: 显示响应中的blocks部分。
master_node: 显示响应中的master_node部分。
metadata: 显示响应中的metadata部分。如果你提供一个逗号分隔的索引列表，返回的输出将只包含这些索引的元数据。
nodes: 显示响应中的nodes部分。
routing_nodes: 显示响应中的routing_nodes部分。
routing_table: 显示响应中的routing_table部分。如果你提供一个逗号分隔的索引列表，返回的输出将只包含这些索引的路由表。
version: 显示集群状态版本。

<target>

(可选，字符串) 用于限制请求的逗号分隔的数据流、索引和别名列表。支持通配符 (*)。要针对所有数据流和索引，请省略此参数或使用 * 或 _all。

查询参数

edit

allow_no_indices

(可选，布尔值) 如果 true，通配符索引表达式解析为没有具体索引时将被忽略。（这包括 _all 字符串或未指定索引时）。

默认为 true。

expand_wildcards

(可选, 字符串) 是否将通配符表达式扩展为具体的索引，这些索引可以是开放的、关闭的或两者兼有。可用选项: open, closed, none, all。

flat_settings

(可选，布尔值) 如果 true，返回设置为扁平格式。默认为 false。

ignore_unavailable

(可选，布尔值) 如果 true，不可用的索引（缺失或关闭）将被忽略。

local

(可选，布尔值) 如果 true，请求仅从本地节点检索信息。默认为 false，这意味着信息从主节点检索。

master_timeout

wait_for_metadata_version

(可选，整数) 等待元数据版本等于或大于指定的元数据版本。

wait_for_timeout

(可选，时间单位) 指定等待wait_for_metadata_version的最大时间，超时则停止等待。

示例

edit

以下示例仅返回foo和bar数据流或索引的metadata和routing_table数据：

GET /_cluster/state/metadata,routing_table/foo,bar

下一个示例返回所有可用的元数据，适用于foo和bar：

GET /_cluster/state/_all/foo,bar

此示例仅返回 blocks 元数据：

GET /_cluster/state/blocks

集群状态 API

edit

返回集群统计信息。

请求

edit

GET /_cluster/stats

GET /_cluster/stats/nodes/

先决条件

edit

如果启用了Elasticsearch安全功能，您必须拥有monitor或manage 集群权限才能使用此API。

描述

edit

Cluster Stats API 允许从集群范围的角度检索统计信息。该 API 返回基本索引指标（分片数量、存储大小、内存使用情况）以及有关当前组成集群的节点的信息（数量、角色、操作系统、JVM 版本、内存使用情况、CPU 和已安装的插件）。

路径参数

edit

<node_filter>: (可选，字符串) 逗号分隔的节点过滤器列表，用于限制返回的信息。默认为集群中的所有节点。

查询参数

edit

timeout: (可选，时间单位) 等待每个节点响应的时间段。如果在其超时到期之前节点未响应，则响应中不包括其统计信息。但是，超时的节点包含在响应的 _nodes.failed 属性中。默认为无超时。
include_remotes: (可选，布尔值) 如果为true，则在响应中包含远程集群信息。默认为false，因此不会返回远程集群信息。

响应体

edit

_nodes

(对象) 包含关于请求的节点过滤器所选择的节点数量的统计信息。

Properties of _nodes

total: (整数) 请求选择的节点总数。
successful: (整数) 成功响应请求的节点数量。
failed: (整数) 拒绝请求或未能响应的节点数量。如果此值不为 0，响应中会包含拒绝或失败的原因。

cluster_name

(字符串) 集群的名称，基于 Cluster name setting 设置。

cluster_uuid

(字符串) 集群的唯一标识符。

timestamp

(整数) Unix 时间戳，以毫秒为单位，表示集群统计信息上次刷新的时间。

status

(字符串) 集群的健康状态，基于其主分片和副本分片的状态。状态包括：

green: 所有分片都已分配。
yellow: 所有主分片都已分配，但一个或多个副本分片未分配。如果集群中的一个节点发生故障，某些数据可能会在修复该节点之前不可用。
red: 一个或多个主分片未分配，因此某些数据不可用。这可能在集群启动期间短暂发生，因为主分片正在分配。

参见 Cluster health。

indices

(对象) 包含关于分配给所选节点的分片的索引的统计信息。

Properties of indices

count

(整数) 分配给所选节点的分片的索引总数。

shards

(对象) 包含分配给所选节点的分片统计信息。

Properties of shards

total

(整数) 分配给所选节点的分片总数。

primaries

(整数) 分配给所选节点的初始分片数量。

replication

(浮点数) 所有所选节点中副本分片与初始分片的比例。

index

(对象) 包含分配给所选节点的分片统计信息。

Properties of index

shards

(对象) 包含有关分配给所选节点的分片数量的统计信息。

Properties of shards

min: (整数) 索引中最少的分片数量，仅计算分配给所选节点的分片。
max: (整数) 索引中最大的分片数量，仅计算分配给所选节点的分片。
avg: (浮点数) 索引中分片的平均数量，仅计算分配给所选节点的分片。

primaries

(对象) 包含有关分配给所选节点的初始分片数量的统计信息。

Properties of primaries

min: (整数) 索引中最少的初始分片数量，仅计算分配给所选节点的分片。
max: (整数) 索引中最大的初始分片数量，仅计算分配给所选节点的分片。
avg: (浮点数) 索引中初始分片的平均数量，仅计算分配给所选节点的分片。

replication

(对象) 包含有关分配给所选节点的复制分片数量的统计信息。

Properties of replication

min: (浮点数) 索引中最小的复制因子，仅计算分配给所选节点的分片。
max: (浮点数) 索引中最大的复制因子，仅计算分配给所选节点的分片。
avg: (浮点数) 索引中复制因子的平均值，仅计算分配给所选节点的分片。

docs

(对象) 包含所选节点中文档的计数。

Properties of docs

count

(整数) 所有分配给选定节点的非删除文档的总数。

这个数字基于Lucene段中的文档，可能包括来自嵌套字段的文档。

deleted

(整数) 在分配给所选节点的所有主分片中删除的文档总数。

这个数字是基于Lucene段中的文档。当一个段合并时，Elasticsearch会回收已删除Lucene文档的磁盘空间。

total_size_in_bytes

(整数) 分配给所选节点的所有主分片的大小总和，以字节为单位。

total_size

(字符串) 分配给所选节点的所有主分片的大小总和，以人类可读的字符串表示。

store

(对象) 包含关于分配给选定节点的分片大小的统计信息。

Properties of store

size: (字节单位) 分配给所选节点的所有分片的大小总和。
size_in_bytes: (整数) 分配给所选节点的所有分片的大小总和，以字节为单位。
total_data_set_size: (字节单位) 分配给所选节点的所有分片的数据集大小总和。这包括未完全存储在节点上的分片的大小，例如部分挂载索引的缓存。
total_data_set_size_in_bytes: (整数) 分配给所选节点的所有分片的数据集大小总和，以字节为单位。这包括未完全存储在节点上的分片的大小，例如部分挂载索引的缓存。
reserved: (字节单位) 由于正在进行对等恢复、恢复快照和类似活动，分片存储最终将增长多少的预测。
reserved_in_bytes: (整数) 由于正在进行对等恢复、恢复快照和类似活动，分片存储最终将增长多少的预测，以字节为单位。

fielddata

(对象) 包含关于所选节点的字段数据缓存的统计信息。

Properties of fielddata

memory_size: (字节单位) 分配给所选节点的所有分片中用于字段数据缓存的内存总量。
memory_size_in_bytes: (整数) 分配给所选节点的所有分片中用于字段数据缓存的内存总量，以字节为单位。
evictions: (整数) 分配给所选节点的所有分片中从字段数据缓存中驱逐的总次数。
global_ordinals.build_time: (时间单位) 为所有字段构建全局序号所花费的总时间。
global_ordinals.build_time_in_millis: (整数) 为所有字段构建全局序号所花费的总时间，以毫秒为单位。
global_ordinals.fields.[field-name].build_time: (时间单位) 为指定名称的字段构建全局序号所花费的总时间。
global_ordinals.fields.[field-name].build_time_in_millis: (整数) 为指定名称的字段构建全局序号所花费的总时间，以毫秒为单位。
global_ordinals.fields.[field-name].shard_max_value_count: (长整型) 为指定名称的字段构建全局序号所花费的总时间。

query_cache

(对象) 包含所选节点的查询缓存统计信息。

Properties of query_cache

memory_size: (字节单位) 分配给所选节点的所有分片中用于查询缓存的内存总量。
memory_size_in_bytes: (整数) 分配给所选节点的所有分片中用于查询缓存的内存总量，以字节为单位。
total_count: (整数) 分配给所选节点的所有分片中查询缓存的命中和未命中的总次数。
hit_count: (整数) 分配给所选节点的所有分片中查询缓存的命中总次数。
miss_count: (整数) 分配给所选节点的所有分片中查询缓存的未命中总次数。
cache_size: (整数) 分配给所选节点的所有分片中当前在查询缓存中的条目总数。
cache_count: (整数) 分配给所选

nodes

(对象) 包含关于请求选择的节点的统计信息，这些节点由请求的节点过滤器选择。

Properties of nodes

count

(对象) 包含由请求的节点过滤器选择的节点的计数。

Properties of count

total: (整数) 所选节点的总数。
coordinating_only: (整数) 没有角色的所选节点数量。这些节点被视为仅协调节点。
: (整数) 具有该角色的所选节点数量。有关角色列表，请参阅 Nodes。

versions

(字符串数组) 所选节点上使用的Elasticsearch版本的数组。

os

(对象) 包含有关所选节点使用的操作系统的统计信息。

Properties of os

available_processors

(整数) 所有选定节点上JVM可用的处理器数量。

allocated_processors

(整数) 用于计算所有选定节点线程池大小的处理器数量。

这个数字可以通过节点的 processors 设置进行设置，默认值为操作系统报告的处理器数量。在这两种情况下，这个数字永远不会超过 32。

names

(对象数组) 包含所选节点使用的操作系统的统计信息。

Properties of names

name: (字符串) 一个或多个所选节点使用的操作系统名称。
count: (字符串) 使用该操作系统的所选节点数量。

pretty_names

(对象数组) 包含所选节点使用的操作系统的统计信息。

Properties of pretty_names

pretty_name: (字符串) 一个或多个所选节点使用的人类可读的操作系统名称。
count: (字符串) 使用该操作系统的所选节点数量。

architectures

(对象数组) 包含所选节点使用的处理器架构（例如，x86_64 或 aarch64）的统计信息。

Properties of architectures

arch: (字符串) 一个或多个所选节点使用的架构名称。
count: (字符串) 使用该架构的所选节点数量。

mem

(对象) 包含有关所选节点使用的内存的统计信息。

Properties of mem

total: (字节单位) 所有选定节点上的物理内存总量。
total_in_bytes: (整数) 所有选定节点上的物理内存总量，以字节为单位。
adjusted_total: (字节值) 所有选定节点上的内存总量，但对于设置了 es.total_memory_bytes 系统属性的节点，使用该系统属性指定的值而不是测量的总内存。
adjusted_total_in_bytes: (整数) 所有选定节点上的内存总量，以字节为单位，但对于设置了 es.total_memory_bytes 系统属性的节点，使用该系统属性指定的值而不是测量的总内存。
free: (字节单位) 所有选定节点上的空闲物理内存量。
free_in_bytes: (整数) 所有选定节点上的空闲物理内存量，以字节为单位。
used: (字节单位) 所有选定节点上正在使用的物理内存量。
used_in_bytes: (整数) 所有选定节点上正在使用的物理内存量，以字节为单位。
free_percent: (整数) 所有选定节点上的空闲物理内存百分比。
used_percent: (整数) 所有选定节点上正在使用的物理内存百分比。

process

(对象) 包含所选节点使用的进程的统计信息。

Properties of process

cpu

(对象) 包含所选节点使用的CPU统计信息。

Properties of cpu

percent: (整数) 所有选定节点上使用的CPU百分比。如果不支持，则返回 -1。

open_file_descriptors

(对象) 包含所选节点中打开文件描述符的统计信息。

Properties of open_file_descriptors

min: (整数) 所有选定节点上同时打开的文件描述符的最小数量。如果不支持，则返回 -1。
max: (整数) 所有选定节点上允许的同时打开的文件描述符的最大数量。如果不支持，则返回 -1。
avg: (整数) 同时打开的文件描述符的平均数量。如果不支持，则返回 -1。

jvm

(对象) 包含有关所选节点使用的Java虚拟机(JVM)的统计信息。

Properties of jvm

max_uptime

(时间单位) JVM 自上次启动以来的最大运行时间。

max_uptime_in_millis

(整数) JVM 自上次启动以来的最大运行时间，以毫秒为单位。

versions

(对象数组) 包含所选节点使用的JVM版本的统计信息。

Properties of versions

version

(字符串) 一个或多个所选节点使用的JVM版本。

vm_name

(字符串) JVM 的名称。

vm_version

(字符串) JVM 的完整版本号。

完整版本号包括一个加号（+），后面跟随构建编号。

vm_vendor

(字符串) JVM 的供应商。

bundled_jdk

(布尔值) 始终为 true。所有发行版都附带一个捆绑的Java开发工具包（JDK）。

using_bundled_jdk

(布尔值) 如果为 true，则JVM正在使用捆绑的JDK。

count

(整数) 使用JVM的所选节点总数。

mem

snapshots

(对象) 包含关于集群中快照活动的统计信息。

Properties of snapshots

current_counts

(对象) 包含报告集群中各种正在进行快照活动的统计信息。

Properties of current_counts

snapshots: (整数) 集群当前正在创建的快照和克隆的总数。
shard_snapshots: (整数) 集群中未完成的分片快照总数。
snapshot_deletions: (整数) 集群当前正在运行的快照删除操作的总数。
concurrent_operations: (整数) 集群当前正在并发运行的快照操作的总数。这是 snapshots 和 snapshot_deletions 条目的总和，并受限于 snapshot.max_concurrent_operations 设置。
cleanups: (整数) 集群当前正在运行的存储库清理操作的总数。这些操作不计入并发操作的总数。

repositories

(对象) 包含按存储库细分的快照活动进度统计信息。此对象包含集群中注册的每个存储库的一个条目。

Properties of repositories

current_counts

(对象) 包含报告此仓库各种正在进行快照活动的统计信息。

Properties of current_counts

snapshots

(整数) 此存储库中正在进行的快照总数。

clones

(整数) 此存储库中正在进行的快照克隆总数。

finalizations

(整数) 此存储库中正在进行的大部分已完成但最后一步“最终化”尚未完成的快照和克隆操作的总数。

deletions

(整数) 此存储库中正在进行的快照删除操作的总数。

snapshot_deletions

(整数) 当前正在从此存储库中删除的快照总数。

active_deletions

(整数) 此存储库中当前处于活动状态的快照删除操作的总数。快照删除操作不与其他快照操作并发运行，因此如果任何待删除操作正在等待其他操作完成，则此值可能为 0。

shards

(对象) 包含报告存储库中正在进行快照活动的分片级别进度的统计信息。请注意，这些统计信息仅与正在进行中的快照相关。

Properties of shards

total: (整数) 此存储库当前跟踪的分片快照总数。此统计信息仅计算正在进行中的快照中的分片，因此当快照完成时此值会下降，如果没有正在进行中的快照，则此值为 0。
complete: (整数) 此存储库中已完成的分片快照总数。此统计信息仅计算正在进行中的快照中的分片，因此当快照完成时此值会下降，如果没有正在进行中的快照，则此值为 0。
incomplete: (整数) 此存储库中未完成的分片快照总数。这是 total 和 complete 值之间的差值。
states: (对象) 此存储库中每个命名状态的分片快照总数。这些状态是快照过程的实现细节，可能会在版本之间发生变化。它们包含在此处供专家用户使用，否则应忽略。

oldest_start_time

(字符串) 此存储库中最旧运行快照的开始时间。

oldest_start_time_in_millis

(整数) 此存储库中最旧运行快照的开始时间，表示为自 Unix 纪元以来的毫秒数。

repositories

(对象) 包含关于集群中定义的快照仓库的统计信息，按仓库类型细分。

Properties of repositories

count: (整数) 集群中此类型的仓库数量。
read_only: (整数) 集群中注册为只读的此类型的仓库数量。
read_write: (整数) 集群中未注册为只读的此类型的仓库数量。

每种仓库类型可能还会在此包含关于该类型仓库的其他统计信息。

ccs

(对象) 包含与跨集群搜索设置和集群中的活动相关的信息。

Properties of ccs

clusters

(对象) 包含远程集群设置和从它们收集的指标。键是集群名称，值是每个集群的数据。仅当 include_remotes 选项设置为 true 时才存在。

Properties of clusters

cluster_uuid

(字符串) 远程集群的UUID。

mode

(字符串) 用于与远程集群通信的连接模式。

skip_unavailable

(布尔值) 用于此远程集群的 skip_unavailable 设置。

transport.compress

(字符串) 用于此远程集群的传输压缩设置。

version

(字符串数组) 远程集群上节点使用的Elasticsearch版本列表。

status

(字符串) 集群的健康状态，基于其主分片和副本分片的状态。状态包括：

green: 所有分片都已分配。
yellow: 所有主分片都已分配，但一个或多个副本分片未分配。如果集群中的节点发生故障，某些数据在修复该节点之前可能不可用。
red: 一个或多个主分片未分配，因此某些数据不可用。这可能在集群启动期间短暂发生，因为主分片正在分配。

参见 Cluster health。

nodes_count

(整数) 远程集群中的节点总数。

shards_count

(整数) 远程集群中的分片总数。

indices_count

(整数) 远程集群中的索引总数。

indices_total_size_in_bytes

(整数) 分配给所选节点的所有分片的数据集总大小，以字节为单位。

indices_total_size

(字符串) 分配给所选节点的所有分片的数据集总大小，以字节为单位，以人类可读的字符串表示。

max_heap_in_bytes

(整数) 远程集群的节点中可用于堆的内存最大量，以字节为单位。

max_heap

(字符串) 远程集群的节点中可用于堆的内存最大量，以字节为单位，以人类可读的字符串表示。

mem_total_in_bytes

(整数) 远程集群的节点中的物理内存总量，以字节为单位。

mem_total

(字符串) 远程集群的节点中的物理内存总量，以字节为单位，以人类可读的字符串表示。

_search

(对象) 包含有关集群中跨集群搜索使用情况的信息。

Properties of _search

total

(整数) 集群已执行的跨集群搜索请求总数。

success

(整数) 集群已成功执行的跨集群搜索请求总数。

skipped

(整数) 至少有一个远程集群被跳过的跨集群搜索请求总数（成功或失败）。

took

(对象) 包含执行跨集群搜索请求所花费时间的统计信息。

Properties of took

max: (整数) 执行跨集群搜索请求所花费的最大时间，以毫秒为单位。
avg: (整数) 执行跨集群搜索请求所花费的中位时间，以毫秒为单位。
p90: (整数) 执行跨集群搜索请求所花费时间的第90百分位数，以毫秒为单位。

took_mrt_true

(对象) 包含关于执行跨集群搜索请求所需时间的统计信息，其中 ccs_minimize_roundtrips 设置为 true。

Properties of took_mrt_true

max: (整数) 执行跨集群搜索请求所花费的最大时间，以毫秒为单位。
avg: (整数) 执行跨集群搜索请求所花费的中位时间，以毫秒为单位。
p90: (整数) 执行跨集群搜索请求所花费时间的第90百分位数，以毫秒为单位。

took_mrt_false

(对象) 包含关于执行跨集群搜索请求所需时间的统计信息，其中 ccs_minimize_roundtrips 设置为 false。

Properties of took_mrt_false

max: (整数) 执行跨集群搜索请求所花费的最大时间，以毫秒为单位。
avg: (整数) 执行跨集群搜索请求所花费的中位时间，以毫秒为单位。
p90: (整数) 执行跨集群搜索请求所花费时间的第90百分位数，以毫秒为单位。

remotes_per_search_max

(整数) 在单个跨集群搜索请求中查询的远程集群的最大数量。

remotes_per_search_avg

(浮点数) 在单个跨集群搜索请求中查询的远程集群的平均数量。

failure_reasons

(对象) 包含关于跨集群搜索请求失败原因的统计信息。键是失败原因的名称，值是因该原因失败的请求数量。

features

(对象) 包含关于在跨集群搜索请求中使用的功能的统计信息。键是搜索功能的名称，值是使用该功能的请求数量。单个请求可以使用多个功能（例如，同时使用 async 和 wildcard）。已知的功能包括：

async - Async search
mrt - ccs_minimize_roundtrips 设置为 true。
wildcard - Multi-target syntax 用于带有通配符的索引的搜索请求。

clients

(对象) 包含关于执行跨集群搜索请求的客户端的统计信息。键是客户端的名称，值是该客户端执行的请求数量。仅统计已知的客户端（例如 kibana 或 elasticsearch）。

clusters

(对象) 包含在跨集群搜索请求中查询的集群的统计信息。键是集群名称，值是每个集群的遥测数据。这还包括本地集群本身，它使用名称 (local)。

Properties of per-cluster data:

total

(整数) 针对此集群执行的成功（未跳过）跨集群搜索请求的总数。这可能包括返回部分结果的请求，但不包括完全跳过该集群的请求。

skipped

(整数) 针对此集群被跳过的跨集群搜索请求的总数。

took

(对象) 包含关于执行针对此集群的请求所花费时间的统计信息。

Properties of took

max: (整数) 执行跨集群搜索请求所花费的最大时间，以毫秒为单位。
avg: (整数) 执行跨集群搜索请求所花费的中位时间，以毫秒为单位。
p90 </dt

示例

edit

GET /_cluster/stats?human&pretty

API返回以下响应：

{
   "_nodes" : {
      "total" : 1,
      "successful" : 1,
      "failed" : 0
   },
   "cluster_uuid": "YjAvIhsCQ9CbjWZb2qJw3Q",
   "cluster_name": "elasticsearch",
   "timestamp": 1459427693515,
   "status": "green",
   "indices": {
      "count": 1,
      "shards": {
         "total": 5,
         "primaries": 5,
         "replication": 0,
         "index": {
            "shards": {
               "min": 5,
               "max": 5,
               "avg": 5
            },
            "primaries": {
               "min": 5,
               "max": 5,
               "avg": 5
            },
            "replication": {
               "min": 0,
               "max": 0,
               "avg": 0
            }
         }
      },
      "docs": {
         "count": 10,
         "deleted": 0,
         "total_size": "8.6kb",
         "total_size_in_bytes": 8833
      },
      "store": {
         "size": "16.2kb",
         "size_in_bytes": 16684,
         "total_data_set_size": "16.2kb",
         "total_data_set_size_in_bytes": 16684,
         "reserved": "0b",
         "reserved_in_bytes": 0
      },
      "search": {
          ...
      },
      "fielddata": {
         "memory_size": "0b",
         "memory_size_in_bytes": 0,
         "evictions": 0,
         "global_ordinals": {
            "build_time" : "0s",
            "build_time_in_millis" : 0
         }
      },
      "query_cache": {
         "memory_size": "0b",
         "memory_size_in_bytes": 0,
         "total_count": 0,
         "hit_count": 0,
         "miss_count": 0,
         "cache_size": 0,
         "cache_count": 0,
         "evictions": 0
      },
      "completion": {
         "size": "0b",
         "size_in_bytes": 0
      },
      "segments": {
         "count": 4,
         "memory": "8.6kb",
         "memory_in_bytes": 0,
         "terms_memory": "0b",
         "terms_memory_in_bytes": 0,
         "stored_fields_memory": "0b",
         "stored_fields_memory_in_bytes": 0,
         "term_vectors_memory": "0b",
         "term_vectors_memory_in_bytes": 0,
         "norms_memory": "0b",
         "norms_memory_in_bytes": 0,
         "points_memory" : "0b",
         "points_memory_in_bytes" : 0,
         "doc_values_memory": "0b",
         "doc_values_memory_in_bytes": 0,
         "index_writer_memory": "0b",
         "index_writer_memory_in_bytes": 0,
         "version_map_memory": "0b",
         "version_map_memory_in_bytes": 0,
         "fixed_bit_set": "0b",
         "fixed_bit_set_memory_in_bytes": 0,
         "max_unsafe_auto_id_timestamp" : -9223372036854775808,
         "file_sizes": {}
      },
      "mappings": {
        "total_field_count": 0,
        "total_deduplicated_field_count": 0,
        "total_deduplicated_mapping_size": "0b",
        "total_deduplicated_mapping_size_in_bytes": 0,
        "field_types": [],
        "runtime_field_types": []
      },
      "analysis": {
        "char_filter_types": [],
        "tokenizer_types": [],
        "filter_types": [],
        "analyzer_types": [],
        "built_in_char_filters": [],
        "built_in_tokenizers": [],
        "built_in_filters": [],
        "built_in_analyzers": [],
        "synonyms": {}
      },
      "versions": [
        {
          "version": "8.0.0",
          "index_count": 1,
          "primary_shard_count": 1,
          "total_primary_size": "7.4kb",
          "total_primary_bytes": 7632
        }
      ],
      "dense_vector": {
          "value_count": 0
      },
      "sparse_vector": {
          "value_count": 0
      }
   },
   "nodes": {
      "count": {
         "total": 1,
         "data": 1,
         "coordinating_only": 0,
         "master": 1,
         "ingest": 1,
         "voting_only": 0
      },
      "versions": [
         "9.0.0-beta1"
      ],
      "os": {
         "available_processors": 8,
         "allocated_processors": 8,
         "names": [
            {
               "name": "Mac OS X",
               "count": 1
            }
         ],
         "pretty_names": [
            {
               "pretty_name": "Mac OS X",
               "count": 1
            }
         ],
         "architectures": [
            {
               "arch": "x86_64",
               "count": 1
            }
         ],
         "mem" : {
            "total" : "16gb",
            "total_in_bytes" : 17179869184,
            "adjusted_total" : "16gb",
            "adjusted_total_in_bytes" : 17179869184,
            "free" : "78.1mb",
            "free_in_bytes" : 81960960,
            "used" : "15.9gb",
            "used_in_bytes" : 17097908224,
            "free_percent" : 0,
            "used_percent" : 100
         }
      },
      "process": {
         "cpu": {
            "percent": 9
         },
         "open_file_descriptors": {
            "min": 268,
            "max": 268,
            "avg": 268
         }
      },
      "jvm": {
         "max_uptime": "13.7s",
         "max_uptime_in_millis": 13737,
         "versions": [
            {
               "version": "12",
               "vm_name": "OpenJDK 64-Bit Server VM",
               "vm_version": "12+33",
               "vm_vendor": "Oracle Corporation",
               "bundled_jdk": true,
               "using_bundled_jdk": true,
               "count": 1
            }
         ],
         "mem": {
            "heap_used": "57.5mb",
            "heap_used_in_bytes": 60312664,
            "heap_max": "989.8mb",
            "heap_max_in_bytes": 1037959168
         },
         "threads": 90
      },
      "fs": {
         "total": "200.6gb",
         "total_in_bytes": 215429193728,
         "free": "32.6gb",
         "free_in_bytes": 35064553472,
         "available": "32.4gb",
         "available_in_bytes": 34802409472
      },
      "plugins": [
        {
          "name": "analysis-icu",
          "version": "9.0.0-beta1",
          "description": "The ICU Analysis plugin integrates Lucene ICU module into elasticsearch, adding ICU relates analysis components.",
          "classname": "org.elasticsearch.plugin.analysis.icu.AnalysisICUPlugin",
          "has_native_controller": false
        },
        ...
      ],
      "ingest": {
        "number_of_pipelines" : 1,
        "processor_stats": {
          ...
        }
      },
      "indexing_pressure": {
        "memory": {
            "current": {
                 "combined_coordinating_and_primary": "0b",
                 "combined_coordinating_and_primary_in_bytes": 0,
                 "coordinating": "0b",
                 "coordinating_in_bytes": 0,
                 "primary": "0b",
                 "primary_in_bytes": 0,
                 "replica": "0b",
                 "replica_in_bytes": 0,
                 "all": "0b",
                 "all_in_bytes": 0
            },
            "total": {
                "combined_coordinating_and_primary": "0b",
                "combined_coordinating_and_primary_in_bytes": 0,
                "coordinating": "0b",
                "coordinating_in_bytes": 0,
                "primary": "0b",
                "primary_in_bytes": 0,
                "replica": "0b",
                "replica_in_bytes": 0,
                "all": "0b",
                "all_in_bytes": 0,
                "coordinating_rejections": 0,
                "primary_rejections": 0,
                "replica_rejections": 0,
                "primary_document_rejections": 0
            },
            "limit" : "0b",
            "limit_in_bytes": 0
        }
      },
      "network_types": {
        ...
      },
      "discovery_types": {
        ...
      },
      "packaging_types": [
        {
          ...
        }
      ]
   },
   "snapshots": {
     ...
   },
   "repositories": {
     ...
   },
   "ccs": {
     "_search": {
        "total": 7,
        "success": 7,
        "skipped": 0,
        "took": {
            "max": 36,
            "avg": 20,
            "p90": 33
        },
        "took_mrt_true": {
            "max": 33,
            "avg": 15,
            "p90": 33
        },
        "took_mrt_false": {
            "max": 36,
            "avg": 26,
            "p90": 36
        },
        "remotes_per_search_max": 3,
        "remotes_per_search_avg": 2.0,
        "failure_reasons": { ... },
        "features": { ... },
        "clients": { ... },
        "clusters": { ... }
     }
  }
}

此API可以通过使用节点过滤器限制到节点的子集：

GET /_cluster/stats/nodes/node1,node*,master:false

此API调用将返回有关已配置的远程集群的数据（如果有）：

GET /_cluster/stats?include_remotes=true

生成的响应将包含 ccs 对象，其中包含有关远程集群的信息：

{
  "ccs": {
    "clusters": {
      "remote_cluster": {
        "cluster_uuid": "YjAvIhsCQ9CbjWZb2qJw3Q",
        "mode": "sniff",
        "skip_unavailable": false,
        "transport.compress": "true",
        "version": ["8.16.0"],
        "status": "green",
        "nodes_count": 10,
        "shards_count": 420,
        "indices_count": 10,
        "indices_total_size_in_bytes": 6232658362,
        "max_heap_in_bytes": 1037959168,
        "mem_total_in_bytes": 137438953472
      }
    }
  }
}

集群更新设置 API

edit

配置动态集群设置。

请求

edit

PUT /_cluster/settings

先决条件

edit

如果启用了Elasticsearch安全功能，您必须拥有manage 集群权限才能使用此API。

描述

edit

您可以使用集群更新设置 API 在运行中的集群上配置和更新动态设置。您还可以在未启动或关闭的节点上使用 elasticsearch.yml 在本地配置动态设置。

使用集群更新设置API进行的更新可以是持久的，这些更新在集群重启后仍然有效，或者是临时的，这些更新在集群重启后会被重置。您还可以通过使用API将它们赋值为null来重置临时或持久设置。

如果你使用多种方法配置相同的设置，Elasticsearch 会按照以下优先级顺序应用设置：

临时设置
持久设置
elasticsearch.yml 设置
默认设置值

例如，您可以应用一个临时设置来覆盖一个持久设置或elasticsearch.yml设置。然而，对elasticsearch.yml设置的更改不会覆盖已定义的临时或持久设置。

如果您使用 Elasticsearch Service，请使用用户设置功能来配置所有集群设置。此方法允许 Elasticsearch Service 自动拒绝可能破坏集群的不安全设置。

如果您在自己的硬件上运行 Elasticsearch，请使用集群更新设置 API 来配置动态集群设置。仅将 elasticsearch.yml 用于静态集群设置和节点设置。该 API 不需要重启，并确保设置的值在所有节点上相同。

我们不再推荐使用瞬态集群设置。请改用持久集群设置。如果集群变得不稳定，瞬态设置可能会意外清除，从而导致潜在的非预期集群配置。请参阅瞬态设置迁移指南。

查询参数

edit

flat_settings: (可选，布尔值) 如果 true，返回设置为扁平格式。默认为 false。
include_defaults: (可选，布尔值) 如果为true，则返回所有默认的集群设置。默认为false。
master_timeout: (可选，时间单位) 等待主节点的时间段。如果在超时到期之前主节点不可用，请求将失败并返回错误。默认为30s。也可以设置为-1，表示请求不应超时。
timeout: (可选，时间单位) 在更新集群元数据后，等待集群中所有相关节点响应的时间段。如果在超时到期之前未收到响应，集群元数据更新仍然适用，但响应将表明它未被完全确认。默认为 30s。也可以设置为 -1 以指示请求不应超时。

示例

edit

持久化更新的一个示例：

PUT /_cluster/settings
{
  "persistent" : {
    "indices.recovery.max_bytes_per_sec" : "50mb"
  }
}

一个瞬态更新的示例：

我们不再推荐使用瞬态集群设置。请改用持久集群设置。如果集群变得不稳定，瞬态设置可能会意外清除，导致可能不希望的集群配置。请参阅瞬态设置迁移指南。

PUT /_cluster/settings?flat_settings=true
{
  "transient" : {
    "indices.recovery.max_bytes_per_sec" : "20mb"
  }
}

对更新的响应返回更改后的设置，如对瞬态示例的响应所示：

{
  ...
  "persistent" : { },
  "transient" : {
    "indices.recovery.max_bytes_per_sec" : "20mb"
  }
}

此示例重置一个设置：

PUT /_cluster/settings
{
  "transient" : {
    "indices.recovery.max_bytes_per_sec" : null
  }
}

响应中不包括已重置的设置：

{
  ...
  "persistent" : {},
  "transient" : {}
}

您也可以使用通配符重置设置。例如，要重置所有动态的 indices.recovery 设置：

PUT /_cluster/settings
{
  "transient" : {
    "indices.recovery.*" : null
  }
}

节点功能使用情况 API

edit

返回有关功能使用情况的信息。

请求

edit

GET /_nodes/usage

GET /_nodes//usage

GET /_nodes/usage/

GET /_nodes//usage/

先决条件

edit

如果启用了Elasticsearch安全功能，您必须拥有monitor或manage 集群权限才能使用此API。

描述

edit

集群节点使用情况 API 允许您检索每个节点的功能使用信息。所有节点选择性选项的解释可以在这里找到。

路径参数

edit

<metric>

(可选，字符串) 将返回的信息限制为特定的指标。以逗号分隔的以下选项列表：

_all: 返回所有统计信息。
rest_actions: 返回REST操作类名及其在节点上被调用的次数。

<node_id>

（可选，字符串）用于限制返回信息的节点ID或名称的逗号分隔列表。

查询参数

edit

timeout: (Optional, time units) Period to wait for each node to respond. If a node does not respond before its timeout expires, the response does not include its information. However, timed out nodes are included in the response’s _nodes.failed property. Defaults to no timeout.

示例

edit

REST 操作示例：

GET _nodes/usage

API返回以下响应：

{
  "_nodes": {
    "total": 1,
    "successful": 1,
    "failed": 0
  },
  "cluster_name": "my_cluster",
  "nodes": {
    "pQHNt5rXTTWNvUgOrdynKg": {
      "timestamp": 1492553961812, 
      "since": 1492553906606, 
      "rest_actions": {
        "nodes_usage_action": 1,
        "create_index_action": 1,
        "document_get_action": 1,
        "search_action": 19, 
        "nodes_info_action": 36
      },
      "aggregations": {
        ...
      }
    }
  }
}

	此节点使用请求执行时的时间戳。
	使用信息记录开始的时间戳。这相当于节点启动的时间。
	搜索操作已为此节点调用19次。

节点热点线程 API

edit

返回集群中每个选定节点上的热点线程。

请求

edit

GET /_nodes/hot_threads

GET /_nodes//hot_threads

先决条件

edit

如果启用了Elasticsearch安全功能，您必须拥有monitor或manage 集群权限才能使用此API。

描述

edit

此API提供了集群中每个选定节点的热线程分解。输出是纯文本格式，包含每个节点的顶级热线程分解。

路径参数

edit

<node_id>: （可选，字符串）用于限制返回信息的节点ID或名称的逗号分隔列表。

查询参数

edit

ignore_idle_threads: (Optional, Boolean) If true, known idle threads (e.g. waiting in a socket select, or to get a task from an empty queue) are filtered out. Defaults to true.
interval: (可选，时间单位) 进行第二次线程采样的间隔。默认为 500ms。
snapshots: (Optional, integer) Number of samples of thread stacktrace. Defaults to 10.
threads: (Optional, integer) Specifies the number of hot threads to provide information for. Defaults to 3. If you are using this API for troubleshooting, set this parameter to a large number (e.g. 9999) to get information about all the threads in the system.
timeout: (可选，时间单位) 指定等待每个节点响应的时间。如果省略，则永远等待。
type: (Optional, string) The type to sample. Available options are block, cpu, and wait. Defaults to cpu.

示例

edit

GET /_nodes/hot_threads
GET /_nodes/nodeId1,nodeId2/hot_threads

节点信息 API

edit

返回集群节点信息。

请求

edit

GET /_nodes

GET /_nodes/

GET /_nodes//

先决条件

edit

如果启用了Elasticsearch安全功能，您必须拥有monitor或manage 集群权限才能使用此API。

描述

edit

集群节点信息API允许检索一个或多个（或所有）集群节点的信息。所有节点选择性选项的解释可以在这里找到。

默认情况下，它会返回节点的所有属性和核心设置。

路径参数

edit

<metric>

(可选, 字符串) 将返回的信息限制为特定的指标。支持以逗号分隔的列表，例如 http,ingest。

有效值为

aggregations

关于可用聚合类型的信息。

http

关于此节点的HTTP接口的信息。

indices

节点级与索引相关的配置：

total_indexing_buffer: 此节点上的索引缓冲区的最大大小。

ingest

关于摄取管道和处理器的信息。

jvm

JVM信息，包括其名称、版本和配置。

os

操作系统信息，包括其名称和版本。

plugins

每个节点上已安装的插件和模块的详细信息。以下信息可用于每个插件和模块：

name: 插件名称
version: 插件构建时所针对的Elasticsearch版本
description: 插件用途的简短描述
classname: 插件入口点的完全限定类名
has_native_controller: 插件是否有本地控制器进程

process

进程信息，包括数字进程ID。

settings

列出在elasticsearch.yml文件中定义的所有正在使用的节点设置。

thread_pool

关于每个线程池配置的信息。

transport

关于节点传输接口的信息。

如果你使用完整的 GET /_nodes// API 形式，那么你也可以请求指标 _all 来检索所有指标，或者你可以请求指标 _none 来抑制所有指标并仅检索节点的身份。

<node_id>: （可选，字符串）用于限制返回信息的节点ID或名称的逗号分隔列表。

响应体

edit

build_hash: 此版本中最后一个git提交的短哈希值。
host: 节点的宿主机名称。
ip: 节点的IP地址。
name: 节点的名称。
total_indexing_buffer: 在必须将最近索引的文档写入磁盘之前，允许用于保存这些文档的总堆大小。此大小是该节点上所有分片共享的池，并且由索引缓冲区设置控制。
total_indexing_buffer_in_bytes: 与total_indexing_buffer相同，但以字节表示。
transport_address: 接受传输HTTP连接的主机和端口。
version: 运行在此节点上的 Elasticsearch 版本。
transport_version: 此节点可以通信的最新传输版本。
index_version: The most recent index version that this node can read.
component_versions: 此节点中加载的各个组件的版本号。

可以将 os 标志设置为检索与操作系统相关的信息：

os.refresh_interval_in_millis: 操作系统统计信息的刷新间隔
os.name: 操作系统名称（例如：Linux、Windows、Mac OS X）
os.arch: JVM架构的名称（例如：amd64、x86）
os.version: 操作系统版本
os.available_processors: Java虚拟机可用的处理器数量
os.allocated_processors: 用于计算线程池大小的实际处理器数量。这个数量可以通过节点的node.processors设置来设置，默认值为操作系统报告的处理器数量。

可以将 process 标志设置为检索与当前运行进程相关的信息：

process.refresh_interval_in_millis: 进程统计的刷新间隔
process.id: 进程标识符 (PID)
process.mlockall: 指示进程地址空间是否已成功锁定在内存中

查询参数

edit

flat_settings: (可选，布尔值) 如果 true，返回设置为扁平格式。默认为 false。
timeout: (可选，时间单位) 等待每个节点响应的时间段。如果在其超时到期之前节点未响应，则响应中不包括其信息。但是，超时的节点包含在响应的 _nodes.failed 属性中。默认为无超时。

示例

edit

# return just process
GET /_nodes/process

# same as above
GET /_nodes/_all/process

# return just jvm and process of only nodeId1 and nodeId2
GET /_nodes/nodeId1,nodeId2/jvm,process

# same as above
GET /_nodes/nodeId1,nodeId2/info/jvm,process

# return all the information of only nodeId1 and nodeId2
GET /_nodes/nodeId1,nodeId2/_all

可以将 _all 标志设置为返回所有信息 - 或者您可以省略它。

插件指标示例

edit

如果指定了plugins，结果将包含已安装的插件和模块的详细信息：

GET /_nodes/plugins

API返回以下响应：

{
  "_nodes": ...
  "cluster_name": "elasticsearch",
  "nodes": {
    "USpTGYaBSIKbgSUJR2Z9lg": {
      "name": "node-0",
      "transport_address": "192.168.17:9300",
      "host": "node-0.elastic.co",
      "ip": "192.168.17",
      "version": "{version}",
      "transport_version": 100000298,
      "index_version": 100000074,
      "component_versions": {
        "ml_config_version": 100000162,
        "transform_config_version": 100000096
      },
      "build_flavor": "default",
      "build_type": "{build_type}",
      "build_hash": "587409e",
      "roles": [
        "master",
        "data",
        "ingest"
      ],
      "attributes": {},
      "plugins": [
        {
          "name": "analysis-icu",
          "version": "{version}",
          "description": "The ICU Analysis plugin integrates Lucene ICU module into elasticsearch, adding ICU relates analysis components.",
          "classname": "org.elasticsearch.plugin.analysis.icu.AnalysisICUPlugin",
          "has_native_controller": false
        }
      ],
      "modules": [
        {
          "name": "lang-painless",
          "version": "{version}",
          "description": "An easy, safe and fast scripting language for Elasticsearch",
          "classname": "org.elasticsearch.painless.PainlessPlugin",
          "has_native_controller": false
        }
      ]
    }
  }
}

摄入指标的示例

edit

如果指定了ingest，响应将包含每个节点可用的处理器详情：

GET /_nodes/ingest

API返回以下响应：

{
  "_nodes": ...
  "cluster_name": "elasticsearch",
  "nodes": {
    "USpTGYaBSIKbgSUJR2Z9lg": {
      "name": "node-0",
      "transport_address": "192.168.17:9300",
      "host": "node-0.elastic.co",
      "ip": "192.168.17",
      "version": "{version}",
      "transport_version": 100000298,
      "index_version": 100000074,
      "component_versions": {
        "ml_config_version": 100000162,
        "transform_config_version": 100000096
      },
      "build_flavor": "default",
      "build_type": "{build_type}",
      "build_hash": "587409e",
      "roles": [],
      "attributes": {},
      "ingest": {
        "processors": [
          {
            "type": "date"
          },
          {
            "type": "uppercase"
          },
          {
            "type": "set"
          },
          {
            "type": "lowercase"
          },
          {
            "type": "gsub"
          },
          {
            "type": "convert"
          },
          {
            "type": "remove"
          },
          {
            "type": "fail"
          },
          {
            "type": "foreach"
          },
          {
            "type": "split"
          },
          {
            "type": "trim"
          },
          {
            "type": "rename"
          },
          {
            "type": "join"
          },
          {
            "type": "append"
          }
        ]
      }
    }
  }
}

预验证节点移除API

edit

此功能旨在供 Elasticsearch Service、Elastic Cloud Enterprise 和 Elastic Cloud on Kubernetes 间接使用。不支持直接使用。

预验证节点移除。

请求

edit

POST /_internal/prevalidate_node_removal

前提条件

edit

如果启用了Elasticsearch安全功能，您必须拥有monitor或manage 集群权限才能使用此API。

描述

edit

此API检查尝试从集群中移除指定节点是否可能成功。对于没有未分配分片的集群，移除任何节点都被认为是安全的，这意味着移除节点很可能会成功。

如果集群的红色集群健康状态，它会验证移除节点是否不会导致移除未分配分片的最后一个副本。如果集群中有红色索引，API会检查这些红色索引是否是可搜索快照索引，如果不是，它会向API调用中指定的每个节点发送请求，以验证这些节点是否可能包含非可搜索快照索引的红色索引的本地分片副本。这个请求会在每个接收节点上处理，通过检查节点是否具有任何红色索引分片的分片目录。

响应包括移除指定节点的整体安全性，以及每个节点的详细响应。响应的节点特定部分还包括关于移除该节点可能不成功的原因的更多详细信息。

请注意，只能使用其中一个查询参数（names、ids 或 external_ids）来指定节点集。

请注意，如果一组节点的预验证结果返回true（即可能成功），这并不意味着所有这些节点都可以一次性成功移除，而是每个节点的移除操作可能会成功。实际的节点移除可以通过节点生命周期API来处理。

查询参数

edit

master_timeout: (可选，时间单位) 等待主节点的时间段。如果在超时到期之前主节点不可用，请求将失败并返回错误。默认为30s。也可以设置为-1，表示请求不应超时。
timeout: (可选，时间单位) 在更新集群元数据后，等待集群中所有相关节点响应的时间段。如果在超时到期之前未收到响应，集群元数据更新仍然适用，但响应将表明它未被完全确认。默认为 30s。也可以设置为 -1 以指示请求不应超时。
names: (可选，字符串) 以逗号分隔的节点名称列表。
ids: (可选，字符串) 以逗号分隔的节点ID列表。
external_ids: (可选，字符串) 以逗号分隔的节点外部ID列表。

响应体

edit

is_safe

(布尔值) 是否可以安全地移除所有提供的节点。

message

(字符串) 提供更多关于为什么该操作被认为是安全或不安全的详细信息的消息。

nodes

(对象) 提供的每个节点的移除预验证结果。

Properties of nodes

(对象) 包含有关特定节点的移除预验证的信息。

Properties of

id

(字符串) 节点ID

name

(字符串) 节点名称

external_id

(字符串) 节点外部ID

result

(对象) 包含节点的移除预验证结果。

Properties of result

is_safe

(布尔值) 移除节点是否被认为是安全的。

reason

(字符串) 一个字符串，指定预验证结果被认为是安全或不安全的原因。它可以是以下值之一：

no_problems: 预验证未发现任何可能阻止节点安全移除的问题。
no_red_shards_except_searchable_snapshots: 节点可以安全移除，因为所有红色索引都是可搜索的快照索引，因此移除节点不会导致该索引从集群中移除最后一个副本。
no_red_shards_on_node: 节点不包含任何红色非可搜索快照索引分片的副本。
red_shards_on_node: 节点可能包含某些非可搜索快照红色索引的分片副本。节点上可能存在的分片列表在message字段中指定。
unable_to_verify_red_shards: 联系节点失败或超时。更多详细信息在message字段中提供。

message

(可选, 字符串) 移除预验证结果的详细信息。

示例

edit

此示例验证是否可以安全地移除节点 node1 和 node2。响应表明可以安全地移除 node1，但移除 node2 可能不安全，因为它可能包含指定红色分片的副本。因此，移除这两个节点的总体预验证返回 false。

POST /_internal/prevalidate_node_removal?names=node1,node2

API返回以下响应：

{
  "is_safe": false,
  "message": "removal of the following nodes might not be safe: [node2-id]",
  "nodes": [
    {
      "id": "node1-id",
      "name" : "node1",
      "external_id" : "node1-externalId",
      "result" : {
        "is_safe": true,
        "reason": "no_red_shards_on_node",
        "message": ""
      }
    },
    {
      "id": "node2-id",
      "name" : "node2",
      "external_id" : "node2-externalId",
      "result" : {
        "is_safe": false,
        "reason": "red_shards_on_node",
        "message": "node contains copies of the following red shards: [[indexName][0]]"
      }
    }
  ]
}

节点重新加载安全设置 API

edit

重新加载集群中节点上的密钥库。

请求

edit

POST /_nodes/reload_secure_settings
POST /_nodes//reload_secure_settings

先决条件

edit

如果启用了Elasticsearch安全功能，您必须拥有manage 集群权限才能使用此API。

描述

edit

安全设置存储在磁盘上的密钥库中。某些这些设置是可重新加载的。也就是说，您可以在磁盘上更改它们并在不重新启动集群中的任何节点的情况下重新加载它们。当您在密钥库中更新了可重新加载的安全设置后，您可以使用此API在每个节点上重新加载这些设置。

当Elasticsearch密钥库被密码保护而不仅仅是被混淆时，您必须在重新加载安全设置时提供密钥库的密码。重新加载整个集群的设置假设所有节点的密钥库都使用相同的密码进行保护；此方法仅在节点间通信被加密时允许。或者，您可以通过本地访问API并在传递节点特定的Elasticsearch密钥库密码的情况下，在每个节点上重新加载安全设置。

路径参数

edit

<node_id>: (可选，字符串) 要定位的集群中特定节点的名称。例如，nodeId1,nodeId2。有关节点选择选项，请参阅节点规范。

Elasticsearch 要求集群节点之间的安全设置保持一致，但这种一致性并未强制执行。因此，重新加载特定节点并不是标准操作。只有在重试失败的重新加载操作时，才具有合理性。

请求体

edit

secure_settings_password: (可选, 字符串) Elasticsearch 密钥库的密码。

示例

edit

以下示例假设集群中每个节点的Elasticsearch密钥库使用相同的密码：

POST _nodes/reload_secure_settings
{
  "secure_settings_password":"keystore-password"
}
POST _nodes/nodeId1,nodeId2/reload_secure_settings
{
  "secure_settings_password":"keystore-password"
}

响应包含 nodes 对象，它是一个以节点 ID 为键的映射。每个值包含节点 name 和一个可选的 reload_exception 字段。reload_exception 字段是重新加载过程中抛出的异常的序列化表示，如果有的话。

{
  "_nodes": {
    "total": 1,
    "successful": 1,
    "failed": 0
  },
  "cluster_name": "my_cluster",
  "nodes": {
    "pQHNt5rXTTWNvUgOrdynKg": {
      "name": "node-0"
    }
  }
}

节点统计信息 API

edit

返回集群节点统计信息。

请求

edit

GET /_nodes/stats

GET /_nodes//stats

GET /_nodes/stats/

GET /_nodes//stats/

GET /_nodes/stats//

GET /_nodes//stats//

先决条件

edit

如果启用了Elasticsearch安全功能，您必须拥有monitor或manage 集群权限才能使用此API。

描述

edit

您可以使用集群节点统计信息API来检索集群中节点的统计信息。

所有节点选择性选项的解释请参见这里。

默认情况下，所有统计数据都会返回。您可以通过使用指标来限制返回的信息。

路径参数

edit

<metric>

(可选，字符串) 将返回的信息限制为特定的指标。以逗号分隔的以下选项列表：

adaptive_selection: 关于自适应副本选择的统计信息。
allocations: 关于已分配分片的统计信息
breaker: 关于字段数据断路器的统计信息。
discovery: 关于发现的统计信息。
fs: 文件系统信息，数据路径，可用磁盘空间，读/写统计信息。
http: HTTP连接信息。
indexing_pressure: 关于节点的索引负载及相关拒绝的统计信息。
indices: 关于索引大小、文档数量、索引和删除时间、搜索时间、字段缓存大小、合并和刷新的统计信息。
ingest: 关于摄取预处理的统计信息。
jvm: JVM统计信息，内存池信息，垃圾回收，缓冲池，已加载/未加载类的数量。
os: 操作系统统计信息，负载平均值，内存，交换。
process: 进程统计信息，内存消耗，CPU使用率，打开的文件描述符。
repositories: 关于快照仓库的统计信息。
thread_pool: 关于每个线程池的统计信息，包括当前大小、队列和拒绝的任务。
transport: 关于集群通信中发送和接收字节的传输统计信息。

<index_metric>

(可选，字符串) 限制为 indices 指标返回的特定索引指标的信息。只有在指定了 indices (或 all) 指标时才能使用。支持的指标包括：

bulk
completion
docs
fielddata
flush
get
indexing
mappings
merge
query_cache
recovery
refresh
request_cache
search
segments
shard_stats
store
translog
warmer
dense_vector
sparse_vector

<node_id>

（可选，字符串）用于限制返回信息的节点ID或名称的逗号分隔列表。

查询参数

edit

completion_fields

(可选，字符串) 以逗号分隔的字段列表或通配符表达式，用于包含在fielddata和suggest统计信息中。

fielddata_fields

(可选，字符串) 以逗号分隔的字段列表或通配符表达式，用于包含在fielddata统计信息中。

fields

(可选，字符串) 逗号分隔的字段列表或通配符表达式，用于包含在统计信息中。

用作默认列表，除非在 completion_fields 或 fielddata_fields 参数中提供了特定的字段列表。

groups

(可选，字符串) 逗号分隔的搜索组列表包含在搜索统计信息中。

level

(可选, 字符串) 指示统计信息是在集群、索引还是分片级别聚合的。如果请求了分片级别，则会显示一些额外的分片特定统计信息。

有效值为：

cluster
indices
shards

types

(可选，字符串) 用于 indexing 索引指标的文档类型的逗号分隔列表。

timeout

(可选，时间单位) 等待每个节点响应的时间段。如果在其超时到期之前节点未响应，则响应中不包括其信息。但是，超时的节点包含在响应的 _nodes.failed 属性中。默认为无超时。

include_segment_file_sizes

(可选, 布尔值) 如果true，调用将报告每个Lucene索引文件的聚合磁盘使用情况（仅在请求段统计信息时适用）。默认为false。

include_unloaded_segments

(可选，布尔值) 如果为 true，响应将包含来自未加载到内存中的分段的信息。默认为 false。

响应体

edit

_nodes

(对象) 包含关于请求选择的节点数量的统计信息。

Properties of _nodes

total: (整数) 请求选择的节点总数。
successful: (整数) 成功响应请求的节点数量。
failed: (整数) 拒绝请求或未能响应的节点数量。如果此值不为 0，响应中会包含拒绝或失败的原因。

cluster_name

(字符串) 集群的名称。基于 Cluster name setting 设置。

nodes

(对象) 包含请求选择的节点的统计信息。

Properties of nodes

(对象) 包含节点的统计信息。

Properties of

timestamp: (integer) 为此响应收集节点统计信息的时间。记录自 Unix Epoch 以来的毫秒数。
name: (string) 节点的可读标识符。基于节点名称设置。
transport_address: (string) 传输层的主机和端口，用于集群中节点之间的内部通信。
host: (string) 节点的主机名，基于网络主机设置。
ip: (string) 节点的IP地址和端口。
roles: (array of strings) 分配给节点的角色。参见节点。
attributes: (object) 包含节点的属性列表。

indices

(对象) 包含关于分配到该节点的分片索引的统计信息。

Properties of indices

docs

(对象) 包含关于分配到该节点的所有主分片中文档的统计信息。

Properties of docs

count: (integer) Lucene 报告的文档数量。这排除了已删除的文档，并将任何嵌套文档与其父文档分开计数。它还排除了最近索引的文档，这些文档尚未属于段。
deleted: (integer) Lucene 报告的已删除文档数量，可能高于或低于您执行的删除操作数量。此数量排除了最近执行的删除操作，这些操作尚未属于段。已删除的文档由自动合并过程清理，如果这样做有意义的话。此外，Elasticsearch 创建额外的已删除文档，以在分片上内部跟踪最近的操作历史记录。

store

(对象) 包含关于分配给节点的分片大小的统计信息。

Properties of store

size: (字节值) 分配给节点的所有分片的总大小。
size_in_bytes: (integer) 分配给节点的所有分片的总大小，以字节为单位。
total_data_set_size: (字节值) 分配给节点的所有分片的总数据集大小。这包括未完全存储在节点上的分片的大小，例如部分挂载索引的缓存。
total_data_set_size_in_bytes: (integer) 分配给节点的所有分片的总数据集大小，以字节为单位。这包括未完全存储在节点上的分片的大小，例如部分挂载索引的缓存。
reserved: (字节值) 由于正在进行的对等恢复、恢复快照和类似活动，此节点上的分片存储最终将增长多少的预测。值为 -1b 表示此信息不可用。
reserved_in_bytes: (integer) 由于正在进行的对等恢复、恢复快照和类似活动，此节点上的分片存储最终将增长多少的预测，以字节为单位。值为 -1 表示此信息不可用。

indexing

(对象) 包含节点索引操作的统计信息。

Properties of indexing

index_total: (integer) 索引操作的总数。
index_time: (时间值) 执行索引操作所花费的总时间。
index_time_in_millis: (integer) 执行索引操作所花费的总时间，以毫秒为单位。
index_current: (integer) 当前正在运行的索引操作的数量。
index_failed: (integer) 失败的索引操作的数量。
delete_total: (integer) 删除操作的总数。
delete_time: (时间值) 执行删除操作所花费的时间。
delete_time_in_millis: (integer) 执行删除操作所花费的时间，以毫秒为单位。
delete_current: (integer) 当前正在运行的删除操作的数量。
noop_update_total: (integer) 无操作的总数。
is_throttled: (Boolean) 操作被限制的次数。
throttle_time: (时间值) 限制操作所花费的总时间。
throttle_time_in_millis: (integer) 限制操作所花费的总时间，以毫秒为单位。
write_load: (double) 索引文档时使用的平均写线程数。

get

(对象) 包含节点获取操作的统计信息。

Properties of get

total: (integer) 获取操作的总数。
getTime: (时间值) 执行获取操作所花费的时间。
time_in_millis: (integer) 执行获取操作所花费的时间，以毫秒为单位。
exists_total: (integer) 成功获取操作的总数。
exists_time: (时间值) 执行成功获取操作所花费的时间。
exists_time_in_millis: (integer) 执行成功获取操作所花费的时间，以毫秒为单位。
missing_total: (integer) 失败的获取操作的总数。
missing_time: (时间值) 执行失败的获取操作所花费的时间。
missing_time_in_millis: (integer) 执行失败的获取操作所花费的时间，以毫秒为单位。
current: (integer) 当前正在运行的获取操作的数量。

search

(对象) 包含节点搜索操作的统计信息。

Properties of search

open_contexts: (integer) 打开的搜索上下文数量。
query_total: (integer) 查询操作的总数。
query_time: (时间值) 执行查询操作所花费的时间。
query_time_in_millis: (integer) 执行查询操作所花费的时间，以毫秒为单位。
query_current

示例

edit

# return just indices
GET /_nodes/stats/indices

# return just os and process
GET /_nodes/stats/os,process

# return just process for node with IP address 10.0.0.1
GET /_nodes/10.0.0.1/stats/process

所有统计信息都可以通过 /_nodes/stats/_all 或 /_nodes/stats?metric=_all 显式请求。

您可以在 node、indices 或 shards 级别获取索引统计信息。

# Fielddata summarized by node
GET /_nodes/stats/indices/fielddata?fields=field1,field2

# Fielddata summarized by node and index
GET /_nodes/stats/indices/fielddata?level=indices&fields=field1,field2

# Fielddata summarized by node, index, and shard
GET /_nodes/stats/indices/fielddata?level=shards&fields=field1,field2

# You can use wildcards for field names
GET /_nodes/stats/indices/fielddata?fields=field*

您可以获取在此节点上执行的搜索的搜索组统计信息。

# All groups with all stats
GET /_nodes/stats?groups=_all

# Some groups from just the indices stats
GET /_nodes/stats/indices?groups=foo,bar

仅检索摄取统计信息

edit

要返回仅与摄取相关的节点统计信息，请将路径参数设置为 ingest 并使用 filter_path 查询参数。

GET /_nodes/stats/ingest?filter_path=nodes.*.ingest

您可以使用 metric 和 filter_path 查询参数来获取相同的响应。

GET /_nodes/stats?metric=ingest&filter_path=nodes.*.ingest

要进一步优化响应，请更改filter_path值。例如，以下请求仅返回摄取管道统计信息。

GET /_nodes/stats?metric=ingest&filter_path=nodes.*.ingest.pipelines

集群信息 API

edit

此功能处于技术预览阶段，可能会在未来的版本中进行更改或移除。Elastic 将努力修复任何问题，但技术预览版中的功能不受官方 GA 功能支持 SLA 的约束。

返回集群信息。

请求

edit

GET /_info/

先决条件

edit

如果启用了Elasticsearch安全功能，您必须拥有monitor或manage 集群权限才能使用此API。

描述

edit

您可以使用集群信息API来检索集群的信息。

路径参数

edit

<target>

(字符串) 将返回的信息限制为特定的 目标。以下选项的逗号分隔列表：

_all: 所有可用的信息。不能与其他目标混合使用。
http: HTTP连接信息。
ingest: 摄取信息。
thread_pool: 每个线程池的统计信息，包括当前大小、队列大小和被拒绝的任务。
script: 包含集群的脚本统计信息。

响应体

edit

cluster_name: (字符串) 集群的名称。基于集群名称设置。

http

(对象) 包含集群的HTTP信息。

Properties of http

current_open

(integer) Current number of open HTTP connections for the cluster.

total_opened

(integer) Total number of HTTP connections opened for the cluster.

clients

(对象数组) 有关当前和最近关闭的HTTP客户端连接的信息。已关闭超过http.client_stats.closed_channels.max_age 设置时间的客户端将不会在此处表示。

Properties of clients

id: (integer) Unique ID for the HTTP client.
agent: (string) Reported agent for the HTTP client. If unavailable, this property is not included in the response.
local_address: (string) Local address for the HTTP connection.
remote_address: (string) Remote address for the HTTP connection.
last_uri: (string) The URI of the client’s most recent request.
x_forwarded_for: (string) Value from the client’s x-forwarded-for HTTP header. If unavailable, this property is not included in the response.
x_opaque_id: (string) Value from the client’s x-opaque-id HTTP header. If unavailable, this property is not included in the response.
opened_time_millis: (integer) Time at which the client opened the connection.
closed_time_millis: (integer) Time at which the client closed the connection if the connection is closed.
last_request_time_millis: (integer) Time of the most recent request from this client.
request_count: (integer) Number of requests from this client.
request_size_bytes: (integer) Cumulative size in bytes of all requests from this client.

ingest

(对象) 包含集群的摄取信息。

Properties of ingest

total

(对象) 包含有关集群摄取操作的信息。

Properties of total

count: (integer) Total number of documents ingested across the cluster.
time: (time value) Total time spent preprocessing ingest documents across the cluster.
time_in_millis: (integer) Total time, in milliseconds, spent preprocessing ingest documents across the cluster.
current: (integer) Total number of documents currently being ingested.
failed: (integer) Total number of failed ingest operations across the cluster.

pipelines

(对象) 包含有关集群摄取管道的信息。

Properties of pipelines

<pipeline_id>

(对象) 包含有关摄取管道的信息。

Properties of <pipeline_id>

count

(integer) Number of documents preprocessed by the ingest pipeline.

time

(time value) Total time spent preprocessing documents in the ingest pipeline.

time_in_millis

(integer) Total time, in milliseconds, spent preprocessing documents in the ingest pipeline.

failed

(integer) Total number of failed operations for the ingest pipeline.

ingested_as_first_pipeline

(byte value) Total ingested size of all documents which were first processed by this pipeline. A document is not added to the stat value for this pipeline if it is a final pipeline after a default pipeline, a pipeline run after a reroute processor, or is within a pipeline processor. Instead, the document size is added to the stat value of the pipeline which initially ingested the document.

ingested_as_first_pipeline_in_bytes

(integer) Total ingested size, in bytes, of all documents which were first processed by this pipeline. A document is not added to the stat value for this pipeline if it is a final pipeline after a default pipeline, a pipeline run after a reroute processor, or is within a pipeline processor. Instead, the document size is added to the stat value of the pipeline which initially ingested the document.

produced_as_first_pipeline

(byte value) Total produced size of all documents which were first processed by this pipeline. A document is not added to the stat value for this pipeline if it is a final pipeline after a default pipeline, a pipeline run after a reroute processor, or is within a pipeline processor. Instead, the document size is added to the stat value of the pipeline which initially ingested the document.

produced_as_first_pipeline_in_bytes

(integer) Total produced size, in bytes, of all documents which were first processed by this pipeline. A document is not added to the stat value for this pipeline if it is a final pipeline after a default pipeline, a pipeline run after a reroute processor, or is within a pipeline processor. Instead, the document size is added to the stat value of the pipeline which initially ingested the document.

processors

(对象数组) 包含用于摄取管道的摄取处理器的相关信息。

Properties of processors

<processor>

(对象) 包含用于摄取处理器的信息。

Properties of <processor>

count: (integer) Number of documents transformed by the processor.
time: (time value) Time spent by the processor transforming documents.
time_in_millis: (integer) Time, in milliseconds, spent by the processor transforming documents.
current: (integer) Number of documents currently being transformed by the processor.
failed: (integer) Number of failed operations for the processor.

thread_pool

(对象) 包含有关集群线程池的信息。

Properties of thread_pool

<thread_pool_name>

(对象) 包含有关名为的集群线程池的信息。

Properties of <thread_pool_name>

threads: (integer) Number of threads in the thread pool.
queue: (integer) Number of tasks in queue for the thread pool.
active: (integer) Number of active threads in the thread pool.
rejected: (integer) Number of tasks rejected by the thread pool executor.
largest: (integer) Highest number of active threads in the thread pool.
completed: (integer) Number of tasks completed by the thread pool executor.

script

(对象) 包含集群的脚本统计信息。

Properties of script

compilations: (integer) Total number of inline script compilations performed by the cluster.
compilations_history: (object) Contains the recent history of script compilations.

Properties of compilations_history

5m: (long) The number of script compilations in the last five minutes.
15m: (long) The number of script compilations in the last fifteen minutes.
24h: (long) The number of script compilations in the last twenty-four hours.

cache_evictions: (integer) Total number of times the script cache has evicted old data.
cache_evictions_history: (object) Contains the recent history of script cache evictions.

Properties of cache_evictions

5m: (long) The number of script cache evictions in the last five minutes.
15m: (long) The number of script cache evictions in the last fifteen minutes.
24h: (long) The number of script cache evictions in the last twenty-four hours.

compilation_limit_triggered: (integer) Total number of times the script compilation circuit breaker has limited inline script compilations.

示例

edit

# returns all stats info of the cluster
GET /_info/_all

# returns the http info of the cluster
GET /_info/http

# returns the http info of the cluster
GET /_info/ingest

# returns the thread_pool info of the cluster
GET /_info/thread_pool

# returns the script info of the cluster
GET /_info/script

# returns the http and ingest info of the cluster
GET /_info/http,ingest

待处理集群任务 API

edit

返回尚未执行的集群级别更改。

请求

edit

GET /_cluster/pending_tasks

先决条件

edit

如果启用了Elasticsearch安全功能，您必须拥有monitor或manage 集群权限才能使用此API。

描述

edit

待处理的集群任务 API 返回尚未执行的任何集群级别更改的列表（例如，创建索引、更新映射、分配或失败分片）。

此API返回集群状态的任何待处理更新的列表。这些更新与任务管理API报告的任务不同，后者包括周期性任务和用户发起的任务，例如节点统计信息、搜索查询或创建索引请求。然而，如果用户发起的任务（如创建索引命令）导致集群状态更新，此任务的活动可能会被任务API和待处理的集群任务API同时报告。

路径参数

edit

local: (可选，布尔值) 如果 true，请求仅从本地节点检索信息。默认为 false，这意味着信息从主节点检索。
master_timeout: (可选，时间单位) 等待主节点的时间段。如果在超时到期之前主节点不可用，请求将失败并返回错误。默认为30s。也可以设置为-1，表示请求不应超时。

响应体

edit

tasks: (对象) 一个待处理任务的列表。
insert_order: (整数) 表示任务何时被插入到任务队列中的数字。
priority: (字符串) 待处理任务的优先级。有效优先级按优先级降序排列为：IMMEDIATE > URGENT > HIGH > NORMAL > LOW > LANGUID。
source: (字符串) 对集群任务的总体描述，可能包括原因和来源。
executing: (布尔值) 真或假，表示当前是否有待处理的任务正在执行。
time_in_queue_millis: (整数) 自任务等待执行以来的时间，以毫秒为单位表示。
time_in_queue: (字符串) 任务等待执行的时间。

示例

edit

通常，请求会返回一个空列表，因为集群级别的更改是快速的。然而，如果存在排队任务，响应将类似于这样：

{
   "tasks": [
      {
         "insert_order": 101,
         "priority": "URGENT",
         "source": "create-index [foo_9], cause [api]",
         "executing" : true,
         "time_in_queue_millis": 86,
         "time_in_queue": "86ms"
      },
      {
         "insert_order": 46,
         "priority": "HIGH",
         "source": "shard-started ([foo_2][1], node[tMTocMvQQgGCkj7QDHl3OA], [P], s[INITIALIZING]), reason [after recovery from shard_store]",
         "executing" : false,
         "time_in_queue_millis": 842,
         "time_in_queue": "842ms"
      },
      {
         "insert_order": 45,
         "priority": "HIGH",
         "source": "shard-started ([foo_2][0], node[tMTocMvQQgGCkj7QDHl3OA], [P], s[INITIALIZING]), reason [after recovery from shard_store]",
         "executing" : false,
         "time_in_queue_millis": 858,
         "time_in_queue": "858ms"
      }
  ]
}

远程集群信息 API

edit

返回配置的远程集群信息。

请求

edit

GET /_remote/info

先决条件

edit

如果启用了Elasticsearch安全功能，您必须拥有monitor或manage 集群权限才能使用此API。

描述

edit

集群远程信息 API 允许您检索所有已配置的远程集群信息。它返回按已配置的远程集群别名键控的连接和端点信息。

响应体

edit

mode: 远程集群的连接模式。返回值为 sniff 和 proxy。
connected: 如果至少有一个到远程集群的连接，则为真。
initial_connect_timeout: 远程集群连接的初始连接超时时间。

skip_unavailable: 跨集群搜索是否在搜索期间跳过远程集群，如果其节点不可用。如果true，跨集群搜索也会忽略远程集群返回的错误。请参阅可选的远程集群。
seeds: 配置嗅探模式时远程集群的初始种子传输地址。
num_nodes_connected: 配置嗅探模式时远程集群中连接节点的数量。
max_connections_per_cluster: 当配置了嗅探模式时，为远程集群维护的最大连接数。
proxy_address: 配置代理模式时的远程连接地址。
num_proxy_sockets_connected: 当配置了代理模式时，与远程集群的开放套接字连接数。
max_proxy_socket_connections: 当配置了代理模式时，与远程集群的最大套接字连接数。
cluster_credentials: 此字段仅在远程集群配置为基于API密钥的模型时显示并具有值::es_redacted::。否则，该字段不存在。

任务管理 API

edit

任务管理API是新的，仍应被视为测试版功能。API可能会以不向后兼容的方式进行更改。有关功能状态，请参阅#51628。

返回有关当前在集群中执行的任务的信息。

请求

edit

GET /_tasks/

GET /_tasks

先决条件

edit

如果启用了Elasticsearch安全功能，您必须拥有monitor或manage 集群权限才能使用此API。

描述

edit

任务管理 API 返回有关当前在集群中一个或多个节点上执行的任务的信息。

路径参数

edit

<task_id>: (可选，字符串) 要返回的任务的ID (node_id:task_number)。

查询参数

edit

actions

(可选，字符串) 逗号分隔的列表或通配符表达式用于限制请求的操作。

省略此参数以返回所有操作。

detailed

(可选，布尔值) 如果为true，响应将包含有关分片恢复的详细信息。默认为false。

group_by

(可选, 字符串) 用于在响应中对任务进行分组的键。

可能的值包括：

nodes: (默认) 节点ID
parents: 父任务ID
none: 不进行任务分组。

nodes

（可选，字符串）用于限制返回信息的节点ID或名称的逗号分隔列表。

parent_task_id

(可选, 字符串) 父任务ID 用于限制返回的信息。

要返回所有任务，省略此参数或使用值 -1。

timeout

(可选，时间单位) 等待每个节点响应的时间段。如果在其超时到期之前节点未响应，则响应中不包括其信息。但是，超时的节点包含在响应的node_failures属性中。默认为30s。

wait_for_completion

(可选，布尔值) 如果 true，请求将阻塞，直到所有找到的任务完成。默认为 false。

响应代码

edit

404 (Missing resources): 如果指定了但未找到，此代码表示没有与请求匹配的资源。

示例

edit

GET _tasks 
GET _tasks?nodes=nodeId1,nodeId2 
GET _tasks?nodes=nodeId1,nodeId2&actions=cluster:*

	检索集群中所有节点上当前正在运行的所有任务。
	检索在节点 `nodeId1` 和 `nodeId2` 上运行的所有任务。有关如何选择单个节点的更多信息，请参阅节点规范。
	检索在节点 `nodeId1` 和 `nodeId2` 上运行的所有与集群相关的任务。

API返回以下结果：

{
  "nodes" : {
    "oTUltX4IQMOUUVeiohTt8A" : {
      "name" : "H5dfFeA",
      "transport_address" : "127.0.0.1:9300",
      "host" : "127.0.0.1",
      "ip" : "127.0.0.1:9300",
      "tasks" : {
        "oTUltX4IQMOUUVeiohTt8A:124" : {
          "node" : "oTUltX4IQMOUUVeiohTt8A",
          "id" : 124,
          "type" : "direct",
          "action" : "cluster:monitor/tasks/lists[n]",
          "start_time_in_millis" : 1458585884904,
          "running_time_in_nanos" : 47402,
          "cancellable" : false,
          "parent_task_id" : "oTUltX4IQMOUUVeiohTt8A:123"
        },
        "oTUltX4IQMOUUVeiohTt8A:123" : {
          "node" : "oTUltX4IQMOUUVeiohTt8A",
          "id" : 123,
          "type" : "transport",
          "action" : "cluster:monitor/tasks/lists",
          "start_time_in_millis" : 1458585884904,
          "running_time_in_nanos" : 236042,
          "cancellable" : false
        }
      }
    }
  }
}

从特定任务中检索信息

edit

也可以检索特定任务的信息。以下示例检索关于任务 oTUltX4IQMOUUVeiohTt8A:124 的信息：

GET _tasks/oTUltX4IQMOUUVeiohTt8A:124

如果未找到任务，API将返回404。

要检索特定任务的所有子任务：

GET _tasks?parent_task_id=oTUltX4IQMOUUVeiohTt8A:123

如果未找到父级，API不会返回404。

获取有关任务的更多信息

edit

您还可以使用 detailed 请求参数来获取有关运行任务的更多信息。这对于区分任务非常有用，但执行成本更高。例如，使用 detailed 请求参数获取所有搜索：

GET _tasks?actions=*search&detailed

API返回以下结果：

{
  "nodes" : {
    "oTUltX4IQMOUUVeiohTt8A" : {
      "name" : "H5dfFeA",
      "transport_address" : "127.0.0.1:9300",
      "host" : "127.0.0.1",
      "ip" : "127.0.0.1:9300",
      "tasks" : {
        "oTUltX4IQMOUUVeiohTt8A:464" : {
          "node" : "oTUltX4IQMOUUVeiohTt8A",
          "id" : 464,
          "type" : "transport",
          "action" : "indices:data/read/search",
          "description" : "indices[test], types[test], search_type[QUERY_THEN_FETCH], source[{\"query\":...}]",
          "start_time_in_millis" : 1483478610008,
          "running_time_in_nanos" : 13991383,
          "cancellable" : true,
          "cancelled" : false
        }
      }
    }
  }
}

新的 description 字段包含可读的文本，用于标识任务正在执行的特定请求，例如识别搜索任务正在执行的搜索请求，如上例所示。其他类型的任务有不同的描述，例如 _reindex 包含源和目标，或 _bulk 仅包含请求数量和目标索引。许多请求将只有一个空的描述，因为关于请求的更详细信息不容易获得，或者在识别请求时不是特别有用。

_tasks 请求带有 detailed 时，也可能返回一个 status。这是一个任务内部状态的报告。因此，其格式因任务而异。虽然我们尽量保持特定任务的 status 在不同版本之间的一致性，但这并不总是可能的，因为我们有时会改变实现方式。在这种情况下，我们可能会从特定请求的 status 中移除字段，因此您对状态进行的任何解析可能会在次要版本中中断。

等待完成

edit

任务API也可以用于等待特定任务的完成。以下调用将阻塞10秒钟或直到ID为oTUltX4IQMOUUVeiohTt8A:12345的任务完成。

GET _tasks/oTUltX4IQMOUUVeiohTt8A:12345?wait_for_completion=true&timeout=10s

您也可以等待所有特定操作类型的任务完成。此命令将等待所有reindex任务完成：

GET _tasks?actions=*reindex&wait_for_completion=true&timeout=10s

任务取消

edit

如果一个长时间运行的任务支持取消，可以使用取消任务API来取消它。以下示例取消任务 oTUltX4IQMOUUVeiohTt8A:12345：

POST _tasks/oTUltX4IQMOUUVeiohTt8A:12345/_cancel

任务取消命令支持与列表任务命令相同的任务选择参数，因此可以同时取消多个任务。例如，以下命令将取消在节点 nodeId1 和 nodeId2 上运行的所有重新索引任务。

POST _tasks/_cancel?nodes=nodeId1,nodeId2&actions=*reindex

一个任务在被取消后可能会继续运行一段时间，因为它可能无法立即安全地停止当前活动，或者因为Elasticsearch必须在处理取消之前完成其他任务的工作。列表任务API将继续列出这些已取消的任务，直到它们完成。列表任务API响应中的cancelled标志表示已处理取消命令，任务将尽快停止。要排查已取消任务为何未及时完成，请使用带有?detailed参数的列表任务API来识别系统正在运行的其他任务，并使用节点热线程API获取系统正在执行的工作的详细信息，而不是完成已取消的任务。

任务分组

edit

任务 API 命令返回的任务列表可以按节点（默认）或使用 group_by 参数按父任务进行分组。以下命令将分组更改为父任务：

GET _tasks?group_by=parents

可以通过将 none 指定为 group_by 参数来禁用分组：

GET _tasks?group_by=none

识别正在运行的任务

edit

当在HTTP请求头中提供X-Opaque-Id头时，它将作为响应头返回，并且还会在任务信息的headers字段中返回。这允许跟踪某些调用，或将某些任务与启动它们的客户端关联起来：

curl -i -H "X-Opaque-Id: 123456" "http://localhost:9200/_tasks?group_by=parents"

API返回以下结果：

HTTP/1.1 200 OK
X-Opaque-Id: 123456 
content-type: application/json; charset=UTF-8
content-length: 831

{
  "tasks" : {
    "u5lcZHqcQhu-rUoFaqDphA:45" : {
      "node" : "u5lcZHqcQhu-rUoFaqDphA",
      "id" : 45,
      "type" : "transport",
      "action" : "cluster:monitor/tasks/lists",
      "start_time_in_millis" : 1513823752749,
      "running_time_in_nanos" : 293139,
      "cancellable" : false,
      "headers" : {
        "X-Opaque-Id" : "123456" 
      },
      "children" : [
        {
          "node" : "u5lcZHqcQhu-rUoFaqDphA",
          "id" : 46,
          "type" : "direct",
          "action" : "cluster:monitor/tasks/lists[n]",
          "start_time_in_millis" : 1513823752750,
          "running_time_in_nanos" : 92133,
          "cancellable" : false,
          "parent_task_id" : "u5lcZHqcQhu-rUoFaqDphA:45",
          "headers" : {
            "X-Opaque-Id" : "123456" 
          }
        }
      ]
    }
  }
}

	id 作为响应头的一部分
	由REST请求发起的任务的id
	由REST请求发起的任务的子任务

投票配置排除 API

edit

从投票配置排除列表中添加或移除具有主节点资格的节点。

请求

edit

POST /_cluster/voting_config_exclusions?node_names=

POST /_cluster/voting_config_exclusions?node_ids=

DELETE /_cluster/voting_config_exclusions

先决条件

edit

如果启用了Elasticsearch安全功能，您必须拥有manage 集群权限才能使用此API。
如果启用了操作员权限功能，则只有操作员用户可以使用此API。

描述

edit

默认情况下，如果集群中有超过三个主节点候选节点，并且您一次移除的主节点候选节点少于集群中主节点候选节点的一半，则投票配置会自动缩小。

如果你想将投票配置缩小到少于三个节点，或者一次性移除集群中一半或更多的符合主节点资格的节点，请使用此API手动从投票配置中移除即将离开的节点。该API会为每个指定的节点在集群的投票配置排除列表中添加一个条目。然后，它会等待直到集群重新配置其投票配置以排除指定的节点。

集群在正常操作中不应有投票配置排除项。一旦被排除的节点停止，使用DELETE /_cluster/voting_config_exclusions清除投票配置排除项。此API会等待节点完全从集群中移除后再返回。如果你的集群有你不再打算移除的节点的投票配置排除项，使用DELETE /_cluster/voting_config_exclusions?wait_for_removal=false来清除投票配置排除项，而不等待节点离开集群。

如果API调用失败，您可以安全地重试。只有成功的响应才能保证该节点已从投票配置中移除，并且不会被重新加入。

仅当您在短时间内从集群中移除至少一半的主节点时，才需要投票排除。移除非主节点或不到一半的主节点时，不需要投票排除。

更多信息，请参阅移除有资格成为主节点的节点。

查询参数

edit

node_names: 要排除在投票配置之外的节点的名称的逗号分隔列表。如果指定，则不能同时指定 ?node_ids。仅适用于此API的 POST 形式。
node_ids: 要排除在投票配置之外的节点的持久性ID的逗号分隔列表。如果指定，则不能同时指定?node_names。仅适用于此API的POST形式。
timeout: (可选，时间单位) 当添加投票配置排除时，API会等待指定节点从投票配置中被排除后再返回。等待的时间由?timeout查询参数指定。如果在超时到期之前未满足适当的条件，请求将失败并返回错误。默认为30s。仅适用于此API的POST形式。
master_timeout: (可选，时间单位) 定义在尝试将请求路由到集群中的当前主节点时等待多长时间。默认为 30s。适用于此API的 POST 和 DELETE 形式。
wait_for_removal: (可选，布尔值) 指定是否在清除投票配置排除列表之前等待所有被排除的节点从集群中移除。默认为 true，意味着在执行此API之前，所有被排除的节点必须从集群中移除。如果设置为 false，则即使某些被排除的节点仍在集群中，投票配置排除列表也会被清除。仅适用于此API的 DELETE 形式。

示例

edit

将名为 nodeName1 和 nodeName2 的节点添加到投票配置排除列表中：

POST /_cluster/voting_config_exclusions?node_names=nodeName1,nodeName2

从列表中移除所有排除项：

DELETE /_cluster/voting_config_exclusions

创建或更新期望节点 API

edit

此功能旨在供 Elasticsearch Service、Elastic Cloud Enterprise 和 Elastic Cloud on Kubernetes 间接使用。不支持直接使用。

创建或更新所需的节点。

请求

edit

PUT /_internal/desired_nodes/<history_id>/<version>
{
    "nodes" : [
        {
            "settings" : {
                 "node.name" : "instance-000187",
                 "node.external_id": "instance-000187",
                 "node.roles" : ["data_hot", "master"],
                 "node.attr.data" : "hot",
                 "node.attr.logical_availability_zone" : "zone-0"
            },
            "processors" : 8.0,
            "memory" : "58gb",
            "storage" : "2tb"
        }
    ]
}

查询参数

edit

master_timeout: (可选，时间单位) 等待主节点的时间段。如果在超时到期之前主节点不可用，请求将失败并返回错误。默认为30s。也可以设置为-1，表示请求不应超时。
dry_run: (可选, 布尔值) 如果 true, 则请求模拟更新并返回一个响应, 其中 dry_run 字段设置为 true。

描述

edit

此API用于创建或更新所需的节点。外部编排器可以使用此API让Elasticsearch了解集群拓扑结构，包括未来的更改，如添加或删除节点。利用这些信息，系统能够做出更好的决策。

通过添加?dry_run查询参数，可以在“干运行”模式下运行更新。这将验证请求结果，但不会实际执行更新。

示例

edit

在这个示例中，为具有历史记录 Ywkh3INLQcuPT49f6kcppA 的所需节点创建了一个新版本。此 API 仅接受单调递增的版本。

PUT /_internal/desired_nodes/Ywkh3INLQcuPT49f6kcppA/100
{
    "nodes" : [
        {
            "settings" : {
                 "node.name" : "instance-000187",
                 "node.external_id": "instance-000187",
                 "node.roles" : ["data_hot", "master"],
                 "node.attr.data" : "hot",
                 "node.attr.logical_availability_zone" : "zone-0"
            },
            "processors" : 8.0,
            "memory" : "58gb",
            "storage" : "2tb"
        }
    ]
}

API返回以下结果：

{
  "replaced_existing_history_id": false,
  "dry_run": false
}

此外，还可以指定处理器范围。这在Elasticsearch节点可以部署在主机中的环境中非常有用，在这些主机中，Elasticsearch进程可以使用的处理器数量保证至少为下限，并且最多为上限。这是在Linux部署中使用cgroups时的常见场景。

PUT /_internal/desired_nodes/Ywkh3INLQcuPT49f6kcppA/101
{
    "nodes" : [
        {
            "settings" : {
                 "node.name" : "instance-000187",
                 "node.external_id": "instance-000187",
                 "node.roles" : ["data_hot", "master"],
                 "node.attr.data" : "hot",
                 "node.attr.logical_availability_zone" : "zone-0"
            },
            "processors_range" : {"min": 8.0, "max": 10.0},
            "memory" : "58gb",
            "storage" : "2tb"
        }
    ]
}

获取所需节点 API

edit

此功能旨在供 Elasticsearch Service、Elastic Cloud Enterprise 和 Elastic Cloud on Kubernetes 间接使用。不支持直接使用。

获取所需节点。

请求

edit

GET /_internal/desired_nodes/_latest

描述

edit

此API获取最新的所需节点。

示例

edit

此示例获取最新的所需节点。

GET /_internal/desired_nodes/_latest

API返回以下结果：

{
    "history_id": <history_id>,
    "version": <version>,
    "nodes": [
        {
            "settings": <node_settings>,
            "processors": <node_processors>,
            "memory": "<node_memory>",
            "storage": "<node_storage>"
        }
    ]
}

删除所需节点 API

edit

此功能旨在供 Elasticsearch Service、Elastic Cloud Enterprise 和 Elastic Cloud on Kubernetes 间接使用。不支持直接使用。

删除所需的节点。

请求

edit

DELETE /_internal/desired_nodes

描述

edit

此API删除所需的节点。

示例

edit

此示例删除当前所需的节点。

DELETE /_internal/desired_nodes

获取期望余额 API

edit

此功能旨在供 Elasticsearch Service、Elastic Cloud Enterprise 和 Elastic Cloud on Kubernetes 间接使用。不支持直接使用。

暴露：

计算和协调统计数据的期望平衡
平衡统计数据，如分片的分布、磁盘和摄取预测跨节点和数据层（基于当前集群状态）
路由表，包含每个分片的当前和期望位置
包含节点磁盘使用情况的集群信息

请求

edit

GET /_internal/desired_balance

API返回以下结果：

{
  "stats": {
    "computation_active": false,
    "computation_submitted": 5,
    "computation_executed": 5,
    "computation_converged": 5,
    "computation_iterations": 4,
    "computation_converged_index": 4,
    "computation_time_in_millis": 0,
    "reconciliation_time_in_millis": 0
  },
  "cluster_balance_stats" : {
    "shard_count": 37,
    "undesired_shard_allocation_count": 0,
    "tiers": {
      "data_hot" : {
        "shard_count" : {
          "total" : 7.0,
          "min" : 2.0,
          "max" : 3.0,
          "average" : 2.3333333333333335,
          "std_dev" : 0.4714045207910317
        },
        "undesired_shard_allocation_count" : {
          "total" : 0.0,
          "min" : 0.0,
          "max" : 0.0,
          "average" : 0.0,
          "std_dev" : 0.0
        },
        "forecast_write_load" : {
          "total" : 21.0,
          "min" : 6.0,
          "max" : 8.5,
          "average" : 7.0,
          "std_dev" : 1.0801234497346435
        },
        "forecast_disk_usage" : {
          "total" : 36.0,
          "min" : 10.0,
          "max" : 16.0,
          "average" : 12.0,
          "std_dev" : 2.8284271247461903
        },
        "actual_disk_usage" : {
          "total" : 36.0,
          "min" : 10.0,
          "max" : 16.0,
          "average" : 12.0,
          "std_dev" : 2.8284271247461903
        }
      },
      "data_warm" : {
        "shard_count" : {
          "total" : 3.0,
          "min" : 1.0,
          "max" : 1.0,
          "average" : 1.0,
          "std_dev" : 0.0
        },
        "undesired_shard_allocation_count" : {
          "total" : 0.0,
          "min" : 0.0,
          "max" : 0.0,
          "average" : 0.0,
          "std_dev" : 0.0
        },
        "forecast_write_load" : {
          "total" : 0.0,
          "min" : 0.0,
          "max" : 0.0,
          "average" : 0.0,
          "std_dev" : 0.0
        },
        "forecast_disk_usage" : {
          "total" : 42.0,
          "min" : 12.0,
          "max" : 18.0,
          "average" : 14.0,
          "std_dev" : 2.8284271247461903
        },
        "actual_disk_usage" : {
          "total" : 42.0,
          "min" : 12.0,
          "max" : 18.0,
          "average" : 14.0,
          "std_dev" : 2.8284271247461903
        }
      }
    },
    "nodes": {
      "node-1": {
        "node_id": "UPYt8VwWTt-IADAEbqpLxA",
        "roles": ["data_content"],
        "shard_count": 10,
        "undesired_shard_allocation_count": 0,
        "forecast_write_load": 8.5,
        "forecast_disk_usage_bytes": 498435,
        "actual_disk_usage_bytes": 498435
      },
      "node-2": {
        "node_id": "bgC66tboTIeFQ0VgRGI4Gg",
        "roles": ["data_content"],
        "shard_count": 15,
        "undesired_shard_allocation_count": 0,
        "forecast_write_load": 3.25,
        "forecast_disk_usage_bytes": 384935,
        "actual_disk_usage_bytes": 384935
      },
      "node-3": {
        "node_id": "2x1VTuSOQdeguXPdN73yRw",
        "roles": ["data_content"],
        "shard_count": 12,
        "undesired_shard_allocation_count": 0,
        "forecast_write_load": 6.0,
        "forecast_disk_usage_bytes": 648766,
        "actual_disk_usage_bytes": 648766
      }
    }
  },
  "routing_table": {
    "test": {
      "0": {
        "current": [
          {
            "state": "STARTED",
            "primary": true,
            "node": "UPYt8VwWTt-IADAEbqpLxA",
            "node_is_desired": true,
            "relocating_node": null,
            "relocating_node_is_desired": null,
            "shard_id": 0,
            "index": "test",
            "forecast_write_load": 8.0,
            "forecast_shard_size_in_bytes": 1024,
            "tier_preference": ["data_content"]
          }
        ],
        "desired": {
          "node_ids": [
            "UPYt8VwWTt-IADAEbqpLxA"
          ],
          "total": 1,
          "unassigned": 0,
          "ignored": 0
        }
      },
      "1": {
        "current": [
          {
            "state": "STARTED",
            "primary": true,
            "node": "2x1VTuSOQdeguXPdN73yRw",
            "node_is_desired": true,
            "relocating_node": null,
            "relocating_node_is_desired": false,
            "shard_id": 1,
            "index": "test",
            "forecast_write_load": null,
            "forecast_shard_size_in_bytes": null,
            "tier_preference": ["data_content"]
          }
        ],
        "desired": {
          "node_ids": [
            "2x1VTuSOQdeguXPdN73yRw"
          ],
          "total": 1,
          "unassigned": 0,
          "ignored": 0
        }
      }
    }
  },
  "cluster_info" : {
      "nodes" : {
        "UPYt8VwWTt-IADAEbqpLxA" : {
          "node_name" : "node-1",
          "least_available" : {
            "path" : "/data",
            "total_bytes" : 1440713945,
            "used_bytes" : 1222486407,
            "free_bytes" : 218227538,
            "free_disk_percent" : 15.1,
            "used_disk_percent" : 84.9
          },
          "most_available" : {
            "path" : "/data",
            "total_bytes" : 1440713945,
            "used_bytes" : 1222486407,
            "free_bytes" : 218227538,
            "free_disk_percent" : 15.1,
            "used_disk_percent" : 84.9
          }
        }
      },
      "shard_sizes" : {
        "[test][0][p]_bytes" : 1720826288,
        "[test][1][p]_bytes" : 1720826288
      },
      "shard_data_set_sizes" : {
        "[test][0][p]_bytes" : 1720826288,
        "[test][1][p]_bytes" : 1720826288
      },
      "shard_paths" : {
        "NodeAndShard[nodeId=UPYt8VwWTt-IADAEbqpLxA, shardId=[test][0]]" : "/data",
        "NodeAndShard[nodeId=bgC66tboTIeFQ0VgRGI4Gg, shardId=[test][0]]" : "/data"
      },
      "reserved_sizes" : []
  }
}

重置期望余额 API

edit

此功能旨在供 Elasticsearch Service、Elastic Cloud Enterprise 和 Elastic Cloud on Kubernetes 间接使用。不支持直接使用。

丢弃当前的期望平衡，并从当前的分片分配开始计算新的期望平衡。这有时可以帮助Elasticsearch找到一个需要较少分片移动来实现的期望平衡，特别是在集群经历了重大变化，使得当前的期望平衡不再最优，而Elasticsearch尚未检测到当前的期望平衡将需要比实际需要的更多的分片移动来实现的情况下。然而，此API 会给选定的主节点带来沉重的负载，并且可能并不总是产生预期的效果。调用此API应该永远不是必要的。相反，可以考虑增加 cluster.routing.allocation.balance.threshold的值，以避免过多的分片移动。

请求

edit

DELETE /_internal/desired_balance

« Compact and aligned text (CAT) APIs Cross-cluster replication APIs »

集群API

集群API

节点规格

集群分配解释 API

请求

先决条件

描述

查询参数

请求体

示例

未分配的主分片

冲突的设置

超过最大重试次数

没有有效的分片副本

未分配的副本分片

分配延迟

分配受限

已分配的分片

无法停留在当前节点

必须保持在当前节点

无参数

集群获取设置 API

前提条件

请求

描述

查询参数

集群健康状况 API

请求

先决条件

描述

路径参数

查询参数

响应体

示例

健康 API

请求

先决条件

描述

路径参数

查询参数

响应体

指标详情

master_is_stable

分片可用性

磁盘

仓库完整性

ilm

slm

分片容量

示例

集群重路由 API

请求

先决条件

描述

查询参数

请求体

示例

集群状态 API

请求

先决条件

描述

路径参数

查询参数

示例

集群状态 API

请求

先决条件

描述

路径参数

查询参数

响应体

示例

集群更新设置 API

请求

先决条件

描述

查询参数

示例

节点功能使用情况 API

请求