› ›

Watcher 入门

编辑

Watcher 入门

编辑

设置一个 Watch 以开始发送警报

安排 Watch 并定义输入.
添加一个条件，检查是否需要发送警报。
配置一个操作，在条件满足时发送警报。

安排 Watch 并定义输入

编辑

Watch 的计划控制 Watch 触发的频率。Watch 的输入获取要评估的数据。

要定期搜索日志数据并将结果加载到 Watch 中，可以使用间隔计划和搜索输入。例如，以下 Watch 每 10 秒搜索一次 logs 索引中的错误

resp = client.watcher.put_watch(
    id="log_error_watch",
    trigger={
        "schedule": {
            "interval": "10s"
        }
    },
    input={
        "search": {
            "request": {
                "indices": [
                    "logs"
                ],
                "body": {
                    "query": {
                        "match": {
                            "message": "error"
                        }
                    }
                }
            }
        }
    },
)
print(resp)

const response = await client.watcher.putWatch({
  id: "log_error_watch",
  trigger: {
    schedule: {
      interval: "10s",
    },
  },
  input: {
    search: {
      request: {
        indices: ["logs"],
        body: {
          query: {
            match: {
              message: "error",
            },
          },
        },
      },
    },
  },
});
console.log(response);

PUT _watcher/watch/log_error_watch
{
  "trigger" : {
    "schedule" : { "interval" : "10s" } 
  },
  "input" : {
    "search" : {
      "request" : {
        "indices" : [ "logs" ],
        "body" : {
          "query" : {
            "match" : { "message": "error" }
          }
        }
      }
    }
  }
}

计划通常配置为较低频率运行。此示例将间隔设置为 10 秒，以便您可以轻松查看 Watch 的触发情况。由于此 Watch 运行频率很高，因此在完成实验后，请务必删除 Watch。

如果您检查 Watch 历史记录，您会看到 Watch 每 10 秒被触发一次。但是，搜索没有返回任何结果，因此没有任何内容加载到 Watch 的有效负载中。

例如，以下请求从 Watch 历史记录中检索最近十次 Watch 执行（Watch 记录）

resp = client.search(
    index=".watcher-history*",
    pretty=True,
    sort=[
        {
            "result.execution_time": "desc"
        }
    ],
)
print(resp)

response = client.search(
  index: '.watcher-history*',
  pretty: true,
  body: {
    sort: [
      {
        'result.execution_time' => 'desc'
      }
    ]
  }
)
puts response

const response = await client.search({
  index: ".watcher-history*",
  pretty: "true",
  sort: [
    {
      "result.execution_time": "desc",
    },
  ],
});
console.log(response);

GET .watcher-history*/_search?pretty
{
  "sort" : [
    { "result.execution_time" : "desc" }
  ]
}

添加条件

编辑

一个条件评估您加载到 Watch 中的数据，并确定是否需要执行任何操作。现在您已将日志错误加载到 Watch 中，您可以定义一个条件来检查是否发现了任何错误。

例如，以下比较条件只是检查搜索输入是否返回了任何命中。

resp = client.watcher.put_watch(
    id="log_error_watch",
    trigger={
        "schedule": {
            "interval": "10s"
        }
    },
    input={
        "search": {
            "request": {
                "indices": [
                    "logs"
                ],
                "body": {
                    "query": {
                        "match": {
                            "message": "error"
                        }
                    }
                }
            }
        }
    },
    condition={
        "compare": {
            "ctx.payload.hits.total": {
                "gt": 0
            }
        }
    },
)
print(resp)

const response = await client.watcher.putWatch({
  id: "log_error_watch",
  trigger: {
    schedule: {
      interval: "10s",
    },
  },
  input: {
    search: {
      request: {
        indices: ["logs"],
        body: {
          query: {
            match: {
              message: "error",
            },
          },
        },
      },
    },
  },
  condition: {
    compare: {
      "ctx.payload.hits.total": {
        gt: 0,
      },
    },
  },
});
console.log(response);

PUT _watcher/watch/log_error_watch
{
  "trigger" : { "schedule" : { "interval" : "10s" }},
  "input" : {
    "search" : {
      "request" : {
        "indices" : [ "logs" ],
        "body" : {
          "query" : {
            "match" : { "message": "error" }
          }
        }
      }
    }
  },
  "condition" : {
    "compare" : { "ctx.payload.hits.total" : { "gt" : 0 }} 
  }
}

比较条件允许您轻松地与执行上下文中的值进行比较。

要使此比较条件评估为 true，您需要向 logs 索引添加包含错误的事件。例如，以下请求将 404 错误添加到 logs 索引

resp = client.index(
    index="logs",
    document={
        "timestamp": "2015-05-17T18:12:07.613Z",
        "request": "GET index.html",
        "status_code": 404,
        "message": "Error: File not found"
    },
)
print(resp)

response = client.index(
  index: 'logs',
  body: {
    timestamp: '2015-05-17T18:12:07.613Z',
    request: 'GET index.html',
    status_code: 404,
    message: 'Error: File not found'
  }
)
puts response

const response = await client.index({
  index: "logs",
  document: {
    timestamp: "2015-05-17T18:12:07.613Z",
    request: "GET index.html",
    status_code: 404,
    message: "Error: File not found",
  },
});
console.log(response);

POST logs/_doc
{
  "timestamp": "2015-05-17T18:12:07.613Z",
  "request": "GET index.html",
  "status_code": 404,
  "message": "Error: File not found"
}

添加此事件后，下次 Watch 执行时，其条件将评估为 true。条件结果在每次 Watch 执行时都会记录为 watch_record 的一部分，因此您可以通过搜索 Watch 历史记录来验证条件是否满足

resp = client.search(
    index=".watcher-history*",
    pretty=True,
    query={
        "bool": {
            "must": [
                {
                    "match": {
                        "result.condition.met": True
                    }
                },
                {
                    "range": {
                        "result.execution_time": {
                            "gte": "now-10s"
                        }
                    }
                }
            ]
        }
    },
)
print(resp)

const response = await client.search({
  index: ".watcher-history*",
  pretty: "true",
  query: {
    bool: {
      must: [
        {
          match: {
            "result.condition.met": true,
          },
        },
        {
          range: {
            "result.execution_time": {
              gte: "now-10s",
            },
          },
        },
      ],
    },
  },
});
console.log(response);

GET .watcher-history*/_search?pretty
{
  "query" : {
    "bool" : {
      "must" : [
        { "match" : { "result.condition.met" : true }},
        { "range" : { "result.execution_time" : { "gte" : "now-10s" }}}
      ]
    }
  }
}

配置操作

编辑

在 Watch 历史记录中记录 Watch 记录很好，但 Watcher 的真正强大之处在于能够在 Watch 条件满足时执行某些操作。Watch 的操作定义了当 Watch 条件评估为 true 时要执行的操作。您可以发送电子邮件、调用第三方 Webhook、将文档写入 Elasticsearch 索引或将消息记录到标准 Elasticsearch 日志文件。

例如，以下操作在检测到错误时将消息写入 Elasticsearch 日志。

resp = client.watcher.put_watch(
    id="log_error_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.putWatch({
  id: "log_error_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);

PUT _watcher/watch/log_error_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"
      }
    }
  }
}

删除 Watch

编辑

由于 log_error_watch 配置为每 10 秒运行一次，因此请确保在完成实验后将其删除。否则，此示例 Watch 产生的噪音将使您难以查看 Watch 历史记录和日志文件中其他正在发生的事情。

要删除 Watch，请使用删除 Watch API

resp = client.watcher.delete_watch(
    id="log_error_watch",
)
print(resp)

response = client.watcher.delete_watch(
  id: 'log_error_watch'
)
puts response

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

DELETE _watcher/watch/log_error_watch

必需的安全权限

编辑

要允许用户创建和操作 Watch，请为其分配 watcher_admin 安全角色。Watcher 管理员还可以查看 Watch、Watch 历史记录和已触发的 Watch。

要允许用户查看 Watch 和 Watch 历史记录，请为其分配 watcher_user 安全角色。Watcher 用户无法创建或操作 Watch；他们只能执行只读 Watch 操作。

后续步骤

编辑

请参阅Watcher 的工作原理，以获取有关 Watch 的结构和 Watch 生命周期的更多信息。
请参阅示例 Watch，以获取更多设置 Watch 的示例。
请参阅 Elastic Examples 存储库中的示例 Watch，以获取您可以用作构建自定义 Watch 的起点的其他示例 Watch。

« Watcher Watcher 的工作原理 »