[spark]standalone伪分布式集群环境(搭建2)

由于只有一台Mac笔记本电脑，我们将搭建一个单机版的Spark集群（伪分布式模式），并使用Python（PySpark）开发机器学习模型。整个过程可以分为以下几个步骤：

步骤概览：

1. 安装Java：Spark需要Java运行环境。
2. 安装Scala（可选）：Spark是用Scala写的，但使用PySpark可以跳过Scala，不过为了完整性和可能的Scala开发，可以选择安装。
3. 安装Hadoop（可选）：Spark可以独立运行，但如果你需要HDFS，可以安装Hadoop。这里我们使用Spark自带的独立集群模式，所以可以不装Hadoop。
4. 安装Spark：下载并配置Spark。
5. 配置Spark单机集群：配置为伪分布式模式。
6. 安装Python和必要的库：包括pyspark、机器学习库等。
7. 开发机器学习模型：使用PySpark编写一个简单的机器学习示例。

详细步骤：

1. 安装Java

Spark需要Java 8或更高版本。在Mac上，可以使用Homebrew安装，也可以从Oracle官网下载。

使用Homebrew安装：

brew update
brew install java

安装完成后，设置环境变量。如果你使用zsh（Mac默认shell），编辑~/.zshrc文件，添加：

export JAVA_HOME=$(/usr/libexec/java_home)

然后使配置生效：

source ~/.zshrc

验证安装：

java -version

2. 安装Scala（可选）

同样可以使用Homebrew安装：

brew install scala

验证：

scala -version

3. 安装Hadoop（可选）

如果不需要HDFS，可以跳过。如果需要，使用Homebrew安装：

brew install hadoop

配置Hadoop伪分布式模式需要一些配置，这里不展开，因为Spark可以独立运行。

4. 安装Spark

从Spark官网下载预编译版本，选择与Hadoop版本匹配的（如果不安装Hadoop，选择“without Hadoop”版本）。或者使用Homebrew安装（但Homebrew可能版本更新不及时）。

这里我们使用下载预编译版本的方式：

• 访问 Spark下载页面
• 选择最新版本，选择包类型为“Pre-built for Apache Hadoop 3.3 and later”（如果你没有安装Hadoop，这个版本包含了必要的Hadoop客户端库，可以独立运行）
• 下载后解压到某个目录，例如 /Users/yourusername/spark
• 配置环境变量，编辑~/.zshrc，添加：

export SPARK_HOME=/Users/yourusername/spark
export PATH=$SPARK_HOME/bin:$PATH

使配置生效：

source ~/.zshrc

验证安装：

spark-shell --version

5. 配置Spark单机集群（伪分布式模式）

在Spark目录下的conf文件夹中，有一个模板文件spark-env.sh.template，复制一份并重命名为spark-env.sh：

cd $SPARK_HOME/conf
cp spark-env.sh.template spark-env.sh

编辑spark-env.sh，添加以下内容（根据你的系统配置调整）：

export JAVA_HOME=$(/usr/libexec/java_home)
# 设置Spark master主机名
export SPARK_MASTER_HOST=localhost
# 设置每个worker使用的内核数，根据你的机器调整
export SPARK_WORKER_CORES=2
# 设置每个worker使用的内存，例如2g
export SPARK_WORKER_MEMORY=2g

另外，需要配置slaves文件（在Spark独立集群中，这个文件指定worker节点）。同样，复制模板：

cp workers.template workers

编辑workers文件，添加：

localhost

这样，我们就有一个worker在本地运行。

6. 启动Spark集群

在Spark目录下，使用以下命令启动集群：

sbin/start-all.sh

停止集群使用：

sbin/stop-all.sh

启动后，可以在浏览器中访问Spark Master的Web UI：http://localhost:8080

7. 安装Python和必要的库

Mac通常自带Python，但建议使用Anaconda来管理Python环境，避免权限问题。

安装Anaconda或Miniconda后，创建一个新的环境：

conda create -n pyspark_env python=3.8
conda activate pyspark_env

安装PySpark。注意：如果你已经安装了Spark，PySpark已经包含在Spark中，但是为了在Python中使用，你可能需要安装PySpark包以获取一些额外的功能。你可以使用pip安装，但版本需要与Spark版本一致。或者，你可以直接使用Spark自带的pyspark。

方法一：使用pip安装PySpark（版本需匹配）：

pip install pyspark

方法二：使用Spark自带的pyspark，需要将pyspark添加到Python路径。在~/.zshrc中添加：

export PYTHONPATH=$SPARK_HOME/python:$PYTHONPATH

然后重新打开终端或执行source ~/.zshrc。

此外，安装一些常用的机器学习库，如numpy、pandas、scikit-learn等（注意：在Spark中，我们通常使用MLlib，但也可以结合使用）：

pip install numpy pandas scikit-learn

8. 开发机器学习模型

下面是一个使用PySpark的MLlib进行逻辑回归的简单示例。

首先，启动一个pyspark shell（在终端中运行pyspark）或者编写一个Python脚本。

示例脚本（保存为spark_ml_example.py）：

from pyspark.sql import SparkSession
from pyspark.ml.classification import LogisticRegression
from pyspark.ml.evaluation import BinaryClassificationEvaluator
from pyspark.ml.feature import VectorAssembler
from pyspark.ml import Pipeline
import pandas as pd

# 创建SparkSession，并连接到本地集群
spark = SparkSession.builder \
    .master("spark://localhost:7077") \
    .appName("Spark ML Example") \
    .getOrCreate()

# 读取数据（这里使用一个示例数据集，你可以替换为自己的数据）
# 假设我们有一个CSV文件，前四列是特征，最后一列是标签
# 这里我们使用一个本地文件，也可以使用HDFS上的文件
# 为了示例，我们使用一个简单的pandas DataFrame创建Spark DataFrame
df = pd.read_csv('data.csv')  # 假设你的数据文件是data.csv
spark_df = spark.createDataFrame(df)

# 将特征列合并为一个向量列
feature_columns = ['feature1', 'feature2', 'feature3', 'feature4']  # 根据你的数据调整
assembler = VectorAssembler(inputCols=feature_columns, outputCol="features")

# 划分训练集和测试集
train, test = spark_df.randomSplit([0.7, 0.3], seed=123)

# 创建逻辑回归模型
lr = LogisticRegression(featuresCol="features", labelCol="label")

# 创建管道
pipeline = Pipeline(stages=[assembler, lr])

# 训练模型
model = pipeline.fit(train)

# 在测试集上预测
predictions = model.transform(test)

# 评估模型
evaluator = BinaryClassificationEvaluator(labelCol="label", rawPredictionCol="rawPrediction", metricName="areaUnderROC")
auc = evaluator.evaluate(predictions)
print("Area under ROC curve: ", auc)

# 停止SparkSession
spark.stop()

运行脚本：

python spark_ml_example.py

9. 注意事项：

• 由于是单机伪分布式模式，资源有限，不适合处理大规模数据。
• 在开发过程中，可以通过Spark Web UI（http://localhost:8080）监控作业执行情况。
• 如果数据量不大，也可以使用本地模式运行Spark，而不启动集群。在代码中，将master设置为"local[*]"即可，这样会在本地使用所有核心运行。

10. 可能遇到的问题：

• 端口冲突：如果8080端口被占用，可以修改Spark master的端口，在spark-env.sh中设置SPARK_MASTER_WEBUI_PORT。
• 内存不足：根据你的机器调整Spark内存设置，可以在spark-env.sh中设置SPARK_DRIVER_MEMORY和SPARK_EXECUTOR_MEMORY。

11. 总结：

以上就是在Mac笔记本电脑上搭建Spark单机集群，并使用PySpark开发机器学习模型的完整过程。根据你的具体需求，可能还需要调整配置和代码。希望对你有所帮助！

---

---

我来为您详细讲解如何在Mac上搭建Spark集群并开发机器学习模型的完整流程。

一、环境准备与软件安装

1. 安装必要工具

# 1.1 安装Homebrew（如果尚未安装）
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# 1.2 安装Java 8/11/17（Spark 3.3+建议Java 11+）
brew install openjdk@11
echo 'export JAVA_HOME="/opt/homebrew/opt/openjdk@11"' >> ~/.zshrc
echo 'export PATH="$JAVA_HOME/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

# 1.3 安装Python和PySpark所需环境
brew install python@3.9
pip3 install --upgrade pip

2. 安装Spark

# 2.1 安装Spark（使用Homebrew）
brew install apache-spark

# 或者手动安装（推荐，便于控制版本）
# 从官网下载：https://spark.apache.org/downloads.html
cd ~/Downloads
curl -O https://dlcdn.apache.org/spark/spark-3.4.1/spark-3.4.1-bin-hadoop3.tgz
tar -xzf spark-3.4.1-bin-hadoop3.tgz
sudo mv spark-3.4.1-bin-hadoop3 /usr/local/spark

# 2.2 配置环境变量
echo '# Spark Configuration' >> ~/.zshrc
echo 'export SPARK_HOME="/usr/local/spark"' >> ~/.zshrc
echo 'export PYSPARK_PYTHON=python3' >> ~/.zshrc
echo 'export PYTHONPATH=$SPARK_HOME/python:$PYTHONPATH' >> ~/.zshrc
echo 'export PATH=$SPARK_HOME/bin:$PATH' >> ~/.zshrc
source ~/.zshrc

3. 安装Python依赖

# 3.1 创建虚拟环境
python3 -m venv ~/spark_env
source ~/spark_env/bin/activate

# 3.2 安装核心库
pip install pyspark==3.4.1
pip install jupyter notebook pandas numpy scikit-learn matplotlib seaborn
pip install findspark  # 帮助在Jupyter中导入PySpark

二、配置单机Spark集群（伪分布式）

1. 配置Spark

# 1.1 复制配置文件
cd $SPARK_HOME/conf
cp spark-env.sh.template spark-env.sh
cp workers.template workers

# 1.2 编辑spark-env.sh
echo 'export JAVA_HOME="$(/usr/libexec/java_home)"' >> spark-env.sh
echo 'export SPARK_MASTER_HOST=localhost' >> spark-env.sh
echo 'export SPARK_WORKER_CORES=4'  # 根据你的CPU核心数调整
echo 'export SPARK_WORKER_MEMORY=4g'  # 根据你的内存调整
echo 'export SPARK_DRIVER_MEMORY=2g' >> spark-env.sh
echo 'export SPARK_EXECUTOR_MEMORY=2g' >> spark-env.sh

# 1.3 编辑workers文件（单机伪集群，添加localhost）
echo "localhost" > workers

2. 启动Spark集群

# 2.1 启动Master节点
$SPARK_HOME/sbin/start-master.sh

# 2.2 启动Worker节点
$SPARK_HOME/sbin/start-worker.sh spark://localhost:7077

# 2.3 检查运行状态
# Master Web UI: http://localhost:8080
# 每个Worker的Web UI: http://localhost:8081

# 2.4 停止集群（完成后）
$SPARK_HOME/sbin/stop-worker.sh
$SPARK_HOME/sbin/stop-master.sh

三、开发环境设置

1. Jupyter Notebook配置

# 1.1 生成Jupyter配置
jupyter notebook --generate-config

# 1.2 创建启动脚本
mkdir -p ~/spark_projects
cd ~/spark_projects

# 创建启动文件：start_spark_notebook.sh
cat > start_spark_notebook.sh << 'EOF'
#!/bin/bash
source ~/spark_env/bin/activate

# 设置环境变量
export SPARK_HOME="/usr/local/spark"
export PYSPARK_PYTHON=python3
export PYSPARK_DRIVER_PYTHON=jupyter
export PYSPARK_DRIVER_PYTHON_OPTS="notebook --port=8889 --no-browser"

# 启动PySpark
pyspark --master spark://localhost:7077 \
        --driver-memory 2g \
        --executor-memory 2g \
        --total-executor-cores 4
EOF

chmod +x start_spark_notebook.sh

四、机器学习模型开发示例

1. 准备示例数据

# create_sample_data.py
import pandas as pd
import numpy as np

# 创建示例数据集
np.random.seed(42)
n_samples = 10000

data = {
    'age': np.random.randint(18, 70, n_samples),
    'income': np.random.normal(50000, 15000, n_samples),
    'education_years': np.random.randint(8, 20, n_samples),
    'experience': np.random.randint(0, 40, n_samples),
    'target': np.random.randint(0, 2, n_samples)  # 二分类目标
}

df = pd.DataFrame(data)
df.to_csv('sample_data.csv', index=False)
print("示例数据已创建: sample_data.csv")

2. 完整的PySpark ML管道示例

# ml_pipeline.py
from pyspark.sql import SparkSession
from pyspark.ml.feature import VectorAssembler, StandardScaler
from pyspark.ml.classification import LogisticRegression, RandomForestClassifier
from pyspark.ml.evaluation import BinaryClassificationEvaluator, MulticlassClassificationEvaluator
from pyspark.ml.tuning import ParamGridBuilder, CrossValidator
from pyspark.ml import Pipeline
import pandas as pd

# 1. 初始化Spark会话
spark = SparkSession.builder \
    .appName("SparkML-Example") \
    .master("spark://localhost:7077") \
    .config("spark.executor.memory", "2g") \
    .config("spark.driver.memory", "2g") \
    .getOrCreate()

print(f"Spark版本: {spark.version}")
print(f"应用名称: {spark.sparkContext.appName}")

# 2. 加载数据
df_pandas = pd.read_csv("sample_data.csv")
spark_df = spark.createDataFrame(df_pandas)

# 显示数据
print("数据概览:")
spark_df.show(5)
spark_df.printSchema()

# 3. 数据预处理
# 3.1 特征向量化
feature_columns = ['age', 'income', 'education_years', 'experience']
assembler = VectorAssembler(inputCols=feature_columns, outputCol="features")

# 3.2 数据标准化
scaler = StandardScaler(inputCol="features", outputCol="scaled_features",
                       withStd=True, withMean=True)

# 4. 划分训练集和测试集
(train_data, test_data) = spark_df.randomSplit([0.8, 0.2], seed=42)

print(f"训练集大小: {train_data.count()}")
print(f"测试集大小: {test_data.count()}")

# 5. 构建逻辑回归模型
lr = LogisticRegression(featuresCol="scaled_features", 
                        labelCol="target",
                        maxIter=10,
                        regParam=0.01)

# 6. 创建管道
pipeline_lr = Pipeline(stages=[assembler, scaler, lr])

# 7. 训练模型
print("训练逻辑回归模型...")
model_lr = pipeline_lr.fit(train_data)

# 8. 预测
predictions_lr = model_lr.transform(test_data)
predictions_lr.select("target", "prediction", "probability").show(10)

# 9. 模型评估
evaluator = BinaryClassificationEvaluator(labelCol="target")
auc_lr = evaluator.evaluate(predictions_lr)
print(f"逻辑回归 AUC: {auc_lr:.4f}")

# 10. 随机森林模型
rf = RandomForestClassifier(featuresCol="scaled_features",
                           labelCol="target",
                           numTrees=20,
                           maxDepth=5)

pipeline_rf = Pipeline(stages=[assembler, scaler, rf])

print("训练随机森林模型...")
model_rf = pipeline_rf.fit(train_data)

predictions_rf = model_rf.transform(test_data)
auc_rf = evaluator.evaluate(predictions_rf)
print(f"随机森林 AUC: {auc_rf:.4f}")

# 11. 模型调优示例（网格搜索）
print("开始模型调优...")
paramGrid = (ParamGridBuilder()
             .addGrid(lr.regParam, [0.01, 0.1, 0.5])
             .addGrid(lr.maxIter, [5, 10, 20])
             .build())

crossval = CrossValidator(estimator=pipeline_lr,
                         estimatorParamMaps=paramGrid,
                         evaluator=evaluator,
                         numFolds=3)

cv_model = crossval.fit(train_data)
print("最佳模型参数:")
print(cv_model.bestModel.stages[-1].extractParamMap())

# 12. 保存模型
print("保存模型...")
model_lr.write().overwrite().save("spark_lr_model")
model_rf.write().overwrite().save("spark_rf_model")

# 13. 模型比较
print("\n=== 模型性能比较 ===")
print(f"逻辑回归 AUC: {auc_lr:.4f}")
print(f"随机森林 AUC: {auc_rf:.4f}")

# 14. 特征重要性（随机森林）
rf_model = model_rf.stages[-1]
feature_importance = list(zip(feature_columns, rf_model.featureImportances))
print("\n特征重要性:")
for feature, importance in feature_importance:
    print(f"{feature}: {importance:.4f}")

# 15. 停止Spark会话
spark.stop()
print("任务完成！")

3. 实时预测示例

# realtime_prediction.py
from pyspark.sql import SparkSession
from pyspark.ml import PipelineModel

# 启动Spark
spark = SparkSession.builder \
    .appName("Realtime-Prediction") \
    .master("local[*]") \
    .getOrCreate()

# 加载保存的模型
loaded_model = PipelineModel.load("spark_lr_model")

# 模拟实时数据
new_data = [
    (35, 60000, 16, 10),
    (45, 80000, 18, 20),
    (28, 40000, 12, 5)
]

columns = ['age', 'income', 'education_years', 'experience']
new_df = spark.createDataFrame(new_data, columns)

# 预测
predictions = loaded_model.transform(new_df)
predictions.select("age", "income", "prediction", "probability").show()

spark.stop()

五、监控与优化

1. Spark UI监控

• Master UI: http://localhost:8080
• 应用UI: http://localhost:4040 (运行应用时自动开启)

2. 性能优化配置

# spark_optimized_config.py
from pyspark.sql import SparkSession

spark = SparkSession.builder \
    .appName("Optimized-ML") \
    .master("spark://localhost:7077") \
    .config("spark.executor.memory", "4g") \
    .config("spark.driver.memory", "2g") \
    .config("spark.executor.cores", "2") \
    .config("spark.default.parallelism", "8") \
    .config("spark.sql.shuffle.partitions", "8") \
    .config("spark.serializer", "org.apache.spark.serializer.KryoSerializer") \
    .config("spark.kryoserializer.buffer.max", "256m") \
    .getOrCreate()

六、自动化脚本

1. 一键启动脚本

#!/bin/bash
# start_all.sh

echo "1. 启动Spark集群..."
$SPARK_HOME/sbin/start-master.sh
sleep 3
$SPARK_HOME/sbin/start-worker.sh spark://localhost:7077

echo "2. 激活Python环境..."
source ~/spark_env/bin/activate

echo "3. 启动Jupyter Notebook..."
cd ~/spark_projects
jupyter notebook --port=8889 --no-browser --ip=0.0.0.0 &
sleep 5

echo "4. 打开Web UI..."
echo "Spark Master: http://localhost:8080"
echo "Jupyter: http://localhost:8889"

2. 清理脚本

#!/bin/bash
# cleanup.sh

echo "停止Spark集群..."
$SPARK_HOME/sbin/stop-worker.sh
$SPARK_HOME/sbin/stop-master.sh

echo "停止Jupyter..."
pkill -f jupyter

echo "清理完成！"

七、故障排除

常见问题及解决方案：

1. Java版本问题：

# 检查Java版本
java -version
# 如果版本不对，重新链接
sudo ln -sfn /opt/homebrew/opt/openjdk@11/libexec/openjdk.jdk /Library/Java/JavaVirtualMachines/openjdk-11.jdk

2. 端口冲突：

# 修改Spark端口
export SPARK_MASTER_WEBUI_PORT=9080
export SPARK_WORKER_WEBUI_PORT=9081

3. 内存不足：

# 调整配置
export SPARK_WORKER_MEMORY=2g
export SPARK_DRIVER_MEMORY=1g

八、项目结构建议

spark_projects/
├── data/              # 数据集
│   ├── raw/          # 原始数据
│   ├── processed/    # 处理后的数据
│   └── sample.csv    # 示例数据
├── notebooks/         # Jupyter notebooks
│   ├── 01_data_exploration.ipynb
│   ├── 02_feature_engineering.ipynb
│   └── 03_model_training.ipynb
├── src/               # 源代码
│   ├── data_preprocessing.py
│   ├── feature_engineering.py
│   └── model_training.py
├── models/            # 保存的模型
├── config/           # 配置文件
├── requirements.txt   # Python依赖
└── README.md         # 项目说明

总结步骤：

1. ✅ 安装Java、Python、Spark
2. ✅ 配置Spark伪分布式集群
3. ✅ 设置Python虚拟环境和依赖
4. ✅ 启动Spark Master和Worker
5. ✅ 使用Jupyter或Python脚本开发
6. ✅ 实现ML管道：数据加载 → 预处理 → 训练 → 评估 → 部署

这个方案在单机Mac上模拟了完整的Spark集群环境，虽然受限于单机资源，但可以完整学习Spark ML的整个工作流程。对于生产环境，建议使用多节点集群或云服务（如Databricks、AWS EMR）。