知识花园

spark-quick-start

7分钟阅读

Spark 快速入门使用指南

一、Spark 是什么

一句话：Spark 是一个分布式数据处理引擎，专门用来跑大数据量的计算任务。

你可以把它理解成”超级版的 Pandas”——Pandas 只能在一台机器上跑，数据大了就内存溢出；Spark 可以把数据拆成 N 份，扔到几十上百台机器上并行算，算完再汇总。

核心优势：

  • 快：基于内存计算，比 Hadoop MapReduce 快 10~100 倍
  • 全：批处理、SQL、流处理、机器学习、图计算，一套引擎全搞定
  • 易用：支持 Python / Java / Scala / SQL，写 SQL 就能跑

当前最新稳定版：Spark 4.2（2026 年 7 月发布）

二、三个必须懂的概念

1. RDD（弹性分布式数据集）

Spark 最底层的数据抽象。简单说就是一个被拆成很多份、分布在不同机器上的集合。

  • 不可变：改不了，要改就得生成新的 RDD
  • 可分区：数据被切成很多块，分散在集群里
  • 容错：挂了自动重算，不用存副本

RDD 是底层 API，95% 的场景你不会直接用它。 知道有这么个东西就行。

2. DataFrame（你 99% 的时间会用这个）

带 Schema 的分布式数据表，长得跟 Pandas DataFrame 一模一样，也跟数据库的表一样——有列名、有类型。

+-------+---+----------+
|   name|age|department|
+-------+---+----------+
|  Alice| 25|        HR|
|    Bob| 30|       Eng|
|Charlie| 35|       Eng|
+-------+---+----------+

为什么比 RDD 快？因为 DataFrame 走 Catalyst 优化器 + Tungsten 引擎——你写的 SQL 会被自动优化执行计划，还做了内存层面的极致优化。

3. SparkSession

你的入口。所有操作从它开始。

三、安装（5 分钟搞定）

方式一：Python 版（推荐新手）

pip install pyspark

就这一行。装完直接在 Python 里用。

方式二：完整版（Scala/Java 开发用）

# 下载
wget https://archive.apache.org/dist/spark/spark-3.5.0/spark-3.5.0-bin-hadoop3.tgz
 
# 解压
tar -xzf spark-3.5.0-bin-hadoop3.tgz
 
# 配环境变量
export SPARK_HOME=/path/to/spark-3.5.0-bin-hadoop3
export PATH=$SPARK_HOME/bin:$PATH

验证

pyspark  # 进入 PySpark 交互式 shell
spark-shell  # 进入 Scala 交互式 shell

四、第一个程序：WordCount

经典入门案例——统计一段文本里每个单词出现的次数。

PySpark 版（DataFrame 写法）

from pyspark.sql import SparkSession
from pyspark.sql.functions import split, explode, count
 
# 1. 创建 SparkSession（入口）
spark = SparkSession.builder \
    .master("local[*]") \
    .appName("WordCount") \
    .getOrCreate()
 
# 2. 造点数据
data = [
    "Apache Spark is a unified analytics engine",
    "Spark SQL is a module for structured data processing",
    "Spark Streaming processes real time data streams",
    "MLlib is Sparks machine learning library"
]
 
# 3. 创建 DataFrame
df = spark.createDataFrame(data, "string").toDF("line")
 
# 4. 统计单词数
result = df \
    .select(explode(split(df.line, " ")).alias("word")) \
    .groupBy("word") \
    .agg(count("*").alias("count")) \
    .orderBy("count", ascending=False)
 
# 5. 输出结果
result.show()
 
# 6. 停止
spark.stop()

运行结果：

+----------+-----+
|      word|count|
+----------+-----+
|     Spark|    3|
|        is|    3|
|         a|    2|
|      data|    2|
|    Apache|    1|
|   unified|    1|
| analytics|    1|
|    engine|    1|
|       SQL|    1|
|    module|    1|
+----------+-----+

RDD 写法（了解即可）

from pyspark import SparkContext
 
sc = SparkContext("local[*]", "WordCount")
 
lines = sc.parallelize([
    "Apache Spark is a unified analytics engine",
    "Spark SQL is a module for structured data processing"
])
 
word_counts = lines \
    .flatMap(lambda line: line.split(" ")) \
    .map(lambda word: (word, 1)) \
    .reduceByKey(lambda a, b: a + b) \
    .collect()
 
for word, count in word_counts:
    print(f"{word}: {count}")
 
sc.stop()

五、常用操作速查

读文件

# 读 CSV
df = spark.read.csv("data.csv", header=True, inferSchema=True)
 
# 读 JSON
df = spark.read.json("data.json")
 
# 读 Parquet（列式存储，Spark 首选格式）
df = spark.read.parquet("data.parquet")
 
# 读 JDBC（MySQL 等）
df = spark.read.jdbc(url, table, properties={"user": "xxx", "password": "xxx"})

写文件

df.write.csv("output.csv", header=True)
df.write.parquet("output.parquet")
df.write.json("output.json")

DataFrame 常用操作

# 选列
df.select("name", "age")
 
# 过滤
df.filter(df.age > 25)
df.where("age > 25")  # SQL 风格
 
# 分组聚合
df.groupBy("department").count()
df.groupBy("department").avg("salary", "age")
 
# 排序
df.orderBy(df.age.desc())
 
# 去重
df.dropDuplicates(["name"])
 
# 新增列
df.withColumn("age_plus_1", df.age + 1)
 
# 改列名
df.withColumnRenamed("old_name", "new_name")
 
# 删列
df.drop("column_name")
 
# Join
df1.join(df2, df1.id == df2.user_id, "inner")  # inner/left/right/full

直接写 SQL

# 注册临时视图
df.createOrReplaceTempView("people")
 
# 写 SQL
result = spark.sql("""
    SELECT department, AVG(age) as avg_age
    FROM people
    WHERE age > 25
    GROUP BY department
    ORDER BY avg_age DESC
""")
 
result.show()

六、运行模式

模式说明适用场景
local本地单线程调试
local[*]本地用所有 CPU 核本地开发测试
standaloneSpark 自带集群简单集群
yarn跑在 Hadoop YARN 上生产环境最常用
k8s跑在 Kubernetes 上云原生环境

提交任务到集群：

spark-submit \
    --master yarn \
    --deploy-mode cluster \
    --num-executors 10 \
    --executor-cores 4 \
    --executor-memory 8g \
    your_script.py

七、常见坑

  1. 数据倾斜：某个 key 数据量特别大，一个 task 跑半天。解决：加盐、广播小表、AQE（Spark 3.0+ 自动优化）。

  2. OOM（内存溢出）：

    • Driver OOM：collect() 了太多数据回 Driver
    • Executor OOM：数据没分好，或者单个分区太大

  3. Shuffle 慢：groupBy、join、reduceByKey 都会触发 Shuffle（数据跨节点传输），能避免就避免。

  4. 别用 collect() 取大数据：它会把所有数据拉到 Driver 节点，数据量大直接 OOM。用 show() 看前几行就行。

八、学习路径建议

第 1 步：PySpark + DataFrame API + SQL
    ↓
第 2 步：理解 Shuffle、分区、持久化（cache/persist）
    ↓
第 3 步：性能调优（资源配置、数据倾斜、广播变量）
    ↓
第 4 步：Spark Streaming / Structured Streaming（实时处理）
    ↓
第 5 步：MLlib（机器学习）、GraphX（图计算）按需学

核心原则：能用 DataFrame/SQL 就别用 RDD。 DataFrame 有 Catalyst 自动优化，写起来简单跑得还快。RDD 只在你需要极致控制底层逻辑时才用。

九、推荐资源

总结：Spark 就是分布式版的 Pandas + SQL 引擎。入门用 PySpark + DataFrame，写 SQL 就能搞定 90% 的场景。先跑通 WordCount，再学常用 API，最后研究调优——就这个顺序。

关系图谱

反向链接