Каковы основные преимущества использования PySpark по сравнению с традиционным Python для обработки больших данных?

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

Как создать SparkSession в PySpark? Каковы его основные назначения?

В PySpark SparkSession является точкой входа для использования функциональности Spark и создаётся с помощью API SparkSession.builder. Его основные назначения включают взаимодействие с Spark SQL для обработки структурированных данных, создание DataFrame, конфигурирование свойств Spark, а также управление жизненным циклом SparkContext и SparkSession. Ниже приведён пример того, как может быть создан SparkSession:

from pyspark.sql import SparkSession
     
spark = SparkSession.builder \
         .appName("MySparkApp") \
         .master("local[*]") \
         .getOrCreate()

Опиши различные способы чтения данных в PySpark.

PySpark поддерживает чтение данных из различных источников, таких как CSV, Parquet и JSON, среди прочих. Для этой цели он предоставляет разные методы, включая spark.read.csv(), spark.read.parquet(), spark.read.json(), spark.read.format() и spark.read.load(). Ниже приведён пример того, как данные могут быть прочитаны в PySpark:

df_from_csv = spark.read.csv("my_file.csv", header=True)
df_from_parquet = spark.read.parquet("my_file.parquet")
df_from_json = spark.read.json("my_file.json")

Как обрабатывать пропущенные данные в PySpark?

В PySpark пропущенные данные можно обрабатывать с использованием нескольких методов. Можно удалять строки или столбцы, содержащие пропущенные значения, с помощью метода .dropna(). Также можно заполнять пропущенные данные конкретным значением или использовать методы интерполяции с помощью .fillna(). Кроме того, можно выполнять импутацию пропущенных значений с использованием статистических методов, таких как среднее значение или медиана, применяя Imputer. Ниже приведён пример обработки пропущенных данных в PySpark:

# Как удалить строки
df_from_csv.dropna(how="any")

# Как заполнить пропущенные значения константой
df_from_parquet.fillna(value=2)

# Как выполнить импутацию значений медианой
from pyspark.ml.feature import Imputer
imputer = Imputer(strategy="median", inputCols=["price","rooms"], outputCols=["price_imputed","rooms_imputed"])
model = imputer.fit(df_from_json)
df_imputed = model.transform(df_from_json)

Как можно кэшировать данные в PySpark для повышения производительности?

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

# Как кэшировать данные в памяти
df_from_csv.cache()

# Как сохранить данные на локальном диске
df_from_csv.persist(storageLevel=StorageLevel.DISK_ONLY)

При использовании cache() применяется только уровень хранения по умолчанию:

• MEMORY_ONLY для RDD
• MEMORY_AND_DISK для Dataset

При использовании persist() вы можете указать нужный уровень хранения как для RDD, так и для Dataset.

Из официальной документации:

• Вы можете пометить RDD для сохранения с помощью методов persist() или cache().
• Каждый сохранённый RDD может храниться с использованием разного уровня хранения.
• Метод cache() — это сокращённая форма использования уровня хранения по умолчанию, а именно StorageLevel.MEMORY_ONLY (хранение десериализованных объектов в памяти).

Используйте persist(), если вы хотите назначить уровень хранения, отличный от:

• MEMORY_ONLY для RDD
• или MEMORY_AND_DISK для Dataset

Подробнее почитать:

• Spark Difference between Cache and Persist?

Опиши выполнение соединений в PySpark

PySpark позволяет выполнять несколько типов соединений, таких как inner, outer, left и right. Используя метод .join(), можно задать условие соединения через параметр on и тип соединения через параметр how, как показано в примере:

# Как выполнить inner join двух наборов данных
df_from_csv.join(df_from_json, on="id", how="inner")

# Как выполнить outer join наборов данных
df_from_json.join(df_from_parquet, on="product_id", how="outer")

В чём заключаются ключевые различия между RDD, DataFrame и Dataset в PySpark?

Spark Resilient Distributed Dataset (RDD), DataFrame и Dataset являются ключевыми абстракциями в Spark, которые позволяют работать со структурированными данными в распределённой вычислительной среде. Несмотря на то что все они представляют данные, между ними существуют важные различия.

RDD являются низкоуровневыми API, не имеющими схемы и предоставляющими полный контроль над данными; они представляют собой неизменяемые коллекции объектов.

DataFrame являются высокоуровневыми API, построенными поверх RDD и оптимизированными для производительности, но не обладающими типобезопасностью; они организуют структурированные и полуструктурированные данные в именованные столбцы.

Dataset объединяют преимущества RDD и DataFrame, являясь высокоуровневыми API, которые предоставляют типобезопасную абстракцию; они поддерживают Python и Scala, обеспечивают проверку типов во время компиляции и при этом работают быстрее, чем DataFrame.

Объясни концепцию ленивых вычислений в PySpark. Как она влияет на производительность?

PySpark реализует стратегию, называемую ленивыми вычислениями, при которой преобразования, применяемые к распределённым наборам данных, таким как RDD, DataFrame или Dataset, не выполняются немедленно. Вместо этого Spark строит последовательность операций или преобразований, которые должны быть выполнены над данными, называемую ориентированным ациклическим графом, или DAG. Такой подход улучшает производительность и оптимизирует выполнение, поскольку вычисления откладываются до момента, когда вызывается действие и их выполнение становится действительно необходимым.

Какова роль партиционирования в PySpark и каким образом оно может улучшить производительность?

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

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

Объясни концепцию широковещательных переменных в PySpark и приведи пример использования

Широковещательные переменные являются важной возможностью распределённых вычислительных фреймворков Spark.

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

В чём различия между PySpark и pandas?

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

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

Как можно преобразовать DataFrame из pandas в PySpark DataFrame и обратно?

DataFrame pandas можно преобразовать в PySpark DataFrame с помощью метода spark.createDataFrame(), а PySpark DataFrame обратно в pandas DataFrame с помощью метода .toPandas().

import pandas as pd
from pyspark.sql import SparkSession

# Инициализация SparkSession
spark = SparkSession.builder.appName("Example").getOrCreate()

# Создание Pandas DataFrame
pdf = pd.DataFrame({'id': [1, 2, 3], 'value': [10, 20, 30]})

# Преобразование в PySpark DataFrame
df_spark = spark.createDataFrame(pdf)

# Обратное преобразование в Pandas DataFrame
pdf_new = df_spark.toPandas()

Intermediate PySpark Interview Questions

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

Что такое Spark Driver и каковы его обязанности?

Spark Driver — это основной процесс, который координирует выполнение приложений Spark, распределяя задачи по кластеру. Он взаимодействует с менеджером кластера для выделения ресурсов, планирования задач и мониторинга выполнения Spark-задач (Tasks).

Что такое Spark DAG?

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

Какие типы менеджеров кластеров доступны в Spark?

В настоящее время Spark поддерживает несколько менеджеров кластеров для управления ресурсами и планирования заданий.

• К ним относится Standalone — простой менеджер кластера, встроенный в Spark.
• Hadoop YARN — универсальный менеджер в экосистеме Hadoop, используемый для планирования заданий и управления ресурсами.
• Kubernetes применяется для автоматизации, развёртывания, масштабирования и управления контейнеризованными приложениями.
• Apache Mesos — распределённая система, используемая для управления ресурсами на уровне приложений.

Опиши, как реализовать пользовательское преобразование в PySpark

Для реализации пользовательского преобразования в PySpark можно определить Python-функцию, которая работает с PySpark DataFrame, а затем использовать метод .transform() для вызова этого преобразования. Ниже приведён пример реализации пользовательского преобразования в PySpark:

# Определение Python-функции, работающей с PySpark DataFrame
def get_discounted_price(df):
    return df.withColumn("discounted_price", \
                          df.price - (df.price * df.discount) / 100) 

# Вызов преобразования
df_discounted = df_from_csv.transfrom(get_discounted_price)

Объясни концепцию оконных функций в PySpark и приведи пример

Оконные функции в PySpark позволяют применять операции к окну строк, возвращая одно значение для каждой входной строки. С их помощью можно выполнять ранжирование, аналитические операции и агрегатные функции. Ниже приведён пример применения оконной функции в PySpark:

from pyspark.sql.window import Window
from pyspark.sql.functions import row_number

# Определение оконной функции
window = Window.orderBy("discounted_price")

# Применение оконной функции
df = df_from_csv.withColumn("row_number", row_number().over(window))

Как обрабатывать ошибки и исключения в PySpark?

Одним из наиболее полезных способов обработки ошибок и исключений в преобразованиях и действиях PySpark является оборачивание кода в блоки try-except для их перехвата. В RDD можно использовать операцию foreach для итерации по элементам и обработки исключений.

Каково назначение чекпойнтов в PySpark?

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

Как PySpark выполняет вывод схемы и как можно задать схему явно?

PySpark автоматически выводит схему при загрузке структурированных данных, однако для лучшего контроля и повышения эффективности можно явно определить схему с помощью StructType и StructField.

from pyspark.sql.types import StructType, StructField, IntegerType, StringType

schema = StructType([
    StructField("id", IntegerType(), True),
    StructField("name", StringType(), True)
])

df = spark.read.csv("data.csv", schema=schema, header=True)

Advanced PySpark Interview Questions

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

Объясни различия между узкими и широкими преобразованиями в PySpark

В PySpark узкие преобразования выполняются тогда, когда каждый входной партиции соответствует не более одной выходной партиции и при этом не требуется выполнение shuffle. К таким преобразованиям относятся, например, map(), filter() и union(). В противоположность этому, широкие преобразования необходимы для операций, при которых каждая входная партиция может вносить вклад в несколько выходных партиций, и при этом требуется перераспределение данных, выполнение соединений или агрегаций. Примерами таких преобразований являются groupBy(), join() и sortBy().

Что такое оптимизатор Catalyst в Spark и как он работает?

В Spark оптимизатор Catalyst является компонентом Spark SQL, основанным на правилах и предназначенным для оптимизации производительности запросов. Его основная задача заключается в преобразовании и улучшении SQL-запросов или операций DataFrame, заданных пользователем, с целью генерации эффективного физического плана выполнения, адаптированного под конкретный запрос и характеристики набора данных.

Опиши, как реализовать пользовательские агрегации в PySpark

Для реализации пользовательских агрегаций в PySpark можно совместно использовать методы groupBy() и agg(). Внутри вызова agg() можно передавать различные функции из модуля pyspark.sql.functions. Кроме того, можно применять пользовательские агрегации Pandas к группам внутри PySpark DataFrame с помощью метода .applyInPandas(). Ниже приведён пример реализации пользовательских агрегаций в PySpark:

# Использование groupBy и agg с функциями
from pyspark.sql import functions as F
df_from_csv.groupBy("house_id").agg(F.mean("price_discounted"))

# Использование applyInPandas
def normalize_price(df):
    disc_price = df["discounted_price"]
    df["normalized_price"] = disc_price.mean() / disc_price.std()

df_from_csv.groupBy("house_id").applyInPandas(normalize_price)

С какими трудностями ты сталкивался при работе с большими наборами данных в PySpark и как ты их преодолевал?

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

• Управление памятью и использование ресурсов.
• Перекос данных и неравномерное распределение нагрузки.
• Оптимизация производительности, особенно для широких преобразований и операций shuffle.
• Отладка и устранение неисправностей сложных сбоев заданий.
• Эффективное партиционирование и хранение данных.

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

Как интегрировать PySpark с другими инструментами и технологиями в экосистеме больших данных?

PySpark обладает тесной интеграцией с различными инструментами для работы с большими данными, включая Hadoop, Hive, Kafka и HBase, а также с облачными хранилищами, такими как AWS S3 и Google Cloud Storage.

Такая интеграция осуществляется с использованием встроенных коннекторов, библиотек и API, предоставляемых PySpark.

Какие лучшие практики существуют для тестирования и отладки приложений PySpark?

К числу рекомендуемых лучших практик для тестирования и отладки приложений PySpark относятся написание модульных тестов с использованием pyspark.sql.test.SQLTestUtils совместно с Python-библиотеками, такими как pytest, отладка приложений и логирование сообщений с помощью библиотеки logging, а также Spark UI, и оптимизация производительности с использованием API Spark org.apache.spark.metrics и инструментов мониторинга производительности.

Как бы ты решал вопросы безопасности и конфиденциальности данных в среде PySpark?

В настоящее время обмен данными стал значительно проще, поэтому защита чувствительной и конфиденциальной информации является важным способом предотвращения утечек данных. Одной из лучших практик является применение шифрования данных во время обработки и хранения. В PySpark этого можно добиться, используя функции aes_encrypt() и aes_decrypt() для столбцов DataFrame. Также для достижения этой цели можно использовать сторонние библиотеки, такие как библиотека cryptography.

Опиши, как использовать PySpark для построения и развёртывания модели машинного обучения

PySpark предоставляет библиотеку MLlib — масштабируемую библиотеку машинного обучения для построения и развёртывания моделей машинного обучения на больших наборах данных. API этой библиотеки может использоваться на различных этапах ML-процесса, таких как предварительная обработка данных, инженерия признаков, обучение модели, оценка качества и развёртывание. Используя кластеры Spark, можно развёртывать модели машинного обучения на базе PySpark в промышленной среде, применяя пакетный или потоковый инференс.

Как можно оптимизировать операции shuffle в PySpark?

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

• Стратегически использовать repartition() для балансировки партиций перед затратными операциями, такими как join.
• Отдавать предпочтение coalesce() вместо repartition() при уменьшении количества партиций, поскольку это минимизирует перемещение данных.
• Выполнять широковещательные соединения небольших таблиц с помощью broadcast() перед соединением с большими таблицами, чтобы избежать операций, интенсивно использующих shuffle.
• Настраивать конфигурации Spark, такие как spark.sql.shuffle.partitions, для оптимизации количества партиций при shuffle-операциях.

Вопросы для собеседования по PySpark для Data Engineer

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

Ниже приведены типичные вопросы, с которыми можно столкнуться.

Опиши, как бы ты оптимизировал задание PySpark, которое работает медленно. На какие ключевые факторы ты бы обратил внимание?

Если задание PySpark работает медленно, существует несколько аспектов, которые можно улучшить для оптимизации его производительности:

• Обеспечение корректного размера и количества партиций данных для минимизации перераспределения данных во время преобразований.
• Использование DataFrame вместо RDD, поскольку они уже используют несколько модулей оптимизации для повышения производительности рабочих нагрузок Spark.
• Использование широковещательных соединений и широковещательных переменных при соединении небольшого набора данных с большим набором данных.
• Кэширование и сохранение промежуточных DataFrame, которые используются повторно.
• Настройка количества партиций, ядер исполнителей и числа экземпляров для эффективного использования ресурсов кластера.

Выбор подходящих форматов файлов для уменьшения объёма данных.

Как обеспечить отказоустойчивость в приложениях PySpark?

Для обеспечения отказоустойчивости в приложениях PySpark можно использовать несколько стратегий:

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

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

Какие существуют способы развертывания и управления приложениями PySpark?

Мы можем развертывать и управлять приложениями PySpark с помощью следующих инструментов:

• YARN: менеджер ресурсов, который помогает развертывать и управлять приложениями в Hadoop-кластерах.
• Kubernetes: Spark предоставляет поддержку для развертывания приложений в кластерах Kubernetes.
• Databricks: предоставляет полностью управляемую платформу для приложений PySpark, абстрагируя сложность управления кластерами.

Как вы бы мониторили и устраняли проблемы в заданиях PySpark, работающих в production-среде?

PySpark предоставляет следующие инструменты для мониторинга и устранения проблем заданий, работающих в production-среде:

• Spark UI: веб-интерфейс, который помогает отслеживать прогресс выполнения заданий, использование ресурсов и выполнение задач.
• Логирование: мы можем настроить логирование для сбора детальной информации об ошибках и предупреждениях.
• Метрики: мы можем использовать системы мониторинга для сбора и анализа метрик, связанных с состоянием кластера и производительностью заданий.

Объясните разницу между динамическим и статическим распределением ресурсов в Spark и в каких случаях вы бы выбрали каждый из них

В Spark статическое распределение ресурсов означает предварительное и постоянное выделение фиксированных ресурсов, таких как память и количество ядер executors, на всё время выполнения приложения. В отличие от этого, динамическое распределение ресурсов позволяет Spark динамически изменять количество executors в зависимости от нагрузки. Ресурсы могут добавляться или удаляться по мере необходимости, что улучшает использование ресурсов и снижает затраты.

Как вы принимаете решение между использованием DataFrames и RDD в PySpark?

Выбор между DataFrames и RDD зависит от структуры данных и типа операций, которые необходимо выполнять.

Используйте DataFrames, когда:

• требуется обработка структурированных данных со схемой;
• нужна оптимизированная обработка с использованием Catalyst и Tungsten;
• используются SQL-запросы и встроенные трансформации.

Используйте RDD, когда:

• нужны низкоуровневые трансформации и более детальный контроль над вычислениями;
• вы работаете с неструктурированными или полуструктурированными данными;
• требуется большая гибкость в определении трансформаций.

Как бы вы реализовали инкрементальную обработку данных в PySpark?

Инкрементальная обработка необходима для эффективной работы с постоянно растущими наборами данных. Она может быть реализована с помощью:

• Использования Delta Lake: хранение обновлений в формате Delta позволяет эффективно обрабатывать инкрементальные изменения.
• Использования watermarking в structured streaming: помогает отбрасывать устаревшие данные, сохраняя при этом агрегаты с состоянием.
• Партиционирования и фильтрации: загрузка только новых или изменённых данных вместо переработки всего объёма.
• Использования checkpointing: сохранение промежуточных результатов для предотвращения переработки с нуля в случае сбоя.

Сообщение PySpark Interview — Вопросы и ответы появились сначала на DataTalks.RU. Data Engineering / DWH / Data Pipeline.

СТАТЬЯ В ПРОЦЕССЕ НАПИСАНИЯ

СТАТЬЯ В ПРОЦЕССЕ НАПИСАНИЯ

СТАТЬЯ В ПРОЦЕССЕ НАПИСАНИЯ

СТАТЬЯ В ПРОЦЕССЕ НАПИСАНИЯ

СТАТЬЯ В ПРОЦЕССЕ НАПИСАНИЯ

Что посмотреть на русском по Spark?

Однозначно плейлист «DataLearn: DE-101 | Модуль 7». Здесь вы получите базовое понимание инструмента.

Краткое описание терминов Spark

• Application (Приложение) — Пользовательская программа, созданная на Spark. Состоит из программы-драйвера и исполнителей на кластере.
• Application JAR — JAR-файл, содержащий приложение Spark пользователя. В некоторых случаях пользователи могут захотеть создать «uber JAR», который будет содержать их приложение вместе с его зависимостями. Однако, пользовательский JAR не должен включать библиотеки Hadoop или Spark, так как они будут добавлены во время выполнения.
• Cluster manager — Внешний сервис для получения ресурсов в кластере.
  Типы Cluster Manager:
  • Standalone (автономный менеджер) – простой менеджер кластеров, входящий в состав Spark, который упрощает настройку кластера.
  • Apache Mesos (Deprecated) — общий менеджер кластера, который также может запускать Hadoop MapReduce и сервисные приложения.
  • Hadoop YARN – менеджер ресурсов в Hadoop 3.
  • Kubernetes – система с открытым исходным кодом для автоматизации развертывания, масштабирования и управления контейнеризированными приложениями.
• Deploy mode (Режим развертывания) — Определяет, где запускается и работает процесс драйвера:
  • В режиме кластера (cluster mode) фреймворк запускает драйвер внутри кластера.
  • В режиме клиента (client mode) ведомый (подчиненный) запускает драйвер за пределами кластера.
  • Можно определить, в каком режиме вы находитесь, выполнив метод deployMode(). Метод возвращает свойство, защищенное от изменения (только для чтения).
• Driver program (Программа-драйвер) — Процесс, выполняющий основную функцию main() приложения и создающий контекст SparkContext. Все начинается именно здесь. Это процесс JVM, который управляет приложением Spark, обрабатывая вводимые пользователем данные и распределяя работу между исполнителями.
• Executor (Исполнитель) — Процесс, запускаемый для приложения на рабочем узле. Исполнитель выполняет задачи и сохраняет промежуточные данные в памяти или на диске. У каждого приложения имеются собственные исполнители.
• Job (Задание) — Параллельное вычисление (выполнение), состоящее из нескольких задач, которые порождаются в ответ на некоторое действие Spark (например, save() или collect()). В Spark job представляет собой ряд преобразований, применяемых к данным. Он охватывает весь рабочий процесс от начала до конца. Одно приложение Spark может иметь более одного job Spark.
• Stage (Этап) — Stage — это сегмент задания, выполняемый без data shuffling (перетасовки данных). Spark разбивает job (задание) на разные этапы, когда преобразование требует перетасовки данных между разделами.
• Task (Задача) — Минимальная единица работы, которая передается одному исполнителю. Каждый этап делится на несколько задач, которые выполняют обработку параллельно в разных data partitions (разделах данных).
• Worker node (Рабочий узел) — Любой узел, который может выполнять код приложения в кластере.
• RDD — это первичная абстракция данных. Используются ли DataFrames или Datasets, они компилируются в RDD за кулисами. Он представляет собой неизменяемую, секционированную коллекцию записей, с которой можно работать параллельно. Данные внутри RDD хранятся в памяти как можно дольше и как можно больше.

Схема Spark с компонентами:

Основы архитектуры Apache Spark

Архитектура Apache Spark используется не только для обработки в реальном времени, но и для пакетной обработки, и она может обеспечить производительность в сто раз выше, чем традиционный метод map-reduce, реализованный в Hadoop.

Архитектура Spark или Apache Spark — это фреймворк параллельной обработки, поддерживающий обработку в памяти для повышения производительности аналитических приложений больших данных и ядро Apache Spark, ресурсы которого управляются YARN. Проще говоря, архитектура Spark известна своей скоростью и эффективностью.

Вот ее основные особенности:

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

ПРИМЕЧАНИЕ: YARN — это своего рода менеджер ресурсов, который в основном используется для управления ресурсами вашей архитектуры Spark.

Архитектура Spark основана на двух важных абстракциях: устойчивом распределенном наборе данных (RDD) и направленном ациклическом графе (DAG).

Понимание операций DAG в Spark

Общая иерархия приложения Spark представлена на картинке:

В этом разделе будет описано, как код Spark разбивается на Job и Stage Tasks через DAG.

DAG (Directed Acyclic Graph) — это направленный ациклический граф, другими словами это набор вершин и ребер. Вершины представляют RDD, а ребра представляют операцию, которая должна быть применена к RDD. В Spark DAG каждое ребро направляется от более раннего к более позднему в последовательности. При вызове Action созданный DAG отправляется в DAG Scheduler, который далее разбивает граф на этапы задачи.

DAGScheduler — это уровень планирования Apache Spark, который реализует поэтапное планирование с использованием Jobs (заданий) и Stages (стадий).

DAGScheduler преобразует логический план выполнения (RDD lineage of dependencies built using RDD transformations) в физический план выполнения (с использованием Stages).

После вызова действия RDD в SparkContext передает логический план DAGScheduler, который он в свою очередь преобразует в набор Stages (этапов), отправляемых в виде TaskSets для выполнения.

PySpark DAG Visualization:

Как это работает в Spark?

• Sequence of Computations (Последовательность вычислений): в Spark, когда вы выполняете действия или преобразования с данными, они изначально представлены как ряд операций. Вместо того, чтобы выполнять каждую операцию немедленно, Spark создает DAG этих операций.
• Lazy Evaluation (Ленивая оценка): этот DAG формирует план выполнения, который оценивается и оптимизируется до фактического вычисления. Ленивая оценка Spark означает, что преобразования не вычисляются сразу, а накапливаются до тех пор, пока не будет вызвано действие. Это позволяет Spark оптимизировать план выполнения, например, путем комбинирования преобразований.
• Fault Tolerance (Отказоустойчивость): структура DAG способствует отказоустойчивости. Если узел выходит из строя во время вычислений, Spark может пересчитать только раздел потерянных данных, используя отношения, представленные DAG, вместо того, чтобы переделывать всю операцию.
• Optimized Execution (Оптимизированное выполнение): DAG позволяет Spark эффективно перестраивать вычислительные задачи. Зная зависимости и преобразования, Spark может выполнять этапы параллельно, оптимизировать распределение ресурсов и выполнять конвейеризацию операций.
• Task Scheduling (Планирование задач): После того, как DAG создан и оптимизирован, Spark делит его на набор этапов с наборами задач, которые запланированы для выполнения. Каждый этап в DAG может выполняться параллельно через доступные исполнители.

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

Еще одна иллюстрация как работает DAG (источник):

Понимание компонентов RDD: Resilient, Distributed, Dataset

RDD (Resilient Distributed Dataset) — является фундаментальной концепцией в Apache Spark, которая обозначает три основных атрибута.

Давайте разберемся, что означает каждый термин:

• Resilient (Устойчивый)
  • Отказоустойчивость: RDD разработаны для автоматического восстановления после ошибок или сбоев. Если узел в кластере выходит из строя, потерянные данные могут быть пересчитаны из его родословной, что гарантирует целостность данных.
  • Эффективное восстановление: с помощью процесса, известного как родословная, RDD могут повторно вычислять только утраченную часть данных, что делает восстановление эффективным без существенного нарушения процессов.
• Distributed (Распределенный)
  • Масштабируемость по узлам: данные распределяются по различным узлам в кластере, что позволяет выполнять параллельную обработку. Такое распределение повышает как скорость, так и эффективность, поскольку задачи могут использовать несколько машин.
  • Балансировка нагрузки: рабочие нагрузки равномерно распределяются по узлам, что позволяет избежать возникновения узких мест, обеспечивая оптимальное использование ресурсов и повышение производительности.
• Dataset (Набор данных)
  • Логическая группировка данных: RDD представляют собой набор данных в логической структуре, позволяя пользователям манипулировать большими объемами данных с помощью единого унифицированного интерфейса.
  • Преобразования и действия: с помощью RDD можно выполнять различные преобразования (например, сопоставление и фильтрация) и действия (например, подсчет и сбор) для беспрепятственного манипулирования и анализа данных.

Внутри каждый RDD в Spark имеет пять ключевых свойств:

• List of Partitions (Список разделов): RDD разделен на разделы, которые являются единицами параллелизма в Spark.
• Computation Function (Функция вычисления): Функция определяет, как вычислять данные для каждого раздела.
• Dependencies (Зависимости): RDD отслеживает свои зависимости от других RDD, которые описывают, как он был создан.
• Partitioner — Разделитель (необязательно): для RDD «ключ-значение» разделитель определяет, как разделяются данные, например, с помощью хэш-разделителя.
• Preferred Locations — Предпочтительные расположения (необязательно): в этом свойстве перечислены предпочтительные расположения для вычисления каждого раздела, например расположения блоков данных в HDFS.

Lazy Evaluation (Ленивая оценка)

Когда вы определяете RDD, его внутренние данные не доступны или не преобразуются немедленно, пока действие не запустит выполнение. Такой подход позволяет Spark определить наиболее эффективный способ выполнения преобразований.

RDD в Apache Spark поддерживает два типа операций:

• Трансформации — это функции, которые принимают существующие RDD в качестве входных данных и выводят один или несколько RDD. Однако данные в существующем RDD в Spark не изменяются, поскольку они неизменяемы.
• Действия в Spark — это функции, которые возвращают конечный результат вычислений RDD. Он использует lineage graph для загрузки данных в RDD в определенном порядке. После того, как все преобразования выполнены, действия возвращают конечный результат в драйвер Spark.

Partitions (Разделы)

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

RDD операции:

Существуют narrow (узкие) и wide (широкие) преобразования.

• В узком преобразовании все элементы данных, необходимые для вычисления записей в single partition (одном разделе), находятся в одном разделе родительского RDD.
• В широком преобразовании все элементы данных, необходимые для вычисления записей в одном разделе, могут находиться во многих разделах родительского RDD, поэтому для завершения преобразования разделы необходимо перетасовать (shuffled).

Narrow vs Wide Transformations:

Two-stage Spark job:

DAGScheduler проходит по родословной RDD от конечного RDD (с действием) обратно к исходному RDD, создавая DAG этапов на основе границ перемешивания. Этапы формируются там, где существуют широкие зависимости (границы перемешивания). Каждый этап состоит из параллельных задач, которые могут выполняться на разных разделах. Этапы создаются как ResultStages (конечный этап) или ShuffleMapStages (промежуточные этапы, которые выполняют перемешивание).

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

Перемешивание Spark срабатывает, когда мы выполняем определенные операции преобразования, такие как gropByKey(), reducebyKey(), join() на RDD и DataFrame.

Еще одна иллюстрация работы приложения Spark

Apache Spark Internals: Understanding Physical Planning (Stages, Tasks & Pipelining)

Apache Spark Internals: Task Scheduling — Execution of a Physical Plan

Что такое кластер Apache Spark?

Кластеры Apache Spark — это группа компьютеров, которые работают как один компьютер и обрабатывают выполнение различных команд, выдаваемых из блокнотов. Apache Spark использует архитектуру типа «master-worker», которая по сути может иметь master process (главный процесс) и worker processes (рабочие процессы), которые могут выполняться на нескольких машинах.

В Master node (главном узле) у вас есть программа драйвера (driver), которая управляет приложением, поэтому код, который вы пишете, ведет себя как программа драйвера. Внутри программы драйвера первое, что мы делаем, это создаем Spark context. Предполагая, что к Spark context может быть шлюзом ко всем или любым функциям Spark при идентичном подключении к базе данных. Worker nodes (рабочие узлы) — это подчиненные узлы, чья работа заключается в основном в выполнении задач.

Главный узел содержит программу драйвера, которая управляет приложением, создавая объект контекста Spark. Объект контекста Spark работает с менеджером кластера для управления различными заданиями. Задача рабочих узлов — выполнять задания и возвращать результаты главному узлу.

Основные компоненты архитектуры Apache Spark

• Программа драйвера: запускает основную функцию и отвечает за координацию задач в кластере. Она определяет один или несколько объектов SparkContext, которые являются основными точками входа для взаимодействия с механизмом выполнения Spark.
• Spark Context: центральный координатор для приложений Spark. Он взаимодействует с менеджером кластера для распределения ресурсов и планирования задач. Spark Context также управляет кэшированием и распределенным хранением RDD.
• Менеджер кластера: отвечает за управление ресурсами и планирование задач в кластере. Spark может работать с различными менеджерами кластера, такими как автономные, Apache Mesos, Hadoop YARN и Kubernetes.
• Executor: это процессы JVM, работающие на рабочих узлах, которые выполняют задачи, запланированные программой драйвера. Каждый executor запускает несколько задач одновременно в отдельных потоках и напрямую взаимодействует с программой драйвера, чтобы сообщать о состоянии задач. Executors также отвечают за кэширование разделов RDD в памяти или на диске.
• Задача: это наименьшая единица работы в Spark, представляющая собой одну операцию над разделом данных. Задачи объединяются в этапы, которые представляют собой группы задач с одинаковой операцией и зависимостями.
• RDD (Resilient Distributed Dataset): это неизменяемая, распределенная коллекция объектов, которые могут обрабатываться параллельно. RDD распределяются по узлам кластера, и Spark автоматически управляет их распределением, отказоустойчивостью и восстановлением.
• Планировщик DAG: делит приложение Spark на этапы на основе зависимостей между RDD. Он планирует задачи на узлах-исполнителях, принимая во внимание локальность данных и ресурсы кластера.
• Выполнение запроса: оптимизатор запросов Spark Catalyst и механизм выполнения Tungsten оптимизируют и выполняют запросы SQL и операции DataFrame/Dataset. Catalyst оптимизирует планы запросов, используя такие методы, как predicate pushdown и project pruning, в то время как Tungsten оптимизирует физическое выполнение, используя такие методы, как генерация кода и управление памятью.

Как компоненты Spark взаимодействуют для выполнения оптимизированного плана, созданного SparkContext. SparkContext передаёт этот план менеджеру кластера (который может быть автономным, YARN или Mesos) в рамках Spark. Менеджер кластера сначала проверяет доступные ресурсы и соответствующим образом назначает рабочие узлы. Эти узлы обрабатывают загрузку данных и выполняют задачи в распределённых разделах данных, обеспечивая быстрые вычисления в Apache Spark.

Дополнительным преимуществом архитектуры Spark является ее беспроблемное развертывание на распределенных системах хранения данных, таких как Hadoop, без необходимости какой-либо дополнительной поддержки для эффективной работы на этих платформах.

Как Executor обрабатывает данные в приложении Spark?

В приложении Spark Executor играет решающую роль в управлении обработкой и хранением данных.

Вот как это работает:

• Инициирование на Worker Nodes (рабочих узлах): каждый Executor инициируется как процесс на рабочем узле, гарантируя, что приложение эффективно использует распределенные вычислительные ресурсы.
• Выполнение задач и управление данными: Executors отвечают за выполнение назначенных им задач. Они предназначены для хранения данных либо в памяти для быстрого доступа, либо на диске для более постоянного хранения. Эта двойная возможность позволяет исполнителям сбалансировать скорость и доступность ресурсов, оптимизируя производительность.
• Взаимодействие с данными: Executors активно взаимодействуют с внешними источниками данных. Они считывают входные данные, необходимые для обработки, и записывают выходные данные обратно в эти источники, поддерживая бесперебойный поток информации в среду Spark и из нее.
• Application-Specific Allocation: каждое приложение Spark инициализирует свой собственный набор Executors. Это гарантирует, что задачи будут выполнены в изоляции от других запущенных приложений, предотвращая конфликты ресурсов и оптимизируя производительность приложения.

Job — это параллельное вычисление, состоящее из нескольких задач, и каждое распределенное действие — это job. Группа задач, которые могут быть выполнены для выполнения одной и той же задачи на нескольких исполнителях, представляет Stage. Каждое job разбивается на наборы задач, которые зависят друг от друга.

Ресурсы, предоставляемые всем рабочим узлам в соответствии с их потребностями, и управление всеми узлами осуществляется с помощью Cluster Manager, т.е. Cluster Manager — это режим, в котором мы можем запустить Spark.

Что такое Spark Session | Точка входа в Spark

Spark Session — это унифицированная точка входа для приложений Spark; она была представлена в Spark 2.0. Она действует как соединитель для всех базовых функций Spark, включая RDD, DataFrames и Datasets, предоставляя унифицированный интерфейс для работы со структурированной обработкой данных. Это один из самых первых объектов, которые вы создаете при разработке приложения Spark PySpark или Spark SQL. Как разработчик Spark, вы создаете SparkSession с помощью метода SparkSession.builder().

Spark Session объединяет несколько ранее отдельных контекстов, таких как SQLContext, HiveContext и StreamingContext, в одну точку входа, упрощая взаимодействие со Spark и его различными API. Он позволяет пользователям выполнять различные операции, такие как чтение данных из различных источников, выполнение SQL-запросов, создание DataFrames и Datasets, а также эффективное выполнение действий с распределенными наборами данных.

• SparkSession.builder()– Возвращаемый SparkSession.Builder класс. Это конструктор для SparkSession.master(), appName() и getOrCreate() являются методами SparkSession.Builder.
• master() – Это позволяет приложениям Spark подключаться и работать в разных режимах (локальный, автономный кластер, Mesos, YARN) в зависимости от конфигурации.
• Используйте local[x] при запуске на локальном ноутбуке. x должно быть целым числом и должно быть больше 0; это показывает, сколько разделов он должен создать при использовании RDD, DataFrame и Dataset. В идеале xзначение должно быть числом ядер ЦП, которые у вас есть.
• Для standalone использования spark://master:7077
• appName() – Задает имя для приложения Spark, которое отображается в веб-интерфейсе Spark. Если имя приложения не задано, задается случайное имя.
• getOrCreate() – Возвращает объект SparkSession, если он уже существует. Создает новый, если он не существует.

Создать еще один Spark Session

Иногда вам может потребоваться создать несколько сеансов, что можно легко сделать с помощью newSession() метода. Он использует то же имя приложения и мастера, что и существующий сеанс. Базовый SparkContext будет одинаковым для обоих сеансов, так как у вас может быть только один контекст на приложение Spark.

Spark Session vs Spark Context

Сессия Spark — это основной объект в Spark — точка входа каждого приложения Spark. Сессия представляет собой обертку вокруг sparkContext и содержит все метаданные, необходимые для начала работы с распределенными данными.

SparkContext — это переменная объекта Spark Session, которая используется для работы с RDD.

Контекст SQL — это то же самое, что и контекст Spark, переменная объекта сеанса Spark, которая используется для выполнения операций с DataFrames и DataSets.

Когда мы закончим анализ, мы можем очистить кэш Spark и завершить сессию с помощью SparkSession.stop().

Сериализация данных в PySpark

Сериализация данных в Spark — это процесс преобразования объектов в байтовый поток, который может быть передан по сети, сохранён в файл или использован в распределённой среде для хранения и обработки данных. В контексте Spark, сериализация имеет особое значение, потому что данные и объекты должны быть переданы между различными узлами или процессами, а также сохранены в формате, который позволяет их быстро считывать и восстанавливать.

Когда мы говорим о физической сериализации данных в Spark, мы имеем в виду преобразование объектов Python (или других языков, которые поддерживает Spark) в бинарный формат, который может быть эффективно передан и обработан на разных узлах кластера или в локальном режиме.

Что происходит при сериализации

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

Типы сериализаторов в PySpark

В Spark доступны два основных сериализатора для общего использования:

JavaSerializer (по умолчанию):

Класс: org.apache.spark.serializer.JavaSerializer

Этот сериализатор используется по умолчанию в Spark, в основном из-за его совместимости с объектами Java. Он использует встроенный механизм сериализации Java, что делает его высокосовместимым со всеми объектами Java.

• Плюсы: Простота, не требует дополнительных настроек, работает с широким спектром типов объектов.
• Минусы: медленнее и производит больше сериализованных данных по сравнению с Kryo. Не идеально подходит для высокопроизводительных приложений с интенсивным использованием памяти.

KryoSerializer

Класс: org.apache.spark.serializer.KryoSerializer

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

• Плюсы: более высокая производительность для больших или сложных объектов, минимизирует размер данных.
• Минусы: требуется ручная регистрация пользовательских классов (т.е. нестандартных типов Java), что добавляет дополнительные шаги и накладные расходы на настройку.

Как работает сериализация в PySpark

В Spark данные сериализуются, когда они перемещаются между узлами или сохраняются на диске.

Вот упрощенный вид процесса:

1. Данные подготавливаются на узле драйвера и сериализуются в двоичный формат с помощью настроенного сериализатора.
2. Сериализованные данные передаются на рабочие узлы кластера.
3. Рабочие узлы десериализуют данные для обработки.
4. Результаты с рабочих узлов снова сериализуются перед отправкой обратно на узел драйвера.

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

Spark Partitioning и Bucketing

Spark Partitioning и Bucketing — это техники организации данных в Apache Spark, которые помогают улучшить производительность при обработке больших объемов данных.

Partitioning в Spark — это процесс распределения данных по разным частям (партициям) для параллельной обработки. Каждая партиция — это подмножество данных, которое может обрабатываться отдельным потоком или задачей.

Партиционирование данных позволяет Spark эффективно распределять работу между кластерами.
При правильном partitioning можно уменьшить количество операций shuffle (перераспределение данных между узлами) в кластере, что значительно ускоряет обработку данных.

Bucketing — это метод организации данных в дисковых файлах с использованием более контролируемого подхода. В отличие от partitioning, который делит данные на основе значений столбцов, bucketing делит данные на несколько фиксированных «ведер» (buckets) по хэш-значению.

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

Partitioning — это метод, который делит данные на части на уровне кластеров.
Bucketing — это метод на уровне файловой системы, где данные делятся на несколько частей в рамках одного файла.

Партиционирование: Используйте партиционирование, когда вам нужно распределить данные для параллельной обработки и оптимизировать локальность данных. Это полезно для фильтрации и объединений (joins), где условие фильтрации соответствует ключу партиции.

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

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

На следующей диаграмме показан поток распределенной обработки:

• Драйвер Spark создает план выполнения для распределенной обработки между множеством исполнителей Spark.
• Драйвер Spark назначает задачи каждому исполнителю на основе плана выполнения. По умолчанию драйвер Spark создает разделы RDD (каждый соответствует задаче Spark) для каждого объекта S3 (Part1 … N). Затем драйвер Spark назначает задачи каждому исполнителю.
• Каждая задача Spark загружает свой назначенный объект S3 и сохраняет его в памяти в разделе RDD. Таким образом, несколько исполнителей Spark загружают и обрабатывают свою назначенную задачу параллельно.

Оптимизатор Catalyst

Внутри Spark используется движок, называемый оптимизатором Catalyst.для оптимизации планов выполнения. Catalyst имеет оптимизатор запросов, который можно использовать при запуске высокоуровневых API Spark, таких как Spark SQL, DataFrame и наборы данных, как показано на следующей диаграмме.

Поскольку оптимизатор Catalyst не работает напрямую с RDD API, высокоуровневые API обычно быстрее низкоуровневого RDD API. Для сложных соединений оптимизатор Catalyst может значительно повысить производительность, оптимизируя план выполнения задания. Вы можете увидеть оптимизированный план вашего задания Spark на вкладке SQL пользовательского интерфейса Spark.

Адаптивное выполнение запросов

Оптимизатор Catalyst выполняет оптимизацию времени выполнения с помощью процесса, называемого Adaptive Query Execution.

Adaptive Query Execution использует статистику времени выполнения для повторной оптимизации плана выполнения запросов во время выполнения вашего задания. Adaptive Query Execution предлагает несколько решений проблем производительности, включая объединение разделов после перемешивания, преобразование объединения сортировки-слияния в широковещательное объединение и оптимизацию перекошенного объединения.

Объединение разделов после перемешивания

Эта функция уменьшает разделы RDD (объединяет) после каждого перемешивания на основе map выходной статистики. Она упрощает настройку номера раздела перемешивания при выполнении запросов. Вам не нужно устанавливать номер раздела перемешивания, чтобы он соответствовал вашему набору данных. Spark может выбрать правильный номер раздела перемешивания во время выполнения после того, как у вас будет достаточно большое начальное количество разделов перемешивания.

Преобразование сортировочно-слиятельного соединения в широковещательное соединение

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

Оптимизация косого соединения

Перекос данных — одно из наиболее распространенных узких мест для заданий Spark. Он описывает ситуацию, в которой данные перекошены в определенные разделы RDD (и, следовательно, определенные задачи), что задерживает общее время обработки приложения. Это часто может снизить производительность операций соединения. Функция оптимизации перекоса соединения динамически обрабатывает перекос в соединениях сортировки-слияния, разделяя (и реплицируя при необходимости) перекошенные задачи на задачи примерно одинакового размера.

Spark RDD vs. DataFrame vs. Dataset

Понимание разницы между Spark RDD, DataFrames и наборами данных имеет важное значение в мире распределенной обработки данных. Эти различия, начиная от контроля и удобства и заканчивая сложностью и ясностью, позволяют специалистам по данным эффективно использовать возможности Apache Spark, независимо от характера их данных или сложности их задач.

Вот некоторая информация о Spark RDD, DataFrames и Datasets:

• Spark RDD: самая базовая абстракция данных в Spark. Это неизменяемые и распределенные коллекции данных. RDD предлагают детальный контроль над обработкой данных, но они могут быть сложны в использовании.
• Spark DataFrames: абстракция более высокого уровня, чем RDD. Это структурированные данные, организованные в именованные столбцы, похожие на таблицу в базе данных. DataFrames проще в использовании, чем RDD, но они предлагают меньший контроль над обработкой данных.
• Spark Datasets: это новая абстракция данных в Spark, которая объединяет преимущества RDD и DataFrames. Datasets — это распределенные коллекции данных с дополнительной схемой. Они предлагают баланс контроля и удобства, что делает их хорошим выбором для различных задач обработки данных.

Таблица сравнения:

YouTube Videos Apache Spark

Прежде чем мы перейдем к настройке среды, я публикую подборку видео по Apache Spark

PySpark Tutorial for Beginners

PlayList PySpark Tutorial for Beginners

Apache Spark Architecture — EXPLAINED!

Java и Apache Spark

Установка Java необходима для работы с PySpark, потому что Apache Spark написан на языке программирования Scala, который работает на платформе Java (JVM — Java Virtual Machine). Spark использует компоненты и библиотеки, которые требуют наличия Java.

Scala компилируется под Java VM.

---

Когда вы запускаете PySpark, Python-код взаимодействует с кластером Spark через Py4J — библиотеку, которая позволяет Python-коду общаться с Java-объектами.

Таким образом, Java необходима для:

• Запуска Spark: Для инициализации ядра Spark и работы всех его компонентов требуется Java.
• Совместимости с компонентами Spark: Spark и его различные компоненты (например, Spark SQL, MLlib и т.д.) используют Java и требуют Java Runtime для своей работы.
• Использования Py4J: Эта библиотека позволяет взаимодействовать Python-коду с JVM-кодом Spark, обеспечивая выполнение задач и обработки данных в распределенной среде.

Таким образом, для корректной работы PySpark обязательно наличие Java на машине.

Установка и настройка Apache Spark на отдельной машине

Все инструкции и примеры по работе с Apache Spark отдельно собраны в одном репозитории GitHub: pyspark-learning.

В рамках этой статьи основной целью является написание Guide, который позволит начать работу в рамках одной машины (я все инсталляции выполняю на Ubuntu). На других ОС действия должны быть похожими, но скорей всего будут чем-то отличаться.

Я начну с описания установки Java, затем перейду к установки Apache Spark и PySpark. После этого будет приведены примеры скриптов для работы с PySpark.

Установка JAVA

Если у вас на машине отсутствует Java, то начинаем с инсталляции Java (будем использовать Java 11 версии).

sudo apt update
sudo apt install openjdk-11-jdk

Проверяем, что Java установлена:

java -version

Ожидаемый вывод должен быть примерно:

openjdk version "11.0.XX"

Далее нам необходимо установить переменную окружения JAVA_HOME.

Запускаем команду:

sudo update-alternatives --config java

Копируем

/usr/lib/jvm/java-11-openjdk-amd64/bin/java

Добавляем в среду переменные в /etc/environment

/etc/environment — это системный файл, который используется для настройки глобальных переменных окружения. Переменные в этом файле доступны для всех пользователей системы.

Команда редактирования переменных:

sudo nano /etc/environment

Добавляем 2 строки:

JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
export JAVA_HOME

Перезагружаем с помощью команды:

. /etc/environment

Проверяем $JAVA_HOME

echo $JAVA_HOME

Результат:

/usr/lib/jvm/java-11-openjdk-amd64

Установка Apache Spark и PySpark — Вариант 1 «Light»

• Нужно ли ставить Spark отдельно?
  Нет. Если ты устанавливаешь через pip install pyspark, он включает Spark внутрь пакета. Можно начать работать без отдельной установки Spark.
• Нужна ли Java?
  Да, обязательно. PySpark использует Java-процессы под капотом.

Установка PySpark в виртуальном окружении

Устанавливаем виртуальную среду

python3 -m venv venv

Активируем среду

source venv/bin/activate

Устанавливаем PySpark:

pip install pyspark

Запускаем PySpark:

pyspark

Результат выполнения команды:

Использование Spark UI

При локальном запуске PySpark предоставляет веб-интерфейс Spark UI для мониторинга процессов.

После запуска PySpark откройте http://localhost:4040.

В Spark UI отражается следующая информация:

• Активные задачи — список всех текущих заданий, которые выполняются на Spark.
• DAG выполнения — Directed Acyclic Graph (DAG) отображает последовательность операций, которые Spark будет выполнять на данных. Это помогает понять, как данные передаются через различные этапы выполнения.
• Использование памяти и shuffle — показывает, сколько памяти используется на каждом этапе обработки и как Spark проводит операции shuffle (перемещение данных между узлами или процессами). В локальном режиме это будет важно для отслеживания, не переполняется ли память вашего устройства.

Если PySpark установлен локально через pip, то Spark запускается в локальном режиме (Local mode). В локальном режиме Spark по-прежнему использует свой распределённый движок, разделяя задачи на подзадачи и управляя их параллельным выполнением. Это позволяет работать с большими объемами данных, но ограничивает производительность количеством доступных ядер и памяти вашего устройства.

.master("local[*]") означает запуск Spark с использованием всех доступных ядер процессора. Вы можете также указать конкретное количество потоков, например, .master("local[4]"), чтобы использовать только 4 ядра.

Процесс выполнения PySpark кода локально:

1. Вы пишете код на Python с использованием PySpark.
2. Запускаете SparkSession, который инициализирует Spark.
3. Spark начинает разбиение данных и распределение их по доступным ядрам процессора.
4. Данные обрабатываются, и результаты возвращаются обратно в ваш код.

Важно! Если вы работаете с большим объёмом данных, которые не помещаются в память вашего устройства, вы можете столкнуться с проблемами производительности или даже с нехваткой памяти. Но для понимания PySpark — локальной машины будет достаточно для экспериментов с инструментом.

Установка Jupyter Notebook и запуск примера PySpark

В той же виртуальной среде запускаем команды установки Jupyter Notebook:

pip install notebook

Стартуем Jupyter Notebook:

jupyter notebook

Откроется http://localhost:8888/tree

Запуск примера приложения PySpark в Jupyter Notebook

todo

Установка Apache Spark и PySpark — Вариант 2 «Docker Compose»

todo

Как работать с Apache Spark в Google Colab?

Пример:

• https://gitlab.com/PythonRu/notebooks/-/blob/master/pyspark_beginner.ipynb — описание в статье Руководство по PySpark для начинающих

todo

Подборка примеров по Apache Spark

• https://github.com/spark-examples/pyspark-examples — Pyspark RDD, DataFrame and Dataset Examples in Python language

Использованные материалы для подготовки статьи

• The Overview Of Apache Spark

Сообщение Apache Spark Quick Start — Как начать работать с PySpark появились сначала на DataTalks.RU. Data Engineering / DWH / Data Pipeline.