名称	必需	默认值	描述
`trigger_data`	否		此结构被解析为触发事件的数据，将在监视执行期间使用
`ignore_condition`	否	否	设置为 `true` 时，监视执行使用 always 条件。这也可以指定为 HTTP 参数。
`alternative_input`	否	null	如果存在，监视将使用此对象作为有效负载，而不是执行其自己的输入。
`action_modes`	否	null	确定如何在监视执行中处理监视操作。有关更多信息，请参阅操作执行模式。
`record_execution`	否	否	设置为 `true` 时，表示监视执行结果的监视记录将持久化到当前时间的 `.watcher-history` 索引中。此外，监视的状态将更新，可能会限制后续执行。这也可以指定为 HTTP 参数。
`watch`	否	null	如果存在，则使用此监视，而不是请求中指定的监视。此监视不会持久化到索引中，并且无法设置 record_execution。

操作执行模式

编辑

操作模式定义在监视执行期间如何处理操作。操作可以关联五种可能的模式

名称	描述
`simulate`	模拟操作执行。每个操作类型定义其自己的模拟操作模式。例如，`email` 操作创建将要发送的电子邮件，但实际上并不发送它。在此模式下，如果监视的当前状态表明应该这样做，则可能会限制操作。
`force_simulate`	类似于 `simulate` 模式，不同之处在于，即使监视的当前状态表明应该这样做，也不会限制操作。
`execute`	执行操作，就像监视被其自己的触发器触发一样执行。如果监视的当前状态表明应该这样做，则可能会限制执行。
`force_execute`	类似于 `execute` 模式，不同之处在于，即使监视的当前状态表明应该这样做，也不会限制操作。
`skip`	跳过该操作，并且不执行或模拟该操作。有效地强制限制操作。

安全集成

编辑

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

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

示例

编辑

以下示例执行 my_watch 监视

resp = client.watcher.execute_watch(
    id="my_watch",
)
print(resp)

const response = await client.watcher.executeWatch({
  id: "my_watch",
});
console.log(response);

POST _watcher/watch/my_watch/_execute

以下示例显示了执行 my-watch 监视的完整示例

resp = client.watcher.execute_watch(
    id="my_watch",
    trigger_data={
        "triggered_time": "now",
        "scheduled_time": "now"
    },
    alternative_input={
        "foo": "bar"
    },
    ignore_condition=True,
    action_modes={
        "my-action": "force_simulate"
    },
    record_execution=True,
)
print(resp)

const response = await client.watcher.executeWatch({
  id: "my_watch",
  trigger_data: {
    triggered_time: "now",
    scheduled_time: "now",
  },
  alternative_input: {
    foo: "bar",
  },
  ignore_condition: true,
  action_modes: {
    "my-action": "force_simulate",
  },
  record_execution: true,
});
console.log(response);

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 相关联，为每个操作设置不同的执行模式

resp = client.watcher.execute_watch(
    id="my_watch",
    action_modes={
        "action1": "force_simulate",
        "action2": "skip"
    },
)
print(resp)

const response = await client.watcher.executeWatch({
  id: "my_watch",
  action_modes: {
    action1: "force_simulate",
    action2: "skip",
  },
});
console.log(response);

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

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

resp = client.watcher.execute_watch(
    id="my_watch",
    action_modes={
        "_all": "force_execute"
    },
)
print(resp)

const response = await client.watcher.executeWatch({
  id: "my_watch",
  action_modes: {
    _all: "force_execute",
  },
});
console.log(response);

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

以下示例演示如何内联执行监视

resp = client.watcher.execute_watch(
    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"
                }
            }
        }
    },
)
print(resp)

const response = await client.watcher.executeWatch({
  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",
        },
      },
    },
  },
});
console.log(response);

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 条件，但在执行期间将忽略此条件

resp = client.watcher.execute_watch(
    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"
                }
            }
        }
    },
)
print(resp)

const response = await client.watcher.executeWatch({
  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",
        },
      },
    },
  },
});
console.log(response);

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 获取监视 API »