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来执行的;