Spark学习笔记1

一、Spark 的简介：

-》spark只是一种类类似于Mapreduce的计算模型

-》用来处理数据

-》处理数据：RDD

-》RDD：弹性分布式数据集（集合）

-》内存，分布式，分区（可以优化的点：分区数》=线程数，一般1核处理1-2个分区的数据）

-》读取数据：将不同的数据读取到RDD中

-》处理数据：调用RDD中的方法，处理数据，生成新的RDD

-》保存数据：调用RDD中的方法，处理数据一般是数组等类型

-》组件

-》基础组件

-》core：scala/java/python RDD

-》SQL:SQL编写 Hive（HDFS） -》DataFrame/DataSet

spark可以直接读hive在mysql中的源数据 这样就可以直接底层跑spark了

-》Streaming Kafka ->Dstream

-》struct Streaming：SQL +Streaming

-》高级组件

-》mlib：机器学习库

-》GraphX：图形计算

-》R

-》分析

-》流程

-》读取数据：rdd、hive、kafka

-》处理数据：map、filter、reduce、sort

-》shuffle

-》保存数据 ：hdfs，mysql，hbase

-》与Mapreduce流程的区别

-》1个Mapreduce=1个app

-》多个job=1个spark程序

-》特点

-》处理效率高

-》使用简单

-》开发接口通用性高

-》running everywhere

-》读取和存储：不同的数据源不同的目标地

-》运行模式：

-》本地模式：开发测试

-》集群模式：

-》standalone：类似于yarn

-》自己实现任务的调度和资源的管理

-》yarn：实现任务的调度和资源的管理

-》mesos：于yarn类似

-》云平台：EC2 阿里云

-》学习

-》看源码

-》看官方文档

-》官方论坛 databricks.com

spark.apache.org

-》学习书籍： 系统性补全 英文书籍

四、spark本地模式的部署及测试

-》工作中：编译（hadoop，hive.....）

-》下载源码

-》修改pom文件

-》maven build

官网有Building Spark

-》SBT：与maven类似，项目管理工具 用于scala

-》安装部署

-》虚拟机：2G+

-》

-》环境：

jdk +scala

-》修改配置文件

conf/spark-env.sh

java_home

scala_home

hadoop_conf_dir

-》架构

-》主从架构

-》master

-》worker

-》启动 spark shell

bin/spark-shell --master local[2] //本地为主节点 分配2个线程

先启动好hadoop 的hdfs namenode 和datanode

-》日志

-》应用端口：INFO util.Utils: Successfully started service 'SparkUI' on port 4040.

-》repl.SparkILoop: Created spark context..

Spark context available as sc. 默认context对象sc

-》创建了一个sparkSQL的context

测试

val inputRdd=sc.textFile("/README.md")

默认读取地址是hdfs 所以需要把文件放在HDFS上

设置日志级别

sc.setLogLevel("WARN")

统计行数

inputRdd.count()

取第一行

inputRdd.first()

val lineWithSpark=inputRdd.filter(line=>line.contains("Spark"))

注意：spark在进行处理时默认也是一行一行的处理

scala> val wordCount=inputRdd.flatMap(_.trim.split(" ").filterNot(_.isEmpty)).map((_,1)).reduceByKey((a,b)=>(a+b))

wordcount：

wordCount.collect() 可以将RDD-》变为数组

但是不推荐使用这个方法，因为数据量大了以后无法再创建Array来存储了

-》修改输出格式：

wordCount.foreach(x=> println(x._1+"\t"+x._2))

这是在输出改变的

推荐在过程中转变

wordCount.map(x=>x._1+"\t"+x._2).foreach(println)

->注意：

-》spark处理时：一行一行的处理

-》spark中程序的层次

application（例如spark-shell）

-》job（一个app中有多个job）

-》stage（跨越stage会进行shuffle过程）

-》task(Rdd) （一个小圆点就是使用了一个RDD）

工作中 调优 需要看Summary Metrics 中 min和max的时间 不能达到100ms 几十毫秒可以接受

输出到hdfs上

wordCount.saveasTextFile("/out.txt")

优化：

中间结果RDD越少越好

避免连续的相同操作

-》排序：sortByKey

如果要按value 排序则先swap一下key value即可

工作实例：

统计会话时长

首先用hive导入数据到hdfs上

之后处理数据：

过滤字段 ：

session_id track_time

分组

session_id list<track_time>

session_id max_time-min_time

判断：按区间

封装元组 1-10,1

10-20

进行wordcount

最后保存到Hdfs上

-》实现：

-》加载数据

val sessionRdd = sc.textFile("/user/hive/warehouse/taobao.db/page_views/page_views.data")

-》处理数据

-》过滤和转换

val keyvalue1= sessionRdd.map(line =>{

val temp1 = line.split("\t")

import java.text.SimpleDateFormat

val time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")

.parse(temp1(0)).getTime()

(temp1(2),time)

})

val result = keyvalue1.groupByKey()

.map{

case (sessionid,iterator) =>{

val max_time=iterator.toList.max

val min_time = iterator.toList.min

val timeLength = (max_time - min_time) / 1000

if(timeLength >= 0 && timeLength < 10){

println("0-10,get inRdd")

("0-10",1)

}else if(timeLength >= 10 && timeLength < 20){

("10-20",1)

}

else if(timeLength >= 20 && timeLength < 30){

("20-30",1)

}else

("30+",1)

}

}.reduceByKey(_+_)

val result2=keyvalue1.groupByKey()

.map(tuple=>{

val maxTime=tuple._2.toList.max

val minTime=tuple._2.toList.min

val timeLength = (maxTime - minTime) / 1000

timeLength match {

case

}

}).foreach(println)

六、Spark架构

-》standalone模式类似于yarn

-》分布式架构：主从架构

-》master ：负责管理集群所有的资源

-》worker ：负责当前节点上所有的资源

-》特殊的角色：

-》Driver：负责管理当前application中所有的task，申请资源（类似app master）默认包含一个sparkcontext对象sc（默认启动生成对象）

-》excutor：运行所有的task，就是一个JVM进程

->缓存：cache

注意：可以将Rdd添加到缓存中 rdd.cache 用完之后一定要记得释放掉 rdd.unpersist

集群模式的搭建：

-》与yarn的区别

yarn上一个机器只能有一个nodemanager

standalone 一台机器可以有多个worker（根据机器资源）

-》修改配置文件

spark-env.sh

SPARK_MASTER_IP=poche.com

SPARK_MASTER_PORT=7077

SPARK_WORKER_CORES=2

SPARK_WORKER_MEMORY=2G

SPARK_WORKER_PORT=7078

SPARK_WORKER_INSTANCES=1

SPARK_MASTER_WEBUI_PORT=8080

slaves

poche.com

->启动服务

sbin/start-master.sh

sbin/start-slaves.sh

必须在master节点上启动从节点

master到任何一个slave节点必须配ssh

再去提交spark-shell

bin/spark-shell --master spark://poche.com:7077

在scala中编程

将打包好的jar包

提交集群运行：

bin/spark-submit --master spark://poche.com:7077 --class com.poche.bigdata.spark.yhd.Yihaodian --jars lib/mysql-connector-java-5.1.27-bin.jar /opt/datas/Develop-1.0-SNAPSHOT.jar

-》角色

-》Driver 4040端口运行在java中

-》资源

-》内存

-》CPU

-》--deploy-mode：部署模式

决定了Driver在那台机器上启动

-》默认情况下Driver：client

-》Client：Driver就在提交程序的机器上启动

-》cluster：在集群中选择一条机器启动Driver

--supervise：集群模式下，如果Driver的机器宕机，将driver重写部署到另一台上

deploy 和 supervise是必须在共工作中配置的！！！！

-》Excutor

-》资源：

-》内存：--executor-memory 指定每个executor的内存

-》CPU：

--total-executor-cores NUM：所有excutor总核数

--executor-cores NUM：每个excutor的核数

-》个数：

cpu的两个参数决定：一定要成倍数关系

bin/spark-submit \

--master spark://poche.com:7077 \

--jars lib/mysql-connector-java-5.1.27-bin.jar \

--class com.poche.bigdata.spark.yhd.Yihaodian \

--deploy-mode cluster \

--supervise \

--driver-memory 1G \

--executor-memory 512M \

--total-executor-cores 2 \

--executor-cores 1 \

/opt/datas/Develop-1.0-SNAPSHOT.jar