PUT _watcher/watch/my_watch
{
  "trigger" : {
    "schedule" : {
      "yearly" : { "in" : "february", "on" : 29, "at" : "noon" }
    }
  },
  "input": {
    "simple": {
      "payload": {
        "send": "yes"
      }
    }
  },
  "condition": {
    "always": {}
  },
  "actions": {
    "test_index": {
      "throttle_period": "15m",
      "index": {
        "index": "test"
      }
    }
  }
}

当你调用获取观察API时，会返回观察的当前状态及其操作的状态与观察定义：

GET _watcher/watch/my_watch

新创建的监视器的操作状态是 awaits_successful_execution：

{
  "found": true,
  "_seq_no": 0,
  "_primary_term": 1,
  "_version": 1,
  "_id": "my_watch",
  "status": {
    "version": 1,
    "actions": {
      "test_index": {
        "ack": {
          "timestamp": "2015-05-26T18:04:27.723Z",
          "state": "awaits_successful_execution"
        }
      }
    },
    "state": ...
  },
  "watch": ...
}

当观察执行并且条件匹配时，ack.state 的值会变为 ackable。让我们强制执行观察并再次获取它以检查状态：

POST _watcher/watch/my_watch/_execute
{
  "record_execution" : true
}

GET _watcher/watch/my_watch

并且操作现在处于可确认状态：

{
  "found": true,
  "_id": "my_watch",
  "_seq_no": 1,
  "_primary_term": 1,
  "_version": 2,
  "status": {
    "version": 2,
    "actions": {
      "test_index": {
        "ack": {
          "timestamp": "2015-05-26T18:04:27.723Z",
          "state": "ackable"
        },
        "last_execution" : {
          "timestamp": "2015-05-25T18:04:27.723Z",
          "successful": true
        },
        "last_successful_execution" : {
          "timestamp": "2015-05-25T18:04:27.723Z",
          "successful": true
        }
      }
    },
    "state": ...,
    "execution_state": "executed",
    "last_checked": ...,
    "last_met_condition": ...
  },
  "watch": ...
}

现在我们可以承认它：

PUT _watcher/watch/my_watch/_ack/test_index
GET _watcher/watch/my_watch

{
  "found": true,
  "_id": "my_watch",
  "_seq_no": 2,
  "_primary_term": 1,
  "_version": 3,
  "status": {
    "version": 3,
    "actions": {
      "test_index": {
        "ack": {
          "timestamp": "2015-05-26T18:04:27.723Z",
          "state": "acked"
        },
        "last_execution" : {
          "timestamp": "2015-05-25T18:04:27.723Z",
          "successful": true
        },
        "last_successful_execution" : {
          "timestamp": "2015-05-25T18:04:27.723Z",
          "successful": true
        }
      }
    },
    "state": ...,
    "execution_state": "executed",
    "last_checked": ...,
    "last_met_condition": ...
  },
  "watch": ...
}

确认一个操作会限制该操作的进一步执行，直到其ack.state被重置为awaits_successful_execution。这种情况发生在观察的条件未满足时（条件评估为false）。

您可以通过将 actions 参数分配为一个以逗号分隔的动作ID列表来确认多个动作：

POST _watcher/watch/my_watch/_ack/action1,action2

要确认一个监视器的所有操作，只需省略 actions 参数：

POST _watcher/watch/my_watch/_ack

响应看起来像是一个获取手表的响应，但只包含状态：

{
  "status": {
    "state": {
      "active": true,
      "timestamp": "2015-05-26T18:04:27.723Z"
    },
    "last_checked": "2015-05-26T18:04:27.753Z",
    "last_met_condition": "2015-05-26T18:04:27.763Z",
    "actions": {
      "test_index": {
        "ack" : {
          "timestamp": "2015-05-26T18:04:27.713Z",
          "state": "acked"
        },
        "last_execution" : {
          "timestamp": "2015-05-25T18:04:27.733Z",
          "successful": true
        },
        "last_successful_execution" : {
          "timestamp": "2015-05-25T18:04:27.773Z",
          "successful": true
        }
      }
    },
    "execution_state": "executed",
    "version": 2
  }
}

激活观察API

edit

一个监视器可以是活动或非活动的。此API使您能够激活当前处于非活动状态的监视器。

请求

edit

PUT _watcher/watch//_activate

先决条件

edit

您必须拥有manage_watcher集群权限才能使用此API。更多信息，请参阅安全权限。

路径参数

edit

<watch_id>: （必需，字符串）监视器的标识符。

示例

edit

当你调用获取观察API时，不活跃的观察状态会随观察定义一起返回：

GET _watcher/watch/my_watch

{
  "found": true,
  "_id": "my_watch",
  "_seq_no": 0,
  "_primary_term": 1,
  "_version": 1,
  "status": {
    "state" : {
      "active" : false,
      "timestamp" : "2015-08-20T12:21:32.734Z"
    },
    "actions": ...,
    "version": 1
  },
  "watch": ...
}

您可以通过执行以下API调用来激活手表：

PUT _watcher/watch/my_watch/_activate

手表的新状态作为其整体状态的一部分返回：

{
  "status": {
    "state" : {
      "active" : true,
      "timestamp" : "2015-09-04T08:39:46.816Z"
    },
    "actions": ...,
    "version": 1
  }
}

停用观察 API

edit

一个监视器可以是活动或非活动的。此API使您能够停用当前活动的监视器。

请求

edit

PUT _watcher/watch//_deactivate

前提条件

edit

您必须拥有manage_watcher集群权限才能使用此API。更多信息，请参阅安全权限。

路径参数

edit

<watch_id>: (必需，字符串) 监视器的标识符。

示例

edit

当你调用获取观察API时，活动观察的状态会与观察定义一起返回：

GET _watcher/watch/my_watch

{
  "found": true,
  "_id": "my_watch",
  "_version": 1,
  "_seq_no": 0,
  "_primary_term": 1,
  "status": {
    "state" : {
      "active" : true,
      "timestamp" : "2015-08-20T12:21:32.734Z"
    },
    "actions": ...,
    "version": 1
  },
  "watch": ...
}

您可以通过执行以下API调用来停用监视：

PUT _watcher/watch/my_watch/_deactivate

手表的新状态作为其整体状态的一部分返回：

{
  "status": {
    "state" : {
      "active" : false,
      "timestamp" : "2015-09-04T08:39:46.816Z"
    },
    "actions": ...,
    "version": 1
  }
}

删除观察API

edit

从 Watcher 中移除一个监视。

请求

edit

DELETE _watcher/watch/

先决条件

edit

您必须拥有manage_watcher集群权限才能使用此API。更多信息，请参阅安全权限。

描述

edit

当手表被移除时，表示该手表在 .watches 索引中的文档将被删除，并且它将永远不会再次运行。

请注意，删除一个观察器不会从观察器历史记录中删除与此观察器相关的任何观察器执行记录。

删除监视器必须仅通过此API完成。不要使用Elasticsearch DELETE Document API直接从.watches索引中删除监视器。当启用了Elasticsearch安全功能时，确保没有向任何人授予对.watches索引的write权限。

路径参数

edit

<watch_id>: (必需, 字符串) 监视器的标识符。

示例

edit

以下示例删除了一个ID为my-watch的监视器：

DELETE _watcher/watch/my_watch

响应:

{
   "found": true,
   "_id": "my_watch",
   "_version": 2
}

执行观察API

edit

强制执行一个存储的观察。

请求

edit

POST _watcher/watch//_execute

POST _watcher/watch/_execute

先决条件

edit

您必须拥有manage_watcher集群权限才能使用此API。更多信息，请参阅安全权限。

描述

edit

此API可用于强制执行监视器，而不受其触发逻辑的限制，或用于调试目的模拟监视器的执行。

为了测试和调试目的，您还可以对监视器运行的方式进行精细控制。您可以执行监视器而不执行其所有操作，或者通过模拟它们来执行。您还可以通过忽略监视器条件来强制执行，并控制监视器执行后是否会将记录写入监视器历史记录。

内联监视执行

edit

您可以使用 Execute API 来执行尚未注册的监视器，方法是将监视器定义内联指定。这是在将监视器添加到 Watcher 之前进行测试和调试的绝佳工具。

路径参数

edit

<watch_id>: （可选，字符串）监视器的标识符。

查询参数

edit

debug: (可选，布尔值) 定义监视器是否在调试模式下运行。默认值是 false。

请求体

edit

此API支持以下字段：

Name	Required	Default	Description
`trigger_data`	否		此结构被解析为触发事件的数据，将在监视执行期间使用
`ignore_condition`	否	假	当设置为`true`时，监视执行使用always条件。这也可以作为HTTP参数指定。
`alternative_input`	否	空	当存在时，手表使用此对象作为有效载荷，而不是执行其自身的输入。
`action_modes`	否	空	确定如何在监视执行过程中处理监视操作。有关更多信息，请参阅操作执行模式。
`record_execution`	否	假	当设置为`true`时，表示监视执行结果的监视记录会被持久化到当前时间的`.watcher-history`索引中。此外，监视的状态会被更新，可能会限制后续的执行。这也可以作为HTTP参数指定。
`观察`	否	空	当存在时，此观察用于替代请求中指定的观察。此观察不会保存到索引中，且无法设置record_execution。

操作执行模式

edit

操作模式定义了在监视执行期间如何处理操作。一个操作可以与以下五种可能的模式之一相关联：

Name	Description
`simulate`	操作执行是模拟的。每种操作类型都定义了自己的模拟操作模式。例如，`email` 操作会创建将要发送的电子邮件，但不会实际发送它。在这种模式下，如果监视的当前状态表明应该进行限制，则操作可能会被限制。
`force_simulate`	类似于`simulate`模式，只是即使当前观察状态指示应该进行限流，操作也不会被限流。
`执行`	执行操作，就像它被自己的触发器触发时一样执行。如果当前的观察状态表明应该进行限制，执行可能会受到限制。
`force_execute`	类似于`execute`模式，只是即使当前观察状态表明应该进行限制，操作也不会被限制。
`跳过`	操作被跳过，不会执行或模拟。实际上强制操作被限流。

安全集成

edit

当Elasticsearch安全功能在您的集群上启用时，监视器将使用存储监视器的用户的权限执行。如果您的用户被允许读取索引a，但不允许读取索引b，那么在执行监视器期间将应用完全相同的规则集。

在使用执行观察 API 时，将使用调用 API 的用户的授权数据作为基础，而不是存储观察的用户信息。

示例

edit

以下示例执行了 my_watch 监视：

POST _watcher/watch/my_watch/_execute

以下示例展示了执行 my-watch 监视的综合示例：

POST _watcher/watch/my_watch/_execute
{
  "trigger_data" : { 
     "triggered_time" : "now",
     "scheduled_time" : "now"
  },
  "alternative_input" : { 
    "foo" : "bar"
  },
  "ignore_condition" : true, 
  "action_modes" : {
    "my-action" : "force_simulate" 
  },
  "record_execution" : true 
}

	触发的和计划的时间已提供。
	由监视器定义的输入被忽略，而是使用提供的输入作为执行负载。
	由监视器定义的条件被忽略，并假定其评估为`true`。
	强制模拟 `my-action`。强制模拟意味着忽略节流，并且由 Watcher 模拟监视器而不是正常执行。
	执行监视操作会在监视历史记录中创建一个监视记录，并且监视的节流状态可能会相应更新。

这是一个输出示例：

{
  "_id": "my_watch_0-2015-06-02T23:17:55.124Z", 
  "watch_record": { 
    "@timestamp": "2015-06-02T23:17:55.124Z",
    "watch_id": "my_watch",
    "node": "my_node",
    "messages": [],
    "trigger_event": {
      "type": "manual",
      "triggered_time": "2015-06-02T23:17:55.124Z",
      "manual": {
        "schedule": {
          "scheduled_time": "2015-06-02T23:17:55.124Z"
        }
      }
    },
    "state": "executed",
    "status": {
      "version": 1,
      "execution_state": "executed",
      "state": {
        "active": true,
        "timestamp": "2015-06-02T23:17:55.111Z"
      },
      "last_checked": "2015-06-02T23:17:55.124Z",
      "last_met_condition": "2015-06-02T23:17:55.124Z",
      "actions": {
        "test_index": {
          "ack": {
            "timestamp": "2015-06-02T23:17:55.124Z",
            "state": "ackable"
          },
          "last_execution": {
            "timestamp": "2015-06-02T23:17:55.124Z",
            "successful": true
          },
          "last_successful_execution": {
            "timestamp": "2015-06-02T23:17:55.124Z",
            "successful": true
          }
        }
      }
    },
    "input": {
      "simple": {
        "payload": {
          "send": "yes"
        }
      }
    },
    "condition": {
      "always": {}
    },
    "result": { 
      "execution_time": "2015-06-02T23:17:55.124Z",
      "execution_duration": 12608,
      "input": {
        "type": "simple",
        "payload": {
          "foo": "bar"
        },
        "status": "success"
      },
      "condition": {
        "type": "always",
        "met": true,
        "status": "success"
      },
      "actions": [
        {
          "id": "test_index",
          "index": {
            "response": {
              "index": "test",
              "version": 1,
              "created": true,
              "result": "created",
              "id": "AVSHKzPa9zx62AzUzFXY"
            }
          },
          "status": "success",
          "type": "index"
        }
      ]
    },
    "user": "test_admin" 
  }
}

	监视记录的ID，如存储在`.watcher-history`索引中。
	观察记录文档，如存储在 `.watcher-history` 索引中。
	查看执行结果。
	用于执行观察的用户。

您可以通过将模式名称与操作ID关联来为每个操作设置不同的执行模式：

POST _watcher/watch/my_watch/_execute
{
  "action_modes" : {
    "action1" : "force_simulate",
    "action2" : "skip"
  }
}

您还可以使用 _all 作为操作 ID，将单一执行模式与监视中的所有操作关联起来：

POST _watcher/watch/my_watch/_execute
{
  "action_modes" : {
    "_all" : "force_execute"
  }
}

以下示例展示了如何内联执行一个监视：

POST _watcher/watch/_execute
{
  "watch" : {
    "trigger" : { "schedule" : { "interval" : "10s" } },
    "input" : {
      "search" : {
        "request" : {
          "indices" : [ "logs" ],
          "body" : {
            "query" : {
              "match" : { "message": "error" }
            }
          }
        }
      }
    },
    "condition" : {
      "compare" : { "ctx.payload.hits.total" : { "gt" : 0 }}
    },
    "actions" : {
      "log_error" : {
        "logging" : {
          "text" : "Found {{ctx.payload.hits.total}} errors in the logs"
        }
      }
    }
  }
}

当内联一个监视时，此API的所有其他设置仍然适用。在以下代码片段中，虽然内联监视定义了一个compare条件，但在执行过程中此条件将被忽略：

POST _watcher/watch/_execute
{
  "ignore_condition" : true,
  "watch" : {
    "trigger" : { "schedule" : { "interval" : "10s" } },
    "input" : {
      "search" : {
        "request" : {
          "indices" : [ "logs" ],
          "body" : {
            "query" : {
              "match" : { "message": "error" }
            }
          }
        }
      }
    },
    "condition" : {
      "compare" : { "ctx.payload.hits.total" : { "gt" : 0 }}
    },
    "actions" : {
      "log_error" : {
        "logging" : {
          "text" : "Found {{ctx.payload.hits.total}} errors in the logs"
        }
      }
    }
  }
}

获取观察API

edit

根据其ID检索手表。

请求

edit

GET _watcher/watch/

先决条件

edit

您必须拥有manage_watcher或monitor_watcher集群权限才能使用此API。更多信息，请参阅安全权限。

路径参数

edit

<watch_id>: （必需，字符串）监视器的标识符。

示例

edit

以下示例获取具有 my_watch id 的监视器：

GET _watcher/watch/my_watch

响应:

{
  "found": true,
  "_id": "my_watch",
  "_seq_no": 0,
  "_primary_term": 1,
  "_version": 1,
  "status": { 
    "version": 1,
    "state": {
      "active": true,
      "timestamp": "2015-05-26T18:21:08.630Z"
    },
    "actions": {
      "test_index": {
        "ack": {
          "timestamp": "2015-05-26T18:21:08.630Z",
          "state": "awaits_successful_execution"
        }
      }
    }
  },
  "watch": {
    "input": {
      "simple": {
        "payload": {
          "send": "yes"
        }
      }
    },
    "condition": {
      "always": {}
    },
    "trigger": {
      "schedule": {
        "hourly": {
          "minute": [0, 5]
        }
      }
    },
    "actions": {
      "test_index": {
        "index": {
          "index": "test"
        }
      }
    }
  }
}

手表的当前状态

获取观察者统计信息 API

edit

检索当前的Watcher指标。

请求

edit

GET _watcher/stats

GET _watcher/stats/

先决条件

edit

您必须拥有manage_watcher或monitor_watcher集群权限才能使用此API。更多信息，请参阅安全权限。

路径参数

edit

emit_stacktraces

(可选，布尔值) 定义是否为每个正在运行的监视器生成堆栈跟踪。默认值为 false。

<metric>

（可选，枚举）定义在响应中包含哪些附加指标。

current_watches: 在响应中包含当前正在执行的监视。
queued_watches: 在响应中包含排队等待执行的监视。
_all: 在响应中包含所有指标。

响应体

edit

此API始终返回基本指标。您可以通过使用metric参数来检索更多指标。

current_watches

(列表) 当前执行的监视器指标提供了关于 Watcher 当前正在执行的监视器的洞察。每个正在执行的监视器都会共享额外的信息。这些信息包括watch_id、执行开始的时间以及当前的执行阶段。

要包含此指标，`metric` 选项应设置为 `current_watches` 或 `_all`。此外，您还可以指定 `emit_stacktraces=true` 参数，该参数为每个正在执行的监视器添加堆栈跟踪。这些堆栈跟踪可以为您提供有关监视器执行的更多洞察。

queued_watches

(列表) Watcher 调节了监视的执行，以确保它们的执行不会对节点及其资源造成过大的压力。如果过多的监视同时触发，而没有足够的容量来执行它们，一些监视将被排队，等待当前正在执行的监视完成其执行。排队的监视指标提供了对这些排队监视的洞察。

要包含此指标，`metric` 选项应包含 `queued_watches` 或 `_all`。

示例

edit

以下示例调用 stats API 以检索基本指标：

GET _watcher/stats

成功的调用将返回类似于以下示例的JSON结构：

{
   "watcher_state": "started",  
   "watch_count": 1, 
   "execution_thread_pool": {
      "size": 1000, 
      "max_size": 1 
   }
}

	当前观察器的状态，可以是 `started`、`starting` 或 `stopped`。
	当前注册的监视器数量。
	已触发的监视器数量，目前正在排队等待执行。
	执行线程池的最大大小，表示并发执行的最大监视器数量。

以下示例将 metric 选项指定为查询字符串参数，并将包含基本指标和关于当前执行的监视器的指标：

GET _watcher/stats?metric=current_watches

以下示例将 metric 选项指定为 URL 路径的一部分：

GET _watcher/stats/current_watches

以下代码片段展示了一个成功捕获正在执行的监视器的JSON响应示例：

{
   "watcher_state": "started",
   "watch_count": 2,
   "execution_thread_pool": {
      "queue_size": 1000,
      "max_size": 20
   },
   "current_watches": [ 
      {
         "watch_id": "slow_condition", 
         "watch_record_id": "slow_condition_3-2015-05-13T07:42:32.179Z", 
         "triggered_time": "2015-05-12T11:53:51.800Z", 
         "execution_time": "2015-05-13T07:42:32.179Z", 
         "execution_phase": "condition" 
      }
   ]
}

	当前由 Watcher 执行的所有监视列表。当没有监视正在执行时，返回一个空数组。捕获的监视按执行时间降序排序。因此，运行时间最长的监视始终位于顶部。
	正在执行的监视器的ID。
	监视记录的ID。
	触发器引擎触发监视器的时间。
	执行观察的时间。这是在输入被执行之前。
	当前的观察执行阶段。可以是 `input`、`condition`、`actions`、 `awaits_execution`、`started`、`watch_transform`、`aborted`、`finished`。

以下示例指定了queued_watches指标选项，并包含了基本指标和排队监视器：

GET _watcher/stats/queued_watches

一个成功捕获执行中的观察的JSON响应示例：

{
   "watcher_state": "started",
   "watch_count": 10,
   "execution_thread_pool": {
      "queue_size": 1000,
      "max_size": 20
   },
   "queued_watches": [ 
         {
            "watch_id": "slow_condition4", 
            "watch_record_id": "slow_condition4_223-2015-05-21T11:59:59.811Z", 
            "triggered_time": "2015-05-21T11:59:59.811Z", 
            "execution_time": "2015-05-21T11:59:59.811Z" 
         },
      ...
   ]
}

	当前排队等待执行的所有监视列表。当没有监视排队时，返回一个空数组。
	等待执行的监视器的ID。
	监视记录的ID。
	触发器引擎触发监视器的时间。
	手表进入排队状态的时间。

查询监视器 API

edit

检索所有已注册的监视器。

请求

edit

GET /_watcher/_query/watches

先决条件

edit

您必须拥有manage_watcher或monitor_watcher集群权限才能使用此API。更多信息，请参阅安全权限。

以分页方式检索所有手表，并可选择通过查询过滤手表。

此API支持以下字段：

Name	Required	Default	Description
`从`	否	0	获取结果的第一个结果的偏移量。需要是非负的。
`大小`	否	10	返回的点击次数。需要是非负数。
`查询`	否	空	可选，查询过滤器以返回的监视。
`排序`	否	空	可选的排序定义。
`search_after`	否	空	可选的 search After 用于使用最后一个匹配项的排序值进行分页。

请注意，只有 _id 和 metadata.* 字段是可查询或可排序的。

此API返回以下顶级字段：

count: 找到的手表总数。
watches: 基于from、size 或 search_after 请求体参数的监视列表。

示例

edit

以下示例列出所有存储的监视器：

GET /_watcher/_query/watches

响应:

{
    "count": 1,
    "watches": [
        {
            "_id": "my_watch",
            "watch": {
                "trigger": {
                    "schedule": {
                        "hourly": {
                            "minute": [
                                0,
                                5
                            ]
                        }
                    }
                },
                "input": {
                    "simple": {
                        "payload": {
                            "send": "yes"
                        }
                    }
                },
                "condition": {
                    "always": {}
                },
                "actions": {
                    "test_index": {
                        "index": {
                            "index": "test"
                        }
                    }
                }
            },
            "status": {
                "state": {
                    "active": true,
                    "timestamp": "2015-05-26T18:21:08.630Z"
                },
                "actions": {
                    "test_index": {
                        "ack": {
                            "timestamp": "2015-05-26T18:21:08.630Z",
                            "state": "awaits_successful_execution"
                        }
                    }
                },
                "version": -1
            },
            "_seq_no": 0,
            "_primary_term": 1
        }
    ]
}

创建或更新观察API

edit

在Watcher中注册一个新的监视器或更新现有的监视器。

请求

edit

PUT _watcher/watch/

先决条件

edit

您必须拥有 manage_watcher 集群权限才能使用此 API。更多信息，请参阅安全权限。

描述

edit

当一个监视器被注册时，一个新的文档会被添加到.watches索引中，并且它的触发器会立即被注册到相关的触发引擎中。通常对于schedule触发器，调度器就是触发引擎。

您必须使用 Kibana 或此 API 来创建一个监视。不要直接使用 Elasticsearch 索引 API 将监视添加到 .watches 索引中。如果启用了 Elasticsearch 安全功能，请不要给用户在 .watches 索引上的 write 权限。

在添加监视器时，您还可以定义其初始的活动状态。您可以通过设置active参数来实现。

安全集成

edit

当启用了Elasticsearch安全功能时，您的监视只能在存储监视的用户具有权限的索引上进行索引或搜索。如果用户能够读取索引a，但不能读取索引b，那么在执行监视时也是如此。

路径参数

edit

<watch_id>: （必需，字符串）监视器的标识符。

查询参数

edit

active: (可选，布尔值) 定义监视器默认是活动还是非活动状态。默认值是 true，这意味着监视器默认是活动状态。

请求体

edit

一个手表有以下字段：

Name	Description
`触发器`	定义监视器何时应运行的触发器。
`输入`	定义用于加载观察数据的输入的输入。
`条件`	定义是否应运行操作的条件。
`actions`	如果条件匹配，将运行的操作列表
`transform`	处理观察负载以准备观察操作的负载转换。
`元数据`	将复制到历史记录条目中的元数据json。
`throttle_period`	动作运行的最小时间间隔，默认值为5秒。这个默认值可以在配置文件中通过设置`xpack.watcher.throttle.period.default_period`来更改。如果同时指定了这个值和`throttle_period_in_millis`参数，Watcher将使用请求中包含的最后一个参数。
`throttle_period_in_millis`	两次操作运行之间的最小时间（以毫秒为单位）。默认为 `5000`。如果同时指定了此值和 `throttle_period` 参数，Watcher 将使用请求中包含的最后一个参数。

示例

edit

以下示例添加了一个具有 my-watch ID 的监视器，该监视器具有以下特性：

监视计划每分钟触发一次。
监视搜索输入查找在过去五分钟内发生的任何404 HTTP响应。
监视条件检查是否找到了任何搜索命中。
当找到时，监视操作会向管理员发送一封电子邮件。

PUT _watcher/watch/my-watch
{
  "trigger" : {
    "schedule" : { "cron" : "0 0/1 * * * ?" }
  },
  "input" : {
    "search" : {
      "request" : {
        "indices" : [
          "logstash*"
        ],
        "body" : {
          "query" : {
            "bool" : {
              "must" : {
                "match": {
                   "response": 404
                }
              },
              "filter" : {
                "range": {
                  "@timestamp": {
                    "from": "{{ctx.trigger.scheduled_time}}||-5m",
                    "to": "{{ctx.trigger.triggered_time}}"
                  }
                }
              }
            }
          }
        }
      }
    }
  },
  "condition" : {
    "compare" : { "ctx.payload.hits.total" : { "gt" : 0 }}
  },
  "actions" : {
    "email_admin" : {
      "email" : {
        "to" : "admin@domain.host.com",
        "subject" : "404 recently encountered"
      }
    }
  }
}

当你添加一个监视器时，你还可以定义它的初始活动状态。你可以通过设置 active 参数来实现。以下命令添加一个监视器并将其默认设置为非活动状态：

PUT _watcher/watch/my-watch?active=false

如果你省略了active参数，监视器默认是激活的。

更新观察者索引设置

edit

此API允许用户修改Watcher内部索引（.watches）的设置。仅允许修改部分设置。包括：

index.auto_expand_replicas
index.number_of_replicas

修改 Watcher 设置的示例：

PUT /_watcher/watch/test_watch
{
  "trigger": {
    "schedule": {
      "hourly": {
        "minute": [ 0, 5 ]
        }
      }
  },
  "input": {
    "simple": {
      "payload": {
        "send": "yes"
      }
    }
  },
  "condition": {
    "always": {}
  }
}

PUT /_watcher/settings
{
  "index.auto_expand_replicas": "0-4"
}

可以使用获取Watcher索引设置 API检索可配置的设置。

获取观察者索引设置

edit

此API允许用户检索Watcher内部索引（.watches）的用户可配置设置。只会显示索引设置的一个子集——那些用户可配置的设置。这包括：

index.auto_expand_replicas
index.number_of_replicas

获取 Watcher 设置的示例：

GET /_watcher/settings

可配置的设置可以使用更新 Watcher 索引设置 API 进行修改。

启动监视服务API

edit

如果尚未运行，则启动Watcher服务。

请求

edit

POST _watcher/_start

先决条件

edit

您必须拥有manage_watcher集群权限才能使用此API。更多信息，请参阅安全权限。

示例

edit

POST _watcher/_start

Watcher 在请求成功时返回以下响应：

{
   "acknowledged": true
}

停止观察服务 API

edit

如果正在运行，停止Watcher服务。

请求

edit

POST _watcher/_stop

先决条件

edit

您必须拥有manage_watcher集群权限才能使用此API。更多信息，请参阅安全权限。

查询参数

edit

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

示例

edit

POST _watcher/_stop

Watcher 在请求成功时返回以下响应：

{
   "acknowledged": true
}

« Usage API Definitions »