Hadoop与HBase自学笔记
1、 安装jdk
使用jdk1.6.0_12版本。
2、 安装Cygwin以及相关服务
2.1 安装Cygwin
cygwin是一个在windows平台上运行的unix模拟环境。
在安装Cygwin之前，得先下载Cygwin安装程序setup.exe。
http://www.cygwin.com/setup.exe
选择install from internet,点next，
默认设置，点next
这里自己选择一个目录。
选择直接连接
然后Add http://www.cygwin.cn/pub/镜像，
点Add
(如果这个镜像下载不了，那就选择163那个吧，我一开始可以，重装就不可以，真奇怪。)
点下一步
默认是defaul，进入“Select Packages”对话框后，必须保证“Net Category”下的“OpenSSL”被安装。
点下一步,
另外，在eclipse上编译Hadoop，还必须安装“Base Category”下的“sed”，如
另外，还建议将“Editors Category”下的vim安装，以方便在Cygwin上直接修改配置
文件；“Devel Category”下的subversion建议安装，
点击完成，开始安装
安装完成后，点击完成，至此，cygwin安装完成。
2.2 配置环境变量
需要配置的环境变量包括PATH和JAVA_HOME：JAVA_HOME指向JRE安装目录；JDK
的bin目录。此外，Cygwin的bin目录，以及Cygwin的usr\sbin目录都必须添加到PATH环境变量中
在path变量增加
C:\cygwin\bin;C:\cygwin\usr\sbin
这串字符串即可（默认先前已经配好jdk环境变量,否则，要增加jdk环境变量）
2.3 安装sshd服务
点击桌面上的Cygwin图标，启动Cygwin，执行ssh-host-config命令
在执行ssh-host-config时，会要求Should privilege separation be used? (yes/no),输入yes/no时，选择输入no，当要求Do you want to install sshd as a service?选择yes
当要求Enter the value of CYGWIN for the daemon: []，输入ntsec
当看到“Have fun”时，一般表示sshd服务安装成功了，如上图所示。接下来，需要启
动sshd 服务。
2.4 启动sshd服务
在windows服务里，启动sshd服务，服务名为CYGWIN sshd
如果提示启动失败
则
在C:/cygwin/etc/passwd文件末尾增加一行
sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin
当CYGWIN sshd的状态为“已启动”后，接下来就是配置ssh登录。
2.5 配置ssh登录
执行ssh-keygen命令生成密钥文件
在上图所示对话框中，需要输入时，直接按回车键即可，如果不出错，应当是需要三次
按回车键。接下来生成authorized_keys文件，按下图所示操作即可
完成上述操作后，执行exit命令先退出Cygwin窗口，如果不执行这一步操作，下面的
操作可能会遇到错误。接下来，重新运行Cygwin，执行ssh localhost命令，在第一次执行ssh
localhost时，会有如下图所示的提示，输入yes，然后回车即可：
如果是Windows域用户，这步操作可能会遇到问题，错误信息如下：。
这个错误暂无解决办法，问题的解决情况，可关注Hadoop技术论坛中的贴：
http://bbs.hadoopor.com/thread-348-1-1.html(Cygwin 1.7.1版本ssh问题)。否则，如果成功，
执行who命令时，可以看到如下图所示的信息：
至此，配置ssh登录成功，下面就可以开始安装hadoop了。
3、安装hadoop
hadoop 安装包下载地址：
http://labs.xiaonei.com/apache-mirror/hadoop/core/hadoop-0.20.1/hadoop-0.20.1.tar.gz
将hadoop安装包hadoop-0.20.1.tar.gz解压到E:\HSS\hadoop-0.20.1目录（可以修改成其它目录）下，
接下来，需要修改hadoop的配置文件，它们位于conf子目录下，分别是hadoop-env.sh、
core-site.xml、hdfs-site.xml和mapred-site.xml共四个文件。在Cygwin环境，masters和slaves两个文件不需要修改。
3.1 修改hadoop-env.sh
只需要将JAVA_HOME修改成JDK的安装目录即可，请注意JDK必须是1.6或以上版本。
export JAVA_HOME=C:/Java/jdk1.6.0_12
注意路径要反斜杠或者双斜杠，因为是要在cygwin那里运行的.
3.2 修改core-site.xml
为简化core-site.xml配置，将E:\HSS\hadoop\run\src\core目录下的core-default.xml文件复制
到E:\HSS\hadoop-0.20.1\conf目录下，并将core-default.xml文件名改成core-site.xml。修改
fs.default.name 的值，如下所示
hdfs://localhost:8888
上图中的端口号8888，可以改成其它未被占用的端口。
同时还要修改这个值
3.3 修改hdfs-site.xml
为简化hdfs-site.xml配置，将E:\HSS\hadoop-0.20.1\src\hdfs目录下的hdfs-default.xml文件复制到E:\HSS\hadoop-0.20.1\conf目录下，并将hdfs-default.xml文件名改成hdfs-site.xml。不需要再做其它修改。
3.4修改mapred-site.xml
为简化mapred-site.xml配置，将E:\HSS\hadoop-0.20.1\src\mapred目录下的mapred-default.xml
文件复制到E:\HSS\hadoop-0.20.1\conf目录下，并将mapred-default.xml文件名改成mapred-site.xml。
上图中的端口号9999，可以改成其它未被占用的端口。到这里，hadoop宣告安装完毕，
可以开始体验hadoop了！
3.5 启动hadoop
在Cygwin中，进入hadoop的bin目录，
cd /cygdrive/E/HSS/hadoop-0.20.1/bin
先format文件
输入./hadoop namenode -format
运行./start-all.sh 启动hadoop，
（关闭是用./stop-all.sh）
在启动成功之后，输入jps命令，有三个任务显示，则表示启动成功了。
可以执行./hadoop fs -ls /命令，查看hadoop的根目录，
至此，hadoop安装完毕。
4、安装HBase
4.1 HBase介绍
HBase是Hadoop的正式子项目，它是一个面向列的分布式数据库，它在存储数据结构上并非关系型，而是疏松分布式的，持久并按多维排序并索引的map型，其思想源于Google的BigTable论文。（Google BigTable的paper: http://labs.google.com/papers/bigtable-osdi06.pdf）
由于HBase是一个分布式、大规模的平台，主要安装在类Unix平台上。但是由于其开发语言是Java，因此它同样具有跨平台的特性，同样也可以安装在Windows操作系统上。为了方便起见，使用具有类Unix特性的Cygwin来安装HBase。
4.2 下载与配置HBase
http://mirrors.tuna.tsinghua.edu.cn/apache/hbase/hbase-0.90.5/hbase-0.90.5.tar.gz
下载后解压到目录，比如E:\HSS\hbase-0.90.5
然后在E:\HSS\hbase-0.90.5文件夹下建立tmp文件夹，再在tmp文件夹里建立hbase文件夹，在hbase里建好tmp和data文件夹
（以后配置时需要用到）
4.2.1 配置hbase-env.sh
打开E:\HSS\hbase-0.90.5\conf下的hbase-env.sh文件，
修改jdk路径以及新增一记录
export HBASE_IDENT_STRING=127.0.0.1
4.2.2 修改hbase-site.xml文件
修改同目录下的hbase-site.xml
内容为：
<configuration>
<property>
<name>hbase.rootdir</name>
<!--<value>hdfs://localhost:9900/hbase</value> -->
<value>file:///E:/HSS/hbase-0.90.5/tmp/hbase/data</value>
<description>The directory shared by RegionServers.
</description>
</property>
<property>
<name>hbase.tmp.dir</name>
<value>E:/HSS/hbase-0.90.5/tmp/hbase/tmp</value>
<description></description>
</property>
<property>
<name>hbase.zookeeper.quorum</name>
<value>127.0.0.1</value>
</property>
</configuration>
如图：
4.3 Cygwin终端设置
先打开Cygwin终端
对一些文件和文件夹赋权
Administrator@Liangbinny /etc
$ chmod +r passwd
Administrator@Liangbinny /etc
$ chmod u+w passwd
Administrator@Liangbinny /etc
$ chmod +r group
Administrator@Liangbinny /etc
$ chmod u+w group
Administrator@Liangbinny /etc
$ chmod 755 /var
如图：
然后ssh登录
4.4 启动hbase
先cd /cygdrive/E/HSS/hbase-0.90.5
执行
./bin/start-hbase.sh
命令
启动hbase
提示时输入Yes
4.5 进入shell
执行
./bin/hbase shell
进入shell
4.6 建表与插数据
执行建表与插记录，
create 'test', 'data'
put 'test', 'row1', 'data:1', 'value1'
put 'test', 'row2', 'data:2', 'value2'
put 'test', 'row3', 'data:3', 'value3'
插入数据完毕，可以用
scan 'test'
查看刚才插入的数据
至此，Hbase安装完毕。
5、HBase数据库
参考网址
http://www.ibm.com/developerworks/cn/opensource/os-hbase/
5.1 数据类型
HBase 数据被建模为多维映射，其中值（表单元）通过 4个键索引：
value = Map(TableName, RowKey, ColumnKey, Timestamp)
其中：
TableName 是一个字符串。是表名。
RowKey 和 ColumnKey是二进制值（Java 类型 byte[]）。代表行健和列族。
Timestamp 是一个 64位整数（Java 类型 long）。
value 是一个未解释的字节数组（Java™类型 byte[]）。
二进制数据被编码为 Base64，以便通过网络传输。
行键是表的主键，通常是一个字符串。行通过行键按字典顺序排序。
存储在表中的信息的结构为列族（column family，就相当于列名），您可以将这种结构视为类别。每个列族可以拥有任意数量的成员，它们通过标签（或修饰符）识别。column键（就是每列的值）由族名、：号和标签组成。例如，对于系列name和成员 first，列键为 name: first。
（这里不是很好理解，看了下面的图可能就比较容易理解了，这个跟数据库有区分，可见，这里一行，不代表就一组数据，往往是多组数据的，一个rowkey可能对应多列的值，而每列的值（可以视为columnkey）是由列族名：标签组成），又如，name:last也是一个成员，他们都在于00001行键上，是00001行键的成员，成员值，就是value。
一个 HBase表模式定义多个列族，但当您向表中插入一行时，应用程序能够在运行时创建新成员。对于一个列族，表中的不同行可以拥有不同数量的成员。换句话说，HBase支持一个动态模式模型。
参考下图更好理解
其实这些记录在hbase是根据TimeStamp排序的，所以这虽然上图看起来很工整，但是实际上载数据库里存放是凌乱的。000001和000002的成员交错着放，唯一定义一个成员的唯一值的行键+列族：标签。
以第一个成员为例：
000001是行键，列族是name和contact，列键（column键）是name:first和name:last和contact:http ，Value值就是Jeffrey和Dean，还有research.google.com/people/jeff….
如果具体到java代码而言
HTabletable = newHTable(conf, tablename);
Scan s = new Scan();
ResultScanner rs = table.getScanner(s);
for (Result r : rs) {
KeyValue[] kv = r.raw();
for (int i = 0; i < kv.length; i++) {
vo = new HBaseVO();
vo.setRow(new String(kv[i].getRow()));
vo.setFamily(new String(kv[i].getFamily()));
vo.setQualifier(new String(kv[i].getQualifier()));
vo.setTimestamp(kv[i].getTimestamp());
vo.setValue(new String(kv[i].getValue()));
list.add(vo);
}
}
这样取数，rs里是有两条记录的，000001和000002，每一个rowKey可以对应多个成员，所以kv数据存放的是成员值，kv[i].getRow()得到的是每个成员的rowKey（000001.。。），Family就是列族，对于第一条记录，kv[0]的family是contact，kv[1],kv[2]是name，Qualifier这个单词比较少见，其实就是标签，对应kv[0]的标签是http，kv[1]是first,kv[2]是last，Timestamp是时间族，这个最简单不过，略，value也是每个成员的值，这个也很好理解，略。
对于任意行，一次只能访问一个列族的一个成员（这与关系数据库不同，在关系数据库中，一个查询可以访问来自一个行中的多个列的单元）。您可以将一个行中的一个列族的成员视为子行。（这个是因为一行可以对应多组成员所定，跟数据库最大的不同在于此吧）
表被分解为多个表区域，等同于 Bigtable片（tablet）。一个区域包含某个范围中的行。将一个表分解为多个区域是高效处理大型表的关键机制。
5.2 HBase语法教程
参考：
http://wiki.apache.org/hadoop/Hbase/Shell
如list显示所有的表，describe描述表
如list
非常详细
6、eclipse下开发hbase
API说明网址
http://www.open-open.com/lib/view/open1342514370807.html
先将E:\HSS\hbase-0.90.5\conf下的hbase-site.xml文件拷贝到工程下的src\main\resource目录
然后将E:\HSS\hbase-0.90.5下的hbase-0.90.5.jar包加入到项目中
新建接口
package com.hsbc.hss.dao;
publicinterface BaseDAO {
}
新建工具类
package com.hsbc.hss.util;
import org.apache.hadoop.hbase.KeyValue;
import com.hsbc.hss.vo.HBaseVO;
public class CommonUtil {
public static HBaseVO changeKeyValueToHBaseVo(KeyValue keyValue) {
HBaseVO vo = new HBaseVO();
vo.setRow(new String(keyValue.getRow()));
vo.setFamily(new String(keyValue.getFamily()));
vo.setQualifier(new String(keyValue.getQualifier()));
vo.setTimestamp(keyValue.getTimestamp());
vo.setValue(new String(keyValue.getValue()));
return vo;
}
}
新建基本类HBaseVO（以后新对象可直接继承这个类）
/**
*
*
* 做hbase查询，首先要对hbase的数据结果比较了解，以下是解释
*
* HBase 数据被建模为多维映射，其中值（表单元）通过 4 个键索引：
*
* value = Map(TableName, RowKey, ColumnKey, Timestamp)
*
* 其中：
* TableName 是一个字符串。是表名。
* RowKey 和 ColumnKey 是二进制值（Java类型 byte[]）。代表行健和列族。
* Timestamp 是一个 64 位整数（Java类型 long）。
* value 是一个未解释的字节数组（Java? 类型 byte[]）。
* 二进制数据被编码为 Base64，以便通过网络传输。
*
*
* 行键是表的主键，通常是一个字符串。行通过行键按字典顺序排序。
*
* 存储在表中的信息的结构为列族（column family，就相当于列名），您可以将这种结构视为类别。每个列族可以拥有任意数量的成员，它们通过标签（或修饰符）识别。column键（就是每列的值）由族名、：号和标签组成。例如，对于系列name和成员 first，列键为 name: first。
*
* 这个跟数据库有区分，可见，这里一行，不代表就一组数据，往往是多组数据的，一个rowkey可能对应多列的值，而每列的值（可以视为columnkey）是由列族名：标签组成），又如，name:last也是一个成员，他们都在于00001行键上，是00001行键的成员，成员值，就是value。
*
*
*
*/
package com.hsbc.hss.dao.impl;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.KeyValue;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.ZooKeeperConnectionException;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.HBaseAdmin;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
import org.apache.hadoop.hbase.filter.FilterList;
import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.log4j.Logger;
import com.hsbc.hss.dao.BaseDAO;
import com.hsbc.hss.util.CommonUtil;
import com.hsbc.hss.vo.HBaseVO;
public class HBaseDAO implements BaseDAO {
private static final Logger LOG = Logger.getLogger(HBaseDAO.class);
private static Configuration conf = null;
static {
conf = HBaseConfiguration.create();
// conf.addResource("hbase-site.xml");
// 与hbase/conf/hbase-site.xml中hbase.zookeeper.quorum配置的值相同
// HBASE_CONFIG.set("hbase.zookeeper.quorum", "10.1.1.1");
// 与hbase/conf/hbase-site.xml中hbase.zookeeper.property.clientPort配置的值相同
// HBASE_CONFIG.set("hbase.zookeeper.property.clientPort", "2181");
// conf = HBaseConfiguration.create(HBASE_CONFIG);
}
/**
*
* create table
*
* @param tablename
* @param cfs
* like the table column , HColumnDescriptor stand for the
* column's schema
* @throws IOException
*/
public static void createTable(String tablename, String[] cfs)
throws IOException {
HBaseAdmin admin = new HBaseAdmin(conf);
if (admin.tableExists(tablename)) {
LOG.error("The table is already exist.");
throw new IOException("The table is already exist.");
} else {
HTableDescriptor tableDesc = new HTableDescriptor(tablename);
for (int i = 0; i < cfs.length; i++) {
tableDesc.addFamily(new HColumnDescriptor(cfs[i])); // column
}
admin.createTable(tableDesc);
LOG.info("Create table " + tablename + " success");
}
}
/**
*
* drop table
*
* @param tablename
*
* @throws IOException
*/
public static void deleteTable(String tablename) throws IOException {
try {
HBaseAdmin admin = new HBaseAdmin(conf);
admin.disableTable(tablename);
admin.deleteTable(tablename);
} catch (MasterNotRunningException e) {
e.printStackTrace();
} catch (ZooKeeperConnectionException e) {
e.printStackTrace();
}
}
/**
* add a row .
*
* @param tablename
* @param cfs
*/
public static void writeRow(String tablename, String[] cfs) {
try {
HTable table = new HTable(conf, tablename);
Put put = new Put(Bytes.toBytes("rows1"));
for (int j = 0; j < cfs.length; j++) {
put.add(Bytes.toBytes(cfs[j]),
Bytes.toBytes(String.valueOf(1)),
Bytes.toBytes("value_1"));
table.put(put);
}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* delete a record .
*
* @param tablename
* @param rowkey
* @throws IOException
*/
public static boolean deleteRow(String tablename, String rowkey)
throws IOException {
HTable table = new HTable(conf, tablename);
Delete d1 = new Delete(rowkey.getBytes());
table.delete(d1);
return true;
}
/**
* search the all rows for table
*
* @param tablename
* @return
* @throws IOException
*/
public static List<HBaseVO> scaner(String tablename) throws IOException {
List<HBaseVO> list = new ArrayList<HBaseVO>();
HBaseVO vo = null;
HTable table = new HTable(conf, tablename);
Scan s = new Scan();
ResultScanner rs = table.getScanner(s);
for (Result r : rs) {
KeyValue[] kv = r.raw();
for (int i = 0; i < kv.length; i++) {
list.add(CommonUtil.changeKeyValueToHBaseVo(kv[i]));
}
}
return list;
}
/**
* select the hbase by rowKey , a row also may map to many HBaseVO
*
* @param tablename
* @param rowKey
* @return
* @throws Exception
*/
public static List<HBaseVO> selectByRowKey(String tablename, String rowKey) throws Exception {
List<HBaseVO> list = new ArrayList<HBaseVO>();
HTable table = new HTable(conf, tablename);
Get g = new Get(Bytes.toBytes(rowKey));
Result r = table.get(g);
for (KeyValue kv : r.raw()) {
list.add(CommonUtil.changeKeyValueToHBaseVo(kv));
}
return list;
}
/*
* rowKey + family + qualifier , may be the unique.
*/
public static HBaseVO getUniqueHBaseVOs(String tablename, String rowKey, String family,String qualifier) throws Exception {
HTable table = new HTable(conf, tablename);
Get g = new Get(Bytes.toBytes(rowKey));
g.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
Result r = table.get(g);
for (KeyValue kv : r.raw()) {
return CommonUtil.changeKeyValueToHBaseVo(kv);
}
return null;
}
/*
* actually , family equal column in hbase
*/
public static List<HBaseVO> selectByRowKeyAndFamily(String tablename, String rowKey, String column) throws Exception {
List<HBaseVO> list = new ArrayList<HBaseVO>();
HTable table = new HTable(conf, tablename);
Get g = new Get(Bytes.toBytes(rowKey));
g.addFamily(Bytes.toBytes(column)); // actually , family equal column in hbase
Result r = table.get(g);
for (KeyValue kv : r.raw()) {
list.add(CommonUtil.changeKeyValueToHBaseVo(kv));
}
return list;
}
//Filter , complex select .
/**
* for example , for the hbase's table 'scores' , records
*
* ROW COLUMN+CELL
* Jerry column=course:art, timestamp=1301294630194, value=80
* Jerry column=course:math, timestamp=1301294630132, value=100
* Jerry column=grade:, timestamp=1301294630073, value=2
* Jim column=course:art, timestamp=1301294630363, value=97
* Jim column=course:math, timestamp=1301294630305, value=100
* Jim column=grade:, timestamp=1301294630247, value=3
*
*
* the code as follow :
*
* List<String> arr=new ArrayList<String>();
* arr.add("course,art,97");
* arr.add("course,math,100");
* HBaseBasic03.selectByFilter("scores",arr);
*
* will return the
* Jim column=course:art, timestamp=1301294630363, value=97
* Jim column=course:math, timestamp=1301294630305, value=100
* Jerry column=course:math, timestamp=1301294630132, value=100
*
* these tree cells.
*
*
* @param tablename
* @param arr
* @throws IOException
*/
public static List<HBaseVO> selectByFilter(String tablename, List<String> arr)
throws IOException {
List<HBaseVO> list = new ArrayList<HBaseVO>();
HTable table = new HTable(conf, tablename);
FilterList filterList = new FilterList();
Scan s1 = new Scan();
for (String v : arr) { // 各个条件之间是“与”的关系
String[] s = v.split(",");
filterList.addFilter(new SingleColumnValueFilter(Bytes
.toBytes(s[0]), Bytes.toBytes(s[1]), CompareOp.EQUAL, Bytes
.toBytes(s[2])));
// 添加下面这一行后，则只返回指定的cell，同一行中的其他cell不返回
s1.addColumn(Bytes.toBytes(s[0]), Bytes.toBytes(s[1]));
}
s1.setFilter(filterList);
ResultScanner ResultScannerFilterList = table.getScanner(s1);
for (Result rr = ResultScannerFilterList.next(); rr != null; rr = ResultScannerFilterList
.next()) {
for (KeyValue kv : rr.list()) {
list.add(CommonUtil.changeKeyValueToHBaseVo(kv));
}
}
return list;
}
public static void main(String[] args) {
try {
String tablename = "test";
List<HBaseVO> list = scaner(tablename);
for (HBaseVO vo : list) {
LOG.info(vo);
}
LOG.info("=============1========================");
list = selectByRowKey(tablename, "row1");
for (HBaseVO vo : list) {
LOG.info(vo);
}
LOG.info("=============2========================");
list = selectByRowKeyAndFamily(tablename, "row1", "data");
for (HBaseVO vo : list) {
LOG.info(vo);
}
LOG.info("=============3========================");
List<String> arr = new ArrayList<String>();
arr.add("data,1,value1");
arr.add("data,2,value2");
list = selectByFilter(tablename, arr);
for (HBaseVO vo : list) {
LOG.info(vo);
}
LOG.info("=============4========================");
HBaseVO vo = getUniqueHBaseVOs(tablename, "row1", "data","1");
LOG.info(vo);
LOG.info("============5========================");
// String newtable = "tmp";
// String[] columns = new String[] {"f1","f2","f3","f4"};
// createTable(newtable,columns);
} catch (Exception e) {
e.printStackTrace();
}
}
}
7、集群下开发HBase
基本上访问那些是不变的，变的是hbase-site.xml
如以下配置：
<?xml version="1.0"?>
<configuration>
<!-- <property> <name>hbase.rootdir</name> <value>hdfs://192.168.1.146:2182/hbase</value>
<description>The directory shared by RegionServers. </description> </property>
<property> <name>hbase.cluster.distributed</name> <value>true</value> </property> -->
<property>
<name>hbase.cluster.distributed</name>
<value>true</value>
</property>
<property>
<name>hbase.rootdir</name>
<value>hdfs://svr2:9000/hbase</value>
</property>
<property>
<name>hbase.zookeeper.quorum</name>
<value>svr2,svr4,svr3</value>
</property>
<property>
<name>hbase.zookeeper.property.clientPort</name>
<value>2181</value>
</property>
<!-- <property> <name>hbase.tmp.dir</name> <value>E:/HSS/hbase-0.90.5/tmp/hbase/tmp</value>
<description></description> </property> -->
<!-- <property> <name>hbase.zookeeper.quorum</name> <value>192.168.1.146</value>
</property> -->
</configuration>
此外，在windows下，
还需要在C:\WINDOWS\system32\drivers\etc下的HOSTS文件增加ip
127.0.0.1 localhost
192.168.1.144 svr1
192.168.1.146 svr2
192.168.1.145 svr3
192.168.1.147 svr4
即可。
346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
