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 在之前的协议版本上进行了迭代,增加了对大量新元素的本机支持,包括元数据、exemplars、创建时间戳和原生直方图。它还使用字符串驻留来减少压缩和解压缩时的有效负载大小和 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 和内存使用方面的效率提升。下面您可以看到 3 个 Prometheus 版本在具有 8 个 CPU 和 49 GB 可分配内存的节点上的性能数字。

  • 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 升级,请查看迁移指南,了解有关您需要进行的任何调整的更多信息。请注意,我们强烈建议您先升级到 v2.55,然后再升级到 v3.0。可以从 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 在之前的协议版本上进行了迭代,增加了对大量新元素的本机支持,包括元数据、exemplars、创建时间戳和原生直方图。它还使用字符串驻留来减少压缩和解压缩时的有效负载大小和 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

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

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

我们对 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 我们对原生/指数直方图的支持。

支持 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 远程写入已获得 大多数领先的可观测性项目和供应商 的支持。但是,OpenTelemetry 协议 (OTLP) 正在变得越来越重要,我们希望在整个 Prometheus 生态系统中支持它。

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

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

增量时序

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

我们希望在 Prometheus 服务器中支持 OpenTelemetry 的增量时序,并且正在 为此努力

呼吁贡献!

如您所见,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 现已进入第八届,汇集了来自世界各地的 Prometheus 用户和开发人员,以交流知识、最佳实践和使用 Prometheus 获得的经验。计划委员会审查了 66 份提交,这些提交将对当今围绕 Prometheus 最紧迫的主题提供新鲜且信息丰富的视角。

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

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

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

注册

注册 参加线下标准定价为 350 美元的活动,截止日期为 9 月 25 日。场地可容纳 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 String Labels 优化常见问题解答

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 二进制文件中。Agent 模式禁用了 Prometheus 的一些常用功能,并优化了二进制文件,用于抓取和远程写入到远程位置。引入减少功能的模式可以实现新的使用模式。在这篇博文中,我将解释为什么它对于 CNCF 生态系统中的某些部署来说是一个游戏规则改变者。我对此感到非常兴奋!

转发用例的历史

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

Prometheus high-level view

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

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

Yoda

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

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

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

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

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

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

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

Prometheus global view

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

Remote Write

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

虽然官方的 Prometheus Remote Write API 规范正在审查阶段,但生态系统已将 Remote Write 协议作为默认指标导出协议采用。例如,Cortex、Thanos、OpenTelemetry 以及 Amazon、Google、Grafana、Logz.io 等云服务都支持通过 Remote Write 摄取数据。

Prometheus 项目还为其 API 提供了官方合规性测试,例如 remote-write sender compliance,适用于提供 Remote Write 客户端功能的解决方案。这是一种快速判断您是否正确实现此协议的绝佳方法。

从这样的抓取器流式传输数据可以通过允许您将指标数据存储在集中位置来启用全局视图用例。这也实现了关注点分离,这在应用程序由与可观测性或监控管道不同的团队管理时很有用。此外,这也是供应商选择 Remote Write 的原因,他们希望尽可能多地从客户那里卸载工作。

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

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

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

Remote Write 实践示例:Katacoda 教程

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

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

请注意,此示例使用 Thanos 在接收模式下作为远程存储。如今,您可以使用许多其他与 remote write 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 服务器或任何其他与 Remote-Write 兼容的项目,则可以将其用作 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 对 agent 并为它们附加持久磁盘。但从技术上讲,如果我们有数千个指标目标(例如容器),我们可以部署多个 Prometheus agent,并安全地更改哪个副本正在抓取哪些目标。这是因为,最终,所有样本都将被推送到相同的中央存储。

总的来说,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 一致性,软件可以符合特定测试,从而产生兼容性评级。术语可能看起来很复杂,但这使我们能够讨论这个主题,而无需使用无休止的文字蛇。

序言

新类别

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

  • 指标公开器
  • Agent/收集器
  • Prometheus 存储后端
  • 完全 Prometheus 兼容性

行动号召

非常欢迎反馈。也许与直觉相反,我们希望社区,而不仅仅是 Prometheus 团队,来塑造这项工作。为了帮助实现这一目标,我们将在 Prometheus 内启动一个 WG Conformance。与 WG DocsWG Storage 一样,这些 WG 将是公开的,我们积极邀请参与。

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

注册进行测试

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

测试结果

完全 Prometheus 兼容性

我们知道我们想要构建哪些测试,但我们尚未完成。正如之前宣布的那样,以此来反对项目或供应商是不公平的。因此,测试 shim 被定义为已通过。例如 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 Prometheus 托管服务
  • Google Cloud Prometheus 托管服务
  • New Relic
  • Sysdig Monitor

注:由于 Amazon Prometheus 托管服务与 Grafana Cloud 一样基于 Cortex,我们预计它们会在下一次更新周期后通过测试。

Agent/采集器

通过

  • 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 一致性计划:Remote Write 合规性测试结果

正如 CNCF 宣布 以及 我们自己宣布 的那样,我们正在启动 Prometheus 一致性计划。

为了让大家在正式运行测试之前了解生态系统的概况,我们想展示我们这个小而愉快的测试套件家族的最新成员:Prometheus Remote Write 合规性测试套件根据我们的规范测试 Remote Write 协议的发送方部分。

在周一的 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)

我们将更加努力改进我们的测试套件,包括添加更多测试和添加新的测试目标。如果您想帮助我们,请考虑添加更多我们的 Remote Write 集成列表中的内容。

Prometheus 一致性计划介绍

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

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

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

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

  • PromQL(需要手动解释,基本完整)
  • Remote Read-Write(完全自动化,正在进行中)
  • OpenMetrics(部分自动化,基本完整,需要问卷)

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

Prometheus 一致性计划的工作方式如下

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

对于任何完整的软件,都会有一个 “Prometheus x.y compatible” 标记,例如 “Prometheus 2.26 compatible”。相关的组件合规性得分相乘。达到 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() 修复,以下查询绘制了 http_requests_total 中那些最近 1 小时 速率排在前 5 名的序列的 1 分钟 速率。因此,现在即使作为范围查询,您也可以理解 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 的重大突破性更改,则它将在下一个主要版本之前保持禁用状态。

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

Remote Read 遇到流式传输

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

在本文中,我想深入探讨我们在 remote 协议中所做的更改、更改的原因以及如何有效地使用它。

Remote API

自 1.x 版本以来,Prometheus 能够使用 remote API 直接与其存储进行交互。

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

  • Write - 接收 Prometheus 推送的样本
  • Read - 从 Prometheus 拉取样本

Remote read and write architecture

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

Remote Write

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

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

Remote Read

read 方法不太常见。它于 2017 年 3 月 添加(服务器端),此后未见重大发展。

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

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

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

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

remote read 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;
}

Remote read 返回匹配的时间序列,其中包含值和时间戳的原始样本。

问题陈述

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

不带流式传输的 remote read 的服务器算法是

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

remote read 的整个响应必须以原始的、未压缩的格式缓冲,以便在将其发送到客户端之前将其编组为可能巨大的 protobuf 消息。然后,必须在客户端再次完全缓冲整个响应,以便能够从接收到的 protobuf 中解组它。只有在那之后,客户端才能使用原始样本。

这意味着什么?这意味着,假设请求仅 8 小时,匹配 10,000 个序列,客户端和服务器各自可能需要分配高达 2.5GB 的内存!

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

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

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

这很好,但是一种非常常见的技术是以这种方式组合查询,即查询返回聚合的 20 个序列,但是底层查询引擎必须接触可能数千个序列才能评估响应(例如,当使用 聚合器 时)。这就是为什么像 Thanos 这样的系统,除其他数据外,还使用来自 remote read 的 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,从而从文件系统中存储的块中逐个最佳地获取序列,从而最大限度地减少分配。

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

现在,STREAMED_XOR_CHUNKS remote read 的响应是一组 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];
}

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

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

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

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

基准测试

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

让我们比较 Prometheus 2.12.02.13.0 之间的 remote read 特性。至于本文开头介绍的初始结果,我使用 Prometheus 作为服务器,Thanos sidecar 作为 remote read 的客户端。我通过使用 grpcurl 对 Thanos sidecar 运行 gRPC 调用来调用测试 remote read 请求。测试是在我的笔记本电脑 (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 几乎看不到任何分配。这证明我们的 remote read 每个请求使用恒定内存,无论您请求多少样本。每个请求分配的内存也大大减少了数据基数的影响,因此像以前一样获取的序列数量减少了。

这有助于在并发限制的帮助下,更轻松地针对用户流量进行容量规划。

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 倍。

延迟

由于流式传输和更少的编码,我们也成功降低了 remote read 请求延迟。

具有 10,000 个序列的 8 小时范围的 Remote read 请求延迟

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 端的处理和编组。

兼容性

Remote read 以向后和向前兼容的方式进行了扩展。这归功于 protobuf 和 accepted_response_types 字段,旧服务器会忽略该字段。同时,如果旧客户端假定旧的 SAMPLES remote read 没有 accepted_response_types,则服务器也可以正常工作。

remote read 协议以向后和向前兼容的方式进行了扩展

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

用法

要在 Prometheus v2.13.0 中使用新的流式 remote read,第三方系统必须将 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 从此改进中获益匪浅。流式 remote read 已添加到 v0.7.0 中,因此,只要 Prometheus 2.13.0 或更高版本与 Thanos sidecar 一起使用,此版本或任何后续版本都将自动使用流式 remote read。

下一步

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

总结

总而言之,分块、流式 remote read 的主要优点是

  • 客户端和服务器都能够实际使用每个请求的恒定内存大小。这是因为 Prometheus 在 remote read 期间只发送一个个小的帧,而不是整个响应。这极大地帮助了容量规划,特别是对于像内存这样的不可压缩资源。
  • 在 remote read 期间,Prometheus 服务器不再需要将 chunks 解码为原始样本。客户端编码也是如此,如果系统正在重用原生 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) 的系统工程师。顾名思义,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 collector 公开自定义的业务相关指标。

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

新的设置将我们的时间分辨率从 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。至关重要的是,如果主节点宕机,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 团队在 2018 年慕尼黑举行的 Prometheus Dev Summit 上就子查询的语法达成了共识。这些是 关于子查询支持的峰会记录,以及用于实现子查询支持的语法的简要 设计文档

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

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

示例

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

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 托管平台,面向出版商、企业品牌和数字机构,他们寻求始终如一地为网站访问者提供无缝体验。

最近,我们为我们的核心产品——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?

在巴塞罗那举行的 Velocity Europe 2014 上,在与 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 服务器。作为我们 Kubernetizing 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 结构转换为 JSON 以用于 file_sd 格式。

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

自定义 SD 实现

现在我们想实际使用 Adapter 来实现我们自己的自定义 SD。一个完整的工作示例在同一个 examples 目录 here 中。

在这里,您可以看到我们正在导入适配器代码 "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(一些详细说明 here),并将其配置为开始从 Envoy 收集统计信息。我们还根据另一位 Ambassador 贡献者的一些工作设置了 Grafana 仪表板 based on some work

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

我们的工程师现在可以了解 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 扩展(甚至无法工作),因为容器会随着我们的工作负载变化而来来去去。

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

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

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

我们对 Prometheus 的未来感到非常兴奋,尤其是在我们正朝着 2.x 系列迈进,以及 CNCF 协作似乎进展顺利的情况下。

Prometheus 在 CloudNativeCon 2017

Prometheus 在 CloudNativeCon 2017

12 月 6 日星期三是 CloudNativeCon Austin 的 Prometheus 日,我们为您准备了精彩的演讲和活动。前往 Prometheus Salon 获取有关如何最好地监控 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 版本。除了新存储层中的各种错误修复之外,它还包含一些计划中的重大更改。

Flag 更改

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

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

记录规则更改

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

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

  • 所有规则都是并发评估的,这实际上是 Prometheus 最古老的未解决的 bug。这有两个问题,显而易见的一个是,如果您有很多规则,则在每个评估间隔负载都会飙升。另一个是,相互依赖的规则可能会被馈送过时的数据。例如

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 本身是由另一个规则生成的。只有在记录了 instance:network_bytes:rate1m 的当前值之后运行警报 HighNetworkTraffic,我们才能获得预期的结果。

  • 规则和警报要求用户学习另一种 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 稳定版迈进!您可以在我们的问题跟踪器上报告错误,并通过我们的社区渠道提供一般反馈。

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 数据库中,该应用程序创建一个实时楼层地图。这使我们只需简单地将鼠标悬停在地图上,即可知道哪个用户坐在哪里,使用什么类型的硬件。我们还创建了另一个页面,其中包含用户的照片和部门信息,这有助于新员工了解他们的邻居是谁。该网站仍然是一个正在进行中的项目,所以请不要评价外观,毕竟我们是系统管理员,而不是 Web 设计师 :-)

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 的系统工程师。我在 60 人的研发部门中工作,团队由 5 名系统工程师组成。我们的工作主要是确保应用程序、服务和底层系统正常运行。我们与开发人员合作,以确保他们的代码能够最轻松地投入生产,并在每个步骤提供必要的反馈。这就是监控的重要性所在。

iAdvize 是一个全栈对话式商务平台。我们为品牌提供了一种简单的方式来集中与其客户互动,无论沟通渠道是什么(聊天、电话、视频、Facebook 页面、Facebook Messenger、Twitter、Instagram、WhatsApp、SMS 等)。我们的客户遍布电子商务、银行、旅游、时尚等领域,覆盖 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 exporterPercona dashboard for grafana。这非常成功,使我们能够发现效率低下之处并进行优化,从而将数据库大小减少了 45%,峰值延迟减少了 75%。

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

可见性非常棒。

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

越来越多的微服务将被部署在云端,Prometheus 用于监控它们。我们使用 Consul 注册服务,并使用 Prometheus 发现指标路由。一切都运行良好,我们能够构建一个 Grafana 仪表板,其中包含许多关键的业务、应用程序和系统指标。

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

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

我们使用 Alertmanager 通过 SMS 或发送到我们的 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

这是一个非常早期的版本,应该预料到崩溃、数据损坏和一般错误。通过将它们提交到 我们的问题跟踪器,帮助我们朝着稳定版本迈进。

实验性远程存储 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 系统会在我们更改配置时更新它。我们在 Prometheus Pod 中使用了一个小型 sidecar 容器来监视配置文件,并在配置文件更改时 ping Prometheus。这意味着我们不必经常重启 Prometheus,可以无需为存储做任何花哨的事情,并且不会丢失历史记录。

仍然是周期性丢失 Prometheus 历史记录的问题困扰着我们,而可用的解决方案,例如 Kubernetes 卷或周期性 S3 备份,都有其缺点。加上我们使用 Prometheus 监控 Scope 服务的绝佳体验,这促使我们构建了一个云原生、分布式的 Prometheus 版本 - 它可以升级、随意移动并在主机故障中幸存下来,而不会丢失历史记录。这就是 Weave Cortex 的诞生方式。

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

暂且忽略 Cortex,我们特别兴奋地看到 HA Alert Manager 的推出;主要是因为它最初是 首批使用 Weave Mesh(我们的 gossip 和协调层)的非 Weaveworks 项目之一。

我也特别热衷于 Fabian 提出的 Kubernetes 服务发现的第二个版本更改 - 这解决了我们在监控 Consul Pod 时遇到的一个严重问题,我们需要抓取同一 Pod 上的多个端口。

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

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

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

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

我还有一个名为 Loki 的小项目,它将 Prometheus 服务发现和抓取引入 OpenTracing,使分布式追踪变得简单而强大。我将在三月底在柏林举行的 KubeCon/CNCFCon 上就此发表演讲,演讲链接为 talk about this at KubeCon/CNCFCon Berlin

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 人的工程团队,构建和运营着一个完全容器化的堆栈,其中包含约 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 处理程序、Go 运行时)帮助我们非常快速地获得了投资回报 - 仅 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 卷的大型实例,然后直接使用了用于 Prometheus 的 社区 chef cookbook

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

我们正在测试单个 Prometheus 可以扩展到多远,并等待它崩溃。它没有崩溃!事实上,它以非常少的资源使用量处理了每 15 秒抓取一次的主机级指标的负载,这些指标来自我们较新的基础设施中的大约 450 台主机。

我们在每台主机上都有很多容器,因此我们预计一旦我们添加所有这些容器的内存使用情况指标,我们将不得不开始分片 Prometheus,但 Prometheus 仍在继续运行,没有任何问题,并且仍然没有太接近饱和其资源。我们目前每 15 秒监控超过 400,000 个不同的指标,这些指标来自 450 台主机上的大约 40,000 个容器,使用单个 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 万个 Droplets(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 中获得的数据大致相同,但对于我们的 golang 开发人员团队来说,创建新的自定义导出器来公开特定于我们在每个虚拟机监控程序上运行的服务的数据要容易得多。

我们正在公开更好的应用程序指标。学习和教授如何创建稍后可以正确聚合的 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 万用户导入了数据。

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

ShuttleCloud by Numbers

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

一开始,我们基础设施的适当监控系统并不是我们的主要优先事项之一。我们没有像现在这样多的项目和实例,因此我们使用其他简单的系统来提醒我们是否有任何东西无法正常工作并将其控制住。

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

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

我们开发了以下系统

Initial Shuttlecloud System

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

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

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

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

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

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

您为什么决定关注 Prometheus?

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

  • 首先,您不必定义固定的指标系统即可开始使用它;将来可以添加或更改指标。当您还不知道要监控的所有指标时,这提供了宝贵的灵活性。
  • 如果您对 Prometheus 有所了解,您就会知道指标可以具有标签,这些标签使我们摆脱了正在考虑不同时间序列的事实。这与其查询语言相结合,提供了更大的灵活性和强大的工具。例如,我们可以为不同的环境或项目定义相同的指标,并获得特定的时间序列或使用适当的标签聚合某些指标
    • http_requests_total{job="my_super_app_1",environment="staging"} - 对应于应用程序“my_super_app_1”的暂存环境的时间序列。
    • http_requests_total{job="my_super_app_1"} - 应用程序“my_super_app_1”的所有环境的时间序列。
    • http_requests_total{environment="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 - 圆满结束!

发生了什么

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

Pull 模式无法扩展 - 真的吗?

让我们来谈谈一个特别持久的误解。每当讨论监控系统以及 Prometheus 基于 pull 模式的指标收集方法时,总有人会插话说,基于 pull 模式的方法“从根本上无法扩展”。给出的理由通常很模糊,或者仅适用于与 Prometheus 从根本上不同的系统。事实上,在最大规模的 pull 模式监控方面工作过的人会发现,这种说法与我们自己的运营经验相悖。

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

Prometheus 不是 Nagios

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

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

谁发起连接并不重要

出于扩展目的,谁发起用于传输指标的 TCP 连接并不重要。无论你采用哪种方式,建立连接的工作量与指标负载和其他所需工作相比都很小。

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

此外,尽管现在的网络非常可靠,但使用基于 TCP 的 pull 模式可以确保指标数据可靠地到达,或者监控系统至少可以立即知道指标传输因网络中断而失败。

Prometheus 不是基于事件的系统

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

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

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

使用 pull 模式,你的监控系统需要知道哪些服务实例存在以及如何连接到它们。有些人担心这需要在监控系统方面进行额外的配置,并将此视为运营扩展性问题。

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

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

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

意外地 DDoS 攻击你的监控系统

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

真实世界的证明

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

但是 pull 模式还有其他问题!

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

一切都很好吗?

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

Prometheus 达到 1.0 版本

今年 1 月,我们发布了一篇关于 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 为新创建的 chunks 选择版本。到目前为止,仅支持两个版本:0 用于原始 delta 编码,1 用于改进的 double-delta 编码。在 0.18.0 版本中,我们添加了版本 2,它是 double-delta 编码的另一种变体。我们称之为 varbit 编码,因为它涉及 chunk 内每个样本的可变位宽。虽然版本 1 在几乎所有方面都优于版本 0,但在版本 1 和 2 之间存在真正的权衡。这篇博文将帮助你做出决定。版本 1 仍然是默认编码,因此如果你在阅读本文后想尝试版本 2,则必须通过命令行标志显式选择它。来回切换没有危害,但请注意,一旦创建,现有 chunks 将不会更改其编码版本。但是,这些 chunks 将根据配置的保留时间逐渐淘汰,因此将被命令行标志中指定的编码的 chunks 替换。

ShowMax 访谈

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

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

我是 Antonin Kral,我领导 ShowMax 的研究和架构。在此之前,我在过去 12 年中担任架构和 CTO 职务。

ShowMax 是一项订阅视频点播服务,于 2015 年在南非推出。我们拥有广泛的内容目录,其中包含超过 20,000 集电视剧和电影。我们的服务目前在全球 65 个国家/地区可用。当更知名的竞争对手在美国和欧洲发生冲突时,ShowMax 正在与一个更困难的问题作斗争:如何在撒哈拉以南非洲几乎没有网络连接的村庄中进行 binge-watch?全球已有 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 的朋友在 2014 年的早期采用。多年来,Prometheus 变得越来越成熟,尽管它已经解决了人们的监控问题,但它仍然不为公众所知。

使用 etcd 的自定义服务发现

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

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

并非所有类型的服务发现都足够通用,可以直接包含在 Prometheus 中。您的组织很可能已经部署了专有系统,而您只需要使其与 Prometheus 协同工作。但这并不意味着您无法享受自动发现新监控目标的优势。

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

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

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

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

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

为了使这样一个活动成为可能,需要部署大量基础设施。这种规模的普通基础设施需要数月才能建成,但 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。