YACE 加入 Prometheus 社区

Yet Another Cloudwatch Exporter (YACE) 已正式加入 Prometheus 社区!此举将使其对用户更易于访问,并为贡献者增强和维护该项目开辟新的机会。还有一篇来自 Cristian Greco 观点的博客文章

早期

当我最初开始 YACE 时,我不知道它会发展到如此规模。当时,我正在 Invision AG(不要与设计应用程序混淆)工作,这是一家专注于劳动力管理软件的公司。他们完全支持我开源该工具,并在我的队友 Kai Forsthövel 的帮助下,YACE 诞生了。

我们的第一次提交是在 2018 年,我们的主要目标之一是使 CloudWatch 指标易于扩展,并自动检测要衡量的指标,同时保持用户体验简单直观。InVision AG 由于机器学习工作负载而扩展其基础设施,我们需要一些可以轻松检测新基础设施的东西。对简单性的关注仍然是核心优先事项。从那时起,YACE 开始找到它的受众。

Yace 获得发展势头

随着 YACE 的扩展,对其的支持也在增加。一个关键时刻是 Grafana Labs 的 Cristian Greco 联系了我。当我几乎跟不上节奏,感到不知所措时,Cristian 介入了,只是问他可以在哪里提供帮助。他很快成为主要的发布者,并领导了 Grafana Labs 对 YACE 的贡献,这是一个对项目产生巨大影响的转折点。与来自世界各地的令人难以置信的贡献者社区一起,他们将 YACE 提升到我个人所能达到的水平之上,将其塑造成一个真正的全球工具。YACE 不再仅仅是我或 Invision 的项目,它属于社区。

感激和未来愿景

我非常感谢每一位为 YACE 的成功做出贡献的开发人员、测试人员和用户。这段旅程向我展示了社区和开源协作的力量。但我们尚未完成。

现在是时候将 Yace 推向更远的地方——进入 Prometheus 生态系统的核心。将 Yace 作为 Prometheus 的官方 Amazon CloudWatch Exporter 将使其对所有人更易于使用和访问。在 Grafana Labs 的持续支持和我致力于改进用户体验的承诺下,我们将确保 YACE 成为任何人都可以轻松使用的直观工具。

亲自试用 YACE

按照我们的分步安装指南,试用 YACE (Yet Another CloudWatch Exporter)

您可以在此处浏览各种配置示例,开始监控特定的 AWS 服务。

我们的目标是实现跨所有 AWS 服务的轻松自动发现,从而简化对任何动态基础设施的监控。

Prometheus 3.0 发布公告

继最近在柏林 PromCon 上发布 Prometheus 3.0 beta 版 之后,Prometheus 团队很高兴地宣布 Prometheus 3.0 版本即时可用!

这个最新版本标志着一个重要的里程碑,因为它是 7 年来的第一个主要版本。Prometheus 在这段时间里取得了长足的进步,从一个早期采用者的项目发展成为云原生监控堆栈的标准组成部分。Prometheus 3.0 旨在通过添加一些令人兴奋的新功能,同时在很大程度上保持与以前版本的稳定性和兼容性,来继续这一旅程。

完整的 3.0 版本在 beta 版的基础上添加了一些新功能,并引入了一些额外的重大更改,我们将在本文中描述这些更改。

新功能

以下是作为 beta 版本发布的一部分的令人兴奋的更改摘要,以及此后添加的内容

新 UI

Prometheus 3.0 的亮点之一是其默认启用的全新 UI

New UI query page

UI 已经完全重写,减少了混乱,外观更现代,具有 PromLens 风格的树形视图等新功能,并且通过使用更现代的技术堆栈,将使未来的维护更容易。

有关新 UI 的更多信息,请参阅 Julius 在 PromLabs 博客上发表的详细文章。用户可以使用 old-ui 功能标志临时启用旧 UI。

由于新 UI 尚未经过实战测试,因此很可能仍然存在错误。如果您发现任何错误,请在 GitHub 上报告

自 beta 版以来,用户界面已更新为支持 UTF-8 指标和标签名称。

New UTF-8 UI

Remote Write 2.0

Remote-Write 2.0 通过为大量新元素(包括元数据、样本、创建时间戳和原生直方图)添加原生支持,迭代了之前的协议版本。它还使用字符串驻留来减少压缩和解压缩时的有效负载大小和 CPU 使用率。对于部分写入,它具有更好的处理能力,以便在发生这种情况时向客户端提供更多详细信息。更多详细信息请参见 此处

UTF-8 支持

Prometheus 现在默认允许在指标和标签名称以及标签值中使用所有有效的 UTF-8 字符,这在 2.x 版本中已经如此。

用户需要确保他们的指标生产者配置为传递 UTF-8 名称,如果任何一方不支持 UTF-8,则指标名称将使用传统的下划线替换方法进行转义。可以使用新的引用语法编写 PromQL 查询来检索 UTF-8 指标,或者用户可以手动指定 __name__ 标签名称。

目前只有 Go 客户端库已更新为支持 UTF-8,但对其他语言的支持将很快添加。

OTLP 支持

为了与我们 对 OpenTelemetry 的承诺保持一致,Prometheus 3.0 具有多项新功能,以提高与 OpenTelemetry 的互操作性。

OTLP 摄取

Prometheus 可以配置为 OTLP 指标协议的本机接收器,在 /api/v1/otlp/v1/metrics 端点上接收 OTLP 指标。

请参阅我们的 指南,了解将 OTLP 指标流量消费到 Prometheus 中的最佳实践。

UTF-8 规范化

借助 Prometheus 3.0,得益于 UTF-8 支持,用户可以存储和查询 OpenTelemetry 指标,而无需对指标和标签名称进行烦人的更改,例如 将点更改为下划线

值得注意的是,这减少了用户和工具在 OpenTelemetry 语义约定或 SDK 中定义的内容与实际可查询内容之间的差异方面的困惑

为了在 OTLP 摄取中实现这一点,Prometheus 3.0 实验性地支持不同的翻译策略。有关详细信息,请参阅 Prometheus 配置中的 otlp 部分

注意:虽然“NoUTF8EscapingWithSuffixes”策略允许特殊字符,但它仍然会添加必需的后缀以获得最佳体验。请参阅 关于在 Prometheus 中启用无后缀的未来工作的提案

原生直方图

原生直方图是一种 Prometheus 指标类型,它提供了比经典直方图更高效率和更低成本的替代方案。原生直方图不必根据数据集选择(并可能需要更新)桶边界,而是具有基于指数增长的预设桶边界。

原生直方图仍处于实验阶段,尚未默认启用,可以通过传递 --enable-feature=native-histograms 来启用。原生直方图的某些方面,如文本格式和访问器函数/运算符仍在积极设计中。

重大更改

Prometheus 社区努力 在主要版本中不破坏现有功能。在新主要版本中,我们借此机会清理了一些但很小的长期存在的问题。换句话说,Prometheus 3.0 包含一些重大更改。这包括对功能标志、配置文件、PromQL 和抓取协议的更改。

请阅读 迁移指南,以了解您的设置是否受到影响以及要采取的措施。

性能

令人印象深刻的是,我们自 Prometheus 2.0 以来在社区中取得的成就。我们都喜欢数字,所以让我们庆祝我们在 TSDB 模式下对 CPU 和内存使用率所做的效率改进。下面您可以看到在具有 8 个 CPU 和 49 GB 可分配内存的节点上,3 个 Prometheus 版本之间的性能数字。

  • 2.0.0(7 年前)
  • 2.18.0(4 年前)
  • 3.0.0(现在)

Memory bytes

CPU seconds

更令人印象深刻的是,这些数字是使用我们的 prombench 宏基准测试 获得的,该基准测试使用相同的 PromQL 查询、配置和环境——突出了核心功能的向后兼容性和稳定性,即使是 3.0 也是如此。

下一步是什么

在 Prometheus 和生态系统中,我们仍然可以进行大量令人兴奋的功能和改进。以下是一个不详尽的列表,让您兴奋并... 希望能激励您贡献并加入我们!

  • 新的、更具包容性的治理
  • 更多 OpenTelemetry 兼容性和功能
  • OpenMetrics 2.0,现在在 Prometheus 治理下!
  • 原生直方图稳定性(以及带有自定义桶!)
  • 更多优化!
  • 更多 SDK 和工具中的 UTF-8 支持覆盖

立即试用!

您可以从我们的 官方二进制文件容器镜像 下载 Prometheus 3.0 进行试用。

如果您是从 Prometheus 2.x 升级,请查看迁移指南,了解有关您需要进行的任何调整的更多信息。请注意,我们强烈建议在升级到 v3.0 之前升级到 v2.55。可以从 v3.0 回滚到 v2.55,但不能回滚到更早的版本。

与往常一样,我们欢迎来自社区的反馈和贡献!

Prometheus 3.0 Beta 版发布

Prometheus 团队自豪地宣布 Prometheus 3.0-beta 版本的发布!您可以在此处下载。与 beta 版本传统一样,我们建议用户在关键生产系统上安装 Prometheus 3.0-beta,但我们希望每个人都对其进行测试并发现错误。

一般来说,唯一的重大更改是删除了已弃用的功能标志。Prometheus 团队努力确保向后兼容性,并且不破坏现有安装,因此下面描述的所有新功能都建立在现有功能之上。大多数用户应该能够开箱即用地试用 Prometheus 3.0,而无需进行任何配置更改。

新功能

自从 Prometheus 2.0 发布以来,已经有超过 7500 次提交,新的单个功能和修复程序太多,无法一一列举,但我们想强调一些重要的、引人注目的和重大更改。我们需要社区中的每个人都尝试一下,并报告您可能发现的任何问题。我们获得的反馈越多,最终的 3.0 版本就越稳定。

新 UI

Prometheus 3.0 的亮点之一是其默认启用的全新 UI

New UI query page

UI 已经完全重写,减少了混乱,外观更现代,具有 PromLens 风格的树形视图等新功能,并且通过使用更现代的技术堆栈,将使未来的维护更容易。

有关新 UI 的更多信息,请参阅 Julius 在 PromLabs 博客上发表的详细文章。用户可以使用 old-ui 功能标志临时启用旧 UI。由于新 UI 尚未经过实战测试,因此很可能仍然存在错误。如果您发现任何错误,请在 GitHub 上报告

Remote Write 2.0

Remote-Write 2.0 通过为大量新元素(包括元数据、样本、创建时间戳和原生直方图)添加原生支持,迭代了之前的协议版本。它还使用字符串驻留来减少压缩和解压缩时的有效负载大小和 CPU 使用率。更多详细信息请参见 此处

OpenTelemetry 支持

Prometheus 旨在成为存储 OpenTelemetry 指标的默认选择,3.0 包括一些重要的新功能,使其作为 OpenTelemetry 指标数据的存储后端更加出色。

UTF-8

默认情况下,Prometheus 将允许在指标和标签名称以及标签值中使用所有有效的 UTF-8 字符,这在 2.x 版本中已经如此。

用户需要确保他们的指标生产者配置为传递 UTF-8 名称,如果任何一方不支持 UTF-8,则指标名称将使用传统的下划线替换方法进行转义。可以使用新的引用语法编写 PromQL 查询来检索 UTF-8 指标,或者用户可以手动指定 __name__ 标签名称。

并非所有语言绑定都已更新为支持 UTF-8,但主要的 Go 库已更新。

OTLP 摄取

Prometheus 可以配置为 OTLP 指标协议的本机接收器,在 /api/v1/otlp/v1/metrics 端点上接收 OTLP 指标。

原生直方图

原生直方图是一种 Prometheus 指标类型,它提供了比经典直方图更高效率和更低成本的替代方案。原生直方图不必根据数据集选择(并可能需要更新)桶边界,而是具有基于指数增长的预设桶边界。

原生直方图仍处于实验阶段,尚未默认启用,可以通过传递 --enable-feature=native-histograms 来启用。原生直方图的某些方面,如文本格式和访问器函数/运算符仍在积极设计中。

其他重大更改

以下功能标志已被删除,而是默认启用。应从配置中删除对这些标志的引用,并且从 Prometheus 3.0 版本开始将被忽略

  • promql-at-modifier
  • promql-negative-offset
  • remote-write-receiver
  • no-scrape-default-port
  • new-service-discovery-manager

范围选择现在是左开右闭,这将避免在操作中包含比预期更多的点的情况。

代理模式现在是稳定的,并且有自己的配置标志而不是功能标志

我们对 OpenTelemetry 的承诺

OpenTelemetry 项目是一个可观测性框架和工具包,旨在创建和管理遥测数据,例如跟踪、指标和日志。由于其信号之间的一致规范以及减少供应商锁定的承诺,它正在获得广泛采用,这让我们感到兴奋。

回顾 2023 年

在过去的几年中,我们与 OpenTelemetry 社区合作,以确保 OpenTelemetry 和 Prometheus 相互双向支持。这促成了官方规范的起草,以在两个系统之间进行转换,以及允许您将 Prometheus 指标摄取到 OpenTelemetry Collector 和反之亦然的实现。

从那时起,我们花费了大量时间来了解 OpenTelemetry 用户在将指标存储在 Prometheus 中时面临的 挑战,并在此基础上探索了 我们如何解决这些挑战。一些拟议的更改需要仔细考虑,以避免破坏任何一方的运营承诺,例如支持推送和拉取。在 2023 年柏林 PromCon 上,我们试图在 一次演讲中总结我们的想法。

在我们的 柏林开发者峰会上,我们花费了大部分时间深入讨论这些更改以及我们对 OpenTelemetry 的总体立场,并且广泛的共识是我们希望 “成为 OpenTelemetry 指标的默认存储”

我们已经成立了一个核心开发人员小组来领导这项计划,我们计划在 2024 年发布 Prometheus 3.0,其中 OTel 支持是其更重要的功能之一。以下是 2024 年即将推出的功能的预览。

未来一年

OTLP 摄取 GA

Prometheus v2.47.0(于 2023 年 9 月 6 日发布)中,我们为 Prometheus 添加了对 OTLP 摄取的实验性支持。我们正在不断改进这一点,并计划添加对陈旧性的支持并使其成为一个稳定的功能。我们还将把我们对乱序摄取的支持标记为稳定。这还包括 GA-ing 我们对原生/指数直方图的支持。

支持 UTF-8 指标和标签名称

OpenTelemetry 语义约定推动将 “.” 作为命名空间字符。例如,http.server.request.duration。但是,Prometheus 目前需要 更有限的字符集,这意味着当将其摄取到 Prometheus 中时,我们会将指标转换为 http_server_request_duration

这会导致不必要的冲突,我们正在努力通过为所有标签和指标名称添加 UTF-8 支持来消除此限制。进度在 此处跟踪。

原生支持资源属性

OpenTelemetry 区分指标属性(用于标识指标本身的标签,如 http.status_code)和资源属性(用于标识指标来源的标签,如 k8s.pod.name),而 Prometheus 具有更扁平的标签模式。这导致了许多可用性问题,这些问题在 此处 详细说明。

我们正在 从多个方面(查询、UX、存储等)探索多种解决方案 来解决这个问题,但我们的目标是使其非常容易在资源属性上进行过滤和分组。这是一项正在进行的工作,欢迎反馈和帮助!

生态系统中的 OTLP 导出

Prometheus remote write 已被 大多数领先的可观测性项目和供应商 支持。但是,OpenTelemetry 协议 (OTLP) 正在获得突出地位,我们希望在 Prometheus 生态系统中支持它。

我们希望将其添加到 Prometheus 服务器、SDK 和导出器中。这将意味着使用 Prometheus SDK 检测的任何服务也将能够推送 OTLP,并且它将为 OpenTelemetry 用户解锁丰富的 Prometheus 导出器生态系统。

但是,我们打算保留和开发 OpenMetrics 公开格式,作为 Prometheus 和基于拉取用例的优化/简化格式。

Delta 临时性

OpenTelemetry 项目还支持 Delta 临时性,它为可观测性生态系统提供了一些用例。我们有很多 Prometheus 用户仍然运行 statsd 并出于各种原因使用 statsd_exporter。

我们希望在 Prometheus 服务器中支持 OpenTelemetry 的 Delta 临时性,并且正在 为此努力

征集贡献!

如您所见,Prometheus 即将推出许多令人兴奋的新事物!如果在可观测性周围的两个最相关的开源项目之间的交集中工作听起来具有挑战性和趣味性,我们希望您加入我们!

今年,治理方面也正在进行变革,这将使成为维护者的过程比以往任何时候都更容易!如果您曾经想对 Prometheus 产生影响,那么现在是开始的好时机。

我们的首要重点始终是尽可能公开透明地说明我们如何组织上述所有工作,以便您也可以做出贡献。我们正在寻找贡献者来支持这项计划并帮助实施这些功能。查看 Prometheus 3.0 公开看板Prometheus OTel 支持里程碑,以跟踪功能开发的进度,并查看您可以 贡献 的方式。

结论

一些拟议的更改是大型的、侵入性的,或者涉及对 Prometheus 原始数据模型的根本背离。但是,我们计划优雅地引入这些更改,以便 Prometheus 3.0 不会发生重大更改,并且大多数用户可以在不受影响的情况下升级。

我们很高兴开始 Prometheus 的新篇章,并欢迎您对建议的更改提出反馈。

PromCon Europe 2023 的日程已上线

PromCon Europe 是第八届完全致力于 Prometheus 监控系统的会议

德国柏林 – 2023 年 9 月 1 日 – CNCF 和 Prometheus 团队发布了为期两天的单轨 PromCon Europe 2023 会议日程,该会议将于 2023 年 9 月 28 日至 29 日在德国柏林举行。与会者将能够从 21 场完整时长(25 分钟)的会议和多达 20 场五分钟的闪电演讲会议中进行选择,这些会议涵盖与 Prometheus 相关的各种主题。

PromCon 现已举办到第 8 届,汇集了来自世界各地的 Prometheus 用户和开发人员,以交流知识、最佳实践和使用 Prometheus 获得的经验。项目委员会审查了 66 份提交,这些提交将对当今 Prometheus 周围最紧迫的主题提供新鲜和信息丰富的视角。

“我们对 PromCon 回到柏林感到非常兴奋。Prometheus 于 2012 年在柏林 Soundcloud 启动。第一届 PromCon 在柏林举办,并在其间搬到了慕尼黑。今年,我们将在柏林弗里德里希斯海因区的 Radialsystem 举办约 300 名与会者。柏林拥有充满活力的 Prometheus 社区,许多 Prometheus 团队成员都住在附近。这是一个与 Prometheus 大家庭建立联系和联系的绝佳机会,他们都对系统和服务监控充满热情,”Polar Signals 高级软件工程师兼今年 PromCon 项目委员会负责人 Matthias Loibl 说。“这将是一个了解 Prometheus 团队本身最新发展并与一些 Prometheus 大型用户近距离接触的绝佳活动。”

社区策划的日程将包括来自开源社区成员的会议,包括

有关完整的 PromCon Europe 2023 计划,请访问日程

注册

通过 9 月 25 日注册现场标准定价为 350 美元。场地可容纳 300 名与会者,所以不要等待!

感谢我们的赞助商

PromCon Europe 2023 的成功举办归功于 Prometheus 周围令人惊叹的社区以及来自我们的钻石赞助商 Grafana Labs、白金赞助商 Red Hat 以及更多黄金和初创企业赞助商的支持。今年的版本由 Polar Signals 和 CNCF 组织。

观看 Prometheus 纪录片

联系方式

Jessie Adams-Shore - The Linux Foundation - [email protected]

PromCon 组织者 - [email protected]

关于 Prometheus 2.43 字符串标签优化常见问题解答

Prometheus 2.43 刚刚发布,它带来了一些令人兴奋的功能和增强功能。其中一项重大改进是 stringlabels 版本,它为标签使用了一种新的数据结构。这篇博文将回答一些关于 2.43 版本和 stringlabels 优化的常见问题。

什么是 stringlabels 版本?

stringlabels 版本是 Prometheus 2.43 版本,它为标签使用了一种新的数据结构。它将所有标签/值存储在单个字符串中,从而减少了堆大小,并在大多数情况下加快了速度。这些优化未在默认二进制文件中提供,需要使用 Go 标签 stringlabels 编译 Prometheus。

为什么不使用我们可以切换的功能标志?

我们考虑过使用功能标志,但这会产生不值得的内存开销。因此,我们决定为那些有兴趣在其生产环境中测试和衡量收益的人提供一个单独的带有这些优化的版本。

这些优化何时普遍可用?

这些优化将在即将发布的 Prometheus 2.44 版本中默认提供。

如何获取 2.43 版本?

Prometheus 2.43 版本可在官方 Prometheus GitHub 发布页面上找到,用户可以直接从那里下载二进制文件。此外,Docker 镜像也适用于那些喜欢使用容器的用户。

stringlabels 优化不包含在这些默认二进制文件中。要使用此优化,用户需要下载 2.43.0+stringlabels 版本 二进制文件或 标记为 v2.43.0-stringlabels 的 Docker 镜像

为什么版本是 v2.43.0+stringlabels,而 Docker 标签是 v2.43.0-stringlabels

在语义版本控制中,加号 (+) 用于表示构建元数据。因此,带有 stringlabels 优化的 Prometheus 2.43 版本被命名为 2.43.0+stringlabels,以表示它包含实验性的 stringlabels 功能。但是,Docker 标签不允许在其名称中使用加号。因此,加号已替换为破折号 (-),以使 Docker 标签为 v2.43.0-stringlabels。这允许 Docker 标签通过下游项目(如 Prometheus Operator)的语义版本控制检查。

Prometheus 2.43 版本中还有哪些其他值得注意的功能?

除了 stringlabels 优化之外,Prometheus 2.43 版本还带来了一些新功能和增强功能。一些重要的新增功能包括

  • 我们添加了对 scrape_config_files 的支持,以包含来自不同文件的抓取配置。这使得管理和组织配置变得更加容易。
  • HTTP 客户端现在包含两个新的配置选项:no_proxy 用于排除代理请求的 URL,以及 proxy_from_environment 用于从环境变量中读取代理设置。这些功能使得在不同环境中管理 HTTP 客户端的行为更加容易。

您可以在完整更新日志中了解更多关于功能和错误修复的信息。

Prometheus Agent 模式介绍:一种高效且云原生的指标转发方式

Bartek Płotka 自 2019 年以来一直是 Prometheus 的维护者,现任 Red Hat 首席软件工程师。他是 CNCF Thanos 项目的共同作者,CNCF 大使以及 CNCF TAG 可观测性技术负责人。在业余时间,他正在与 O'Reilly 合作撰写一本名为《高效 Go》的书籍。以上观点仅代表我个人!

我个人非常喜欢 Prometheus 项目,这也是我加入该团队的众多原因之一,那就是项目对目标的激光般聚焦。Prometheus 一直致力于突破界限,提供实用、可靠、廉价但又非常宝贵的基于指标的监控。Prometheus 超稳定且强大的 API、查询语言和集成协议(例如 Remote Write 和 OpenMetrics)使得云原生计算基金会 (CNCF) 指标生态系统能够在这些坚实的基础上发展壮大。结果令人惊叹。

  • 我们可以看到社区为几乎所有事物开发了导出器,例如 容器eBPFMinecraft 服务器统计信息,甚至 园艺时植物的健康状况
  • 现在大多数人期望云原生软件具有 Prometheus 可以抓取的 HTTP/HTTPS /metrics 端点。这个概念最初在 Google 内部秘密开发,并由 Prometheus 项目在全球范围内率先推广。
  • 可观测性范式发生了转变。我们看到 SRE 和开发人员从一开始就严重依赖指标,这提高了软件的弹性、可调试性和数据驱动的决策能力!

最终,我们几乎看不到没有运行 Prometheus 的 Kubernetes 集群。

Prometheus 社区的强大关注也促使其他开源项目发展壮大,从而将 Prometheus 的部署模型扩展到单节点之外(例如 CortexThanos 等)。更不用说云厂商也采用了 Prometheus 的 API 和数据模型(例如 Amazon Managed PrometheusGoogle Cloud Managed PrometheusGrafana Cloud 等)。如果您正在寻找 Prometheus 项目如此成功的一个原因,那就是:将监控社区的注意力集中在重要的事情上

在这篇(冗长的)博客文章中,我想介绍一种新的 Prometheus 运行操作模式,称为“Agent”(代理)。它直接内置于 Prometheus 二进制文件中。代理模式禁用了 Prometheus 的一些常用功能,并针对抓取和远程写入到远程位置进行了优化。引入减少功能的模式可以实现新的使用模式。在这篇博文中,我将解释为什么它对于 CNCF 生态系统中的某些部署来说是一个游戏规则改变者。我对此感到非常兴奋!

转发用例的历史

Prometheus 的核心设计在其整个生命周期中一直没有改变。受 Google 的 Borgmon 监控系统 的启发,您可以将 Prometheus 服务器与您要监控的应用程序一起部署,告诉 Prometheus 如何访问它们,并允许定期抓取其指标的当前值。这种收集方法通常被称为“拉取模型”,是 使 Prometheus 变得轻量级和可靠 的核心原则。此外,它使得应用程序仪表化和导出器变得非常简单,因为它们只需要提供一个简单的人类可读的 HTTP 端点,其中包含所有跟踪指标的当前值(以 OpenMetrics 格式)。所有这些都无需复杂的推送基础设施和非平凡的客户端库。总的来说,简化的典型 Prometheus 监控部署如下所示:

Prometheus high-level view

这非常有效,多年来我们已经看到了数百万个像这样的成功部署,它们处理了数千万个活跃序列。其中一些用于更长时间的保留,例如两年左右。所有这些都允许查询、告警和记录对集群管理员和开发人员都有用的指标。

然而,云原生世界正在不断发展和演变。随着托管 Kubernetes 解决方案的增长以及在几秒钟内按需创建的集群,我们现在终于能够将集群视为“牲畜”,而不是“宠物”(换句话说,我们不太关心这些集群的单个实例)。在某些情况下,解决方案甚至不再具有集群的概念,例如 kcpFargate 和其他平台。

Yoda

另一个有趣的用例是 边缘 集群或网络的概念。随着电信、汽车和物联网设备等行业采用云原生技术,我们看到越来越多资源受限的小型集群。这迫使所有数据(包括可观测性数据)都必须传输到远程、更大的对等方,因为几乎没有数据可以存储在这些远程节点上。

这意味着什么?这意味着监控数据必须以某种方式聚合、呈现给用户,有时甚至存储在全局级别。这通常被称为 全局视图 功能。

天真地,我们可以考虑通过将 Prometheus 放在全局级别并跨远程网络抓取指标,或者直接从应用程序将指标推送到中央位置进行监控来实现这一点。让我解释一下为什么这两种方法通常都是非常糟糕的主意:

🔥 跨越网络边界进行抓取可能会带来挑战,因为它会在监控管道中增加新的未知因素。本地拉取模型允许 Prometheus 确切地知道指标目标为何以及何时出现问题。也许它已关闭、配置错误、重新启动、速度太慢无法提供指标(例如 CPU 饱和)、服务发现无法发现、我们没有访问凭据,或者只是 DNS、网络或整个集群都已关闭。通过将抓取器放在网络外部,我们可能会因引入与单个目标无关的不可靠抓取而丢失一些信息。最重要的是,如果网络暂时中断,我们可能会完全失去重要的可见性。请不要这样做。不值得。(

🔥 直接从应用程序将指标推送到某个中央位置同样糟糕。尤其是当您监控大型集群时,当您看不到来自远程应用程序的指标时,您实际上什么都不知道。应用程序是否已关闭?我的接收器管道是否已关闭?也许应用程序未能授权?也许它未能获取远程集群的 IP 地址?也许它太慢了?也许网络已关闭?更糟糕的是,您甚至可能不知道某些应用程序目标的数据丢失了。而且您并没有获得太多好处,因为您需要跟踪应该发送数据的每件事的状态和状况。这种设计需要仔细分析,因为它很容易成为失败的根源。

注意: 无服务器函数和短生命周期的容器通常是我们考虑从应用程序推送作为补救措施的情况。然而,此时我们讨论的是事件或指标片段,我们可能希望将其聚合到更长时间的时间序列中。此主题在 此处 讨论,欢迎您贡献力量,帮助我们更好地支持这些情况!

Prometheus 引入了三种方法来支持全局视图用例,每种方法都有其优点和缺点。让我们简要地了解一下这些方法。它们在下图中以橙色显示:

Prometheus global view

  • 联邦(Federation) 作为第一种聚合功能被引入。它允许全局级别的 Prometheus 服务器从叶级 Prometheus 服务器抓取指标子集。“联邦”抓取减少了跨网络的一些未知因素,因为联邦端点公开的指标包括原始样本的时间戳。然而,它通常会受到无法联合所有指标以及在较长的网络分区(分钟)期间丢失数据的困扰。
  • Prometheus 远程读取(Remote Read) 允许从远程 Prometheus 服务器的数据库中选择原始指标,而无需直接的 PromQL 查询。您可以将 Prometheus 或其他解决方案(例如 Thanos)部署在全局级别,以便在此数据上执行 PromQL 查询,同时从多个远程位置获取所需的指标。这非常强大,因为它允许您“本地”存储数据,并在需要时才访问它。不幸的是,也有缺点。在没有像 查询下推(Query Pushdown) 这样的功能的情况下,在极端情况下,我们需要拉取 GB 级的压缩指标数据来回答单个查询。此外,如果发生网络分区,我们将暂时失明。最后但并非最不重要的一点是,某些安全指南不允许入口流量,只允许出口流量。
  • 最后,我们有 Prometheus 远程写入(Remote Write),这似乎是目前最流行的选择。由于代理模式专注于远程写入用例,让我们更详细地解释一下它。

远程写入

Prometheus 远程写入协议允许我们将 Prometheus 收集的所有或部分指标转发(流式传输)到远程位置。您可以配置 Prometheus 将某些指标(如果需要,可以包含所有元数据和样本!)转发到一个或多个支持远程写入 API 的位置。事实上,Prometheus 既支持接收也支持发送远程写入,因此您可以将 Prometheus 部署在全局级别以接收该流并聚合跨集群的数据。

虽然官方的 Prometheus 远程写入 API 规范仍处于审查阶段,但生态系统已将远程写入协议作为默认的指标导出协议。例如,Cortex、Thanos、OpenTelemetry 和云服务(如 Amazon、Google、Grafana、Logz.io 等)都支持通过远程写入摄取数据。

Prometheus 项目还为其 API 提供了官方的合规性测试,例如为提供远程写入客户端功能的解决方案提供的 远程写入发送器合规性。这是一个快速判断您是否正确实施此协议的好方法。

从这样的抓取器流式传输数据可以通过允许您在集中位置存储指标数据来实现全局视图用例。这也有助于关注点分离,当应用程序由不同的团队管理,而不是可观测性或监控管道时,这非常有用。此外,这也是供应商选择远程写入的原因,他们希望尽可能多地减轻客户的工作负担。

等一下,Bartek。你之前不是提到直接从应用程序推送指标不是最好的主意吗!

当然,但令人惊奇的是,即使使用远程写入,Prometheus 仍然使用拉取模型从应用程序收集指标,这使我们能够了解这些不同的故障模式。之后,我们批量处理样本和序列,并将数据导出、复制(推送)到远程写入端点,从而限制了中央点拥有的监控未知数!

重要的是要注意,可靠且高效的远程写入实现是一个非平凡的问题。Prometheus 社区花费了大约三年的时间才提出了稳定且可扩展的实现。我们多次重新实现了 WAL(预写日志),添加了内部排队、分片、智能退避等。所有这些都对用户隐藏起来,用户可以享受高性能的流式传输或存储在集中位置的大量指标。

远程写入实践示例:Katacoda 教程

所有这些在 Prometheus 中都不是新鲜事物。我们中的许多人已经使用 Prometheus 来抓取所有必需的指标,并将所有或部分指标远程写入到远程位置。

假设您想尝试远程写入功能的实践体验。在这种情况下,我们推荐 Thanos Katacoda 教程:从 Prometheus 远程写入指标,其中解释了 Prometheus 将所有指标转发到远程位置所需的所有步骤。它是免费的,只需注册一个帐户即可享受教程!🤗

请注意,此示例使用 Thanos 以接收模式作为远程存储。如今,您可以使用大量其他与远程写入 API 兼容的项目。

因此,如果远程写入工作正常,为什么我们要向 Prometheus 添加特殊的 Agent 模式?

Prometheus Agent 模式

从 Prometheus v2.32.0(下一个版本)开始,每个人都将能够使用实验性的 --enable-feature=agent 标志运行 Prometheus 二进制文件。如果您想在发布之前尝试它,请随时使用 Prometheus v2.32.0-beta.0 或使用我们的 quay.io/prometheus/prometheus:v2.32.0-beta.0 镜像。

Agent 模式优化了 Prometheus 以用于远程写入用例。它禁用了查询、告警和本地存储,并将其替换为自定义的 TSDB WAL。其他一切都保持不变:抓取逻辑、服务发现和相关配置。如果您只想将数据转发到远程 Prometheus 服务器或任何其他与远程写入兼容的项目,则可以将其用作 Prometheus 的直接替代品。本质上,它看起来像这样:

Prometheus agent

关于 Prometheus Agent 最好的部分是它内置于 Prometheus 中。相同的抓取 API、相同的语义、相同的配置和发现机制。

如果您计划不在本地查询或告警数据,而是将指标流式传输到外部,那么使用 Agent 模式有什么好处呢?有以下几点:

首先,效率。我们的自定义 Agent TSDB WAL 在成功写入后立即删除数据。如果无法访问远程端点,它会将数据临时持久化到磁盘上,直到远程端点恢复在线。目前这仅限于两小时的缓冲区,与非 Agent Prometheus 类似,希望很快解除限制。这意味着我们不需要在内存中构建数据块。我们不需要维护用于查询目的的完整索引。从本质上讲,Agent 模式使用的资源只是正常 Prometheus 服务器在类似情况下使用资源的一小部分。

这种效率重要吗?是的!正如我们所提到的,对于某些部署来说,边缘集群上使用的每 GB 内存和每个 CPU 核心都很重要。另一方面,使用指标执行监控的范式在今天已经相当成熟。这意味着您可以以相同的成本传输更多相关的、更高基数的指标 - 就越好。

注意: 随着 Agent 模式的引入,原始 Prometheus 服务器模式仍然是推荐的、稳定和维护的模式。带有远程存储的 Agent 模式带来了额外的复杂性。请谨慎使用。

其次,新的 Agent 模式的好处是它可以更容易地实现水平扩展以进行数据摄取。这是我最兴奋的事情。让我解释一下原因。

梦想:自动可扩展的指标摄取

真正的自动可扩展的抓取解决方案需要基于指标目标的数量及其公开的指标数量。我们需要抓取的数据越多,我们自动部署的 Prometheus 实例就越多。如果目标数量或其指标数量减少,我们可以缩减规模并删除几个实例。这将消除手动调整 Prometheus 大小的负担,并停止在集群暂时较小时过度分配 Prometheus 的需求。

仅使用服务器模式的 Prometheus,这很难实现。这是因为服务器模式下的 Prometheus 是有状态的。无论收集到什么都保持原样在一个地方。这意味着缩减规模的过程需要在终止之前将收集到的数据备份到现有实例。然后我们将面临抓取重叠、误导性陈旧标记等问题。

最重要的是,服务器模式下 Prometheus 的资源使用量取决于比数据摄取更多的因素。例如,告警、记录、查询、压缩、远程写入等,可能需要更多或更少的资源,而与指标目标的数量无关。

Agent 模式本质上将发现、抓取和远程写入移动到一个单独的微服务。这使得操作模型专注于仅进行数据摄取。因此,Agent 模式下的 Prometheus 或多或少是无状态的。是的,为了避免指标丢失,我们需要部署一对 HA 代理并为它们附加持久磁盘。但从技术上讲,如果我们有数千个指标目标(例如容器),我们可以部署多个 Prometheus 代理,并安全地更改哪个副本正在抓取哪些目标。这是因为,最终,所有样本都将被推送到相同的中央存储。

总的来说,Agent 模式下的 Prometheus 实现了基于 Prometheus 的抓取的轻松水平自动扩展能力,可以对指标目标的动态变化做出反应。这绝对是我们未来将与 Prometheus Kubernetes Operator 社区一起研究的方向。

现在让我们看一下 Prometheus 中当前实现的 Agent 模式的状态。它可以使用了吗?

Agent 模式已在大规模环境中得到验证

下一个版本的 Prometheus 将包含 Agent 模式作为实验性功能。标志、API 和磁盘上的 WAL 格式可能会更改。但由于 Grafana Labs 的开源工作,该实现的性能已经过实战检验。

我们的 Agent 自定义 WAL 的初始实现灵感来自当前 Prometheus 服务器的 TSDB WAL,由 Robert Fratto 在 2019 年在 Prometheus 维护者 Tom Wilkie 的指导下创建。然后,它被用于开源 Grafana Agent 项目中,该项目自那时起已被许多 Grafana Cloud 客户和社区成员使用。鉴于该解决方案的成熟度,现在是将该实现捐赠给 Prometheus 以进行原生集成和更广泛采用的时候了。Robert (Grafana Labs) 在 Srikrishna (Red Hat) 和社区的帮助下,将代码移植到 Prometheus 代码库中,该代码库在 2 周前合并到 main 分支!

捐赠过程非常顺利。由于一些 Prometheus 维护者之前在 Grafana Agent 中为此代码做出了贡献,并且由于新的 WAL 受 Prometheus 自己的 WAL 的启发,因此当前的 Prometheus TSDB 维护者不难将其纳入全面维护!Robert 加入 Prometheus 团队担任 TSDB 维护者(祝贺!)也确实很有帮助。

现在,让我们解释一下如何使用它!(

如何详细使用 Agent 模式

从现在开始,如果您显示 Prometheus 的帮助输出(--help 标志),您应该会看到大致如下的内容:

usage: prometheus [<flags>]

The Prometheus monitoring server

Flags:
  -h, --help                     Show context-sensitive help (also try --help-long and --help-man).
      (... other flags)
      --storage.tsdb.path="data/"
                                 Base path for metrics storage. Use with server mode only.
      --storage.agent.path="data-agent/"
                                 Base path for metrics storage. Use with agent mode only.
      (... other flags)
      --enable-feature= ...      Comma separated feature names to enable. Valid options: agent, exemplar-storage, expand-external-labels, memory-snapshot-on-shutdown, promql-at-modifier, promql-negative-offset, remote-write-receiver,
                                 extra-scrape-metrics, new-service-discovery-manager. See https://prometheus.ac.cn/docs/prometheus/latest/feature_flags/ for more details.

由于 Agent 模式位于功能标志之后,如前所述,请使用 --enable-feature=agent 标志在 Agent 模式下运行 Prometheus。现在,其余标志要么用于服务器模式和 Agent 模式,要么仅用于特定模式。您可以通过检查标志的帮助字符串的最后一句话来查看哪个标志用于哪种模式。“仅用于服务器模式”意味着它仅用于服务器模式。如果您没有看到任何类似的提及,则表示该标志是共享的。

Agent 模式接受相同的抓取配置,具有相同的发现选项和远程写入选项。

它还公开了一个 Web UI,其中禁用了查询功能,但显示了构建信息、配置、目标和服务发现信息,与正常的 Prometheus 服务器相同。

Prometheus Agent 实践示例:Katacoda 教程

与 Prometheus 远程写入教程类似,如果您想尝试 Prometheus Agent 功能的实践体验,我们推荐 Thanos Katacoda 教程:Prometheus Agent,其中解释了运行 Prometheus Agent 的简易程度。

总结

希望您觉得这很有趣!在这篇文章中,我们回顾了出现的新用例,例如:

  • 边缘集群
  • 有限访问网络
  • 大量集群
  • 短暂且动态的集群

然后,我们解释了新的 Prometheus Agent 模式,该模式允许高效地将抓取的指标转发到远程写入端点。

与往常一样,如果您有任何问题或反馈,请随时在 GitHub 上提交工单或在邮件列表中提问

这篇博客文章是 CNCF、Grafana 和 Prometheus 之间协调发布的一部分。也欢迎阅读 CNCF 公告 和关于 Grafana Agent(Prometheus Agent 的基础)的角度

Prometheus 合规性计划:第一轮结果

今天,我们启动了 Prometheus 合规性计划,目标是确保 Prometheus 监控领域中不同项目和供应商之间的互操作性。虽然法律文件仍需最终确定,但我们已经进行了测试,并将以下内容视为我们的第一轮结果。作为此次发布的一部分,Julius Volz 更新了他的 PromQL 测试结果

快速提醒:该计划称为 Prometheus 合规性(Conformance),软件可以 符合(compliant) 特定测试,从而产生 兼容性(compatibility) 评级。术语可能看起来很复杂,但它使我们能够在不使用冗长语句的情况下谈论这个话题。

序言

新类别

我们发现很难推理出什么需要应用于什么软件。为了帮助整理我的思路,我们创建了 一个概述,介绍了我们可以将软件归入的四个新类别:

  • 指标暴露器(Metrics Exposers)
  • Agent/Collector
  • Prometheus 存储后端
  • 完全 Prometheus 兼容性

行动号召

非常欢迎反馈。也许与直觉相反,我们希望社区,而不仅仅是 Prometheus 团队,来塑造这项工作。为了帮助实现这一点,我们将在 Prometheus 中启动一个 WG Conformance(合规性工作组)。与 WG Docs(文档工作组)WG Storage(存储工作组) 一样,这些工作组将是公开的,我们积极邀请参与。

正如我们 最近暗示的,Prometheus 的维护者/采用率出乎意料地低,或者说是令人震惊地低。换句话说,我们希望围绕 Prometheus 兼容性的经济激励措施将吸引供应商分配资源与我们一起构建测试。如果您一直想在工作时间为 Prometheus 做出贡献,这可能是一个途径;并且是一种让您接触到 Prometheus 许多高度相关方面的方式。有很多方法可以 与我们取得联系

注册接受测试

如果您想注册接受测试,可以使用 相同的沟通渠道 与我们联系。一旦文书工作到位,我们将把联系信息和合同操作移交给 CNCF。

测试结果

完全 Prometheus 兼容性

我们知道我们想要构建哪些测试,但我们尚未完成。正如之前宣布的那样,以此来反对项目或供应商是不公平的。因此,测试垫片被定义为已通过。目前半手动的性质,例如 Julius 本周运行的 PromQL 测试 意味着 Julius 在大多数情况下测试了通过 Prometheus Remote Write 发送数据作为 PromQL 测试的一部分。我们在这里以不止一种方式重复使用他的结果。这将很快得到理清,来自不同角度的更多测试将不断提高要求,从而提高最终用户的信心。

将项目和 aaS 产品分为两组来查看是有意义的。

项目

通过

  • Cortex 1.10.0
  • M3 1.3.0
  • Promscale 0.6.2
  • Thanos 0.23.1

未通过

VictoriaMetrics 1.67.0 未通过,并且 不打算通过。本着最终用户信心的精神,我们决定跟踪他们的结果,同时他们将自己定位为 Prometheus 的直接替代品。

aaS

通过

  • Chronosphere
  • Grafana Cloud

未通过

  • Amazon Managed Service for Prometheus
  • Google Cloud Managed Service for Prometheus
  • New Relic
  • Sysdig Monitor

注意:由于 Amazon Managed Service for Prometheus 与 Grafana Cloud 一样基于 Cortex,我们预计它们将在下一次更新周期后通过。

Agent/Collector

通过

  • Grafana Agent 0.19.0
  • OpenTelemetry Collector 0.37.0
  • Prometheus 2.30.3

未通过

  • Telegraf 1.20.2
  • Timber Vector 0.16.1
  • VictoriaMetrics Agent 1.67.0

注意:我们测试了 Vector 0.16.1 而不是 0.17.0,因为 0.17.0 没有二进制下载,并且我们的测试工具链目前需要二进制文件。

关于勒索软件命名

正如奥斯卡·王尔德所说,模仿是最真诚的奉承。

“Prometheus”和“Thanos”这两个名字 最近被一个勒索软件团伙采用。除了通知您正在发生这种情况之外,我们无能为力。除了意识到正在发生这种情况之外,您也无能为力。

虽然我们没有理由相信该团伙会试图欺骗任何人下载我们项目的虚假二进制文件,但我们仍然建议遵循常见的供应链和安全实践。部署软件时,请通过以下机制之一进行:

除非您能够合理地信任特定的来源和供应链,否则您不应使用该软件。

由于勒索软件团伙有可能故意选择这些名称,因此可能会看到这篇博文:请停止。勒索软件和命名选择都请停止。

Prometheus 合规性计划:远程写入合规性测试结果

正如 CNCF 宣布我们自己宣布 的那样,我们正在启动 Prometheus 合规性计划。

为了让每个人了解生态系统在正式运行测试之前的状况,我们想展示我们快乐的小型测试套件家族中的最新成员:Prometheus 远程写入 合规性测试套件根据我们的 规范 测试远程写入协议的发送器部分。

在周一的 PromCon 上,Tom Wilkie 展示了几周前录制的测试结果。在直播部分,他已经有了一个 更新。两天后,我们又有两个更新:添加了 可观测性管道工具 Vector,以及 现有系统的新版本

因此,事不宜迟,当前的按字母顺序排列的结果是:

发送器 版本 得分
Grafana Agent 0.13.1 100%
Prometheus 2.26.0 100%
OpenTelemetry Collector 0.26.0 41%
Telegraf 1.18.2 65%
Timber Vector 0.13.1 35%
VictoriaMetrics Agent 1.59.0 76%

原始结果是:

--- PASS: TestRemoteWrite/grafana (0.01s)
    --- PASS: TestRemoteWrite/grafana/Counter (10.02s)
    --- PASS: TestRemoteWrite/grafana/EmptyLabels (10.02s)
    --- PASS: TestRemoteWrite/grafana/Gauge (10.02s)
    --- PASS: TestRemoteWrite/grafana/Headers (10.02s)
    --- PASS: TestRemoteWrite/grafana/Histogram (10.02s)
    --- PASS: TestRemoteWrite/grafana/HonorLabels (10.02s)
    --- PASS: TestRemoteWrite/grafana/InstanceLabel (10.02s)
    --- PASS: TestRemoteWrite/grafana/Invalid (10.02s)
    --- PASS: TestRemoteWrite/grafana/JobLabel (10.02s)
    --- PASS: TestRemoteWrite/grafana/NameLabel (10.02s)
    --- PASS: TestRemoteWrite/grafana/Ordering (26.12s)
    --- PASS: TestRemoteWrite/grafana/RepeatedLabels (10.02s)
    --- PASS: TestRemoteWrite/grafana/SortedLabels (10.02s)
    --- PASS: TestRemoteWrite/grafana/Staleness (10.01s)
    --- PASS: TestRemoteWrite/grafana/Summary (10.01s)
    --- PASS: TestRemoteWrite/grafana/Timestamp (10.01s)
    --- PASS: TestRemoteWrite/grafana/Up (10.02s)
--- PASS: TestRemoteWrite/prometheus (0.01s)
    --- PASS: TestRemoteWrite/prometheus/Counter (10.02s)
    --- PASS: TestRemoteWrite/prometheus/EmptyLabels (10.02s)
    --- PASS: TestRemoteWrite/prometheus/Gauge (10.02s)
    --- PASS: TestRemoteWrite/prometheus/Headers (10.02s)
    --- PASS: TestRemoteWrite/prometheus/Histogram (10.02s)
    --- PASS: TestRemoteWrite/prometheus/HonorLabels (10.02s)
    --- PASS: TestRemoteWrite/prometheus/InstanceLabel (10.02s)
    --- PASS: TestRemoteWrite/prometheus/Invalid (10.02s)
    --- PASS: TestRemoteWrite/prometheus/JobLabel (10.02s)
    --- PASS: TestRemoteWrite/prometheus/NameLabel (10.03s)
    --- PASS: TestRemoteWrite/prometheus/Ordering (24.99s)
    --- PASS: TestRemoteWrite/prometheus/RepeatedLabels (10.02s)
    --- PASS: TestRemoteWrite/prometheus/SortedLabels (10.02s)
    --- PASS: TestRemoteWrite/prometheus/Staleness (10.02s)
    --- PASS: TestRemoteWrite/prometheus/Summary (10.02s)
    --- PASS: TestRemoteWrite/prometheus/Timestamp (10.02s)
    --- PASS: TestRemoteWrite/prometheus/Up (10.02s)
--- FAIL: TestRemoteWrite/otelcollector (0.00s)
    --- FAIL: TestRemoteWrite/otelcollector/Counter (10.01s)
    --- FAIL: TestRemoteWrite/otelcollector/Histogram (10.01s)
    --- FAIL: TestRemoteWrite/otelcollector/InstanceLabel (10.01s)
    --- FAIL: TestRemoteWrite/otelcollector/Invalid (10.01s)
    --- FAIL: TestRemoteWrite/otelcollector/JobLabel (10.01s)
    --- FAIL: TestRemoteWrite/otelcollector/Ordering (13.54s)
    --- FAIL: TestRemoteWrite/otelcollector/RepeatedLabels (10.01s)
    --- FAIL: TestRemoteWrite/otelcollector/Staleness (10.01s)
    --- FAIL: TestRemoteWrite/otelcollector/Summary (10.01s)
    --- FAIL: TestRemoteWrite/otelcollector/Up (10.01s)
    --- PASS: TestRemoteWrite/otelcollector/EmptyLabels (10.01s)
    --- PASS: TestRemoteWrite/otelcollector/Gauge (10.01s)
    --- PASS: TestRemoteWrite/otelcollector/Headers (10.01s)
    --- PASS: TestRemoteWrite/otelcollector/HonorLabels (10.01s)
    --- PASS: TestRemoteWrite/otelcollector/NameLabel (10.01s)
    --- PASS: TestRemoteWrite/otelcollector/SortedLabels (10.01s)
    --- PASS: TestRemoteWrite/otelcollector/Timestamp (10.01s)
--- FAIL: TestRemoteWrite/telegraf (0.01s)
    --- FAIL: TestRemoteWrite/telegraf/EmptyLabels (14.60s)
    --- FAIL: TestRemoteWrite/telegraf/HonorLabels (14.61s)
    --- FAIL: TestRemoteWrite/telegraf/Invalid (14.61s)
    --- FAIL: TestRemoteWrite/telegraf/RepeatedLabels (14.61s)
    --- FAIL: TestRemoteWrite/telegraf/Staleness (14.59s)
    --- FAIL: TestRemoteWrite/telegraf/Up (14.60s)
    --- PASS: TestRemoteWrite/telegraf/Counter (14.61s)
    --- PASS: TestRemoteWrite/telegraf/Gauge (14.60s)
    --- PASS: TestRemoteWrite/telegraf/Headers (14.61s)
    --- PASS: TestRemoteWrite/telegraf/Histogram (14.61s)
    --- PASS: TestRemoteWrite/telegraf/InstanceLabel (14.61s)
    --- PASS: TestRemoteWrite/telegraf/JobLabel (14.61s)
    --- PASS: TestRemoteWrite/telegraf/NameLabel (14.60s)
    --- PASS: TestRemoteWrite/telegraf/Ordering (14.61s)
    --- PASS: TestRemoteWrite/telegraf/SortedLabels (14.61s)
    --- PASS: TestRemoteWrite/telegraf/Summary (14.60s)
    --- PASS: TestRemoteWrite/telegraf/Timestamp (14.61s)
--- FAIL: TestRemoteWrite/vector (0.01s)
    --- FAIL: TestRemoteWrite/vector/Counter (10.02s)
    --- FAIL: TestRemoteWrite/vector/EmptyLabels (10.01s)
    --- FAIL: TestRemoteWrite/vector/Headers (10.02s)
    --- FAIL: TestRemoteWrite/vector/HonorLabels (10.02s)
    --- FAIL: TestRemoteWrite/vector/InstanceLabel (10.02s)
    --- FAIL: TestRemoteWrite/vector/Invalid (10.02s)
    --- FAIL: TestRemoteWrite/vector/JobLabel (10.01s)
    --- FAIL: TestRemoteWrite/vector/Ordering (13.01s)
    --- FAIL: TestRemoteWrite/vector/RepeatedLabels (10.02s)
    --- FAIL: TestRemoteWrite/vector/Staleness (10.02s)
    --- FAIL: TestRemoteWrite/vector/Up (10.02s)
    --- PASS: TestRemoteWrite/vector/Gauge (10.02s)
    --- PASS: TestRemoteWrite/vector/Histogram (10.02s)
    --- PASS: TestRemoteWrite/vector/NameLabel (10.02s)
    --- PASS: TestRemoteWrite/vector/SortedLabels (10.02s)
    --- PASS: TestRemoteWrite/vector/Summary (10.02s)
    --- PASS: TestRemoteWrite/vector/Timestamp (10.02s)
--- FAIL: TestRemoteWrite/vmagent (0.01s)
    --- FAIL: TestRemoteWrite/vmagent/Invalid (20.66s)
    --- FAIL: TestRemoteWrite/vmagent/Ordering (22.05s)
    --- FAIL: TestRemoteWrite/vmagent/RepeatedLabels (20.67s)
    --- FAIL: TestRemoteWrite/vmagent/Staleness (20.67s)
    --- PASS: TestRemoteWrite/vmagent/Counter (20.67s)
    --- PASS: TestRemoteWrite/vmagent/EmptyLabels (20.64s)
    --- PASS: TestRemoteWrite/vmagent/Gauge (20.66s)
    --- PASS: TestRemoteWrite/vmagent/Headers (20.64s)
    --- PASS: TestRemoteWrite/vmagent/Histogram (20.66s)
    --- PASS: TestRemoteWrite/vmagent/HonorLabels (20.66s)
    --- PASS: TestRemoteWrite/vmagent/InstanceLabel (20.66s)
    --- PASS: TestRemoteWrite/vmagent/JobLabel (20.66s)
    --- PASS: TestRemoteWrite/vmagent/NameLabel (20.66s)
    --- PASS: TestRemoteWrite/vmagent/SortedLabels (20.66s)
    --- PASS: TestRemoteWrite/vmagent/Summary (20.66s)
    --- PASS: TestRemoteWrite/vmagent/Timestamp (20.67s)
    --- PASS: TestRemoteWrite/vmagent/Up (20.66s)

我们将更加努力地改进我们的测试套件,包括添加更多测试和添加新的测试目标。如果您想帮助我们,请考虑添加更多 我们的远程写入集成列表

Prometheus 合规性计划介绍

Prometheus 是云原生领域及其他领域中指标监控的标准。为了确保互操作性、保护用户免受意外情况的影响,并实现更并行的创新,Prometheus 项目正在 CNCF 的帮助下引入 Prometheus 合规性计划,以认证组件合规性和 Prometheus 兼容性。

CNCF 理事会预计将在下次会议期间正式审查并批准该计划。我们邀请更广泛的社区帮助改进我们在启动阶段的测试。

借助我们 广泛且不断扩展的测试套件,项目和供应商可以确定其对我们规范的合规性和在 Prometheus 生态系统中的兼容性。

在启动时,我们为三个组件提供合规性测试:

  • PromQL(需要手动解释,基本完成)
  • 远程读写(完全自动化,WIP)
  • OpenMetrics(部分自动化,基本完成,需要问卷调查)

我们计划添加更多组件。Prometheus 远程读取或我们的数据存储/TSDB 的测试可能是下一个新增内容。我们明确邀请所有人扩展和改进现有测试,并提交新的测试。

Prometheus 合规性计划的工作方式如下:

对于每个组件,都会有一个标记“foo YYYY-MM compliant”,例如“OpenMetrics 2021-05 compliant”、“PromQL 2021-05 compliant”和“Prometheus Remote Write 2021-05 compliant”。任何项目或供应商都可以提交其合规性文档。达到 100% 后,将授予该标记。

对于任何完整的软件,都会有一个 “Prometheus x.y 兼容” 的标记,例如 “Prometheus 2.26 兼容”。相关的组件兼容性得分将被相乘。当达到 100% 时,将授予该标记。

例如,Prometheus Agent 支持 OpenMetrics 和 Prometheus Remote Write,但不支持 PromQL。因此,只有 OpenMetrics 和 Prometheus Remote Write 的兼容性得分会被相乘。

兼容和兼容性标记的有效期均为 2 个小版本或 12 周,以较长者为准。

引入 “@” 修饰符

您是否曾经选择过某个指标的前 10 个时间序列,但结果得到的不是 10 个而是 100 个?如果是,那么这篇文章就是为您准备的。让我带您了解一下根本问题是什么,以及我是如何解决它的。

目前,topk() 查询仅在即时查询中才有意义,您可以在其中获得正好 k 个结果,但是当您将其作为范围查询运行时,您可能会获得远多于 k 个结果,因为每个步骤都是独立评估的。这个 @ 修饰符让您可以为范围查询中的所有步骤固定排名。

在 Prometheus v2.25.0 中,我们引入了一个新的 PromQL 修饰符 @。类似于 offset 修饰符允许您相对于评估时间偏移向量选择器、范围向量选择器和子查询的评估一样,@ 修饰符允许您固定这些选择器的评估,而与查询评估时间无关。此语法的功劳归于 Björn Rabenstein

<vector-selector> @ <timestamp>
<range-vector-selector> @ <timestamp>
<subquery> @ <timestamp>

<timestamp> 是一个 Unix 时间戳,用浮点文字描述。

例如,查询 http_requests_total @ 1609746000 返回 http_requests_total2021-01-04T07:40:00+00:00 的值。查询 rate(http_requests_total[5m] @ 1609746000) 返回同一时间的 http_requests_total 的 5 分钟速率。

此外,start()end() 也可以用作 @ 修饰符的特殊值。对于范围查询,它们分别解析为范围查询的开始和结束,并且对于所有步骤保持不变。对于即时查询,start()end() 都解析为评估时间。

回到 topk() 的修复,以下查询绘制了那些最后 1h 速率排名前 5 的时间序列的 1m 速率。因此,现在您可以理解即使作为范围查询,topk() 也具有意义,它可以精确地绘制 k 个结果。

rate(http_requests_total[1m]) # This acts like the actual selector.
  and
topk(5, rate(http_requests_total[1h] @ end())) # This acts like a ranking function which filters the selector.

类似地,topk() 排名可以替换为其他函数,例如目前仅在即时查询中有意义的 histogram_quantile()rate() 可以替换为 <aggregation>_over_time() 等。请告诉我们您如何使用这个新的修饰符!

@ 修饰符默认禁用,可以使用标志 --enable-feature=promql-at-modifier 启用。在 这篇博客文章 中了解更多关于功能标志的信息,并在 这里 找到 @ 修饰符的文档。

引入功能标志

我们一直围绕稳定性和遵循 SemVer 模型的重大更改做出坚定的承诺。情况仍然如此。

由于我们希望在实验方面更大胆,我们计划更多地使用功能标志。

从 v2.25.0 开始,我们引入了一个名为 禁用功能 的新章节,其中包含隐藏在 --enable-feature 标志后面的功能。您可以期待在未来的版本中向此部分添加越来越多的功能。

此列表中的功能被认为是实验性的,并且只要它们仍然在 --enable-feature 后面,就具有以下注意事项

  1. 如果该功能有任何 API(Web API、代码接口等),API 规范可能会更改。
  2. 该功能的行为可能会更改。
  3. 它们可能会打破您可能对 Prometheus 有的某些假设。
    • 例如,查询不会超前于评估时间来查找样本的假设,这将通过 @ 修饰符和负偏移量打破。
  4. 它们可能不稳定,但我们当然会尽力保持它们的稳定。

这些注意事项使我们能够更大胆地进行实验,并更快地进行创新。一旦任何功能得到广泛使用,并且在其 API、行为和实现方面被认为是稳定的,它们可能会从禁用功能列表中移除并默认启用。如果我们发现任何功能不值得或已损坏,我们可能会完全删除它。如果启用某些功能被认为是 Prometheus 的重大突破性更改,则它将在下一个主要版本之前保持禁用状态。

请密切关注每个版本中的此列表,并尝试使用它们!

远程读取与流式传输相遇

新的 Prometheus 版本 2.13.0 已发布,与往常一样,它包含许多修复和改进。您可以在 此处 阅读更改内容。但是,有一个功能是某些项目和用户一直在等待的:分块、流式传输版本的远程读取 API

在本文中,我想深入探讨我们在远程协议中更改了什么,为什么要更改以及如何有效地使用它。

远程 API

自 1.x 版本以来,Prometheus 具有使用 远程 API 直接与其存储交互的能力。

此 API 允许第三方系统通过两种方法与指标数据进行交互

  • 写入 - 接收 Prometheus 推送的样本
  • 读取 - 从 Prometheus 拉取样本

Remote read and write architecture

两种方法都使用 HTTP,消息使用 protobufs 编码。两种方法的请求和响应都使用 snappy 压缩。

远程写入

这是将 Prometheus 数据复制到第三方系统中最流行的方式。在这种模式下,Prometheus 通过定期向给定端点发送一批样本来流式传输样本。

远程写入最近在 3 月份通过 基于 WAL 的远程写入 得到了大规模改进,这提高了可靠性和资源消耗。还值得注意的是,几乎所有 此处 提到的第三方集成都支持远程写入。

远程读取

读取方法不太常见。它在 2017 年 3 月(服务器端)添加,此后没有看到重大发展。

Prometheus 2.13.0 的发布包括修复已知 Read API 中的资源瓶颈。本文将重点介绍这些改进。

远程读取的关键思想是允许直接查询 Prometheus 存储 (TSDB),而无需 PromQL 评估。它类似于 PromQL 引擎用于从存储检索数据的 Querier 接口。

这本质上允许读取 Prometheus 收集的 TSDB 中的时间序列。远程读取的主要用例是

  • 在 Prometheus 的不同数据格式之间进行无缝 Prometheus 升级,因此让 Prometheus 从另一个 Prometheus 读取数据
  • Prometheus 能够从第三方长期存储系统(例如 InfluxDB)读取数据。
  • 第三方系统从 Prometheus 查询数据,例如 Thanos

远程读取 API 公开了一个简单的 HTTP 端点,该端点期望以下 protobuf 有效负载

message ReadRequest {
  repeated Query queries = 1;
}

message Query {
  int64 start_timestamp_ms = 1;
  int64 end_timestamp_ms = 2;
  repeated prometheus.LabelMatcher matchers = 3;
  prometheus.ReadHints hints = 4;
}

使用此有效负载,客户端可以请求与给定 matchers 匹配的特定序列,以及具有 endstart 的时间范围。

响应同样简单

message ReadResponse {
  // In same order as the request's queries.
  repeated QueryResult results = 1;
}

message Sample {
  double value    = 1;
  int64 timestamp = 2;
}

message TimeSeries {
  repeated Label labels   = 1;
  repeated Sample samples = 2;
}

message QueryResult {
  repeated prometheus.TimeSeries timeseries = 1;
}

远程读取返回具有原始样本(值和时间戳)的匹配时间序列。

问题陈述

对于如此简单的远程读取,存在两个关键问题。它易于使用和理解,但在我们定义的 protobuf 格式的单个 HTTP 请求中没有流式传输功能。其次,响应包括原始样本(float64 值和 int64 时间戳),而不是用于在 TSDB 内部存储指标的编码、压缩样本批次,称为“块”。

没有流式传输的远程读取的服务器算法是

  1. 解析请求。
  2. 从 TSDB 中选择指标。
  3. 对于所有解码的序列
    • 对于所有样本
      • 添加到响应 protobuf
  4. 编组响应。
  5. Snappy 压缩。
  6. 发回 HTTP 响应。

远程读取的整个响应必须以原始、未压缩的格式缓冲,以便在发送到客户端之前将其编组到可能非常大的 protobuf 消息中。整个响应也必须在客户端中完全缓冲,以便能够从接收到的 protobuf 中解组它。只有在此之后,客户端才能使用原始样本。

这意味着什么?这意味着请求(例如)仅 8 小时,匹配 10,000 个序列可能会占用客户端和服务器各自分配的最多 2.5GB 内存!

以下是 Prometheus 和 Thanos Sidecar(远程读取客户端)在远程读取请求期间的内存使用情况指标

Prometheus 2.12.0: RSS of single read 8h of 10k series

Prometheus 2.12.0: Heap-only allocations of single read 8h of 10k series

值得注意的是,查询 10,000 个序列不是一个好主意,即使对于 Prometheus 原生 HTTP query_range 端点也是如此,因为您的浏览器根本不会乐于获取、存储和渲染数百兆字节的数据。此外,对于仪表板和渲染目的而言,拥有如此多的数据是不切实际的,因为人类不可能读取它。这就是为什么通常我们设计的查询不超过 20 个序列。

这很好,但是一个非常常见的技术是以这样的方式组合查询,即查询返回 聚合 的 20 个序列,但是底层查询引擎必须访问可能数千个序列才能评估响应(例如,当使用 聚合运算符 时)。这就是为什么像 Thanos 这样的系统(除其他数据外,还使用来自远程读取的 TSDB 数据)经常出现请求繁重的情况。

解决方案

为了解释此问题的解决方案,了解 Prometheus 在查询时如何迭代数据很有帮助。核心概念可以在 QuerierSelect 方法返回的类型 SeriesSet 中显示。接口如下所示

// SeriesSet contains a set of series.
type SeriesSet interface {
    Next() bool
    At() Series
    Err() error
}

// Series represents a single time series.
type Series interface {
    // Labels returns the complete set of labels identifying the series.
    Labels() labels.Labels
    // Iterator returns a new iterator of the data of the series.
    Iterator() SeriesIterator
}

// SeriesIterator iterates over the data of a time series.
type SeriesIterator interface {
    // At returns the current timestamp/value pair.
    At() (t int64, v float64)
    // Next advances the iterator by one.
    Next() bool
    Err() error
}

这些接口集允许进程内部的“流式”流程。我们不再需要预先计算的保存样本的序列列表。使用此接口,每个 SeriesSet.Next() 实现都可以按需获取序列。以类似的方式,在每个序列中,我们也可以分别通过 SeriesIterator.Next 动态获取每个样本。

根据此约定,Prometheus 可以最大限度地减少分配的内存,因为 PromQL 引擎可以最佳地迭代样本以评估查询。同样,TSDB 以一种从文件系统中存储的块中逐个最佳地获取序列的方式实现 SeriesSet,从而最大限度地减少分配。

这对于远程读取 API 非常重要,因为我们可以重用相同的流式传输模式,方法是将响应的一部分以单个序列的几个块的形式发送给客户端。由于 protobuf 没有原生分隔逻辑,我们 扩展了 proto 定义,以允许发送一组小的协议缓冲区消息,而不是单个巨大的消息。我们将此模式称为 STREAMED_XOR_CHUNKS 远程读取,而旧模式称为 SAMPLES。扩展协议意味着 Prometheus 不再需要缓冲整个响应。相反,它可以顺序处理每个序列,并为每个 SeriesSet.Next 或一批 SeriesIterator.Next 迭代发送单个帧,从而有可能为下一个序列重用相同的内存页!

现在,STREAMED_XOR_CHUNKS 远程读取的响应是一组 Protobuf 消息(帧),如下所示

// ChunkedReadResponse is a response when response_type equals STREAMED_XOR_CHUNKS.
// We strictly stream full series after series, optionally split by time. This means that a single frame can contain
// partition of the single series, but once a new series is started to be streamed it means that no more chunks will
// be sent for previous one.
message ChunkedReadResponse {
  repeated prometheus.ChunkedSeries chunked_series = 1;
}

// ChunkedSeries represents single, encoded time series.
message ChunkedSeries {
  // Labels should be sorted.
  repeated Label labels = 1 [(gogoproto.nullable) = false];
  // Chunks will be in start time order and may overlap.
  repeated Chunk chunks = 2 [(gogoproto.nullable) = false];
}

如您所见,帧不再包含原始样本。这是我们做的第二个改进:我们在消息中发送以块批处理的样本(请观看 此视频 以了解有关块的更多信息),这些块与我们存储在 TSDB 中的块完全相同。

我们最终得到了以下服务器算法

  1. 解析请求。
  2. 从 TSDB 中选择指标。
  3. 对于所有序列
    • 对于所有样本
      • 编码为块
        • 如果帧 >= 1MB;则中断
    • 编组 ChunkedReadResponse 消息。
    • Snappy 压缩
    • 发送消息

您可以在 此处 找到完整的设计。

基准测试

这种新方法的性能与旧解决方案相比如何?

让我们比较 Prometheus 2.12.02.13.0 之间的远程读取特性。对于本文开头介绍的初始结果,我使用 Prometheus 作为服务器,Thanos sidecar 作为远程读取的客户端。我通过使用 grpcurl 对 Thanos sidecar 运行 gRPC 调用来调用测试远程读取请求。测试是在我的笔记本电脑 (Lenovo X1 16GB, i7 8th) 上使用 docker 中的 Kubernetes (使用 kind) 执行的。

数据是人工生成的,代表高度动态的 10,000 个序列(最坏情况)。

完整的测试平台可在 thanosbench repo 中找到。

内存

没有流式传输

Prometheus 2.12.0: Heap-only allocations of single read 8h of 10k series

具有流式传输

Prometheus 2.13.0: Heap-only allocations of single read 8h of 10k series

减少内存是我们解决方案的主要目标。Prometheus 在整个请求期间缓冲大约 50MB 的内存,而不是分配 GB 的内存,而 Thanos 的内存使用量仅为边际内存使用量。由于流式传输的 Thanos gRPC StoreAPI,sidecar 现在是一个非常简单的代理。

此外,我尝试了不同的时间范围和序列数量,但正如预期的那样,我一直看到 Prometheus 的最大分配量为 50MB,而 Thanos 的分配量几乎不可见。这证明我们的远程读取每个请求使用恒定的内存,无论您请求多少样本。每个请求分配的内存也大大减少了数据基数的影响,因此像以前一样获取的序列数量也减少了影响。

这有助于更轻松地根据用户流量进行容量规划,并借助并发限制。

CPU

没有流式传输

Prometheus 2.12.0: CPU time of single read 8h of 10k series

具有流式传输

Prometheus 2.13.0: CPU time of single read 8h of 10k series

在我的测试中,CPU 使用率也得到了提高,CPU 时间减少了 2 倍。

延迟

由于流式传输和更少的编码,我们还实现了降低远程读取请求延迟。

具有 10,000 个序列的 8 小时范围的远程读取请求延迟

2.12.0:平均时间 2.13.0:平均时间
实际时间 0m34.701s 0m8.164s
用户时间 0m7.324s 0m8.181s
系统时间 0m1.172s 0m0.749s

以及 2 小时的时间范围

2.12.0:平均时间 2.13.0:平均时间
实际时间 0m10.904s 0m4.145s
用户时间 0m6.236s 0m4.322s
系统时间 0m0.973s 0m0.536s

除了 ~2.5 倍的延迟降低外,响应会立即流式传输,而非流式传输版本中,客户端延迟为 27 秒(实际时间 减去 用户时间),仅用于 Prometheus 和 Thanos 端的处理和编组。

兼容性

远程读取以向后和向前兼容的方式扩展。这要归功于 protobuf 和 accepted_response_types 字段,旧服务器会忽略该字段。同时,如果较旧的客户端未提供 accepted_response_types,则服务器也可以正常工作,并假定为旧的 SAMPLES 远程读取。

远程读取协议以向后和向前兼容的方式扩展

  • v2.13.0 之前的 Prometheus 将安全地忽略较新客户端提供的 accepted_response_types 字段,并假定为 SAMPLES 模式。
  • v2.13.0 之后的 Prometheus 将为未提供 accepted_response_types 参数的旧客户端默认为 SAMPLES 模式。

用法

要在 Prometheus v2.13.0 中使用新的流式远程读取,第三方系统必须将 accepted_response_types = [STREAMED_XOR_CHUNKS] 添加到请求中。

然后,Prometheus 将流式传输 ChunkedReadResponse 而不是旧消息。每个 ChunkedReadResponse 消息都遵循 varint 大小和固定大小的大端 uint32,用于 CRC32 Castagnoli 校验和。

对于 Go,建议使用 ChunkedReader 直接从流中读取。

请注意,storage.remote.read-sample-limit 标志不再适用于 STREAMED_XOR_CHUNKSstorage.remote.read-concurrent-limit 像以前一样工作。

还有一个新的选项 storage.remote.read-max-bytes-in-frame,用于控制每个消息的最大大小。建议将其保持为默认值 1MB,因为 Google 建议将 protobuf 消息保持为 不大于 1MB

如前所述,Thanos 从此改进中获益匪浅。流式远程读取已添加到 v0.7.0 中,因此,只要将 Thanos sidecar 与 Prometheus 2.13.0 或更高版本一起使用,此版本或任何后续版本都将自动使用流式远程读取。

下一步

2.13.0 版本引入了扩展的远程读取和 Prometheus 服务器端实现,但是,在撰写本文时,仍然有一些项目需要完成,以便充分利用扩展的远程读取协议

总结

总而言之,分块、流式远程读取的主要优点是

  • 客户端和服务器都能够使用实际上恒定的每个请求内存大小。这是因为 Prometheus 在远程读取期间仅发送单个小帧,而不是整个响应。这极大地帮助了容量规划,特别是对于像内存这样不可压缩的资源。
  • Prometheus 服务器在远程读取期间不再需要将块解码为原始样本。客户端的编码也是如此,如果系统重用原生 TSDB XOR 压缩(如 Thanos 所做的那样)。

与往常一样,如果您有任何问题或反馈,请随时在 GitHub 上提交工单或在邮件列表中提问。

ForgeRock 访谈

继续我们对 Prometheus 用户进行的一系列访谈,ForgeRock 的 Ludovic Poitou 谈论了他们的监控之旅。

您能介绍一下您自己以及 ForgeRock 是做什么的吗?

我是 Ludovic Poitou,ForgeRock 的产品管理总监,位于法国格勒诺布尔附近。ForgeRock 是一家国际身份和访问管理软件公司,拥有 500 多名员工,于 2010 年在挪威成立,现在总部位于美国旧金山。我们提供解决方案,以保护与客户、员工、设备和事物的每一次在线互动。我们拥有 800 多家客户,从金融公司到政府服务部门。

您在 Prometheus 之前的监控经验是什么?

ForgeRock Identity Platform 一直提供监控接口。但是该平台由 4 个主要产品组成,每个产品都有不同的选项。例如,Directory Services 产品通过 SNMP、JMX 或 LDAP 甚至最新版本中的 HTTP 上的 RESTful API 提供监控信息。其他产品只有 REST 或 JMX。因此,监控整个平台很复杂,并且需要能够集成这些协议的工具。

您为什么决定关注 Prometheus?

我们需要为所有产品提供一个单一且通用的监控接口,同时保持现有接口的向后兼容性。

我们开始使用 DropWizard 在所有产品中收集指标。与此同时,我们开始将这些产品迁移到云端,并在 Docker 和 Kubernetes 中运行它们。因此,Prometheus 因其与 Kubernetes 的集成、部署的简易性以及 Grafana 的集成而变得显而易见。我们还研究了 Graphite,虽然我们也在我们的产品中添加了对它的支持,但我们的客户几乎没有使用它。

您是如何过渡的?

我们的一些产品已经在使用 DropWizard 库,我们已决定在所有产品中使用一个通用库,因此 DropWizard 是为仪表代码进行检测的显而易见的选择。但是很快,我们就遇到了数据模型的问题。Prometheus 接口使用维度,而我们倾向于为指标使用分层模型。我们还开始使用 Micrometer,并很快遇到了一些限制。因此,我们最终构建了一个自定义实现,以使用 Micrometer 接口收集我们的指标。我们调整了 DropWizard Metrics 以满足我们的要求,并对 DropWizard Prometheus 导出器进行了调整。现在,通过单个仪表,我们可以以维度或分层方式公开指标。然后,我们开始构建示例 Grafana 仪表板,我们的客户可以安装和自定义这些仪表板,以拥有他们自己的监控视图和警报。

Access Management ForgeRock's Grafana dashboard

我们确实继续提供以前的接口,但我们强烈建议我们的客户使用 Prometheus 和 Grafana。

自切换以来,您看到了哪些改进?

第一个好处来自我们的质量工程团队。当他们开始测试我们的 Prometheus 支持和不同的指标时,他们开始默认在所有压力和性能测试中启用它。他们开始为特定测试自定义 Grafana 仪表板。此后不久,他们开始突出显示并指出各种指标来解释一些性能问题。

在重现问题以便理解和修复它们时,我们的工程团队也使用了 Prometheus,并扩展了一些仪表板。整个过程为我们带来了更好的产品,并让我们更好地理解哪些指标对于客户的监控和可视化至关重要。

您认为 ForgeRock 和 Prometheus 的未来会怎样?

ForgeRock 已开始努力将其产品和解决方案作为服务提供。随着这一举措,监控和警报变得更加关键,当然,我们的监控基础设施是基于 Prometheus 的。我们目前有两个级别的监控,每个租户一个级别,我们在其中使用 Prometheus 来收集有关一个客户环境的数据,并且我们可以为该客户公开一组指标。但是,我们还构建了一个中央 Prometheus 服务,其中推送来自所有已部署租户的指标,以便我们的 SRE 团队可以真正了解所有客户环境的运行情况和方式。总的来说,我想说 Prometheus 已成为我们的主要监控服务,它为我们的本地客户以及我们自己作为服务运行的解决方案提供服务。

Hostinger 访谈

继续我们对 Prometheus 用户进行的一系列访谈,Hostinger 的 Donatas Abraitis 谈论了他们的监控之旅。

您能介绍一下您自己以及 Hostinger 是做什么的吗?

我是 Donatas Abraitis,Hostinger 的系统工程师。顾名思义,Hostinger 是一家托管公司。自 2004 年以来,我们拥有约 3000 万客户,其中包括 000webhost.com 项目 - 免费的网站托管提供商。

您在 Prometheus 之前的监控经验是什么?

当 Hostinger 还是一家很小的公司时,市场上只有 Nagios、Cacti 和 Ganglia 作为开源监控工具。这就像告诉年轻人什么是软盘驱动器一样,但是 Nagios 和 Cacti 今天仍在开发周期中。

即使没有自动化工具。Bash + Perl 完成了这项工作。如果您想扩展您的团队和您自己,则永远不应忽略自动化。没有自动化 - 涉及更多人工手动工作。

当时大约有 150 台物理服务器。相比之下,直到今天,我们拥有大约 2000 台服务器,包括虚拟机和物理机。

对于网络设备,SNMP 仍然被广泛使用。随着“白盒”交换机的兴起,SNMP 变得不再那么必要,因为可以安装常规工具。

您可以运行 node_exporter 或交换机内部的任何其他导出器来公开您需要的任何指标,并使用人类可读的格式,而不是 SNMP。美丽胜于丑陋,对吗?

我们使用 CumulusOS,在我们的案例中,它主要是 x86,因此绝对可以运行任何类型的 Linux 组件。

您为什么决定关注 Prometheus?

在 2015 年,当我们开始自动化所有可以自动化的事物时,我们将 Prometheus 引入了生态系统。最初,我们有一个单独的监控主机,Alertmanager、Pushgateway、Grafana、Graylog 和 rsyslogd 在其中运行。

我们还评估了 TICK(Telegraf/InfluxDB/Chronograf/Kapacitor)堆栈,但我们对它们不满意,因为当时功能有限,并且 Prometheus 在许多方面看起来更简单、更成熟以实现。

您是如何过渡的?

在从旧的监控堆栈 (NCG - Nagios/Cacti/Ganglia) 过渡期间,我们同时使用了这两个系统,最终,我们仅依赖 Prometheus。

我们有大约 25 个社区指标导出器 + 一些自定义编写的导出器,例如我们机群中的 lxc_exporter。主要我们使用 textfile 收集器公开自定义的业务相关指标。

自切换以来,您看到了哪些改进?

新的设置将我们的时间分辨率从 5 分钟提高到 15 秒,这使我们能够进行细粒度和相当深入的分析。甚至平均检测时间 (MTTD) 也减少了 4 倍。

您认为 Hostinger 和 Prometheus 的未来会怎样?

自从 2015 年以来,我们的基础设施增长了 N 倍,主要的瓶颈变成了 Prometheus 和 Alertmanager。我们的 Prometheus 消耗大约 ~2TB 的磁盘空间。因此,如果我们重新启动或更改维护下的节点,我们会错过一段时间的监控数据。目前我们运行的是 Prometheus 2.4.2 版本,但在不久的将来,我们计划升级到 2.6。特别是我们对 性能 和 WAL 相关功能感兴趣。Prometheus 重启大约需要 10-15 分钟。不可接受。另一个问题是,如果单个位置发生故障,我们也会错过监控数据。因此,我们决定实施高可用性监控基础设施:两个 Prometheus 节点,两个位于不同大陆的 Alertmanager。

我们的主要可视化工具是 Grafana。至关重要的是,如果主 Prometheus 节点发生故障,Grafana 可以查询备份 Prometheus 节点。这很简单 - 在前面放置 HAProxy 并本地接受连接即可。

另一个问题:我们如何阻止用户(开发人员和其他内部员工)滥用仪表板,使 Prometheus 节点过载。

或者,如果主节点发生故障,备份节点也会过载 - 惊群效应问题

为了达到期望的状态,我们给了 Trickster 一个机会。这令人难以置信地加快了仪表板加载时间。它缓存时间序列。在我们的案例中,缓存位于内存中,但是还有更多存储位置的选择。即使主节点发生故障,并且您刷新仪表板,Trickster 也不会查询第二个节点以获取其在内存中缓存的时间序列。Trickster 位于 Grafana 和 Prometheus 之间。它仅与 Prometheus API 通信。

Hostinger Graphing Architecture

Prometheus 节点是独立的,而 Alertmanager 节点形成一个集群。如果两个 Alertmanager 都看到相同的警报,它们将进行重复数据删除,并触发一次而不是多次。

我们计划运行大量的 blackbox_exporters 并监控每个 Hostinger 客户的网站,因为任何无法监控的东西都无法评估。

我们期待在未来实施更多的 Prometheus 节点,以便在多个 Prometheus 实例之间分片节点。这将使我们能够避免如果每个区域的一个实例发生故障时出现瓶颈。

子查询支持

简介

正如标题所示,子查询是查询的一部分,它允许您在查询中执行范围查询,这在以前是不可能的。这是一个长期存在的功能请求:prometheus/prometheus/1227

用于子查询支持的 pull request 最近已合并到 Prometheus 中,将在 Prometheus 2.7 中可用。让我们在下面了解更多关于它的信息。

动机

有时,在某些情况下,您希望使用较低分辨率/范围(例如 5m)的 rate 来发现问题,同时聚合更高范围(例如 1hmax_over_time)的此数据。

以前,对于单个 PromQL 查询,以上是不可能的。如果您希望对查询进行范围选择以用于您的警报规则或绘图,则需要根据该查询制定记录规则,并对记录规则创建的指标执行范围选择。示例:max_over_time(rate(my_counter_total[5m])[1h])

当您想要获得跨越数天或数周的数据的快速结果时,可能需要等待一段时间,直到您的记录规则中有足够的数据才能使用它。忘记添加记录规则可能会令人沮丧。并且为查询的每个步骤创建记录规则将是乏味的。

借助子查询支持,所有等待和挫败感都得到了解决。

子查询

子查询类似于 /api/v1/query_range API 调用,但嵌入在即时查询中。子查询的结果是范围向量。

Prometheus 团队在慕尼黑举行的 Prometheus Dev Summit 2018 上就子查询的语法达成共识。这些是 关于子查询支持的峰会记录,以及用于实现子查询支持的语法的简要 设计文档

<instant_query> '[' <range> ':' [ <resolution> ] ']' [ offset <duration> ]
  • <instant_query> 等效于 /query_range API 中的 query 字段。
  • <range>offset <duration> 类似于范围选择器。
  • <resolution> 是可选的,它等效于 /query_range API 中的 step

当未指定分辨率时,全局评估间隔将用作子查询的默认分辨率。此外,子查询的步长是独立对齐的,并且不依赖于父查询的评估时间。

示例

min_over_time 函数内部的子查询以 1 分钟的分辨率,返回过去 30 分钟内 http_requests_total 指标的 5 分钟速率。这等同于使用 query=rate(http_requests_total[5m]), end=<now>, start=<now>-30m, step=1m 参数调用 /query_range API,并取所有接收值的最小值。

min_over_time( rate(http_requests_total[5m])[30m:1m] )

分解

  • rate(http_requests_total[5m])[30m:1m] 是子查询,其中 rate(http_requests_total[5m]) 是要执行的查询。
  • rate(http_requests_total[5m]) 的执行范围从 start=<now>-30mend=<now>,分辨率为 1m。请注意,start 时间与 1m 的步长独立对齐(对齐的步长为 0m 1m 2m 3m ...)。
  • 最后,以上所有评估的结果都将传递给 min_over_time()

下面是一个嵌套子查询以及默认分辨率的用法示例。最内层的子查询获取 distance_covered_meters_total 在一段时间范围内的速率。我们使用它来获取速率的 deriv(),同样也是在一个时间范围内。最后取所有导数的最大值。请注意,最内层子查询的 <now> 时间是相对于 deriv() 上的外部子查询的评估时间而言的。

max_over_time( deriv( rate(distance_covered_meters_total[1m])[5m:1m] )[10m:] )

在大多数情况下,您将需要默认的评估间隔,即规则默认评估的间隔。自定义分辨率在您希望降低/提高计算频率的情况下会很有帮助,例如,您可能希望降低昂贵查询的计算频率。

结语

虽然子查询非常方便,可以用来代替记录规则,但不必要地使用它们会带来性能影响。繁重的子查询最终应转换为记录规则以提高效率。

也不建议在记录规则内部使用子查询。如果您确实需要在记录规则中使用子查询,请创建更多记录规则。

Presslabs 访谈

继续我们的 Prometheus 用户系列访谈,Presslabs 的 Mile Rosu 谈论了他们的监控之旅。

您能介绍一下您自己以及 Presslabs 是做什么的吗?

Presslabs 是一个高性能的托管 WordPress 托管平台,面向出版商、企业品牌和数字机构,他们力求始终 100% 为其网站访问者提供无缝体验。

最近,我们为我们的核心产品——WordPress 商业智能开发了一个创新组件。用户现在可以在综合仪表板中获得实时的、可操作的数据,以支持从问题到部署的快速流程以及站点的持续改进。

我们支持每月无缝交付高达 20 亿的页面浏览量,在一支完全致力于为要求苛刻的客户提供托管 WordPress 托管的 100 台机器的集群上。

我们目前正致力于为全球 WordPress 出版商带来最佳体验。在这个旅程中,Kubernetes 促进了我们走向即将到来的高可用性 WordPress 托管基础设施标准的道路。

您在 Prometheus 之前的监控经验是什么?

我们早在 2009 年就开始构建我们的 WordPress 托管平台。当时,我们使用的是 Munin,一个开源的系统、网络和基础设施监控系统,它可以执行我们所需的所有操作:暴露、收集、聚合、告警和可视化指标。虽然它的性能良好,但每分钟收集一次,每 5 分钟聚合一次对我们来说太慢了,因此它生成的输出不足以正确分析我们平台上的事件。

Graphite 是我们的第二个选择,它解决了 Munin 解决的时间挑战。我们在组合中添加了 collectd 以暴露指标,并使用 Graphite 来收集和聚合它。

然后我们制作了 Viz,一个我们用 JavaScript 和 Python 编写的用于可视化和告警的工具。但是,我们停止积极使用这项服务,因为维护它需要大量工作,而 Grafana 从其第一个版本开始就很好地替代了它。

Presslab's Viz

自 2017 年下半年以来,我们的 Presslabs 平台进入了大规模转型阶段。主要变化之一是我们迁移到 Kubernetes,这暗示了对高性能监控系统的需求。那时我们开始关注 Prometheus,我们从那时起就一直在使用它,并计划将其集成到我们在新平台上的所有服务中,作为提取和暴露指标的核心组件。

您为什么决定关注 Prometheus?

我们在 2014 年巴塞罗那 Velocity Europe 大会上与 Soundcloud 的一个工程师团队交谈后,开始考虑 Prometheus。他们展示的好处足以让我们尝试一下 Prometheus。

您是如何过渡的?

我们仍处于转型过程中,因此我们并行运行着两个系统——Prometheus 和 Graphite-collectd 组合。对于客户端仪表板和我们的核心服务,我们使用 Prometheus,但是,对于客户端站点,我们仍然使用 Graphite-collectd。在这两者之上,都有一个 Grafana 用于可视化。

Presslab's Redis Grafana dashboards

Prometheus 文档、Github 问题和源代码是集成 Prometheus 的首选资源;当然,StackOverflow 为这个过程增添了一些趣味,它满足了我们的许多好奇心。

Prometheus 唯一的问题是我们无法为某些指标获得长期存储。我们的托管基础设施平台需要存储使用情况指标,例如页面浏览量,至少一年。但是,自从我们使用 Prometheus 以来,Prometheus 的前景已经大大改善,我们仍然需要测试可能的解决方案。

自切换以来,您看到了哪些改进?

自从切换到 Prometheus 以来,我们注意到与我们以前使用的任何其他替代方案相比,资源使用量显着减少。此外,它易于安装,因为它与 Kubernetes 的自动集成节省了大量时间。

您认为 Presslabs 和 Prometheus 的未来会怎样?

我们对 Prometheus 有宏伟的计划,因为我们正在努力用我们新基础设施上的 Prometheus Operator 替换我们现在使用的 Prometheus Helm chart。该实现将提供平台客户的隔离,因为我们将为有限数量的网站分配一个专用的 Prometheus 服务器。作为我们 Kubernetes 化 WordPress 工作的一部分,我们已经在为此努力。

我们还在努力以 Prometheus 格式导出 WordPress 指标。Grafana 将继续存在,因为它与 Prometheus 携手解决了可视化需求。

Prometheus 在 CNCF 内毕业

我们很高兴地宣布,截至今天,Prometheus 在 CNCF 内毕业了。

Prometheus 是有史以来第二个达到这一级别的项目。通过让 Prometheus 毕业,CNCF 表明它对我们的代码和功能迭代速度、我们的成熟度和稳定性以及我们的治理和社区流程充满信心。对于任何在内部讨论监控工具选择的人来说,这也可以作为外部质量验证。

自从达到孵化级别以来,发生了很多事情;其中一些突出

  • 我们完全重写了我们的存储后端,以支持服务中的高流失率
  • 我们在稳定性方面进行了大力推动,尤其是 2.3.2 版本
  • 我们开始推动文档编写,特别关注使 Prometheus 的采用和加入社区变得更容易

尤其最后一点很重要,因为我们目前正进入采用的第四阶段。这些阶段的采用者是

  1. 积极寻找最佳监控方案的以监控为中心的用户
  2. 面临监控环境无法跟上其规模的超大规模用户
  3. 从小型企业到财富 50 强企业都在重新构建其监控基础设施
  4. 缺乏资金和/或资源来专注于监控,但从各个地方听到 Prometheus 的好处的用户

展望未来,我们预计更广泛的采用,并仍然致力于处理未来的规模,就在今天。

实施自定义服务发现

实施自定义服务发现

Prometheus 包含许多服务发现 (SD) 系统的内置集成,例如 Consul、Kubernetes 和公共云提供商,例如 Azure。但是,我们无法为所有服务发现选项提供集成实现。Prometheus 团队已经在支持当前的 SD 集成集方面捉襟见肘,因此为每个可能的 SD 选项维护集成是不可行的。在许多情况下,当前的 SD 实现是由团队外部的人员贡献的,然后没有得到很好的维护或测试。我们希望承诺仅提供与我们知道可以维护并且按预期工作的服务发现机制的直接集成。因此,目前暂停新的 SD 集成。

但是,我们知道仍然有希望能够与其他 SD 机制(例如 Docker Swarm)集成的需求。最近,一个小的代码更改以及一个示例被提交到 Prometheus 存储库中 目录下的文档中,用于实现自定义服务发现集成,而无需将其合并到主 Prometheus 二进制文件中。代码更改允许我们使用内部 Discovery Manager 代码来编写另一个可执行文件,该文件与新的 SD 机制交互并输出与 Prometheus 的 file_sd 兼容的文件。通过将 Prometheus 和我们的新可执行文件放在同一位置,我们可以配置 Prometheus 以读取我们可执行文件的 file_sd 兼容输出,从而从该服务发现机制中抓取目标。将来,这将使我们能够将 SD 集成移出主 Prometheus 二进制文件,以及将稳定的 SD 集成(使用适配器)移动到 Prometheus discovery 包中。

使用 file_sd 的集成(例如使用适配器代码实现的集成)在此处 列出

让我们看一下示例代码。

适配器

首先,我们有文件 adapter.go。您可以直接复制此文件用于您的自定义 SD 实现,但了解这里发生了什么是很有用的。

// Adapter runs an unknown service discovery implementation and converts its target groups
// to JSON and writes to a file for file_sd.
type Adapter struct {
    ctx     context.Context
    disc    discovery.Discoverer
    groups  map[string]*customSD
    manager *discovery.Manager
    output  string
    name    string
    logger  log.Logger
}

// Run starts a Discovery Manager and the custom service discovery implementation.
func (a *Adapter) Run() {
    go a.manager.Run()
    a.manager.StartCustomProvider(a.ctx, a.name, a.disc)
    go a.runCustomSD(a.ctx)
}

适配器使用 discovery.Manager 在 goroutine 中实际启动我们的自定义 SD 提供程序的 Run 函数。Manager 有一个通道,我们的自定义 SD 将向其发送更新。这些更新包含 SD 目标。groups 字段包含我们的自定义 SD 可执行文件从我们的 SD 机制中知道的所有目标和标签。

type customSD struct {
    Targets []string          `json:"targets"`
    Labels  map[string]string `json:"labels"`
}

customSD 结构的存在主要是为了帮助我们将 Prometheus 内部的 targetgroup.Group 结构转换为 file_sd 格式的 JSON。

运行时,适配器将监听通道,以接收来自我们的自定义 SD 实现的更新。收到更新后,它会将 targetgroup.Groups 解析为另一个 map[string]*customSD,并将其与 Adapter 的 groups 字段中存储的内容进行比较。如果两者不同,我们将新组分配给 Adapter 结构,并将它们作为 JSON 写入输出文件。请注意,此实现假定 SD 实现通过通道发送的每个更新都包含 SD 知道的所有目标组的完整列表。

自定义 SD 实现

现在我们要实际使用适配器来实现我们自己的自定义 SD。一个完整的工作示例在同一个示例目录 这里

在这里您可以看到我们正在导入适配器代码 "github.com/prometheus/prometheus/documentation/examples/custom-sd/adapter" 以及其他一些 Prometheus 库。为了编写自定义 SD,我们需要 Discoverer 接口的实现。

// Discoverer provides information about target groups. It maintains a set
// of sources from which TargetGroups can originate. Whenever a discovery provider
// detects a potential change, it sends the TargetGroup through its channel.
//
// Discoverer does not know if an actual change happened.
// It does guarantee that it sends the new TargetGroup whenever a change happens.
//
// Discoverers should initially send a full set of all discoverable TargetGroups.
type Discoverer interface {
    // Run hands a channel to the discovery provider(consul,dns etc) through which it can send
    // updated target groups.
    // Must returns if the context gets canceled. It should not close the update
    // channel on returning.
    Run(ctx context.Context, up chan<- []*targetgroup.Group)
}

我们实际上只需要实现一个函数,Run(ctx context.Context, up chan<- []*targetgroup.Group)。这是 Adapter 代码中的管理器将在 goroutine 中调用的函数。Run 函数使用上下文来了解何时退出,并传递一个通道以发送其目标组的更新。

查看提供的示例中 Run 函数,我们可以看到一些关键的事情正在发生,我们需要在另一个 SD 的实现中做这些事情。我们定期进行调用,在本例中是 Consul(为了本示例,假设还没有内置的 Consul SD 实现),并将响应转换为一组 targetgroup.Group 结构。由于 Consul 的工作方式,我们必须首先调用以获取所有已知服务,然后每个服务再调用一次以获取有关所有后备实例的信息。

请注意在循环上方的注释,该注释调用 Consul 获取每个服务

// Note that we treat errors when querying specific consul services as fatal for for this
// iteration of the time.Tick loop. It's better to have some stale targets than an incomplete
// list of targets simply because there may have been a timeout. If the service is actually
// gone as far as consul is concerned, that will be picked up during the next iteration of
// the outer loop.

通过这一点,我们表示,如果我们无法获得所有目标的信息,那么最好根本不发送任何更新,而不是发送不完整的更新。我们宁愿在短时间内拥有一个过时的目标列表,并防止由于诸如瞬时网络问题、进程重启或 HTTP 超时等原因导致的误报。如果我们确实碰巧从 Consul 获得了关于每个目标的响应,我们会将所有这些目标发送到通道上。还有一个辅助函数 parseServiceNodes,它接受单个服务的 Consul 响应,并从带有标签的后备节点创建一个目标组。

使用当前示例

在开始编写您自己的自定义 SD 实现之前,在查看代码后运行当前示例可能是一个好主意。为了简单起见,在处理示例代码时,我通常使用 docker-compose 将 Consul 和 Prometheus 都作为 Docker 容器运行。

docker-compose.yml

version: '2'
services:
consul:
    image: consul:latest
    container_name: consul
    ports:
    - 8300:8300
    - 8500:8500
    volumes:
    - ${PWD}/consul.json:/consul/config/consul.json
prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
    - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
    - 9090:9090

consul.json

{
"service": {
    "name": "prometheus",
    "port": 9090,
    "checks": [
    {
        "id": "metrics",
        "name": "Prometheus Server Metrics",
        "http": "http://prometheus:9090/metrics",
        "interval": "10s"
    }
    ]

}
}

如果我们通过 docker-compose 启动两个容器,然后运行示例 main.go,我们将查询 localhost:8500 上的 Consul HTTP API,并且 filesd 兼容的文件将写入为 customsd.json。我们可以配置 Prometheus 通过 file_sd 配置来拾取此文件

scrape_configs:
  - job_name: "custom-sd"
    scrape_interval: "15s"
    file_sd_configs:
    - files:
      - /path/to/custom_sd.json

Datawire 访谈

继续我们的 Prometheus 用户系列访谈,Datawire 的 Richard Li 谈论了他们如何过渡到 Prometheus。

您能介绍一下您自己以及 Datawire 是做什么的吗?

在 Datawire,我们制作开源工具,帮助开发人员在 Kubernetes 上更快地编写代码。我们的项目包括 Telepresence,用于 Kubernetes 服务的本地开发;Ambassador,一个基于 Envoy Proxy 构建的 Kubernetes 原生 API 网关;以及 Forge,一个构建/部署系统。

我们在 AWS 中的 Kubernetes 中运行许多任务关键型云服务,以支持我们的开源工作。这些服务支持诸如每天动态配置数十个 Kubernetes 集群的用例,这些集群然后被我们的自动化测试基础设施使用。

您在 Prometheus 之前的监控经验是什么?

我们使用了 AWS CloudWatch。这很容易设置,但是我们发现,随着我们采用更分布式的开发模型(微服务),我们想要更多的灵活性和控制权。例如,我们希望每个团队都能够根据需要自定义其监控,而无需运营方面的帮助。

您为什么决定关注 Prometheus?

我们有两个主要要求。第一个是我们希望这里的每位工程师都能够对其服务拥有运营控制权和可见性。我们的开发模型在设计上是高度分散的,我们尽量避免工程师需要等待另一位工程师才能完成某项工作的情况。对于监控,我们希望我们的工程师能够对其指标基础设施具有很大的灵活性和控制权。我们的第二个要求是强大的生态系统。强大的生态系统通常意味着已建立(且有文档记录)的最佳实践、持续开发以及许多可以在您遇到困难时提供帮助的人。

Prometheus,特别是 Prometheus Operator,符合我们的要求。借助 Prometheus Operator,每个开发人员都可以根据需要创建自己的 Prometheus 实例,而无需运营方面的帮助(没有瓶颈!)。我们也是 CNCF 的成员,在 Kubernetes 和 Envoy 社区方面拥有丰富的经验,因此考虑 Prometheus 中的另一个 CNCF 社区是很自然的。

Datawire's Ambassador dashboards

您是如何过渡的?

我们知道我们想从将 Prometheus 与我们的 API 网关集成开始。我们的 API 网关使用 Envoy 进行代理,Envoy 使用 statsd 协议自动发出指标。我们安装了 Prometheus Operator(一些详细说明 在此处),并将其配置为开始从 Envoy 收集统计信息。我们还基于另一位 Ambassador 贡献者的一些工作设置了一个 Grafana 仪表板

自切换以来,您看到了哪些改进?

我们的工程师现在可以了解 L7 流量。我们还可以使用 Prometheus 来比较我们的金丝雀部署的延迟和吞吐量,从而使我们更有信心新版本的服务不会导致性能下降。

您认为 Datawire 和 Prometheus 的未来会怎样?

使用 Prometheus Operator 仍然有点复杂。我们需要为我们的服务团队找出运营最佳实践(何时部署 Prometheus?)。然后,我们需要教育我们的工程师了解这些最佳实践,并培训他们如何配置 Operator 以满足他们的需求。我们预计这将是一个实验领域,因为我们要弄清楚哪些方法有效,哪些方法无效。

Scalefastr 访谈

继续我们的 Prometheus 用户系列访谈,Scalefastr 的 Kevin Burton 谈论了他们如何使用 Prometheus。

您能介绍一下您自己以及 Scalefastr 是做什么的吗?

我叫 Kevin Burton,我是 Scalefastr 的 CEO。我的背景是分布式系统,我之前运营过 Datastreamer,这是一家构建了 PB 级分布式社交媒体爬虫和搜索引擎的公司。

在 Datastreamer,我们在基础设施方面遇到了可扩展性问题,并构建了一个基于 Debian、Elasticsearch、Cassandra 和 Kubernetes 的高性能集群。

我们发现我们的许多客户也在努力解决他们的基础设施问题,我很惊讶他们在 AWS 和 Google Cloud 上托管大量内容的花费有多高。

我们不断评估在云中运行的成本,对我们来说,我们的托管成本将是我们目前支付成本的 5-10 倍。

我们决定基于开源和云原生技术(如 Kubernetes、Prometheus、Elasticsearch、Cassandra、Grafana、Etcd 等)推出一个新的云平台。

我们目前正在为一些 PB 级的客户提供托管服务,并且本月正在软启动我们的新平台。

您在 Prometheus 之前的监控经验是什么?

在 Datastreamer,我们发现指标是我们快速迭代能力的关键。对我们平台的可观察性成为我们拥抱的东西,我们集成了 Dropwizard Metrics 等工具,以便轻松开发我们平台的分析。

我们构建了一个基于 KairosDB、Grafana 和我们自己的(简单的)可视化引擎的平台,这个平台在很长一段时间内都运行良好。

我们看到的 KairosDB 的主要问题是采用率和客户对 Prometheus 的需求。

此外,Prometheus 的优点在于对由项目本身或社区实施的导出器的支持。

对于 KairosDB,我们经常努力构建我们自己的导出器。与 Prometheus 相比,已经存在 KairosDB 的导出器的可能性相当低。

例如,KairosDB 有 CollectD 支持,但在 Debian 中不受很好的支持,并且 CollectD 存在实际的错误,阻止其在生产环境中可靠地工作。

使用 Prometheus,您可以非常快速地启动并运行(系统非常易于安装),并且您的平台有现成的导出器的可能性很高。

此外,我们预计一旦有像 Scalefastr 这样的托管平台将其作为标准化和受支持的产品集成,客户应用程序将开始标准化 Prometheus 指标。

了解您的应用程序性能至关重要,Prometheus 的高可扩展性对于实现这一点是必要的。

您为什么决定关注 Prometheus?

我们最初很好奇其他人是如何监控他们的 Kubernetes 和容器应用程序的。

容器的主要挑战之一是它们可以快速出现和消失,留下需要分析的日志和指标数据。

当我们看到人们成功地在生产环境中将 Prometheus 与容器优先架构一起使用时,以及对导出器和仪表板的支持,我们清楚地意识到我们应该将 Prometheus 作为我们的分析后端进行研究。

One of Scalefastr's Grafana dashboards

您是如何过渡的?

对于我们来说,过渡过程在某种程度上是轻松的,因为 Scalefastr 是一个全新的环境。

在大多数情况下,该架构是新的,限制因素很少。

我们的主要目标是在裸机上部署,但在现有和标准化的硬件之上构建云功能。

我们的想法是将我们集群中的所有分析都由 Prometheus 支持。

我们为客户提供他们自己的“管理”基础设施,其中包括 Prometheus、Grafana、Elasticsearch 和 Kibana 以及 Kubernetes 控制平面。我们使用 Ansible 编排这个系统,Ansible 处理初始机器设置(ssh、核心 Debian 软件包等)和基线配置。

然后我们部署 Prometheus、客户配置所需的所有导出器以及 Grafana 的仪表板。

我们发现有点问题的是,Grafana.com 上的一些仪表板是为 Prometheus 1.x 编写的,并且没有干净地移植到 2.x。事实证明,2.x 系列中只有少数函数不存在,其中许多函数只需要在这里和那里进行一些小的调整。此外,一些仪表板是为早期版本的 Grafana 编写的。

为了帮助解决这个问题,我们本周宣布了一个项目,旨在 标准化和改进 Prometheus 的仪表板,用于 Cassandra、Elasticsearch、操作系统以及 Prometheus 本身等工具。我们将其开源,并在上周 发布到 Github

我们希望这能让其他人更容易迁移到 Prometheus。

我们想要改进的一件事是自动将其与我们的 Grafana 后端同步,并且还将这些仪表板上传到 Grafana.com。

我们还发布了我们的 Prometheus 配置,以便标签与我们的 Grafana 模板正确配合使用。这允许您使用下拉菜单来选择更具体的指标,如集群名称、实例名称等。

Using template variables in Grafana dashboards

自切换以来,您看到了哪些改进?

易于部署、高性能和标准化的导出器使我们很容易切换。此外,后端相当容易配置(基本上,只有守护程序本身),并且没有太多移动部件,这使其成为一个容易的决定。

您认为 Scalefastr 和 Prometheus 的未来会怎样?

现在我们直接在裸机上部署 Elasticsearch 和 Cassandra。我们正在努力直接在 Kubernetes 之上的容器中运行它们,并努力使用容器存储接口 (CSI) 使之成为可能。

在我们这样做之前,我们需要让 Prometheus 服务发现工作起来,这是我们尚未尝试过的。目前,我们通过 Ansible 部署和配置 Prometheus,但这显然无法随着 Kubernetes 一起扩展(甚至无法工作),因为容器会随着我们的工作负载变化而出现和消失。

我们还在努力改进标准仪表板和告警。我们想要添加的功能之一(可能作为容器)是基于霍尔特-温特斯预测的告警支持。

这将从本质上使我们能够在严重的性能问题发生之前对其进行预测。而不是等到某些东西发生故障(如磁盘空间不足)才采取行动纠正它。

在一定程度上,Kubernetes 有助于解决这个问题,因为我们可以根据水位线向集群添加节点。一旦资源利用率过高,我们就可以自动扩展。

我们对 Prometheus 的未来感到非常兴奋,特别是现在我们正在 2.x 系列上前进,并且 CNCF 协作似乎进展顺利。

2017 年 CloudNativeCon 上的 Prometheus

2017 年 CloudNativeCon 上的 Prometheus

12 月 6 日星期三是奥斯汀 CloudNativeCon 的 Prometheus 日,我们为您准备了精彩的演讲和活动阵容。前往 Prometheus 沙龙,获取有关如何最好地监控 Kubernetes 的实践建议,参加一系列关于 Prometheus 各个方面的讲座,然后在 CNCF 展位与一些 Prometheus 开发人员一起闲逛,所有这些之后是 Prometheus 欢乐时光。继续阅读以了解更多详情...

宣布 Prometheus 2.0

宣布 Prometheus 2.0

大约一年半前,我们发布了 Prometheus 1.0 到野外。该版本标志着该项目的一个重要里程碑。我们已经实现了一套广泛的功能,这些功能构成了 Prometheus 简单而又极其强大的监控理念。

从那时起,我们添加和改进了各种服务发现集成,扩展了 PromQL,并试验了远程 API 的第一个迭代,以实现可插拔的长期存储解决方案。

但是,还有什么变化值得发布新的主要版本呢?

PromCon 2017 回顾

发生了什么

两周前,来自世界各地的 Prometheus 用户和开发人员齐聚慕尼黑,参加 PromCon 2017,这是围绕 Prometheus 监控系统的第二次会议。本次活动的目的是交流知识和最佳实践,并在使用 Prometheus 进行监控方面建立专业联系。谷歌慕尼黑办事处今年为我们提供了更大的空间,这使我们能够从 80 名增加到 220 名与会者,同时仍然售罄!

观看回顾视频以了解活动印象

带有新规则格式的 Prometheus 2.0 Alpha.3

今天,我们发布了 Prometheus 2.0 的第三个 alpha 版本。除了新存储层中的各种错误修复外,它还包含一些计划的重大更改。

标志更改

首先,我们迁移到了一个新的标志库,该库对标志使用更常见的双破折号 -- 前缀,而不是 Prometheus 迄今为止使用的单破折号。部署必须相应地进行调整。此外,此 alpha 版本中删除了一些标志。自 Prometheus 1.0.0 以来的完整列表是

  • web.telemetry-path
  • 所有 storage.remote.* 标志
  • 所有 storage.local.* 标志
  • query.staleness-delta
  • alertmanager.url

记录规则更改

告警和记录规则是 Prometheus 的关键功能之一。但它们也存在一些设计问题和缺少的功能,即

  • 所有规则都以相同的间隔运行。我们可以有一些繁重的规则,最好以 10 分钟的间隔运行,而有些规则可以以 15 秒的间隔运行。

  • 所有规则都是并发评估的,这实际上是 Prometheus 最古老的 开放错误。这有一些问题,最明显的一个是,如果您有很多规则,则每次评估间隔负载都会激增。另一个是,相互依赖的规则可能会被馈送过时的数据。例如

instance:network_bytes:rate1m = sum by(instance) (rate(network_bytes_total[1m]))

ALERT HighNetworkTraffic
  IF instance:network_bytes:rate1m > 10e6
  FOR 5m

在这里,我们正在对 instance:network_bytes:rate1m 发出告警,但 instance:network_bytes:rate1m 本身是由另一个规则生成的。只有在告警 HighNetworkTraffic 在记录 instance:network_bytes:rate1m 的当前值之后运行时,我们才能获得预期的结果。

  • 规则和告警要求用户学习另一种 DSL。

为了解决上述问题,规则分组早在很久之前就被提出,但直到最近才在 Prometheus 2.0 中作为一部分被实现。作为此实现的一部分,我们还将规则迁移到了知名的 YAML 格式,这也使得基于用户环境中的常见模式生成告警规则变得更加容易。

以下是新格式的外观

groups:
- name: my-group-name
  interval: 30s   # defaults to global interval
  rules:
  - record: instance:errors:rate5m
    expr: rate(errors_total[5m])
  - record: instance:requests:rate5m
    expr: rate(requests_total[5m])
  - alert: HighErrors
    # Expressions remain PromQL as before and can be spread over
    # multiple lines via YAML’s multi-line strings.
    expr: |
      sum without(instance) (instance:errors:rate5m)
      / 
      sum without(instance) (instance:requests:rate5m)
    for: 5m
    labels:
      severity: critical
    annotations:
      description: "stuff's happening with {{ $labels.service }}"      

每个组中的规则按顺序执行,并且您可以为每个组设置评估间隔。

由于此更改是破坏性的,我们将随 2.0 版本一起发布,并为 promtool 添加了一个迁移命令:promtool update rules <filenames>。转换后的文件会附加 .yml 后缀,并且您的 Prometheus 配置中的 rule_files 子句必须进行调整。

通过测试这个新的 alpha 版本,帮助我们向 Prometheus 2.0 稳定版本迈进!您可以在我们的 issue 跟踪器上报告错误,并通过我们的 社区渠道提供一般反馈。

L’Atelier Animation 访谈

继续我们对 Prometheus 用户的一系列访谈,L’Atelier Animation 的 Philippe Panaite 和 Barthelemy Stevens 讲述了他们如何将动画工作室从 Nagios、Graphite 和 InfluxDB 的混合方案切换到 Prometheus。

您能介绍一下您自己以及 L’Atelier Animation 是做什么的吗?

L’Atelier Animation 是一家位于加拿大美丽城市蒙特利尔的 3D 动画工作室。我们的第一部故事片 《Ballerina》(也称为《Leap》)于 2017 年在全球发行,预计今年晚些时候在美国上映。

我们目前正努力制作一部动画电视剧和我们的第二部故事片。 我们的基础设施包括大约 300 个渲染刀片服务器、150 个工作站和 20 个各种服务器。除了几台 Mac 电脑外,所有设备都运行在 Linux (CentOS) 上,没有一台 Windows 机器。

 

您在 Prometheus 之前的监控经验是什么?

最初我们采用了 NagiosGraphiteInfluxDB 的混合方案。最初的设置“还可以”,但没什么特别之处,而且过于复杂(移动部件太多)。

您为什么决定关注 Prometheus?

当我们将所有服务切换到 CentOS 7 时,我们开始寻找新的监控解决方案,而 Prometheus 因多种原因而出现,但最重要的是

  • Node Exporter:凭借其自定义功能,我们可以从客户端获取任何数据
  • SNMP 支持:消除了对第三方 SNMP 服务的需求
  • 告警系统:再见 Nagios
  • Grafana 支持

您是如何过渡的?

当我们完成第一部电影时,我们有一段停工期,这是我们 IT 部门进行重大变更的绝佳机会。我们决定彻底清除我们的整个监控系统,因为它没有我们期望的那么好。

最重要的部分之一是监控网络设备,因此我们首先配置了 snmp_exporter 以从我们的一台交换机获取数据。导出器对 NetSNMP 的调用在 CentOS 下有所不同,因此我们不得不重新编译一些二进制文件,我们在这里和那里遇到了一些小问题,但在 Robust Perception 的 Brian Brazil 的帮助下,我们很快就解决了所有问题。一旦我们让 snmp_exporter 工作起来,我们就能够轻松添加新设备并获取 SNMP 数据。我们现在在 Grafana 中监控了我们的核心网络(包括 13 台交换机、10 个 VLAN)。

Switch metrics from SNMP data

之后,我们配置了 node_exporter,因为我们需要对工作站、渲染刀片服务器和服务器进行分析。在我们的领域,当 CPU 未达到 100% 时,这是一个问题,我们希望使用所有可以使用的功率,因此最终温度更为关键。此外,我们需要尽可能长的正常运行时间,因此我们所有工作站都通过 Prometheus 的 Alertmanager 设置了电子邮件警报,以便我们在任何设备宕机时都能意识到。

Dashboard for one workstation

我们的特定需求要求我们监控来自客户端的自定义数据,通过使用 node_exporter 的 textfile collector 功能可以轻松实现这一点。一个 cronjob 将来自任何给定工具的特定数据输出到 Prometheus 可读的预格式化文本文件中。

由于所有数据都可通过 HTTP 协议获得,因此我们编写了一个 Python 脚本来从 Prometheus 获取数据。我们将其存储在通过 Web 应用程序访问的 MySQL 数据库中,该应用程序创建了一个实时楼层地图。这使我们只需将鼠标悬停在地图上即可知道哪个用户坐在哪里以及使用哪种类型的硬件。我们还创建了另一个页面,其中包含用户的照片和部门信息,这有助于新员工了解他们的邻居是谁。该网站仍然是一个正在进行的项目,所以请不要评判外观,毕竟我们是系统管理员,而不是网页设计师 :-)

Floormap with workstation detail

自切换以来,您看到了哪些改进?

这为我们提供了一个机会来改变我们监控工作室中一切事物的方式,并启发我们创建一个新的自定义楼层地图,其中包含最初由 Prometheus 获取的所有数据。设置更加简单,只需一个服务即可统治一切。

您认为 L’Atelier Animation 和 Prometheus 的未来会怎样?

我们目前正在将软件许可证使用情况与 Prometheus 集成。这些信息将使艺术家们清楚地了解谁在使用什么以及在哪里使用。

我们将继续根据用户需求自定义 Prometheus 并添加新内容,并且由于我们与艺术家合作,我们知道会有很多需求 :-) 借助 SNMP 和 node_exporter 的自定义文本文件输入,可能性是无限的...

iAdvize 访谈

继续我们对 Prometheus 用户的一系列访谈,iAdvize 的 Laurent COMMARIEU 讲述了他们如何用 Prometheus 替换了他们遗留的 Nagios 和 Centreon 监控系统。

您能介绍一下 iAdvize 是做什么的吗?

我是 Laurent COMMARIEU,iAdvize 的系统工程师。我在由 5 名系统工程师组成的团队中工作,隶属于 60 人的研发部门。我们的工作主要是确保应用程序、服务和底层系统正常运行。我们与开发人员合作,确保他们的代码能够以最简单的方式投入生产,并在每个步骤提供必要的反馈。这就是监控的重要性所在。

iAdvize 是一个全栈对话式商务平台。我们为品牌提供了一种简单的方式来集中与其客户互动,无论沟通渠道如何(聊天、电话、视频、Facebook 页面、Facebook Messenger、Twitter、Instagram、WhatsApp、短信等...)。我们的客户遍布 电子商务、银行、旅游、时尚等行业,覆盖 40 个国家。我们是一家拥有 200 名员工的国际公司,在法国、英国、德国、西班牙和意大利设有办事处。我们在 2015 年融资 1600 万美元。

您在 Prometheus 之前的监控经验是什么?

我于 2016 年 2 月加入 iAdvize。之前我曾在专门从事网络和应用程序监控的公司工作。我们使用开源软件,如 NagiosCactiCentreonZabbixOpenNMS 等,以及一些非免费软件,如 HP NNMIBM Netcool suiteBMC Patrol 等。

iAdvize 过去将监控委托给外部供应商。他们使用 Nagios 和 Centreon 确保 24/7 监控。这套工具在遗留的静态架构(裸机服务器,没有虚拟机,没有容器)下运行良好。为了完善这个监控堆栈,我们还使用了 Pingdom

随着我们将单体应用程序转向微服务架构(使用 Docker)以及我们将当前工作负载迁移到基础设施云提供商的意愿,我们需要对监控有更多的控制和灵活性。与此同时,iAdvize 招聘了 3 名员工,基础设施团队从 2 人增加到 5 人。使用旧系统,在 Centreon 中添加一些新指标至少需要几天或一周的时间,并且有实际成本(时间和金钱)。

您为什么决定关注 Prometheus?

我们知道 Nagios 之类的工具不是一个好的选择。当时 Prometheus 是一颗冉冉升起的新星,我们决定进行 PoC 验证。Sensu 最初也在列表中,但对于我们的用例来说,Prometheus 似乎更有前景。

我们需要能够与 Consul(我们的服务发现系统)集成的工具。我们的微服务已经有了一个 /health 路由;添加一个 /metrics 端点很简单。对于我们使用的几乎每个工具,都有一个可用的导出器(MySQL、Memcached、Redis、nginx、FPM 等)。

从纸面上看,这看起来不错。

One of iAdvize's Grafana dashboards

您是如何过渡的?

首先,我们必须说服开发团队(40 人)Prometheus 是这项工作的正确工具,并且他们必须为他们的应用程序添加一个导出器。因此,我们对 RabbitMQ 进行了演示,我们安装了一个 RabbitMQ 导出器,并构建了一个简单的 Grafana 仪表板,向开发人员显示使用情况指标。编写了一个 Python 脚本来创建一些队列并发布/消费消息。

他们对看到队列和消息实时出现印象深刻。在此之前,开发人员无法访问任何监控数据。Centreon 受我们的基础设施提供商限制。如今,iAdvize 的每个人都可以使用 Grafana,使用 Google Auth 集成进行身份验证。上面有 78 个活跃帐户(从开发团队到 CEO)。

在我们开始使用 Consul 和 cAdvisor 监控现有服务后,我们监控了容器的实际存在情况。它们之前使用 Pingdom 检查进行监控,但这还不够。

我们用 Go 开发了一些自定义导出器,用于从我们的数据库(MySQL 和 Redis)抓取一些业务指标。

很快,我们就能够用 Prometheus 替换所有遗留的监控系统。

One of iAdvize's Grafana dashboards

自切换以来,您看到了哪些改进?

业务指标变得非常受欢迎,在销售期间,每个人都连接到 Grafana,看看我们是否会打破某些记录。我们监控同时进行的对话数量、路由错误、代理连接数、加载 iAdvize 标签的访客数量、我们 API 网关上的调用次数等。

我们花了一个月的时间来优化我们的 MySQL 服务器,分析基于 Newrelic exporterGrafana 的 Percona 仪表板。这是一个真正的成功,使我们能够发现效率低下的问题并执行优化,将数据库大小减少了 45%,峰值延迟减少了 75%。

有很多要说的。我们知道 AMQP 队列是否没有消费者,或者是否异常填充。我们知道容器何时重启。

可见性非常棒。

这只是针对遗留平台而言。

越来越多的微服务将部署在云端,Prometheus 用于监控它们。我们使用 Consul 注册服务,Prometheus 发现指标路由。一切都像魅力一样工作,我们能够构建一个 Grafana 仪表板,其中包含大量关键的业务、应用程序和系统指标。

我们正在构建一个可扩展的架构,以使用 Nomad 部署我们的服务。Nomad 在 Consul 中注册健康的服务,通过一些标签重标记,我们能够过滤掉那些带有标签名称 “metrics=true” 的服务。这为我们部署监控节省了大量时间。我们什么都不用做 ^^。

我们还使用 EC2 服务发现。它在自动伸缩组中非常有用。我们伸缩和回收实例,并且它已经被监控。不再需要等待我们的外部基础设施提供商注意到生产环境中发生的事情。

我们使用 alertmanager 通过短信或发送到我们的 Flowdock 中来发送一些警报。

您认为 iAdvize 和 Prometheus 的未来会怎样?

  • 我们正在等待一种简单的方法来为我们的容量规划添加长期可扩展的存储。
  • 我们梦想着有一天,我们的自动伸缩将由 Prometheus 告警触发。我们希望构建一个基于响应时间和业务指标的自主系统。
  • 我曾经使用过 Netuitive,它具有出色的异常检测功能和自动关联功能。如果在 Prometheus 中也能拥有一些这样的功能就太好了。

Prometheus 2.0 抢先看

2016 年 7 月,Prometheus 发布了 1.0 版本,达到了一个重要的里程碑。从那时起,添加了许多新功能,例如新的服务发现集成和我们的实验性远程 API。我们还意识到,基础设施领域的新发展,特别是 Kubernetes,使得受监控的环境变得更加动态。不出所料,这也给 Prometheus 带来了新的挑战,我们发现了其存储层中的性能瓶颈。

在过去的几个月中,我们一直在设计和实现一种新的存储概念,以解决这些瓶颈,并在整体上显示出显着的性能改进。它也为添加热备份等功能铺平了道路。

这些更改是如此根本,以至于它将触发一个新的主要版本:Prometheus 2.0。
在稳定版本发布之前,还计划了超出存储的重要功能和更改。但是,今天我们发布了 Prometheus 2.0 的早期 alpha 版本,以启动新存储的稳定过程。

发布 tarballDocker 容器 现已可用。如果您对新存储的机制感兴趣,请务必阅读 深入的博客文章,了解其内部原理。

此版本不适用于旧的存储数据,不应替换现有的生产部署。要运行它,数据目录必须为空,并且除了 -storage.local.retention 之外的所有现有存储标志都必须删除。

例如;之前

./prometheus -storage.local.retention=200h -storage.local.memory-chunks=1000000 -storage.local.max-chunks-to-persist=500000 -storage.local.chunk-encoding=2 -config.file=/etc/prometheus.yaml

之后

./prometheus -storage.local.retention=200h -config.file=/etc/prometheus.yaml

这是一个非常早期的版本,预计会出现崩溃、数据损坏和一般错误。请将它们提交到 我们的 issue 跟踪器,帮助我们向稳定版本迈进。

实验性的远程存储 API 在此 alpha 版本中被禁用。抓取暴露时间戳的目标(例如联合的 Prometheus 服务器)尚无法工作。存储格式是破坏性的,并且在后续的 alpha 版本之间会再次破坏。我们计划在接近稳定版本时记录从 1.0 到 2.0 的升级路径。

Europace 访谈

继续我们对 Prometheus 用户的一系列访谈,Europace 的 Tobias Gesellchen 讲述了他们如何发现 Prometheus。

您能介绍一下 Europace 是做什么的吗?

Europace AG 开发和运营基于 Web 的 EUROPACE 金融市场,这是德国最大的抵押贷款、建房融资产品和个人贷款平台。一个完全集成的系统连接了大约 400 家合作伙伴——银行、保险公司和金融产品分销商。每月有数千名用户在 EUROPACE 上执行约 35,000 笔交易,总价值高达 40 亿欧元。我们的工程师定期在 http://tech.europace.de/@EuropaceTech 上发布博客。

您在 Prometheus 之前的监控经验是什么?

Nagios/Icinga 仍在其他项目中使用,但随着服务数量的增长和对灵活性的更高需求,我们寻找了其他解决方案。由于 Nagios 和 Icinga 更多地是集中维护,Prometheus 符合我们团队拥有完整 DevOps 堆栈并将特定职责从我们的基础设施团队转移到项目成员的目标。

您为什么决定关注 Prometheus?

通过我们在 Docker Berlin 社区 的活动,我们与 SoundCloudJulius Volz 取得了联系,他为我们提供了很好的概述。灵活的 Docker 容器与高度灵活的基于标签的概念相结合,使我们确信可以尝试 Prometheus。Prometheus 的设置非常简单,Alertmanager 也满足了我们的需求,因此我们看不到任何理由尝试替代方案。甚至我们为改进 Docker 环境和消息传递工具的集成而提出的一些小的 pull request 也很快被合并了。随着时间的推移,我们向堆栈添加了几个导出器和 Grafana。我们从未回头或寻找替代方案。

Grafana dashboard for Docker Registry

您是如何过渡的?

我们的团队在一个新项目中引入了 Prometheus,因此过渡并非在我们团队中发生。其他团队首先将 Prometheus 与现有解决方案并排添加,然后逐步迁移指标收集器。自定义导出器和其他临时服务在迁移期间提供了帮助。Grafana 已经存在,因此我们不必考虑另一个仪表板。一些项目仍然并行使用 Icinga 和 Prometheus。

自切换以来,您看到了哪些改进?

由于可扩展性问题,我们在使用 Icinga 时遇到了问题——多个团队维护一个集中管理的解决方案效果不佳。使用 Prometheus 堆栈以及 Alertmanager 使我们的团队和项目解耦。Alertmanager 现在能够以 高可用性模式 部署,这对我们监控基础设施的核心来说是一个巨大的改进。

您认为 Europace 和 Prometheus 的未来会怎样?

我们公司中的其他团队已在其项目中逐步采用 Prometheus。我们预计更多项目将引入 Prometheus 以及 Alertmanager,并逐渐取代 Icinga。凭借 Prometheus 固有的灵活性,我们预计它将随着我们的需求而扩展,并且我们不会在使其适应未来需求方面遇到问题。

Weaveworks 访谈

继续我们对 Prometheus 用户的一系列访谈,Weaveworks 的 Tom Wilkie 讲述了他们如何选择 Prometheus 以及现在如何基于它进行构建。

您能介绍一下 Weaveworks 吗?

Weaveworks 提供 Weave Cloud 服务,该服务通过开源项目和软件即服务相结合的方式“运营化”微服务。

Weave Cloud 包括

您可以免费试用 Weave Cloud 60 天。有关我们产品的最新信息,请查看我们的 博客TwitterSlack (邀请)。

您在 Prometheus 之前的监控经验是什么?

Weave Cloud 是一个全新的实现,因此之前没有监控系统。在之前的经历中,该团队使用过 Munin 和 Nagios 等典型工具。Weave Cloud 最初是 Scope 的多租户托管版本。Scope 包含 CPU 和内存使用率等基本监控功能,因此我想你可以说我们使用了它。但我们需要一些东西来监控 Scope 本身...

您为什么决定关注 Prometheus?

我们有一群前 Google SRE 员工,因此在 Borgmon 方面有很多经验,还有一位前 SoundCloud 员工拥有 Prometheus 的经验。我们在 Kubernetes 上构建了该服务,并正在寻找一些能够“适应”其动态调度特性的东西——因此 Prometheus 是不二之选。我们甚至写了一系列博客文章,其中 为什么 Prometheus 和 Kubernetes 如此完美地协同工作 是第一篇。

您是如何过渡的?

当我们开始使用 Prometheus 时,Kubernetes 服务发现仍然只是一个 PR,因此几乎没有文档。我们自定义构建了一段时间,并且有点摸着石头过河,自己摸索出来。最终,我们在 伦敦 Prometheus 聚会 上就 我们的经验 发表了演讲,并发布了 一系列 博客 文章

我们几乎尝试了运行 Prometheus 的每种不同选项。我们最初构建了自己的容器镜像,其中嵌入了配置,并将它们与 Grafana 和 Alert Manager 一起在单个 Pod 中一起运行。我们使用 Pod 内的临时存储来存储时间序列数据。然后,我们将其分解为不同的 Pod,这样我们就不必在每次更改仪表板时都重启 Prometheus(并丢失历史记录)。最近,我们已转向使用上游镜像并将配置存储在 Kubernetes config map 中——我们的 CI 系统会在我们更改配置时更新 config map。我们在 Prometheus Pod 中使用一个小的 sidecar 容器来监视配置文件,并在配置文件更改时 ping Prometheus。这意味着我们不必经常重启 Prometheus,可以在不进行任何花哨的存储操作的情况下摆脱困境,并且不会丢失历史记录。

但周期性丢失 Prometheus 历史记录的问题仍然困扰着我们,而 Kubernetes 卷或定期 S3 备份等可用解决方案都有其缺点。凭借我们使用 Prometheus 监控 Scope 服务的出色经验,这促使我们构建了一个云原生、分布式的 Prometheus 版本——一个可以升级、重新洗牌并在不丢失历史记录的情况下从主机故障中幸存下来的版本。这就是 Weave Cortex 的诞生方式。

自切换以来,您看到了哪些改进?

暂且忽略 Cortex,我们特别高兴地看到 HA Alert Manager 的推出;虽然主要是因为它成为 第一个使用 Weave Mesh 的非 Weaveworks 项目,Weave Mesh 是我们的 gossip 和协调层。

我也特别热衷于 Fabian 对 Kubernetes 服务发现的 v2 版本更改——这解决了我们在监控 Consul Pod 时遇到的一个迫在眉睫的问题,我们需要抓取同一 Pod 上的多个端口。

如果我不提及远程写入功能(我自己参与开发的功能),那将是我的疏忽。有了这个功能,Prometheus 就成为了 Weave Cortex 本身的关键组件,抓取目标并将样本发送给我们。

您认为 Weaveworks 和 Prometheus 的未来会怎样?

对我来说,眼前的未来是 Weave Cortex,Weaveworks 的 Prometheus 即服务。我们在内部广泛使用它,并且开始从中获得相当不错的查询性能。它现在正在生产环境中与真实用户一起运行,不久我们将引入对告警的支持,并实现与上游 Prometheus 的功能对等。从那里,我们将进入稳定化的 beta 计划,然后在今年年中实现全面可用性。

作为 Cortex 的一部分,我们开发了一个智能的 Prometheus 表达式浏览器,具有 PromQL 的自动完成功能和 Jupyter 式笔记本。我们期待将其展示给更多人,并最终开源。

我还有一个名为 Loki 的小型 side project,它将 Prometheus 服务发现和抓取引入 OpenTracing,使分布式追踪变得容易且可靠。我将在 3 月底在柏林举行的 KubeCon/CNCFCon 上就此 发表演讲,主题为:《Loki:用 Go 编写的开源 Zipkin-Prometheus 混搭》。

Canonical 访谈

继续我们对 Prometheus 用户的一系列访谈,Canonical 讲述了他们如何过渡到 Prometheus。

您能介绍一下您自己以及 Canonical 是做什么的吗?

Canonical 可能最出名的是赞助 Ubuntu Linux 的公司。我们还生产或贡献了许多其他开源项目,包括 MAAS、Juju 和 OpenStack,并为这些产品提供商业支持。Ubuntu 为大多数 OpenStack 部署提供支持,占据 55% 的生产云和 58% 的大型云部署

我的团队 BootStack 是我们完全托管的私有云服务。我们为 Canonical 客户构建和运营 OpenStack 云。

您在 Prometheus 之前的监控经验是什么?

我们过去使用 NagiosGraphite/statsd 以及内部 Django 应用程序的组合。这些工具无法为我们的内部和客户云环境提供我们所需的灵活性和报告级别。

您为什么决定关注 Prometheus?

我们评估了一些替代方案,包括 InfluxDB 和扩展我们对 Graphite 的使用,但我们对 Prometheus 的初步体验证明它具有我们正在寻找的简单性和强大性的结合。我们特别欣赏标签的便利性、简单的 HTTP 协议以及开箱即用的 时间序列告警。Prometheus 有潜力用一个工具替换 2 个不同的工具(告警和趋势分析),这一点尤其吸引人。

此外,我们的一些员工在 Google 工作期间拥有 Borgmon 的经验,这极大地增加了我们对它的兴趣!

您是如何过渡的?

我们仍处于过渡过程中,我们预计这将需要一些时间,因为我们现有的系统中使用了许多自定义检查,这些检查需要在 Prometheus 中重新实现。最有用的资源是 prometheus.io 网站文档。

我们花了一段时间才选择导出器。我们最初选择了 collectd,但遇到了限制。我们现在正在编写一个 openstack-exporter,并且有点惊讶地发现没有关于如何从头开始编写导出器的好的、可用的示例。

我们遇到的一些挑战是:没有降采样支持,没有长期存储解决方案(尚未),并且我们对默认的 2 周保留期感到惊讶。目前没有与 Juju 的关联,但 我们正在努力

自切换以来,您看到了哪些改进?

一旦我们掌握了导出器,我们发现它们非常容易编写,并且为我们提供了非常有用的指标。例如,我们正在为我们的云环境开发一个 openstack-exporter。我们还看到我们的 DevOps 和 WebOps 团队以及开发人员非常迅速地跨团队采用。我们尚未部署告警,但我们预计一旦我们进入过渡的这个阶段,将会看到更多进展。

您认为 Canonical 和 Prometheus 的未来会怎样?

我们预计 Prometheus 将成为我们监控和报告基础设施的重要组成部分,为当前和未来的众多系统提供指标收集和存储。我们认为它有可能取代 Nagios 作为告警工具。

JustWatch 访谈

继续我们对 Prometheus 用户的一系列访谈,JustWatch 讲述了他们如何建立监控系统。

您能介绍一下您自己以及 JustWatch 是做什么的吗?

对于消费者而言,JustWatch 是一个流媒体搜索引擎,可帮助查找在哪里合法在线和在影院观看电影和电视节目。您可以在所有主要流媒体提供商(如 Netflix、HBO、Amazon Video、iTunes、Google Play 以及其他 17 个国家/地区的许多提供商)中搜索电影内容。

对于我们的客户(如电影制片厂或视频点播提供商)而言,我们是一家国际电影营销公司,从我们的消费者应用程序中收集关于全球影迷的购买行为和电影品味的匿名数据。我们帮助制片厂向正确的受众宣传他们的内容,并使数字视频广告更有效地最大限度地减少无效覆盖。

JustWatch logo

自 2014 年推出以来,我们从零增长到国际上最大的 2 万个网站之一,而没有在营销上花费一分钱——在不到两年的时间内成为全球最大的流媒体搜索引擎。目前,我们仅拥有 10 人的工程团队,我们构建和运营着一个完全 Docker 化的堆栈,其中包含大约 50 个微服务和宏服务,主要在 Kubernetes 上运行。

您在 Prometheus 之前的监控经验是什么?

在之前的公司中,我们中的许多人都使用过当时大多数开源监控产品。我们在使用 NagiosIcingaZabbixMonitMuninGraphite 和其他一些系统方面拥有相当丰富的经验。在一家公司,我帮助使用 Puppet 构建了一个分布式的 Nagios 设置。这个设置很好,因为新服务会自动显示在系统中,但是将实例移除仍然很痛苦。一旦你的系统中出现一些差异,基于主机和服务的监控套件就无法很好地适应。Prometheus 采用的基于标签的方法是我一直想要拥有的,但以前没有找到。

您为什么决定关注 Prometheus?

在 JustWatch,Prometheus 的公开声明恰好赶上了合适的时机。在公司成立的最初几个月中,我们主要进行了黑盒监控——CloudWatch 用于一些最重要的内部指标,并结合 Pingdom 等外部服务来检测站点范围的中断。此外,经典的基于主机的解决方案都不能让我们满意。在容器和微服务的世界中,像 Icinga、Thruk 或 Zabbix 这样的基于主机的工具感觉过时且无法胜任这项工作。当我们开始研究白盒监控时,我们中的一些人幸运地参加了 Golang Meetup,Julius 和 Björn 在那里宣布了 Prometheus。我们快速搭建了一个 Prometheus 服务器,并开始检测我们的 Go 服务(我们的后端几乎只使用 Go)。这非常容易,令人惊叹——设计感觉像是将云和服务导向作为第一原则,并且从不碍事。

您是如何过渡的?

过渡并不困难,因为在时间上,我们很幸运地从没有相关的监控直接过渡到了 Prometheus。

过渡到 Prometheus 主要包括将 Go 客户端包含到我们的应用程序中并包装 HTTP 处理程序。我们还编写和部署了几个导出器,包括 node_exporter 和几个云提供商 API 的导出器。根据我们的经验,监控和告警是一个永无止境的项目,但大部分工作是在几周内作为副项目完成的。

自从部署 Prometheus 以来,每当我们错过某些东西或从头开始设计新服务时,我们都倾向于查看指标。

完全掌握 PromQL 和标签概念的优雅性花了一些时间,但这种努力确实得到了回报。

自切换以来,您看到了哪些改进?

Prometheus 通过使人们能够非常容易地从白盒监控和基于标签的金丝雀部署中获益而启迪了我们。许多 Golang 方面的开箱即用指标(HTTP Handler、Go Runtime)帮助我们非常快速地获得了投资回报——仅 goroutine 指标就多次挽救了局面。我们之前真正喜欢的唯一监控组件——Grafana——感觉与 Prometheus 自然契合,并使我们能够创建一些非常有用的仪表板。我们赞赏 Prometheus 没有试图重新发明轮子,而是与现有的最佳解决方案完美契合。与前辈相比,Prometheus 的另一个巨大改进是专注于实际正确地进行数学运算(百分位数等)。在其他系统中,我们从来都不确定所提供的操作是否有意义。特别是百分位数是推理微服务性能的一种如此自然和必要的方式,以至于它们获得一流的待遇感觉很棒。

Database Dashboard

集成服务发现功能使管理抓取目标变得非常容易。对于 Kubernetes 来说,一切开箱即用。对于一些尚未在 Kubernetes 上运行的其他系统,我们使用 基于 Consul 的方法。要让 Prometheus 监控应用程序,只需添加客户端,暴露 /metrics 端点,并在 Container/Pod 上设置一个简单的注解。这种低耦合性消除了开发和运维之间的许多摩擦——许多服务从一开始就被构建得井井有条,因为它既简单又有趣。

时间序列和巧妙函数的结合造就了强大的告警能力。在服务器上运行的聚合,以及将时间序列、它们的组合,甚至这些组合上的函数都视为一等公民,使得告警变得轻而易举——通常在事后也是如此。

您认为 JustWatch 和 Prometheus 的未来会怎样?

虽然我们非常重视 Prometheus 不专注于花哨的功能,而是专注于实际工作和交付价值,同时部署和操作也相当容易——但特别是 Alertmanager 仍有许多不足之处。仅仅是一些简单的改进,例如在前端简化交互式告警构建和编辑,就能大大简化告警的使用。

我们非常期待存储层的持续改进,包括远程存储。我们也希望 Project PrismVulcan 中采用的一些方法能够反向移植到核心 Prometheus 中。我们目前最感兴趣的主题是 GCE 服务发现、更简单的扩展以及更长的保留期(即使以较冷的存储和更长的旧事件查询时间为代价)。

我们也期待将 Prometheus 用于更多的非技术部门。我们希望用 Prometheus 覆盖我们的大部分 KPI,以便每个人都可以创建漂亮的仪表板以及告警。我们目前甚至计划将强大的告警引擎滥用于一个新的内部业务项目——敬请期待!

与 Compose 的访谈

在我们对 Prometheus 用户进行的一系列访谈中,Compose 谈论了他们从 Graphite 和 InfluxDB 到 Prometheus 的监控之旅。

您能介绍一下您自己以及 Compose 是做什么的吗?

Compose 为世界各地的开发人员提供生产就绪的数据库集群即服务。应用程序开发人员可以来找我们,只需点击几下,即可在几分钟内获得一个多主机、高可用、自动备份且安全的数据库。这些数据库部署随后会随着需求的增加而自动扩展,因此开发人员可以将时间花在构建出色的应用程序上,而不是运行他们的数据库。

我们在 AWS、Google Cloud Platform 和 SoftLayer 的每个平台中,至少在两个区域拥有数十个主机集群。每个集群都跨越可用区(如果支持),并且容纳大约 1000 个高可用数据库部署,这些部署位于各自的私有网络中。更多的区域和提供商正在筹备中。

您在 Prometheus 之前的监控经验是什么?

在 Prometheus 之前,我们尝试了许多不同的指标系统。我们尝试的第一个系统是 Graphite,它最初运行良好,但是我们需要存储的大量不同指标,加上 Whisper 文件在磁盘上的存储和访问方式,很快就使我们的系统过载。虽然我们知道 Graphite 可以相对容易地水平扩展,但这将是一个昂贵的集群。InfluxDB 看起来更有希望,所以我们开始尝试早期版本,它似乎在很长一段时间内运行良好。再见 Graphite。

早期版本的 InfluxDB 偶尔会出现数据损坏的问题。我们半定期地不得不清除我们所有的指标。这对我们来说通常不是毁灭性的损失,但这很令人恼火。持续承诺的功能从未实现,坦率地说,这让我们感到厌倦。

您为什么决定关注 Prometheus?

与其他方案相比,它似乎将更好的效率与更简单的操作结合在一起。

拉取式指标收集最初让我们感到困惑,但我们很快意识到了它的好处。最初,它看起来在我们的环境中扩展可能过于重量级,在我们的环境中,我们通常在每台主机上有数百个容器,每个容器都有自己的指标,但是通过将其与 Telegraf 结合使用,我们可以安排每台主机通过单个 Prometheus 抓取目标导出其所有容器(以及其整体资源指标)的指标。

您是如何过渡的?

我们是一家 Chef 商店,所以我们启动了一个大型实例,配备了一个大的 EBS 卷,然后直接使用了 社区 Chef Cookbook for Prometheus。

在主机上启动 Prometheus 后,我们编写了一个小的 Ruby 脚本,该脚本使用 Chef API 查询我们所有的主机,并写出一个 Prometheus 目标配置文件。我们将此文件与 file_sd_config 一起使用,以确保所有主机在 Chef 注册后立即被发现和抓取。感谢 Prometheus 的开放生态系统,我们可以直接使用 Telegraf,通过简单的配置导出主机级别的指标。

我们正在测试单个 Prometheus 的扩展能力,并等待它崩溃。但它没有!事实上,它处理了每 15 秒抓取一次的主机级别指标的负载,用于我们较新的基础设施中的大约 450 台主机,资源使用率非常低。

我们在每台主机上都有很多容器,所以我们预计一旦我们添加所有这些容器的内存使用指标,我们就必须开始分片 Prometheus,但是 Prometheus 继续运行,没有任何问题,并且仍然没有接近饱和其资源。我们目前每 15 秒监控超过 400,000 个不同的指标,用于大约 40,000 个容器,分布在 450 台主机上,使用单个 m4.xlarge Prometheus 实例,配备 1TB 的存储空间。您可以在下面看到我们这台主机的主机仪表板。1TB gp2 SSD EBS 卷上的磁盘 IO 最终可能会成为限制因素。我们最初的猜测现在已经过度配置了,但是我们在收集的指标和要监控的主机/容器方面都在快速增长。

Prometheus Host Dashboard

此时,我们启动用于测试的 Prometheus 服务器比我们之前用于完成相同工作的 InfluxDB 集群可靠得多,所以我们做了一些基本的工作,使其不再是单点故障。我们添加了另一个相同的节点,抓取所有相同的目标,然后添加了一个简单的故障转移方案,使用 keepalived + DNS 更新。现在这比我们之前的系统更具高可用性,所以我们将面向客户的图表切换为使用 Prometheus,并拆除了旧系统。

Prometheus-powered memory metrics for PostgresSQL containers in our app

自切换以来,您看到了哪些改进?

我们之前的监控设置不可靠且难以管理。使用 Prometheus,我们拥有一个运行良好的系统,可以绘制大量指标,并且我们的团队成员突然对使用它的新方式感到兴奋,而不是像以前那样对接触我们使用的指标系统感到警惕。

集群也更简单,只有两个相同的节点。随着我们的增长,我们知道我们将不得不跨更多 Prometheus 主机分片工作,并且已经考虑了几种方法来实现这一点。

您认为 Compose 和 Prometheus 的未来会怎样?

目前,我们只复制了我们在以前的系统中已经收集的指标——客户容器的基本内存使用情况以及我们自己操作的主机级别资源使用情况。下一步合乎逻辑的步骤是使数据库团队能够从 DB 容器内部将指标推送到本地 Telegraf 实例,以便我们也可以记录数据库级别的统计信息,而无需增加要抓取的目标数量。

我们还有几个其他系统想要加入 Prometheus,以获得更好的可见性。我们在 Mesos 上运行我们的应用程序,并且已经集成了基本的 Docker 容器指标,这比以前更好,但是我们也希望 Mesos 集群中更多的基础设施组件记录到中央 Prometheus,以便我们可以拥有集中的仪表板,显示从负载均衡器一直到应用程序指标的所有支持系统健康状况的元素。

最终,我们将需要分片 Prometheus。出于各种原因,我们已经将客户部署分散到许多较小的集群中,因此一个合乎逻辑的选择是移动到每个集群一个较小的 Prometheus 服务器(或一对用于冗余),而不是一个单一的全局服务器。

对于大多数报告需求来说,这不是一个大问题,因为我们通常不需要在同一个仪表板中包含来自不同集群的主机/容器,但我们可能会保留一个小型全局集群,具有更长的保留期,并且只使用来自每个集群 Prometheus 的少量降采样和聚合指标,使用 Recording Rules。

与 DigitalOcean 的访谈

在我们对 Prometheus 用户进行的一系列访谈中,DigitalOcean 谈论了他们如何使用 Prometheus。Carlos Amedee 还在 PromCon 2016 上谈到了 推广的社会方面

您能介绍一下您自己以及 DigitalOcean 是做什么的吗?

我叫 Ian Hansen,我在平台指标团队工作。DigitalOcean 提供简单的云计算服务。到目前为止,我们在 13 个区域创建了 2000 万个 Droplet(SSD 云服务器)。我们最近还发布了一个新的块存储产品。

DigitalOcean logo

您在 Prometheus 之前的监控经验是什么?

在 Prometheus 之前,我们运行的是 GraphiteOpenTSDB。Graphite 用于较小规模的应用程序,OpenTSDB 用于通过 Collectd 收集我们所有物理服务器的指标。Nagios 会拉取这些数据库来触发告警。我们仍然使用 Graphite,但我们不再运行 OpenTSDB。

您为什么决定关注 Prometheus?

我对 OpenTSDB 感到沮丧,因为我负责保持集群在线,但发现很难防范指标风暴。有时,一个团队会启动一项新的(非常嘈杂的)服务,这会影响集群的总容量并损害我的 SLA。

我们能够将新的指标列入 OpenTSDB 的黑名单/白名单,但是除了组织流程(这很难改变/执行)之外,我们没有很好的方法来防范嘈杂的服务。其他团队对查询语言和当时可用的可视化工具感到沮丧。我当时正在与 Julius Volz 讨论推送与拉取指标系统,当我看到我可以真正控制我的 SLA,因为我可以决定我要拉取什么以及拉取频率时,我被说服想要尝试 Prometheus。此外,我真的非常喜欢查询语言。

您是如何过渡的?

我们通过 Collectd 将指标发送到 OpenTSDB 来收集指标。并行安装 Node Exporter 和我们已经运行的 Collectd 设置,使我们能够开始尝试 Prometheus。我们还创建了一个自定义导出器来暴露 Droplet 指标。很快,我们拥有了与我们的 OpenTSDB 服务相同的功能,并开始关闭 Collectd,然后关闭了 OpenTSDB 集群。

人们非常喜欢 Prometheus 以及随之而来的可视化工具。突然之间,我们这个小小的指标团队有了一个我们无法快速完成的积压工作,以满足人们的需求,并且我们没有为人们的服务提供和维护 Prometheus,而是着眼于创建工具,使其他团队尽可能容易地运行他们自己的 Prometheus 服务器,并运行我们在公司常用的通用导出器。

一些团队已经开始使用 Alertmanager,但我们仍然有一种从我们现有的监控工具中拉取 Prometheus 的概念。

自切换以来,您看到了哪些改进?

我们改进了对虚拟机监控程序的洞察。我们可以从 Collectd 和 Node Exporter 中获得的数据大致相同,但是对于我们的 Go 语言开发人员团队来说,创建新的自定义导出器要容易得多,该导出器暴露特定于我们在每个虚拟机监控程序上运行的服务的数据。

我们正在暴露更好的应用程序指标。学习和教授如何创建可以在以后正确聚合的 Prometheus 指标更容易。使用 Graphite,很容易创建一个以后无法以某种方式聚合的指标,因为点分隔的名称结构不正确。

创建告警比我们以前拥有的系统更快更简单,而且使用一种熟悉的语言。这使团队能够为他们了解和理解的服务创建更好的告警,因为他们可以快速迭代。

您认为 DigitalOcean 和 Prometheus 的未来会怎样?

我们正在继续研究如何使 DigitalOcean 的团队尽可能容易地收集指标。现在,团队正在为他们关心的事物运行自己的 Prometheus 服务器,这使我们获得了我们原本无法如此快速获得的可见性。但是,并非每个团队都应该知道如何运行 Prometheus。我们正在研究我们可以做些什么来使 Prometheus 尽可能自动化,以便团队可以专注于他们想要在其服务和数据库上进行的查询和告警。

我们还创建了 Vulcan,以便我们拥有长期数据存储,同时保留我们围绕其构建工具并培训人们如何使用的 Prometheus 查询语言。

与 ShuttleCloud 的访谈

在我们对 Prometheus 用户进行的一系列访谈中,ShuttleCloud 谈论了他们如何开始使用 Prometheus。来自 ShuttleCloud 的 Ignacio 还在 PromCon 2016 上解释了 Prometheus 对您的小型创业公司有好处

ShuttleCloud 是做什么的?

ShuttleCloud 是世界上最具可扩展性的电子邮件和联系人数据导入系统。我们通过自动化数据导入的切换体验,帮助包括 Google 和 Comcast 在内的一些领先的电子邮件和地址簿提供商增加用户增长和参与度。

通过将我们的 API 集成到他们的产品中,我们的客户允许他们的用户轻松地将其电子邮件和联系人从一个参与的提供商迁移到另一个提供商,从而减少用户在切换到新提供商时面临的摩擦。支持 24/7 电子邮件提供商包括所有主要的美国互联网服务提供商:Comcast、Time Warner Cable、AT&T、Verizon 等。

通过为最终用户提供一种简单的迁移电子邮件的方式(同时保持对导入工具 UI 的完全控制),我们的客户大大提高了用户激活和入职率。

ShuttleCloud's integration with Gmail ShuttleCloud 与 Google Gmail 平台的集成 Gmail 已使用我们的 API 为 300 万用户导入了数据。

除了遵循最安全的标准(SSL、oAuth)以确保 API 请求的机密性和完整性之外,ShuttleCloud 的技术还加密了处理导入所需的所有数据。我们的技术使我们能够保证我们平台的高可用性,正常运行时间高达 99.5%。

ShuttleCloud by Numbers

您在 Prometheus 之前的监控经验是什么?

最初,我们基础设施的适当监控系统并不是我们的主要优先事项之一。我们没有现在这么多的项目和实例,所以我们使用其他简单的系统来提醒我们是否有任何东西运行不正常,并将其控制住。

  • 我们有一组自动脚本来监控机器的大部分操作指标。这些脚本基于 cron,并使用 Ansible 从中央机器执行。告警是直接发送给整个开发团队的电子邮件。
  • 我们信任 Pingdom 进行外部黑盒监控,并检查我们所有的前端是否正常运行。他们提供了一个简单的界面和告警系统,以防我们的任何外部服务无法访问。

幸运的是,大客户来了,SLA 开始变得更加苛刻。因此,我们需要其他东西来衡量我们的表现,并确保我们遵守所有 SLA。我们需要的其中一个功能是拥有关于我们性能和业务指标的准确统计数据(即,有多少迁移正确完成),因此报告比监控更让我们关注。

我们开发了以下系统

Initial Shuttlecloud System

  • 所有必要数据的来源是 CouchDB 中的状态数据库。在那里,每个文档代表一个操作的状态。此信息由状态导入器处理,并以关系方式存储在 MySQL 数据库中。

  • 一个组件从该数据库收集数据,信息被聚合并后处理成多个视图。

    • 其中一个视图是电子邮件报告,我们需要它用于报告目的。这通过电子邮件发送。
    • 另一个视图将数据推送到仪表板,可以在其中轻松控制数据。我们使用的仪表板服务是外部的。我们信任 Ducksboard,不仅是因为仪表板易于设置且看起来很漂亮,还因为它们在达到阈值时提供自动告警。

有了这一切,我们很快意识到,随着项目数量的开始增加,我们将需要一个适当的指标、监控和告警系统。

当时我们拥有的系统的一些缺点是

  • 没有集中的监控系统。每种指标类型都有不同的系统
    • 系统指标 → 由 Ansible 运行的脚本。
    • 业务指标 → Ducksboard 和电子邮件报告。
    • 黑盒指标 → Pingdom。
  • 没有标准的告警系统。每种指标类型都有不同的告警(电子邮件、推送通知等)。
  • 一些业务指标没有告警。这些指标是手动审查的。

您为什么决定关注 Prometheus?

我们分析了几个监控和告警系统。我们渴望亲身实践,检查一个解决方案是否会成功或失败。我们决定进行测试的系统是 Prometheus,原因如下

  • 首先,您不必定义固定的指标系统即可开始使用它;指标可以在将来添加或更改。当您还不知道所有要监控的指标时,这提供了宝贵的灵活性。
  • 如果您对 Prometheus 有任何了解,您就会知道指标可以具有标签,这些标签使我们从考虑不同时间序列的事实中抽象出来。这与它的查询语言一起,提供了更大的灵活性和强大的工具。例如,我们可以为不同的环境或项目定义相同的指标,并获得特定的时间序列或使用适当的标签聚合某些指标
    • http_requests_total{job="my_super_app_1",environment="staging"} - 对应于应用程序 "my_super_app_1" 的 staging 环境的时间序列。
    • http_requests_total{job="my_super_app_1"} - 应用程序 "my_super_app_1" 的所有环境的时间序列。
    • http_requests_total{environment="staging"} - 所有作业的所有 staging 环境的时间序列。
  • Prometheus 支持 DNS 服务用于服务发现。我们碰巧已经拥有一个内部 DNS 服务。
  • 无需安装任何外部服务(例如,与 Sensu 不同,Sensu 需要像 Redis 这样的数据存储服务和像 RabbitMQ 这样的消息总线)。这可能不是一个决定性因素,但它绝对使测试更容易执行、部署和维护。
  • Prometheus 非常容易安装,因为您只需要下载一个可执行的 Go 文件。Docker 容器也运行良好,并且很容易启动。

您如何使用 Prometheus?

最初,我们只使用 node_exporter 提供的开箱即用的一些指标,包括

  • 硬盘使用情况。
  • 内存使用情况。
  • 实例是否启动或关闭。

我们的内部 DNS 服务已集成用于服务发现,因此每个新实例都会被自动监控。

我们使用的一些指标,默认情况下 node_exporter 不提供这些指标,是使用 node_exporter textfile collector 功能导出的。我们在 Prometheus Alertmanager 上声明的第一个告警主要与上述操作指标有关。

后来,我们开发了一个操作导出器,使我们能够几乎实时地了解系统的状态。它暴露了业务指标,即所有操作的状态、传入迁移的数量、完成迁移的数量和错误数量。我们可以在 Prometheus 端聚合这些指标,并让它计算不同的比率。

我们决定导出和监控以下指标

  • operation_requests_total
  • operation_statuses_total
  • operation_errors_total

Shuttlecloud Prometheus System

我们的大部分服务都在两个 Google Cloud Platform 可用区中复制。这包括监控系统。在两个或多个不同的区域中拥有多个操作导出器非常简单,因为 Prometheus 可以聚合来自所有这些导出器的数据并生成一个指标(即,所有导出器中的最大值)。我们目前没有 HA 中的 Prometheus 或 Alertmanager——只有一个元监控实例——但我们正在努力实现它。

对于外部黑盒监控,我们使用 Prometheus Blackbox Exporter。除了检查我们的外部前端是否正常运行之外,它对于拥有 SSL 证书到期日期的指标尤其有用。它甚至检查整个证书链。感谢 Robust Perception 在他们的 博客文章 中完美地解释了这一点。

我们在 Grafana 中为一些仪表板中的可视化监控设置了一些图表,并且与 Prometheus 的集成非常简单。用于定义图表的查询语言与 Prometheus 中的相同,这大大简化了它们的创建。

我们还将 Prometheus 与 Pagerduty 集成,并创建了一个关键告警值班人员表。对于那些不被认为是关键的告警,我们只发送了一封电子邮件。

Prometheus 如何为您带来更好的体验?

我们无法将 Prometheus 与我们之前的解决方案进行比较,因为我们没有解决方案,但是我们可以谈谈 Prometheus 的哪些功能对我们来说是亮点

  • 它几乎不需要维护。
  • 它很高效:一台机器可以处理监控整个集群。
  • 社区很友好——包括开发人员和用户。此外,Brian 的博客 是一个非常好的资源。
  • 它没有第三方要求;它只是服务器和导出器。(无需维护 RabbitMQ 或 Redis。)
  • Go 应用程序的部署非常轻松。

您认为 ShuttleCloud 和 Prometheus 的未来会怎样?

我们对 Prometheus 非常满意,但是我们总是欢迎新的导出器(例如 Celery 或 Spark)。

我们每次添加新告警时都会面临一个问题:我们如何测试告警是否按预期工作?如果有一种方法可以注入虚假指标以引发告警,以便进行测试,那就太好了。

PromCon 2016 - 圆满结束!

发生了什么

上周,来自世界各地的 80 位 Prometheus 用户和开发人员齐聚柏林两天,参加了有史以来第一次关于 Prometheus 监控系统的会议:PromCon 2016。本次会议的目标是交流知识、最佳实践以及使用 Prometheus 获得的经验。我们还希望发展社区,并帮助人们建立围绕服务监控的专业联系。以下是第一天上午的一些印象

拉取不可扩展 - 还是可以?

让我们来谈谈一个特别持久的神话。每当讨论监控系统和 Prometheus 的基于拉取的指标收集方法时,总会有人插话说,基于拉取的方法“从根本上来说是不可扩展的”。给出的理由通常含糊不清,或者只适用于与 Prometheus 从根本上不同的系统。事实上,在我们以最大规模使用基于拉取的监控之后,这种说法与我们自己的运营经验相悖。

我们已经有一个关于 为什么 Prometheus 选择拉取而不是推送 的常见问题解答条目,但它没有特别关注扩展方面。让我们更仔细地看看围绕这种说法的常见误解,并分析它们是否以及如何适用于 Prometheus。

Prometheus 不是 Nagios

当人们想到主动拉取的监控系统时,他们通常会想到 Nagios。Nagios 因扩展性不佳而闻名,部分原因是它为活动检查生成子进程,这些子进程可以在 Nagios 主机上运行任意操作,以确定特定主机或服务的健康状况。这种检查架构确实不能很好地扩展,因为中央 Nagios 主机很快就会不堪重负。因此,人们通常将检查配置为每隔几分钟才执行一次,否则他们会遇到更严重的问题。

但是,Prometheus 采用了一种完全不同的方法。它不是执行检查脚本,而是仅从一组仪表化目标通过网络收集时间序列数据。对于每个目标,Prometheus 服务器只是通过 HTTP(以高度并行的方式,使用 goroutine)获取该目标的所有指标的当前状态,并且没有其他与拉取相关的执行开销。这引出了下一个要点

谁发起连接并不重要

为了扩展目的,谁发起 TCP 连接,然后通过该连接传输指标,这并不重要。无论您采用哪种方式,建立连接的工作量都远小于指标负载和其他所需的工作。

但是,您可能会说,基于推送的方法可以使用 UDP 并完全避免建立连接!没错,但与 Prometheus 服务器必须执行的其他数据摄取工作(特别是将时间序列数据持久化到磁盘上)相比,Prometheus 中的 TCP/HTTP 开销仍然可以忽略不计。为了用数字来说明这一点:一个大型 Prometheus 服务器可以轻松存储数百万个时间序列,每秒记录 80 万个传入样本(根据 SoundCloud 的实际生产指标数据测量)。考虑到 10 秒的抓取间隔和每个主机 700 个时间序列,这允许您从单个 Prometheus 服务器监控超过 10,000 台机器。这里的扩展瓶颈从来都不是与拉取指标相关的,而是通常与 Prometheus 服务器将数据摄取到内存中,然后可持续地将数据持久化和过期到磁盘/SSD 上的速度有关。

此外,尽管现在的网络非常可靠,但使用基于 TCP 的拉取方法可以确保指标数据可靠地到达,或者监控系统至少可以立即知道何时由于网络中断而导致指标传输失败。

Prometheus 不是基于事件的系统

一些监控系统是基于事件的。也就是说,它们会立即向中央监控系统报告每个单独的事件(HTTP 请求、异常,等等)。然后,这个中央系统要么将事件聚合为指标(StatsD 是主要的例子),要么单独存储事件以供稍后处理(ELK 堆栈就是一个例子)。在这样的系统中,拉取确实会成为问题:被监控的服务必须在拉取之间缓冲事件,并且拉取必须非常频繁地发生,才能模拟基于推送的方法的相同“实时性”,并且不会使事件缓冲区不堪重负。

然而,再次强调,Prometheus 不是基于事件的监控系统。您不会向 Prometheus 发送原始事件,它也不能存储它们。Prometheus 的业务是收集聚合的时间序列数据。这意味着它只对定期收集给定指标集的当前状态感兴趣,而不是对导致这些指标生成的底层事件感兴趣。例如,一个被监控的服务不会在处理每个 HTTP 请求时都向 Prometheus 发送消息,而只是在内存中累加这些请求。这每秒可以发生数十万次,而不会产生任何监控流量。然后,Prometheus 只需每 15 或 30 秒(或您配置的任何时间)询问服务实例当前的计数器值,并将该值与抓取时间戳一起存储为样本。其他指标类型,如仪表盘、直方图和摘要,也以类似的方式处理。由此产生的监控流量很低,并且在这种情况下,基于拉取的方法也不会产生问题。

但是现在我的监控需要知道我的服务实例!

使用基于拉取的方法,您的监控系统需要知道哪些服务实例存在以及如何连接到它们。有些人担心这需要在监控系统方面进行额外的配置,并将此视为操作可扩展性问题。

我们认为,在任何情况下,对于严肃的监控设置,您都无法逃避这种配置工作:如果您的监控系统不知道世界应该是什么样子,也不知道应该存在哪些被监控的服务实例,它又如何能够判断某个实例只是从未报告,是由于中断而宕机,还是真的不再应该存在?只有当您从不关心单个实例的健康状况时,这才可以接受,例如当您只运行临时工作程序时,只要足够数量的工作程序报告一些结果就足够了。大多数环境并非完全如此。

如果监控系统无论如何都需要知道世界的期望状态,那么基于推送的方法实际上需要更多的总配置。不仅您的监控系统需要知道应该存在哪些服务实例,而且您的服务实例现在还需要知道如何访问您的监控系统。基于拉取的方法不仅需要的配置更少,而且还使您的监控设置更加灵活。使用拉取,您只需在笔记本电脑上运行生产监控的副本即可进行实验。它还允许您使用其他工具获取指标或手动检查指标端点。为了获得高可用性,拉取允许您并行运行两个配置相同的 Prometheus 服务器。最后,如果您必须移动监控可访问的端点,基于拉取的方法不需要您重新配置所有指标源。

在实践方面,Prometheus 通过其内置的对云提供商和容器调度系统的各种服务发现机制的支持,可以轻松配置世界的期望状态:Consul、Marathon、Kubernetes、EC2、基于 DNS 的 SD、Azure、Zookeeper Serversets 等等。如果需要,Prometheus 还允许您插入自己的自定义机制。在微服务世界或任何多层架构中,如果您的监控系统使用与您的服务实例用于发现其后端相同的方法来发现要监控的目标,从根本上来说也是一个优势。这样,您可以确保您正在监控与服务生产流量的目标相同的目标,并且您只需要维护一种发现机制。

意外地 DDoS 您的监控

无论您是拉取还是推送,如果发送给时间序列数据库的样本超过其处理能力,它都会崩溃。但是,根据我们的经验,基于推送的方法稍微更容易意外地使您的监控系统宕机。如果对从哪些实例摄取哪些指标的控制不是集中式的(在您的监控系统中),那么您就会面临实验性或恶意作业突然将大量垃圾数据推送到您的生产监控系统并使其宕机的危险。仍然有很多方法可以通过基于拉取的方法发生这种情况(它只控制从哪里拉取指标,但不控制指标负载的大小和性质),但风险较低。更重要的是,此类事件可以在中心点得到缓解。

真实世界的证明

除了 Prometheus 已经被用于监控真实世界中的非常大型的设置(例如,使用它来监控 DigitalOcean 的数百万台机器)之外,还有其他突出的例子表明,基于拉取的监控已在尽可能大的环境中使用并取得成功。Prometheus 的灵感来自 Google 的 Borgmon,Borgmon 曾经(并且部分仍然)在 Google 内部使用,以使用基于拉取的方法监控其所有关键生产服务。我们在 Google 使用 Borgmon 遇到的任何扩展问题都不是由于其拉取方法造成的。如果基于拉取的方法可以扩展到具有数十个数据中心和数百万台机器的全球环境,您很难说拉取无法扩展。

但是拉取还有其他问题!

确实有一些设置很难使用基于拉取的方法进行监控。一个突出的例子是,当您有许多端点分散在世界各地,由于防火墙或复杂的网络设置而无法直接访问,并且在每个网段中直接运行 Prometheus 服务器是不可行的时候。这不太符合 Prometheus 的构建环境,尽管通常可以找到解决方法(通过 Pushgateway 或重组您的设置)。在任何情况下,这些关于基于拉取的监控的剩余担忧通常与扩展无关,而是由于围绕打开 TCP 连接的网络操作困难。

一切都很好吗?

本文解决了围绕基于拉取的监控方法的最常见的可扩展性担忧。随着 Prometheus 和其他基于拉取的系统在非常大的环境中成功使用,并且拉取方面在现实中没有造成瓶颈,结果应该很清楚:“拉取无法扩展”的论点不是一个真正的担忧。我们希望未来的辩论将集中在比这个转移注意力的问题更重要的事情上。

Prometheus 达到 1.0 版本

今年一月,我们发布了一篇关于 Prometheus 公开存在的第一年 的博文,总结了我们令人惊叹的旅程,并希望对您来说是一个创新且有用的监控解决方案。此后,Prometheus 也加入了云原生计算基金会,在那里我们与 Kubernetes 之后成为第二个创始项目,与大家为伍,感觉很好。

我们最近的工作重点是交付稳定的 API 和用户界面,以 Prometheus 1.0 版本为标志。我们很高兴地宣布,我们已经实现了这个目标,并且 Prometheus 1.0 今天发布

1.0 版本对您意味着什么?

如果您已经使用 Prometheus 一段时间了,您可能已经注意到,在过去一年中,破坏性更改的频率和影响已显着降低。本着同样的精神,达到 1.0 版本意味着后续的 1.x 版本将保持 API 稳定。升级不会破坏基于 Prometheus API 构建的程序,更新也不会要求存储重新初始化或部署更改。自定义仪表板和警报在 1.x 版本更新中也将保持不变。我们相信 Prometheus 1.0 是一个可靠的监控解决方案。既然 Prometheus 服务器已经达到了稳定的 API 状态,其他模块也将随之发布它们自己的稳定 1.0 版本。

细则

那么,API 稳定性意味着什么?Prometheus 具有很大的表面积,某些部分肯定比其他部分更成熟。有两个简单的类别:稳定不稳定

自 v1.0 起及整个 1.x 系列中稳定

  • 查询语言和数据模型
  • 警报和记录规则
  • 摄取暴露格式
  • 配置标志名称
  • HTTP API(由仪表板和 UI 使用)
  • 配置文件格式(减去不稳定的服务发现集成,见下文)
  • 在可预见的未来,与 Alertmanager 0.1+ 的警报集成
  • 控制台模板语法和语义

不稳定且可能在 1.x 版本内更改

  • 远程存储集成(InfluxDB、OpenTSDB、Graphite)仍处于实验阶段,并且将在某个时候被删除,以支持更通用的、更复杂的 API,该 API 允许将样本存储在任意存储系统中。
  • 一些服务发现集成是新的,需要跟上快速发展的系统。因此,与 Kubernetes、Marathon、Azure 和 EC2 的集成仍处于 beta 状态,并且可能会发生变化。但是,更改将明确宣布。
  • 确切的标志含义可能会根据需要更改。但是,更改永远不会导致服务器无法使用以前的标志配置启动。
  • 作为服务器一部分的软件包的 Go API。
  • Web UI 生成的 HTML。
  • Prometheus 自身的 /metrics 端点中的指标。
  • 确切的磁盘格式。但是,潜在的更改将是向前兼容的,并且 Prometheus 会透明地处理。

那么 Prometheus 现在完成了吗?

绝对没有。我们前面还有很长的路线图,充满了要实现的强大功能。Prometheus 不会停留在 1.x 版本多年。基础设施领域正在快速发展,我们完全打算让 Prometheus 随之发展。这意味着我们将继续愿意质疑我们过去所做的事情,并乐于抛弃那些已经失去相关性的东西。Prometheus 将会有新的主要版本,以促进未来的计划,如持久的长期存储、Alertmanager 的更新迭代、内部存储改进以及许多我们甚至还不知道的事情。

结束语

我们要感谢我们出色的社区,感谢他们对新版本进行现场测试、提交错误报告、贡献代码、帮助其他社区成员以及通过参与无数富有成效的讨论来塑造 Prometheus。最终,是你们让 Prometheus 获得成功。

谢谢你们,并继续保持出色的工作!

Prometheus 加入云原生计算基金会

自 Prometheus 诞生以来,我们一直在为该项目寻找独立于任何一家公司的可持续治理模式。最近,我们一直在与新成立的 云原生计算基金会 (CNCF) 进行讨论,该基金会由 Google、CoreOS、Docker、Weaveworks、Mesosphere 和 其他领先的基础设施公司 支持。

今天,我们很高兴地宣布,CNCF 的技术监督委员会 一致投票 接受 Prometheus 作为继 Kubernetes 之后的第二个托管项目!您可以在 CNCF 的官方新闻稿 中找到有关这些计划的更多信息。

通过加入 CNCF,我们希望建立清晰且可持续的项目治理模式,并从独立基金会为其成员提供的资源、基础设施和建议中受益。

我们认为 CNCF 和 Prometheus 是理想的主题匹配,因为两者都专注于带来云的现代愿景。

在接下来的几个月中,我们将与 CNCF 合作,最终确定项目治理结构。当有更多细节要宣布时,我们将汇报。

何时(不)使用 varbit chunks

Prometheus 服务器的嵌入式时间序列数据库 (TSDB) 将每个时间序列的原始样本数据组织成恒定 1024 字节大小的 chunks。除了原始样本数据外,chunk 还包含一些元数据,这些元数据允许为每个 chunk 选择不同的编码。最根本的区别是编码版本。您可以通过命令行标志 -storage.local.chunk-encoding-version 为新创建的 chunk 选择版本。到目前为止,只有两个受支持的版本:0 代表原始 delta 编码,1 代表改进的 double-delta 编码。在 0.18.0 版本中,我们添加了版本 2,它是 double-delta 编码的另一种变体。我们称之为 varbit 编码,因为它涉及 chunk 内每个样本的可变位宽。虽然版本 1 在几乎所有方面都优于版本 0,但版本 1 和版本 2 之间存在真正的权衡。这篇博文将帮助您做出决定。版本 1 仍然是默认编码,因此如果您在阅读本文后想尝试版本 2,则必须通过命令行标志显式选择它。来回切换没有坏处,但请注意,一旦创建,现有 chunk 将不会更改其编码版本。但是,这些 chunk 将根据配置的保留时间逐渐淘汰,因此将被命令行标志中指定的编码的 chunk 替换。

ShowMax 访谈

这是 Prometheus 用户访谈系列的第二篇,让他们分享评估和使用 Prometheus 的经验。

您能告诉我们您自己以及 ShowMax 是做什么的吗?

我是 Antonin Kral,我负责 ShowMax 的研究和架构。在此之前,我在过去的 12 年中担任架构师和 CTO 角色。

ShowMax 是一项订阅视频点播服务,于 2015 年在南非推出。我们拥有广泛的内容目录,其中包含超过 20,000 集电视剧和电影。我们的服务目前在全球 65 个国家/地区可用。当更知名的竞争对手在美洲和欧洲发生冲突时,ShowMax 正在努力解决一个更困难的问题:如何在撒哈拉以南非洲地区几乎没有网络连接的村庄中狂看节目?全球已有 35% 的视频通过流媒体播放,但仍有许多地方这场革命尚未触及。

ShowMax logo

我们正在管理大约 50 个服务,这些服务主要在围绕 CoreOS 构建的私有集群上运行。它们主要处理来自我们客户端(Android、iOS、AppleTV、JavaScript、Samsung TV、LG TV 等)的 API 请求,而其中一些服务在内部使用。最大的内部管道之一是视频编码,在处理大型摄取批次时,它可以占用 400 多台物理服务器。

我们的大多数后端服务都是用 Ruby、Go 或 Python 编写的。在 Ruby 中编写应用程序时,我们使用 EventMachine(MRI 上的 Goliath,JRuby 上的 Puma)。Go 通常用于需要大吞吐量且没有太多业务逻辑的应用程序中。我们对用 Python 编写的 Falcon 服务非常满意。数据存储在 PostgreSQL 和 ElasticSearch 集群中。我们使用 etcd 和自定义工具来配置用于路由请求的 Varnishes。

Life360 访谈

这是 Prometheus 用户访谈系列的第一篇,让他们分享评估和使用 Prometheus 的经验。我们的第一次访谈对象是来自 Life360 的 Daniel。

您能告诉我们您自己以及 Life360 是做什么的吗?

我是 Daniel Ben Yosef,又名 dby,我是 Life360 的基础设施工程师,在此之前,我在过去的 9 年中担任系统工程师角色。

Life360 创造了帮助家庭保持联系的技术,我们是家庭网络应用程序。我们非常忙于处理这些家庭 - 在高峰期,我们每分钟为 7000 万注册家庭提供 70 万个请求。

我们在生产环境中管理大约 20 个服务,主要处理来自移动客户端(Android、iOS 和 Windows Phone)的位置请求,高峰期跨越 150 多个实例。冗余和高可用性是我们的目标,我们努力尽可能保持 100% 的正常运行时间,因为家庭信任我们能够随时可用。

我们将用户数据保存在 MySQL 多主集群和 12 节点的 Cassandra 环中,后者在任何给定时间都保存约 4TB 的数据。我们有使用 Go、Python、PHP 编写的服务,以及计划将 Java 引入我们的堆栈。我们使用 Consul 进行服务发现,当然,我们的 Prometheus 设置也与它集成在一起。

自定义 Alertmanager 模板

Alertmanager 处理 Prometheus 服务器发送的警报,并根据其标签将有关警报的通知发送给不同的接收器。

接收器可以是许多不同的集成之一,例如 PagerDuty、Slack、电子邮件,或通过通用 webhook 接口的自定义集成(例如 JIRA)。

模板

发送给接收器的消息通过模板构建。Alertmanager 附带默认模板,但也允许定义自定义模板。

在这篇博文中,我们将逐步介绍 Slack 通知的简单自定义。

我们使用这个简单的 Alertmanager 配置,它将所有警报发送到 Slack

global:
  slack_api_url: '<slack_webhook_url>'

route:
  receiver: 'slack-notifications'
  # All alerts in a notification have the same value for these labels.
  group_by: [alertname, datacenter, app]

receivers:
- name: 'slack-notifications'
  slack_configs:
  - channel: '#alerts'

默认情况下,Alertmanager 发送的 Slack 消息如下所示

它向我们展示了一个正在触发的警报,后跟警报分组的标签值(alertname、datacenter、app)以及警报共有的其他标签值(critical)。

Prometheus 开源开发一年

开端

一年前的今天,我们正式向更广阔的世界宣布了 Prometheus。这对我们来说是一个很好的机会,回顾过去,分享自那时以来该项目发生的一些精彩的事情。但首先,让我们从头开始。

尽管我们早在 2012 年就已在 GitHub 上以开源项目启动了 Prometheus,但我们最初并没有大张旗鼓地宣传它。我们希望给项目时间成熟,并能够在没有摩擦的情况下进行实验。Prometheus 在 2013 年逐步引入 SoundCloud 用于生产监控,然后在公司内部以及我们在 Docker 和 Boxever 的朋友的早期采用中看到了越来越多的使用。多年来,Prometheus 变得越来越成熟,尽管它已经解决了人们的监控问题,但它仍然不为公众所知。

使用 etcd 的自定义服务发现

之前的帖子中,我们介绍了在 Prometheus 中进行服务发现的众多新方法。从那时起,发生了很多事情。我们改进了内部实现,并收到了我们社区的精彩贡献,增加了对 Kubernetes 和 Marathon 的服务发现的支持。它们将在 0.16 版本中发布。

我们还谈到了自定义服务发现的主题。

并非每种类型的服务发现都足够通用,可以直接包含在 Prometheus 中。您的组织很可能有一个专有系统,您只需要使其与 Prometheus 一起工作。这并不意味着您无法享受自动发现新监控目标的好处。

在这篇文章中,我们将实现一个小实用程序,该程序将基于 etcd(高度一致的分布式键值存储)的自定义服务发现方法连接到 Prometheus。

监控 DreamHack - 世界最大的数字节

编者注:本文是由 Prometheus 用户撰写的客座文章。

如果您正在为 10,000 名要求苛刻的游戏玩家运营网络,您需要真正了解网络内部发生的事情。哦,而且一切都需要在短短五天内从头开始构建。

如果您以前从未听说过 DreamHack,这里是介绍:将 20,000 人聚集在一起,让他们中的大多数人自带电脑。融入专业游戏(电子竞技)、编程竞赛和现场音乐会。结果是世界上最大的完全致力于数字技术的节日。

为了使这样的活动成为可能,需要大量的基础设施到位。这种规模的普通基础设施需要数月才能建成,但 DreamHack 的工作人员仅用五天就从头开始构建一切。这当然包括配置网络交换机之类的东西,还包括构建配电、建立食品和饮料商店,甚至建造实际的桌子。

构建和运营与网络相关的一切的团队正式名称为网络团队,但我们通常将自己称为 techdhtech。这篇文章将重点介绍 dhtech 的工作,以及我们在 2015 年 DreamHack 夏季期间如何使用 Prometheus 来尝试将我们的监控提升到一个新的水平。

实用异常检测

John Allspaw 在他的 给监控/指标/警报公司的公开信 中断言,试图“完美地、在正确的时间检测异常是不可能的”。

我见过一些才华横溢的工程师尝试构建系统,以基于时间序列数据自动检测和诊断问题。虽然当然有可能让演示工作起来,但数据总是太嘈杂,以至于这种方法无法用于任何真实世界的系统,除非是最简单的系统。

不过,并非所有希望都破灭了。有许多常见的异常,您可以使用自定义构建的规则来检测和处理。Prometheus 查询语言 为您提供了发现这些异常的工具,同时避免误报。

Prometheus 0.14.0 中的高级服务发现

本周我们发布了 Prometheus v0.14.0 — 一个包含许多期待已久的新增功能和改进的版本。

在用户方面,Prometheus 现在支持新的服务发现机制。除了 DNS-SRV 记录外,它现在还开箱即用地支持 Consul,并且基于文件的接口允许您连接自己的发现机制。随着时间的推移,我们计划向 Prometheus 添加其他常见的服务发现机制。

除了许多较小的修复和改进之外,您现在还可以通过向 Prometheus 进程发送 SIGHUP 在运行时重新加载您的配置。有关更改的完整列表,请查看 此版本的更改日志

在这篇博文中,我们将仔细研究内置的服务发现机制,并提供一些实际示例。作为补充资源,请参阅 Prometheus 的配置文档

Prometheus 监控在互联网上传播

自从我们公开发布 Prometheus 0.10.0 版本以来已经快三个月了,我们现在已经发布了 0.13.1 版本。

SoundCloud 的公告博文 仍然是对 Prometheus 关键组件的最佳概述,但是围绕 Prometheus 还有许多其他在线活动。这篇文章将让您赶上您错过的任何内容。

将来,我们将使用此博客发布更多文章和公告,以帮助您充分利用 Prometheus。