Системный дизайн распределённого планировщика задач: cron в масштабе, аренда и at-least-once
Как спроектировать распределённый планировщик задач на system design интервью: хранение расписаний, поиск созревших запусков, аренда с heartbeat, fencing, at-least-once, ретраи, часовые пояса.
Коротко
| Вопрос | Решение в этом разборе |
|---|---|
| Нагрузка | 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 часа, это запусков в секунду.
- Распределение неравномерное. Люди пишут
0 * * * *и0 0 * * *, поэтому в начале часа и особенно в полночь UTC приходит всплеск в десятки раз выше среднего. - Запись о расписании — около 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, где вставка и извлечение стоят . После рестарта он просто перечитывает окно из базы.
- Наблюдаемость. Главная метрика — задержка запуска (фактическое время старта минус
run_at). Её рост раньше всего показывает, что исполнителей не хватает.
Узкие места и вопросы вглубь
| Вопрос интервьюера | Ответ |
|---|---|
| Два планировщика создали один запуск | невозможно: уникальный ключ (job_id, run_at) |
| Исполнитель умер посреди задачи | аренда протухнет, запуск заберёт другой; получатель идемпотентен |
| Задача длится час | heartbeat продлевает аренду; таймаут — отдельное поле задачи |
| Целевой сервис лежит | ретраи с backoff, DLQ, лимит одновременных запусков на получателя |
| Пользователь удалил задачу во время запуска | текущий запуск доходит до конца, следующий не создаётся (enabled = false) |
| Зависимости между задачами (DAG) | отдельный слой поверх планировщика: запуск следующей по событию «готово» |
Типичные ошибки на интервью
- Обещать exactly-once. Правильный ответ — at-least-once плюс идемпотентность получателя.
- Одна глобальная распределённая блокировка на каждый запуск. Уникальный ключ в базе проще и надёжнее.
- Аренда без fencing. Проснувшийся после паузы исполнитель затрёт чужой результат.
- Хранить время в локальной зоне или прибавлять 86 400 секунд для «каждый день».
- Планировщик выполняет задачи сам. Тогда долгая задача блокирует планирование остальных.
- Забыть про пик в 00:00 и пропущенные запуски.
Что запомнить
- Планирование и исполнение — разные компоненты, между ними очередь.
- Запуск идентифицируется
(job_id, run_at); уникальный ключ отсекает дубли планирования. - Исполнитель держит аренду с heartbeat;
attemptслужит fencing token. - Гарантия — at-least-once; ключ идемпотентности
job_id:run_atпередаётся получателю. next_run_atв UTC, расчёт — через IANA-зону, политики для DST и пропусков — явные.