Dev48
ЯЗЫК
  • О нас
  • Услуги
  • Индустрии
  • Технологии
  • Статьи
  • Контакты
Забронировать звонок
    Главная/Статьи/Kak my masshtabirovali agregatsiyu metrik perenesya dolgovechnoe sostoyanie v hr
Dev48
info@dev48.org+375 29 320-40-96WhatsApp@isky_by

© 2026 · Все права защищены.

Как мы масштабировали агрегацию метрик, перенеся долговечное состояние в хранилище

Источник: Datadog•17 ноября 2026 г. в 15:54

Как мы масштабировали агрегацию метрик, перенеся долговечное состояние в хранилище

Узнайте, как в Datadog эволюционировала агрегация метрик: от фиксированного владения разделами к передаваемому состоянию и, в конечном итоге, к сверке на стороне хранилища.

Каждое новое поколение системы агрегации метрик Datadog должно было поддерживать объем метрик примерно в 10 раз больше, чем предыдущее. По мере роста объема управление состоянием агрегации и его восстановление стали главным ограничением масштабируемости системы.

Агрегация метрик должна обеспечивать корректность результатов даже в случаях, когда данные поступают с задержкой, доставляются более одного раза или процесс обработки прерывается. Наш первоначальный подход соответствовал этому требованию за счет хранения исторического состояния в непосредственной близости от выполняемой работы. Это хорошо работало при начальных масштабах, но дальнейший рост сделал восстановление, горизонтальное масштабирование и повседневную эксплуатацию все более сложными.

Мы переработали систему в течение трех поколений, перейдя от фиксированного владения разделами к передаваемому состоянию и, наконец, к архитектуре, в которой хранилище выполняет сверку частичных агрегатов, дубликатов и данных, поступивших с задержкой. В этой статье объясняется, как перенос ответственности за долговечную корректность изменил модель масштабирования и восстановления системы, почему каждая архитектура в конечном итоге достигала своего предела и как дизайн третьего поколения позволяет потоковому уровню возобновлять работу с «живого» края без предварительного восстановления многочасового исторического состояния агрегации.

Почему агрегация метрик становится проблемой управления состоянием

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

Datadog позволяет клиентам выбирать, какие теги останутся доступными для запросов к метрике. Удаление ненужных измерений тегов уменьшает объем индексируемых пользовательских метрик, что может снизить затраты и повысить производительность запросов, сохраняя при этом математически точные результаты по оставшимся измерениям.

Рассмотрим сервис, работающий на 100 подах. Каждый под сообщает распределение service.request.duration с такими тегами, как env, region, service, endpoint и pod_name. Пользователи могут захотеть анализировать задержку сервиса по регионам или конечным точкам, не сохраняя отдельный запрашиваемый ряд для каждого пода. Сохраняя только env, region, service и endpoint, Datadog может объединить распределения на уровне подов в меньшее количество индексируемых рядов метрик, при этом вычисляя глобально точные процентили.

Для метрик распределения каждый источник отправляет компактный DDSketch, представляющий наблюдаемые им значения. Эти эскизы (sketches) можно объединять без хранения каждого отдельного измерения, сохраняя при этом точные вычисления процентилей.

Сервис агрегации на бэкенде должен:

  • Сокращать данные с метками времени из N измерений в M измерений, где M меньше N.

Сокращать данные с метками времени из N измерений в M измерений, где M меньше N.

  • Агрегировать данные за короткие временные интервалы, например, 10 секунд.

Агрегировать данные за короткие временные интервалы, например, 10 секунд.

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

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

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

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

Три описанных ниже проекта не были заменой «один к одному» и не ограничивались одним типом метрик. Статическое секционирование, например, использовалось как в системах точечных метрик, так и в системах метрик распределения. Мы представляем эти проекты как три поколения, потому что они иллюстрируют более широкую архитектурную прогрессию от фиксированного владения к передаваемому состоянию и, наконец, к потоковому уровню, который делегирует долговечную сверку хранилищу. Каждый из них решал одну и ту же фундаментальную проблему: сокращение размерности метрик при сохранении корректности в условиях повторных попыток, задержек данных, сбоев и восстановления.

Первое поколение: Агрегация с сохранением состояния и статическим назначением

Наш первый сервис распределенной агрегации вырос из нашего опыта эксплуатации Kafka. Он следовал привычному шаблону: потреблять полезные нагрузки из брокера сообщений, агрегировать их и передавать результаты в нижестоящее хранилище.

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

Для каждой полезной нагрузки сервис декодировал и дедуплицировал данные, выбирал настроенные теги и объединял DDSketch в соответствующий бакет агрегации. Последние бакеты хранились в памяти, в то время как RocksDB сохранял несколько часов бакетов и идентификаторов дедупликации, чтобы данные с задержкой все еще могли быть включены. Сервис периодически сбрасывал последнюю версию каждого бакета в нижестоящее хранилище.

Такой дизайн делал каждый экземпляр агрегации состоянием. Система принимала данные, поступающие с задержкой, в пределах ограниченного временного окна. После перезапуска без использования локального состояния экземпляру приходилось потреблять полный интервал данных, прежде чем он мог начать сброс результатов. Этот период прогрева делал перезапуски операционно неудобными.

Каждая статически назначенная группа разделов имела лидера и последователя. Оба экземпляра выполняли работу по агрегации, но в нормальных условиях только лидер записывал результаты в нижестоящее хранилище. Если лидер выходил из строя, последователь мог взять управление на себя с минимальным перерывом, поскольку его состояние было почти актуальным. Однако восстановление экземпляра с нуля все равно требовало полного периода прогрева. Полученная модель статического владения выглядела так:

Модель «лидер-последователь» обеспечивала высокую доступность, но оба узла выполняли одну и ту же работу по агрегации, хотя обычно только лидер записывал данные в нижестоящее хранилище. Это фактически удваивало вычислительные затраты на агрегацию и затрудняло горизонтальное масштабирование. Поскольку разделы были назначены конкретным развертываниям и размерам экземпляров, добавление реплик не приводило к автоматическому перераспределению работы.

Когда раздел становился слишком большим, инженерам приходилось вручную разделять его назначение. Это требовало создания новых диапазонов разделов, обновления конфигурации, развертывания сменных лидеров и последователей, координации переключения, проверки смещений Kafka и выходных данных, а также удаления старого развертывания. Одно задокументированное разделение потребовало около 1,5 часов скоординированной инженерной работы. Количество скоординированных шагов делало процедуру хрупкой и создавало риски для корректности.

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

Второе поколение: Агрегация с сохранением состояния и динамическим назначением

Второе поколение отделило владение разделами от отдельных экземпляров.

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

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

Каждый узел поддерживал свое локальное состояние в RocksDB. Это состояние содержало корзины агрегации и информацию о дедупликации, необходимые для включения запоздалых данных и безопасной обработки сообщений, охватывающих несколько часов. Однако, в отличие от архитектуры первого поколения, локальная база данных больше не была единственной копией. Каждый узел непрерывно выгружал инкрементальные изменения SSTable в хранилище больших двоичных объектов (blob storage), позволяя другому узлу восстановить состояние после переназначения.

Загрузка всего состояния после каждого переназначения была бы слишком дорогой и медленной. Поскольку большинство данных поступало вовремя, узлу обычно требовалось только самое последнее состояние, чтобы возобновить обработку текущих данных. Мы разделили состояние RocksDB на временные окна, чтобы новый узел мог сначала восстановить самое последнее окно и загружать более старые окна только тогда, когда они требовались для запоздалых данных. Это позволило быстро возобновить текущую обработку, в то время как историческое состояние восстанавливалось по требованию.

Эта конструкция улучшила производительность восстановления и снизила общие затраты. Она также позволила нам внедрить модель автоматического масштабирования для выделения ресурсов. Автомасштабировщик должен был учитывать не только использование процессора. Ему также нужно было учитывать, сколько состояния будет перемещено, сколько времени займет восстановление и смогут ли оставшиеся узлы продолжать обработку, пока разделы переназначаются.

Мы настроили это поведение, используя эвристики, разработанные в ходе экспериментов. Слишком медленное масштабирование могло привести к тому, что служба не успевала бы за входящими данными. Слишком агрессивное масштабирование могло спровоцировать множество одновременных восстановлений состояния, увеличивая нагрузку вместо ее снижения.

После миграции мы смогли поддерживать примерно в 10 раз большие объемы метрик при минимальном операционном вмешательстве.

По мере роста рабочих нагрузок наших клиентов управление состоянием стало основным источником сложности системы. Локальные базы данных, удаленные снимки, окна восстановления и переназначение разделов — все это должно было работать вместе корректно. Инциденты выше по потоку и большие объемы повторной обработки данных могли заставить многие узлы восстанавливать или расширять свое состояние одновременно, что сделало восстановление состояния следующим узким местом масштабирования.

Третье поколение: потоковая передача с максимальными усилиями и согласование на стороне хранилища

Третье поколение началось с другой предпосылки: службе потоковой агрегации не нужно владеть окончательным долговечным агрегатом.

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

Мы спроектировали новую службу так, чтобы агрегация и дедупликация на уровне потоковой передачи выполнялись по принципу «максимальных усилий». Во время нормальной работы она объединяла как можно больше своевременных данных и отбрасывала повторные попытки, которые могла распознать в своем активном окне. Запоздалые данные, повторная обработка и работа, которую нельзя было завершить немедленно, продолжали поступать в хранилище, вместо того чтобы блокировать «живой» конвейер. Долговечная корректность больше не могла зависеть от того, что уровень потоковой передачи помнит каждый предыдущий ввод.

Наша система хранения имеет два уровня: один оптимизирован для недавних данных в реальном времени, а другой — для долгосрочного хранения. Оба уровня хранения должны были понимать формат, представляющий частичные агрегаты, а не отдельные точки. Каждый частичный агрегат идентифицирует свой ряд и временную корзину, определяет, как он должен быть объединен с другими вкладами, и включает достаточно информации для обнаружения дубликатов. Система хранения группирует вклады для одного и того же ряда и корзины, удаляет дубликаты и объединяет оставшиеся результаты. Она применяет эти правила всякий раз, когда записи объединяются, как при чтении на разных уровнях хранения, так и во время фоновой компакции. Компакция постепенно консолидирует результаты, в то время как тот же процесс включает запоздалые или неупорядоченные данные без повторного воспроизведения исходного потока или восстановления предыдущего состояния рабочего процесса агрегации. Представление сохраняется по мере перемещения данных из недавнего хранилища в долгосрочное, что обеспечивает согласованность согласования на обоих уровнях.

Эта конструкция изменила границу корректности системы. Служба агрегации могла отдавать приоритет текущему трафику, не сохраняя несколько часов долговечного состояния. Хранилище стало отвечать за объединение результатов быстрого пути с данными, поступающими по более медленным путям.

Эта ответственность не была полностью новой для уровня хранения. Еще до того, как мы внедрили потоковую предварительную агрегацию, механизм хранения временных рядов Datadog должен был согласовывать запоздалые и неупорядоченные записи. Расширение этого специализированного пути согласования позволило нам вынести состояние долговечной агрегации из службы потоковой передачи, вместо того чтобы воспроизводить ту же ответственность в базе данных RocksDB каждого рабочего процесса.

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

Перенос долговечной корректности в хранилище также изменил модель восстановления. Уровень потоковой передачи мог сброситься до «живого» края, пока хранилище согласовывало отложенные данные вне пути обработки в реальном времени.

Удаление долговечного локального состояния также изменило модель затрат системы. Рабочим процессам потоковой передачи больше не требовались диски, рассчитанные на несколько часов состояния RocksDB, постоянная выгрузка инкрементального состояния или загрузка больших снимков при перемещении разделов. Это позволило нам выделять ресурсы для потокового парка под текущий трафик, а не под худший сценарий стоимости одновременного восстановления множества рабочих процессов с состоянием.

Это поколение также ознаменовало наше первое использование платформы потоковой передачи Datadog для службы агрегации. Прямая эксплуатация Kafka требовала специальных инструментов для восстановления, управления группами потребителей, проверки состояния, обработки перегрузок и сброса потребителей до «живого» края. Эти возможности были необходимы, но их поддержка не была тем, на что команда агрегации хотела тратить свое время. Переход на платформу, которая их предоставляла, устранил большую часть этой операционной работы и позволил команде сосредоточиться на самой системе агрегации.

Развертывание подтвердило эффективность новой модели восстановления в промышленной среде. Во время одного из инцидентов нам потребовалось сбросить обработку до актуального состояния (live edge). Оператор выполнил сброс непосредственно через пользовательский интерфейс Streaming Platform, в то время как хранилище взяло на себя отложенную агрегацию.

Этот инцидент продемонстрировал главное преимущество архитектуры: для восстановления текущего трафика больше не требовалось предварительно реконструировать все историческое состояние агрегации. На протяжении трех поколений системы долговечное состояние перемещалось от фиксированных потребителей к динамически назначаемым, а затем — в хранилище для сверки.

Как развивалась архитектура

Ни одно из проектных решений не было универсально лучшим. Каждое из них соответствовало масштабу и эксплуатационным ограничениям, с которыми система сталкивалась в то время.

Вынос состояния за пределы критического пути восстановления

На протяжении трех поколений центральной задачей было определение того, где должно находиться состояние и какой объем данных необходимо восстановить, прежде чем обработка сможет продолжиться. Статическое владение обеспечивало локальную корректность, но для масштабирования инженерам приходилось вручную изменять топологию развертывания. Ограничение корректности стало ограничением масштабируемости. Возможность передачи состояния позволила динамически масштабироваться, но его перемещение и реконструкция в конечном итоге стали новым «узким местом».

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

Более общий урок заключается в том, что состояние не обязательно должно исчезать, чтобы уровень обработки стал проще в масштабировании. Когда восстановление становится «узким местом», перемещения состояния между воркерами может быть недостаточно. Размещение долговечного состояния на уровне, предназначенном для его хранения и сверки, позволяет сохранить корректность, исключив историческое состояние из критического пути для текущих задач.

Если вам интересно создавать распределенные системы, обрабатывающие метрики в больших масштабах, мы нанимаем сотрудников.

Благодарности

Этот пост отражает коллективный опыт и работу нынешних и бывших членов команды агрегации метрик. Хотя я написал итоговый черновик, многие другие люди определяли техническое направление, вносили вклад в код, руководили реализацией и эксплуатировали эти системы в промышленной среде.

Особая благодарность Артему Крылысову, Кристиану Дамианидису, Дэвиду Дос Сантосу и Дмитрию Громову за рецензирование поста, а также Сесилу Греггу, Челси Лю, Эдварду Фарберу, Эвану Бендеру, Айви Цао, Хавьеру Аргуэльо Соса, Джоэлу Барсиаускасу, Джастину Джаффраю, Матиасу Томасу, Павлу Кнапу, Квентину Франсуа, Рохану Пиллаю, Шан Вангу, Стефану Караиванову, Вивеку Неламангале и многим другим, кто помогал проектировать, создавать, мигрировать и эксплуатировать эти системы на протяжении многих лет.

← Все статьи

О чём эта статья

Ещё в разделе «Данные и аналитика»

Все →
Отслеживайте свой стек Azure AI и получите широкое покрытие Azure с Datadog
Datadog

Отслеживайте свой стек Azure AI и получите широкое покрытие Azure с Datadog

Помогайте своей команде писать код быстрее и исследовать больше с помощью Kilo Desktop
Anaconda

Помогайте своей команде писать код быстрее и исследовать больше с помощью Kilo Desktop

Меняйте базу данных, а не кодовую базу: Couchbase Converge в закрытом предварительном просмотре
Couchbase

Меняйте базу данных, а не кодовую базу: Couchbase Converge в закрытом предварительном просмотре

Беженцы, банкоматы и налоговые изменения: что движет криптовалютой в Восточной Европе
Chainalysis

Беженцы, банкоматы и налоговые изменения: что движет криптовалютой в Восточной Европе

Запуск RediSearch, векторных наборов и RedisJSON нативно в Windows с Memurai
Redis

Запуск RediSearch, векторных наборов и RedisJSON нативно в Windows с Memurai

Gartner Magic Quadrant 2026: Системы управления облачными операционными базами данных
Looker

Gartner Magic Quadrant 2026: Системы управления облачными операционными базами данных

Ещё от Datadog

Отслеживайте свой стек Azure AI и получите широкое покрытие Azure с Datadog
Datadog

Отслеживайте свой стек Azure AI и получите широкое покрытие Azure с Datadog

Как проверить, готовы ли ваши рабочие нагрузки EC2 к IMDSv2
Datadog

Как проверить, готовы ли ваши рабочие нагрузки EC2 к IMDSv2

Получайте полезные логи из любого источника с помощью Datadog Auto-Processing
Datadog

Получайте полезные логи из любого источника с помощью Datadog Auto-Processing

Исследуйте человека, стоящего за риском, с помощью Cloud SIEM
Datadog

Исследуйте человека, стоящего за риском, с помощью Cloud SIEM

Где запускать рабочие нагрузки AWS и как ограничить к ним доступ
Datadog

Где запускать рабочие нагрузки AWS и как ограничить к ним доступ

Мониторинг и устранение неполадок на устройствах сотрудников с помощью Datadog End User Device Monitoring
Datadog

Мониторинг и устранение неполадок на устройствах сотрудников с помощью Datadog End User Device Monitoring