PySpark Architecture Cheat Sheet

1. Core Components of PySpark

2. PySpark Layered Architecture

3. Spark Cluster Architecture

4. Spark Execution Process

5. Spark RDD Architecture

6. Spark DataFrame Architecture

7. Spark SQL Architecture

8. Spark Streaming Architecture

9. Spark Master-Slave Architecture

10. Key Concepts in PySpark

11. Common Use Cases for PySpark

• Batch Processing: Large-scale ETL (Extract, Transform, Load) jobs.
• Stream Processing: Real-time analytics, monitoring systems.
• Machine Learning: Training models at scale using Spark MLlib.
• Graph Processing: Social network analysis, recommendation systems.
• Data Warehousing: Leveraging Spark SQL for querying structured datasets.

Which parts of your PySpark ETL script are executed on the driver, master (YARN), or executors

Understanding how PySpark scripts execute across different nodes in a cluster is crucial for optimization and debugging. Here’s a breakdown of how to identify which parts of your script run on the driver, master/YARN, executors, or NameNodes:

Driver:

1. Script initialization: SparkSession creation, configuration, and setting up the Spark context.
2. Data ingestion: Reading data from sources (e.g., files, databases).
3. Data transformation definitions: Defining transformations (e.g., maps, filters, joins).
4. Action execution: Calling actions (e.g., count(), show(), write()).

Executor:

1. Task execution: Executing tasks assigned by the driver (e.g., mapping, filtering, joining).
2. Data processing: Processing data in parallel across executor nodes.
3. Shuffle operations: Exchanging data between executors during shuffle operations.

Master/YARN:

1. Resource management: Managing resources (e.g., memory, CPU) for the Spark application.
2. Job scheduling: Scheduling jobs and tasks on executor nodes.
3. Monitoring: Tracking application progress and performance.

NameNode (HDFS):

1. Data storage: Storing data in HDFS.
2. Metadata management: Managing file system metadata.

To identify which parts of your script run on each component, follow these steps:

Step 1: Enable Spark UI

Add the following configuration to your SparkSession:

spark = SparkSession.builder \
    .appName("Your App Name") \
    .config("spark.ui.enabled", True) \
    .config("spark.ui.port", 4040) \
    .getOrCreate()

Step 2: Analyze Spark UI

Access the Spark UI at http://driver-node-ip:4040:

1. Jobs: View job execution details, including task execution times.
2. Stages: Analyze stage execution, including shuffle operations.
3. Tasks: Examine task execution on individual executor nodes.

Step 3: Use Debugging Tools

1. Spark logs: Inspect logs for driver, executor, and master nodes.
2. Print statements: Add print statements to your script to track execution.

Real-Life Use Case:

Suppose you have a PySpark script that:

# Driver: Initialize SparkSession and read data
spark = SparkSession.builder.appName("ETL").getOrCreate()
data = spark.read.parquet("input_data")

# Driver: Define data transformations
transformed_data = data.filter(data["age"] > 18).join(data2, "id")

# Executor: Execute transformations and shuffle operations
transformed_data = transformed_data.repartition(10)

# Driver: Execute action and write data
transformed_data.write.parquet("output_data")

In this example:

• The driver initializes the SparkSession, reads data, defines transformations, and executes the action.
• The executor executes tasks assigned by the driver, including filtering, joining, and repartitioning.
• The master/YARN manages resources, schedules jobs, and monitors application progress.

By analyzing the Spark UI, logs, and debugging tools, you can gain insights into which parts of your script run on each component.