spark1

?spark

Apache Saprk is anopen source cluster computing system that aims to make data analytics fast – both fast to run and fast to write.

• 处理含量数据
• 处理速度快
• 通用 MLlib， sql，stream ， graghx

BDAS

hadoop spark对比

回顾hadoop

两个阶段map,reduce
参考网址

hadoop慢

额外的赋值,序列化和磁盘IO开销

spark块?

把硬盘换成了内存,速度快,1, 内存便宜 2, 大数据并不是真正的大, 适合spark这种内存计算
3. DAG有向无环图 可以对任务进行有效的分配

sparkAPI

scala
python
java

那些模式可以运行spark

• local(测试)
• Stanalone
• Mesos
• YARN

RDD

1. Resilient Distributed Dataset 弹性数据集
   
   • A list of partitions 分片
   • A funciton for computing each split 每个分区
   • A list of dependencies on other RDDs 依赖 rddb依赖rdda
   • Optionally, a Partitioner for key-value RDDs (e.g. to say that the
     RDD is hash-partitioned)
   • Optionally, a list of preferred locations to compute each split on
     (e.g. block locations for an HDFS file) 本地运行

流程

RDD可以从集合直接转换⽽来，也可以由从现存的任何HadoopInputFormat⽽来,亦或者HBase等

first demo

lines = sc.textFile(“hdfs://...”) //加载进来成为RDDerrors = lines.filter(_.startsWith(“ERROR”))errors.persist()//transformation 现在不执行action才执行Mysql_errors = errors.filter(_.contains(“MySQL”)).count//缓存RDDhttp_errors = errors.filter(_.contains(“Http”)).count//action

缓存策略

class StorageLevel private(private var useDisk_ : Boolean,private var useMemory_ : Boolean,private var deserialized_ : Boolean,private var replication_ : Int = 1)val NONE = new StorageLevel(false, false, false)val DISK_ONLY = new StorageLevel(true, false, false)val DISK_ONLY_2 = new StorageLevel(true, false, false, 2)val MEMORY_ONLY = new StorageLevel(false, true, true) //默认 存在缓存 反序列化 备份1份val MEMORY_ONLY_2 = new StorageLevel(false, true, true, 2)val MEMORY_ONLY_SER = new StorageLevel(false, true, false)val MEMORY_ONLY_SER_2 = new StorageLevel(false, true, false, 2)val MEMORY_AND_DISK = new StorageLevel(true, true, true)val MEMORY_AND_DISK_2 = new StorageLevel(true, true, true, 2)val MEMORY_AND_DISK_SER = new StorageLevel(true, true, false)val MEMORY_AND_DISK_SER_2 = new StorageLevel(true, true, false, 2)

transformation && action!

参考网址

简介：
1，transformation是得到一个新的RDD，方式很多，比如从数据源生成一个新的RDD，从RDD生成一个新的RDD
2，action是得到一个值，或者一个结果（直接将RDDcache到内存中）
所有的transformation都是采用的懒策略，就是如果只是将transformation提交是不会执行计算的，计算只有在action被提交的时候才被触发。

transformation操作：

1. map(func):对调用map的RDD数据集中的每个element都使用func，然后返回一个新的RDD,这个返回的数据集是分布式的数据集

2. filter(func): 对调用filter的RDD数据集中的每个元素都使用func，然后返回一个包含使func为true的元素构成的RDD

3. flatMap(func):和map差不多，但是flatMap生成的是多个结果
4. mapPartitions(func):和map很像，但是map是每个element，而mapPartitions是每个partition
5. mapPartitionsWithSplit(func):和mapPartitions很像，但是func作用的是其中一个split上，所以func中应该有index
6. sample(withReplacement,faction,seed):抽样
7. union(otherDataset)：返回一个新的dataset，包含源dataset和给定dataset的元素的集合
8. distinct([numTasks]):返回一个新的dataset，这个dataset含有的是源dataset中的distinct的element
9. groupByKey(numTasks):返回(K,Seq[V])，也就是hadoop中reduce函数接受的key-valuelist
10. reduceByKey(func,[numTasks]):就是用一个给定的4. reducefunc再作用在groupByKey产生的(K,Seq[V]),比如求和，求平均数
11. sortByKey([ascending],[numTasks]):按照key来进行排序，是升序还是降序，ascending是boolean类型
12. join(otherDataset,[numTasks]):当有两个KV的dataset(K,V)和(K,W)，返回的是(K,(V,W))的dataset,numTasks为并发的任务数
13. cogroup(otherDataset,[numTasks]):当有两个KV的dataset(K,V)和(K,W)，返回的是(K,Seq[V],Seq[W])的dataset,numTasks为并发的任务数
14. cartesian(otherDataset)：笛卡尔积就是m*n，大家懂的

action操作：

1. reduce(func)：说白了就是聚集，但是传入的函数是两个参数输入返回一个值，这个函数必须是满足交换律和结合律的
2. collect()：一般在filter或者足够小的结果的时候，再用collect封装返回一个数组
3. count():返回的是dataset中的element的个数
4. first():返回的是dataset中的第一个元素
5. take(n):返回前n个elements，这个士driverprogram返回的
6. takeSample(withReplacement，num，seed)：抽样返回一个dataset中的num个元素，随机种子seed
7. saveAsTextFile（path）：把dataset写到一个textfile中，或者hdfs，或者hdfs支持的文件系统中，spark把每条记录都转换为一行记录，然后写到file中
8. saveAsSequenceFile(path):只能用在key-value对上，然后生成SequenceFile写到本地或者hadoop文件系统
9. countByKey()：返回的是key对应的个数的一个map，作用于一个RDD
10. foreach(func):对dataset中的每个元素都使用func

val rdd = sc.parallelize(List(1,2,3,4,5,6))rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at parallelize at <console>:21val mapRdd = rdd.map(2 * _)mapRdd: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[1] at map at <console>:23mapRdd.collect[...]res0: Array[Int] = Array(2, 4, 6, 8, 10, 12)val rddFilter = rddMap.filter(_ >5)rddFilter.collectres0: Array[Int] = Array(2, 4, 6, 8, 10, 12)

//建议的方式 rdd.map(_*2).filter(_>5).collectres3: Array[Int] = Array(6, 8, 10, 12)

放在内存更快

val rdd = sc.textFile(“/input/zimu“)rdd.collect //用时3srdd.cache //放在内存rdd.collect //0.886250 s//countnumberrdd.flatMap(_.split(' ')).map((_,1)).reduceByKey(_+_).collectres14: Array[(String, Int)] = Array((d,11), (s,1), (a,5), (b,4), (h,1), (f,4), (g,1), (c,13))

val rdd1=sc.parallelize(List(('a',1),('a',2)))val rdd2=sc.parallelize(List(('a',1),('a',2),('b',3)))rdd1.union(rdd2)val rdd2=sc.parallelize(List(('a',1),('a',2),('b',3)))

rdd1.lookup('a')res7: Seq[Int] = WrappedArray(1, 2)

字幕出现频率排序降序(sortByKey(false))

rdd.flatMap(_.split(' ')).map((_,1)).reduceByKey(_+_).map(x=>(x._2,x._1)).sortByKey(false).map(x=>(x._2,x._1)).collectres31: Array[(String, Int)] = Array((c,13), (d,11), (a,5), (b,4), (f,4), (s,1), (h,1), (g,1))

lineage

容错

dependency依赖

窄依赖和宽依赖的区别:
窄依赖就是每一个父partition至多被一个子partition.每个节点独立计算互不影响.
宽依赖要等把每个几点结果都算好才可以计算下一个结果.

搜狗文件分析例子

val rdd = sc.textFile("/input/SogouQ.reduced")rdd.cacherdd.count>:24, took 11.758597 sres1: Long = 1724264

下载搜狗实验室⽤户查询⽇志精简版： http://www.sogou.com/labs/dl/q.html
（63M），做以下查询：
① ⽤户在00:00:00到12:00:00之间的查询数？

rdd.map(_.split('\t')).map(_(0)).filter(_>"00:00:00").filter(_<"12:00:00").counte>:24, took 5.842976 sres24: Long = 527232

② 搜索结果排名第⼀，但是点击次序排在第⼆的数据有多少？

rdd.map(_.split('\t')).map(_(3)).filter(line=>(line=="1 2")).counte>:24, took 5.024275 sres46: Long = 79765

计算最多出的网址

 rdd.map(_.split('\t')(5)).map((_,1)).reduceByKey(_+_).map(x=>(x._2,x._1)).sortByKey(false).map(x=>(x._2,x._1)).take(10)

从hadoop获取结果提取到本地

/usr/hadoop/bin/hadoop fs -getmerge /output/countSite/ result1