Hadoop生态系统
配置Hadoop运行环境
Hadoop系统架构
HDFS分布式文件系统
MapReduce分布式计算(MapReduce项目实战)
使用脚本语言Pig(Pig项目实战)
数据仓库工具Hive(Hive项目实战)
无限大表数据库HBase
YARN架构数据处理
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
＃include <bitcoin/bitcoin.hpp> bc::hash_digest create_merkle(bc::hash_digest_list& merkle) { // Stop if hash list is empty if (merkle.empty()) { return bc::null_hash; } else if (merkle.size() == 1) { return merkle[0]; } // While there is more than 1 hash in the list, keep looping... while (merkle.size() > 1) { // If number of hashes is odd, dplicate the last hash in the list if (merkle.size() % 2 != 0) { merkle.push_back(merkle.back()); } // List size is now even assert(merkle.size() % 2 ==0); // New hash list bc::hash_digest_list new_merkle; // Loop through hashes 2 at a time for (auto it = merkle.begin(); it != merkle.end(); it += 2) { // Join both current hashes together (concatenate) bc::data_chunk concat_data(bc::hash_size * 2); auto concat = bc::make_serializer(concat_data.begin()); concat.write_hash(*it); concat.write_hash(*(it + 1)); assert(concat.iterator() == concat_data.end()); // Hash both of the hashes bc::hash_digest new_root = bc::bitcoin_hash(concat_data); // Add this to the new list new_merkle.push_back(new_root); } merkle = new_merkle; } return merkle[0]; }
Hadoop生态系统
Ambari: 整合Hadoop集群管理工具，包括安装，监控和维护
https://ambari.apache.org/
Flume: 分布式日志收集系统
https://flume.apache.org
HBase: 分布式，面向列的开源数据库，适用于非结构大数据存储
https://hbase.apache.org
HCatalog: 用于管理Hadoop产生的数据的表存储管理系统
https://cwiki.apache.org/confluence/display/Hive/HCatalog
HCatalog is a table and storage management layer for Hadoop that enables users with different data processing tools — Pig, MapReduce — to more easily read and write data on the grid.
Hive: 基于HDFS的数据仓库工具可以将结构化的文件映射为一张数据库表，提供类SQL语言HiveQL
https://hive.apache.org/
Hue: Hadoop图形界面管理工具，可以浏览文件及发出Hive/Pig指令
gethue.com
Pig: 用于大数据分析工具，包含一个能产生MapReduce程序的编译器及查询语言 Pig Latin
https://pig.apache.org
Sqoop: 用于Hadoop系统与传统数据库间进行数据交换多工具
sqoop.apache.org
ZooKeeper: 是一个分布式应用程序协调服务器
http://zookeeper.apache.org
Mahout: 数据挖掘算法库
mahout.apache.org
The Apache Mahout™ project's goal is to build an environment for quickly creating scalable performant machine learning applications.
配置Hadoop运行环境
建立Hadoop运行环境
Hadoop1.x, 最稳定的版本是1.2.1, 1.0版本相当于0.20.205
Hadoop2.x, 最新版本2.7.2(Jan 25, 2016)，2.x版本相当于0.23.x版本，相比1.x，2.x是一个全新的架构。
案例采用1.x安装于64位Redhat Linux操作系统。
安装和配置Hadoop
Hadoop系统三种运行模式：
单机模式：默认Hadoop被配置为非分布式模式运行的独立Java进程
伪分布式：单节点上用不同的Java进程模拟分布式运行中的各类节点（案例模式）
完全分布式：在多节点上配置Hadoop集群
Hadoop安装步骤
1 安装JDK (jdk-7u71-linux-x64.tar.gz)
以root用户登录，将JDK安装到/usr/jdk1.7.0_71目录中。
$ su root #升级为root用户
$ zcat jdk-7u71-linux-x64.tar.gz | tar xvf - -C /usr
将JDK加入PATH环境变量：
$ cd
$ vi .bash_profile
……
PATH=/usr/jdk1.7.0_71/bin:$PATH:$HOME/bin
…… #保存并退出
$ . .bash_profile # 加载配置文件
$ java –version # 测试JDK是否正常工作
2 配置免密码SSH(Secure Shell)
Hadoop的运行将在SSH环境下进行，因此需要为其配置一个免密码SSH工作环境。配置步骤如下：
生成密钥对：
$ ssh-keygen –t rsa
进入.ssh目录，复制密钥：
$ cd .ssh
$ cp id_rsa.pub authorized_keys
确认SSH连接免密码：
$ ssh localhost
3 解压Hadoop包，配置Hadoop (hadoop-1.2.1.tar.gz)
以root用户登录，将Hadoop系统安装到/usr/hadoop-1.2.1目录中。
$ su root #升级为root用户
$ zcat hadoop-1.2.1.tar.gz | tar xvf - -C /usr (gunzip hadoop-2.7.2.tar.gz for mac)
在/usr/hadoop-1.2.1安装目录下，修改conf/hadoop-env.sh文件，在其中增加：
export JAVA_HOME=/usr/jdk1.7.0_71。
将Hadoop加入PATH环境变量：
$ cd
$ vi .bash_profile
……
PATH=/usr/hadoop-1.2.1/bin:/usr/jdk1.7.0_71/bin:$PATH:$HOME/bin
…… #保存并退出
conf/core-site.xml：系统核心配置文件 1 <configuration> 2 <property> 3 <name>fs.default.name</name> 4 <value>hdfs://localhost:9000</value> 5 </property> 6 </configuration> conf/hdfs-site.xml：HDFS子系统配置文件。 1 <configuration> 2 <property> 3 <name>dfs.replication</name> 4 <value>1</value> 5 </property> 6 </configuration> conf/mapred-site.xml：MapReduce子系统配置文件。 1 <configuration> 2 <property> 3 <name>mapred.job.tracker</name> 4 <value>localhost:9001</value> 5 </property> 6 </configuration>
在首次运行Hadoop时，首先需要格式化分布式文件系统。
转至Hadoop安装目录，使用以下命令对文件系统进行格式化。
$ bin/hadoop namenode –format
注意:该命令只需运行一次。
启动和停止Hadoop
转至Hadoop安装目录，使用以下命令启动Hadoop守护进程：
$ bin/start-all.sh
该命令启动Hadoop所有进程。启动之后，可使用jsp命令查看进程情况以确认：
$ jps
4066 SecondaryNameNode
3599 JobTracker
3881 NameNode
4255 TaskTracker
5639 Jps
3484 DataNode
转至Hadoop安装目录，使用以下命令可停止Hadoop守护进程：
$ bin/stop-all.sh
经典案例WordCount
在本地新建一个目录，以input命名，并新建两个文本文件：
[hadoop@localhost ~]$ mkdir input
[hadoop@localhost input]$ cd input
[hadoop@localhost input]$ echo "hello world" > test1.txt
[hadoop@localhost input]$ echo "hello hadoop" >test2.txt
[hadoop@localhost input]$ ls –al
[hadoop@localhost input]$ cd ..
将本地文件系统上的input复制到HDFS根目录下，并命名为in：
[hadoop@localhost ~]$ hadoop dfs -put input in
执行Hadoop自带的wordcount实例，统计一批文本文件中个单词出现的次数：
[hadoop@localhost ~]$ hadoop jar /usr/hadoop-1.2.1/hadoop-examples-1.2.1.jar wordcount in out
其中 out为数据处理完成后的输出目录（注意执行此目录前out目录必须为空，或不存在，否则会出错）
[hadoop@localhost ~]$ hadoop dfs -cat out/*
hadoop 1
hello 2
world 1
Hadoop系统架构
Hadoop 1.x架构
无论主、从节点，均安装同样的Hadoop系统，然后通过配置来区分主、从类型。
NameNode、SecondaryNameNode和JobTracker — Hadoop主节点上必需的进程。
DataNode和TaskTracker — Hadoop从节点上必需的进程。
SecondaryNameNode进程会定期与NameNode通信，并定期保存HDFS元数据的快照，从而降低由于NameNode宕机所带来的损失。另外，SecondaryNameNode进程也可以作为备用的NameNode。
每个从节点上只有一个TaskTracker, 但它可以产生多个JVM进程，以并行处理多个Map和Reduce任务。TaskTracker的一个重要职责是与JobTracker进行定时通讯联络。
HDFS系统架构
运行在HDFS之上的应用程序必须流式地访问它们的数据集。
HDFS被设计为适合批量处理的，而不是用户交互式的。
其支持的重点是在数据吞吐量上，而不是数据访问的反应时间。
大部分HDFS应用程序对文件操作需要的是一次写入多次读取的操作模式。
文件一旦被创建、写入、关闭之后，就不再需要修改。
Block（数据块）：大文件会被分割成多个Block进行存储，Block大小默认为64MB。每一个Block会在多个DataNode上存储多个副本，默认值为3。
HDFS客户端读文件
HDFS客户端写文件
HDFS分布式文件系统
HDFS数据存储和访问
fsimage：顾名思义，是保存文件系统的映射信息。
edits：用来临时性记录数据改变情况的文件。
CheckPoint工作过程如下：
定期启动CheckPoint。当CheckPoint启动时，NameNode创建一个新文件来接受日志文件系统的变化，该文件名为edits.new；
文件edits不再接受新的变化，并和fsimage一起拷贝到CheckPointNode所在文件系统中；
CheckPointNode将两个文件合并产生fsimage.ckpt文件；
CheckPointNode将fsimage.ckpt拷贝到NameNode上；
NameNode使用新的fsimage.ckt替代原fsimage文件；
NameNode用edits.new替代edits。
HDFS提供了一个Balancer工具，可用来根据存储的策略重新分配数据，将数据从过度使用的节点移到使用率低的节点，以达到平衡。
HDFS常用命令
与Linux命令基本相同。所有命令的通用格式为：hadoop fs –<cmd> [args]
HDFS路径（称为资源）使用URI格式来表示：例如：hdfs://localhost:9000/user/chunk/test.txt。
如果在core-site.xml中有如下配置，则直接使用/user/chunk/test.txt格式即可。 fs.default.name=hdfs://localhost:9000
因此，之前的列目录命令可以写为： hadoop fs –ls hdfs://localhost:9000/user/ 或 hadoop fs –ls /user/
HDFS默认工作目录为/user/$USER，$USER表示当前用户名。
在user/目录下创建trunk子目录：hadoop fs -mkdir /user/trunk 列出user/目录下所有文件和子目录：hadoop fs -ls /user 递归列出user/目录下所有文件和子目录：hadoop fs -lsr /user 将本地当前目录下的test.txt文件上传至HDFS的/user/trunk目录：hadoop fs -put test.txt /user/trunk 将本地当前目录下的test.txt文件上传至HDFS当前目录：hadoop fs -put test.txt . 将HDFS/user/trunk/test.txt文件下载至本地当前目录：hadoop fs -get /user/trunk/test.txt . 查看/user/trunk/test.txt文件内容：hadoop fs -cat /user/trunk/test.txt 查看/user/trunk/test.txt文件的尾部内容（最后1K）：hadoop fs -tail /user/trunk/test.txt 删除/user/trunk/test.txt文件：hadoop fs -rm /user/trunk/test.txt 查看ls命令的帮助文档：hadoop fs -help ls
MapReduce分布式计算
MapReduce框架
MapReduce核心包含两个抽象方法：
map()方法：负责将任务分解为多个子任务执行。
reduce()方法：负责将这些子任务的处理结果进行汇总。
Mapper处理的数据记录可能跨越了两个数据块，为此，HDFS引入了Input Split概念，以对数据块中的数据进行逻辑表示。
Map阶段的处理过程如下：
将Input Split进一步分解为键值<K1, V1>；
为每一个Split创建一个Mapper任务，执行用户自定义的map()方法，得到计算的中间结果<K2,V2>；
将中间结果按K2进行排序，并将Key值相同的Value组合到一起形成一个列表集合（List），进而形成<K2,list(V2)>列表组；
最后根据Key值的范围将这些列表组进行分组，对应不同的Reducer任务。
Reduce阶段的处理过程如下：
Reducer将从不同Mapper任务接收来的数据整合在一起并进行排序；
调用用户自定义的reduce()方法，对输入的<K2,list(V2)>进行相应的处理，得到键值对<K3,V3>并输出到HDFS上
Reducer任务的数量是由用户自行定义的。
在mapred-site.xml配置文件中有一个表示Reducer数量的属性mapred.reduce.tasks，其默认值是1。
WordCount案例分析
WordCount.java
package wordcount; import java.io.IOException; import java.util.*; import org.apache.hadoop.fs.Path; import ora.apache.hadoop.io.*; import org.apache.hadoop.mapred.*; public class WordCount { public static class Map extends MapReduceBase implements Mapper<LongWritable, Text, Text, IntWritable> { private final static IntWritable one = new IntWritable(1); private Text word = new Text(); @Override public void map(LongWritable key, Text value, OutputCollector<Text, IntWritable> output, Reporter reporter) throws IOException { String line = value.toString(); StringTokenizer tokenizer = new StringTokenizer(line); while(tokenizer.hasMoreTokens()) { word.set(tokenizer.nextToken()); output.collect(word, one); } } } public static class Reduce extends MapReduceBase implements Reducer<Text, IntWritable, Text, IntWritable> { @Override public void reduce(Text key, Iterator<IntWritable> values, OutputCollector<Text, IntWritable> output, Reporter reporter) throws IOException { int sum = 0; while (values.hasNext()) { sum += values.next().get(); } output.collect(key, new IntWritable(sum)); } } public static void main(String[] args) throws Exception { JobConf conf = new JobConf(WordCount.class); conf.setJobName("wordcount"); conf.setOutputKeyClass(Text.class); conf.setOutputValueClass(IntWritable.class); conf.setMapperClass(Map.class); conf.setCombinerClass(Reduce.class); conf.setReducerClass(Reduce.class); conf.setInputFormat(TextInputFormat.class); conf.setOutputFormat(TextOutputFormat.class); FileInputFormat.setInputPaths(conf, new Path(args[0])); FileOutputFormat.setOutputPath(conf, new Path(args[1])); JobClient.runJob(conf); } }
$ hadoop jar /……/hadoop-examples-1.2.1.jar wordcount <输入路径> <输入路径>
对于MapReduce Java应用程序，需经过编译、打包（生成jar文件）后才能运行。 以WordCount程序为例，可使用下列命令编译WordCount.java： $ mkdir wordcount_classes #指定目标文件路径 $ javac -classpath /usr/hadoop-1.2.1/hadoop-1.2.1-core.jar -d wordcount_classes WordCount.java 将编译后的.class文件打包： $ jar -cvf /usr/hadoop/wordcount.jar -C wordcount_classes/ . 使用下列命令执行示例程序： $ hadoop jar ./wordcount.jar wordcount.WordCount /wordcount/input /wordcount/output
MapReduce项目实战：美国民航航班历年数据统计
下列代码可实现将文件拷贝至本地目录：
import org.apache.hadoop.fs.Path; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileSystem; …… Configuration cfg = new Configuration(); FileSystem hdfs = FileSystem.get(cfg); Path src = new Path(outputPath + "/part-00000"); Path dst = new Path("/root/flight.dat"); hdfs.copyToLocalFile(src, dst);
下列JSP脚本代码声明了queryData() 方法，用于读取统计文件数据，并以Map集合的方式返回：
<%!
private Map<String, Integer> queryData() {
Map<String, Integer> map = new TreeMap<String, Integer>();
try {
BufferedReader br = new BufferedReader(new FileReader("d:/prj/flight.dat"));
String line;
while ((line = br.readLine()) != null) {
String[] data = line.split("\t");
String flight = data[0];
int dist = Integer.parseInt(data[1]);
map.put(flight, dist);
}
} catch (IOException e) {}
return map;
}
%>
使用脚本语言Pig
Pig大数据处理平台
Pig相当于一个Hadoop的客户端，它先连接到Hadoop集群，之后才能在集群上进行各种操作。用户不用在集群中安装任何额外的软件，也不用对集群做任何配置。
当需要处理海量数据时，先使用Pig Latin语言编写程序，Pig将用户编写的Pig Latin程序编译为MapReduce作业程序，并上传到集群中运行。
Pig安装：
Pig包下载URL http://www.apache.org/dyn/closer.cgi/pig （pig-0.12.1.tar.gz） 解压安装包： # tar zxvf pig-0.12.1.tar.gz –C /usr 在.bash_profile中添加pig安装路径 export JAVA_HOME=/usr/jdk1.7.0_71 export PATH=$PATH:/usr/pig-0.12.1/bin # source .bash_profile
执行 pig –x local，出现 “grunt>”提示符说明正确安装。
Pig的两种工作模式：
本地模式
执行命令为pig –x local, 通过本地JVM访问本地数据
MapReduce模式
默认的工作模式，执行命令是pig或pig –x mapreduce, Pig脚本转换成MapReduce任务，在Hadoop集群下工作
Pig日志：
Pig默认情况下将日志文件存放在当前目录。
修改pig-0.12.1/conf/pig.properties文件，将“# pig.logfile=”修改为 “pig.logfile=/usr/pig-0.12.1/log”即可
Pig运行方式：
Grunt Shell方式
|
命令 |
说明 |
|
cat |
列出文件内容 |
|
clear |
清楚屏幕显示 |
|
cd |
转换目录 |
|
copyFromLocal |
将文件从本地文件系统拷贝到HDFS |
|
copyToLocal |
将文件从HDFS拷贝到本地系统 |
|
fs |
执行Hadoop命令，例如grunt> fs -ls |
|
help |
显示帮助信息 |
|
ls |
列出目录内容 |
|
mv |
移到文件或目录 |
|
mkdir |
创建新目录 |
|
pwd |
显示当前目录 |
|
quit | \q |
退出shell |
|
rm |
删除文件 |
|
rmf |
删除目录 |
|
sh |
执行shell命令 |
脚本方式：脚本文件通常后缀为.pig 。
# pig –x local script.pig # pig script.pig （MapReduce模式下执行本地文件系统中的脚本文件） # pig hdfs://localhost:9000/script.pig
嵌入式方式
可以将Pig命令嵌入到Java语言中运行：
先编写特定的Java程序，在程序中嵌入Pig命令脚本代码
编译生成对应的Class文件并打成JAR包
执行JAR包，调用main方法运行程序
使用类似下列命令执行JAR包：
本地模式
# java –cp pig.jar org.apache.pig.Main –x local script.pig
MapReduce模式
# java -cp pig.jar org.apache.pig.Main script.pig
# java -cp pig.jar org.apache.pig.Main –x mapreduce script.pig
Pig Latin编程语言
现有以下数据data.txt：
John 100 class1 Marry 99 class2 Peter 97 class3 Smith 98 class2 Linda 95 class1 Jane 96 class2
现有以下Pig脚本程序，用来处理data.txt数据：
A = LOAD ‘data.txt’ AS (name, score, class); -- 载入数据 B = GROUP A BY class; -- 分组 C = FOREACH B GENERATE group, COUNT($1); -- 按组计数 DUMP C -- 输出结果
该脚本用于计算表中各班的人数。执行该脚本，将产生以下输出结果：
(class1, 2)
(class2, 3)
(class3, 1)
Pig Latin的数据模型：
Pig的数据模型包括以下四种类型：
Field：存放一个原子的数据，可以是一个字符串，一个数字等。例如，‘lucy’
Tuple：Field的序列，其中的每个Field可以是任何一种数据类型。例如，(‘lucy’, ‘1234’)
Bag：Tuple的集合，每个Tuple可以包含不同数目不同类型的Field。例如，{ (‘lucy’,’1234’) (‘jack’, ( ‘iPod’, ‘apple’)) }
Map：一组键值对的组合，在一个关系中的键值对必须是唯一的。例如：[name#Mike,phone#1391234]
函数与数据检索
从文件导入数据：
MySQL命令： CREATE TABLE TMP_TABLE(USER VARCHAR(32),AGE INT,IS_MALE BOOLEAN); CREATE TABLE TMP_TABLE_2(AGE INT,OPTIONS VARCHAR(50)); -- 用于Join LOAD DATA LOCAL INFILE '/tmp/data_file_1' INTO TABLE TMP_TABLE ; LOAD DATA LOCAL INFILE '/tmp/data_file_2' INTO TABLE TMP_TABLE_2; Pig命令： tmp_table = LOAD '/tmp/data_file_1' USING PigStorage('\t') AS (user:chararray, age:int,is_male:int); tmp_table_2= LOAD '/tmp/data_file_2' USING PigStorage('\t') AS (age:int,options:chararray);
查询整张表：
MySQL命令： SELECT * FROM TMP_TABLE; Pig命令： DUMP tmp_table;
查询前50行：
MySQL命令： SELECT * FROM TMP_TABLE LIMIT 50; Pig命令： tmp_table_limit = LIMIT tmp_table 50; DUMP tmp_table_limit;
查询某些列：
MySQL命令： SELECT USER FROM TMP_TABLE; Pig命令： tmp_table_user = FOREACH tmp_table GENERATE user; DUMP tmp_table_user;
开发Pig脚本程序
grunt> records = LOAD 'input/1987_sub.csv' USING PigStorage(',')
AS (Year,
Month,
DayofMonth,
DayOfWeek,
DepTime,
CRSDepTime,
ArrTime,
CRSArrTime,
UniqueCarrier,
FlightNum,
TailNum,
ActualElapsedTime,
CRSElapsedTime,
AirTime,
ArrDelay,
DepDelay,
Origin,
Dest,
Distance:int,
TaxiIn,
TaxiOut,Cancelled,CancellationCode,Diverted,CarrierDelay,WeatherDelay,NASDelay,SecurityDelay,LateAircraftDelay);
grunt> milage_recs = GROUP records ALL;
grunt> tot_miles = FOREACH milage_recs GENERATE SUM(records.Distance);
grunt> DUMP tot_miles;
数据仓库工具Hive
使用Hive构建数据仓库
Hive由shell环境、元数据库、解析器和数据仓库等组件构成。
Hive是一种客户端工具，需要在哪台机器上运行就将其安装在哪台机器上。
安装过程如下：
下载Hive软件包
官方URL ：http://www.apache.org/dyn/closer.cgi/hive/
本课程使用的版本为apache-hive-0.14.0-bin.tar.gz
解压安装包到指定目录，例如/usr
$ tar zxvf apache-hive-0.14.0-bin.tar.gz –C /usr
在/etc/profile中添加Hive路径：
export PATH=$PATH:/usr/apache-hive-0.14.0-bin/bin
使用source命令使配置生效
source /etc/profile
创建Hive运行所需目录：
$ hadoop dfs -mkdir /tmp/hive $ hadoop dfs -mkdir /user/hive/warehouse $ hadoop dfs -chmod a+w /tmp/hive $ hadoop dfs -chmod a+w /user/hive/warehouse
设置配置文件。配置文件位于/usr/apache-hive-0.14.0-bin/conf中，名为hive-site.xml：
<configuration>
<property>
<name>hive.metastore.warehouse.dir</name>
<value>hdfs://localhost:9000/user/hive/warehouse</value>
<description>location of default database for the warehouse</description>
</property>
</configuration>
在命令行下输入“hive”，如果能够进入Hive的shell界面，则表示Hive已经可以使用。
# hive
使用Hive QL访问数据
｛占位符｝
实现Hive与Java的整合
使用Hive的JDBC接口访问Hadoop数据，需要额外提供以下Hadoop和Hive库文件。
Hadoop JAR文件（位于$HADOOP_HOME/lib/目录下）：
hadoop-core-1.2.1.jar
slf4j-api-1.4.3.jar
slf4j-log4j12-1.4.3.jar
log4j-1.2.15.jar:.
Hive JAR文件（位于$HIVE_HOME/lib/目录下）
hive-jdbc-0.14.0.jar
hive-exec-0.14.0.jar
hive-metastore-0.14.0.jar
hive-service-0.14.0.jar
libfb303-0.9.0.jar
commons-logging-1.1.3.jar
libthrift-0.9.0.jar
8 public class HiveJdbcTest { 9 private static String driverName = "org.apache.hadoop.hive.jdbc.HiveDriver"; 10 private static final String HOST = "192.168.1.106:10021"; 11 private static final String URL = "jdbc:hive://" + HOST + "/default"; 12 13 public static void main(String[] args) throws Exception { 14 Class.forName(driverName); 15 Connection conn = DriverManager.getConnection(URL, "", ""); 16 Statement stmt = conn.createStatement(); 17 18 String sql = "SELECT * FROM st"; 19 System.out.println(sql); 20 ResultSet res = stmt.executeQuery(sql); 21 while (res.next()) { 22 System.out.println(res.getString(1) + " \t" + res.getString(2) + '\t' + 23 res.getInt(3) + '\t' + res.getString(4)); 24 } 25 26 sql = "select id, name, score from st where class='class2'"; 27 System.out.println(sql); 28 res = stmt.executeQuery(sql); 29 while (res.next()) { 30 System.out.println(res.getString("id") + " \t" + 31 res.getString("name") + '\t' + res.getInt("score")); 32 } 33 34 sql = "select class, count(*) from st group by class"; 35 System.out.println(sql); 36 res = stmt.executeQuery(sql); 37 while (res.next()) { 38 System.out.println(res.getString(1) + '\t' + res.getInt(2)); 39 } 40 41 res.close(); 42 stmt.close(); 43 conn.close(); 44 } 45 }
无限大表数据库HBase
HBase工作原理
HBase是Google Big Table的Java实现。
HBase表的特点：
大：一个表可以有上亿行，上百万列
面向列：面向列(族)的存储和权限控制，列(族)的独立检索
稀疏：对于为空(null)的列，不占存储空间
安装和使用HBase
HBase和Hadoop一样支持三种运行模式：单机模式、伪分布模式和完全分布模式。
HBase包下载URL
http://www.apache.org/dyn/closer.cgi/hbase/
本课程使用的是hbase-0.98.9-hadoop1-bin.tar.gz
解压下载的hive安装包到指定目录，例如：/usr
[root@localhost usr]$ tar -zxvf hbase-0.98.9-hadoop1-bin.tar.gz
配置环境变量
编辑hbase-0.98.9-hadoop1/conf/hbase-env.sh
export JAVA_HOME=/usr/jdk1.7.0_71/
export HBASE_CLASSPATH=/usr/hadoop-1.2.1/conf
创建HBase工作目录
Hadoop dfs –mkdir hbase
配置HBase在伪分布式模式模式下运行
配置hbase-0.98.9-hadoop1/conf/hbase-site.xml
<configuration> <property> <name>hbase.rootdir</name> <value>hdfs://localhost:9000/hbase</value> </property> <property> <name>hbase.cluster.distributed</name> <value>true</value> </property> <property> <name>hbase.zookeeper.property.clientPort</name> <value>2222</value> <description>Property from ZooKeeper's config zoo.cfg. The port at which the clients will connect. </description> </property> <property> <name>hbase.zookeeper.property.dataDir</name> <value>/home/hadoop/zookeeper</value> </property> </configuration>
启动HBase
[hadoop@localhost bin]$ ./start-hbase.sh localhost: starting zookeeper, logging to /home/hadoop/hbase-0.98.9-hadoop1/bin/../logs/hbase-hadoop-zookeeper-localhost.localdomain.out starting master, logging to /home/hadoop/hbase-0.98.9-hadoop1/bin/../logs/hbase-hadoop-master-localhost.localdomain.out localhost: starting regionserver, logging to /home/hadoop/hbase-0.98.9-hadoop1/bin/../logs/hbase-hadoop-regionserver-localhost.localdomain.out [hadoop@localhost bin]$ jps 4795 Jps 4587 HMaster 4742 HRegionServer 4530 HQuorumPeer
YARN架构数据处理
Hadoop 1.x和YARN
Hadoop 1.x只支持MapReduce计算框架，它的主要优势是对大规模数据进行批量处理，但不能解决所有的问题，还有许多其他计算场景，与之对应的也出现了许多计算框架，比如流式计算的Storm、迭代计算的Spark、以及图计算的Giraph，这就要求Hadoop支持除MapReduce之外的更多的框架
YARN对MapReduce架构的的重构主要是JobTracker的两个主要功能分离成单独的组件：
资源管理
任务调度、监控
YARN架构
YARN架构中的角色
ResourceManager：负责Job的调度、管理，资源的分配、管理的模块。它所管理的单位是Job(更为通用的叫法是Application)，不再是具体的Task，因此能比传统的MapReduce支持更大规模的集群
NodeManager：负责执行具体Task的模块。它不再有Slots的概念，取而代之的Container，Task都是通过在NodeManager上启动Container的方式来执行的；
ApplicationMaster：由YARN框架提供的一个Libary，每个用户Application(Job)会对应一个ApplicationMaster，在用户提交Application后，ResourceManager会启动该Application对应的ApplicationMaster, 并把ApplicationMaster的地址反馈给客户端，后续客户端直接跟ApplicationMaster进行交互。ApplicatoinMaster负责向ResourceManager申请执行用户Task所需要的资源，以及管理用户Application中每一个Task的运行情况；
Container：抽象出来的资源集合的概念，它代表由ResouceManage授予给Application的资源，包括CPU、内存等。最终用户Task都是通过Container来执行的；
浙公网安备 33010602011771号