大数据技术入门

1.9 大数据交易 18
1.10 大数据之我见 19
第2章 大数据软件框架 20
2.1 Hadoop框架 20
2.1.1 HDFS（分布式文件系统） 21
2.1.2 MapReduce（分布式计算框架） 22
2.1.3 YARN（集群资源管理器） 25
2.1.4 Zookeeper（分布式协作服务） 28
2.1.5 Ambari（管理工具） 29
2.2 Spark（内存计算框架） 29
2.2.1 Scala 31
2.2.2 Spark SQL 32
2.2.3 Spark Streaming 33
2.3 实时流处理框架 34
2.4 框架的选择 35
第3章 安装与配置大数据软件 36
3.1 Hadoop发行版 36
3.1.1 Cloudera 36
3.1.2 HortonWorks 37
3.1.3 MapR 38
3.2 安装Hadoop前的准备工作 39
3.2.1 Linux主机配置 40
3.2.2 配置Java环境 41
3.2.3 安装NTP和python 42
3.2.4 安装和配置openssl 43
3.2.5 启动和停止特定服务 44
3.2.6 配置SSH无密码访问 44
3.3 安装Ambari 和 HDP 45
3.3.1 配置安装包文件 45
3.3.2 安装 Ambari 46
3.3.3 安装和配置HDP 47
3.4 初识Hadoop 49
3.4.1 启动和停止服务 50
3.4.2 使用HDFS 51
3.5 Hadoop的特性 52
第4章 大数据存储：文件系统 53
4.1 HDFS shell命令 53
4.2 HDFS配置文件 55
4.3 HDFS API编程 57
4.3.1 读取HDFS文件内容 57
4.3.2 写HDFS文件内容 60
4.4 HDFS API总结 62
4.4.1 Configuration类 62
4.4.2 FileSystem抽象类 62
4.4.3 Path类 63
4.4.4 FSDataInputStream类 63
4.4.5 FSDataOutputStream类 63
4.4.6 IOUtils类 63
4.4.7 FileStatus类 64
4.4.8 FsShell类 64
4.4.9 ChecksumFileSystem抽象类 64
4.4.10 其他HDFS API实例 64
4.4.11 综合实例 67
4.5 HDFS文件格式 69
4.5.1 SequenceFile 70
4.5.2 TextFile（文本格式） 70
4.5.3 RCFile 70
4.5.4 Avro 72
第5章 大数据存储：数据库 73
5.1 NoSQL 73
5.2 HBase管理 74
5.2.1 HBase表结构 75
5.2.2 HBase系统架构 78
5.2.3 启动并操作HBase数据库 80
5.2.4 HBase Shell工具 82
5.3 HBase编程 86
5.3.1 增删改查API 86
5.3.2 过滤器 90
5.3.3 计数器 93
5.3.4 原子操作 94
5.3.5 管理API 94
5.4 其他NoSQL数据库 95
第6章 大数据访问：SQL引擎层 97
6.1 Phoenix 97
6.1.1 安装和配置Phoenix 98
6.1.2 在eclipse上开发phoenix程序 104
6.1.3 Phoenix SQL工具 108
6.1.4 Phoenix SQL 语法 109
6.2 Hive 111
6.2.1 Hive架构 111
6.2.2 安装Hive 112
6.2.3 Hive和MySQL的配置 114
6.2.4 Hive CLI 115
6.2.5 Hive数据类型 115
6.2.6 HiveQL DDL 119
6.2.7 HiveQL DML 121
6.2.8 Hive编程 123
6.2.9 HBase集成 125
6.2.10 XML和JSON数据 127
6.2.11 使用Tez 128
6.3 Pig 130
6.3.1 Pig语法 131
6.3.2 Pig和Hive的使用场景比较 134
6.4 ElasticSearch（全文搜索引擎） 136
6.4.1 全文索引的基础知识 136
6.4.2 安装和配置ES 138
6.4.3 ES API 140
第7章 大数据采集和导入 143
7.1 Flume 145
7.1.1 Flume架构 145
7.1.2 Flume事件 146
7.1.3 Flume源 147
7.1.4 Flume拦截器（Interceptor） 148
7.1.5 Flume通道选择器（Channel Selector） 149
7.1.6 Flume通道 150
7.1.7 Flume接收器 151
7.1.8 负载均衡和单点失败 153
7.1.9 Flume监控管理 153
7.1.10 Flume实例 154
7.2 Kafka 155
7.2.1 Kafka架构 156
7.2.2 Kafka与JMS的异同 158
7.2.3 Kafka性能考虑 158
7.2.4 消息传送机制 159
7.2.5 Kafka和Flume的比较 159
7.3 Sqoop 160
7.3.1 从数据库导入HDFS 160
7.3.2 增量导入 163
7.3.3 将数据从Oracle导入Hive 163
7.3.4 将数据从Oracle导入HBase 164
7.3.5 导入所有表 165
7.3.6 从HDFS导出数据 165
7.3.7 数据验证 165
7.3.8 其他Sqoop功能 165
7.4 Storm 167
7.4.1 Storm基本概念 168
7.4.2 spout 169
7.4.3 bolt 171
7.4.4 拓扑 173
7.4.5 Storm总结 175
7.5 Splunk 175
第8章 大数据管理平台 177
8.1 大数据建设总体架构 177
8.2 大数据管理平台的必要性 178
8.3 大数据管理平台的功能 179
8.3.1 推进数据资源全面整合共享 179
8.3.2 增强数据管理水平 180
8.3.3 支撑创新大数据分析 180
8.4 数据管理平台（DMP） 180
8.5 EasyDoop案例分析 182
8.5.1 大数据建模平台 183
8.5.2 大数据交换和共享平台 184
8.5.3 大数据云平台 185
8.5.4 大数据服务平台 186
8.5.5 EasyDoop平台技术原理分析 188
第9章 Spark技术 192
9.1 Spark框架 192
9.1.1 安装Spark 193
9.1.2 配置Spark 194
9.2 Spark Shell 195
9.3 Spark编程 198
9.3.1 编写Spark API程序 198
9.3.2 使用sbt编译并打成jar包 199
9.3.3 运行程序 200
9.4 RDD 200
9.4.1 RDD算子和RDD依赖关系 201
9.4.2 RDD转换操作 203
9.4.3 RDD行动（Action）操作 204
9.4.4 RDD控制操作 205
9.4.5 RDD实例 205
9.5 Spark SQL 208
9.5.1 DataFrame 209
9.5.2 RDD转化为DataFrame 213
9.5.3 JDBC数据源 215
9.5.4 Hive数据源 216
9.6 Spark Streaming 217
9.6.1 DStream编程模型 218
9.6.2 DStream操作 221
9.6.3 性能考虑 223
9.6.4 容错能力 224
9.7 GraphX图计算框架 224
9.7.1 属性图 226
9.7.2 图操作符 228
9.7.3 属性操作 231
9.7.4 结构操作 231
9.7.5 关联（join）操作 233
9.7.6 聚合操作 234
9.7.7 计算度信息 235
9.7.8 缓存操作 236
9.7.9 图算法 236
第10章 大数据分析 238
10.1 数据科学 239
10.1.1 探索性数据分析 240
10.1.2 描述统计 241
10.1.3 数据可视化 241
10.2 预测分析 244
10.2.1 预测分析实例 244
10.2.2 回归（Regression）分析预测法 246
10.3 机器学习 247
10.3.1 机器学习的市场动态 248
10.3.2 机器学习分类 249
10.3.3 机器学习算法 251
10.4 Spark MLib 252
10.4.1 MLib架构 253
10.4.2 MLib算法库 253
10.4.3 决策树 257
10.5 深入了解算法 261
10.5.1 分类算法 262
10.5.2 预测算法 263
10.5.3 聚类分析 263
10.5.4 关联分析 264
10.5.5 异常值分析算法 266
10.5.6 协同过滤（推荐引擎）算法 267
10.6 Mahout简介 267
第11章 案例分析：环保大数据 268
11.1 环保大数据管理平台 268
11.2 环保大数据应用平台 269
11.2.1 环境自动监测监控服务 270
11.2.2 综合查询服务 272
11.2.3 统计分析服务 272
11.2.4 GIS服务 274
11.2.5 视频服务 274
11.2.6 预警服务 275
11.2.7 应急服务 276
11.2.8 电子政务服务 277
11.2.9 智能化运营管理系统 279
11.2.10 环保移动应用系统 279
11.2.11 空气质量发布系统 280
11.3 环保大数据分析系统 280
第12章 案例分析：公安大数据 281
12.1 总体架构设计 281
12.2 建设内容 282
12.3 建设步骤 284
附录 1 数据量的单位级别 285
附录 2 Linux Shell常见命令 286
附录 3 Ganglia（分布式监控系统） 289
附录 4 auth-ssh脚本 290
附录 5 作者简介 292

.　　（2）大数据访问：探究SQL引擎层中Hive、Phoenix、Spark SQL等组件的功能，并阐述了全文搜索的ElasticSearch，也探究了Spark的高速访问能力。
　　（3）大数据采集：大数据的采集是指接收各类数据源（比如：Web、行业应用系统或者传感器等）的数据。大数据采集的主要特点和挑战是导入的数据量大（每秒钟的导入量经常会达到百兆，甚至千兆级别）、并发数高和数据源的异构。采集端可能会有很多数据库（或文件），有时需要在导入基础上做一些简单的清洗和预处理工作。在这个部分，我们探究了Flume、Kafka、Sqoop等技术，也探究了如何使用Storm和Spark Streaming来对数据进行流式计算，来满足部分业务的实时和准实时计算需求。
　　（4）大数据管理：探究数据模型、安全控制、数据生命周期等数据管理内容。
　　（5）大数据的统计和分析：探究了如何利用分布式计算集群来对存储于其内的海量数据进行统计分析，重点探究了机器学习和Spark MLlib，也阐述了多种分析算法。
　　参加本书编写的同志还有：余飞、邵敏华、欧阳涛、杨正礼、王娜、李祥、刘毕操、彭勃、李招、张剑、杨磊等人。由于我们水平有限，书中难免存在纰漏之处，敬请读者批评指正。杨正洪的邮件地址为yangzhenghong@yahoo.com。
　　杨正洪
　　2016年5月 于 San Jose
　　

.　　cd /usr/local
　　sudo mv ./spark-1.6.1-bin-without-hadoop/ ./spark
　　sudo chown -R hadoop:hadoop ./spark
　　9.1.2 配置Spark
　　安装后，进入conf目录，以spark-env.sh.template文件为模块创建spark-env.sh文件，然后修改其配置信息，命令如下：
　　cd /usr/local/spark
　　cp ./conf/spark-env.sh.template ./conf/spark-env.sh
　　编辑 ./conf/spark-env.sh（vim ./conf/spark-env.sh），在文件的最后加上如下一行：
　　export SPARK_DIST_CLASSPATH=$(/usr/local/hadoop/bin/hadoop classpath)
　　保存后，Spark 就可以启动和运行了。在 ./examples/src/main 目录下有一些 Spark 的示例程序，有 Scala、Java、Python、R 等语言的版本。我们可以先运行一个示例程序 SparkPi（即计算 π 的近似值），执行如下命令：
　　cd /usr/local/spark
　　./bin/run-example SparkPi
　　执行时会输出非常多的运行信息，输出结果不容易找到，可以通过 grep 命令进行过滤（命令中的 2>&1 可以将所有的信息都输出到 stdout 中）：
　　./bin/run-example SparkPi 2>&1 ｜ grep "Pi is roughly"
　　过滤后的运行结果为 π 的 5 位小数近似值 。
　　9.2 Spark Shell
　　以前的统计和机器学习依赖于数据抽样。从统计的角度来看，抽样如果足够随机，其实可以很精准地反应全集的结果，但事实上往往很难做到随机，所以通常做出来也会不准。现在大数据解决了这个问题，它不是通过优化抽样的随机来解决，而是通过全量数据来解决。要解决全量的数据就需要有强大的处理能力，Spark首先具备强大的处理能力，其次Spark Shell带来了即席查询。做算法的工程师，以前经常是在小数据集上跑个单机，然后看效果不错，一到全量上，就可能和单机效果很不一样。有了Spark后就不一样了，尤其是有了Spark Shell。可以边写代码，边运行，边看结果。Spark提供了很多的算法，最常用的是贝叶斯、word2vec、线性回归等。作为算法工程师，或者大数据分析师，一定要学会用Spark Shell。
　　Spark Shell 提供了简单的方式来学习 Spark API，也提供了交互的方式来分析数据。Spark Shell 支持 Scala 和 Python，本书选择使用 Scala 来进行介绍。Scala集成了面向对象和函数语言的特性，并运行于Java 虚拟机之上，兼容现有的 Java 程序。Scala 是 Spark 的主要编程语言，如果仅仅是写 Spark 应用，并非一定要用 Scala，用Java和Python都是可以的。使用 Scala 的优势是开发效率更高，代码更精简，并且可以通过 Spark Shell 进行交互式实时查询，方便排查问题。执行如下命令启动 Spark Shell：
　　./bin/spark-shell
　　启动成功后会有“scala >”的命令提示符。这表明已经成功启动了Spark Shell。在 Spark Shell 启动时，输出日志的最后有这么几条信息：
　　16/04/16 17:25:47 INFO repl.SparkILoop: Created spark context..
　　Spark context available as sc.
　　这些信息表明 SparkContext已经初始化好了，可通过对应的sc变量直接进行访问。Spark 的主要抽象是分布式的数据集合RDD，它可被分发到集群各个节点上，进行并行操作。一个RDD可以通过 Hadoop InputFormats 创建（如 HDFS），或者从其他 RDDs转化而来。下面我们从 ./README 文件新建一个 RDD，代码如下：
　　scala>val textFile = sc.textFile("file:///usr/local/spark/README.md")
　　上述的sc是Spark创建的SparkContext，我们使用SparkContext对象加载本地文件README.md来创建RDD。输出结果如下：
　　textFile: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[1] at textFile at :27
　　上述返回结果为一个MapPartitionsRDD文件。需要说明的是，加载HDFS文件和本地文件都是使用textFile ，区别在于前缀“hdfs://”为HDFS文件，而“file:// ”为本地文件。上述代码中通过“file://”前缀指定读取本地文件，直接返回MapPartitionsRDD。Spark Shell默认方式是读取HDFS中的文件。从HDFS读取的文件先转换为HadoopRDD，然后隐式转换成MapPartitionsRDD。
　　上面的例子使用Spark中的文本文件README.md创建一个RDD textFile，文件中包含了若干文本行。将该文本文件读入RDD textFile时，其中的文本行将被分区，以便能够分发到集群中并行化操作。我们可以想象，RDD有多个分区，每个分区上有多行的文本内容。RDDs 支持两种类型的操作：
　　? actions：在数据集上运行计算后返回结果值。
　　? transformations：转换。从现有RDD创建一个新的RDD。
　　下面我们演示count()和first()操作：
　　scala>textFile.count() // RDD 中的 item 数量，对于文本文件，就是总行数
　　输出结果为：
　　res0: Long = 95
　　scala>textFile.first() // RDD 中的第一个 item，对于文本文件，就是第一行内容
　　输出结果为：
　　res1: String = # Apache Spark
　　上面这两个例子都是action的例子。接着演示 transformation，通过 filter transformation来筛选出包含 Spark 的行，返回一个新的RDD，代码如下：
　　scala>val linesWithSpark = textFile.filter(line => line.contains("Spark"))
　　scala>linesWithSpark.count() // 统计行数
　　上面的linesWithSpark RDD有多个分区，每个分区上只有包含了Spark的若干文本行。输出结果为：
　　res4: Long = 17
　　上述结果表明一共有17行内容包含“Spark”，这与通过 Linux 命令 cat ./README.md ｜ grep "Spark" -c 得到的结果一致，说明是正确的。action 和 transformation 可以用链式操作的方式结合使用，使代码更为简洁：
　　scala>textFile.filter(line => line.contains("Spark")).count()// 统计包含 Spark 的行数
　　RDD的actions和transformations可用在更复杂的计算中。例如，通过如下代码可以找到包含单词最多的那一行内容共有几个单词：
　　scala>textFile.map(line => line.split(" ").size).reduce((a, b) => if (a > b) a else b)
　　输出结果为：
　　res5: Int = 14
　　上述代码将每一行文本内容使用split进行分词，并统计分词后的单词数。将每一行内容map为一个整数，这将创建一个新的 RDD，并在这个 RDD 中执行reduce操作，找到最大的数。map()、reduce()中的参数是Scala的函数字面量（function literals），并且可以使用Scala/Java的库。例如，通过使用 Math.max() 函数（需要导入Java的Math库），可以使上述代码更容易理解：
　　scala>import java.lang.Math
　　scala>textFile.map(line => line.split(" ").size).reduce((a, b) => Math.max(a, b))
　　词频统计（WordCount）是Hadoop MapReduce的入门程序，Spark可以更容易地实现。首先结合flatMap、map和reduceKey来计算文件中每个单词的词频：
　　scala>val wordCounts = textFile.flatMap(line => line.split(" ")).map(word => (word, 1)).reduceByKey((a, b) => a + b)
　　输出结果为(string，int)类型的键值对ShuffledRDD。这是因为reduceByKey操作需要进行Shuffle操作，返回的是一个Shuffle形式的ShuffleRDD：
　　wordCounts: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[4] at reduceByKey at :29
　　然后使用collect聚合单词计算结果：
　　scala>wordCounts.collect()
　　输出结果为：
　　res7: Array[(String, Int)] = Array((package,1), (For,2), (Programs,1), (processing,1), (Because,1), (The,1)...)
　　Spark 支持将数据缓存在集群的内存缓存中，当数据需要反复访问时这个特征非常有用。调用 cache()，就可以将数据集进行缓存：
　　scala>textFilter.cache()
　　9.3 Spark编程
　　无论Windows或Linux操作系统，都是基于Eclipse或Idea构建开发环境，通过Java、Scala或Python语言进行开发。根据开发语言的不同，我们需要预先准备好JDK、Scala或Python环境，然后在Eclipse中下载安装Scala或Python插件。
　　下面我们通过一个简单的应用程序 SimpleApp 来演示如何通过 Spark API 编写一个独立应用程序。不同于使用Spark Shell自动初始化的SparkContext，独立应用程序需要自己初始化一个SparkContext，将一个包含应用程序信息的SparkConf对象传递给SparkContext构造函数。对于独立应用程序，使用 Scala 编写的程序需要使用 sbt 进行编译打包，相应地，Java 程序使用 Maven 编译打包，而 Python 程序通过 spark-submit 直接提交。
　　在终端中执行如下命令，创建一个文件夹 sparkapp 作为应用程序根目录：
　　cd ~ # 进入用户主文件夹
　　mkdir ./sparkapp # 创建应用程序根目录
　　mkdir -p ./sparkapp/src/main/scala# 创建所需的文件夹结构
　　9.3.1 编写Spark API程序
　　在./sparkapp/src/main/scala下建立一个名为SimpleApp.scala 的文件（vim ./sparkapp/src/main/scala/SimpleApp.scala），添加代码如下：
　　/* SimpleApp.scala */
　　import org.apache.spark.SparkContext
　　import org.apache.spark.SparkContext._
　　import org.apache.spark.SparkConf
　　object SimpleApp {
　　//使用关键字def声明函数，必须为函数指定参数类型
　　def main(args: Array[String]) {
　　val logFile = "file:///usr/local/spark/README.md" // 一个本地文件
　　//创建SparkConf对象，该对象包含应用程序的信息
　　val conf = new SparkConf().setAppName("Simple Application")
　　//创建SparkContext对象，该对象可以访问Spark集群
　　val sc = new SparkContext(conf)
　　val logData = sc.textFile(logFile, 2).cache()
　　//line=>line.contains(..)是匿名函数的定义，line是参数
　　val numAs = logData.filter(line => line.contains("a")).count()
　　val numBs = logData.filter(line => line.contains("b")).count()
　　println("Lines with a: %s, Lines with b: %s".format(numAs, numBs))
　　}
　　}
　　上述程序计算 /usr/local/spark/README 文件中包含 “a” 的行数和包含 “b” 的行数。不同于 Spark Shell，独立应用程序需要通过“val sc = new SparkContext(conf)”初始化 SparkContext，SparkContext 的参数 SparkConf 包含了应用程序的信息。
　　9.3.2 使用sbt编译并打成jar包
　　该程序依赖 Spark API，因此我们需要通过sbt（或mvn）进行编译打包。我们以sbt为例，创建一个包含应用程序代码的jar包。在 ./sparkapp 中新建文件 simple.sbt（vim ./sparkapp/simple.sbt），添加如下内容，声明该独立应用程序的信息以及与 Spark 的依赖关系：
　　name := "Simple Project"
　　version := "1.0"
　　scalaVersion := "2.10.5"
　　libraryDependencies += "org.apache.spark" %% "spark-core" % "1.6.1"
　　文件 simple.sbt 需要指明Spark和Scala的版本。上述版本信息可以从Spark Shell获得。我们启动Spark Shell的过程中，当输出到 Spark 的符号图形时，可以看到相关的版本信息。
　　Spark中没有自带sbt，需要手动安装sbt，我们选择安装在/usr/local/sbt中：
　　sudo mkdir /usr/local/sbt
　　sudo chown -R hadoop /usr/local/sbt # 此处的hadoop为你的用户名
　　cd /usr/local/sbt
　　下载sbt后，拷贝至 /usr/local/sbt 中。接着在 /usr/local/sbt 中创建 sbt 脚本（vim ./sbt），添加如下内容：
　　#!/bin/bash
　　SBT_OPTS="-Xms512M -Xmx1536M -Xss1M -XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=256M"
　　java $SBT_OPTS -jar `dirname $0`/sbt-launch.jar "$@"
　　保存后，为 ./sbt 脚本增加可执行权限：
　　chmod u+x ./sbt
　　最后检验 sbt 是否可用：
　　./sbt sbt-version
　　只要能得到版本信息就说明sbt安装没问题了。接着，我们可以通过如下代码将整个应用程序打包成 JAR文件：
　　/usr/local/sbt/sbt package
　　打包成功的话，会输出“Done Packaging”信息。生成的 jar 包的位置为 ~/sparkapp/target/scala-2.10/simple-project_2.10-1.0.jar。
　　9.3.3 运行程序
　　一旦应用程序被打包成jar文件，就可以通过 /bin/spark-submit脚本启动应用程序。将生成的jar包通过spark-submit提交到 Spark 中运行了，命令如下：
　　/usr/local/spark/bin/spark-submit --class "SimpleApp" \
　　~/sparkapp/target/scala-2.10/simple-project_2.10-1.0.jar
　　如果你觉得输出信息太多，可以通过如下命令过滤结果信息：
　　/usr/local/spark/bin/spark-submit --class "SimpleApp" \
　　~/sparkapp/target/scala-2.10/simple-project_2.10-1.0.jar 2>&1 ｜ grep "Lines with a:"
　　最终得到的结果如下：
　　Lines with a: 58, Lines with b: 26