› › ›

API Execute watch

Принудительно выполняет сохраненное наблюдение.

Запрос

POST _watcher/watch/<watch_id>/_execute

POST _watcher/watch/_execute

Предварительные условия

У вас должны быть manage_watcher привилегии кластера для использования этого API. Дополнительную информацию см. в Разделах о правах доступа.

Описание

Этот API можно использовать для принудительного выполнения наблюдения вне его логики срабатывания или для моделирования выполнения наблюдения в целях отладки.

Для тестирования и отладки вы также можете точно контролировать, как выполняется наблюдение. Вы можете выполнить наблюдение без выполнения всех его действий или, альтернативно, смоделировать их. Вы также можете принудительно выполнить его, игнорируя условие наблюдения, и контролировать, будет ли запись о наблюдении сохранена в истории наблюдения после выполнения.

Выполнение наблюдения в строке

Вы можете использовать API Execute, чтобы выполнить наблюдения, которые еще не зарегистрированы, указав определение наблюдения в строке. Это служит отличным инструментом для тестирования и отладки ваших наблюдений перед добавлением их в Watcher.

Параметры пути

<watch_id>: (Необязательно, строка) Идентификатор наблюдения.

Параметры запроса

debug: (Необязательно, логическое значение) Определяет, выполняется ли наблюдение в отладочном режиме. Значение по умолчанию — false.

Тело запроса

Этот API поддерживает следующие поля:

Имя	Требуется	Значение по умолчанию	Описание
`trigger_data`	нет		Эта структура интерпретируется как данные события триггера, которые будут использоваться во время выполнения наблюдения
`ignore_condition`	нет	false	При установке в значение `true` выполнение наблюдения использует условие always. Это также можно указать в качестве параметра HTTP.
`alternative_input`	нет	null	Если присутствует, наблюдение использует этот объект в качестве полезной нагрузки вместо выполнения собственного ввода.
`action_modes`	нет	null	Определяет, как обрабатывать действия наблюдения в рамках выполнения наблюдения. Подробнее см. в режимах выполнения действий.
`record_execution`	нет	false	При установке в значение `true`, запись наблюдения, представляющая результат выполнения наблюдения, сохраняется в индексе `.watcher-history` для текущего времени. Кроме того, обновляется состояние наблюдения, что может ограничивать последующие выполнения. Это также можно указать в качестве параметра HTTP.
`watch`	нет	null	Если присутствует, используется это наблюдение вместо указанного в запросе. Это наблюдение не сохраняется в индексе, и record_execution не может быть задан.

Режимы выполнения действий

Режимы действий определяют, как обрабатываются действия во время выполнения наблюдения. Существует пять возможных режимов, которые могут быть связаны с действием:

Имя	Описание
`simulate`	Выполнение действия моделируется. Каждый тип действия определяет свой собственный режим моделирования. Например, действие `email` создает электронное письмо, которое должно было быть отправлено, но фактически не отправляет его. В этом режиме действие может быть ограничено, если текущее состояние наблюдения указывает на это.
`force_simulate`	Аналогично режиму `simulate`, за исключением того, что действие не ограничивается, даже если текущее состояние наблюдения указывает на это.
`execute`	Выполняет действие так, как оно должно было быть выполнено, если наблюдение было вызвано собственным триггером. Выполнение может быть ограничено, если текущее состояние наблюдения указывает на это.
`force_execute`	Аналогично режиму `execute`, за исключением того, что действие не ограничивается, даже если текущее состояние наблюдения указывает на это.
`skip`	Действие пропускается и не выполняется или не моделируется. Эффективно заставляет действие быть ограниченным.

Интеграция безопасности

Когда в вашем кластере включены функции безопасности Elasticsearch, наблюдения выполняются с привилегиями пользователя, который сохранил наблюдения. Если вашему пользователю разрешено читать индекс a, но не индекс b, то те же правила будут применяться во время выполнения наблюдения.

При использовании API Execute watch будут использованы данные об авторизации пользователя, который вызвался 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" 
  }
}

	Идентификатор записи наблюдения, как он будет храниться в индексе `.watcher-history`.
	Документ записи наблюдения, как он будет храниться в индексе `.watcher-history`.
	Результаты выполнения наблюдения.
	Пользователь, который выполнил наблюдение.

Вы можете установить другой режим выполнения для каждого действия, связав имя режима с идентификатором действия:

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 в качестве идентификатора действия:

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

© 2023-2025 Elasticsearch
As of September 2024, Elasticsearch is available under a choice of three licenses: the Server Side Public License (SSPL), the Elastic License, or the AGPLv3 (OSI approved).
Elasticsearch and the Elasticsearch logo are trademarks of Elasticsearch B.V., registered in the U.S. and in other countries.
https://www.elastic.co/guide/en/elasticsearch/reference/8.17/watcher-api-execute-watch.html