Перейти к содержимому
TelegramGitHub

Designing Data-Intensive Applications, глава 11: Пакетная обработка

Главная мысль: batch job читает неизменяемый вход и каждый раз заново строит выход, поэтому ошибку в коде исправляют перезапуском. Современная пакетная обработка похожа на распределённую операционную систему: хранилище (DFS или S3), оркестратор и движок вроде Spark, на котором пишут SQL или DataFrame.

До сих пор книга говорила о запросах и быстрых ответах. Глава 11 разбирает большие вычисления, которые идут минуты и часы. В главе 10 узлы договаривались друг с другом, а здесь они вместе обрабатывают огромный набор данных. Темы главы:

  • анализ лога Unix-командами и почему сортировка масштабируется;
  • распределённые файловые системы, объектные хранилища и оркестраторы;
  • MapReduce, dataflow engine, shuffle и joins;
  • SQL, DataFrame и сближение с облачными хранилищами данных;
  • применения: ETL, аналитика, машинное обучение, выдача производных данных.

Сравнение одной Unix-машины и кластера: файловая система ОС соответствует DFS или S3, ядро с планировщиком — оркестратору Kubernetes или YARN, программы с pipes — batch jobs и workflow на Spark, Flink и Airflow

Схема показывает главную аналогию главы: слева части Unix-машины, справа их аналоги в кластере.

Браузер, API, база данных и кэш работают по одной схеме: пришёл запрос, нужен быстрый ответ. Авторы называют их онлайн-системами. Их главная мера — время ответа.

Но иногда нужно обучить AI-модель, перегнать много данных в другой формат или посчитать аналитику по огромному набору. Такие задачи называют batch job, а системы для них — офлайн-системами. Batch job — это задача, которая читает вход, не меняя его, и каждый раз строит выход с нуля. Выход — это производные данные (см. главу 1). Если результат плохой, его удаляют, правят логику и запускают job снова.

Неизменяемый вход и отсутствие побочных эффектов дают несколько плюсов:

  • Откат ошибок. Если код испортил выход, верните старый код и перезапустите job. Или держите старый выход в другом каталоге и переключитесь на него: объектные хранилища и открытые табличные форматы умеют это под названием time travel. В базе с транзакциями откат кода не исправит уже записанные плохие данные. Эту способность пережить ошибку в коде называют human fault tolerance.
  • Быстрая разработка. Ошибку легко отменить, поэтому новые функции разрабатывают быстрее.
  • Общий вход. Одни и те же файлы читают и рабочие jobs, и jobs мониторинга, которые сравнивают новый выход с прошлым.
  • Экономия ресурсов. Через OLTP-базу большие объёмы обрабатывать намного дороже.

Минусы тоже есть. Обычно выход можно читать только после конца всего job. А любое изменение входа, даже в один байт, требует обработать весь набор заново.

Batch job идёт минуты, часы или дни, часто по расписанию, например раз в сутки. Его главная мера — throughput: сколько данных он обрабатывает за единицу времени. Граница с онлайн-системами размыта: долгий запрос к базе тоже похож на batch job. Пакетная обработка хорошо подходит для интеграции данных, когда несколько систем вместе делают то, что одна не может; классический пример — ETL. Альтернатива — потоковая обработка: job не заканчивается, а обрабатывает изменения вскоре после того, как они случились. Ей посвящена глава 12.

На пакетную обработку сильно повлиял MapReduce. Google опубликовала этот алгоритм в 2004 году, потом его повторили Hadoop, CouchDB и MongoDB. MapReduce — довольно низкоуровневая модель программирования, она устроена примитивнее параллельных движков запросов в хранилищах данных. Когда-то она позволила обрабатывать огромные объёмы на обычном железе, но сейчас почти устарела, и в Google её больше не используют.

Сегодня batch jobs пишут на Spark и Flink или запускают в хранилищах данных. Они тоже опираются на sharding (см. главу 7) и параллельность, но кэшируют и планируют работу умнее. Проблемы эксплуатации в целом решены, и внимание сместилось к удобству: DataFrame, языки запросов, оркестраторы Airflow, Dagster и Prefect вместо Oozie и Azkaban. Хранение переезжает из HDFS в объектные хранилища вроде S3, а BigQuery и Snowflake стирают границу между хранилищем данных и пакетной обработкой.

Пусть веб-сервер на каждый запрос дописывает строку в лог. В формате NGINX строка содержит IP клиента, время, путь запроса, код ответа, размер ответа, страницу-источник и браузер. Разбор логов кажется надуманным примером, но на нём держатся многие компании, от рекламы до платежей. Именно анализ логов во многом ускорил распространение MapReduce и движения «big data».

Пять самых популярных страниц сайта находит цепочка Unix-команд:

Окно терминала
cat /var/log/nginx/access.log | # читаем лог
awk '{print $7}' | # берём 7-е поле: URL запроса
sort | # одинаковые URL встают рядом
uniq -c | # схлопываем повторы и считаем их
sort -r -n | # сортируем по числу, большие сверху
head -n 5 # оставляем первые пять строк

Первый sort ставит одинаковые URL подряд, а uniq -c сравнивает соседние строки и считает повторы. Такая цепочка обрабатывает гигабайты логов за секунды, и её легко менять: например, {print $1} вместо {print $7} считает IP-адреса. Авторы советуют выучить awk, sed, grep, sort, uniq и xargs: с ними многие анализы занимают минуты.

То же можно написать на Python со словарём счётчиков:

counts = defaultdict(int) # URL -> сколько раз встретился
with path.open() as f:
for line in f:
url = line.split()[6] # 7-е поле, индекс 6
counts[url] += 1
top5 = sorted(((c, u) for u, c in counts.items()), reverse=True)[:5]

Мы сгенерировали лог из 20 000 строк и прогнали обе версии скриптом scripts/ddia-code/ch11_top_urls.py. Результаты совпадают:

Unix pipeline:
5866 /favicon.ico
4089 /blog/kafka.html
3264 /blog/duckdb.html
2751 /
1735 /css/typography.css
Python:
5866 /favicon.ico
4089 /blog/kafka.html
3264 /blog/duckdb.html
2751 /
1735 /css/typography.css
Совпадает: True

Какая версия приятнее — дело вкуса. Важнее, что они выполняются по-разному, и на большом файле это заметно.

Python держит хеш-таблицу URL в памяти, а Unix-цепочка сортирует список, где один URL повторяется много раз. Что лучше, зависит от числа разных URL. Рабочий набор (working set) — это объём памяти, к которому job обращается в произвольном порядке. Здесь он зависит только от числа разных URL: миллион запросов к одной странице занимают одну запись. Если рабочий набор мал (у среднего сайта влезет, скажем, в 1 ГБ), хеш-таблица отлично работает даже на ноутбуке.

Если рабочий набор больше памяти, выигрывает сортировка. Как в log-structured хранилищах из главы 4, куски сортируют в памяти, пишут на диск сегментами и сливают. Mergesort читает и пишет последовательно, а это быстро для дисков. GNU sort сам сбрасывает данные на диск и распараллеливает сортировку по ядрам, поэтому узким местом, скорее всего, станет скорость чтения файла с диска. Но Unix-инструменты работают на одной машине. Если данные не влезают на её диск, нужны распределённые фреймворки.

Пакетная обработка в распределённых системах

Заголовок раздела «Пакетная обработка в распределённых системах»

Машина из примера использует три части: накопители за файловой системой ОС, планировщик процессов и программы, у которых stdin и stdout соединены pipes. Те же части есть в распределённых фреймворках (см. схему в начале). Их можно считать распределёнными операционными системами.

Файловая система ОС состоит из слоёв. Внизу драйверы читают и пишут сырые блоки диска. Над ними page cache держит недавние блоки в памяти. Файловая система (ext4, XFS) режет файлы на блоки и ведёт метаданные. Наверху виртуальная файловая система (VFS) даёт приложениям общий API.

Распределённая файловая система (DFS) устроена так же, только блоки лежат на многих машинах. Блоки гораздо крупнее: 128 МБ в HDFS, 4 МБ в JuiceFS и многих объектных хранилищах против 4096 байт в ext4. Крупные блоки дают меньше метаданных, что важно на петабайтах, и делают поиск блока дешевле его чтения. Диск не умеет писать неполные блоки, поэтому ОС занимает целый блок, даже если данных меньше. DFS работает поверх файловой системы ОС, и у неё такого требования нет: файл в 900 МБ займёт семь блоков по 128 МБ и один в 4 МБ.

Блоки читают по сети. На каждой машине работает демон, который хранит блоки как локальные файлы: DataNode в HDFS, glusterfsd в GlusterFS, в книге — data node. Его ОС кэширует частые блоки в памяти, а JuiceFS добавляет кэш на клиенте. Метаданные (где блоки, права доступа) хранит отдельный сервис: NameNode в Hadoop, а 3FS от DeepSeek пишет их в key-value-хранилище вроде FoundationDB.

Аналог VFS — протокол DFS. Подойдёт любое хранилище, которое его реализует. Например, API S3 повторили MinIO, Cloudflare R2, Backblaze B2 и другие, поэтому фреймворк с поддержкой S3 работает с любым из них. Некоторые DFS совместимы с POSIX и подключаются к VFS через FUSE или NFS. Amazon EFS и Archil дают NFS-совместимые системы, которые масштабируются гораздо лучше классического NFS: клиент видит одну точку входа, а внутри работают распределённые сервисы.

DFS построены по принципу shared-nothing, а NAS и SAN — по принципу shared-disk: центральное устройство со специальным железом и сетью вроде Fibre Channel. DFS хватает обычных компьютеров в обычной сети. Недорогое железо ломается чаще, поэтому блоки реплицируют на несколько машин (см. главу 6). Заодно планировщик может запустить задачу на любом узле с копией её входа. Вместо полных копий можно использовать erasure coding, например коды Рида–Соломона: они восстанавливают потерянные данные и занимают меньше места. Идея похожа на RAID, только по сети и без особого железа.

Объектные хранилища (object store) — S3, Google Cloud Storage, Azure Blob Storage — стали популярной заменой DFS. Граница размыта: через FUSE S3 выглядит как файловая система, а JuiceFS и Ceph дают оба API. Но скорость и гарантии согласованности у них разные, и авторы советуют проверять поведение, а не только наличие API.

Адрес объекта выглядит так: s3://my-photo-bucket/2025/04/01/birthday.png. Здесь my-photo-bucket — это bucket с глобально уникальным именем, а остальное — ключ, уникальный внутри bucket. Объект читают через get и пишут через put. После записи он не меняется: чтобы обновить, его перезаписывают целиком. Дописывать в конец умеют лишь Azure Blob Storage и S3 Express One Zone, а fopen и fseek они не поддерживают.

Каталогов в объектном хранилище нет, слеши — просто часть ключа. Список по префиксу отличается от просмотра каталога: он рекурсивный, как ls -R, и пустых «каталогов» не бывает. Если удалить все объекты под префиксом, он исчезнет из списка, поэтому иногда создают пустой объект-заглушку. Нет и ссылок, блокировок и атомарного переименования: объект копируют под новым ключом и удаляют старый. Чтобы переименовать «каталог», переименовывают каждый объект в нём.

Key-value-хранилища из главы 4 рассчитаны на мелкие значения и частые быстрые операции. DFS и объектные хранилища — на большие объекты (мегабайты и гигабайты) и редкие крупные чтения. Впрочем, S3 Express One Zone уже отвечает за миллисекунды и стоит почти как key-value-хранилище. Ещё одно отличие: HDFS умеет запускать задачу там, где лежит её файл, и не гонять его по сети. Объектные хранилища отделяют хранение от вычислений. Трафика больше, но сети в дата-центрах быстрые, а CPU и память можно масштабировать отдельно от хранилища.

На одной машине ядро ОС запускает процессы, передаёт между ними данные, выделяет память и делит CPU. В кластере это делает оркестратор. Фреймворк просит его запустить job и передаёт метаданные. Среди них число задач (task), память, CPU и диск для каждой, вход и выход, нужное железо (например, GPU), учётные данные и адрес кода. Оркестраторы вроде Kubernetes и YARN выполняют job с помощью трёх частей:

ЧастьЧто делаетПримеры
executorДемон на узле: скачивает код, запускает task, следит за ней, шлёт heartbeat. Через cgroups изолирует задачи друг от другаNodeManager в YARN, kubelet в Kubernetes
resource managerЗнает ресурсы и состояние всех узлов. Из-за централизации может стать узким местомСостояние хранят в ZooKeeper (YARN) или etcd (Kubernetes)
Планировщик (scheduler)Принимает запросы на запуск и остановку jobs и решает, какая task пойдёт на какой узел«10 tasks из этого Docker-образа на узлах с нужной GPU»

Иногда нужны ещё планировщики под конкретное приложение: ApplicationMaster в YARN, операторы в Kubernetes.

Планировщик делит ограниченные ресурсы и ищет баланс между справедливостью и эффективностью. Пример из книги: в кластере 160 ядер, а два jobs просят по 100. Можно дать каждому по 80 и запускать остальное по мере освобождения ядер. Можно применить gang scheduling: запустить все задачи одного job вместе, а второй — когда освободятся 100 ядер. А если второй запрос придёт позже, неясно, держать ли ядра про запас для job, который может и не прийти.

У каждого варианта своя цена. При gang scheduling узлы простаивают, пока копятся 100 ядер, а если ядра копят несколько jobs, возможен deadlock. Если просто ждать, ядра могут перехватить другие, и job будет голодать (starvation). Можно вытеснить (preemption) часть задач первого job, но их потом придётся перезапускать. Для миллионов запросов задача NP-трудная, поэтому планировщики используют эвристики: FIFO, dominant resource fairness (DRF), очереди с приоритетами, квоты и bin packing.

Как Unix-команды соединены pipes, так и выход одного job часто становится входом других. Такой граф называют workflow, или DAG jobs.

Пояснение: в главе 5 «workflow» означал durable execution: надёжные шаги с вызовами RPC. В пакетной обработке workflow — это цепочка batch jobs, которые читают и пишут данные и обычно не вызывают внешние сервисы.

Workflow нужен в трёх случаях. Выход одного job читают jobs разных команд. Данные переходят из инструмента в инструмент: Spark пишет в HDFS, затем Trino обрабатывает файлы и пишет в S3. Или стадиям нужен sharding по разным ключам.

Unix-pipe держит маленький буфер в памяти. Если буфер полон, отправитель ждёт получателя — это backpressure. Spark и Flink тоже умеют передавать выход задачи прямо в другую задачу. Но чаще job пишет выход в DFS или S3, а следующий читает его оттуда. Так jobs не зависят друг от друга и могут идти в разное время, а job с несколькими входами ждёт, пока успешно закончатся все jobs, которые их производят. Планировщики оркестраторов (ResourceManager в YARN, планировщик Spark) управляют отдельными jobs. Зависимости между jobs ведут Airflow, Dagster и Prefect. Без них сложно управлять такими графами: workflow из 50–100 jobs — обычное дело.

Долгий job с множеством параллельных задач скорее всего столкнётся со сбоем хотя бы одной из них: из-за железа, сети (см. главу 9) или вытеснения. Дешёвые машины с низким приоритетом облако может забрать в любой момент: spot instance в EC2, spot VM в Azure, preemptible instances в Google Cloud. Пакетной обработке обычно не к спеху, поэтому такие машины ей подходят и повышают загрузку кластера. Минус в том, что вытеснение случается чаще, чем сбои железа, поэтому такие задачи убивают чаще.

Batch job строит выход с нуля, поэтому сбой обработать просто: удалить частичный выход и запустить задачу на другой машине. Перезапускать весь job расточительно, поэтому MapReduce и его наследники повторяют работу по одной задаче.

Сложнее, когда выход одной задачи — вход другой. MapReduce пишет промежуточные данные в DFS и даёт их читать только после успешного конца задачи. Это надёжно, но записей в DFS много. Spark держит промежуточные данные в памяти (или на локальном диске) и помнит, как их получил, чтобы при потере вычислить заново. Flink периодически делает checkpoint — снимок состояния задач.

Две главные модели — MapReduce и dataflow engine. Второй почти вытеснил первый, но MapReduce полезно понимать: он повлиял на многие фреймворки. Обе модели сейчас поддерживают низкоуровневые API, SQL и DataFrame, поэтому с данными работают и инженеры, и аналитики, и нетехнические сотрудники.

MapReduce обрабатывает данные почти как наша цепочка команд:

  1. Прочитать входные файлы и разбить на записи. Вход лежит в HDFS или S3 в форматах вроде Parquet (колоночный, глава 4) или Avro (строковый, глава 5).
  2. Вызвать mapper, который достаёт из записи ключ и значение. В примере это awk '{print $7}'.
  3. Отсортировать пары по ключу, как первый sort.
  4. Вызвать reducer, который проходит по отсортированным парам. Одинаковые ключи стоят рядом, поэтому их легко объединить без большого состояния. В примере это uniq -c.

Разработчик пишет только шаги 2 и 4. Шаг 1 делает парсер формата, а сортировку MapReduce выполняет сам.

  • Mapper вызывается для каждой записи и выдаёт сколько угодно пар ключ-значение, в том числе ни одной. Состояния между записями он не хранит, поэтому много mapper работают параллельно.
  • Reducer получает от фреймворка все значения одного ключа и выдаёт выходные записи, например число запросов к URL. Разные ключи тоже обрабатываются параллельно.

Второй sort из Unix-примера требует второго MapReduce job, который читает выход первого. В такой цепочке видно разделение ролей: mapper готовит данные к сортировке, а reducer обрабатывает уже отсортированные данные.

map и reduce (fold) пришли из Lisp как функции высшего порядка. Главный принцип — отказ от изменяемого состояния: каждый вызов зависит только от данных, которые передал фреймворк. Поэтому фреймворк может запускать вызовы параллельно на разных узлах, а при сбое — повторить вызов на другом.

Но писать сложную обработку на «голом» MapReduce трудно: даже join приходится писать с нуля. К тому же он медленный: передача данных через файлы не даёт следующему job начать работу до конца предыдущего.

Эти проблемы решают Spark и Flink. Общее у них одно: весь workflow для них — один job. Они явно моделируют поток данных через стадии, поэтому их называют dataflow engine. Кроме функции на каждую запись, у них есть операторы join, group by, filter и агрегации, а внутри эти операторы работают через shuffle. Операторы не обязаны чередоваться как map и reduce.

Подход вырос из исследовательских систем Dryad и Nephele. Его преимущества перед MapReduce:

  • сортировка идёт только там, где нужна, а не между каждыми map и reduce;
  • операторы подряд, которые не меняют sharding (map, filter), склеиваются в одну задачу;
  • зависимости объявлены явно, поэтому планировщик может поставить задачу-потребителя рядом с задачей-производителем и передать данные через память, а не по сети;
  • промежуточные данные лежат в памяти или на локальном диске, а не в DFS с репликами;
  • оператор стартует, как только готов его вход;
  • процессы переиспользуются, а MapReduce запускает новую JVM на каждую задачу.

Поэтому те же вычисления dataflow engine обычно выполняет заметно быстрее.

Сравнение MapReduce и dataflow engine: в MapReduce Job 1 пишет промежуточные файлы в DFS с репликами, а Job 2 их читает; в Spark и Flink операторы одного job передают данные через память, а результат пишется в DFS

Верхний ряд — workflow на MapReduce: каждый job пишет промежуточный результат в DFS. Нижний ряд — тот же расчёт в dataflow engine: в DFS попадают только вход и итог.

Сортировать нужно петабайты, которые не влезают на одну машину. Распределённый алгоритм сортировки, у которого и вход, и выход разделены на shard, называют shuffle.

Пояснение: перетасованная (shuffled) колода лежит в случайном порядке, а shuffle в пакетной обработке даёт отсортированный порядок без всякой случайности.

На shuffle держатся joins и агрегации, его реализуют MapReduce, Spark, Flink, Daft, Dataflow и BigQuery. Авторы разбирают его на Hadoop MapReduce. Пусть вход разделён на shard m1, m2 и m3: это отдельные файлы HDFS или объекты под одним префиксом.

MapReduce job из трёх mapper и трёх reducer: каждый mapper читает свой shard из DFS и пишет отдельный отсортированный файл для каждого reducer; каждый reducer забирает свои файлы у всех mapper, сливает их и пишет shard результата в DFS

Схема читается слева направо. На каждый входной shard запускается map-задача. Число reduce-задач задаёт автор job, и оно может отличаться от числа map-задач. Пары с одним ключом должны попасть к одному reducer, поэтому mapper пишет на локальный диск отдельный файл для каждого reducer. Файл (m1, r2) — это данные mapper 1 для reducer 2. Нужный файл определяет хеш ключа, как при sharding по хешу в главе 7. Внутри файла mapper сортирует пары, как log-structured хранилище: копит в памяти, пишет сегменты и сливает их.

Когда mapper закончил, каждый reducer копирует у него свой файл. Собрав файлы от всех mapper, reducer сливает их с сохранением порядка. Теперь пары одного ключа стоят подряд, и функция reducer вызывается по разу на ключ. Её выход пишется в один файл на задачу, и файлы r1, r2, r3 становятся shard результата в DFS.

Современные движки делают shuffle умнее. Например, BigQuery держит его данные в памяти и пишет во внешние сервисы сортировки, которые ускоряют shuffle и реплицируют данные ради надёжности.

Пример из книги: лог действий пользователей на сайте (clickstream) и база пользователей. Это часть star schema (см. главу 3): лог — таблица фактов (fact table), база пользователей — измерение. Мы хотим узнать, какие страницы популярнее у молодых, а какие — у пожилых. Дата рождения лежит в профиле, значит, нужен join, а обе таблицы так велики, что разделены на shard.

Shuffle собирает все пары с одним ключом у одного reducer, поэтому ключом делают user_id. Один mapper выдаёт URL просмотра с ключом user_id, другой — дату рождения с тем же ключом.

Sort-merge join: mapper событий выдаёт пары user_id и url, mapper пользователей выдаёт пары user_id и дата рождения; shuffle с secondary sort ставит профиль перед событиями; reducer выдаёт url с датой рождения, а следующий job группирует просмотры по url и возрасту

Job может упорядочить записи так, что reducer видит сначала профиль, а потом события по времени. Это secondary sort. Reducer запоминает дату рождения и выдаёт каждый URL вместе с ней. В памяти лежит одна запись пользователя, и сетевых запросов нет. Такой алгоритм называют sort-merge join: выход mapper отсортирован, а reducer сливает отсортированные списки обеих сторон.

Следующий job делает shuffle по URL и для каждой страницы считает просмотры по возрастным группам. Так реализуются group by и агрегация.

Движки уже надёжно обрабатывают петабайты на кластерах из более чем 10 000 машин, поэтому внимание перешло к модели программирования. MapReduce, dataflow engine и облачные хранилища данных приняли SQL как общий язык. Его знают все, его поддерживают инструменты аналитики и ETL, а код выходит короче рукописного MapReduce. SQL позволяет и работать интерактивно: аналитики, продакт-менеджеры и финансисты исследуют данные запросами.

SQL помогает не только людям: с ним и машины выполняют jobs эффективнее. Движок переводит запрос в синтаксическое дерево, затем в физические операторы, и по пути оптимизирует его. Оптимизаторы по стоимости в Hive, Trino, Spark и Flink сами выбирают алгоритм join и даже меняют порядок joins, чтобы промежуточных данных было меньше.

Есть и нишевые языки. Apache Pig описывал pipeline шаг за шагом, а не одним большим SQL-запросом, похожим путём идут DataFrame и язык Morel. Для JSON есть jq, JMESPath и JSONPath, для графов (см. главу 3) — Gremlin из Apache TinkerPop.

Сближение пакетной обработки и облачных хранилищ данных

Заголовок раздела «Сближение пакетной обработки и облачных хранилищ данных»

Раньше хранилища данных работали на специальных комплексах и выполняли SQL. MapReduce давал масштаб и гибкость: код на любом языке и любые форматы. Со временем хранилища и фреймворки сблизились. Фреймворки выучили SQL и быстро выполняют его благодаря Parquet и оптимизированным движкам (см. главу 4). Хранилища данных переехали в облако и переняли планирование, отказоустойчивость и shuffle. Фреймворки взяли SQL, а хранилища в ответ взяли другие модели обработки: у BigQuery есть DataFrame, Snowpark в Snowflake работает с Pandas, а Airflow, Prefect и Dagster интегрированы с хранилищами.

Не всё легко выразить на SQL: итеративные графовые алгоритмы вроде PageRank, сложное ML, изображения, видео и звук для AI. Облачные хранилища данных медленнее на построчных вычислениях по колоночным данным и обычно дороже, поэтому большие jobs бывает выгоднее запускать в Spark или Flink. Выбор зависит от стоимости, удобства и доступности. У крупных компаний много систем, а небольшие часто обходятся одной.

Data scientists привыкли к DataFrame из R и Pandas. DataFrame похож на таблицу: набор строк, где значения одного столбца одного типа. Вместо большого SQL-запроса пользователь вызывает функции: фильтр, join, сортировку, агрегацию.

Сначала DataFrame жили в памяти одной машины. Чтобы работать с большими данными через привычный API, Spark, Flink и Daft добавили свои DataFrame. Но локальные DataFrame обычно индексированы и упорядочены, а распределённые — нет, поэтому при переходе на распределённый фреймворк скорость может неприятно удивить. Pandas выполняет операцию сразу, а Spark сначала строит план запроса, оптимизирует его и только потом выполняет. Daft считает мелкие операции на клиенте, а большие — на сервере, и общий колоночный формат Apache Arrow связывает обе стороны.

Batch jobs хороши для больших объёмов, но не для малой задержки. Их используют там, где данных много, а свежесть не критична: сверка бухгалтерии и складов, прогноз спроса, обучение рекомендательных моделей, финансовые системы. Например, банковская сеть США почти целиком работает на batch jobs.

ETL и ELT (см. главу 1) извлекают данные из рабочей базы, преобразуют и загружают в другую систему, часто в хранилище данных. Фильтры, выбор полей и многие другие преобразования распараллеливаются тривиально («embarrassingly parallel»), поэтому batch jobs здесь удобны. Планировщики workflow повторяют упавший job, а job, который падает снова и снова, помечают, и инженер сразу видит, где сломался pipeline. В Airflow есть готовые операторы для MySQL, PostgreSQL, Snowflake, Spark и десятков других систем.

Batch jobs легко отлаживать: файлы упавшего job можно открыть, а job исправить и перезапустить. Например, если во входе нет нужного поля, инженер данных быстро это заметит и поправит логику.

Раньше pipeline вела одна команда инженеров данных. Теперь инструменты стали проще, и команды по всей компании ведут свои pipeline сами, а практики data mesh, data contract и data fabric помогают им безопасно публиковать данные. ETL и аналитика всё чаще идут в одном движке, например в SparkSQL, Trino или DuckDB. Из-за этого стирается граница между разработкой, инженерией данных, analytics engineering и бизнес-анализом.

Аналитические запросы (OLAP) сканируют много записей и агрегируют их, и их можно запускать в системе пакетной обработки. Аналитики пишут SQL, движок читает файлы из DFS или S3, а метаданные таблиц ведут табличные форматы вроде Apache Iceberg и каталоги вроде Unity. Такую архитектуру называют lakehouse. Запросы бывают двух видов:

ВидКак работает
Предварительная агрегацияДанные по расписанию сворачивают в OLAP-кубы или витрины (см. главу 4) и читают в хранилище или в Apache Druid и Pinot
Запросы ad hocОтветы на бизнес-вопросы и отладка. Аналитик задаёт запросы один за другим, поэтому важна скорость ответа

Через SQL фреймворки подключаются к инструментам визуализации: Tableau, Power BI, Looker и Apache Superset. Например, Superset работает с Trino, Hive и Spark SQL, а те для ответа на запрос запускают batch jobs.

ML-инженеры используют пакетную обработку в трёх задачах:

  • feature engineering — превращение сырых данных в признаки, например текста в числа;
  • обучение — данные служат входом job, а веса модели — выходом;
  • batch inference — предсказания сразу для большого набора, в том числе оценка модели на тестовых данных.

Для этого есть MLlib в Spark и FlinkML во Flink. Рекомендательные системы и ранжирование много работают с графами: алгоритм идёт по одному ребру за шаг и повторяет шаги, пока метрика не сойдётся. Для этого популярна модель bulk synchronous parallel (BSP), или Pregel: её реализуют Apache Giraph, GraphX в Spark и Gelly во Flink.

Пакетная обработка нужна и для больших языковых моделей. Сырой текст сайтов лежит в DFS или S3. Перед обучением его готовят: извлекают текст из HTML, удаляют некачественные документы и дубликаты, разбивают на токены и превращают в embedding — числовые представления слов. Для этого созданы Kubeflow, Flyte и Ray; OpenAI, например, использует Ray при обучении ChatGPT. Эти фреймворки интегрированы с PyTorch и TensorFlow и поддерживают обучение, batch inference и fine-tuning. Наконец, data scientists работают в ноутбуках вроде Jupyter и Hex, которые запускают batch jobs через DataFrame или SQL.

Batch jobs строят производные данные: рекомендации, отчёты, признаки для ML. Пользователи получают их из рабочей базы, key-value-хранилища или поискового движка, поэтому данные нужно туда перенести.

Писать из job прямо в базу запись за записью — плохая идея по трём причинам:

  • сетевой запрос на каждую запись снижает скорость на порядки по сравнению с обычным throughput batch-задачи;
  • много параллельных задач легко перегрузят базу, а это ударит по запросам пользователей и другим системам;
  • batch job гарантирует «всё или ничего»: при успехе выход такой, будто каждая задача выполнилась ровно раз, при сбое выхода нет. Запись во внешнюю систему — видимый побочный эффект: другие увидят результат недоделанного job, а перезапущенная задача может записать данные повторно.

Лучше отправлять готовые данные в поток, например в topic Kafka (см. главу 12). Elasticsearch, Pinot, Druid, Venice и ClickHouse умеют сами читать Kafka. Поток хорошо переносит массовую последовательную запись и служит буфером: получатели сами выбирают скорость чтения. Выход одного job могут читать несколько систем, а поток в демилитаризованной зоне (DMZ) отделяет batch-окружение от рабочей сети. Но «всё или ничего» поток сам не даёт. Для этого job в конце сообщает, что данные готовы, а получатели до этого прячут их от запросов, как незафиксированную транзакцию при read committed (см. главу 8).

При первичном заполнении базы чаще делают иначе: job строит готовые файлы базы, а их массово загружают (bulk load). Так умеют Lightning в TiDB, импорт в Apache Pinot, загрузка SST-файлов в RocksDB. Это очень быстро и позволяет атомарно переключиться на новую версию данных, но инкрементальные обновления так делать трудно. Поэтому, когда нужны и первичная загрузка, и инкрементальные обновления, часто берут гибрид: Venice поддерживает и построчные обновления, и полную замену набора.

  • Batch job читает неизменяемый вход и строит выход с нуля, поэтому ошибки исправляют перезапуском.
  • Сортировка масштабируется на данные больше памяти, а хеш-таблица хороша при малом рабочем наборе.
  • Распределённый фреймворк похож на ОС: хранилище (DFS или S3), оркестратор и слой вычислений.
  • Объектные хранилища вытесняют DFS, но у них нет каталогов, атомарного переименования и изменения объекта на месте.
  • Оптимальное распределение ресурсов — NP-трудная задача, поэтому планировщики используют эвристики.
  • Dataflow engine вроде Spark и Flink почти вытеснил MapReduce: весь workflow у него — один job с промежуточными данными в памяти.
  • Shuffle — распределённая сортировка, на которой построены joins (sort-merge join) и агрегации.
  • SQL и DataFrame сделали пакетную обработку доступнее и дали движку оптимизировать запросы.
  • Основные применения: ETL, аналитика, ML и выдача производных данных через поток или bulk load.
ТерминЗначение
batch jobЗадача, которая читает неизменяемый вход и строит выход с нуля
DFSРаспределённая файловая система: блоки файлов на многих машинах
Объектное хранилищеS3 и аналоги: неизменяемые объекты по ключу в bucket
ОркестраторKubernetes, YARN: запускает task на узлах
gang schedulingВсе задачи job стартуют только вместе
Вытеснение (preemption)Планировщик убивает задачу ради другой
workflowDAG jobs, где выход одного — вход другого
mapper / reducerИзвлекает ключ и значение / обрабатывает все значения одного ключа
dataflow engineДвижок, который выполняет весь workflow как один job
shuffleРаспределённая сортировка: один ключ — один reducer
sort-merge joinОбе стороны сортируют по ключу, reducer сливает их
lakehouseSQL-движок над файлами в объектном хранилище с табличным форматом
  • Делайте jobs идемпотентными: вход не меняется, результат пишется целиком и заменяет прежний. Тогда перезапуск безопасен.
  • Не пишите из задач в рабочую БД запись за записью. Готовьте файл или снимок и загружайте целиком с атомарным переключением или отправляйте данные через Kafka с сигналом о конце job.
  • Выбирайте join по данным: маленькую таблицу измерений можно раздать всем задачам (broadcast), а для двух больших нужен общий ключ sharding. Следите за перекосом (skew): смотрите на самую медленную task.
  • Spark и Flink обычно быстрее MapReduce. Они пересчитывают потерянные данные, поэтому убирайте недетерминизм: время, random без seed, порядок hash table.
  • Храните сырые данные неизменяемыми (data lake). Моделирование делайте отдельным шагом. Тогда ошибку в трансформации можно исправить пересчётом.
  • Для зависимостей между jobs нужен планировщик workflow (Airflow, Dagster, Prefect). Метаданные о sharding и сортировке ведите в каталоге.
  • Запускайте несрочные jobs на spot instance, но так, чтобы задачи спокойно перезапускались.
  • Не считайте переименование «каталога» в S3 атомарным: для атомарной публикации данных используйте табличный формат вроде Iceberg.

Запустите duckdb в терминале или откройте shell.duckdb.org. Блоки идут по порядку. DuckDB сам распараллеливает GROUP BY и JOIN, а мы посмотрим на них глазами MapReduce.

CREATE TABLE users AS
SELECT * FROM (VALUES
(1, DATE '1999-03-14'), (2, DATE '1985-07-02'), (3, DATE '2003-11-20'),
(4, DATE '1972-01-09'), (5, DATE '1995-05-30'), (6, DATE '1988-09-17')
) AS t(user_id, birth_date);
CREATE TABLE page_views AS
SELECT
i AS event_id,
(i * 7 + i // 4) % 6 + 1 AS user_id,
['/', '/blog/kafka.html', '/blog/spark.html'][(i * 5 + i // 3) % 3 + 1] AS url,
TIMESTAMP '2025-06-27 17:00:00' + INTERVAL (i) MINUTE AS ts
FROM generate_series(1, 40) AS g(i);

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

SELECT
(SELECT count(*) FROM users) AS users,
(SELECT count(*) FROM page_views) AS views,
(SELECT count(*) FROM page_views v
WHERE NOT EXISTS (SELECT 1 FROM users u WHERE u.user_id = v.user_id)) AS orphan_views;
┌───────┬───────┬──────────────┐
│ users │ views │ orphan_views │
│ int64 │ int64 │ int64 │
├───────┼───────┼──────────────┤
│ 6 │ 40 │ 0 │
└───────┴───────┴──────────────┘

1. Самые популярные страницы. Повторите цепочку sort | uniq -c | sort -r -n | head одним запросом.

Решение
SELECT url, count(*) AS views
FROM page_views
GROUP BY url
ORDER BY views DESC, url
LIMIT 3;
┌──────────────────┬───────┐
│ url │ views │
│ varchar │ int64 │
├──────────────────┼───────┤
│ /blog/kafka.html │ 14 │
│ / │ 13 │
│ /blog/spark.html │ 13 │
└──────────────────┴───────┘

GROUP BY url — это map (ключ = URL), shuffle и reduce (count). ORDER BY ... LIMIT — второй MapReduce job, который ранжирует результат.

2. Возраст аудитории по страницам. Соедините просмотры с профилями и посчитайте просмотры каждой страницы по группам «младше 30» и «30 и старше» на 27 июня 2025 года.

Решение
SELECT
url,
CASE WHEN birth_date > DATE '1995-06-27' THEN 'младше 30' ELSE '30 и старше' END AS age_group,
count(*) AS views
FROM page_views v
JOIN users u USING (user_id)
GROUP BY ALL
ORDER BY url, age_group;
┌──────────────────┬─────────────┬───────┐
│ url │ age_group │ views │
│ varchar │ varchar │ int64 │
├──────────────────┼─────────────┼───────┤
│ / │ 30 и старше │ 10 │
│ / │ младше 30 │ 3 │
│ /blog/kafka.html │ 30 и старше │ 7 │
│ /blog/kafka.html │ младше 30 │ 7 │
│ /blog/spark.html │ 30 и старше │ 9 │
│ /blog/spark.html │ младше 30 │ 4 │
└──────────────────┴─────────────┴───────┘

Это два job из книги в одном запросе: join по user_id и группировка по URL. Главную страницу смотрят в основном пользователи 30 лет и старше.

3. Раздача ключей по reducer. Раздайте записи трём reducer по правилу user_id % 3 (настоящий shuffle берёт хеш ключа). Проверьте, что все записи одного пользователя попадают к одному reducer.

Решение
SELECT
user_id % 3 AS reducer,
count(*) AS records,
count(DISTINCT user_id) AS keys,
list_sort(list(DISTINCT user_id)) AS user_ids
FROM page_views
GROUP BY reducer
ORDER BY reducer;
┌─────────┬─────────┬───────┬──────────┐
│ reducer │ records │ keys │ user_ids │
│ int64 │ int64 │ int64 │ int64[] │
├─────────┼─────────┼───────┼──────────┤
│ 0 │ 14 │ 2 │ [3, 6] │
│ 1 │ 13 │ 2 │ [1, 4] │
│ 2 │ 13 │ 2 │ [2, 5] │
└─────────┴─────────┴───────┴──────────┘

Каждый пользователь стоит ровно в одной строке, значит, все его записи достались одному reducer. Нагрузка ровная: 14, 13 и 13 записей.

  1. Почему неизменяемый вход делает batch job устойчивым к ошибкам в коде, а база с транзакциями так не умеет?
  2. Когда хеш-таблица в памяти лучше сортировки, а когда выигрывает сортировка?
  3. Чем объектное хранилище отличается от DFS? Почему переименование «каталога» в S3 опасно?
  4. Почему gang scheduling и вытеснение снижают загрузку кластера? Зачем batch jobs запускают на spot instance?
  5. Как shuffle гарантирует, что reducer увидит все записи одного ключа, и как на этом строится sort-merge join?
  6. Почему не стоит писать выход batch job прямо в рабочую базу и что делать вместо этого?

Предыдущая: Согласованность и консенсус. Следующая: Потоковая обработка.