HBase學習筆記

時間  2021-02-18
標籤 html java node mysql linux web 算法 sql shell 數據庫 欄目 Hadoop 简体版
原文   原文鏈接

目錄

1、HBaes介紹

一、HBase簡介

  HBase是一個分佈式的、面向列的開源數據庫，它是一個適合於非結構化數據存儲的數據庫。另外一個不一樣的是HBase基於列的而不是基於行的模式。
  大：上億行、百萬列
  面向列：面向列（族）的存儲和權限控制，列（簇）獨立檢索
  稀疏：對於爲空(null)的列，並不佔用存儲空間，所以，表的設計的很是的稀疏html

二、HBase的角色

2.一、HMaster

  功能：
  1) 監控RegionServer
  2) 處理RegionServer故障轉移
  3) 處理元數據的變動
  4) 處理region的分配或移除
  5) 在空閒時間進行數據的負載均衡
  6) 經過Zookeeper發佈本身的位置給客戶端java

2.二、HRegionServer

  功能：
  1) 負責存儲HBase的實際數據
  2) 處理分配給它的Region
  3) 刷新緩存到HDFS
  4) 維護HLog
  5) 執行壓縮
  6) 負責處理Region分片node

  組件：mysql

    1. Write-Ahead logs
        HBase的修改記錄，當對HBase讀寫數據的時候，數據不是直接寫進磁盤，它會在內存中保留一段時間（時間以及數據量閾值
      能夠設定）。但把數據保存在內存中可能有更高的機率引發數據丟失，爲了解決這個問題，數據會先寫在一個叫作Write-Ahead logfile的文件中，而後再寫入內存中。因此在系統出現故障的時候，數據能夠經過這個日誌文件重建。
    1. HFile
        這是在磁盤上保存原始數據的實際的物理文件，是實際的存儲文件。
    1. Store
        HFile存儲在Store中，一個Store對應HBase表中的一個列簇。
    1. MemStore
        顧名思義，就是內存存儲，位於內存中，用來保存當前的數據操做，因此當數據保存在WAL中以後，RegsionServer會在內存中存儲鍵值對。
    1. Region

  Hbase表的分片，HBase表會根據RowKey值被切分紅不一樣的region存儲在RegionServer中，在一個RegionServer中能夠有多個不一樣的region。linux

三、HBase的架構

  一個RegionServer能夠包含多個HRegion，每一個RegionServer維護一個HLog，和多個HFiles以及其對應的MemStore。RegionServer運行於DataNode上，數量能夠與DatNode數量一致，請參考以下架構圖：web

四、HBase數據模型

  肯定一個單元格的位置（cell），須要以下四個算法

  rowkey + Colume Family + Colume + timestamp(版本version)，數據有版本的概念，即一個單元格可能有多個值，可是隻有最新得一個對外顯示。sql

  • HBase中有兩張特殊的Table，-ROOT-和.META.
  • .META.：記錄了用戶表的Region信息，.META.能夠有多個region
  • -ROOT-：記錄了.META.表的Region信息，-ROOT-只有一個region
  • Zookeeper中記錄了-ROOT-表的location
  • Client訪問用戶數據以前須要首先訪問zookeeper，而後訪問-ROOT-表，接着訪問.META.表，最後才能找到用戶數據的位置去訪問，中間須要屢次網絡操做，不過client端會作cache緩存，注意：在0.96版本後，Hbase移除了-ROOT-表

Row Key:
行鍵，Table的主鍵，Table中的記錄默認按照Row Key升序排序shell

Timestamp:
時間戳，每次數據操做對應的時間戳，能夠看做是數據的version number數據庫

Column Family：
列簇，Table在水平方向有一個或者多個Column Family組成，一個Column Family中能夠由任意多個Column組成，即Column Family支持動態擴展，無需預先定義Column的數量以及類型，全部Column均以二進制格式存儲，用戶須要自行進行類型轉換。

Table & Region:
當Table隨着記錄數不斷增長而變大後，會逐漸分裂成多份splits，成爲regions，一個region由[startkey,endkey)表示，不一樣的region會被Master分配給相應的RegionServer進行管理：.

HMaster：
HMaster沒有單點問題，HBase中能夠啓動多個HMaster，經過Zookeeper的Master Election機制保證總有一個Master運行，HMaster在功能上主要負責Table和Region的管理工做：1. 管理用戶對Table的增、刪、改、查操做。2. 管理HRegionServer的負載均衡，調整Region分佈。3. 在Region Split後，負責新Region的分配。4. 在HRegionServer停機後，負責失效HRegionServer 上的Regions遷移

HRegionServer：
HRegionServer內部管理了一系列HRegion對象，每一個HRegion對應了Table中的一個Region，HRegion中由多個HStore組成。每一個HStore對應了Table中的一個Column Family的存儲，能夠看出每一個Column Family其實就是一個集中的存儲單元，所以最好將具有共同IO特性的column放在一個Column Family中，這樣最高效。

MemStore & StoreFiles
HStore存儲是HBase存儲的核心了，其中由兩部分組成，一部分是MemStore，一部分是StoreFiles。MemStore是Sorted Memory Buffer，用戶寫入的數據首先會放入MemStore，當MemStore滿了之後會Flush成一個StoreFile（底層實現是HFile），當StoreFile文件數量增加到必定閾值，會觸發Compact合併操做，將多個StoreFiles合併成一個StoreFile，合併過程當中會進行版本合併和數據刪除，所以能夠看出HBase其實只有增長數據，全部的更新和刪除操做都是在後續的compact過程當中進行的，這使得用戶的寫操做只要進入內存中就能夠當即返回，保證了HBase I/O的高性能。當StoreFiles Compact後，會逐步造成愈來愈大的StoreFile，當單個StoreFile大小超過必定閾值後，會觸發Split操做，同時把當前Region Split成2個Region，父Region會下線，新Split出的2個孩子Region會被HMaster分配到相應的HRegionServer上，使得原先1個Region的壓力得以分流到2個Region上。

HLog
每一個HRegionServer中都有一個HLog對象，HLog是一個實現Write Ahead Log的類，在每次用戶操做寫入MemStore的同時，也會寫一份數據到HLog文件中，HLog文件按期會滾動出新的，並刪除舊的文件（已持久化到StoreFile中的數據）。當HRegionServer意外終止後，HMaster會經過Zookeeper感知到，HMaster首先會處理遺留的 HLog文件，將其中不一樣Region的Log數據進行拆分，分別放到相應region的目錄下，而後再將失效的region從新分配，領取 到這些region的HRegionServer在Load Region的過程當中，會發現有歷史HLog須要處理，所以會Replay HLog中的數據到MemStore中，而後flush到StoreFiles，完成數據恢復。

文件類型
HBase中的全部數據文件都存儲在Hadoop HDFS文件系統上，主要包括上述提出的兩種文件類型：

  1. HFile， HBase中KeyValue數據的存儲格式，HFile是Hadoop的二進制格式文件，實際上StoreFile就是對HFile作了輕量級包裝，即StoreFile底層就是HFile
    2.HLog File，HBase中WAL（Write Ahead Log） 的存儲格式，物理上是Hadoop的Sequence File

2、HBase部署與使用

一、部署

  • 1.一、Zookeeper正常部署

  首先保證Zookeeper集羣的正常部署，並啓動之：

/opt/module/zookeeper-3.4.5/bin/zkServer.sh start
  • 1.二、Hadoop正常部署

  Hadoop集羣的正常部署並啓動：

/opt/module/hadoop-2.8.4/sbin/start-dfs.sh
/opt/module/hadoop-2.8.4/sbin/start-yarn.sh
  • 1.三、HBase的解壓

  解壓HBase到指定目錄：

tar -zxf /opt/software/hbase-1.3.1-bin.tar.gz -C /opt/module/
  • 1.四、HBase的配置文件

  須要修改HBase對應的配置文件。
  hbase-env.sh修改內容：

export JAVA_HOME=/opt/module/jdk1.8.0_121
export HBASE_MANAGES_ZK=false
尖叫提示：若是使用的是JDK8以上版本，註釋掉hbase-env.sh的45-47行，否則會報警告

hbase-site.xml修改內容：

<property>  
		<name>hbase.rootdir</name>  
		<value>hdfs://bigdata111:9000/hbase</value>  
	</property>


	<property>
		<name>hbase.cluster.distributed</name>
		<value>true</value>
	</property>


	<property>
		<name>hbase.master.port</name>
		<value>16000</value>
	</property>


	<property>  
		<name>hbase.zookeeper.quorum</name>
		<value>bigdata111:2181,bigdata112:2181,bigdata113:2181</value>
	</property>


	<property>  
		<name>hbase.zookeeper.property.dataDir</name>
	 <value>/opt/module/zookeeper-3.4.10/zkData</value>
	</property>

<property>
<name>hbase.master.maxclockskew</name>
<value>180000</value>
</property>

regionservers：

bigdata111
bigdata112
bigdata113
  • 1.五、HBase須要依賴的Jar包(額外，不用配置)

  因爲HBase須要依賴Hadoop，因此替換HBase的lib目錄下的jar包，以解決兼容問題：
  1) 刪除原有的jar：

rm -rf /opt/module/hbase-1.3.1/lib/hadoop-*
rm -rf /opt/module/hbase-1.3.1/lib/zookeeper-3.4.10.jar

  2)拷貝新jar，涉及的jar有：

hadoop-annotations-2.8.4.jar
hadoop-auth-2.8.4.jar
hadoop-client-2.8.4.jar
hadoop-common-2.8.4.jar
hadoop-hdfs-2.8.4.jar
hadoop-mapreduce-client-app-2.8.4.jar
hadoop-mapreduce-client-common-2.8.4.jar
hadoop-mapreduce-client-core-2.8.4.jar
hadoop-mapreduce-client-hs-2.8.4.jar
hadoop-mapreduce-client-hs-plugins-2.8.4.jar
hadoop-mapreduce-client-jobclient-2.8.4.jar
hadoop-mapreduce-client-jobclient-2.8.4-tests.jar
hadoop-mapreduce-client-shuffle-2.8.4.jar
hadoop-yarn-api-2.8.4.jar
hadoop-yarn-applications-distributedshell-2.8.4.jar
hadoop-yarn-applications-unmanaged-am-launcher-2.8.4.jar
hadoop-yarn-client-2.8.4.jar
hadoop-yarn-common-2.8.4.jar
hadoop-yarn-server-applicationhistoryservice-2.8.4.jar
hadoop-yarn-server-common-2.8.4.jar
hadoop-yarn-server-nodemanager-2.8.4.jar
hadoop-yarn-server-resourcemanager-2.8.4.jar
hadoop-yarn-server-tests-2.8.4.jar
hadoop-yarn-server-web-proxy-2.8.4.jar
zookeeper-3.4.10.jar

//尖叫提示：這些jar包的對應版本應替換成你目前使用的hadoop版本，具體狀況具體分析。
//查找jar包舉例：
find /opt/module/hadoop-2.8.4/ -name hadoop-annotations*
//而後將找到的jar包複製到HBase的lib目錄下便可。
  • 1.六、HBase軟鏈接Hadoop配置(額外，不用配置)
ln -s /opt/module/hadoop-2.8.4/etc/hadoop/core-site.xml /opt/module/hbase-1.3.1/conf/core-site.xml
ln -s /opt/module/hadoop-2.8.4/etc/hadoop/hdfs-site.xml /opt/module/hbase-1.3.1/conf/hdfs-site.xml
  • 1.7.0 配置環境變量
vi /etc/profile
export HBASE_HOME=/opt/module/hbase-1.3.1
export PATH=$HBASE_HOME/bin:$PATH
source /etc/profile
  • 1.七、HBase遠程scp到其餘集羣
scp -r /opt/module/hbase-1.3.1/ bigdata112:/opt/module/
scp -r /opt/module/hbase-1.3.1/ bigdata113:/opt/module/
  • 1.八、HBase服務的啓動

啓動方式1：

bin/hbase-daemon.sh start master
bin/hbase-daemon.sh start regionserver
尖叫提示：若是集羣之間的節點時間不一樣步，會致使regionserver沒法啓動，拋出ClockOutOfSyncException異常。

啓動方式2：

bin/start-hbase.sh
對應的中止服務：

bin/stop-hbase.sh
  • 1.九、查看Hbse頁面
//啓動成功後，能夠經過「host:port」的方式來訪問HBase管理頁面，例如：

http://bigdata111:16010

二、基本操做

    1. 進入HBase客戶端命令行
bin/hbase shell
    1. 查看幫助命令
hbase(main)> help
    1. 查看當前數據庫中有哪些表
hbase(main)> list
    1. 查看當前數據庫中有哪些命名空間
hbase(main)> list_namespace
2.1 表的操做
    1. 建立表
hbase(main)> create 'student','info'
hbase(main)> create 'iparkmerchant_order','smzf'
hbase(main)> create 'staff','info'
    1. 插入數據到表
hbase(main) > put 'student','1001','info:name','Thomas'
hbase(main) > put 'student','1001','info:sex','male'
hbase(main) > put 'student','1001','info:age','18'
hbase(main) > put 'student','1002','info:name','Janna'
hbase(main) > put 'student','1002','info:sex','female'
hbase(main) > put 'student','1002','info:age','20'

  數據插入後的數據模型

    1. 掃描查看錶數據
hbase(main) > scan 'student'
hbase(main) > scan 'student',{STARTROW => '1001', STOPROW  => '1001'}
hbase(main) > scan 'student',{STARTROW => '1001'}
注：這個是從哪個rowkey開始掃描
    1. 查看錶結構
hbase(main):012:0> desc 'student'
    1. 更新指定字段的數據
hbase(main) > put 'student','1001','info:name','Nick'
hbase(main) > put 'student','1001','info:age','100'
hbase(main) > put 'student','1001','info:isNull',''（僅測試空值問題）
    1. 查看「指定行」或「指定列族:列」的數據
hbase(main) > get 'student','1001'
hbase(main) > get 'student','1001','info:name'
    1. 刪除數據
//刪除某rowkey的所有數據：
hbase(main) > deleteall 'student','1001'
    1. 清空表數據
hbase(main) > truncate 'student'
//尖叫提示：清空表的操做順序爲先disable，而後再truncate。
    1. 刪除表
//首先須要先讓該表爲disable狀態：
hbase(main) > disable 'student'

//檢查這個表是否被禁用
hbase(main) > is_enabled 'hbase_book'
hbase(main) > is_disabled 'hbase_book'

//恢復被禁用得表
enable 'student'


//而後才能drop這個表：
hbase(main) > drop 'student'
//尖叫提示：若是直接drop表，會報錯：Drop the named table. Table must first be disabled
ERROR: Table student is enabled. Disable it first.
    1. 統計表數據行數
hbase(main) > count 'student'
    1. 變動表信息
//將info列族中的數據存放3個版本：
hbase(main) > alter 'student',{NAME=>'info',VERSIONS=>3}

//查看student的最新的版本的數據
hbase(main) > get 'student','1001'

//查看HBase中的多版本
hbase(main) > get 'student','1001',{COLUMN=>'info:name',VERSIONS=>10}
2.二、經常使用Shell操做
    1. satus 例如：顯示服務器狀態
hbase> status 'bigdata111'
    1. exist 檢查表是否存在，適用於表量特別多的狀況
hbase> exist 'hbase_book'
    1. is_enabled/is_disabled 檢查表是否啓用或禁用
hbase> is_enabled 'hbase_book'
hbase> is_disabled 'hbase_book'
    1. alter 該命令能夠改變表和列族的模式，例如：
爲當前表增長列族：
hbase> alter 'hbase_book', NAME => 'CF2', VERSIONS => 2

爲當前表刪除列族：
hbase> alter 'hbase_book', 'delete' => 'CF2'
    1. disable禁用一張表
hbase> disable 'hbase_book'
hbase> drop 'hbase_book'
    1. delete
刪除一行中一個單元格的值，例如：
hbase> delete 'hbase_book', 'rowKey', 'CF:C'
    1. truncate清空表數據，即禁用表-刪除表-建立表
hbase> truncate 'hbase_book'
    1. create
建立多個列族：
hbase> create 't1', {NAME => 'f1'}, {NAME => 'f2'}, {NAME => 'f3'}

三、讀寫流程

3.一、HBase讀數據流程
    1. HRegionServer保存着.META.的這樣一張表以及表數據，要訪問表數據，首先Client先去訪問zookeeper，從zookeeper裏面找到.META.表所在的位置信息，即找到這個.META.表在哪一個HRegionServer上保存着。
    1. 接着Client經過剛纔獲取到的HRegionServer的IP來訪問.META.表所在的HRegionServer，從而讀取到.META.，進而獲取到.META.表中存放的元數據。
    1. Client經過元數據中存儲的信息，訪問對應的HRegionServer，而後掃描(scan)所在
      HRegionServer的Memstore和Storefile來查詢數據。
    1. 最後HRegionServer把查詢到的數據響應給Client。
3.二、HBase寫數據流程
    1. Client也是先訪問zookeeper，找到-ROOT-表，進而找到.META.表，並獲取.META.表信息。
    1. 肯定當前將要寫入的數據所對應的RegionServer服務器和Region。
    1. Client向該RegionServer服務器發起寫入數據請求，而後RegionServer收到請求並響應。
    1. Client先把數據寫入到HLog，以防止數據丟失。
    1. 而後將數據寫入到Memstore。
    1. 若是Hlog和Memstore均寫入成功，則這條數據寫入成功。在此過程當中，若是Memstore達到閾值，會把Memstore中的數據flush到StoreFile中。
    1. 當Storefile愈來愈多，會觸發Compact合併操做，把過多的Storefile合併成一個大的Storefile。當Storefile愈來愈大，Region也會愈來愈大，達到閾值後，會觸發Split操做，將Region一分爲二。

尖叫提示：由於內存空間是有限的，因此說溢寫過程一定伴隨着大量的小文件產生。

四、JavaAPI

4.1 新建Maven Project

  新建項目後在pom.xml中添加依賴：

<dependency>
<groupId>org.apache.hbase</groupId>
<artifactId>hbase-server</artifactId>
<version>1.3.1</version>
</dependency>


<dependency>
<groupId>org.apache.hbase</groupId>
<artifactId>hbase-client</artifactId>
<version>1.3.1</version>
</dependency>
4.2 編寫HBaseAPI

  注意，這部分的學習內容，咱們先學習使用老版本的API，接着再寫出新版本的API調用方式。由於在企業中，有些時候咱們須要一些過期的API來提供更好的兼容性。

    1. 首先須要獲取Configuration對象：
public static Configuration conf;
static{
	//使用HBaseConfiguration的單例方法實例化
	conf = HBaseConfiguration.create();
conf.set("hbase.zookeeper.quorum", "bigdata111");
conf.set("hbase.zookeeper.property.clientPort", "2181");
	conf.set("zookeeper.znode.parent", "/hbase");
}
    1. 判斷表是否存在：
public static boolean isTableExist(String tableName) throws MasterNotRunningException, ZooKeeperConnectionException, IOException{
	//在HBase中管理、訪問表須要先建立HBaseAdmin對象
Connection connection = ConnectionFactory.createConnection(conf);
HBaseAdmin admin = (HBaseAdmin) connection.getAdmin();
	//HBaseAdmin admin = new HBaseAdmin(conf);
	return admin.tableExists(tableName);
}
    1. 建立表
public static void createTable(String tableName, String... columnFamily) throws MasterNotRunningException, ZooKeeperConnectionException, IOException{
	HBaseAdmin admin = new HBaseAdmin(conf);
	//判斷表是否存在
	if(isTableExist(tableName)){
		System.out.println("表" + tableName + "已存在");
		//System.exit(0);
	}else{
		//建立表屬性對象,表名須要轉字節
		HTableDescriptor descriptor = new HTableDescriptor(TableName.valueOf(tableName));
		//建立多個列族
		for(String cf : columnFamily){
			descriptor.addFamily(new HColumnDescriptor(cf));
		}
		//根據對錶的配置，建立表
		admin.createTable(descriptor);
		System.out.println("表" + tableName + "建立成功！");
	}
}
    1. 刪除表
public static void dropTable(String tableName) throws Exception{
	HBaseAdmin admin = new HBaseAdmin(conf);
	if(isTableExist(tableName)){
		admin.disableTable(tableName);
		admin.deleteTable(tableName);
		System.out.println("表" + tableName + "刪除成功！");
	}else{
		System.out.println("表" + tableName + "不存在！");
	}
}
    1. 向表中插入數據
public static void addRowData(String tableName, String rowKey, String columnFamily, String column, String value) throws Exception{
	//建立HTable對象
	HTable hTable = new HTable(conf, tableName);
	//向表中插入數據
	Put put = new Put(Bytes.toBytes(rowKey));
	//向Put對象中組裝數據
	put.add(Bytes.toBytes(columnFamily), Bytes.toBytes(column), Bytes.toBytes(value));
	hTable.put(put);
	hTable.close();
	System.out.println("插入數據成功");
}
    1. 刪除多行數據
public static void deleteMultiRow(String tableName, String... rows) throws IOException{
	HTable hTable = new HTable(conf, tableName);
	List<Delete> deleteList = new ArrayList<Delete>();
	for(String row : rows){
		Delete delete = new Delete(Bytes.toBytes(row));
		deleteList.add(delete);
	}
	hTable.delete(deleteList);
	hTable.close();
}
    1. 獲得全部數據
public static void getAllRows(String tableName) throws IOException{
	HTable hTable = new HTable(conf, tableName);
	//獲得用於掃描region的對象
	Scan scan = new Scan();
	//使用HTable獲得resultcanner實現類的對象
	ResultScanner resultScanner = hTable.getScanner(scan);
	for(Result result : resultScanner){
		Cell[] cells = result.rawCells();
		for(Cell cell : cells){
			//獲得rowkey
			System.out.println("行鍵:" + Bytes.toString(CellUtil.cloneRow(cell)));
			//獲得列族
			System.out.println("列族" + Bytes.toString(CellUtil.cloneFamily(cell)));
			System.out.println("列:" + Bytes.toString(CellUtil.cloneQualifier(cell)));
			System.out.println("值:" + Bytes.toString(CellUtil.cloneValue(cell)));
		}
	}
}
    1. 獲得某一行全部數據
public static void getRow(String tableName, String rowKey) throws IOException{
	HTable table = new HTable(conf, tableName);
	Get get = new Get(Bytes.toBytes(rowKey));
	//get.setMaxVersions();顯示全部版本
//get.setTimeStamp();顯示指定時間戳的版本
	Result result = table.get(get);
	for(Cell cell : result.rawCells()){
		System.out.println("行鍵:" + Bytes.toString(result.getRow()));
		System.out.println("列族" + Bytes.toString(CellUtil.cloneFamily(cell)));
		System.out.println("列:" + Bytes.toString(CellUtil.cloneQualifier(cell)));
		System.out.println("值:" + Bytes.toString(CellUtil.cloneValue(cell)));
		System.out.println("時間戳:" + cell.getTimestamp());
	}
}
    1. 獲取某一行指定「列族:列」的數據
public static void getRowQualifier(String tableName, String rowKey, String family, String qualifier) throws IOException{
	HTable table = new HTable(conf, tableName);
	Get get = new Get(Bytes.toBytes(rowKey));
	get.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
	Result result = table.get(get);
	for(Cell cell : result.rawCells()){
		System.out.println("行鍵:" + Bytes.toString(result.getRow()));
		System.out.println("列族" + Bytes.toString(CellUtil.cloneFamily(cell)));
		System.out.println("列:" + Bytes.toString(CellUtil.cloneQualifier(cell)));
		System.out.println("值:" + Bytes.toString(CellUtil.cloneValue(cell)));
	}
}
4.3 HBaseUtil
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.NamespaceDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.util.Bytes;


import java.io.IOException;
import java.text.DecimalFormat;
import java.util.Iterator;
import java.util.TreeSet;


/**
* @author Andy
* 一、NameSpace ====>  命名空間
* 二、createTable ===> 表
* 三、isTable   ====>  判斷表是否存在
* 四、Region、RowKey、分區鍵
*/
public class HBaseUtil {


/**
* 初始化命名空間
*
* @param conf      配置對象
* @param namespace 命名空間的名字
* @throws Exception
*/
public static void initNameSpace(Configuration conf, String namespace) throws Exception {
Connection connection = ConnectionFactory.createConnection(conf);
Admin admin = connection.getAdmin();
//命名空間描述器
NamespaceDescriptor nd = NamespaceDescriptor
.create(namespace)
.addConfiguration("AUTHOR", "Andy")
.build();
//經過admin對象來建立命名空間
admin.createNamespace(nd);
System.out.println("已初始化命名空間");
//關閉兩個對象
close(admin, connection);
}


/**
* 關閉admin對象和connection對象
*
* @param admin      關閉admin對象
* @param connection 關閉connection對象
* @throws IOException IO異常
*/
private static void close(Admin admin, Connection connection) throws IOException {
if (admin != null) {
admin.close();
}
if (connection != null) {
connection.close();
}
}


/**
* 建立HBase的表
* @param conf
* @param tableName
* @param regions
* @param columnFamily
*/
public static void createTable(Configuration conf, String tableName, int regions, String... columnFamily) throws IOException {
Connection connection = ConnectionFactory.createConnection(conf);
Admin admin = connection.getAdmin();
//判斷表
if (isExistTable(conf, tableName)) {
return;
}
//表描述器 HTableDescriptor
HTableDescriptor htd = new HTableDescriptor(TableName.valueOf(tableName));
for (String cf : columnFamily) {
//列描述器 ：HColumnDescriptor
htd.addFamily(new HColumnDescriptor(cf));
}
//htd.addCoprocessor("hbase.CalleeWriteObserver");
//建立表
admin.createTable(htd,genSplitKeys(regions));
System.out.println("已建表");
//關閉對象
close(admin,connection);
}


/**
* 分區鍵
* @param regions region個數
* @return splitKeys
*/
private static byte[][] genSplitKeys(int regions) {
//存放分區鍵的數組
String[] keys = new String[regions];
//格式化分區鍵的形式  00 01 02
DecimalFormat df = new DecimalFormat("00");
for (int i = 0; i < regions; i++) {
keys[i] = df.format(i) + "";
}


byte[][] splitKeys = new byte[regions][];
//排序 保證你這個分區鍵是有序得
TreeSet<byte[]> treeSet = new TreeSet<>(Bytes.BYTES_COMPARATOR);
for (int i = 0; i < regions; i++) {
treeSet.add(Bytes.toBytes(keys[i]));
}


//輸出
Iterator<byte[]> iterator = treeSet.iterator();
int index = 0;
while (iterator.hasNext()) {
byte[] next = iterator.next();
splitKeys[index++]= next;
}


return splitKeys;
}


/**
* 判斷表是否存在
* @param conf      配置 conf
* @param tableName 表名
*/
public static boolean isExistTable(Configuration conf, String tableName) throws IOException {
Connection connection = ConnectionFactory.createConnection(conf);
Admin admin = connection.getAdmin();


boolean result = admin.tableExists(TableName.valueOf(tableName));
close(admin, connection);
return result;
}
}
4.4 PropertiesUtil
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;


public class PropertiesUtil {
public static Properties properties = null;
static {
//獲取配置文件、方便維護
InputStream is = ClassLoader.getSystemResourceAsStream("hbase_consumer.properties");
properties = new Properties();


try {
properties.load(is);
} catch (IOException e) {
e.printStackTrace();
}
}


/**
* 獲取參數值
* @param key 名字
* @return 參數值
*/
public static String getProperty(String key){
return properties.getProperty(key);
}


}
4.5 HBaseDAO
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;




public class HBaseDAO {


private static String namespace = PropertiesUtil.getProperty("hbase.calllog.namespace");
private static String tableName = PropertiesUtil.getProperty("hbase.calllog.tablename");
private static Integer regions = Integer.valueOf(PropertiesUtil.getProperty("hbase.calllog.regions"));


public static void main(String[] args) throws Exception {
Configuration conf = HBaseConfiguration.create();
conf.set("hbase.zookeeper.property.clientPort", "2181");
conf.set("hbase.zookeeper.quorum", "bigdata111");
conf.set("zookeeper.znode.parent", "/hbase");


if (!HBaseUtil.isExistTable(conf, tableName)) {
HBaseUtil.initNameSpace(conf, namespace);
HBaseUtil.createTable(conf, tableName, regions, "f1", "f2");
}
}
2.五、MapReduce

  經過HBase的相關JavaAPI，咱們能夠實現伴隨HBase操做的MapReduce過程，好比使用MapReduce將數據從本地文件系統導入到HBase的表中，好比咱們從HBase中讀取一些原始數據後使用MapReduce作數據分析。

五、官方HBase-MapReduce

    1. 查看HBase的MapReduce任務的所需的依賴
$ bin/hbase mapredcp
    1. 執行環境變量的導入
$ export HBASE_HOME=/opt/module/hbase-1.3.1
$ export HADOOP_CLASSPATH=`${HBASE_HOME}/bin/hbase mapredcp`
    1. 運行官方的MapReduce任務

--案例一：統計Student表中有多少行數據

$ /opt/module/hadoop-2.8.4/bin/yarn jar lib/hbase-server-1.3.1.jar rowcounter ns_ct:calllog

--案例二：使用MapReduce將本地數據導入到HBase

    1. 在本地建立一個tsv格式的文件：fruit.tsv，本身建表用\t分割數據
1001	Apple	Red
1002	Pear	Yellow
1003	Pineapple	Yellow
//尖叫提示：上面的這個數據不要從word中直接複製，有格式錯誤
    1. 建立HBase表
hbase(main):001:0> create 'fruit','info'
    1. 在HDFS中建立input_fruit文件夾並上傳fruit.tsv文件
$ /opt/module/hadoop-2.8.4/bin/hdfs dfs -mkdir /input_fruit/
$ /opt/module/hadoop-2.8.4/bin/hdfs dfs -put fruit.tsv /input_fruit/
    1. 執行MapReduce到HBase的fruit表中
$ /opt/module/hadoop-2.8.4/bin/yarn jar lib/hbase-server-1.3.1.jar importtsv \
-Dimporttsv.columns=HBASE_ROW_KEY,info:name,info:color fruit \
hdfs://bigdata11:9000/input_fruit
    1. 使用scan命令查看導入後的結果
hbase(main):001:0> scan 'fruit'
5.一、HBase to HBase

  目標：將fruit表中的一部分數據，經過MR遷入到fruit_mr表中。

  分步實現：

    1. 構建ReadFruitMapper類，用於讀取fruit表中的數據
import java.io.IOException;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableMapper;
import org.apache.hadoop.hbase.util.Bytes;


public class ReadFruitMapper extends TableMapper<ImmutableBytesWritable, Put> {


	@Override
	protected void map(ImmutableBytesWritable key, Result value, Context context)
	throws IOException, InterruptedException {
	//將fruit的name和color提取出來，至關於將每一行數據讀取出來放入到Put對象中。
		Put put = new Put(key.get());
		//遍歷添加column行
		for(Cell cell: value.rawCells()){
			//添加/克隆列族:info
			if("info".equals(Bytes.toString(CellUtil.cloneFamily(cell)))){
				//添加/克隆列：name
				if("name".equals(Bytes.toString(CellUtil.cloneQualifier(cell)))){
					//將該列cell加入到put對象中
					put.add(cell);
					//添加/克隆列:color
				}else if("color".equals(Bytes.toString(CellUtil.cloneQualifier(cell)))){
					//向該列cell加入到put對象中
					put.add(cell);
				}
			}
		}
		//將從fruit讀取到的每行數據寫入到context中做爲map的輸出
		context.write(key, put);
	}
}
    1. 構建WriteFruitMRReducer類，用於將讀取到的fruit表中的數據寫入到fruit_mr表中
import java.io.IOException;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableReducer;
import org.apache.hadoop.io.NullWritable;


public class WriteFruitMRReducer extends TableReducer<ImmutableBytesWritable, Put, NullWritable> {
	@Override
	protected void reduce(ImmutableBytesWritable key, Iterable<Put> values, Context context)
	throws IOException, InterruptedException {
		//讀出來的每一行數據寫入到fruit_mr表中
		for(Put put: values){
			context.write(NullWritable.get(), put);
		}
	}
}
    1. 構建Fruit2FruitMRRunner extends Configured implements Tool用於組裝運行Job任務
package MRToHBase;


import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableMapReduceUtil;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;


import java.io.IOException;


public class Fruit2FruitMRRunner extends Configured implements Tool {
@Override
public int run(String[] strings) throws Exception {
//獲得Configuration
Configuration conf = this.getConf();
//建立Job任務
Job job = Job.getInstance(conf, this.getClass().getSimpleName());
job.setJarByClass(Fruit2FruitMRRunner.class);


//配置Job
Scan scan = new Scan();
scan.setCacheBlocks(false);
scan.setCaching(500);


//設置Mapper，注意導入的是mapreduce包下的，不是mapred包下的，後者是老版本
TableMapReduceUtil.initTableMapperJob(
"fruit", //數據源的表名
scan, //scan掃描控制器
ReadFruitMapper.class,//設置Mapper類
ImmutableBytesWritable.class,//設置Mapper輸出key類型
Put.class,//設置Mapper輸出value值類型
job//設置給哪一個JOB
);
//設置Reducer
TableMapReduceUtil.initTableReducerJob(
"fruit_mr",
WriteFruitMRReducer.class,
job);
//設置Reduce數量，最少1個
job.setNumReduceTasks(1);


boolean isSuccess = job.waitForCompletion(true);
if(!isSuccess){
throw new IOException("Job running with error");
}
return isSuccess ? 0 : 1;
}


public static void main(String[] args) throws Exception {
Configuration conf = HBaseConfiguration.create();
int status = ToolRunner.run(conf, new Fruit2FruitMRRunner(), args);
System.exit(status);
}
}
    1. 打包運行任務
$ /opt/module/hadoop-2.8.4/bin/yarn jar /opt/module/hbase-1.3.1/HBase-1.0-SNAPSHOT.jar  MRToHBase.Fruit2FruitMRRunner
//尖叫提示：運行任務前，若是待數據導入的表不存在，則須要提早建立之。
5.二、HDFS to HBase

  目標：實現將HDFS中的數據寫入到HBase表中。

  分步實現：

    1. 構建ReadFruitFromHDFSMapper於讀取HDFS中的文件數據
import java.io.IOException;


import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;


public class ReadFruitFromHDFSMapper extends Mapper<LongWritable, Text, ImmutableBytesWritable, Put> {
	@Override
	protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
		//從HDFS中讀取的數據
		String lineValue = value.toString();
		//讀取出來的每行數據使用\t進行分割，存於String數組
		String[] values = lineValue.split("\t");
		
		//根據數據中值的含義取值
		String rowKey = values[0];
		String name = values[1];
		String color = values[2];
		
		//初始化rowKey
		ImmutableBytesWritable rowKeyWritable = new ImmutableBytesWritable(Bytes.toBytes(rowKey));
		
		//初始化put對象
		Put put = new Put(Bytes.toBytes(rowKey));
		
		//參數分別:列族、列、值
put.add(Bytes.toBytes("info"), Bytes.toBytes("name"),  Bytes.toBytes(name));
put.add(Bytes.toBytes("info"), Bytes.toBytes("color"),  Bytes.toBytes(color));

context.write(rowKeyWritable, put);
	}
}
    1. 構建WriteFruitMRFromTxtReducer類
import java.io.IOException;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableReducer;
import org.apache.hadoop.io.NullWritable;


public class WriteFruitMRFromTxtReducer extends TableReducer<ImmutableBytesWritable, Put, NullWritable> {
	@Override
	protected void reduce(ImmutableBytesWritable key, Iterable<Put> values, Context context) throws IOException, InterruptedException {
		//讀出來的每一行數據寫入到fruit_hdfs表中
		for(Put put: values){
			context.write(NullWritable.get(), put);
		}
	}
}
    1. 建立Txt2FruitRunner組裝Job
package HDFSToHBase;


import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableMapReduceUtil;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;


import java.io.IOException;


public class Txt2FruitRunner extends Configured implements Tool {
@Override
public int run(String[] strings) throws Exception {
//獲得Configuration
Configuration conf = this.getConf();


//建立Job任務
Job job = Job.getInstance(conf, this.getClass().getSimpleName());
job.setJarByClass(Txt2FruitRunner.class);
Path inPath = new Path("hdfs://bigdata11:9000/input_fruit/fruit.tsv");
FileInputFormat.addInputPath(job, inPath);


//設置Mapper
job.setMapperClass(ReadFruitFromHDFSMapper.class);
job.setMapOutputKeyClass(ImmutableBytesWritable.class);
job.setMapOutputValueClass(Put.class);


//設置Reducer
TableMapReduceUtil.initTableReducerJob("fruit_mr", WriteFruitMRFromTxtReducer.class, job);


//設置Reduce數量，最少1個
job.setNumReduceTasks(1);


boolean isSuccess = job.waitForCompletion(true);
if (!isSuccess) {
throw new IOException("Job running with error");
}


return isSuccess ? 0 : 1;
}


public static void main(String[] args) throws Exception {
Configuration conf = HBaseConfiguration.create();
int status = ToolRunner.run(conf, new Txt2FruitRunner(), args);
System.exit(status);
}
}
    1. 打包運行
/opt/module/hadoop-2.8.4/bin/yarn jar HDFSToHBase.jar HDFSToHBase.ReadFruitFromHDFSMapper
//尖叫提示：運行任務前，若是待數據導入的表不存在，則須要提早建立之。

六、與Hive的集成

6.一、HBase與Hive的對比
Hive HBase
特色 類SQL 數據倉庫 NoSQL （Key-value）
適用場景 離線數據分析和清洗 適合在線業務
延遲 延遲高 延遲低
存儲位置 存儲在HDFS 存儲在HDFS
6.二、HBase與Hive集成使用

  環境準備
  由於咱們後續可能會在操做Hive的同時對HBase也會產生影響，因此Hive須要持有操做HBase的Jar，那麼接下來拷貝Hive所依賴的Jar包（或者使用軟鏈接的形式）。記得還有把zookeeper的jar包考入到hive的lib目錄下。

#環境變量/etc/profile
$ export HBASE_HOME=/opt/module/hbase-1.3.1
$ export HIVE_HOME=/opt/module/apache-hive-1.2.2-bin
#Shell執行
$ ln -s $HBASE_HOME/lib/hbase-common-1.3.1.jar  $HIVE_HOME/lib/hbase-common-1.3.1.jar
$ ln -s $HBASE_HOME/lib/hbase-server-1.3.1.jar $HIVE_HOME/lib/hbase-server-1.3.1.jar
$ ln -s $HBASE_HOME/lib/hbase-client-1.3.1.jar $HIVE_HOME/lib/hbase-client-1.3.1.jar
$ ln -s $HBASE_HOME/lib/hbase-protocol-1.3.1.jar $HIVE_HOME/lib/hbase-protocol-1.3.1.jar
$ ln -s $HBASE_HOME/lib/hbase-it-1.3.1.jar $HIVE_HOME/lib/hbase-it-1.3.1.jar
$ ln -s $HBASE_HOME/lib/htrace-core-3.1.0-incubating.jar $HIVE_HOME/lib/htrace-core-3.1.0-incubating.jar
$ ln -s $HBASE_HOME/lib/hbase-hadoop2-compat-1.3.1.jar $HIVE_HOME/lib/hbase-hadoop2-compat-1.3.1.jar
$ ln -s $HBASE_HOME/lib/hbase-hadoop-compat-1.3.1.jar $HIVE_HOME/lib/hbase-hadoop-compat-1.3.1.jar
  • 同時在hive-site.xml中修改zookeeper的屬性，以下：
<property>
<name>hive.zookeeper.quorum</name>
<value>bigdata11,bigdata12,bigdata13</value>
<description>The list of ZooKeeper servers to talk to. This is only needed for read/write locks.</description>
</property>
<property>
<name>hive.zookeeper.client.port</name>
<value>2181</value>
<description>The port of ZooKeeper servers to talk to. This is only needed for read/write locks.</description>
</property>
    1. 案例一

  目標：創建Hive表，關聯HBase表，插入數據到Hive表的同時可以影響HBase表。
  分步實現：

  (1) 在Hive中建立表同時關聯HBase

CREATE TABLE hive_hbase_emp_table1(
empno int,
ename string,
job string,
mgr int,
hiredate string,
sal double,
comm double,
deptno int)
STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'
WITH SERDEPROPERTIES ("hbase.columns.mapping" = ":key,info:ename,info:job,info:mgr,info:hiredate,info:sal,info:comm,info:deptno")
TBLPROPERTIES ("hbase.table.name" = "hbase_emp_table1");

  尖叫提示：完成以後，能夠分別進入Hive和HBase查看，都生成了對應的表

  (2) 在Hive中建立臨時中間表，用於load文件中的數據

  尖叫提示：不能將數據直接load進Hive所關聯HBase的那張表中

CREATE TABLE emp(
empno int,
ename string,
job string,
mgr int,
hiredate string,
sal double,
comm double,
deptno int)
row format delimited fields terminated by '\t';

  (3) 向Hive中間表中load數據

hive> load data local inpath '/opt/module/datas/emp.txt' into table emp;

  (4) 經過insert命令將中間表中的數據導入到Hive關聯HBase的那張表中

hive> insert into table hive_hbase_emp_table1 select * from emp;

  (5) 查看Hive以及關聯的HBase表中是否已經成功的同步插入了數據
Hive：

hive> select * from hive_hbase_emp_table;

HBase：

hbase> scan 'hbase_emp_table'
    1. 案例二

  目標：在HBase中已經存儲了某一張表hbase_emp_table，而後在Hive中建立一個外部表來關聯HBase中的hbase_emp_table這張表，使之能夠藉助Hive來分析HBase這張表中的數據。
  注：該案例2緊跟案例1的腳步，因此完成此案例前，請先完成案例1。
  分步實現：

  (1) 在Hive中建立外部表

CREATE EXTERNAL TABLE relevance_hbase_emp(
empno int,
ename string,
job string,
mgr int,
hiredate string,
sal double,
comm double,
deptno int)
STORED BY 
'org.apache.hadoop.hive.hbase.HBaseStorageHandler'
WITH SERDEPROPERTIES ("hbase.columns.mapping" = 
":key,info:ename,info:job,info:mgr,info:hiredate,info:sal,info:comm,info:deptno") 
TBLPROPERTIES ("hbase.table.name" = "hbase_emp_table1");

  (2) 關聯後就可使用Hive函數進行一些分析操做了

hive (default)> select * from relevance_hbase_emp;

七、Sqoop集成：MySQL TO HBase

  Sqoop supports additional import targets beyond HDFS and Hive. Sqoop can also import records into a table in HBase.
  以前咱們已經學習過如何使用Sqoop在Hadoop集羣和關係型數據庫中進行數據的導入導出工做，接下來咱們學習一下利用Sqoop在HBase和RDBMS中進行數據的轉儲。

  相關參數：

參數 描述
--column-family 設置導入的目標列族。
--hbase-create-table 是否自動建立不存在的HBase表（這就意味着，不須要手動提早在HBase中先創建表）
--hbase-table 指定數據將要導入到HBase中的哪張表中。
--hbase-bulkload 是否容許bulk形式的導入。
--hbase-row-key mysql中哪一列的值做爲HBase的rowkey，若是rowkey是個組合鍵，則以逗號分隔。（注：避免rowkey的重複）
    1. 案例

  目標：將RDBMS中的數據抽取到HBase中
  分步實現：

   (1) 配置sqoop-env.sh，添加以下內容：

export HBASE_HOME=/opt/module/hbase-1.3.1

  (2) 在Mysql中新建一個數據庫db_library，一張表book

CREATE DATABASE db_library;
CREATE TABLE db_library.book(
id int(4) PRIMARY KEY NOT NULL AUTO_INCREMENT, 
name VARCHAR(255) NOT NULL, 
price VARCHAR(255) NOT NULL);

(3) 向表中插入一些數據

INSERT INTO db_library.book (name, price) VALUES('Lie Sporting', '30');  
INSERT INTO db_library.book (name, price) VALUES('Pride & Prejudice', '70');  
INSERT INTO db_library.book (name, price) VALUES('Fall of Giants', '50');

(4) 執行Sqoop導入數據的操做

//手動建立HBase表
hbase> create 'hbase_book','info'

(5) 在HBase中scan這張表獲得以下內容

hbase> scan 'hbase_book'

思考：嘗試使用複合鍵做爲導入數據時的rowkey。

$ bin/sqoop import \
--connect jdbc:mysql://bigdata11:3306/db_library \
--username root \
--password 000000 \
--table book \
--columns "id,name,price" \
--column-family "info" \
--hbase-create-table \
--hbase-row-key "id" \
--hbase-table "hbase_book" \
--num-mappers 1 \
--split-by id

&emsp 尖叫提示：sqoop1.4.6只支持HBase1.0.1以前的版本的自動建立HBase表的功能

九、Phoenix集成

1. Phoenix介紹

&emsp 能夠把Phoenix理解爲Hbase的查詢引擎，phoenix，由saleforce.com開源的一個項目，後又捐給了Apache。它至關於一個Java中間件，幫助開發者，像使用jdbc訪問關係型數據庫一些，訪問NoSql數據庫HBase。

&emsp phoenix，操做的表及數據，存儲在hbase上。phoenix只是須要和Hbase進行表關聯起來。而後再用工具進行一些讀或寫操做。

&emsp 其實，能夠把Phoenix只當作一種代替HBase的語法的一個工具。雖然能夠用java能夠用jdbc來鏈接phoenix，而後操做HBase，可是在生產環境中，不能夠用在OLTP中。在線事務處理的環境中，須要低延遲，而Phoenix在查詢HBase時，雖然作了一些優化，但延遲仍是不小。因此依然是用在OLAT中，再將結果返回存儲下來。

2.phoenix安裝包解壓縮更換目錄
tar -zxvf apache-phoenix-4.14.1-HBase-1.2-bin.tar.gz -C /opt/module
mv apache-phoenix-4.14.1-HBase-1.2-bin phoenix-4.14.1
//環境變量vi /etc/profile


//在最後兩行加上以下phoenix配置
export PHOENIX_HOME=/opt/module/phoenix-4.14.1
export PATH=$PATH:$PHOENIX_HOME/bin


//使環境變量配置生效
source /etc/profile

//將主節點的phoenix包傳到從節點
$ scp -r phoenix-4.14.1 root@bigdata13:/opt/module
$ scp -r phoenix-4.14.1 root@bigdata12:/opt/module

//拷貝hbase-site.xml（注）三臺都要
cp hbase-site.xml /opt/module/phoenix-4.14.1/bin/

//將以下兩個jar包，目錄在/opt/module/phoenix-4.14.1下，拷貝到hbase的lib目錄，目錄在/opt/module/hbase-1.3.1/lib/
（注）三臺都要
phoenix-4.10.0-HBase-1.2-server.jar
phoenix-core-4.10.0-HBase-1.2.jar


//啓動Phoenix
sqlline.py bigdata11:2181

基本命令
#展現表
> !table
#建立表
> create table test(id integer not null primary key,name varchar);
> create table "Andy"(
id integer not null primary key,
name varchar);
#刪除表
drop table test;
#插入數據
> upsert into test values(1,'Andy');
> upsert into users(name) values('toms');
#查詢數據
phoenix > select * from test;
hbase > scan 'test'
#退出phoenix
> !q
#刪除數據
delete from test where id=2;
#sum函數的使用
select sum(id) from "Andy";
#增長一列
alter table "Andy" add address varchar;
#刪除一列
alter table "Andy" drop column address;

其餘語法詳見：http://phoenix.apache.org/language/index.html

  • 表映射
#hbase中建立表
create 'teacher','info','contact'
#插入數據
put 'teacher','1001','info:name','Jack'
put 'teacher','1001','info:age','28'
put 'teacher','1001','info:gender','male'
put 'teacher','1001','contact:address','shanghai'
put 'teacher','1001','contact:phone','13458646987'

put 'teacher','1002','info:name','Jim'
put 'teacher','1002','info:age','30'
put 'teacher','1002','info:gender','male'
put 'teacher','1002','contact:address','tianjian'
put 'teacher','1002','contact:phone','13512436987'
#在Phoenix建立映射表
create view "teacher"(
"ROW" varchar primary key,
"contact"."address" varchar,
"contact"."phone" varchar,
"info"."age"  varchar,
"info"."gender" varchar,
"info"."name" varchar
);
#在Phoenix查找數據
select * from "teacher";

十、節點的管理

10.一、服役（commissioning）

  當啓動regionserver時，regionserver會向HMaster註冊並開始接收本地數據，開始的時候，新加入的節點不會有任何數據，平衡器開啓的狀況下，將會有新的region移動到開啓的RegionServer上。若是啓動和中止進程是使用ssh和HBase腳本，那麼會將新添加的節點的主機名加入到conf/regionservers文件中。

1）$ ./bin/hbase-daemon.sh stop regionserver

2）hbase(main):001:0>balance_switch true
10.二、退役（decommissioning）

  顧名思義，就是從當前HBase集羣中刪除某個RegionServer，這個過程分爲以下幾個過程：
  在0.90.2以前，咱們只能經過在要卸載的節點上執行

    1. 中止負載平衡器
hbase> balance_switch false
    1. 在退役節點上中止RegionServer
[root@bigdata11 hbase-1.3.1] hbase-daemon.sh stop regionserver
    1. RegionServer一旦中止，會關閉維護的全部region
    1. Zookeeper上的該RegionServer節點消失
    1. Master節點檢測到該RegionServer下線，開啓平衡器
hbase> balance_switch true
    1. 下線的RegionServer的region服務獲得從新分配

  這種方法很大的一個缺點是該節點上的Region會離線很長時間。由於假如該RegionServer上有大量Region的話，由於Region的關閉是順序執行的，第一個關閉的Region得等到和最後一個Region關閉並Assigned後一塊兒上線。這是一個至關漫長的時間。每一個Region Assigned須要4s，也就是說光Assigned就至少須要2個小時。該關閉方法比較傳統，須要花費必定的時間，並且會形成部分region短暫的不可用。

另外一種方案：

    1. 新方法
        自0.90.2以後，HBase添加了一個新的方法，即「graceful_stop」,只須要在HBase Master節點執行
$ bin/graceful_stop.sh <RegionServer-hostname>

  該命令會自動關閉Load Balancer，而後Assigned Region，以後會將該節點關閉。除此以外，你還能夠查看remove的過程，已經assigned了多少個Region，還剩多少個Region，每一個Region 的Assigned耗時

  • 2)開啓負載平衡器
hbase> balance_switch false

3、HBase的優化

一、高可用

  在HBase中Hmaster負責監控RegionServer的生命週期，均衡RegionServer的負載，若是Hmaster掛掉了，那麼整個HBase集羣將陷入不健康的狀態，而且此時的工做狀態並不會維持過久。因此HBase支持對Hmaster的高可用配置。

    1. 關閉HBase集羣（若是沒有開啓則跳過此步）
$ bin/stop-hbase.sh
    1. 在conf目錄下建立backup-masters文件
$ touch conf/backup-masters
    1. 在backup-masters文件中配置高可用HMaster節點
$ echo bigdata112 >  conf/backup-masters
    1. 將整個conf目錄scp到其餘節點
$ scp -r conf/ bigdata112:/opt/module/hbase-1.3.1
$ scp -r conf/ bigdata113:/opt/module/hbase-1.3.1
    1. 從新啓動HBase後打開頁面測試查看
0.98版本以後：http://bigdata111:16010

二、Hadoop的通用性優化

    1. NameNode元數據備份使用SSD
    1. 定時備份NameNode上的元數據
      每小時或者天天備份，若是數據極其重要，能夠5~10分鐘備份一次。備份能夠經過定時任務複製元數據目錄便可。
    1. 爲NameNode指定多個元數據目錄
      使用dfs.name.dir或者dfs.namenode.name.dir指定。這樣能夠提供元數據的冗餘和健壯性，以避免發生故障。
    1. NameNode的dir自恢復
      設置dfs.namenode.name.dir.restore爲true，容許嘗試恢復以前失敗的dfs.namenode.name.dir目錄，在建立checkpoint時作此嘗試，若是設置了多個磁盤，建議容許。
    1. HDFS保證RPC調用會有較多的線程數

hdfs-site.xml

屬性：dfs.namenode.handler.count
解釋：該屬性是NameNode服務默認線程數，的默認值是10，根據機器的可用內存能夠調整爲50~100

屬性：dfs.datanode.handler.count
解釋：該屬性默認值爲10，是DataNode的處理線程數，若是HDFS客戶端程序讀寫請求比較多，能夠調高到15~20，設置的值越大，內存消耗越多，不要調整的太高，通常業務中，5~10便可。
  1. HDFS副本數的調整

hdfs-site.xml

屬性：dfs.replication
解釋：若是數據量巨大，且不是很是之重要，能夠調整爲2~3，若是數據很是之重要，能夠調整爲3~5。
    1. HDFS文件塊大小的調整

hdfs-site.xml

屬性：dfs.blocksize
解釋：塊大小定義，該屬性應該根據存儲的大量的單個文件大小來設置，若是大量的單個文件都小於100M，建議設置成64M塊大小，對於大於100M或者達到GB的這種狀況，建議設置成256M，通常設置範圍波動在64M~256M之間。
    1. MapReduce Job任務服務線程數調整

mapred-site.xml

屬性：mapreduce.jobtracker.handler.count
解釋：該屬性是Job任務線程數，默認值是10，根據機器的可用內存能夠調整爲50~100
    1. Http服務器工做線程數

mapred-site.xml

屬性：mapreduce.tasktracker.http.threads
解釋：定義HTTP服務器工做線程數，默認值爲40，對於大集羣能夠調整到80~100
    1. 文件排序合併優化

mapred-site.xml

屬性：mapreduce.task.io.sort.factor
解釋：文件排序時同時合併的數據流的數量，這也定義了同時打開文件的個數，默認值爲10，若是調高該參數，能夠明顯減小磁盤IO，即減小文件讀取的次數。
    1. 設置任務併發

mapred-site.xml

屬性：mapreduce.map.speculative
解釋：該屬性能夠設置任務是否能夠併發執行，若是任務多而小，該屬性設置爲true能夠明顯加快任務執行效率，可是對於延遲很是高的任務，建議改成false，這就相似於迅雷下載。
    1. MR輸出數據的壓縮

mapred-site.xml

屬性：mapreduce.map.output.compress、mapreduce.output.fileoutputformat.compress
解釋：對於大集羣而言，建議設置Map-Reduce的輸出爲壓縮的數據，而對於小集羣，則不須要。
    1. 優化Mapper和Reducer的個數

mapred-site.xml

屬性：
mapreduce.tasktracker.map.tasks.maximum
mapreduce.tasktracker.reduce.tasks.maximum
解釋：以上兩個屬性分別爲一個單獨的Job任務能夠同時運行的Map和Reduce的數量。
設置上面兩個參數時，須要考慮CPU核數、磁盤和內存容量。假設一個8核的CPU，業務內容很是消耗CPU，那麼能夠設置map數量爲4，若是該業務不是特別消耗CPU類型的，那麼能夠設置map數量爲40，reduce數量爲20。這些參數的值修改完成以後，必定要觀察是否有較長等待的任務，若是有的話，能夠減小數量以加快任務執行，若是設置一個很大的值，會引發大量的上下文切換，以及內存與磁盤之間的數據交換，這裏沒有標準的配置數值，須要根據業務和硬件配置以及經驗來作出選擇。
在同一時刻，不要同時運行太多的MapReduce，這樣會消耗過多的內存，任務會執行的很是緩慢，咱們須要根據CPU核數，內存容量設置一個MR任務併發的最大值，使固定數據量的任務徹底加載到內存中，避免頻繁的內存和磁盤數據交換，從而下降磁盤IO，提升性能。

大概估算公式：

map = 2 + ⅔cpu_core
reduce = 2 + ⅓cpu_core

三、Linux優化

    1. 開啓文件系統的預讀緩存能夠提升讀取速度
$ sudo blockdev --setra 32768 /dev/sda
//尖叫提示：ra是readahead的縮寫
    1. 關閉進程睡眠池

  即不容許後臺進程進入睡眠狀態，若是進程空閒，則直接kill掉釋放資源

$ sudo sysctl -w vm.swappiness=0
    1. 調整ulimit上限，默認值爲比較小的數字
$ ulimit -n 查看容許最大進程數
$ ulimit -u 查看容許打開最大文件數

優化修改：

$ sudo vi /etc/security/limits.conf 修改打開文件數限制
末尾添加：
*                soft    nofile          1024000
*                hard    nofile          1024000
Hive             -       nofile          1024000
hive             -       nproc           1024000 

$ sudo vi /etc/security/limits.d/20-nproc.conf 修改用戶打開進程數限制
修改成：
#*          soft    nproc     4096
#root       soft    nproc     unlimited
*          soft    nproc     40960
root       soft    nproc     unlimited
    1. 開啓集羣的時間同步NTP

  集羣中某臺機器同步網絡時間服務器的時間，集羣中其餘機器則同步這臺機器的時間。

    1. 更新系統補丁

  更新補丁前，請先測試新版本補丁對集羣節點的兼容性。

四、Zookeeper優化

    1. 優化Zookeeper會話超時時間

hbase-site.xml

參數：zookeeper.session.timeout
解釋：In hbase-site.xml, set zookeeper.session.timeout to 30 seconds or less to bound failure detection (20-30 seconds is a good start).該值會直接關係到master發現服務器宕機的最大週期，默認值爲30秒（不一樣的HBase版本，該默認值不同），若是該值太小，會在HBase在寫入大量數據發生而GC時，致使RegionServer短暫的不可用，從而沒有向ZK發送心跳包，最終致使認爲從節點shutdown。通常20臺左右的集羣須要配置5臺zookeeper。****

五、HBase優化

5.一、預分區

  每個region維護着startRow與endRowKey，若是加入的數據符合某個region維護的rowKey範圍，則該數據交給這個region維護。那麼依照這個原則，咱們能夠將數據索要投放的分區提早大體的規劃好，以提升HBase性能。

    1. 手動設定預分區
hbase> create 'staff','info','partition1',SPLITS => ['1000','2000','3000','4000']
    1. 生成16進制序列預分區
create 'staff2','info','partition2',{NUMREGIONS => 15, SPLITALGO => 'HexStringSplit'}
    1. 按照文件中設置的規則預分區

  建立splits.txt文件內容以下：

aaaa
bbbb
cccc
dddd

而後執行：

create 'staff3','partition3',SPLITS_FILE => '/opt/module/hbase-1.3.1/splits.txt'
    1. 使用JavaAPI建立預分區
//自定義算法，產生一系列Hash散列值存儲在二維數組中
byte[][] splitKeys = 某個散列值函數
//建立HBaseAdmin實例
HBaseAdmin hAdmin = new HBaseAdmin(HBaseConfiguration.create());
//建立HTableDescriptor實例
HTableDescriptor tableDesc = new HTableDescriptor(tableName);
//經過HTableDescriptor實例和散列值二維數組建立帶有預分區的HBase表
hAdmin.createTable(tableDesc, splitKeys);
5.二、RowKey設計

  一條數據的惟一標識就是rowkey，那麼這條數據存儲於哪一個分區，取決於rowkey處於哪一個一個預分區的區間內，設計rowkey的主要目的 ，就是讓數據均勻的分佈於全部的region中，在必定程度上防止數據傾斜。接下來咱們就談一談rowkey經常使用的設計方案。

    1. 生成隨機數、hash、散列值
好比：
本來rowKey爲1001的，SHA1後變成：dd01903921ea24941c26a48f2cec24e0bb0e8cc7
本來rowKey爲3001的，SHA1後變成：49042c54de64a1e9bf0b33e00245660ef92dc7bd
本來rowKey爲5001的，SHA1後變成：7b61dec07e02c188790670af43e717f0f46e8913
在作此操做以前，通常咱們會選擇從數據集中抽取樣本，來決定什麼樣的rowKey來Hash後做爲每一個分區的臨界值。
    1. 字符串反轉
20170524000001轉成10000042507102
20170524000002轉成20000042507102

  這樣也能夠在必定程度上散列逐步put進來的數據。

    1. 字符串拼接
20170524000001_a12e
20170524000001_93i7
5.三、內存優化

  HBase操做過程當中須要大量的內存開銷，畢竟Table是能夠緩存在內存中的，通常會分配整個可用內存的70%給HBase的Java堆。可是不建議分配很是大的堆內存，由於GC過程持續過久會致使RegionServer處於長期不可用狀態，通常16~48G內存就能夠了，若是由於框架佔用內存太高致使系統內存不足，框架同樣會被系統服務拖死。

5.四、基礎優化
    1. 容許在HDFS的文件中追加內容

不是不容許追加內容麼？沒錯，請看背景故事：
http://blog.cloudera.com/blog/2009/07/file-appends-in-hdfs/

hdfs-site.xml、hbase-site.xml

屬性：dfs.support.append
解釋：開啓HDFS追加同步，能夠優秀的配合HBase的數據同步和持久化。默認值爲true。
    1. 優化DataNode容許的最大文件打開數

hdfs-site.xml

屬性：dfs.datanode.max.transfer.threads
解釋：HBase通常都會同一時間操做大量的文件，根據集羣的數量和規模以及數據動做，設置爲4096或者更高。默認值：4096
    1. 優化延遲高的數據操做的等待時間
      hdfs-site.xml
屬性：dfs.image.transfer.timeout
解釋：若是對於某一次數據操做來說，延遲很是高，socket須要等待更長的時間，建議把該值設置爲更大的值（默認60000毫秒），以確保socket不會被timeout掉。
    1. 優化數據的寫入效率

mapred-site.xml

屬性：
mapreduce.map.output.compress
mapreduce.map.output.compress.codec
解釋：開啓這兩個數據能夠大大提升文件的寫入效率，減小寫入時間。第一個屬性值修改成true，第二個屬性值修改成：org.apache.hadoop.io.compress.GzipCodec或者其餘壓縮方式。
    1. 優化DataNode存儲
屬性：dfs.datanode.failed.volumes.tolerated
解釋： 默認爲0，意思是當DataNode中有一個磁盤出現故障，則會認爲該DataNode shutdown了。若是修改成1，則一個磁盤出現故障時，數據會被複制到其餘正常的DataNode上，當前的DataNode繼續工做。
    1. 設置RPC監聽數量
      hbase-site.xml
屬性：hbase.regionserver.handler.count
解釋：默認值爲30，用於指定RPC監聽的數量，能夠根據客戶端的請求數進行調整，讀寫請求較多時，增長此值。
    1. 優化HStore文件大小
      hbase-site.xml
屬性：hbase.hregion.max.filesize
解釋：默認值10737418240（10GB），若是須要運行HBase的MR任務，能夠減少此值，由於一個region對應一個map任務，若是單個region過大，會致使map任務執行時間過長。該值的意思就是，若是HFile的大小達到這個數值，則這個region會被切分爲兩個Hfile。
    1. 優化hbase客戶端緩存
      hbase-site.xml
屬性：hbase.client.write.buffer
解釋：用於指定HBase客戶端緩存，增大該值能夠減小RPC調用次數，可是會消耗更多內存，反之則反之。通常咱們須要設定必定的緩存大小，以達到減小RPC次數的目的。
    1. 指定scan.next掃描HBase所獲取的行數
      hbase-site.xml
屬性：hbase.client.scanner.caching
解釋：用於指定scan.next方法獲取的默認行數，值越大，消耗內存越大。
    1. flush、compact、split機制
當MemStore達到閾值，將Memstore中的數據Flush進Storefile；compact機制則是把flush出來的小文件合併成大的Storefile文件。split則是當Region達到閾值，會把過大的Region一分爲二。
  • 涉及屬性：即：128M就是Memstore的默認閾值
hbase.hregion.memstore.flush.size：134217728

  即：這個參數的做用是當單個HRegion內全部的Memstore大小總和超過指定值時，flush該HRegion的全部memstore。RegionServer的flush是經過將請求添加一個隊列，模擬生產消費模型來異步處理的。那這裏就有一個問題，當隊列來不及消費，產生大量積壓請求時，可能會致使內存陡增，最壞的狀況是觸發OOM。

hbase.regionserver.global.memstore.upperLimit：0.4
hbase.regionserver.global.memstore.lowerLimit：0.38

  即：當MemStore使用內存總量達到hbase.regionserver.global.memstore.upperLimit指定值時，將會有多個MemStores flush到文件中，MemStore flush 順序是按照大小降序執行的，直到刷新到MemStore使用內存略小於lowerLimit

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程