Elasticsearch：开始使用 Watcher

于 2021-07-05 18:08:01 发布
阅读量4k 收藏 8
点赞数
分类专栏： Elastic Elasticsearch 文章标签： elasticsearch 大数据 运维
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/UbuntuTouch/article/details/118492652
版权
Elastic 同时被 2 个专栏收录
1496 篇文章 904 订阅
订阅专栏
Elasticsearch
1023 篇文章 596 订阅
订阅专栏

我在之前的文章中已经创建了一些关于如何创建一个 Watcher。请参阅文章 “Elastic：菜鸟上手指南” 里的 “通知及警报” 部分。在其中的一篇文章 “Elastic：创建你的第一个Elastic watcher” 中，可能会涉及到两个机器的配置，不编译实验。在今天的文章中，我将使用一台机器来进行展示。

在这里我必须指出的是：Watchers 和 Alerts 都可以发出警报，但是 Watchers 是在 Elasticsearch 中运行的，而 Alerts 是在 Kibana 里运行的。 

在进行下面的练习之前，你必须打开试用许可：

关于如何订阅许可，请参阅 Elastic 的官方网站 https://www.elastic.co/cn/subscriptions 以及 License management.

Watcher API

在今天的练习中，我们将使用 Watcher API 来进行监控。请大家参考 Elastic 的官方文档https://www.elastic.co/guide/en/elasticsearch/reference/current/watcher-api.html。简单地说，为了配置一个 Watcher，我们必须配置如下的几个：

PUT _watcher/watch/log_error_watch
{
  "trigger": {},
  "input": {},
  "condition": {},
  "transform" {},
  "actions": {}
}

从上面的结构中可以看出来：一个 watcher 由5个部分组成，尽管 transform 在有些时候是可以不需要的。

在下面的描述中，我们将分别进行阐述:

trigger

这个定义多长时间 watcher 运行一次。比如我们可以定义如下：

  "trigger": {
    "schedule" : {
      "interval": "1m"
    }
  },

在上面，我们定以每隔 1 分钟运行一次。

input

watch input 获取你要评估的数据。要定期搜索日志数据并将结果加载到 watch 中，你可以使用 interval schedule 和 search input。 例如，以下 Watch 每 5 分钟在日志索引中搜索错误：

PUT _watcher/watch/log_error_watch
{
  "trigger": {
    "schedule": {
      "interval": "1m"
    }
  },
  "input": {
    "search": {
      "request": {
        "indices": [
          "logs"
        ],
        "body": {
          "query": {
            "bool": {
              "must": [
                {
                  "match": {
                    "message": "error"
                  }
                }
              ],
              "filter": [
                {
                  "range": {
                    "@timestamp": {
                      "from": "{{ctx.trigger.scheduled_time}}||-5m",
                      "to": "{{ctx.trigger.triggered_time}}"
                    }
                  }
                }
              ]
            }
          }
        }
      }
    }
  }
}

在上面，我们针对 logs 索引，在过去 5 分钟之内查询 messsage 字段里含有 error 的匹配。

对于上面的查询，它类似于我们的 DSL 查询：

GET logs/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "message": "error"
          }
        }
      ],
      "filter": [
        {
          "range": {
            "@timestamp": {
              "from": "now-1m",
              "to": "now"
            }
          }
        }
      ]
    }
  }
}

如果你查看观看历史记录，你会看到 watch 每 1 分钟触发一次。 但是，搜索不会返回任何结果，因此不会将任何内容加载到监视负载中。

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

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

上面会显示如下的的结果：

{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [
      {
        "_index" : ".watcher-history-13-2021.07.05",
        "_type" : "_doc",
        "_id" : "log_error_watch_bf5abb48-a012-43b9-9eae-b88796dbd334-2021-07-05T09:04:44.837331Z",
        "_score" : null,
        "_source" : {
          "watch_id" : "log_error_watch",
          "node" : "m9DhvMAuQy2F3c0XaoO2_A",
          "state" : "failed",
          "status" : {
            "state" : {
              "active" : true,
              "timestamp" : "2021-07-05T09:03:06.180Z"
            },
            "actions" : { },
            "execution_state" : "failed",
            "version" : -1
          },
          "trigger_event" : {
            "type" : "schedule",
            "triggered_time" : "2021-07-05T09:04:44.832Z",
            "schedule" : {
              "scheduled_time" : "2021-07-05T09:04:44.813Z"
            }
          },
          "input" : {
            "search" : {
              "request" : {
                "search_type" : "query_then_fetch",
                "indices" : [
                  "logs"
                ],
                "rest_total_hits_as_int" : true,
                "body" : {
                  "bool" : {
                    "must" : {
                      "match" : {
                        "message" : "error"
                      }
                    },
                    "filter" : {
                      "range" : {
                        "@timestamp" : {
                          "from" : "{{ctx.trigger.scheduled_time}}||-5m",
                          "to" : "{{ctx.trigger.triggered_time}}"
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "condition" : {
            "always" : { }
          },
          "result" : {
            "execution_time" : "2021-07-05T09:04:44.837Z",
            "execution_duration" : 30,
            "input" : {
              "type" : "search",
              "status" : "failure",
              "error" : {
                "root_cause" : [
                  {
                    "type" : "parsing_exception",
                    "reason" : "Unknown key for a START_OBJECT in [bool].",
                    "line" : 1,
                    "col" : 9
                  }
                ],
                "type" : "parsing_exception",
                "reason" : "Unknown key for a START_OBJECT in [bool].",
                "line" : 1,
                "col" : 9
              },
              "search" : {
                "request" : {
                  "search_type" : "query_then_fetch",
                  "indices" : [
                    "logs"
                  ],
                  "rest_total_hits_as_int" : true,
                  "body" : {
                    "bool" : {
                      "must" : {
                        "match" : {
                          "message" : "error"
                        }
                      },
                      "filter" : {
                        "range" : {
                          "@timestamp" : {
                            "from" : "2021-07-05T09:04:44.813Z||-5m",
                            "to" : "2021-07-05T09:04:44.832Z"
                          }
                        }
                      }
                    }
                  }
                }
              }
            },
            "actions" : [ ]
          },
          "messages" : [
            "failed to execute watch input"
          ]
        },
        "sort" : [
          1625475884837
        ]
      }
    ]
  }
}

condition

condition 评估你加载到 watch 中的数据并确定是否需要任何操作。 现在你已经将日志 error 加载到 watch 中，你可以定义一个条件来检查是否发现了任何 error。

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

  "condition" : {
    "compare" : { "ctx.payload.hits.total" : { "gt" : 3 }} 
  }

在上面，它显示如果在过去的 5 分钟发现有超过 3 个的错误信息，那么将触发警报。我们完整的请求时这样的：

PUT _watcher/watch/log_error_watch
{
  "trigger": {
    "schedule": {
      "interval": "1m"
    }
  },
  "input": {
    "search": {
      "request": {
        "indices": [
          "logs"
        ],
        "body": {
          "query": {
            "bool": {
              "must": [
                {
                  "match": {
                    "message": "error"
                  }
                }
              ],
              "filter": [
                {
                  "range": {
                    "@timestamp": {
                      "from": "{{ctx.trigger.scheduled_time}}||-5m",
                      "to": "{{ctx.trigger.triggered_time}}"
                    }
                  }
                }
              ]
            }
          }
        }
      }
    }
  },
  "condition": {
    "compare": {
      "ctx.payload.hits.total": {
        "gt": 3
      }
    }
  }
}

你需要向包含错误的日志索引 logs 添加至少 3 个事件。 例如，以下请求向日志索引 logs 添加 404 错误。我们首先运行下面的一个 pipeline：

PUT _ingest/pipeline/add-timestamp
{
  "processors": [
    {
      "set": {
        "field": "@timestamp",
        "value": "{{_ingest.timestamp}}"
      }
    }
  ]
}

然后，运行下面的命令 4 次：

POST logs/event?pipeline=add-timestamp
{
  "request": "GET index.html",
  "status_code": 404,
  "message": "Error: File not found"
}

添加此事件后，watch 下次执行其条件时将评估为 true。 每次 watch 执行时，条件结果都会记录在 watch_record 中，所以可以通过查询 watch history 来验证是否满足条件：

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

经过 1 分钟后，我们使用上面的命令检查结果：

{
  "took" : 3,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1,
      "relation" : "eq"
    },
    "max_score" : 1.287682,
    "hits" : [
      {
        "_index" : ".watcher-history-13-2021.07.05",
        "_type" : "_doc",
        "_id" : "log_error_watch_66abece2-8311-419b-a702-3d1b90d00d8e-2021-07-05T09:40:43.485371Z",
        "_score" : 1.287682,
        "_source" : {
          "watch_id" : "log_error_watch",
          "node" : "m9DhvMAuQy2F3c0XaoO2_A",
          "state" : "executed",
          "status" : {
            "state" : {
              "active" : true,
              "timestamp" : "2021-07-05T09:39:43.235Z"
            },
            "last_checked" : "2021-07-05T09:40:43.485Z",
            "last_met_condition" : "2021-07-05T09:40:43.485Z",
            "actions" : { },
            "execution_state" : "executed",
            "version" : -1
          },
          "trigger_event" : {
            "type" : "schedule",
            "triggered_time" : "2021-07-05T09:40:43.485Z",
            "schedule" : {
              "scheduled_time" : "2021-07-05T09:40:43.237Z"
            }
          },
          "input" : {
            "search" : {
              "request" : {
                "search_type" : "query_then_fetch",
                "indices" : [
                  "logs"
                ],
                "rest_total_hits_as_int" : true,
                "body" : {
                  "query" : {
                    "bool" : {
                      "must" : [
                        {
                          "match" : {
                            "message" : "error"
                          }
                        }
                      ],
                      "filter" : [
                        {
                          "range" : {
                            "@timestamp" : {
                              "from" : "{{ctx.trigger.scheduled_time}}||-5m",
                              "to" : "{{ctx.trigger.triggered_time}}"
                            }
                          }
                        }
                      ]
                    }
                  }
                }
              }
            }
          },
          "condition" : {
            "always" : { }
          },
          "result" : {
            "execution_time" : "2021-07-05T09:40:43.485Z",
            "execution_duration" : 419,
            "input" : {
              "type" : "search",
              "status" : "success",
              "payload" : {
                "_shards" : {
                  "total" : 1,
                  "failed" : 0,
                  "successful" : 1,
                  "skipped" : 0
                },
                "hits" : {
                  "hits" : [
                    {
                      "_index" : "logs",
                      "_type" : "event",
                      "_source" : {
                        "request" : "GET index.html",
                        "status_code" : 404,
                        "@timestamp" : "2021-07-05T09:38:40.860745Z",
                        "message" : "Error: File not found"
                      },
                      "_id" : "xVAIdnoBY7N_y24HuOdc",
                      "_score" : 0.018018503
                    },
                    {
                      "_index" : "logs",
                      "_type" : "event",
                      "_source" : {
                        "request" : "GET index.html",
                        "status_code" : 404,
                        "@timestamp" : "2021-07-05T09:38:41.052902Z",
                        "message" : "Error: File not found"
                      },
                      "_id" : "xlAIdnoBY7N_y24Huecd",
                      "_score" : 0.018018503
                    },
                    {
                      "_index" : "logs",
                      "_type" : "event",
                      "_source" : {
                        "request" : "GET index.html",
                        "status_code" : 404,
                        "@timestamp" : "2021-07-05T09:38:41.302771Z",
                        "message" : "Error: File not found"
                      },
                      "_id" : "x1AIdnoBY7N_y24HuucW",
                      "_score" : 0.018018503
                    },
                    {
                      "_index" : "logs",
                      "_type" : "event",
                      "_source" : {
                        "request" : "GET index.html",
                        "status_code" : 404,
                        "@timestamp" : "2021-07-05T09:38:41.636798Z",
                        "message" : "Error: File not found"
                      },
                      "_id" : "yFAIdnoBY7N_y24Hu-dk",
                      "_score" : 0.018018503
                    },
                    {
                      "_index" : "logs",
                      "_type" : "event",
                      "_source" : {
                        "request" : "GET index.html",
                        "status_code" : 404,
                        "@timestamp" : "2021-07-05T09:39:50.793076Z",
                        "message" : "Error: File not found"
                      },
                      "_id" : "yVAJdnoBY7N_y24HyeeJ",
                      "_score" : 0.018018503
                    },
                    {
                      "_index" : "logs",
                      "_type" : "event",
                      "_source" : {
                        "request" : "GET index.html",
                        "status_code" : 404,
                        "@timestamp" : "2021-07-05T09:39:51.718527Z",
                        "message" : "Error: File not found"
                      },
                      "_id" : "ylAJdnoBY7N_y24Hzecm",
                      "_score" : 0.018018503
                    },
                    {
                      "_index" : "logs",
                      "_type" : "event",
                      "_source" : {
                        "request" : "GET index.html",
                        "status_code" : 404,
                        "@timestamp" : "2021-07-05T09:39:52.277911Z",
                        "message" : "Error: File not found"
                      },
                      "_id" : "y1AJdnoBY7N_y24Hz-dW",
                      "_score" : 0.018018503
                    },
                    {
                      "_index" : "logs",
                      "_type" : "event",
                      "_source" : {
                        "request" : "GET index.html",
                        "status_code" : 404,
                        "@timestamp" : "2021-07-05T09:39:52.863406Z",
                        "message" : "Error: File not found"
                      },
                      "_id" : "zFAJdnoBY7N_y24H0eef",
                      "_score" : 0.018018503
                    }
                  ],
                  "total" : 8,
                  "max_score" : 0.018018503
                },
                "took" : 416,
                "timed_out" : false
              },
              "search" : {
                "request" : {
                  "search_type" : "query_then_fetch",
                  "indices" : [
                    "logs"
                  ],
                  "rest_total_hits_as_int" : true,
                  "body" : {
                    "query" : {
                      "bool" : {
                        "must" : [
                          {
                            "match" : {
                              "message" : "error"
                            }
                          }
                        ],
                        "filter" : [
                          {
                            "range" : {
                              "@timestamp" : {
                                "from" : "2021-07-05T09:40:43.237Z||-5m",
                                "to" : "2021-07-05T09:40:43.485Z"
                              }
                            }
                          }
                        ]
                      }
                    }
                  }
                }
              }
            },
            "condition" : {
              "type" : "always",
              "status" : "success",
              "met" : true
            },
            "actions" : [ ]
          },
          "messages" : [ ]
        }
      }
    ]
  }
}

action

在 watch history 中记录 watch 的记录固然不错，但是 Watcher 真正的强大在于能够在满足 watch 条件的时候做一些事情。 watch 的操作定义了当 watch 条件评估为真时要做什么。 你可以发送电子邮件、调用第三方 webhook、将文档写入 Elasticsearch 索引或将消息记录到标准 Elasticsearch 日志文件中。

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

PUT _watcher/watch/log_error_watch
{
  "trigger": {
    "schedule": {
      "interval": "1m"
    }
  },
  "input": {
    "search": {
      "request": {
        "indices": [
          "logs"
        ],
        "body": {
          "query": {
            "bool": {
              "must": [
                {
                  "match": {
                    "message": "error"
                  }
                }
              ],
              "filter": [
                {
                  "range": {
                    "@timestamp": {
                      "from": "{{ctx.trigger.scheduled_time}}||-5m",
                      "to": "{{ctx.trigger.triggered_time}}"
                    }
                  }
                }
              ]
            }
          }
        }
      }
    }
  },
  "condition": {
    "compare": {
      "ctx.payload.hits.total": {
        "gt": 3
      }
    }
  },
  "actions": {
    "log_error": {
      "logging": {
        "text": "Found {{ctx.payload.hits.total}} errors in the logs"
      }
    }
  }
}

在上面定义的 action 中，它将在 Elasticsearch 的 Server 日志中打出上面 text 所输出的信息。

测试 Watcher

在上面，我们每隔 1 分钟检查一次，但是在实际的实践中，我们的这个 interval 可能会是1个小时，或者是1天的实践。我们不可能去等这么长的时间来测试这个 watcher。Elastic 为了方便我们的测试，提供了 _execute 接口：

PUT _watcher/watch/log_error_watch/_execute

通过上面的接口，我们不需要等在 schedule 中设置的那么久的时间才运行一下我们的 watcher。上面的命令可以直接帮我们运行 watcher。

我们连续运行如下的命令4次：

POST logs/event?pipeline=add-timestamp
{
  "request": "GET index.html",
  "status_code": 404,
  "message": "Error: File not found"
}

然后接着运行：

PUT _watcher/watch/log_error_watch/_execute

这样，我们就不用等每隔1分钟才可以看到输出的结果。我们立马在 Elasticsearch Server 的日志中看到输出：

至此，我们已经完整地创建并测试了我们的 Watcher。

在 Kibana 中进行查看

我们刚才通过命令创建的 watcher 也可以在 Kibana 的界面中进行查看。当然，我们甚至可以使用 Kibana 的界面来生成想要的 watcher：

在上面，我们可以看到完整的 watcher 定义。当然我们甚至可以在这个界面对它进行修改。

删除 Watcher

由于 log_error_watch 配置为每 1 分钟运行一次，因此请确保在完成实验后将其删除。 否则，此示例 Watcher 发出的噪音将使你很难看到您的观看历史记录和日志文件中发生了什么。

DELETE _watcher/watch/log_error_watch

当然，你也可以在 Kibana 的界面中对它进行删除。

Elastic 中国社区官方博客
关注
专栏目录
博客
Elasticsearch 开放推理 API 新增阿里云 AI 搜索支持
09-19 1448
我们很高兴地宣布，Elasticsearch 开放推理 API 新增了阿里云 AI 搜索的集成功能。此项工作使 Elastic 用户能够直接连接到阿里云 AI 平台。使用 Elasticsearch 向量数据库构建 RAG 应用程序的开发人员可以使用 semantic_text 存储和使用托管在阿里云 AI 搜索平台上的模型生成的密集和稀疏嵌入。此外，Elastic 用户现在可以集成访问重新排名模型，以增强语义重新排名和LLM 系列。
博客
Elastic 线下 Meetup 将于 2024 年 9 月 21 号在成都举办
08-29 1643
2024 Elastic Meetup 成都站活动，由 Elastic、腾讯、新智锦绣联合举办，现诚邀广大技术爱好者及开发者参加。
博客
Elastic：如何成为一名 Elastic 认证工程师，Elastic 认证分析师及 Elastic 认证可观测性工程师
10-28 2万+
Elasticsearch 无疑是是目前世界上最为流行的大数据搜索引擎。根据 DB - Engines 的统计，Elasticsearch 雄踞排行榜第一名，并且市场还在不断地扩大：能够成为一名 Elastic 认证工程师也是很多开发者的梦想。这个代表了 Elastic 的最高认证，在业界也得到了很高的认知度。得到认证的工程师，必须除了具有丰富的 Elastic Stack 知识，而且必须有丰富的操作及有效的解决问题的能力。拥有这个认证证书，也代表了个人及公司的荣誉。针对个人的好处是，你可以..
博客
Elastic：开发者上手指南
02-25 15万+
你们好，我是Elastic的刘晓国。如果大家想开始学习Elastic的话，那么这里将是你理想的学习园地。在我的博客几乎涵盖了你想学习的许多方面。在这里，我来讲述一下作为一个菜鸟该如何阅读我的这些博客文章。我们可以按照如下的步骤来学习：1)Elasticsearch简介：对Elasticsearch做了一个简单的介绍2)Elasticsearch中的一些重要概念:cluster, n..........................................................
博客
Elastic：培训视频 - ​在生产环境中配置 Fleet Server 和 Elastic Agent 之间的安全
01-06 1万+
在这篇文章中，我将会把我写的有些内容录制成视频，供大家参考。希望对大家有所帮助。优酷的视频频道地址在这里。Elastic 简介及Elastic Stack 安装：优酷，腾讯 Elastic Stack docker 部署：优酷，腾讯 Elasticsearch中的一些重要概念（Cluster/Shards/Replica/Document/Type/Index）：优酷，腾讯 开始使用El...............
博客
Elasticsearch 简介
08-08 17万+
Elasticsearch是一个非常强大的搜索引擎。它目前被广泛地使用于各个IT公司。Elasticsearch是由Elastic公司创建并开源维护的。它的开源代码位于https://github.com/elastic/elasticsearch。同时，Elastic公司也拥有Logstash及Kibana开源项目。这个三个开源项目组合在一起，就形成了 ELK软件栈。他们三个共同形成了一个强大的...
博客
Observability：构建下一代托管接入服务
09-21 1040
随着无服务器（serverless）的引入，向 Elastic Cloud 发送可观察性数据变得越来越容易。你可以在中创建一个可观察性无服务器项目，并将可观察性信号直接发送到 Elasticsearch 或通过我们一直称之为托管接收服务（类似于 Elastic APM 服务器的完全托管解决方案）发送。你不再需要担心 APM 服务器的大小和配置。相反，你可以将数据直接发送到托管接收服务，让我们的平台为你完成艰难的扩展工作。
博客
LangChain 和 Elasticsearch 加速构建 AI 检索代理
09-20 1213
​Elastic 和 LangChain 很高兴地宣布发布新的 LangGraph 检索代理模板，旨在简化需要代理使用 Elasticsearch 进行代理检索的生成式人工智能 (GenAI) 代理应用程序的开发。此模板预先配置为使用 Elasticsearch，允许开发人员使用 LangChain 和 Elasticsearch 快速构建代理。要立即开始，请访问 github 上的项目：https://github.com/langchain-ai/retrieval-agent-template
博客
Elasticsearch：检索增强生成背后的重要思想
09-20 2020
星期天晚上 10 点，我九年级的女儿哭着冲进我的房间。她说她对代数一无所知，注定要失败。我进入超级妈妈模式，却发现我一点高中数学知识都不记得了。于是，我做了任何一位超级妈妈在 2024 年都会做的事情，前往 ChatGPT 寻求帮助。这些生成式 AI 聊天机器人太棒了。我很快就得到了关于如何解决她所有问题的详细解释。“但是妈妈，”她抱怨道，“我们不是这样做的！”如果我能让 ChatGPT 的答案与班级的特定做事方式保持一致就好了……
博客
Elasticsearch：一次生产集群 ES Watcher 失效的深度排查与分析 - 全过程剖析与解决方案
09-19 1379
Watcher是 Elasticsearch 提供的一项监控和告警服务，允许用户定义、管理警报规则，并持续跟踪网络和数据的变化。基于 Elasticsearch 的分布式架构，Watcher 可以对基础设施、索引数据、集群健康等多种指标进行实时监控和自动化告警。当预设条件被触发时，Watcher 会及时发送通知。这项功能特别适用于日志数据的监控、应用性能追踪，以及其他需要自动化响应的场景，帮助运维人员快速响应潜在问题，提升系统稳定性和可靠性。1）定时监控数据。
博客
Elastic 的 OpenTelemetry PHP 发行版简介
09-18 1419
宣布 OpenTelemetry PHP 的 Elastic 发行版的第一个 alpha 版本。在本篇博文中了解使用 OpenTelemetry 来检测 PHP 应用程序是多么简单。我们很高兴推出 OpenTelemetry PHP 的 Elastic Distribution 的第一个 alpha 版本。在这篇文章中，你将了解如何轻松安装和设置 PHP 应用程序的监控。
博客
Elasticsearch：Open Crawler 现已进入测试阶段
09-18 2113
今天，我们发布了 Open Crawler 0.2 版，该版本也已升级为测试版！Open Crawler 最初于作为技术预览版发布（0.1 版）。从那时起，我们一直在迭代产品并添加了几个新功能。要访问这些更改，你可以使用最新的 Docker 工件，或直接从 GitHub 存储库下载源代码。按照我们文档中的设置说明开始使用。
博客
Observability：日志管理的最佳实践 - 利用日志更快地解决问题
09-17 1132
在当今快速发展的软件开发环境中，高效的日志管理对于维护系统可靠性和性能至关重要。随着基础架构和应用程序组件的不断扩展和复杂化，运营和开发团队的职责也不断增加且越来越复杂。这篇博文概述了有效日志管理的最佳实践，以应对数据量不断增长、基础架构复杂以及快速解决问题的需求等挑战。
博客
Kibana：如何使用魔法公式创建具有影响力的可视化效果？（第 1 部分）
09-16 892
在上一篇博文《作为非设计师设计直观的 Kibana 仪表板》中，我们强调了创建直观仪表板的重要性。它展示了简单的更改（分组主题、更改类型图表等）如何对理解数据产生影响。在提供Kibana 数据分析或课程等课程时，我们强调了这篇博文以及这些更改如何帮助将重要信息带到表面。我喜欢一种互补的方法来实现这一目标：使用两种颜色将最高数据值与常见数据值区分开来。为了说明这个想法，我们将使用示例航班数据数据集。现在，让我们比较两个可视化，按航班总数排名前 10 个目的地国家。哪个可视化的影响更大？
博客
Observability：OpenTelemetry Java Agent Elastic 分布正式发布
09-15 1367
Elastic 宣布 OpenTelemetry (OTel) Java Agent 的 Elastic 发行版正式发布，这是一个与 OTel 完全兼容的代理，具有一组丰富实用的附加功能。随着 Elastic 继续致力于 OpenTelemetry (OTel)，我们很高兴地宣布) 正式上市。
博客
了解 BSI IT Grundschutz：使用 GenAI 搜索你的（私人）PDF 宝藏的秘诀
09-14 1135
有没有想过如何让多年来收集的文档可以通过语义而不是关键字进行搜索？处理充满有价值信息的 PDF 可能具有挑战性，尤其是在分块和创建跨多种语言的可搜索数据时。这篇博文将指导你将文档集合转换为 AI 驱动的语义搜索系统。我们将探索 Elastic 如何为 RAG 提供端到端解决方案：提取 PDF、将其处理成块、向量化内容，并提供一个交互式游乐场来查询和与数据交互。探索如何让你的信息不仅更易于访问，而且真正具有对话性。你将能够测试如何轻松创建相关信息摘要，了解每个给出的答案的相关性分数，并最大限度地了解创建答
博客
用于安全研究的 Elastic Container Project
09-13 1334
​Elastic Stack 是一个模块化数据分析生态系统。虽然这允许工程灵活性，但建立开发实例进行测试可能很麻烦。建立 Elastic Stack 的最简单方法是使用 Elastic Cloud - 这是完全一站式的。但是，在某些情况下，Elastic Cloud 可能不适用于你的测试环境。为了帮助解决这个问题，本博客将为你提供必要的信息，以便快速轻松地建立本地、完全容器化、TLS 安全的 Elastic Stack，并启用 Fleet 和检测引擎。你将能够创建 Fleet 策略，在本地主机或 VM 上
博客
使用 Elastic 和 LM Studio 的 Herding Llama 3.1
09-13 2066
最新的 LM Studio 0.3 更新使 Elastic 的安全 AI Assistant 能够更轻松、更快速地与 LM Studio 托管模型一起运行。在这篇博客中，Elastic 和 LM Studio 团队将向你展示如何在几分钟内开始使用。如果你在同一网络上或在你的机器上本地工作，则不再需要设置代理。
博客
Elastic 线上 Meetup “Elastic 认证及 Watcher 使用分享” 将于 9 月 18 号举办
09-13 706
Elastic 线上 Meetup “Elastic 认证及 Watcher 使用分享” 将于 9 月 18 号举办
博客
Elasticsearch 开放 inference API 为 Hugging Face 添加了原生分块支持
09-13 1379
​借助 Elasticsearch 开放推理 API，你可以使用 Hugging Face 的推理端点（Inference Endpoints）在 Elasticsearch 之外执行推理。这样你就可以使用 Hugging Face 的可扩展基础架构，包括在 GPU 和 AI 加速器上执行推理的能力。使用 Hugging Face 生成的嵌入的能力是作为 Elasticsearch 8.11 中的第一个开放推理 API 集成引入的，从那时起，我们一直在努力工作，并使用更强大的功能对其进行了更新，让您可以事
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值