spark学习基础篇1--spark概述与入门

最新推荐文章于 2023-05-01 17:33:35 发布

fan_bigdata

最新推荐文章于 2023-05-01 17:33:35 发布

阅读量470

点赞数

分类专栏： spark 文章标签： spark学习基础篇 spark概述与入门

本文链接：https://blog.csdn.net/fan_bigdata/article/details/103108978

版权

spark 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

spark总结
一: spark 概述
1. Spark 是分布式内存计算框架
Apache Spark 是一个快速的, 多用途的集群计算系统, 相对于 Hadoop MapReduce 将中间结果保存在磁盘中,
Spark 使用了内存保存中间结果, 能在数据尚未写入硬盘时在内存中进行运算.
1. Spark是Apache的开源框架
2. Spark的母公司叫做 Databricks
3. Spark 是为了解决 MapReduce 等过去的计算系统无法在内存中保存中间结果的问题
4. Spark 的核心是 RDDs, RDDs 不仅是一种计算框架, 也是一种数据结构

二: Spark的特点
1. 速度快
spark为什么比hadoop要快?
1. mapreduce的计算结果保存在HDFS中,而spark的数据首先是保存在内存中,内存不够后才保存在磁盘中(从内存读取数据比从磁盘/HDFS中速度更快)
2. mapreduce的task是进程级别的,spark的task是线程级别的.
2. 易用
Spark 支持 Java, Scala, Python, R, SQL 等多种语言的API.
3. 通用
Spark 提供一个完整的技术栈, 包括 SQL执行, Dataset命令式API, 机器学习库MLlib,
图计算框架GraphX, 流计算SparkStreaming等
4. 兼容
Spark 可以运行在 Hadoop Yarn, Apache Mesos, Kubernets, Spark Standalone等集群中
Spark 可以访问 HBase, HDFS, Hive, Cassandra 在内的多种数据库
总结:
1. 支持Java,Scala,Python 和R的API
2. 可扩展超过8K个节点
3. 能够在内存中缓存数据集,以实现交互式数据分析
4. 提供命令行窗口,减少探索式的数据分析的反应时间

三: Spark 的组件
1. Spark-Core 和弹性分布式数据集(RDDs)
Spark 最核心的功能是 RDDs, RDDs 存在于 spark-core 这个包内, 这个包也是 Spark 最核心的包.
Spark-Core 是整个 Spark 的基础, 提供了分布式任务调度和基本的 I/O 功能
Spark 的基础的程序抽象是弹性分布式数据集(RDDs), 是一个可以并行操作, 有容错的数据集合
2. Sprk SQL
Spark SQL 在 spark-core 基础之上带出了一个名为 DataSet 和 DataFrame 的数据抽象化的概念
Spark SQL 提供了在 Dataset 和 DataFrame 之上执行 SQL 的能力
Spark SQL 提供了 DSL, 可以通过 Scala, Java, Python 等语言操作 DataSet 和 DataFrame
它还支持使用 JDBC/ODBC 服务器操作 SQL 语言
3. Spark Streaming
Spark Streaming 充分利用 spark-core 的快速调度能力来运行流分析
它截取小批量的数据并可以对之运行 RDD Transformation(按照时间切分数据)
4. MLlib
MLlib 是 Spark 上分布式机器学习的框架. Spark分布式内存的架构比 Hadoop磁盘式的 Apache Mahout 快上 10 倍, 扩展性也非常优良
MLlib 可以使用许多常见的机器学习和统计算法, 简化大规模机器学习
汇总统计, 相关性, 分层抽样, 假设检定, 随即数据生成
支持向量机, 回归, 线性回归, 逻辑回归, 决策树, 朴素贝叶斯
协同过滤, ALS
K-means
SVD奇异值分解, PCA主成分分析
TF-IDF, Word2Vec, StandardScaler
SGD随机梯度下降, L-BFGS
5. Graphx
GraphX 是分布式图计算框架, 提供了一组可以表达图计算的 API, GraphX 还对这种抽象化提供了优化运行

四: Spark集群结构
1. spark集群结构
1. Master
负责集群管理，资源分配
2. Workder
任务执行节点
executor:进程，用来执行任务的进程
task:要执行的任务
3. Driver
1. 运行main方法
2. 创建SparkContext对象。SparkContext是spark程序的入口，负责任务的切分以及任务的调度
运行一个 Spark 程序大致经历如下几个步骤
1. 启动 Drive, 创建 SparkContext
2. Client 提交程序给 Drive, Drive 向 Cluster Manager 申请集群资源
3. 资源申请完毕, 在 Worker 中启动 Executor
4. Driver 将程序转化为 Tasks, 分发给 Executor 执行
spark可以使用如下几个集群管理工具:
1. Spark Standalone
2. Hadoop Yarn
3. Apache Mesos
4. Kubernets
常用的是:2,3,4
2. Driver 和 Worker 什么时候被启动?
1. 在Standalone集群模式中,
Worker在集群启动的时候就会启动
Driver启动的分为两种模式:
1. 在Client模式下时, Driver 运行在 Client 端, 在 Client 启动的时候被启动.
2. 在 Cluster 模式下, Driver 运行在某个 Worker中,任务提交的时候启动,任务结束时,Driver消失
2. 在 spark on yarn 模式下
1、Worker相当于不存在，executor启动在nodemanager上的container
2、Driver是在任务提交的时候才会启动，任务结束，Driver消失
spark on yarn中client与Cluster的区别？
client模式的时候Driver在client端，client端不能够关闭。关闭之后Driver消失，不能进行任务的切分和调度，导致spark任务失败
cluster模式的时候Driver在AppMaster所处的位置,client端可以关闭

五: 集群搭建(个人搭建,公司搭建使用CDH)
准备工作: 分配好资源
步骤1 下载和解压
下载 Spark 安装包, 下载时候选择对应的 Hadoop 版本(避免版本不兼容问题)
下载地址 https://archive.apache.org/dist/spark/spark-2.2.0/spark-2.2.0-bin-hadoop2.7.tgz
上传/解压到指定目录
tar xzvf spark-2.2.0-bin-hadoop2.7.tgz -C /export/servers

步骤2 修改配置文件 spark-env.sh
cd /export/servers/spark/conf
vim spark-env.sh
(增加如下内容)
# 指定 Java Home
export JAVA_HOME=/export/servers/jdk1.8.0
# 指定 Spark Master 地址
export SPARK_MASTER_HOST=node01
export SPARK_MASTER_PORT=7077

步骤3 修改配置文件 slaves, 以指定从节点为止, 从在使用 sbin/start-all.sh 启动集群的时候,
可以一键启动整个集群所有的 Worker
进入配置目录, 并复制一份新的配置文件, 以供在此基础之上进行修改
cd /export/servers/spark/conf
cp slaves.template slaves
vi slave
配置所有从节点的地址
node02
node03
…

步骤4 配置 HistoryServer
默认情况下, Spark 程序运行完毕后, 就无法再查看运行记录的 Web UI 了, 通过 HistoryServer
可以提供一个服务, 通过读取日志文件, 使得我们可以在程序运行结束后, 依然能够查看运行过程
1. 复制 spark-defaults.conf, 以供修改
2. 将以下内容复制到spark-defaults.conf末尾处, 通过这段配置, 可以指定 Spark 将日志输入到 HDFS 中
spark.eventLog.enabled true
spark.eventLog.dir hdfs://node01:8020/spark_log
spark.eventLog.compress true
3. 将以下内容复制到spark-env.sh的末尾, 配置 HistoryServer 启动参数,
使得 HistoryServer 在启动的时候读取 HDFS 中写入的 Spark 日志
指定 Spark History 运行参数
export SPARK_HISTORY_OPTS="-Dspark.history.ui.port=4000 -Dspark.history.retainedApplications=3 -Dspark.history.fs.logDirectory=hdfs://node01:8020/spark_log"
4. 为 Spark 创建 HDFS 中的日志目录
hdfs dfs -mkdir -p /spark_log

步骤5 分发和运行
将 Spark 安装包分发给集群中其它机器
启动 Spark Master 和 Slaves, 以及 HistoryServer
cd /export/servers/spark
sbin/start-all.sh
sbin/start-history-server.sh

spark集群高可用搭建
在上述的基础上
步骤1 spark-env.sh, 添加 Spark 启动参数, 并去掉 SPARK_MASTER_HOST 地址
# 指定 Java Home
export JAVA_HOME=/export/servers/jdk1.8.0_141
# 指定 Spark Master 地址
# export SPARK_MASTER_HOST=node01
export SPARK_MASTER_PORT=7077
# 指定 Spark History 运行参数
export SPARK_HISTORY_OPTS="-Dspark.history.ui.port=4000 -Dspark.history.retainedApplications=3 -Dspark.history.fs.logDirectory=hdfs://node01:8020/spark_log"
# 指定 Spark 运行时参数
export SPARK_DAEMON_JAVA_OPTS="-Dspark.deploy.recoveryMode=ZOOKEEPER -Dspark.deploy.zookeeper.url=node01:2181,node02:2181,node03:2181 … -Dspark.deploy.zookeeper.dir=/spark"

步骤2 分发配置文件到整个集群
步骤3 启动集群
在 node01 上启动整个集群
在 node02 上单独再启动一个 Master
步骤4 查看 node01 master 和 node02 master 的 WebUI

Spark各服务端口
Master WebUI -> node01:8080
Worker WebUI -> node01:8081
History Server -> node01:4000

六: 应用运行示例
步骤1 进入 Spark 安装目录中(或者配置环境变量可省去)
cd /export/servers/spark/
步骤2 运行 Spark 示例任务
bin/spark-submit
–class org.apache.spark.examples.SparkPi
–master spark://node01:7077,node02:7077 \ (根据开启的master来写)
–executor-memory 1G
–total-executor-cores 2
/export/servers/spark/examples/jars/spark-examples_2.11-2.2.3.jar
100
步骤3 运行结果
Pi is roughly 3.141550671141551

七: Spark 入门案例
编写 Spark 程序的两种常见方式
spark-shell
spark-submit
1. Spark shell 的方式编写 WordCount
第一步创建maven工程增加 Scala支持
第二步编写 Maven 配置文件 pom.xml(配置依赖,复制)

		<properties>
			<scala.version>2.11.8</scala.version>
			<spark.version>2.2.0</spark.version>
			<slf4j.version>1.7.16</slf4j.version>
			<log4j.version>1.2.17</log4j.version>
		</properties>
		<dependencies>
			<dependency>
				<groupId>org.scala-lang</groupId>
				<artifactId>scala-library</artifactId>
				<version>${scala.version}</version>
			</dependency>
			<dependency>
				<groupId>org.apache.spark</groupId>
				<artifactId>spark-core_2.11</artifactId>
				<version>${spark.version}</version>
			</dependency>
			<dependency>
				<groupId>org.apache.hadoop</groupId>
				<artifactId>hadoop-client</artifactId>
				<version>2.6.0</version>
			</dependency>
			<dependency>
				<groupId>org.slf4j</groupId>
				<artifactId>jcl-over-slf4j</artifactId>
				<version>${slf4j.version}</version>
			</dependency>
			<dependency>
				<groupId>org.slf4j</groupId>
				<artifactId>slf4j-api</artifactId>
				<version>${slf4j.version}</version>
			</dependency>
			<dependency>
				<groupId>org.slf4j</groupId>
				<artifactId>slf4j-log4j12</artifactId>
				<version>${slf4j.version}</version>
			</dependency>
			<dependency>
				<groupId>log4j</groupId>
				<artifactId>log4j</artifactId>
				<version>${log4j.version}</version>
			</dependency>
			<dependency>
				<groupId>junit</groupId>
				<artifactId>junit</artifactId>
				<version>4.10</version>
				<scope>provided</scope>
			</dependency>
		</dependencies>

		<build>
			<sourceDirectory>src/main/scala</sourceDirectory>
			<testSourceDirectory>src/test/scala</testSourceDirectory>
			<plugins>

				<plugin>
					<groupId>org.apache.maven.plugins</groupId>
					<artifactId>maven-compiler-plugin</artifactId>
					<version>3.0</version>
					<configuration>
						<source>1.8</source>
						<target>1.8</target>
						<encoding>UTF-8</encoding>
					</configuration>
				</plugin>

				<plugin>
					<groupId>net.alchim31.maven</groupId>
					<artifactId>scala-maven-plugin</artifactId>
					<version>3.2.0</version>
					<executions>
						<execution>
							<goals>
								<goal>compile</goal>
								<goal>testCompile</goal>
							</goals>
							<configuration>
								<args>
									<arg>-dependencyfile</arg>
									<arg>${project.build.directory}/.scala_dependencies</arg>
								</args>
							</configuration>
						</execution>
					</executions>
				</plugin>

				<plugin>
					<groupId>org.apache.maven.plugins</groupId>
					<artifactId>maven-shade-plugin</artifactId>
					<version>3.1.1</version>
					<executions>
						<execution>
							<phase>package</phase>
							<goals>
								<goal>shade</goal>
							</goals>
							<configuration>
								<filters>
									<filter>
										<artifact>*:*</artifact>
										<excludes>
											<exclude>META-INF/*.SF</exclude>
											<exclude>META-INF/*.DSA</exclude>
											<exclude>META-INF/*.RSA</exclude>
										</excludes>
									</filter>
								</filters>
								<transformers>
									<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
										<mainClass></mainClass>
									</transformer>
								</transformers>
							</configuration>
						</execution>
					</executions>
				</plugin>
			</plugins>
		</build>
		
	因为在 pom.xml 中指定了 Scala 的代码目录, 所以创建目录 src/main/scala 和目录 src/test/scala

第三步: 编写代码

			object WordCounts {
			  def main(args: Array[String]): Unit = {
				// 1. 创建 Spark Context
				val conf = new SparkConf().setMaster("local[2]")
				val sc: SparkContext = new SparkContext(conf)
				// 2. 读取文件并计算词频
				val source: RDD[String] = sc.textFile("hdfs://node01:8020/dataset/wordcount.txt", 2)
				val words: RDD[String] = source.flatMap { line => line.split(" ") }
				val wordsTuple: RDD[(String, Int)] = words.map { word => (word, 1) }
				val wordsCount: RDD[(String, Int)] = wordsTuple.reduceByKey { (x, y) => x + y }
				// 3. 查看执行结果
				println(wordsCount.collect)
			  }
			}

第四步: 运行
spark 独立应用大致有两种方式, 一种是直接在 IDEA 中调试,
另一种是可以在提交至 Spark 集群中运行, 而 Spark 又支持多种集群, 不同的集群有不同的运行方式

spark-submit 集群运行方式的参数说明
bin/spark-submit
–class
–master
–deploy-mode
–conf =
… # other options

[application-arguments]
1) --class : 指定运行的主类[带有main方法object]
2) --master : 指定资源管理器的位置 standalone:spark://node01:7077:7077,node02, yarn:yarn
3) --deploy-mode : 指定运行模式<client/cluster>
4) --executor-core : 指定每个executor的CPU核数<只用于spark on yarn>
5) --executor-memory : 指定每个executor的内存大小
6) --num-executor : 指定executor的个数<只用于spark on yarn>
7) --driver-memory : 指定 Driver的内存大小
8) --queue :指定队列
9) --total-executor-cores 指定executor的总CPU核数<用于standalone或者spark on mesos模式>

spark-shell
1、启动方式: spark-shell --master <local[num]/yarn/spark://node01:7077>
2、spark-shell中已经自动创建了sparkcontext，赋值为sc
读取HDFS文件
1、读取方式:
1、sc.textFile(“hdfs://node01:8020/…”)
2、sc.textFile(“hdfs:///user/”) [必须在配置文件中配置HADOOP配置文件的路径]
3、sc.textFile("/user/hdfs/…") [必须在配置文件中配置HADOOP配置文件的路径]

fan_bigdata

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spark学习基础篇1--spark概述与入门

spark总结一: spark 概述1. Spark 是分布式内存计算框架Apache Spark 是一个快速的, 多用途的集群计算系统, 相对于 Hadoop MapReduce 将中间结果保存在磁盘中, Spark 使用了内存保存中间结果, 能在数据尚未写入硬盘时在内存中进行运算.1. Spark是Apache的开源框架2. Spark的母公司叫做 Databricks3....
复制链接

扫一扫