Apache Hadoop 工具

一、生态工具

（一）Hive技术

1.什么是Hive

hive是facebook开源，并捐献给了apache组织，作为apache组织的顶级项目。 hive.apache.org
hive是一个基于大数据技术的数据仓库技术 DataWareHouse (数仓)
数据库 DataBase
数据量级小，数据价值高
数据仓库 DataWareHouse
数据体量大，数据价值低
底层依附是HDFS,MapReduce

2.Hive好处

Hive让程序员应用时，书写SQL语句，最终由Hive把SQL语句转换成MapReduce运行，这样简化了程序员的工作。

3.Hive运行原理

4.Hive环境的搭建

1. linux服务器  ip 映射  主机名  关闭防火墙  关闭selinux  ssh免密登陆 jdk
2. 搭建hadoop环境
3. 安装Hive
3.1 解压缩hive 
3.2 hive_home/conf/hive-env.sh [改名]
   HADOOP_HOME=/opt/install/hadoop-2.5.2
   export HIVE_CONF_DIR=/opt/install/apache-hive-0.13.1-bin/conf
3.2 hdfs创建2个目录
   /tmp
   /user/hive/warehouse
   bin/hdfs dfs -mkdir /tmp
   bin/hdfs dfs -mkdir /user/hive/warehouse
3.3 启动hive
   bin/hive 
3.4 jps
   runjar

5. Hive基本操作

# 创建数据库
create database [if not exists] baizhi_150;
# 查看所有数据库
show databases;
# 使用数据库
use db_name;
# 删除空数据库 
drop database db_name;
drop database db_name cascade;
# 查看数据库的本质
hive中的数据库 本质是 hdfs的目录 /user/hive/warehouse/baizhi_150.db

# 查看当前数据库下的所有表
show tables;
# 建表语句
create table t_user(
id int ,
name string
)row format delimited fields terminated by '\t';
# 查看表的本质
hive中的表  本质是 hdfs的目录 /user/hive/warehouse/baizhi_150.db/t_user
# 删除表
drop table t_user;

# hive中向表导入数据
load data local inpath '/root/hive/data' into table t_user;
# hive导入数据的本质
load data local inpath '/root/hive/data' into table t_user;
1. 导入数据 本质本质上就是 hdfs 上传文件
bin/hdfs dfs -put /root/hive/data /user/hive/warehouse/baizhi_150.db/t_user;
2. 上传了重复数据，hive导数据时，会自动修改文件名
3. 查询某一个张表时，Hive会把表中这个目录下所有文件的内容，整合查询出来


# SQL(类SQL 类似于SQL HQL Hive Query Language)
select * from t_user;
select id from t_user;
1. Hive把SQL转换成MapReduce (如果清洗数据 没有Reduce)
2. Hive在绝大多数情况下运行MR,但是在* limit操作时不运行MR

6.MetaStore的替换问题

Hive中的MetaStore把HDFS对应结构，与表对应结果做了映射（对应）。但是默认情况下hive的metaStore应用的是derby数据库，只支持一个client访问。

1. Hive中元数据库Derby替换成MySQL(Oracle)

0. 删除hdfs /user/hive/warehouse目录，并重新建立
1. linux mysql
  yum -y install mysql-server
2. 启动mysql服务并设置管理员密码
  service mysqld start
  /usr/bin/mysqladmin -u root password '123456'
3. 打开mysql远程访问权限
  GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY '123456';
  flush privileges;   
  use mysql 
  delete from user where host like 'hadoop%';
  delete from user where host like 'l%';
  delete from user where host like '1%';
  service mysqld restart
4. 创建conf/hive-site.xml
  mv hive-default.xml.template hive-site.xml
  hive-site.xml
  <property>
  <name>javax.jdo.option.ConnectionURL</name>
  <value>jdbc:mysql://hadoop21.baizhiedu.com:3306/metastore?createDatabaseIfNotExist=true</value>
  <description>the URL of the MySQL database</description>
</property>

<property>
  <name>javax.jdo.option.ConnectionDriverName</name>
  <value>com.mysql.jdbc.Driver</value>
  <description>Driver class name for a JDBC metastore</description>
</property>

<property>
  <name>javax.jdo.option.ConnectionUserName</name>
  <value>root</value>
</property>

<property>
  <name>javax.jdo.option.ConnectionPassword</name>
  <value>123456</value>
</property>
5. hive_home/lib 上传mysql driver jar包

7.Hive的语法细节

1. HQL (SQL)

1. 基本查询
select * from table_name # 不启动mr
select id from table_name # 启动mr
2. 条件查询 where
select id,name from t_users where name = 'suns1';
2.1 比较查询  =  ！=  >=  <=
   select id,name from t_users where age > 20;
2.2 逻辑查询  and or  not
   select id,name,age from t_users where name = 'suns' or age>30;
2.3 谓词运算
   between and
   select name,salary from t_users where salary between 100 and 300;
   in
   select name,salary from t_users where salary in (100,300);
   is null
   select name,salary from t_users where salary is null;
   like
   select name,salary from t_users where name like 'suns%';
   select name,salary from t_users where name like 'suns__';
   select name,salary from t_users where name like 'suns%' and length(name) = 6;
3. 排序 order by [底层使用的是 map sort  group sort  compareto]
select name,salary from t_users order by salary desc;
4. 去重 distinct
select distinct(age) from t_users;
5. 分页 [Mysql可以定义起始的分页条目，但是Hive不可以]
select * from t_users limit 3;  
6. 聚合函数（分组函数） count() avg() max() min() sum() 
count(*)  count(id) 区别
7. group by
select max(salary) from t_users group by age;
规矩： select 后面只能写 分组依据和聚合函数 （Oracle报错，Mysql不报错，结果不对）
8. having 
分组后，聚合函数的条件判断用having
select max(salary) from t_users group by age having max(salary) > 800;
9. hive不支持子查询 
10. hive内置函数 
show functions 

length(column_name)  获得列中字符串数据长度
substring(column_name,start_pos,total_count)
concat(col1,col2)
to_data('yyyy-mm-dd')
year(data) 获得年份
month(data)
date_add
....
select year(to_date('1999-10-11')) ;
11. 多表操作
inner join
select e.name,e.salary,d.dname
from t_emp as e
inner join t_dept as d
on e.dept_id = d.id;

select e.name,e.salary,d.dname
from t_emp as e
left join t_dept as d
on e.dept_id = d.id;

select e.name,e.salary,d.dname
from t_emp as e
right join t_dept as d
on e.dept_id = d.id;

select e.name,e.salary,d.dname [mysql 不支持]
from t_emp as e
full join t_dept as d
on e.dept_id = d.id; 

2. 表相关的操作

• 管理表 (MANAGED_TABLE)

1. 基本管理表的创建
create table if not exists table_name(
column_name data_type,
column_name data_type
)row format delimited fields terminated by '\t' [location 'hdfs_path']

2. as 关键字创建管理表
create table if not exists table_name as select id,name from t_users [location ''];
表结构 由 查询的列决定，同时会把查询结果的数据 插入新表中

3. like 关键字创建管理表
create table if not exists table_name like t_users [location 'hdfs_path'];
表结构 和 like关键字后面的表 一致，但是没有数据是空表

细节

1. 数据类型 int string varchar char double float boolean  
2. location hdfs_path
  定制创建表的位置，默认是 /user/hive/warehouse/db_name.db/table_name
  create table t_suns(
  id,int
  name,string
  )row format delimited fields terminated by '\t' location /xiaohei ;
  启示：先有hdfs目录，文件，再创建表进行操作。
3. 查看hive表结构的命令
  desc table_name        describe table_name
  desc extended table_name
  desc formatted table_name 

• 外部表

1. 基本
create external table if not exists table_name(
id int,
name string
) row delimited fields terminated by '\t' [location 'hdfs_path'];
2. as 
create external table if not exists table_name as select id,name from t_users [location ''];
3. like
create external table if not exists table_name like t_users [location 'hdfs_path'];

1. 管理表和外部表的区别
   drop table t_users_as; 删除管理表时，直接删除metastore,同时删除hdfs的目录和数据文件
   drop table t_user_ex; 删除外部表时，删除metastore的数据。
2. 外部表与管理表使用方式的区别
   

• 分区表 【查询优化】
  思想：如下图所示
  

create table t_user_part(
id int,
name string,
age int,
salary int)partitioned by (data string) row format delimited fields terminated by '\t';

load data local inpath '/root/data15' into table t_user_part partition (date='15');
load data local inpath '/root/data16' into table t_user_part partition (date='16');

select * from t_user_part  全表数据进行的统计

select id from t_user_part where data='15' and age>20;

8.数据的导入

1. 基本导入 【重点】

load data local inpath 'local_path' into table table_name

2. 通过as关键完成数据的导入【重点】

建表的同时，通过查询导入数据
create table if not exists table_name as select id,name from t_users

3. 通过insert的方式导入数据 【重点】

#表格已经建好，通过查询导入数据。
create table t_users_like like t_users;

insert into table t_users_like select id,name,age,salary from t_users;

4. hdfs导入数据 【了解】

load data inpath 'hdfs_path' into table table_name

5. 导入数据过程中数据的覆盖【了解】

load data inpath 'hdfs_path' overwrite into table table_name
本质 把原有表格目录的文件全部删除，再上传新的

6. 通过HDFS的API完成文件的上传【了解】

bin/hdfs dfs -put /xxxx  /user/hive/warehouse/db_name.db/table_name

9.数据的导出

1. sqoop 【重点】

hadoop的一种辅助工具  HDFS/Hive  <------> RDB (MySQL,Oracle)

2. insert的方式【了解】

#xiaohei一定不能存在，自动创建
insert overwrite 【local】 directory '/root/xiaohei' select name from t_user; 

3. 通过HDFS的API完成文件的下载【了解】

bin/hdfs dfsd -get /user/hive/warehouse/db_name.db/table_name /root/xxxx

4. 命令行脚本的方式【了解】

bin/hive --database 'baizhi_150' -f /root/hive.sql > /root/result

5. Hive提供导入，导出的工具【了解】

1. export 导出
export table tb_name to 'hdfs_path'
2. import 导入
import table tb_name from 'hdfs_path'

10.Hive相关的配置参数

1. hive-default.xml 
2. hive-site.xml 

javax.jdo.option.ConnectionURL
javax.jdo.option.ConnectionDriverName
javax.jdo.option.ConnectionUserName
javax.jdo.option.ConnectionPassword
hive.cli.print.current.db
hive.cli.print.header

<property>
<name></name>
<value></value>
</property>

3. bin/hive --hiveconf hive.cli.print.current.db=false
4. hive>set hive.cli.print.current.db 查看参数
    set hive.cli.print.current.db=true; 设置参数

#与MR相关的参数
Map --> Split  ---> Block 
#reduce相关个数
mapred-site.xml
<property>
 <name>mapreduce.job.reduces</name>
 <value>1</value>
</property>
hive-site.xml
<!--1G-->
<property>
<name>hive.exec.reducers.bytes.per.reducer</name>
<value>1000000000</value>
</property>
<property>
 <name>hive.exec.reducers.max</name>
 <value>999</value>
</property>

<!--在查询中是否启动MR 是如下参数配置决定的 -->
<property>
<name>hive.fetch.task.conversion</name>
<value>minimal</value>
<description>
1. minimal : SELECT STAR, FILTER on partition columns, LIMIT only
2. more    : SELECT, FILTER, LIMIT only (TABLESAMPLE, virtual columns)
</description>
</property>

11.Hive相关的启动参数

1. 启动hive终端时，临时设置hive的配置参数
bin/hive --hiveconf
2. 启动hive时，指定启动的数据库
bin/hive --database baizhi_150
3. 启动hive时，可以执行sql命令，执行完毕后，退出
bin/hive -e 'sql'
bin/hive --database baizhi_150 -e 'sql'
bin/hive --database baizhi_150 -e 'select * from t_user' > /root/result
bin/hive --database baizhi_150 -e 'select * from t_user' >> /root/result
4. 启动hive是，如果需要执行多条sql可以把sql写在一个独立的文件里，执行。完毕退出
bin/hive -f /root/hive.sql
bin/hive --database baizhi_150 -f /root/hive.sql > /root/result
bin/hive --database baizhi_150 -f /root/hive.sql >> /root/result

12.开发过程中，对于Hive使用的分析

（一）Hbase

1.Hbase的引言

1. 什么是HBase

hbase是Apache 组织开源的顶级项目 distributed, scalable, big data store 产品
hbase是基于Hadoop的一个NoSQL产品 Column类型的NoSQL
hbase是Google BigTable的开源实现, 爬虫爬取的网页
hbase运行亿级数据查询时，效率可达到秒级，毫秒级 在线处理 实时的处理

2. NoSQL特点

1. 部分NoSQL In-Memory 内存型 （Redis)
2. Schema-Less NoSchema 弱格式 无格式
3. 杜绝表连接
4. 弱化事务，没有事务 （Redis有事务，MongoDB(4.x 没事务 4.x后有事务了)
5. 搭建集群方便

3. NoSQL分类

1. key value 类型 redis
2. document 类型 mongodb
3. column 类型 HBase Cassandra
4. 图 类型 neo4j (金融 知识图谱)

2.Hbase存储的逻辑结构

3.Hbase伪分布式环境的搭建

1. hbase目前采用非CDH版搭建，作业CDH版搭建一次
2. Hmaster Hregionserver 

1. linux服务器 ip 主机名 主机映射 防火墙 selinux ssh免密 jdk
2. hadoop安装
2.1 解压缩
2.2 6个配置文件
2.3 格式化
2.4 启动进程
3. 安装zookeeper
3.1 解压缩
3.2 配置conf/zoo.cfg 
3.3 创建临时目录 data ---> myid文件（集群）
3.4 启动服务
4. hbase的安装
4.1 解压缩hbase
4.2 hdfs上创建 /hbase文件夹
            hbase_home/data/tmp文件夹
4.3 修改hbase相关的配置文件 
  env.sh
  export HBASE_MANAGES_ZK=false
  export JAVA_HOME=/usr/java/jdk1.7.0_71
  hbase-site.xml 
  <property >
<name>hbase.tmp.dir</name>
<value>/opt/install/hbase-0.98.6-hadoop2/data/tmp</value>
  </property>
  <property >
       <name>hbase.rootdir</name>
       <value>hdfs://hadoop31.baizhiedu.com:8020/hbase</value>
   </property>
   <property >
       <name>hbase.cluster.distributed</name>
       <value>true</value>
   </property>
   <property>
       <name>hbase.zookeeper.quorum</name>
       <value>hadoop31.baizhiedu.com</value>
   </property>
4.4 修改
  regionservers文件
  hadoop31.baizhiedu.com
4.5 替换hbase相关hadoop的jar
4.6 启动hbase
  bin/hbase-daemon.sh start master
  bin/hbase-daemon.sh start regionserver
4.7 网络访问
  http://hadoop31.baizhiedu.com:60010
  bin/hbase shell

4.Hbase的shell命令

1. help 帮助命令
help '命令名字'
2. hbase中数据库的概念
namespace 
2.1 显示所有的数据库 
list_namespace 
默认  default  
     hbase
2.2 显示当前数据库中所有的表
list_namespace_tables 'hbase'
2.3 创建一个数据库
create_namespace 'baizhi150'
2.4 描述数据库
describe_namespace 'baizhi150'
2.5 修改数据库
alter_namespace
2.6 删除数据库
drop_namespace 'baizhi150'
3. 创建hbase中的表【重点】
3.1 基本的建表方式 【默认default库中】
create 't1','cf1'
3.2 创建多个列簇【默认default库中】
create 't1','cf1','cf2'
3.3 指定表所属的数据库
create 'baizhi150:t1','cf1'
3.4 详细描述列簇的相关属性
create 'baizhi150:t2',{NAME=>'cf1',VERSIONS=>2},{NAME=>'cf2'}
4. 描述表 
describe 'baizhi150:t1'
5. 修改表
alter 'baizhi150:t2',{NAME=>'cf2',VERSIONS=>2}
6. 删除表
disable 'baizhi150:t2'
drop 'baizhi150:t2'
7. 失效 生效表相关命令
enable disable 
enable_all disable_all
is_enable is_disable
8. 判断表是否存在
exists 
9. 表的查找命令
list 'ns:t.*'
10. 插入数据
put 't1'，’rowkey‘,'family:qualify','value'
put 'ns:t1'，’rowkey‘,'family:qualify','value'
11. 删除数据
delete 'ns:t1' ,'rowkey','family:qualify','timestamp'
12. 全表扫描 
scan '表名'
scan 'ns1:tb1', {STARTROW => '20170521_10001',STOPROW => '20170521_10003'}
scan 'baizhi150:user',{STARTROW=>'001',STOPROW=>'004'}
不包括stoprow的值
13. 某条数据的查询
get 'baizhi150:user','001'
get 'baizhi150:user','001','base:name'

5.Hbase的集群的搭建

1. 时间同步集群

hadoop41.baizhiedu.com 作为时间同步服务器 主节点
1. yum install ntp 三台机器
2. service ntpd start 三台机器
chkconfig ntpd on
3. 服务器节点 主节点
ntpdate -u 202.112.10.36
vi /etc/ntp.conf
restrict 192.168.111.0 mask 255.255.255.0 nomodify notrap
# 中国这边最活跃的时间服务器 : http://www.pool.ntp.org/zone/cn
server 210.72.145.44 perfer      # 中国国家受时中心
server 202.112.10.36             # 1.cn.pool.ntp.org
server 59.124.196.83             # 0.asia.pool.ntp.org

# 允许上层时间服务器主动修改本机时间
restrict 210.72.145.44 nomodify notrap noquery
restrict 202.112.10.36 nomodify notrap noquery
restrict 59.124.196.83 nomodify notrap noquery

# 外部时间服务器不可用时，以本地时间作为时间服务
server  127.127.1.0     # local clock
fudge   127.127.1.0 stratum 10
service ntpd restart

4. client端
vi /etc/ntp.conf
server 192.168.111.41 #这里指的是ntp服务的ip 192.168.206.130
restrict 192.168.111.41 nomodify notrap noquery

server  127.127.1.0     # local clock
fudge   127.127.1.0 stratum 10
5. 三台机器 service ntpd restart
6. 从节点同步主节点时间 ntpdate -u 192.168.184.16
adjust time server 192.168.19.10 offset -0.017552 sec
5. date命令查看处理结果

2. Hadoop集群

HDFS集群
Yarn集群

3. Zookeeper集群

1. 解压缩
2. 创建数据文件夹
 zookeeper_home/data
3. 修改配置文件
 conf/zoo.cfg
 dataDir
 server.0 
4. 在data文件夹中创建 myid文件 0 1 2 
5. 启动服务

4. Hbase集群

1. 准备：hbase_home  data/tmp  logs目录中的内容清空
      hdfs 上面 hbase目录清空
2. 修改hbase_home/conf/hbase-env.sh
export JAVA_HOME=/usr/java/jdk1.7.0_71
export HBASE_MANAGES_ZK=false
3. hbase-site.xml
<property >
  <name>hbase.tmp.dir</name>
  <value>/opt/install/hbase-0.98.6-hadoop2/data/tmp</value>
</property>
<property >
  <name>hbase.rootdir</name>
  <value>hdfs://hadoop6.baizhiedu.com:8020/hbase</value>
</property>
<property >
  <name>hbase.cluster.distributed</name>
  <value>true</value>
</property>
<property>
<name>hbase.zookeeper.quorum</name>
<value>hadoop.baizhiedu.com,hadoop1.baizhiedu.com,hadoop2.baizhiedu.com</value>
</property>
4. regionservers
hadoop.baizhiedu.com
hadoop1.baizhiedu.com
hadoop2.baizhiedu.com
5. 替换jar hadoop jar
6. scp 分发
6. 启动hbase
bin/hbase-daemon.sh start master
bin/hbase-daemon.sh start regionserver

6.HBase的Java API

# java访问HBase的核心API
Configruation  HBase相关的配置 
Htable         HBase中的表
Put            插入数据 
Get            查询数据
Scan           扫描数据
BytesUtil      字节处理

<!-- https://mvnrepository.com/artifact/org.apache.hbase/hbase-client -->
<dependency>
  <groupId>org.apache.hbase</groupId>
  <artifactId>hbase-client</artifactId>
  <version>0.98.6-hadoop2</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.apache.hbase/hbase-server -->
<dependency>
  <groupId>org.apache.hbase</groupId>
  <artifactId>hbase-server</artifactId>
  <version>0.98.6-hadoop2</version>
</dependency>

对象	作用	基本用法
Configruation	Hbase相关的配置文件	conf.set(“key”,“value”);
HTable	Hbase中的表	表相关的操作都是HTable完成
Put	HBase中插入数据	Put put = new Put(rowkey) put.add HTable.put(put)
Delete	HBase中的删除操作	Delete delete = new Delete(rowkey) HTable.delete(delete)
Get	HBase查询单条数据	Get get = net Get(rowkey) HTable.get(get) —> Result
Result	单行数据	Result – Cells — Cell — cloneFamily cloneQualify cloneValue
Scan	表的扫描	ResultScanner —> Result

7.Hbase中的过滤器

1. 行键相关的过滤器

 1.比较行键值的大小
 Filter filter1 = new RowFilter(CompareFilter.CompareOp.GREATER, new
                 BinaryComparator(Bytes.toBytes("0003")));
 scan.setFilter(filter1); 
 2. 比较行键按照特定的规则设计
 Filter filter1 = new PrefixFilter(Bytes.toBytes("000"));
 scan.setFilter(filter1);

2. 列簇相关的筛选

 1. 只要base列簇相关的数据
 Filter filter1 = new FamilyFilter(CompareFilter.CompareOp.EQUAL, new
                 BinaryComparator(Bytes.toBytes("base"))); 
 scan.setFilter(filter1);

3. 限定符相关筛选

 Filter filter1 = new QualifierFilter(CompareFilter.CompareOp.EQUAL, new
 BinaryComparator(Bytes.toBytes("age")));

 scan.setFilter(filter1);

4. 值的筛选

Filter filter = new ValueFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator("1") );

scan.setFilter(filter);

5. 列簇中的数据进行筛选

SingleColumnValueFilter filter = new SingleColumnValueFilter(
                Bytes.toBytes("base"),
                Bytes.toBytes("sex"),
                CompareFilter.CompareOp.EQUAL,
                new SubstringComparator("male"));
          filter.setFilterIfMissing(true);
        //filter.setF·1···
        
        ilterIfMissing(false); //符合要求的数据 password=123456
                                          //column 中不包含password限定符 查询出来
        scan.setFilter(filter);
        

同时要排除password 限定符        
SingleColumnValueExcludeFilter filter = new SingleColumnValueExcludeFilter(
                Bytes.toBytes("base"),
                Bytes.toBytes("password"),
                CompareFilter.CompareOp.NOT_EQUAL,
                new SubstringComparator("66666"));
  filter.setFilterIfMissing(true);
        //filter.setFilterIfMissing(false); //符合要求的数据 password=123456
        //column 中不包含password限定符 查询出来
        scan.setFilter(filter);

6. FilterList

设置多个过滤器 同时生效
 FilterList filterList = new FilterList();

 Filter filter1 = new PrefixFilter(Bytes.toBytes("000"));

  SingleColumnValueFilter filter2 = new SingleColumnValueFilter(
                Bytes.toBytes("base"),
                Bytes.toBytes("password"),
                CompareFilter.CompareOp.EQUAL,
                new SubstringComparator("123456"));
  filter2.setFilterIfMissing(true);

  filterList.addFilter(filter1);
  filterList.addFilter(filter2);

  scan.setFilter(filterList);

8.HBase中列簇的相关属性

1. 创建HBase表
create 'table_name',{NAME=>'',VERSIONS=>''}
2. Hbase列簇的常见属性
# 列簇的名字
NAME='xxxxx'
# 列簇对应限定符 能存几个版本的数据
VERSIONS => '1'
# TTL Time To Live  
指定的是cell中的数据，存储在HBase中的存活时间 'FOREVER'
TTL => 100  
# 指定HBase上存储的数据 是否 启动压缩
COMPRESSION => 'NONE'
COMPRESSION => 'snappy'
# 列簇中的数据，存储在内存中，提高查询效率 （默认关闭）
IN_MEMORY => 'false’ 
# 缓存 列簇部分数据，从而提高查询效率
BLOCKCACHE => 'true'
# Block是列簇中存储数据的最小单位
BLOCKSIZE => '65536'
调整大   顺序查询  需求高
调整小   随机查询  需求高 
# 提高查询效率
BLOOMFILTER 布隆过滤

9.HBase的体系结构

1. RegionServer 【重点】

2. HMaster作用

1. HRegionServer 集群是否健康 
2. Region---RegionServer分配
3. 新Region加入后，负载均衡

3. Zookeeper作用 【重点】

1. 管理HMaster的高可用
2. 存储了HBase中非常重要的信息  meta信息
 rowkey 范围  ---- region  ---- RegionServer(健康)

4. HBase compact 和 split

10.RowKey设计

1. HBase相关的查询操作，95%上都是对RowKey查询。
2. 设计过程 
2.1 复合
2.2 查询内容作为rowkey组成
3. rowkey 64K 10--100字节唯一
4. rowkey结合自己的实际需求
4.1  区域查询多，建议 rowkey 连续    
4.4  区域查询少，散列 hash ---> 加密、UUID

System.out.println(UUID.randomUUID().toString());
String rowkey = "suns_male_130";
String result = DigestUtils.md5Hex(rowkey);
System.out.println(result);

11.HBase优化策略

1. 解决热点效应

1. 预分区
 在创建表时，不按照默认的策略，为表只创建一个Region,而是根据需要，为一张表创建多个Region,从而避免热点效应
2. 预分区的依据 
 基于Rowkey进行预分区
3. 语法：
 3.1 create 't1', 'f1', SPLITS => ['10', '20', '30', '40']
 3.2 create 't1', 'f1', SPLITS_FILE => 'splits.txt'
     splits.txt
     10
     20
     30
     40
 3.3 create 't2', 'f1', {NUMREGIONS => 15, SPLITALGO => 'HexStringSplit'}
4. 根本上解决热点问题需要注意如下几点
 1. 预分区
 2. rowkey设置
 综上2者尽量解决热点问题。

2. 如何提高检索效率

1. rowkey 相对连续 那么检索效率一定高 （顺序查询 scan操作）
2. 设置Memstore大小 ， Block Cache大小 
 hbase-site.xml 设置 
 
 hbase.hregion.memstore.flush.size  128M  每一个memstore达到128M flush 
 hbase.regionserver.global.memstore.size 0.4 堆空间的40% （regionserver占用JVM 对空间）
 1. 让数据尽可能多的放置在内存中，提高检索效率
 2. 避免flush memstore 阻塞client操作
 hbase.regionserver.global.memstore.size.lower.limit 当全局flush到 memstore用量达95%不在flush
 
 hfile.block.cache.size 0.4
3. hbase内部的块数据索引，布隆过滤器

3. JVM参数配置

1. JVM Java进程 
2. JVM (堆空间) HBase
 新生代 1/3                             老年代 2/3  永久代（静态，常量）
 eden survivor(from)  survivor(to)
  8      1                1
 ParNewGC                              ConcMarkSweepGC
 ”-Xmx8g -Xms8G -Xmn128m -XX:UseParNewGC  -XX:UseConcMarkSweepGC -   XX:CMSInitiatingOccupancyFraction=70  -verbose:gc -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xloggc:$HBASE_HOME/logs/gc-${hostname}-hbase.log”

 hbase-env.sh
 export HBASE_REGIONSERVER_OPTS=”-Xmx8g -Xms8G  -Xmn128m -XX:UseParNewGC     -XX:UseConcMarkSweepGC -XX:CMSInitiatingOccupancyFraction=70  -verbose:gc -XX:+PrintGCDetails -XX:+PrintGCTimeStamps    -Xloggc:$HBASE_HOME/logs/gc-${hostname}-hbase.log”

4. mslab

1. 防止内存碎片，内存碎片过多，内存泄露，发生FullGC,导致STW.
hbase.hregion.memstore.mslab.enabled  true
hbase.hregion.memstore.mslab.chunksize  2M -->  4,5M 6M 

5. 自动化处理的功能变成手工处理

结合定时，shell脚本 完成处理
hbase tools 手工操作 compact split

test.sh
/opt/install/hbase-0.98.6-hadoop2/bin/hbase shell /root/hbase/test

12.HBase与MapReduce的集成

1. Hbase为什么需要和MR集成？

HBase数据的迁移。

2. MR改如何与HBase集成

hadoop-env.sh 
export HADOOP_CLASSPATH=$HADOOP_CLASSPATH:/opt/install/hbase-0.98.6-hadoop2/lib/*

二、辅助工具

（一）Sqoop(CDH)

1. Hadoop(CDH)

1. ip 主机名 映射 防火墙 selinux  jdk  ssh 
2. hadoop解压缩
3. 修改hadoop相关配置文件
hadoop-env.sh
core-site.xml
hdfs-site.xml
mapred-site.xml
yarn-site.xml
slaves
4. 解压缩cdh5.3.6-snappy-lib-natirve.tar.gz 替换 hadoop中的native文件的内容
解决的是64操作系统兼容的问题
5. 格式化
bin/hdfs namenode -format
6. 启动进程 4个进程

2. Hive(CDH)

1. 解压缩hive
2. 修改hive_home/conf/hive-env.sh 
hadoop_home
hive_conf_dir
hive-site.xml  修改metastore 预先安装mysql 
3. 上传mysql驱动jar 
4. hdfs 创建2个目录 /tmp  /user/hive/warehouse
5. 启动hive

3. Sqoop（CDH)

1. 解压缩 sqoop 
2. 配置 sqoop_home/conf
sqoop-env.sh
export HADOOP_COMMON_HOME=/opt/install/hadoop-2.5.0-cdh5.3.6
export HADOOP_MAPRED_HOME=/opt/install/hadoop-2.5.0-cdh5.3.6
export HIVE_HOME=/opt/install/hive-0.13.1-cdh5.3.6
3. 导入驱动jar
4. 测试
bin/sqoop list-databases -connect jdbc:mysql://hadoop22.baizhiedu.com:3306 -username root -password 123456

4. Sqoop语法详解

(1)语法格式

1. 
bin/sqoop list-databases -connect jdbc:mysql://hadoop22.baizhiedu.com:3306 -username root -password 123456

2. 推荐
bin/sqoop list-databases \
--connect \
jdbc:mysql://hadoop22.baizhiedu.com:3306 \
--username root \
--password 123456 

(2)Import导入 （MySQL ----> HDFS/Hive)

1. 准备

mysql的数据
create database sqoop

create table mysql_user(
id int primary key,
name varchar(12)
);
insert into mysql_user values (1,'suns1');
insert into mysql_user values (2,'suns2');
insert into mysql_user values (3,'suns3');
insert into mysql_user values (4,'suns4');
insert into mysql_user values (5,'suns5');

2. 基本导入HDFS

bin/sqoop import \
--connect \
jdbc:mysql://hadoop22.baizhiedu.com:3306/sqoop \
--username root \
--password 123456 \
--table mysql_user

#hdfs的位置？默认导入hdfs的位置：/user/root/mysql_user
                         /user/${username}/${table_name}
#sqoop导数据时，所运行的mapreduce 没有reduce只有map
#为什么sqoop导数据时，split是5 对应5个map?
Text  --- TextInputFormat ---- block --- split --- map
DB    --- DBInputFormat --- 一行 --- 一个split -- 一个map
#输出的文件内容中，列的分隔符默认是，

# 自定义mysql 导入 hdfs目录 /sqoop
bin/sqoop import \
--connect \
jdbc:mysql://hadoop22.baizhiedu.com:3306/sqoop \
--username root \
--password 123456 \
--table mysql_user \
--target-dir /sqoop

# 在目标目录存在的情况下，sqoop自动删除
bin/sqoop import \
--connect \
jdbc:mysql://hadoop22.baizhiedu.com:3306/sqoop \
--username root \
--password 123456 \
--table mysql_user \
--target-dir /sqoop \
--delete-target-dir

# 指定map的个数
bin/sqoop import \
--connect \
jdbc:mysql://hadoop22.baizhiedu.com:3306/sqoop \
--username root \
--password 123456 \
--table mysql_user \
--target-dir /sqoop \
--num-mappers 1 \
--delete-target-dir

# 指定列分割符
bin/sqoop import \
--connect \
jdbc:mysql://hadoop22.baizhiedu.com:3306/sqoop \
--username root \
--password 123456 \
--table mysql_user \
--target-dir /sqoop \
--num-mappers 1 \
--delete-target-dir \
--fields-terminated-by '\t'

# 增量导入数据
--check-column <column>        Source column to check for incremental    id
--last-value <value>           Last imported value in the incremental    5
--incremental <import-type>    Define an incremental import of type     append
                           'append' or 'lastmodified'
                           
# 一定不要加入 --delete-target-dir

bin/sqoop import \
--connect \
jdbc:mysql://hadoop22.baizhiedu.com:3306/sqoop \
--username root \
--password 123456 \
--table mysql_user \
--target-dir /sqoop \
--num-mappers 1 \
--fields-terminated-by '\t' \
--check-column id \
--last-value 5 \
--incremental append

# 快速导入模式
bin/sqoop import \
--connect \
jdbc:mysql://hadoop22.baizhiedu.com:3306/sqoop \
--username root \
--password 123456 \
--table mysql_user \
--target-dir /sqoop \
--num-mappers 1 \
--delete-target-dir \
--direct
--fields-terminated-by '\t'

原理： 非快速模式 数据的导入 jdbc
  快速 使用的是mysql提供 export import工具
注意： sqoop如果和mysql 安装在不同的机器中 ，使用快速导入 默认报错。

# import hive表
#--hive-import \
#--hive-database baizhi125 \
#--hive-table t_user \

bin/sqoop import \
--connect \
jdbc:mysql://hadoop22.baizhiedu.com:3306/sqoop \
--username root \
--password 123456 \
--table mysql_user \
--delete-target-dir \
--hive-import \
--hive-database baizhi_150 \
--hive-table t_user \
--num-mappers 1 \
--fields-terminated-by '\t'

(3)Export (HDFS/Hive —> MySQL)

create table to_mysql(
id int,
name varchar(50)
);

1. hdfs------>mysql
bin/sqoop export \
--connect \
jdbc:mysql://hadoop22.baizhiedu.com:3306/sqoop \
--username root \
--password 123456 \
--table to_mysql \
--export-dir /sqoop \
--num-mappers 1 \
--input-fields-terminated-by ','

2. hive ------->mysql
bin/sqoop export \
--connect \
jdbc:mysql://hadoop22.baizhiedu.com:3306/sqoop \
--username root \
--password 123456 \
--table to_mysql \
--export-dir /user/hive/warehouse/baizhi_150.db/t_user \
--num-mappers 1 \
--input-fields-terminated-by ','

(4) 脚本化的sqoop

# 脚本化的目的：复用sqoop导入 导出命令
1. file文件
1.1 创建一个Sqoop文件 普通文件 sqoop.file
export
--connect
jdbc:mysql://hadoop22.baizhiedu.com:3306/sqoop
--username
root
--password
123456
--table
to_mysql
--export-dir
/sqoop
--num-mappers 1
--input-fields-terminated-by
','

1.2 
bin/sqoop --options-file /root/sqoop.file 

2. job作业
1.1 创建job作业
bin/sqoop job \
--create test_job1 \
-- \
export \
--connect \
jdbc:mysql://hadoop22.baizhiedu.com:3306/sqoop \
--username root \
--password 123456 \
--table to_mysql \
--export-dir /sqoop \
--num-mappers 1 \
--input-fields-terminated-by ','

1.2
bin/sqoop job --exec test_job1

1.3 问题 每一次输入密码 不利于自动化处理 所以定密码的存储文件

echo -n "123456"  >> /root/password

bin/sqoop job \
--create test_job2 \
-- \
export \
--connect \
jdbc:mysql://hadoop22.baizhiedu.com:3306/sqoop \
--username root \
--password-file file:///root/password \
--table to_mysql \
--export-dir /sqoop \
--num-mappers 1 \
--input-fields-terminated-by ','

# export_mysql.sh
/opt/install/sqoop-1.4.5-cdh5.3.6/bin/sqoop job --exec test_job2

(5) 定时处理

1. 安装crontab 
2. crontab -e 
编辑配置文件
minute   hour   day   month   week   command 

*/5 * * * * command
*/1 * * * * echo 'suns' >> /root/sunshuai
*/1 * * * * /opt/install/sqoop-1.4.5-cdh5.3.6/bin/sqoop job --exec test_job2

3. 启动关闭服务
/sbin/service crond start
/sbin/service crond stop

ps -ef | grep cron

基本格式 :
* *　 *　 *　 *　　command
分　时　日　月　周　 命令

第1列表示分钟1～59 每分钟用*或者 */1表示
第2列表示小时1～23（0表示0点）
第3列表示日期1～31
第4列表示月份1～12
第5列标识号星期0～6（0表示星期天）
第6列要运行的命令

crontab文件的一些例子：

30 21 * * * /usr/local/etc/rc.d/lighttpd restart
上面的例子表示每晚的21:30重启apache。

45 4 1,10,22 * * /usr/local/etc/rc.d/lighttpd restart
上面的例子表示每月1、10、22日的4 : 45重启apache。

10 1 * * 6,0 /usr/local/etc/rc.d/lighttpd restart
上面的例子表示每周六、周日的1 : 10重启apache。

0,30 18-23 * * * /usr/local/etc/rc.d/lighttpd restart
上面的例子表示在每天18 : 00至23 : 00之间每隔30分钟重启apache。

0 23 * * 6 /usr/local/etc/rc.d/lighttpd restart
上面的例子表示每星期六的11 : 00 pm重启apache。

* */1 * * * /usr/local/etc/rc.d/lighttpd restart
每一小时重启apache

* 23-7/1 * * * /usr/local/etc/rc.d/lighttpd restart
晚上11点到早上7点之间，每隔一小时重启apache

0 11 4 * mon-wed /usr/local/etc/rc.d/lighttpd restart
每月的4号与每周一到周三的11点重启apache

0 4 1 jan * /usr/local/etc/rc.d/lighttpd restart
一月一号的4点重启apache

*/30 * * * * /usr/sbin/ntpdate 210.72.145.44
每半小时同步一下时间