Системный дизайн распределённого планировщика задач: cron в масштабе, аренда и at-least-once

Как спроектировать распределённый планировщик задач на system design интервью: хранение расписаний, поиск созревших запусков, аренда с heartbeat, fencing, at-least-once, ретраи, часовые пояса.

12 мин чтениясистемный дизайн · распределённые системы · python · собеседования

Коротко

ВопросРешение в этом разборе
Нагрузка100 млн расписаний, в среднем около 10 тыс. запусков в секунду, пики на круглых минутах
Две частипланировщик решает «когда», исполнители решают «что»; между ними очередь
Поиск созревшихиндекс по next_run_at, разбитый на партиции, у каждой партиции один владелец
Гарантияat-least-once: задача может выполниться дважды, поэтому она обязана быть идемпотентной
Защита от дублейуникальный ключ (job_id, run_at), аренда с heartbeat, fencing token
Сбоипротухшая аренда — запуск забирает другой исполнитель; ретраи с backoff и DLQ
Подводные камничасовые пояса и переход на летнее время, пропущенные запуски, всплеск в 00:00

cron на одной машине работает десятилетиями. Проблемы начинаются, когда расписаний миллионы, машин десятки, и любая из них может умереть посреди задачи. Интервьюер в этой задаче проверяет одно: понимаете ли вы, что «ровно один раз» в распределённой системе не бывает, и что вы с этим делаете.

Общий план секции — в статье про подходы к проектированию систем.

Шаг 1. Требования

ВопросОтвет интервьюераЧто это меняет
Какие задачи?одноразовые «в момент T» и cron-выраженияодна модель: следующий запуск next_run_at
Что значит «выполнить»?вызвать HTTP-эндпоинт или положить сообщениеисполнитель — тонкий, логика у клиента
Точность?до нескольких секундможно опрашивать БД раз в секунду
Можно ли выполнить дважды?лучше нет, но потерять хужеat-least-once + идемпотентность у получателя
Сколько длится задача?от миллисекунд до часанужна аренда с продлением, а не таймаут на всё
Что если система лежала 10 минут?зависит от задачиполитика пропусков: догонять или пропускать

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

Шаг 2. Оценка нагрузки

  • 100 млн активных расписаний. Если в среднем каждое срабатывает раз в 3 часа, это 108/104≈10410^8 / 10^4 \approx 10^4 запусков в секунду.
  • Распределение неравномерное. Люди пишут 0 * * * * и 0 0 * * *, поэтому в начале часа и особенно в полночь UTC приходит всплеск в десятки раз выше среднего.
  • Запись о расписании — около 1 КБ: 108×110^8 \times 1 КБ = 100 ГБ. Плюс история запусков, которая растёт быстрее — её храним с TTL или выносим в отдельное хранилище.

Детали таких прикидок — в статье про оценку на салфетке. Вывод: 100 ГБ расписаний — это одна большая база или несколько шардов, а вот 10 тыс. запусков в секунду с пиками надо разносить по многим исполнителям.

Шаг 3. Модель данных и API

POST   /jobs            {cron: "0 9 * * 1-5", tz: "Europe/Moscow", target: "https://...", payload, retry_policy}
DELETE /jobs/{id}
GET    /jobs/{id}/runs  история запусков

Две таблицы:

  • jobs(job_id, cron, tz, target, payload, next_run_at, partition, enabled) — определения. Индекс по (partition, next_run_at).
  • runs(job_id, run_at, status, owner, lease_until, attempt, result) — конкретные запуски. Первичный ключ (job_id, run_at).

Ключ (job_id, run_at) — главное решение всей задачи. Запуск «отчёт за 9:00 понедельника» существует в системе ровно в одном экземпляре, сколько бы планировщиков ни решили его создать. Дубли на уровне планирования отсекаются базой, а не распределённой блокировкой.

Шаг 4. Архитектура

API ──► БД расписаний (партиции 0..P-1)
              │
   Scheduler-узлы: каждый владеет набором партиций (аренда в etcd/ZooKeeper)
              │  раз в секунду: SELECT ... WHERE partition IN (...) AND next_run_at <= now()
              ▼
       runs (INSERT ... ON CONFLICT DO NOTHING) ──► очередь ──► Workers ──► target
                                                                 │
                                                       heartbeat / complete

Планировщик только находит созревшие расписания, создаёт строку в runs, кладёт её в очередь и сдвигает next_run_at на следующий запуск по cron. Всё это в одной транзакции, а публикация в очередь — через transactional outbox, иначе можно закоммитить сдвиг и не отправить сообщение.

Чтобы два планировщика не сканировали одно и то же, расписания разбиты на партиции по hash(job_id) % P, и у каждой партиции один владелец. Владение — это аренда в etcd или ZooKeeper, как в статье про выбор лидера. Если узел умер, его партиции через несколько секунд разберут другие. Если два узла на короткое время оба считают себя владельцами — ничего страшного: уникальный ключ (job_id, run_at) не даст создать запуск дважды.

Исполнители берут запуски из очереди, ставят аренду, вызывают целевой сервис, продлевают аренду, пока задача идёт, и отмечают результат. Очередь (Kafka, SQS, RabbitMQ — сравнение есть в статье про очереди сообщений) сглаживает пики: в полночь планировщик быстро набивает очередь, а исполнители разбирают её в своём темпе.

Для небольшой системы очередь можно убрать: исполнители забирают задачи прямо из таблицы runs. В Postgres это делается конструкцией FOR UPDATE SKIP LOCKED — каждый воркер берёт строки, которые сейчас никто не держит:

UPDATE runs SET status = 'running', owner = :worker, lease_until = now() + interval '30 seconds', attempt = attempt + 1 WHERE (job_id, run_at) IN ( SELECT job_id, run_at FROM runs WHERE status = 'pending' AND run_at <= now() ORDER BY run_at LIMIT 10 FOR UPDATE SKIP LOCKED) RETURNING job_id, run_at, attempt;

Это честный и популярный вариант до тысяч запусков в секунду. Дальше база становится узким местом, и появляется очередь.

Шаг 5. Аренда, heartbeat и fencing

Исполнитель может умереть посреди задачи. Если просто пометить запуск как running, он останется в этом статусе навсегда. Поэтому вместо «взял» — «арендовал до момента T»:

  • Исполнитель ставит lease_until = now + 30 с и каждые 10 секунд продлевает её (heartbeat).
  • Если аренда протухла, запуск снова доступен, и его заберёт другой исполнитель.
  • Каждый захват увеличивает attempt. Это fencing token: продлить аренду или записать результат может только тот, чей attempt совпадает с текущим.

Последний пункт закрывает самый коварный сценарий. Исполнитель w1 ушёл в долгую GC-паузу, аренда протухла, задачу забрал w2. Потом w1 проснулся и хочет записать «готово». Без fencing он перезапишет состояние, которое уже принадлежит w2. Подробно об этой ловушке — в статье про распределённые блокировки.

Модель на SQLite из стандартной библиотеки Python, которая воспроизводит этот сценарий:

import sqlite3 db = sqlite3.connect(':memory:', isolation_level=None) db.executescript(''' CREATE TABLE runs ( job_id TEXT, run_at INTEGER, -- плановое время запуска status TEXT DEFAULT 'pending', owner TEXT, lease_until INTEGER DEFAULT 0, attempt INTEGER DEFAULT 0, -- он же fencing token PRIMARY KEY (job_id, run_at) -- один запуск на слот, дубли невозможны ); ''') def schedule(job_id, run_at): db.execute('INSERT OR IGNORE INTO runs (job_id, run_at) VALUES (?, ?)', (job_id, run_at)) def claim(worker, now, lease=30): """Взять один созревший запуск: свободный или с протухшей арендой.""" return db.execute(''' UPDATE runs SET owner = ?, lease_until = ?, attempt = attempt + 1, status = 'running' WHERE rowid = ( SELECT rowid FROM runs WHERE run_at <= ? AND status IN ('pending', 'running') AND lease_until < ? ORDER BY run_at LIMIT 1) RETURNING job_id, run_at, attempt''', (worker, now + lease, now, now)).fetchone() def heartbeat(job_id, run_at, attempt, now, lease=30): cur = db.execute('''UPDATE runs SET lease_until = ? WHERE job_id = ? AND run_at = ? AND attempt = ? AND status = 'running' ''', (now + lease, job_id, run_at, attempt)) return cur.rowcount == 1 # False — аренду уже перехватили def complete(job_id, run_at, attempt): cur = db.execute('''UPDATE runs SET status = 'done' WHERE job_id = ? AND run_at = ? AND attempt = ? AND status = 'running' ''', (job_id, run_at, attempt)) return cur.rowcount == 1 schedule('report', 100) schedule('report', 100) # повторное планирование — no-op w1 = claim('w1', now=100) print('w1 взял', w1) # ('report', 100, 1) print('w2:', claim('w2', now=110)) # None — аренда w1 ещё действует # w1 завис (GC-пауза, сеть) и не продлил аренду w2 = claim('w2', now=131) print('w2 перехватил', w2) # ('report', 100, 2) print('w1 продлевает:', heartbeat(*w1, now=135)) # False print('w1 завершает:', complete(*w1)) # False print('w2 завершает:', complete(*w2)) # True

Обратите внимание: fencing защищает нашу таблицу, но не внешний мир. Если w1 успел отправить письмо до паузы, а w2 отправил его снова — пользователь получит два письма. Это и есть at-least-once.

Шаг 6. At-least-once и идемпотентность

«Ровно один раз» недостижимо: исполнитель может выполнить задачу и умереть до того, как записал «готово». Система не может отличить этот случай от «умер до начала», поэтому запустит задачу снова. Выбор только между «иногда дважды» (at-least-once) и «иногда ни разу» (at-most-once). Для планировщика почти всегда выбирают первое.

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

Ретраи. Если целевой сервис ответил ошибкой, запуск возвращается в pending с run_at = now + backoff. Задержка растёт экспоненциально, со случайным разбросом, а после N попыток запуск уходит в dead letter queue и поднимает алерт. Почему без jitter ретраи превращаются в шторм — в статье про экспоненциальный backoff.

Шаг 7. Время — самая скользкая часть

Часовые пояса. «Каждый день в 9:00 по Москве» хранится как cron + IANA-зона, а next_run_at — в UTC. Пересчитывать следующий запуск нужно через зону, а не прибавлением 24 часов: в странах с переходом на летнее время сутки бывают по 23 и 25 часов.

Несуществующее и двойное время. В ночь перехода на летнее время в Европе 02:30 не существует, а осенью 02:30 случается дважды. Решите политику явно. Вот что делает стандартный zoneinfo в Python для «каждый день в 02:30 по Берлину» вокруг 29 марта 2026 года:

from datetime import datetime, timedelta, timezone from zoneinfo import ZoneInfo TZ = ZoneInfo('Europe/Berlin') def next_daily_run(after_utc, hour, minute): """Следующий запуск «каждый день в hh:mm по Берлину» строго после after_utc.""" day = after_utc.astimezone(TZ).date() while True: local = datetime(day.year, day.month, day.day, hour, minute, tzinfo=TZ) run = local.astimezone(timezone.utc) if run > after_utc: return run day += timedelta(days=1) t = datetime(2026, 3, 27, 12, 0, tzinfo=timezone.utc) for _ in range(3): t = next_daily_run(t, 2, 30) print(t.strftime('%d.%m %H:%M UTC'), '→', t.astimezone(TZ).strftime('%H:%M %Z')) # 28.03 01:30 UTC → 02:30 CET # 29.03 01:30 UTC → 03:30 CEST ← 02:30 не было, запуск сдвинулся на час # 30.03 00:30 UTC → 02:30 CEST

Сдвиг на 03:30 — разумное поведение, но его надо осознанно принять и записать в документацию, а не обнаружить в проде.

Пропущенные запуски. Система лежала 10 минут, и за это время должны были сработать 10 запусков ежеминутной задачи. Варианты: запустить все 10 (catch-up), запустить один последний, пропустить. Это настройка задачи, а не глобальное решение: для «пересчитать баланс» нужен каждый запуск, для «отправить сводку» — только последний.

Всплеск в полночь. Миллионы задач на 0 0 * * * создают пик. Если пользователю не важна точная секунда, планировщик добавляет детерминированный сдвиг: hash(job_id) % 300 секунд. Для тех, кому важна, — заранее масштабированные исполнители. Сам планировщик может создавать записи runs чуть заранее (за минуту), чтобы к моменту пика очередь уже была наполнена.

Шаг 8. Масштабирование планировщика

  • Партиции по hash(job_id): их больше, чем узлов (например, 1024 на 20 узлов), чтобы перераспределять нагрузку мелкими кусками. Схема похожа на шардирование с репликацией.
  • Точные задержки в памяти. Для одноразовых задач «через 30 секунд» опрашивать базу каждую секунду дорого. Планировщик заранее загружает запуски ближайших минут в память — в кучу по времени или в hierarchical timing wheel, где вставка и извлечение стоят O(1)O(1). После рестарта он просто перечитывает окно из базы.
  • Наблюдаемость. Главная метрика — задержка запуска (фактическое время старта минус run_at). Её рост раньше всего показывает, что исполнителей не хватает.

Узкие места и вопросы вглубь

Вопрос интервьюераОтвет
Два планировщика создали один запускневозможно: уникальный ключ (job_id, run_at)
Исполнитель умер посреди задачиаренда протухнет, запуск заберёт другой; получатель идемпотентен
Задача длится часheartbeat продлевает аренду; таймаут — отдельное поле задачи
Целевой сервис лежитретраи с backoff, DLQ, лимит одновременных запусков на получателя
Пользователь удалил задачу во время запускатекущий запуск доходит до конца, следующий не создаётся (enabled = false)
Зависимости между задачами (DAG)отдельный слой поверх планировщика: запуск следующей по событию «готово»

Типичные ошибки на интервью

  • Обещать exactly-once. Правильный ответ — at-least-once плюс идемпотентность получателя.
  • Одна глобальная распределённая блокировка на каждый запуск. Уникальный ключ в базе проще и надёжнее.
  • Аренда без fencing. Проснувшийся после паузы исполнитель затрёт чужой результат.
  • Хранить время в локальной зоне или прибавлять 86 400 секунд для «каждый день».
  • Планировщик выполняет задачи сам. Тогда долгая задача блокирует планирование остальных.
  • Забыть про пик в 00:00 и пропущенные запуски.

Что запомнить

  1. Планирование и исполнение — разные компоненты, между ними очередь.
  2. Запуск идентифицируется (job_id, run_at); уникальный ключ отсекает дубли планирования.
  3. Исполнитель держит аренду с heartbeat; attempt служит fencing token.
  4. Гарантия — at-least-once; ключ идемпотентности job_id:run_at передаётся получателю.
  5. next_run_at в UTC, расчёт — через IANA-зону, политики для DST и пропусков — явные.

Потренироваться в спокойной обстановке

Все задачи