Introduction to Apache Spark

Apache Spark is a fast, general purpose engine for processing large amounts of data across a cluster of machines. It offers high level APIs in Java, Scala, Python, and R, backed by an optimized execution engine, along with higher level tools for SQL and structured data processing, machine learning, graph processing, and stream processing, all built on the same core engine.

History of Apache Spark

Spark began life in 2009 as a research project inside UC Berkeley’s AMPLab. It was released as open source in 2010 under the BSD license, then donated to the Apache Software Foundation in 2013, becoming a top level Apache project in 2014. Development has continued steadily since, and Spark is now in its fourth major version line, still actively maintained by the Apache community.

Why Spark Was Needed

Before Spark, different jobs typically needed different specialized tools. Hadoop MapReduce handled batch processing. Apache Storm or S4 handled stream processing. Apache Impala or Tez handled interactive queries. Neo4j or Apache Giraph handled graph processing. No single engine covered all of these well, and none of them offered fast, in memory processing with sub second response times.

Spark’s pitch was to be that one engine, real time streaming, interactive queries, graph processing, and batch processing, all handled through in memory processing that runs meaningfully faster than reading and writing to disk at every step. That combination, plus a consistent interface across all of it, is what set Spark apart from Hadoop and from single purpose tools like Storm.

Components of Apache Spark

• Spark Core, the foundation everything else runs on top of, providing the execution platform for every Spark application.
• Spark SQL, which lets you run SQL and HiveQL queries against structured and semi structured data, often meaningfully faster than the same queries running unmodified on older systems.
• Spark Streaming, which processes live data by breaking it into small micro batches that run on top of Spark Core.
• MLlib, Spark’s machine learning library, built to take advantage of in memory processing for iterative algorithms that would otherwise be slow.
• GraphX, a graph computation engine for processing graph structured data at scale.
• SparkR, a lightweight front end that lets R users analyze large datasets and run jobs interactively from the R shell, combining R’s usability with Spark’s scalability.

Apache Spark architecture overview

Spark has a layered architecture where its components stay loosely coupled, which is what makes it straightforward to extend with additional libraries. The architecture rests on two core abstractions: the Resilient Distributed Dataset, or RDD, and the Directed Acyclic Graph or DAG, which represents the sequence of steps in a computation.

How Apache Spark Works 

Like Hadoop MapReduce, Spark distributes data across a cluster and processes it in parallel. It uses a master and worker style architecture, one central coordinator and many distributed workers. That central coordinator is called the driver.

Apache Spark Terminology

Spark Context

The Spark Context is the entry point of a Spark application. It connects to the Spark execution environment and is used to create RDDs, accumulators, and broadcast variables, access Spark services, and run jobs. Its responsibilities include:

• Checking the current status of a Spark application
• Canceling a job or a stage
• Running a job synchronously or asynchronously
• Accessing or unpersisting a cached RDD
• Programmable dynamic allocation of resources

Spark Shell

The Spark Shell is a Spark application written in Scala that gives you a command line environment with auto completion, useful for getting familiar with Spark’s features before writing a standalone application of your own.

Spark Application

A Spark application is a self contained computation that runs user supplied code to produce a result. It can have processes running on its behalf even when it is not actively running a job.

Task, Job, and Stage

• Task, the smallest unit of work, sent to a single executor. Each partition of an RDD gets its own task.
• Job, a parallel computation made up of multiple tasks, created in response to an action.
• Stage, a set of tasks within a job that depend on each other. A job is split into stages because not every computation can happen in one continuous pass, some steps have to wait on others to finish first.

Spark Runtime Architecture

The Driver

The driver runs the main method of your program. It is the process that creates RDDs, performs transformations and actions on them, and creates the Spark Context. Launching the Spark Shell is itself an example of starting a driver program, and the application ends once the driver terminates.

The driver splits a Spark application into tasks and schedules them onto executors, through a task scheduler that lives inside the driver itself. Its two key jobs are converting your program into tasks, and scheduling those tasks on executors.

At a high level, a Spark program takes some input data as an RDD, derives new RDDs from it through transformations, then runs an action to actually compute a result. This builds up a DAG of operations implicitly as you write your code, and when the driver runs, it converts that DAG into an actual physical execution plan.

The Cluster Manager

Spark relies on a cluster manager to launch executors, and in some setups, to launch the driver as well. The cluster manager is a pluggable component, jobs and actions within a Spark application are scheduled by Spark’s own scheduler, by default in FIFO order, though round robin scheduling is also available. Applications can grow or shrink their resource usage dynamically based on workload, freeing resources when idle and requesting more again when demand returns. Spark currently supports this dynamic allocation across standalone mode, YARN, and Kubernetes. Apache Mesos was a supported option in earlier Spark versions, but that support was deprecated in Spark 3.2 and fully removed in Spark 4.0.

Executors

Executors run the individual tasks that make up a Spark job. They launch once at the start of an application and stay alive for its entire lifetime, and if one executor fails, the application can generally continue without stopping entirely. Executors have two main jobs: running the tasks that make up the application and returning results to the driver, and providing in memory storage for any RDDs the user has chosen to cache.

Resilient Distributed Dataset, RDD

RDDs are the building blocks of any Spark application. RDDs Stands for:

• Resilient: Fault tolerant and is capable of rebuilding data on failure
• Distributed: Distributed data among the multiple nodes in a cluster
• Dataset: Collection of partitioned data with values

RDD Persistence :

One of Spark’s most useful capabilities is persisting or caching, a dataset in memory across multiple operations. Once an RDD is persisted, each node keeps the partitions it computed in memory and reuses them for later actions on that same dataset or on datasets derived from it, which can make later operations dramatically faster, often by an order of magnitude, particularly for iterative algorithms and interactive analysis.

You mark an RDD for persistence using persist or cache. The first action that computes it will keep it in memory going forward. Spark’s cache is itself fault tolerant, if a partition is lost, Spark automatically recomputes it using the same transformations that built it originally.

A persisted RDD can use different storage strategies, called storage levels, depending on your priorities:

• MEMORY_ONLY, the default, keeps deserialized objects in memory. Partitions that do not fit are recomputed on demand rather than cached.
• MEMORY_AND_DISK, keeps deserialized objects in memory, but spills partitions that do not fit onto disk instead of recomputing them.
• MEMORY_ONLY_SER and MEMORY_AND_DISK_SER, available in Java and Scala, store serialized objects instead, which uses less memory at the cost of more CPU work to read.
• DISK_ONLY, stores partitions only on disk.
• Replicated variants, such as MEMORY_ONLY_2, work the same as their base level but keep a copy of each partition on two separate nodes.
• OFF_HEAP, an experimental option that stores serialized data outside the JVM heap, which requires off heap memory to be enabled.

Deploying Spark: Master URLs

When you launch a Spark application, the master URL tells Spark where and how to run:

• local, runs Spark on one worker thread, with no real parallelism, generally used only for quick local testing.
• local[K], runs Spark locally with K worker threads, typically set to match the number of cores on your machine.
• local[*], runs Spark locally using as many worker threads as there are logical cores available.
• spark colon slash slash HOST colon PORT, connects to a Spark standalone cluster at the given host and port.
• yarn, runs on a YARN managed cluster, using whichever configuration is set for client or cluster deploy mode.
• k8s colon slash slash HOST colon PORT, runs on a Kubernetes cluster, the current standard option for containerized Spark deployments.

Deployment Modes Compared

YARN can run Spark in two different modes, cluster and client, and standalone mode offers a third option that does not depend on YARN at all:

Real World Use Cases of Apache Spark

• Large scale batch processing, such as transforming and aggregating logs or transaction data across a data lake.
• Real time analytics, such as monitoring fraud signals or system metrics as events arrive, using Structured Streaming.
• Machine learning at scale, training models against datasets too large to fit comfortably on a single machine, using MLlib.
• ETL pipelines, reading from multiple sources, transforming the data, and loading it into a warehouse or lake using Spark SQL and DataFrames.
• Graph analysis, such as analyzing social networks or recommendation graphs using GraphX.

Common Misconceptions to Watch For

• Assuming Spark replaces Hadoop entirely. Spark commonly runs on top of Hadoop’s YARN resource manager and reads from HDFS, it replaces MapReduce as the processing engine, not the whole Hadoop ecosystem.
• Assuming Mesos is still a supported way to run Spark. It was removed in Spark 4.0. Standalone mode, YARN, and Kubernetes are the current options.
• Persisting every RDD by default. Caching costs memory. It pays off when a dataset is reused across multiple actions, but persisting data you only use once just adds overhead for no benefit.

That covers Apache Spark’s architecture, terminology, deployment options, and real world use cases. To go further, explore Prwatech’s Apache Spark training program, which includes placement assistance.