并行
集群计算。
并行计算。
并发
并发执行。
Spark
Lightning-fast cluster computing。
快如闪电的集群计算。
大规模快速通用的计算引擎。
速度: 比hadoop 100x,磁盘计算快10x
使用: java / Scala /R /python
提供80+算子(操作符),容易构建并行应用。
通用: 组合SQL ,流计算 + 复杂分析。
运行: Hadoop, Mesos, standalone, or in the cloud,local.
Spark模块
Spark core //核心模块
Spark SQL //SQL
Spark Streaming //流计算
Spark MLlib //机器学习
Spark graph //图计算
DAG //direct acycle graph,有向无环图。
安装Spark
1.下载spark-2.1.0-bin-hadoop2.7.tgz
..
2.解压
..
3.环境变量
[/etc/profile]
SPARK_HOME=/soft/spark
PATH=$PATH:$SPARK_HOME/bin:$SPARK_HOME/sbin
[source]
$>source /etc/profile
4.验证spark
$>cd /soft/spark
$>./spark-shell
5.webui
http://s201:4040/
体验spark
0.sc
SparkContext,Spark程序的入口点,封装了整个spark运行环境的信息。
1.进入spark-shell
$>spark-shell
$scala>sc
API
[SparkContext]
Spark程序的入口点,封装了整个spark运行环境的信息。
[RDD]
resilient distributed dataset,弹性分布式数据集。等价于集合。
spark实现word count
//加载文本文件,以换行符方式切割文本.Array(hello world2,hello world2 ,...)
val rdd1 = sc.textFile("/home/centos/test.txt");
//单词统计1
$scala>val rdd1 = sc.textFile("/home/centos/test.txt")
$scala>val rdd2 = rdd1.flatMap(line=>line.split(" "))
$scala>val rdd3 = rdd2.map(word = > (word,1))
$scala>val rdd4 = rdd3.reduceByKey(_ + _)
$scala>rdd4.collect
//单词统计2
sc.textFile("/home/centos/test.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_ + _).collect
//统计所有含有wor字样到单词个数。filter
//过滤单词
sc.textFile("/home/centos/test.txt").flatMap(_.split(" ")).filter(_.contains("wor")).map((_,1)).reduceByKey(_ + _).collect
[API]
SparkContext:
Spark功能的主要入口点。代表到Spark集群的连接,可以创建RDD、累加器和广播变量.
每个JVM只能激活一个SparkContext对象,在创建sc之前需要stop掉active的sc。
SparkConf:
spark配置对象,设置Spark应用各种参数,kv形式。
编写scala程序,引入spark类库,完成wordcount
1.创建Scala模块,并添加pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.it18zhang</groupId>
<artifactId>SparkDemo1</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.11</artifactId>
<version>2.1.0</version>
</dependency>
</dependencies>
</project>
2.编写scala文件
import org.apache.spark.{SparkConf, SparkContext}
/**
* Created by Administrator on 2017/4/20.
*/
object WordCountDemo {
def main(args: Array[String]): Unit = {
//创建Spark配置对象
val conf = new SparkConf();
conf.setAppName("WordCountSpark")
//设置master属性
conf.setMaster("local") ;
//通过conf创建sc
val sc = new SparkContext(conf);
//加载文本文件
val rdd1 = sc.textFile("d:/scala/test.txt");
//压扁
val rdd2 = rdd1.flatMap(line => line.split(" ")) ;
//映射w => (w,1)
val rdd3 = rdd2.map((_,1))
val rdd4 = rdd3.reduceByKey(_ + _)
val r = rdd4.collect()
r.foreach(println)
}
}
java版单词统计
import org.apache.spark.SparkConf;
import org.apache.spark.SparkContext;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import scala.Tuple2;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* java版
*/
public class WordCountJava2 {
public static void main(String[] args) {
//创建SparkConf对象
SparkConf conf = new SparkConf();
conf.setAppName("WordCountJava2");
conf.setMaster("local");
//创建java sc
JavaSparkContext sc = new JavaSparkContext(conf);
//加载文本文件
JavaRDD<String> rdd1 = sc.textFile("d:/scala//test.txt");
//压扁
JavaRDD<String> rdd2 = rdd1.flatMap(new FlatMapFunction<String, String>() {
public Iterator<String> call(String s) throws Exception {
List<String> list = new ArrayList<String>();
String[] arr = s.split(" ");
for(String ss :arr){
list.add(ss);
}
return list.iterator();
}
});
//映射,word -> (word,1)
JavaPairRDD<String,Integer> rdd3 = rdd2.mapToPair(new PairFunction<String, String, Integer>() {
public Tuple2<String, Integer> call(String s) throws Exception {
return new Tuple2<String, Integer>(s,1);
}
});
//reduce化简
JavaPairRDD<String,Integer> rdd4 = rdd3.reduceByKey(new Function2<Integer, Integer, Integer>() {
public Integer call(Integer v1, Integer v2) throws Exception {
return v1 + v2;
}
});
//
List<Tuple2<String,Integer>> list = rdd4.collect();
for(Tuple2<String, Integer> t : list){
System.out.println(t._1() + " : " + t._2());
}
}
}
Spark2.1.0最新版是基于Scala2.11.8版本,因此安装scala2.11.8版本,
否则如果基于2.12.0版本编译会出现找不到包的问题。
1.卸载原来的scala.
2.重新安装scala2.11.8版本
3.配置idea的全局库
project settings -> global library -> 删除原来的scala sdk
project settings -> global library -> 添加sdk -> browser -> 定位scala安装目录 ->选中scala-compiler.jar +
scala-library.jar +
scala-reflect.jar
4.在模块中添加scala sdk 2.11.8版本
5.重新编译项目 -> 导入jar ->丢到集群运行。
提交作业到spark集群运行
1.导出jar包
2.spark-submit提交命令运行job
//Scala版本
$>spark-submit --master local --name MyWordCount --class com.it18zhang.spark.scala.WordCountScala SparkDemo1-1.0-SNAPSHOT.jar /home/centos/test.txt
//java版
$>spark-submit --master local --name MyWordCount --class com.it18zhang.spark.java.WordCountJava SparkDemo1-1.0-SNAPSHOT.jar /home/centos/test.txt
Spark集群模式
1.local
nothing!
spark-shell --master local; //默认
2.standalone
独立。
a)复制spark目录到其他主机
b)配置其他主机的所有环境变量
[/etc/profile]
SPARK_HOME
PATH
c)配置master节点的slaves
[/soft/spark/conf/slaves]
s202
s203
s204
d)启动spark集群
/soft/spark/sbin/start-all.sh
e)查看进程
$>xcall.jps jps
master //s201
worker //s202
worker //s203
worker //s204
e)webui
http://s201:8080/
提交作业jar到完全分布式spark集群
1.需要启动hadoop集群(只需要hdfs)
$>start-dfs.sh
2.put文件到hdfs.
3.运行spark-submit
$>spark-submit --master spark://s201:7077 --name MyWordCount --class com.it18zhang.spark.scala.WordCountScala Spark-1.0-SNAPSHOT.jar hdfs://s201:8020/user/centos/test.txt
脚本分析
[start-all.sh]
sbin/spark-config.sh
sbin/spark-master.sh //启动master进程
sbin/spark-slaves.sh //启动worker进程
[start-master.sh]
sbin/spark-config.sh
org.apache.spark.deploy.master.Master
spark-daemon.sh start org.apache.spark.deploy.master.Master --host --port --webui-port ...
[spark-slaves.sh]
sbin/spark-config.sh
slaves.sh //conf/slaves
[slaves.sh]
for conf/slaves{
ssh host start-slave.sh ...
}
[start-slave.sh]
CLASS="org.apache.spark.deploy.worker.Worker"
sbin/spark-config.sh
for (( .. )) ; do
start_instance $(( 1 + $i )) "$@"
done
$>cd /soft/spark/sbin
$>./stop-all.sh //停掉整个spark集群.
$>./start-master.sh //停掉整个spark集群.
$>./start-master.sh //启动master节点
$>./start-slaves.sh //启动所有worker节点
Spark
通用性。
Spark模块
Spark Core //核心库
Spark SQL //SQL
Spark Streaming //准实时计算。
Spark MLlib //机器学习库
Spark graph //图计算
Spark集群运行
1.local //本地模式
2.standalone //独立模式
3.yarn //yarn模式
4.mesos //mesos
start-all.sh
start-master.sh //RPC端口 7077
start-slave.sh spark://s201:7077
webui
http://s201:8080
添加针对scala文件的编译插件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.it18zhang</groupId>
<artifactId>SparkDemo1</artifactId>
<version>1.0-SNAPSHOT</version>
<build>
<sourceDirectory>src/main/java</sourceDirectory>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>net.alchim31.maven</groupId>
<artifactId>scala-maven-plugin</artifactId>
<version>3.2.2</version>
<configuration>
<recompileMode>incremental</recompileMode>
</configuration>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>testCompile</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.11</artifactId>
<version>2.1.0</version>
</dependency>
</dependencies>
</project>
C:\Users\Administrator.m2\repository\net
C:\Users\Administrator.m2\repository\net\alchim31\maven…
SparkContext:
Spark集群的连接。主要入口点。
SparkConf = new ();
conf.setApp("")
conf.setMaster("local") ;
sc = new SparkContext(conf);
//RDD : Resilient distributed dataset,弹性分布式数据集。
val rdd1 = sc.textFile("d:/scala/test.txt");
val rdd2 = rdd1.flatMap(line=>line.split(" "));
val rdd3 = rdd2.map(word=>(word,1));
val rdd4 = rdd3.reduceByKey(_ + _) ;
val list = rdd4.collect()
list.foreach(e=>println(e));
//
sc.textFile("d:/scala").flatMap(_.split(" ")).map((_1)).reduceByKey(_ + _).collect().foreach(println)
spark
基于hadoop的mr,扩展MR模型高效使用MR模型,内存型集群计算,提高app处理速度。
spark特点
速度:在内存中存储中间结果。
支持多种语言.
内置了80+的算子.
高级分析:MR,SQL/ Streamming /mllib / graph
spark模块
core //通用执行引擎,提供内存计算和对外部数据集的引用。
SQL //构建在core之上,引入新的抽象SchemaRDD,提供了结构化和半结构化支持。
Streaming //小批量计算,RDD.
MLlib //机器学习库。core在。
Graphx //图计算。
RDD:
是spark的基本数据结构,是不可变数据集。RDD中的数据集进行逻辑分区,每个分区可以单独在集群节点
进行计算。可以包含任何java,scala,python和自定义类型。
RDD是只读的记录分区集合。RDD具有容错机制。
创建RDD方式,一、并行化一个现有集合。
hadoop 花费90%时间用户rw。、
内存处理计算。在job间进行数据共享。内存的IO速率高于网络和disk的10 ~ 100之间。
内部包含5个主要属性
-----------------------
1.分区列表
2.针对每个split的计算函数。
3.对其他rdd的依赖列表
4.可选,如果是KeyValueRDD的话,可以带分区类。
5.可选,首选块位置列表(hdfs block location);
//默认并发度
local.backend.defaultParallelism() = scheduler.conf.getInt(“spark.default.parallelism”, totalCores)
taskScheduler.defaultParallelism = backend.defaultParallelism()
sc.defaultParallelism =…; taskScheduler.defaultParallelism
defaultMinPartitions = math.min(defaultParallelism, 2)
sc.textFile(path,defaultMinPartitions) //1,2
RDD变换
返回指向新rdd的指针,在rdd之间创建依赖关系。每个rdd都有计算函数和指向父RDD的指针。
map() //对每个元素进行变换,应用变换函数
//(T)=>V
filter() //过滤器,(T)=>Boolean
flatMap() //压扁,T => TraversableOnce[U]
mapPartitions() //对每个分区进行应用变换,输入的Iterator,返回新的迭代器,可以对分区进行函数处理。
//Iterator<T> => Iterator<U>
mapPartitionsWithIndex(func) //同上,(Int, Iterator<T>) => Iterator<U>
sample(withReplacement, fraction, seed) //采样返回采样的RDD子集。
//withReplacement 元素是否可以多次采样.
//fraction : 期望采样数量.[0,1]
union() //类似于mysql union操作。
//select * from persons where id < 10
//union select * from id persons where id > 29 ;
intersection //交集,提取两个rdd中都含有的元素。
distinct([numTasks])) //去重,去除重复的元素。
groupByKey() //(K,V) => (K,Iterable<V>)
reduceByKey(*) //按key聚合。
aggregateByKey(zeroValue)(seqOp, combOp, [numTasks])
//按照key进行聚合
key:String U:Int = 0
sortByKey //排序
join(otherDataset, [numTasks]) //连接,(K,V).join(K,W) =>(K,(V,W))
cogroup //协分组
//(K,V).cogroup(K,W) =>(K,(Iterable<V>,Iterable<!-- <W> -->))
cartesian(otherDataset) //笛卡尔积,RR[T] RDD[U] => RDD[(T,U)]
pipe //将rdd的元素传递给脚本或者命令,执行结果返回形成新的RDD
coalesce(numPartitions) //减少分区
repartition //可增可减
repartitionAndSortWithinPartitions(partitioner)
//再分区并在分区内进行排序
RDD Action
collect() //收集rdd元素形成数组.
count() //统计rdd元素的个数
reduce() //聚合,返回一个值。
first //取出第一个元素take(1)
take //
takeSample (withReplacement,num, [seed])
takeOrdered(n, [ordering])
saveAsTextFile(path) //保存到文件
saveAsSequenceFile(path) //保存成序列文件
saveAsObjectFile(path) (Java and Scala)
countByKey() //按照key,统计每个key下value的个数.
spark集成hadoop ha
1.复制core-site.xml + hdfs-site.xml到spark/conf目录下
2.分发文件到spark所有work节点
3.启动spark集群
4.启动spark-shell,连接spark集群上
$>spark-shell --master spark://s201:7077
$scala>sc.textFile("hdfs://mycluster/user/centos/test.txt").collect();