Apache Spark Internals

Это курс не о том, как писать Spark-приложения. Если вы здесь — у вас уже есть production-пайплайны на Spark: DataFrame API, джойны, агрегации, сохранение в Delta или Parquet, деплой на YARN или Kubernetes. Вы умеете читать Spark UI, ловить спиллы и настраивать spark.sql.shuffle.partitions. И вы уже сталкивались с тем, что этой поверхностной модели не хватает: plan выглядит разумно, а job идёт в три раза дольше ожидаемого. Или AQE “зачем-то” перепланировал join, и вы не знаете, улучшил он ситуацию или ухудшил. Или на executor начинаются OOM при 20 GB данных, хотя heap выставлен в 30 GB.

Этот курс — про спуск с уровня API до уровня машины.

Для кого этот курс

Курс рассчитан на senior data-инженеров и platform-инженеров, которые:

• Уже пишут Spark в продакшне. Не один пайплайн, а несколько, с нетривиальными требованиями по latency или throughput.
• Знают middle-курс или эквивалент. DataFrame API, Catalyst optimizer на уровне “что такое logical plan и physical plan”, AQE как концепция, Structured Streaming на уровне trigger и output modes — это baseline. Если какой-то из этих терминов требует объяснения, сначала middle-курс.
• Хотят понять “почему”, а не только “как”. Не “как включить AQE”, а “какой именно re-plan произошёл и почему он помог”. Не “как настроить shuffle.partitions”, а “что происходит с map-выходом до того, как редьюсер его читает”.
• Готовы читать исходники. Курс ссылается на конкретные классы Spark: org.apache.spark.sql.catalyst.optimizer.Optimizer, org.apache.spark.shuffle.sort.SortShuffleManager, org.apache.spark.sql.execution.streaming.IncrementalExecution. Открывать их в IDE — часть процесса.

Чем этот курс отличается от spark-course

Middle-курс spark-course учит работать с движком: как написать эффективный join, как читать Spark UI, как настроить broadcast. Этот курс объясняет, что происходит внутри при каждом из этих действий.

Конкретный пример. В middle-курсе вы узнали, что broadcast join быстрее sort-merge join для маленьких таблиц. В этом курсе вы разберёте: как Catalyst принимает решение о broadcast, что происходит с broadcast-переменной в driver, как она сериализуется и передаётся на executor, что такое BroadcastExchangeExec в physical plan и при каком размере таблицы broadcast перестаёт помещаться в memory-store. Это другой уровень детализации — и другая ценность при отладке.

Ещё одно отличие: этот курс намеренно идёт к исходному коду. Каждый модуль заканчивается списком классов Spark, которые реализуют обсуждаемую механику. Идея не в том, чтобы зазубрить имена классов, а в том, чтобы знать, куда смотреть, когда debug-сессия заходит в тупик.

Версия Spark — 4.0 (2026)

Baseline курса — Apache Spark 4.0, stable на 2026 год. Это важно по нескольким причинам:

• Spark Connect стал рекомендуемым способом работы с кластером. Классический SparkSession напрямую к кластеру всё ещё работает, но Spark Connect меняет deployment model: client-библиотека тонкая, plan-сборка локальная, execution — на сервере.
• Structured Streaming transformWithState — новый stateful API в Spark 4.0, который заменит flatMapGroupsWithState. Курс разбирает internals обоих.
• Project Tungsten и whole-stage codegen — зрелые с 2.x, но в 4.0 дополнены новыми оптимизациями row format. Разбираем до уровня JVM bytecode.
• AQE по умолчанию включён с 3.2 и в 4.0 получил расширенные стратегии. Разбираем все три адаптивных оптимизации.
• Comet и Gluten — native execution engines, которые заменяют JVM-выполнение на Arrow/Velox. Это не просто фичи — это другая модель execution. Модуль 13 разбирает, как они встраиваются в Spark.

Там, где поведение или API изменились с 3.x — об этом явно сказано.

Что вы умеете после курса

Сформулируем конкретно. После прохождения всего курса вы:

1. Понимаете полный путь запроса от API до байтов. От df.filter("price > 100") через Analysis, Logical Optimization, Physical Planning, Whole-Stage Codegen до байтов UnsafeRow в памяти executor-а. Вы можете развернуть любой шаг этого пути и объяснить, какой класс Spark за него отвечает.

2. Диагностируете production-инциденты по Spark UI без догадок. Видите долгий stage — знаете, какие метрики смотреть (shuffle read/write, spill, task skew, GC time) и что каждая из них означает на уровне механики. Видите AQE re-plan — понимаете, какое решение было принято и почему.

3. Тюните Spark осознанно, а не по cargo-cult. Параметры вроде spark.sql.autoBroadcastJoinThreshold, spark.shuffle.file.buffer, spark.memory.offHeap.size не просто “рекомендуемые значения из блога” — вы понимаете, что каждый из них меняет в runtime и какие побочные эффекты возможны.

4. Знаете shuffle до байтов. Sort-based shuffle, tungsten sort, external merge sort, shuffle write/read path — от ShuffleMapTask до BlockStoreShuffleReader. Это самая болезненная точка production Spark, и вы знаете, как её диагностировать.

5. Понимаете Structured Streaming как систему. IncrementalExecution, micro-batch vs continuous, StateStore backends (HDFS и RocksDB), transformWithState internals, watermark mechanics на уровне кода.

6. Работаете с Spark Connect. Понимаете client-server model, что происходит с plan на client-стороне, как это меняет отладку и что значит “remote SparkSession” на практике.

7. Знаете, когда Spark — не лучший инструмент. Native execution engines (Comet, Gluten), External Shuffle Service, альтернативные execution backends — понимаете их trade-offs и когда они дают реальный выигрыш.

Пререквизиты

Обязательно:

• Уверенный опыт Spark на уровне production-пайплайнов (DataFrame API, joins, aggregations, Spark UI чтение)
• Middle-курс spark-course или эквивалентный опыт (~2 года production Spark)
• Способность читать JVM-код (Java или Scala): курс ссылается на Spark source, написанный на Scala/Java, на уровне “понять что делает метод”
• Понимание основ distributed systems: executor, driver, shuffle, partitioning — как концепции, не только как слова

Рекомендуется:

• Курс storage-formats (Parquet internals, columnar formats) — несколько модулей пересекаются с форматами хранения
• Базовое понимание JVM memory model: heap, off-heap, GC basics

Как устроена подача

Каждый модуль этого курса устроен одинаково:

• Концептуальный слой — что делает данная подсистема и зачем она так устроена. Без этого нет смысла идти глубже.
• Механика — как именно она это делает: алгоритмы, структуры данных, протоколы взаимодействия между компонентами.
• Исходный код — конкретные классы и методы Spark, которые реализуют обсуждаемую механику. Рекомендуется открывать параллельно с чтением.
• Production-применение — как эти знания меняют конкретные debugging-сценарии, tюнинг-решения или архитектурные выборы.

Курс не пересказывает документацию Spark. Документация говорит “вот такой параметр”. Этот курс говорит “вот почему такой параметр существует и что происходит в коде, когда вы его меняете”.

Скачайте Spark source и держите рядом:

git clone https://github.com/apache/spark.git
cd spark
git checkout v4.0.0

В каждом deep-уроке курс ссылается на конкретные классы. Открывайте их в IDE параллельно. Понимание приходит не от чтения урока, а от верификации: вы открываете SortShuffleManager.scala, находите метод, описанный в уроке, и убеждаетесь, что это действительно так.

Что дальше

Следующий урок — карта всех 17 модулей курса: логика порядка, рекомендации как проходить, разные learning paths в зависимости от ваших целей.

После intro-блока начинается модуль 01 (Философия internals) — зачем вообще спускаться на этот уровень и как думает senior-инженер, когда видит production-инцидент. Это короткий модуль, но он задаёт правильный mental model для остального курса.

Как создавался курс

Курс создан при участии Claude (Anthropic) как соавтора: ИИ помогал писать материалы, структурировать темы, генерировать примеры кода и диаграммы. Каждая глава проходила ручную сверку с первоисточниками — спецификациями, документацией, исходным кодом рассматриваемых систем — но гарантировать 100% точность невозможно.

Если вы заметили неточность, опечатку или хотите предложить улучшение — напишите в Telegram-группу курса. Это самый ценный вклад в курс, который вы можете сделать.

Углублённое изучение с Claude

Курс рассчитан на самостоятельное изучение, но любая теория быстрее ложится, если задавать вопросы. Рекомендую держать рядом браузерное расширение Claude (claude.com/download) — оно работает с контентом открытой страницы: выделяете кусок урока и спрашиваете напрямую.

Сценарии, которые особенно хорошо работают для углублённого погружения:

• «Объясни проще» / «дай ещё один пример» — когда формулировка из урока не дошла с первого раза.
• «Покажи, как это устроено на уровне кода / железа» — когда хочется спуститься на слой ниже того, что даёт урок.
• «Как это связано с [другая тема курса]» — когда нужно увязать концепцию с тем, что было раньше.
• «У меня в проекте стек X — как применить?» — когда хочется примерить материал на свой реальный кейс.

Это не замена курсу, а способ ускорить интеграцию материала в вашу картину мира. Если что-то из ответов Claude расходится с уроком — присылайте в Telegram-группу, курс будет уточнён.

Нашли ошибку?

Если вы заметили неточность, опечатку или хотите предложить улучшение:

Telegram-канал

Подписывайтесь, чтобы узнавать об обновлениях и новых курсах: