Hbase最新官方文档中文翻译与注解1-10|hbase简介与配置信息等

Bertha 。 2022-08-28 13:55 7阅读 0赞

## ![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rak55Sf5omL6K6w_size_20_color_FFFFFF_t_70_g_se_x_16][] ##

**注意：翻译的Hbase官方手册，文中黑色加粗的是官方文档中提醒用户应该注意的地方。红色加粗是作者个人经验总结分享，非官方文档里的内容。**

*  [一、简介][Link 1]
 *  [2. 快速入门 - 独立 HBase][2. _ - _ HBase]
 *  [Apache HBase 配置][Apache HBase]
    
     *  [3. 配置文件][3.]
     *  [4. 基本条件][4.]
     *  [5. HBase 运行模式：Standalone 和 Distributed][5. HBase _Standalone _ Distributed]
     *  [6. 运行并确认您的安装][6.]
     *  [7. 默认配置][7.]
     *  [8. 示例配置][8.]
     *  [9. 重要配置][9.]
     *  [10. 动态配置][10.]

# **一.前言** #

## 1.简介 ##

[快速入门][2. _ - _ HBase]将使您在 HBase 的单节点独立实例上启动并运行。

## 2. 快速入门 - 独立 HBase ##

本节介绍单节点独立 HBase 的设置。一个*独立的*实例包含所有 HBase 守护进程——Master、RegionServers 和 ZooKeeper——在一个持久化到本地文件系统的 JVM 中运行。这是我们最基本的部署配置文件。我们将向您展示如何使用`hbase shell`CLI在 HBase 中创建表、向表中插入行、对表执行放置和扫描操作、启用或禁用表以及启动和停止 HBase。

除了下载 HBase 外，此过程应该不到 10 分钟

### 2.1. JDK 版本要求 ###

HBase 要求安装 JDK。有关支持的 JDK 版本的信息，请参阅[Java][]。

### 2.2. HBase 入门 ###

*过程：以独立模式下载、配置和启动 HBase*

1.  从此[Apache 下载镜像][Apache]列表中选择一个下载站点。单击建议的顶部链接。这将带您到*HBase Releases*的镜像。单击名为*stable*的文件夹，然后将以*.tar.gz*结尾的二进制文件下载到本地文件系统。暂时不要下载以*src.tar.gz*结尾的文件。
2.  解压下载的文件，并切换到新创建的目录。
    
        $ tar xzvf hbase-3.0.0-alpha-2-SNAPSHOT-bin.tar.gz
        $ cd hbase-3.0.0-alpha-2-SNAPSHOT/
3.  您必须`JAVA_HOME`在启动 HBase 之前设置环境变量。为了更容易，HBase 允许您在*conf/hbase-env.sh*文件中设置它。您必须找到机器上安装 Java 的位置，找到它的一种方法是使用*whereis java*命令。获得位置后，编辑*conf/hbase-env.sh*文件并取消注释以*\#export JAVA\_HOME=*开头的行，然后将其设置为 Java 安装路径。
    
    *从设置了JAVA\_HOME 的hbase-env.sh中提取的示例*
    
        # 这里设置环境变量。 # 要使用的 java 实现。 导出 JAVA_HOME=/usr/jdk64/jdk1.8.0_112
4.  bin*/ start-hbase.sh*脚本是作为启动HBase的一种便捷方式。发出命令，如果一切顺利，标准输出会记录一条消息，表明 HBase 已成功启动。您可以使用该`jps`命令来验证您是否有一个名为 的正在运行的进程`HMaster`。在独立模式下，HBase 在这个单个 JVM 中运行所有守护进程，即 HMaster、单个 HRegionServer 和 ZooKeeper 守护进程。转到*[http://localhost:16010][http_localhost_16010]*查看 HBase Web UI。

*过程：首次使用 HBase*

1.  连接到 HBase。
    
    使用`hbase shell`位于HBase 安装的*bin/*目录中的命令连接到正在运行的 HBase 实例。在本示例中，省略了启动 HBase Shell 时打印的一些用法和版本信息。HBase Shell 提示以`>`字符结尾。
    
        $ ./bin/hbase shell
        hbase(main):001:0>
2.  显示 HBase Shell 帮助文本。
    
    键入`help`并按 Enter键，以显示 HBase Shell 的一些基本用法信息，以及几个示例命令。**请注意，表名、行、列都必须用引号引起来。**
3.  通过Hbase Shell创建一个表。
    
    使用该`create`命令创建一个新表。**您必须指定表名称和 ColumnFamily 名称**。
    
        hbase(main):001:0> create 'test', 'cf'
        0 row(s) in 0.4170 seconds
        
        => Hbase::Table - test
4.  列出你的所有表
    
    使用`list`命令确认你的表存在
    
        hbase(main):002:0> list 'test'
        TABLE
        test
        1 row(s) in 0.0180 seconds
        
        => ["test"]
    
    **现在使用`describe`命令查看详细表结构信息，包括配置的默认值（具体关于表结构的其他默认值的详解，参考后面）**
    
        hbase(main):003:0> describe 'test'
        Table test is ENABLED
        test
        COLUMN FAMILIES DESCRIPTION
        {NAME => 'cf', VERSIONS => '1', EVICT_BLOCKS_ON_CLOSE => 'false', NEW_VERSION_BEHAVIOR => 'false', KEEP_DELETED_CELLS => 'FALSE', CACHE_DATA_ON_WRITE =>
        'false', DATA_BLOCK_ENCODING => 'NONE', TTL => 'FOREVER', MIN_VERSIONS => '0', REPLICATION_SCOPE => '0', BLOOMFILTER => 'ROW', CACHE_INDEX_ON_WRITE => 'f
        alse', IN_MEMORY => 'false', CACHE_BLOOMS_ON_WRITE => 'false', PREFETCH_BLOCKS_ON_OPEN => 'false', COMPRESSION => 'NONE', BLOCKCACHE => 'true', BLOCKSIZE
         => '65536'}
        1 row(s)
        Took 0.9998 seconds
5.  将数据放入表中
    
    要将数据放入表中，请使用该`put`命令。
    
        hbase(main):003:0> put 'test', 'row1', 'cf:a', 'value1'
        0 row(s) in 0.0850 seconds
        
        hbase(main):004:0> put 'test', 'row2', 'cf:b', 'value2'
        0 row(s) in 0.0110 seconds
        
        hbase(main):005:0> put 'test', 'row3', 'cf:c', 'value3'
        0 row(s) in 0.0100 seconds
    
    在这里，我们使用put命令插入三个值，一次一个。注意put命令：第一个参数'test'是表名，第二个插入是rowkey,这里是 `row1`, 第三个是列族:列名，这里是 `cf:a`，最后第四个是这个列对应的值为`value1`。
    
    HBase 中的列由列族前缀组成，`cf`在本例中就是列族，后跟冒号：，然后是列限定符后缀，**a这里就是列。组合起来就是cf：a**
6.  一次扫描表格中的所有数据。
    
    从 HBase 获取数据的方法之一是扫描scan。使用该`scan`命令扫描表中的数据。您可以限制扫描(**通过各种限制条件，显示scan范围)**，这里的案例是扫描scan所有的数据。
    
        hbase(main):006:0> scan 'test'
        ROW                                      COLUMN+CELL
         row1                                    column=cf:a, timestamp=1421762485768, value=value1
         row2                                    column=cf:b, timestamp=1421762491785, value=value2
         row3                                    column=cf:c, timestamp=1421762496210, value=value3
        3 row(s) in 0.0230 seconds
7.  获取表中单行数据。
    
    要一次获取一行数据，请使用该`get`命令。（**get一次获取一行数据，所以就需要指定表名，rowkey名即可）**
    
        hbase(main):007:0> get 'test', 'row1'
        COLUMN                                   CELL
         cf:a                                    timestamp=1421762485768, value=value1
        1 row(s) in 0.0350 seconds
8.  禁用表。
    
    如果要删除表或更改其设置，以及在某些其他特殊情况下，您需要先使用该`disable`命令禁用该表。当然您可以使用该`enable`命令重新启用它。**（禁用表后不可查询等，一般生产修改表结构等需要禁用表**）
    
        hbase(main):008:0> disable 'test'
        0 row(s) in 1.1820 seconds
        
        hbase(main):009:0> enable 'test'
        0 row(s) in 0.1770 seconds
    
    如果您测试了`enable`上面的命令，请再次禁用该表：
    
        hbase(main):010:0> disable 'test'
        0 row(s) in 1.1820 seconds
9.  删除表
    
    要删除（删除）表，请使用该`drop`命令。**（注意这里更简洁，没有drop table ）**
    
        hbase(main):011:0> drop 'test'
        0 row(s) in 0.1370 seconds
        
        #注意删除表需先禁用
        hbase(main):009:0> drop 'test'
        
        ERROR: Table test is enabled. Disable it first.
        
        For usage try 'help "drop"'
10. 退出 HBase Shell。
    
    要退出 HBase Shell 并与集群断开连接，请使用该`quit`命令。（**退出的只是Hbase shell，不是停止Hbase进程）**HBase 仍在后台运行。

*过程：停止 HBase*

1.  *bin/start-hbase.sh*脚本可以方便启动所有 HBase 守护进程的方式相同，*bin/stop-hbase.sh* 脚本停止它们。
    
        $ ./bin/stop-hbase.sh
        stopping hbase....................
        $
2.  发出命令后，进程可能需要几分钟才能关闭。使用`jps`来确保 HMaster 和 HRegionServer 进程已关闭。

上面已经向您展示了如何启动和停止 HBase 的独立实例。在接下来的部分中，我们将快速概述 hbase 部署的其他模式。

### 2.3. 用于本地测试的伪分布式 ###

在完成[快速入门][2. _ - _ HBase]独立模式后，您可以重新配置 HBase 以在伪分布式模式下运行。伪分布式模式意味着 HBase 仍然完全运行在单个主机上，但每个 HBase 守护进程（HMaster、HRegionServer 和 ZooKeeper）作为一个单独的进程运行：在独立模式下，所有守护进程都在一个 jvm 进程/实例中运行。

默认情况下，除非您`hbase.rootdir`按照[快速入门中的说明][2. _ - _ HBase]配置该属性 ，否则您的数据仍存储在*/tmp/ 中*。在本演练中，我们将您的数据存储在 HDFS 中，假设您有可用的 HDFS。您可以跳过 HDFS 配置以继续将数据存储在本地文件系统中。

1. 如果 HBase 正在运行，请停止它。
 
 如果您刚刚完成[快速入门][2. _ - _ HBase]并且 HBase 仍在运行，请停止它。此过程将创建一个全新的目录，HBase 将在其中存储其数据，因此您之前创建的任何数据库都将丢失。
2. 配置 HBase。
 
 编辑*hbase-site.xml*配置。首先，添加以下属性，指示 HBase 以分布式模式运行，每个守护程序有一个 JVM 实例。
 
 <property>
 <name>hbase.cluster.distributed</name>
 <value>true</value>
 </property>
 
 接下来，`hbase.rootdir`使用`hdfs:`URI 语法添加指向 HDFS 实例地址的配置。在本例中，HDFS 在 localhost 的 8020 端口上运行。
 
 <property>
 <name>hbase.rootdir</name>
 <value>hdfs://localhost:8020/hbase</value>
 </property>
 
 您不需要在 HDFS 中创建目录。HBase 会为你做这件事。如果您创建目录，HBase 将尝试进行迁移，这不是您想要的。
 
 最后，删除如下现有的有配置：
 
 hbase.tmp.dir
 hbase.unsafe.stream.capability.enforce，
3. 启动 HBase。
 
 使用*bin/start-hbase.sh*命令启动 HBase。如果您的系统配置正确，该`jps`命令应显示正在运行的 HMaster 和 HRegionServer 进程。
4. 检查 HDFS 中的 HBase 目录。
 
 如果一切正常，HBase 在 HDFS 中创建它的目录。在上面的配置中，它存储在HDFS 上的*/hbase/*中。您可以使用`hadoop fs`命令（这个命令在hadoop/bin目录中）来列出该目录。
 
 $ ./bin/hadoop fs -ls /hbase
 Found 7 items
 drwxr-xr-x - hbase users 0 2014-06-25 18:58 /hbase/.tmp
 drwxr-xr-x - hbase users 0 2014-06-25 21:49 /hbase/WALs
 drwxr-xr-x - hbase users 0 2014-06-25 18:48 /hbase/corrupt
 drwxr-xr-x - hbase users 0 2014-06-25 18:58 /hbase/data
 -rw-r--r-- 3 hbase users 42 2014-06-25 18:41 /hbase/hbase.id
 -rw-r--r-- 3 hbase users 7 2014-06-25 18:41 /hbase/hbase.version
 drwxr-xr-x - hbase users 0 2014-06-25 21:49 /hbase/oldWALs
5. 创建一个表，并添加数据。
 
 您可以使用 HBase Shell 创建一个表，给他添加数据，扫描scan它并从中获取数据，使用与上面的shell一样的命令。
6. 启动和停止备份 HBase Master (HMaster) 服务器。
 
 <table> 
 <tbody> 
 <tr> 
 <td>在同一硬件上运行多个 HMaster 实例在生产环境中没有意义，就像在生产环境中运行伪分布式集群没有意义一样。此步骤仅用于测试和学习目的。</td> 
 </tr> 
 </tbody> 
 </table>
 
 HMaster 服务器控制 HBase 集群。**您最多可以启动 9 个备份 HMaster 服务器，总共有 10 个 HMaster，包括主服务器**。要启动备份 HMaster，请使用`local-master-backup.sh`. 对于您要启动的每个备份master，添加一个代表该主站端口偏移的参数。每个 HMaster 使用两个端口（默认为 16000 和 16010）。端口偏移量被添加到这些端口，因此使用偏移量 2，备份 HMaster 将使用端口 16002 和 16012。以下命令使用端口 16002/16012、16003/16013 和 16005/16015 启动 3 个备份服务器。
 
 $ ./bin/local-master-backup.sh start 2 3 5
 
 要在不杀死整个集群的情况下杀死一个备份主节点，您需要找到它的进程 ID（PID）。PID 存储在名称类似于*/tmp/hbase-USER-X-master.pid*的文件中。该文件的唯一内容是 PID。您可以使用该`kill -9`命令来终止该 PID。以下命令将终止端口偏移量为 1 的主节点，但保持集群运行：
 
 $ cat /tmp/hbase-testuser-1-master.pid |xargs kill -9
7. 启动和停止额外的 RegionServers
 
 **HRegionServer 按照 HMaster 的指示管理其 StoreFiles 中的数据。通常，集群中的每个节点运行一个 HRegionServer。在同一个系统上运行多个 HRegionServer 对伪分布式模式下的测试很有用**。该`local-regionservers.sh`命令允许您运行多个 RegionServers。它的工作方式与`local-master-backup.sh`命令类似，因为您提供的每个参数都代表实例的端口偏移量。每个 RegionServer 需要两个端口，默认端口为 16020 和 16030。由于 HBase 1.1.0 版本，HMaster 不使用区域服务器端口，这留下 10 个端口（16020 到 16029 和 16030 到 16039）用于 RegionServers。为了支持额外的 RegionServers，在运行脚本之前将环境变量 HBASE\_RS\_BASE\_PORT 和 HBASE\_RS\_INFO\_BASE\_PORT 设置为适当的值`local-regionservers.sh`. 例如，对于基本端口的值 16200 和 16300，可以在服务器上支持 99 个额外的 RegionServers。以下命令启动四个额外的 RegionServers，在从 16022/16032（基本端口 16020/16030 加 2）开始的顺序端口上运行。
 
 $ .bin/local-regionservers.sh start 2 3 4 5
 
 要手动停止 RegionServer，请使用`local-regionservers.sh`带有`stop`参数和要停止的服务器的偏移量的命令。
 
 .bin/local-regionservers.sh stop 3
8. 停止 HBase。
 
 您可以使用*bin/stop-hbase.sh*命令以与[快速入门][2. _ - _ HBase]过程中相同的方式停止 HBase 。

### 2.4. 完全分布式生产 ###

实际上，您需要一个完全分布式的配置来全面测试 HBase 并在实际场景中使用它。在分布式配置中，集群包含多个节点，每个节点运行一个或多个 HBase 守护进程。其中包括主备Master实例、多个ZooKeeper节点和多个RegionServer节点。

此高级快速入门将另外两个节点添加到您的集群。架构如下：

<table> 
 表 1. 分布式集群演示架构 
 <thead> 
 <tr> 
 <th style="border-color:#dedede;text-align:left;vertical-align:top;">节点名称</th> 
 <th style="border-color:#dedede;text-align:left;vertical-align:top;">Master</th> 
 <th style="border-color:#dedede;text-align:left;vertical-align:top;">zookeeper</th> 
 <th style="border-color:#dedede;text-align:left;vertical-align:top;">regionserver</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> node-a.example.com </td> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> 是的 </td> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> 是的 </td> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> 不 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> node-b.example.com </td> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> 备份 </td> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> 是的 </td> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> 是的 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> node-c.example.com </td> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> 不 </td> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> 是的 </td> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> 是的 </td> 
 </tr> 
 </tbody> 
</table>

本快速入门假设每个节点都是一个虚拟机，并且它们都在同一网络上。它建立在之前的快速入门[Pseudo-Distributed for Local Testing][]之上，假设您在该过程中配置的系统现在是`node-a`. `node-a`在继续之前停止 HBase 。

<table> 
 <tbody> 
 <tr> 
 <td>确保所有节点都具有通信的完全访问权限，并且没有防火墙规则可以阻止它们相互通信。如果您看到类似 的任何错误<code>no route to host</code>，请检查您的防火墙。</td> 
 </tr> 
 </tbody> 
</table>

*过程：配置无密码 SSH 访问*

`   node-a`需要能够登录`node-b`和`node-c`（以及登录到自己）才能启动守护进程。完成此操作的最简单方法是在所有主机上使用相同的用户名，并配置从`node-a`其他主机到其他主机的无密码 SSH 登录。

1.  在 上`node-a`，生成密钥对。
    
    运行HBase的用户身份登录后，使用以下命令生成 SSH 密钥对：
    
        $ ssh-keygen -t rsa
    
    如果命令成功，密钥对的位置将打印到标准输出。公钥的默认名称是*id\_rsa.pub*。
2.  创建将在其他节点上保存共享密钥的目录。
    
    在`node-b`和 上`node-c`，以 HBase 用户身份登录并在用户的主目录中创建一个*.ssh/*目录（如果该目录尚不存在）。如果它已经存在，请注意它可能已经包含其他键。
3.  将公钥复制到其他节点。
    
    `node-a`通过使用`scp`或其他一些安全手段，将公钥安全地复制到每个节点。在其他每个节点上，创建一个名为*.ssh/authorized\_keys* 的新文件（*如果尚不存在）*，并将*id\_rsa.pub*文件的内容附加到它的末尾。请注意，您还需要为`node-a`自己执行此操作。
    
        $ cat id_rsa.pub >> ~/.ssh/authorized_keys
4.  测试无密码登录。
    
    如果您正确执行了该过程，则在您`node-a`使用相同的用户名从其他节点通过SSH 连接时，不应提示您输入密码。
5.  由于`node-b`将运行一个备份 Master，重复上面的过程，替换`node-b`你看到的所有地方`node-a`。确保不要覆盖现有的*.ssh/authorized\_keys*文件，注意使用的是追加>>运算符而不是覆盖>运算符,将新密钥追加到现有文件上。

*程序：准备 `node-a`*

`   node-a`将运行您的主要 master 和 ZooKeeper 进程，但不会运行 RegionServers。停止 RegionServer 从 开始`node-a`。

1. 编辑*conf/regionservers*并删除包含`localhost`. 添加node-b和node-c的主机名或IP地址行。
 
 即使您确实想在节点a上运行RegionServer，您也应该通过其他服务器用于与之通信的主机名来引用它。在本例中，它是node-a.example.com。这使您能够将配置分发到集群的每个节点，以避免主机名冲突。保存文件。
2. 将 HBase 配置为`node-b`用作备份Master节点
 
 在*conf/ 中*创建一个名为*backup-masters*的新文件，并在其中添加一个新行，主机名为`node-b`. 在本演示中，主机名是`node-b.example.com`.
3. 配置 ZooKeeper
 
 实际上，您应该仔细考虑您的 ZooKeeper 配置。您可以在[zookeeper][]部分找到有关配置 ZooKeeper 的更多信息。此配置将指示 HBase 在集群的每个节点上启动和管理 ZooKeeper 实例。
 
 在 上`node-a`，编辑*conf/hbase-site.xml*并添加以下属性。
 
 <property>
 <name>hbase.zookeeper.quorum</name>
 <value>node-a.example.com,node-b.example.com,node-c.example.com</value>
 </property>
 <property>
 <name>hbase.zookeeper.property.dataDir</name>
 <value>/usr/local/zookeeper</value>
 </property>
4. 在配置中将node-a引用为localhost的任何地方，都需要将引用改为指向其他节点将使用的主机名。在本示例中，主机名是node-a.example.com。

*程序：准备`node-b`和`node-c`*

`   node-b` 将运行一个备份Master和一个 ZooKeeper 实例。

1.  下载并解压 HBase。
    
    下载 HBase 并将其解压到`node-b`，就像您在独立和伪分布式快速入门中所做的一样。
2.   **将配置文件从`node-a复制到node-b和``node-c同名目录下`**
    
    集群的每个节点都需要具有相同的配置信息。将node-a的*conf /*目录下文件复制到`node-b`和`node-c的/conf目录下`

*过程：启动并测试您的集群*

1. 确保 HBase 未在任何节点上运行。
 
      如果您在之前的测试中忘记停止 HBase，则会出现错误。使用`jps`命令检查 HBase 是否正在您的任何节点上运行，可以查看`HMaster`，`HRegionServer`和`HQuorumPeer这些进程是否存在`。如果它们存在，就杀死它们。
2. 启动集群。
 
 在 上`node-a`，发出`start-hbase.sh`命令。您的输出将类似于下面的输出。
 
 $ bin/start-hbase.sh
 node-c.example.com: starting zookeeper, logging to /home/hbuser/hbase-0.98.3-hadoop2/bin/../logs/hbase-hbuser-zookeeper-node-c.example.com.out
 node-a.example.com: starting zookeeper, logging to /home/hbuser/hbase-0.98.3-hadoop2/bin/../logs/hbase-hbuser-zookeeper-node-a.example.com.out
 node-b.example.com: starting zookeeper, logging to /home/hbuser/hbase-0.98.3-hadoop2/bin/../logs/hbase-hbuser-zookeeper-node-b.example.com.out
 starting master, logging to /home/hbuser/hbase-0.98.3-hadoop2/bin/../logs/hbase-hbuser-master-node-a.example.com.out
 node-c.example.com: starting regionserver, logging to /home/hbuser/hbase-0.98.3-hadoop2/bin/../logs/hbase-hbuser-regionserver-node-c.example.com.out
 node-b.example.com: starting regionserver, logging to /home/hbuser/hbase-0.98.3-hadoop2/bin/../logs/hbase-hbuser-regionserver-node-b.example.com.out
 node-b.example.com: starting master, logging to /home/hbuser/hbase-0.98.3-hadoop2/bin/../logs/hbase-hbuser-master-nodeb.example.com.out
 
 ZooKeeper 首先启动，然后是 master，然后是 RegionServers，最后是备份 master。
3. 验证进程是否正在运行。
 
      在集群的每个节点上，运行`jps`命令并验证每个服务器上运行的进程是否正确。如果有其他 Java 进程用于其他目的，您可能还会看到服务器上运行的其他 Java 进程。
 
 *`node-a` `jps` 输出*
 
 $ jps
 20355 Jps
 20071 HQuorumPeer
 20137 HMaster
 
 *`node-b` `jps` 输出*
 
 $ jps
 15930 HRegionServer
 16194 Jps
 15838 HQuorumPeer
 16010 HMaster
 
 *`node-c` `jps` 输出*
 
 $ jps
 13901 Jps
 13639 HQuorumPeer
 13737 HRegionServer
 
 <table> 
 <tbody> 
 <tr> 
 <td> 
 <div style="margin-left:.25em;text-align:left;"> 
 ZooKeeper 进程名称 
 </div> 
 <div style="margin-left:0;"> 
 该<code>HQuorumPeer</code>进程是一个由 HBase 控制和启动的 ZooKeeper 实例。如果您以这种方式使用 ZooKeeper，则它仅限于每个集群节点一个实例，并且仅适用于测试。如果 ZooKeeper 在 HBase 之外运行，则该过程称为<code>QuorumPeer</code>。有关 ZooKeeper 配置的更多信息，包括将外部 ZooKeeper 实例与 HBase 一起使用，请参阅<a href="http://hbase.apache.org/book.html#zookeeper" title="zookeeper" rel="nofollow">zookeeper</a>部分。 
 </div> </td> 
 </tr> 
 </tbody> 
 </table>
4. 浏览到 Web UI。
 
 <table> 
 <tbody> 
 <tr> 
 <td> 
 <div style="margin-left:.25em;text-align:left;"> 
 Web UI 端口更改 
 </div> 
 <div style="margin-left:0;"> 
 在0.98.x以上的HBase中，HBase Web UI使用的HTTP端口从Master的60010和每个RegionServer的60030变为Master的16010和RegionServer的16030。 
 </div> </td> 
 </tr> 
 </tbody> 
 </table>
 
 如果一切设置正确，您应该能够 使用 Web 浏览器连接到 Master`http://node-a.example.com:16010/`或辅助Master 的 UI `http://node-b.example.com:16010/`。如果您可以通过`localhost`但不能从其他主机连接，请检查您的防火墙规则。您可以在其 IP 地址的端口 16030 处查看每个 RegionServers 的 Web UI，或者通过单击它们在 Master 的 Web UI 中的链接。
5. 测试当节点或服务消失时会发生什么。
 
 使用您配置的三个节点集群，测试不会非常有弹性（**因为三个节点可以测试的范围有限，3个以上节点测试的变量更多）**。但您仍然可以通过杀死相关进程并查看其日志来测试主 Master 或 RegionServer 的行为。

### 2.5. 下一步去哪里 ###

下一章，[配置][Apache HBase]，提供有关不同 HBase 运行模式、运行 HBase 的系统要求以及设置分布式 HBase 集群的关键配置区域的更多信息。

# 二.Apache HBase 配置 #

本章扩展了[入门][Link 2]章节，以进一步解释 Apache HBase 的配置。请仔细阅读本章，尤其是 [基本前提条件，][4.]以确保您的 HBase 测试和部署顺利进行。熟悉[支持和测试期望][Link 3]。

## 3. 配置文件 ##

Apache HBase 使用与 Apache Hadoop 相同的配置系统。所有配置文件都位于*conf/*目录中，需要为集群上的每个节点保持同步。

*HBase 配置文件说明*

***backup-masters***

默认情况下不存在。一个纯文本文件，其中列出了 Master 应该在其上启动备份 Master 进程的主机，每行一个主机。

***hadoop-metrics2-hbase.properties***

用于连接HBase Hadoop的Metrics2框架。有关 Metrics2 的更多信息，请参阅[Hadoop Wiki 条目][Hadoop Wiki]。默认情况下仅包含注释掉的示例。

***hbase-env.cmd*和*hbase-env.sh***

适用于 Windows 和 Linux / Unix 环境的脚本，用于设置 HBase 的工作环境，包括 Java 的位置、Java 选项和其他环境变量。该文件包含许多注释掉的示例以提供指导。

***hbase-policy.xml***

RPC 服务器用于对客户端请求做出授权决策的默认策略配置文件。仅在启用HBase[安全性时][Link 4]使用。

***hbase-site.xml***

主要的 HBase 配置文件。此文件指定覆盖 HBase 的默认配置的配置选项**。您可以在*hbase-common/src/main/resources/hbase-default.xml*查看（但不要编辑）默认配置文件**。您还可以在 HBase Web UI的HBase 配置选项卡中查看集群的整个有效配置（默认和覆盖）。

***log4j2.xml***

用于 HBase 日志记录的配置文件`log4j2`。

***regionservers***

** 一个纯文本文件，其中包含应该在 HBase 集群中运行 RegionServer 的主机列表**。默认情况下，此文件包含单个条目`localhost`. 它应该包含一个主机名或 IP 地址列表，每行一个，并且应该只包含 `localhost`集群中的每个节点是否将在其`localhost`接口上运行 RegionServer 。

## 4. 基本条件 ##

本节列出了必需的服务和一些必需的系统配置。

Java

HBase 在 Java 虚拟机上运行，因此所有 HBase 部署都需要 JVM 运行时。

下表总结了 HBase 社区关于在各种 Java 版本上运行的建议。这符号表示测试的基本水平以及帮助诊断和解决您可能遇到的问题的意愿；这些是预期的部署组合。一个条目 意味着这种组合可能存在挑战，在决定将其作为部署策略之前，您应该寻找更多信息。这表示这种组合不起作用；

HBase 社区认为较旧的 Java 版本已弃用，或者已知这种组合不起作用。对于较新的 JDK 与较旧的 HBase 版本的组合，很可能存在我们的兼容性保证无法解决的已知兼容性问题，因此无法进行组合。在某些情况下，还注明了有关限制的具体指南（例如，编译/单元测试是否有效、特定的操作问题等）。假设此处未列出的任何组合都被考虑在内.

<table> 
 <tbody> 
 <tr> 
 <td> 
 <div style="margin-left:.25em;text-align:left;"> 
 推荐长期支持 JDK 
 </div> 
 <div style="margin-left:0;"> 
 HBase 建议下游用户仅依赖标记为长期支持 (LTS) 的 JDK 版本，无论是来自 OpenJDK 项目还是供应商。在撰写本文时，以下 JDK 版本不是 LTS 版本，并且未经 Apache HBase 社区测试或提倡使用：JDK9、JDK10、JDK12、JDK13 和 JDK14。围绕此决定的社区讨论记录在<a href="https://issues.apache.org/jira/browse/HBASE-20264" title="HBASE-20264 上" rel="nofollow">HBASE-20264 上</a>。 
 </div> </td> 
 </tr> 
 </tbody> 
</table>

<table> 
 表 2. Hbase发行版的Java 支持 
 <img alt="" height="302" src="https://img-blog.csdnimg.cn/20210921104321827.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5rak55Sf5omL6K6w,size_20,color_FFFFFF,t_70,g_se,x_16" width="801"> 
 <tbody> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:center;vertical-align:middle;"> </td> 
 </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
 <tr> 
 <td> 
 <div style="margin-left:.25em;text-align:left;"> 
 关于 JDK11 的说明&nbsp;* 
 </div> 
 <div style="margin-left:0;"> 
 HBase 2.3.0 引入了对 JDK11 的初步支持。这种支持仅限于编译和运行完整的测试套件。关于 JDK11 与 Apache ZooKeeper 和 Apache Hadoop (&nbsp;<a href="https://issues.apache.org/jira/browse/HADOOP-15338" title="HADOOP-15338" rel="nofollow">HADOOP-15338</a>&nbsp;)的运行时兼容性存在未决问题。值得注意的是，这两个项目都尚未发布明确支持 JDK11 的运行时版本。HBase 中剩余的已知问题在<a href="https://issues.apache.org/jira/browse/HBASE-22972" title="HBASE-22972 中" rel="nofollow">HBASE-22972 中</a>进行了编目&nbsp;。 
 </div> </td> 
 </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
 <tr> 
 <td>您必须<code>JAVA_HOME</code>在集群的每个节点上进行设置。hbase-env.sh提供了一个方便的机制来做到这一点。</td> 
 </tr> 
 </tbody> 
</table>

### *操作系统实用程序* ###

**1.SSH**

HBase 广泛使用 Secure Shell (ssh) 命令和实用程序在集群节点之间进行通信。集群中的每个服务器都必须运行，`ssh`以便可以管理 Hadoop 和 HBase 守护进程。您必须能够通过 SSH 连接到所有节点，包括本地节点，从 Master 和任何备份 Master，使用共享密钥而不是密码。您可以在“[过程：配置无密码 SSH 访问][SSH]”中[查看][SSH]在 Linux 或 Unix 系统中进行此类设置的基本方法。如果您的集群节点使用 OS X，请参阅 Hadoop wiki 上的[SSH：设置远程桌面和启用自登录部分][SSH 1]。

**2.DNS**

HBase 使用本地主机名自行报告其 IP 地址。

**3.NTP**

集群节点上的时钟应该同步。少量的变化是可以接受的，但大量的偏差会导致不稳定和意外的行为。如果您在集群中发现无法解释的问题，时间同步是首先要检查的事情之一。建议您在集群上运行网络时间协议 (NTP) 服务或其他时间同步机制，并且所有节点都寻找相同的服务进行时间同步。请参阅 [基本NTP配置][NTP]在 *Linux文档项目（TLDP）*成立NTP。

**4.文件和进程数限制 (ulimit)**

Apache HBase 是一个数据库。它需要能够一次打开大量文件。许多 Linux 发行版限制了单个用户可以打开的文件数量`1024`（或`256` 在旧版本的 OS X 上）。`ulimit -n`当以运行 HBase 的用户身份登录时，您可以通过运行命令来检查服务器上的此限制 。如果限制太低，您可能会遇到一些问题，请参阅 [故障排除部分][Link 5]。您可能还会注意到以下错误：

2010-04-06 03:04:37,542 INFO org.apache.hadoop.hdfs.DFSClient: Exception increateBlockOutputStream java.io.EOFException
    2010-04-06 03:04:37,542 INFO org.apache.hadoop.hdfs.DFSClient: Abandoning block blk_-6935524980745310745_1391901

**建议将 ulimit 提高到至少 10,000，但更有可能提高到 10,240，因为该值通常以 1024 的倍数表示。每个 ColumnFamily 至少有一个 StoreFile，如果区域负载不足，则可能超过六个 StoreFile。所需打开文件的数量取决于 ColumnFamilies 的数量和区域的数量。以下是计算 RegionServer 上潜在打开文件数的粗略公式。**

*计算打开文件的潜在数量*

(StoreFiles per ColumnFamily) x (regions per RegionServer)

例如，假设一张表每个region有 3 个 ColumnFamilies，每个 ColumnFamily 平均有 3 个 StoreFiles，并且每个 RegionServer 有 100 个区域，JVM 将打开`3 * 3 * 100 = 900` 文件描述符，不计算打开的 JAR 文件、配置文件等。打开文件不会占用很多资源，并且允许用户打开过多文件的风险很小。

另一个相关设置是允许用户一次运行的进程数。在 Linux 和 Unix 中，进程数是使用`ulimit -u`命令设置的。这不应与`nproc`命令混淆，该命令控制给定用户可用的 CPU 数量。在负载下，a`ulimit -u`太低会导致 OutOfMemoryError 异常。

**为运行 HBase 进程的用户配置最大文件描述符和进程数是操作系统配置，而不是 HBase 配置**。确保为实际运行 HBase 的用户更改设置也很重要。要查看哪个用户启动了 HBase，以及该用户的 ulimit 配置，请查看该实例的 HBase 日志的第一行。

*示例 1. `ulimit `Ubuntu 上的设置*

要在 Ubuntu 上配置 ulimit 设置，请编辑*/etc/security/limits.conf*，这是一个以空格分隔的四列文件。有关此文件格式的详细信息，请参阅*limits.conf*的手册页。在以下示例中，第一行将用户名为 hadoop 的操作系统用户的打开文件数 (nofile) 的软限制和硬限制设置为 32768。第二行将同一用户的进程数设置为 32000。

hadoop  -       nofile  32768
    hadoop  -       nproc   32000

这些设置仅在可插拔身份验证模块 (PAM) 环境被定向使用时才应用。要将 PAM 配置为使用这些限制，请确保*/etc/pam.d/common-session* 文件包含以下行：

session required  pam_limits.so

**Linux外壳**

HBase 附带的所有 shell 脚本都依赖于 [GNU Bash][] shell。

**windows**

不建议在 Windows 机器上运行生产系统。

### 4.1. [Hadoop][] ###

下表总结了每个 HBase 版本支持的 Hadoop 版本。未出现在此表中的旧版本被视为不受支持且可能缺少必要的功能，而新版本未经测试但可能适用。

根据 HBase 的版本，您应该选择最合适的 Hadoop 版本。您可以使用 Apache Hadoop 或供应商分发的 Hadoop。这里不做区分。有关[Hadoop][Hadoop 1] 供应商的信息，请参阅 [Hadoop wiki][Hadoop 1]。

<table> 
 <tbody> 
 <tr> 
 <td> 
 <div style="margin-left:.25em;text-align:left;"> 
 推荐使用 Hadoop 2.x。 
 </div> 
 <div style="margin-left:0;"> 
 Hadoop 2.x 速度更快，并且包含短路读取等功能（请参阅&nbsp;<a href="http://hbase.apache.org/book.html#perf.hdfs.configs.localread" title="利用本地数据" rel="nofollow">利用本地数据</a>），这将有助于改进您的 HBase 随机读取配置文件。Hadoop 2.x 还包括重要的错误修复，可改善您的整体 HBase 体验。HBase 不支持与早期版本的 Hadoop 一起运行。有关特定于不同 HBase 版本的要求，请参阅下表。 
 </div> 
 <div style="margin-left:0;"> 
 Hadoop 3.x 仍处于早期访问版本，尚未经过 HBase 社区针对生产用例的充分测试。 
 </div> </td> 
 </tr> 
 </tbody> 
</table>

使用以下图例来解释此表：

*Hadoop 版本支持矩阵*

*   = 经测试功能齐全
 *  = 已知功能[不全][Link 6]，或者存在 [CVE，][Link 6]因此我们放弃了对较新的次要版本的支持
 *   = 未测试，可能/可能不工作

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rak55Sf5omL6K6w_size_20_color_FFFFFF_t_70_g_se_x_16 1][]

<table> 
 <tbody> 
 <tr> 
 <td> 
 <div style="margin-left:.25em;text-align:left;"> 
 Hadoop 2.y.0 版本 
 </div> 
 <div style="margin-left:0;"> 
 从 Hadoop 版本 2.7.0 开始，Hadoop PMC 养成了在其主要版本 2 发布线上调用新的次要版本的习惯，认为它们不稳定/生产就绪。因此，HBase 明确建议下游用户避免在这些版本之上运行。请注意，Hadoop PMC 还对 2.8.1 版本给出了相同的警告。如需参考，请参阅<a href="https://s.apache.org/hadoop-2.7.0-announcement" title="Apache Hadoop 2.7.0" rel="nofollow">Apache Hadoop 2.7.0</a>、&nbsp;<a href="https://s.apache.org/hadoop-2.8.0-announcement" title="Apache Hadoop 2.8.0" rel="nofollow">Apache Hadoop 2.8.0</a>、&nbsp;<a href="https://s.apache.org/hadoop-2.8.1-announcement" title="Apache Hadoop 2.8.1" rel="nofollow">Apache Hadoop 2.8.1</a>和&nbsp;<a href="https://s.apache.org/hadoop-2.9.0-announcement" title="Apache Hadoop 2.9.0" rel="nofollow">Apache Hadoop 2.9.0</a>的发布公告。 
 </div> </td> 
 </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
 <tr> 
 <td> 
 <div style="margin-left:.25em;text-align:left;"> 
 用 HBase 替换捆绑的 Hadoop！ 
 </div> 
 <div style="margin-left:0;"> 
 因为 HBase 依赖于 Hadoop，所以它在其lib目录下捆绑了 Hadoop jar&nbsp;。捆绑的 jar 仅用于独立模式。在分布式模式下，集群上的 Hadoop 版本与 HBase 下的版本匹配至关重要。将 HBase lib 目录中的 hadoop jar 替换为您在集群上运行的版本中的等效 hadoop jar，以避免版本不匹配问题。确保在整个集群中替换 HBase 下的 jar。Hadoop版本不匹配问题有多种表现形式。如果 HBase 出现挂起，请检查是否不匹配。 
 </div> </td> 
 </tr> 
 </tbody> 
</table>

**4.1.1. `dfs.datanode.max.transfer.threads`**

一个 HDFS DataNode 对它在任何时候将服务的文件数量有一个上限。在进行任何加载之前，请确保您已配置 Hadoop 的*conf/hdfs-site.xml*，`dfs.datanode.max.transfer.threads`至少将值设置 为以下内容：

<property>
 <name>dfs.datanode.max.transfer.threads</name>
 <value>4096</value>
 </property>

确保在进行上述配置后重新启动 HDFS。

没有这种配置会导致看起来很奇怪的失败。一种表现是对丢失块的抱怨。例如：

10/12/08 20:10:31 INFO hdfs.DFSClient: Could not obtain block
              blk_XXXXXXXXXXXXXXXXXXXXXX_YYYYYYYY from any node: java.io.IOException: No live nodes
              contain current block. Will get new block locations from namenode and retry...

另请参阅[casetudies.max.transfer.threads][]并注意此属性以前称为`dfs.datanode.max.xcievers`（例如 [Hadoop HDFS：Deceived by Xciever][Hadoop HDFS_Deceived by Xciever]）。

### 4.2. ZooKeeper 要求 ###

需要 Apache ZooKeeper 仲裁。确切的版本取决于您的 HBase 版本，尽管最低 ZooKeeper 版本是 3.4.x，因为该`useMulti`功能在 1.0.0 中默认设置（请参阅[HBASE-16598][]）。

## 5. HBase 运行模式：Standalone 和 Distributed ##

HBase 有两种运行模式：[独立][Link 7]和[分布式][Link 8]。开箱即用，HBase 以独立模式运行。无论您使用哪种模式，您都需要通过编辑 HBase /*conf*目录中的文件来配置 HBase 。至少您必须编辑conf/hbase-env.sh以告诉 HBase 使用哪个 java。在此文件中，您可以设置 HBase 环境变量，例如 heapsize 和其他选项 `JVM`、日志文件的首选位置等。将JAVA\_HOME 设置为指向 Java 安装的根目录。

### 5.1. 独立 HBase ###

这是默认模式。独立模式是[快速入门][2. _ - _ HBase]部分中描述的内容。在独立模式下，HBase 不使用 HDFS——而是使用本地文件系统——并且它在同一个 JVM 中运行所有 HBase 守护进程和本地 ZooKeeper。ZooKeeper 绑定到一个众所周知的端口，因此客户端可以与 HBase 通信。

5.1.1. HDFS 上的独立 HBase

独立 hbase 的一个变体让所有守护进程在一个 JVM 内运行，但不是持久化到本地文件系统，而是持久化到 HDFS 实例。

当您打算使用简单的部署配置文件时，您可能会考虑使用此配置文件，负载很轻，但数据必须在节点进出时保持不变。写入复制数据的 HDFS 可确保后者。

要配置此独立变体，请编辑*hbase-site.xml* 设置*hbase.rootdir* 以指向 HDFS 实例中的目录，然后将*hbase.cluster.distributed*设置 为*false*。例如：

### 5.2. 分布式的Hbase ###

分布式模式可以细分为伪分布式，即所有守护程序都运行在单个节点上和*完全分布式*，其中守护程序分布在集群中的所有节点上。在*伪分布式模式*与*完全分布式*的命名来自于Hadoop的。

伪分布式模式可以针对本地文件系统运行，也可以针对*Hadoop 分布式文件系统*(HDFS)的实例运行。完全分布式模式只能在 HDFS 上运行。有关如何设置 HDFS，请参阅 Hadoop[文档][Link 9]。在 Hadoop 2 上设置 HDFS 的一个很好的演练可以在[Hadoop YARN Installation: The definitive guide | Alex JF][Hadoop YARN Installation_ The definitive guide _ Alex JF]找到 。

5.2.1. 伪分布式

伪分布式模式只是在单个主机上运行的完全分布式模式。将此 HBase 配置仅用于测试和原型设计目的。不要将此配置用于生产或性能评估。

### 5.3. 完全分布式 ###

默认情况下，HBase 以独立模式运行。单机模式和伪分布式模式都是为了小规模测试而提供的。对于生产环境，建议采用完全分布式模式。在完全分布式模式下，HBase 守护进程的多个实例在集群中的多个服务器上运行。

** 就像在伪分布式模式下一样，完全分布式配置要求您将`hbase.cluster.distributed`属性设置 为`true`。通常，`hbase.rootdir`配置为指向高度可用的 HDFS 文件系统。**

此外，集群配置为多个集群节点登记为 RegionServers、ZooKeeper QuorumPeers 和备份 HMaster 服务器。这些配置基础都在[quickstart-fully-distributed 中][quickstart-fully-distributed]演示。

***分布式区域服务器***

通常，您的集群将包含多个运行在不同服务器上的 RegionServer，以及主要和备份 Master 和 ZooKeeper 守护进程。该*CONF / regionservers*在主服务器上的文件中包含主机，其RegionServers与该集群相关的列表。每个主机都在单独的行上。当主服务器启动或停止时，此文件中列出的所有主机都会启动和停止它们的 RegionServer 进程。

***ZooKeeper 和 HBase***

有关HBase 的 ZooKeeper 设置说明，请参阅[ZooKeeper][zookeeper]部分。

*示例 2. 分布式 HBase 集群示例*

这是分布式 HBase 集群的基本*conf/hbase-site.xml*。用于实际工作的集群将包含更多自定义配置参数。大多数 HBase 配置指令都有默认值，除非该值在*hbase-site.xml 中*被覆盖，否则会使用默认值。有关详细信息，请参阅“[配置文件][7.]”。

<configuration>
 <property>
 <name>hbase.rootdir</name>
 <value>hdfs://namenode.example.org:8020/hbase</value>
 </property>
 <property>
 <name>hbase.cluster.distributed</name>
 <value>true</value>
 </property>
 <property>
 <name>hbase.zookeeper.quorum</name>
 <value>node-a.example.com,node-b.example.com,node-c.example.com</value>
 </property>
 </configuration>

这是一个示例*conf/regionservers*文件，其中包含应该在集群中运行 RegionServer 的节点列表。这些节点需要安装 HBase，并且它们需要使用与主服务器相同的*conf/*目录内容。

node-a.example.com
    node-b.example.com
    node-c.example.com

这是一个示例*conf/backup-masters*文件，其中包含应该运行备份 Master 实例的每个节点的列表。除非主 Master 变得不可用，否则备份 Master 实例将处于空闲状态。

node-b.example.com
    node-c.example.com

***分布式 HBase 快速入门***

有关具有多个 ZooKeeper、备份 HMaster 和 RegionServer 实例的简单三节点集群配置的演练，请参阅[快速入门全分布式][quickstart-fully-distributed]。

*过程：HDFS 客户端配置*

1.  值得注意的是，如果您在 Hadoop 集群上进行了 HDFS 客户端配置更改，例如 HDFS 客户端的配置指令，而不是服务器端配置，则必须使用以下方法之一来使 HBase 能够查看和使用这些配置更改：
    
    添加HADOOP\_CONF\_DIR的环境变量指向*hbase-env.sh中，其次*在*$\{HBASE\_HOME\}/conf*下添加*hdfs-site.xml*（或*hadoop-site.xml*）或更好的软链到这个文件；最后如果只有少量的HDFS客户端配置,将它们添加到hbase-site.xml。

这种 HDFS 客户端配置的一个例子是`dfs.replication`. 例如，如果您想以 5 的复制因子运行，HBase 将创建默认值为 3 的文件，除非您执行上述操作以使配置可用于 HBase。

## 6. 运行并确认您的安装 ##

首先确保 HDFS 正在运行。通过在`HADOOP_HOME`目录下运行*bin/start-hdfs.sh*来启动和停止 Hadoop HDFS 守护进程。您可以通过测试`put`和`get`文件到 Hadoop 文件系统来确保它正确启动。**HBase 通常不使用 MapReduce 或 YARN 守护进程。这些不需要启动。**

*如果*您正在管理自己的 ZooKeeper，请启动它并确认它正在运行，否则 HBase 将为您启动 ZooKeeper 作为其启动过程的一部分。

使用以下命令启动 HBase：

bin/start-hbase.sh

从`HBASE_HOME`目录下运行上面的内容。

您现在应该有一个正在运行的 HBase 实例。**HBase 日志可以在*logs*子目录中找到。检查它们，尤其是在 HBase 启动时遇到问题时。**

HBase 还提供了一个列出重要属性的 UI。默认情况下，它部署在 Master 主机的 16010 端口（HBase RegionServers 默认侦听端口 16020，并在端口 16030 放置一个信息性 HTTP 服务器）。如果 Master  `master.example.org`在以默认端口命名的主机上运行，请将浏览器指向 http://master.example.org:16010 以查看 Web 界面。

HBase 启动后，请参阅[shell 练习][shell]部分，了解如何创建表、添加数据、扫描插入以及最后禁用和删除表。

要在退出 HBase shell 后停止 HBase，请输入

$ ./bin/stop-hbase.sh
    stopping hbase...............

**关闭可能需要一些时间才能完成。如果您的集群由许多机器组成，则可能需要更长的时间。如果您正在运行分布式操作，请确保在停止 Hadoop 守护进程之前等待 HBase 完全关闭。**

## 7. 默认配置 ##

### 7.1. *hbase-site.xml*和*hbase-default.xml* ###

就像在 Hadoop 中将特定于站点的 HDFS 配置添加到*hdfs-site.xml*文件一样，对于 HBase，特定于站点的自定义进入文件*conf/hbase-site.xml*。有关可配置属性的列表，请参阅下面的[hbase 默认配置][hbase]**或在*src/main/resources*处查看HBase 源代码中的原始*hbase-default.xml*源文件。**

**并非所有配置选项都适用于*hbase-default.xml*。有些配置只会出现在源代码中；识别这些更改的唯一方法是通过代码审查。**

**目前，此处的更改需要重启集群才能让 HBase 注意到更改。**

### 7.2. HBase 默认配置 ###

下面的文档是使用默认的 hbase 配置文件*hbase-default.xml*作为源生成的。

`hbase.tmp.dir`

*描述*

**本地文件系统上的临时目录。将此设置更改为指向比“/tmp”更持久的位置，这是 java.io.tmpdir 的常用解析，因为“/tmp”目录在机器重新启动时被清除。**

*默认*

`${java.io.tmpdir}/hbase-${user.name}`

`hbase.rootdir`

*描述*

region server共享的目录，HBase数据保存在该目录中。URL 应该是“完全限定的”以包含文件系统方案。例如，要指定 HDFS 实例的 namenode 在端口 9000 上的 namenode.example.org 上运行的 HDFS 目录“/hbase”，请将此值设置为：hdfs://namenode.example.org:9000/hbase。默认情况下，我们也会写入 $\{hbase.tmp.dir\} 设置的任何内容 - 通常是 /tmp - 所以更改此配置，否则所有数据将在机器重启时丢失。

*默认*

`${hbase.tmp.dir}/hbase`

`hbase.cluster.distributed`

*描述*

集群将处于的模式。独立模式的可能值为 false，分布式模式的可能值为 true。如果为 false，则启动将在一个 JVM 中一起运行所有 HBase 和 ZooKeeper 守护程序。

*默认*

`false`

`hbase.zookeeper.quorum`

*描述*

ZooKeeper 集合中以逗号分隔的服务器列表（此配置应命名为 hbase.zookeeper.ensemble）。例如，“host1.mydomain.com,host2.mydomain.com,host3.mydomain.com”。默认情况下，对于本地和伪分布式操作模式，这设置为 localhost。对于完全分布式设置，这应该设置为 ZooKeeper 集成服务器的完整列表。如果在 hbase-env.sh 中设置了 HBASE\_MANAGES\_ZK，这是 hbase 将在集群启动/停止过程中启动/停止 ZooKeeper 的服务器列表。在客户端，我们将把这个 ensemble 成员列表与 hbase.zookeeper.property.clientPort 配置放在一起。并将其作为 connectString 参数传递给 zookeeper 构造函数。

*默认*

`127.0.0.1`

`zookeeper.recovery.retry.maxsleeptime`

*描述*

重试zookeeper操作之前的最大睡眠时间（以毫秒为单位），这里需要一个最大时间，以便睡眠时间不会无限制地增长

*默认*

`60000`

`hbase.local.dir`

*描述*

要用作本地存储的本地文件系统上的目录。

*默认*

`${hbase.tmp.dir}/local/`

`hbase.master.port`

*描述*

HBase Master 应该绑定的端口。

*默认*

`16000`

`hbase.master.info.port`

*描述*

HBase Master Web UI 的端口。如果您不想运行 UI 实例，请设置为 -1。

*默认*

`16010`

`hbase.master.info.bindAddress`

*描述*

HBase Master web UI 的绑定地址

*默认*

`0.0.0.0`

`hbase.master.logcleaner.plugins`

*描述*

LogsCleaner 服务调用的 BaseLogCleanerDelegate 的逗号分隔列表。这些 WAL 清洁器是按顺序调用的，因此将修剪最多文件的清洁器放在前面。要实现自己的 BaseLogCleanerDelegate，只需将其放在 HBase 的类路径中并在此处添加完全限定的类名。始终在列表中添加上述默认日志清理器。

*默认*

`org.apache.hadoop.hbase.master.cleaner.TimeToLiveLogCleaner,org.apache.hadoop.hbase.master.cleaner.TimeToLiveProcedureWALCleaner,org.apache.hadoop.hbase.master.cleaner.TimeToLiveMasterLocalStoreWALCleaner`

`hbase.master.logcleaner.ttl`

*描述*

WAL 在存档 (\{hbase.rootdir\}/oldWALs) 目录中保留多长时间，之后它将被主线程清理。该值以毫秒为单位。

*默认*

`600000`

`hbase.master.hfilecleaner.plugins`

*描述*

由 HFileCleaner 服务调用的 BaseHFileCleanerDelegate 的逗号分隔列表。这些 HFiles 清理器是按顺序调用的，因此将修剪最多文件的清理器放在前面。要实现您自己的 BaseHFileCleanerDelegate，只需将其放在 HBase 的类路径中并在此处添加完全限定的类名。始终在列表中添加上述默认 hfile 清洁器，因为它们将在 hbase-site.xml 中被覆盖。

*默认*

`org.apache.hadoop.hbase.master.cleaner.TimeToLiveHFileCleaner,org.apache.hadoop.hbase.master.cleaner.TimeToLiveMasterLocalStoreHFileCleaner`

`hbase.master.infoserver.redirect`

*描述*

Master 是否侦听 Master Web UI 端口（hbase.master.info.port）并将请求重定向到 Master 和 RegionServer 共享的 Web UI 服务器。配置。当 Master 为 Region 提供服务时（不是默认的）是有意义的。

*默认*

`true`

`hbase.master.fileSplitTimeout`

*描述*

拆分区域，在中止尝试之前等待文件拆分步骤的时间。默认值：600000。此设置在 hbase-1.x 中以前称为 hbase.regionserver.fileSplitTimeout。拆分现在在主端运行，因此重命名（如果找到“hbase.master.fileSplitTimeout”设置，将使用它来启动当前的“hbase.master.fileSplitTimeout”配置。

*默认*

`600000`

`hbase.regionserver.port`

*描述*

HBase RegionServer 绑定的端口。

*默认*

`16020`

`hbase.regionserver.info.port`

*描述*

如果您不希望 RegionServer UI 运行，则 HBase RegionServer Web UI 的端口设置为 -1。

*默认*

`16030`

`hbase.regionserver.info.bindAddress`

*描述*

HBase RegionServer web UI 的地址

*默认*

`0.0.0.0`

`hbase.regionserver.info.port.auto`

*描述*

Master 或 RegionServer UI 是否应该搜索要绑定到的端口。如果 hbase.regionserver.info.port 已在使用，则启用自动端口搜索。用于测试，默认关闭。

*默认*

`false`

`hbase.regionserver.handler.count`

*描述*

在 RegionServers 上启动的 RPC 侦听器实例的计数。Master 使用相同的属性来计算 master 处理程序。太多的处理程序可能会适得其反。使其成为 CPU 计数的倍数。如果主要是只读的，处理程序计数接近 cpu 计数效果很好。从两倍的 CPU 计数开始并从那里调整。

*默认*

`30`

`hbase.ipc.server.callqueue.handler.factor`

*描述*

确定呼叫队列数量的因素。值 0 表示在所有处理程序之间共享单个队列。值为 1 表示每个处理程序都有自己的队列。

*默认*

`0.1`

`hbase.ipc.server.callqueue.read.ratio`

*描述*

将调用队列拆分为读写队列。指定的时间间隔（应该在 0.0 和 1.0 之间）将乘以呼叫队列数。值 0 表示不拆分调用队列，这意味着读取和写入请求都将被推送到同一组队列。低于 0.5 的值意味着读取队列将少于写入队列。值为 0.5 意味着将有相同数量的读取和写入队列。大于 0.5 的值意味着读取队列比写入队列多。值为 1.0 意味着除一个队列之外的所有队列都用于分派读取请求。示例：假设调用队列的总数为 10，则 read.ratio 为 0 意味着：10 个队列将包含读/写请求。read.ratio 为 0.3 意味着：3 个队列仅包含读取请求，7 个队列仅包含写入请求。read.ratio 为 0.5 意味着：5 个队列将仅包含读取请求，5 个队列将仅包含写入请求。read.ratio 为 0.8 意味着：8 个队列将仅包含读取请求，2 个队列将仅包含写入请求。read.ratio 为 1 意味着：9 个队列将仅包含读取请求，1 个队列将仅包含写入请求。

*默认*

`0`

`hbase.ipc.server.callqueue.scan.ratio`

*描述*

给定读取调用队列的数量，根据调用队列总数乘以 callqueue.read.ratio 计算得出，scan.ratio 属性会将读取调用队列拆分为小读队列和长读队列。低于 0.5 的值意味着长读队列比短读队列少。值为 0.5 意味着将有相同数量的短读队列和长读队列。大于 0.5 的值意味着长读队列比短读队列多 0 或 1 值表示对获取和扫描使用相同的队列集。示例：假设读取调用队列的总数为 8，则 scan.ratio 为 0 或 1 意味着： 8 个队列将包含长读请求和短读请求。scan.ratio 为 0.3 意味着：2 个队列将仅包含长读请求，6 个队列将仅包含短读请求。scan.ratio 为 0.5 意味着：4 个队列将仅包含长读请求，4 个队列将仅包含短读请求。scan.ratio 为 0.8 意味着：6 个队列将仅包含长读请求，2 个队列将仅包含短读请求。

*默认*

`0`

`hbase.regionserver.msginterval`

*描述*

从 RegionServer 到 Master 的消息之间的间隔（以毫秒为单位）。

*默认*

`3000`

`hbase.regionserver.logroll.period`

*描述*

无论有多少编辑，我们都将滚动提交日志的时间段。

*默认*

`3600000`

`hbase.regionserver.logroll.errors.tolerated`

*描述*

在触发服务器中止之前，我们将允许的连续 WAL 关闭错误的数量。如果在日志滚动期间关闭当前 WAL 编写器失败，则设置为 0 将导致区域服务器中止。即使是很小的值（2 或 3）也将允许区域服务器克服暂时的 HDFS 错误。

*默认*

`2`

`hbase.regionserver.hlog.reader.impl`

*描述*

WAL 文件读取器实现。

*默认*

`org.apache.hadoop.hbase.regionserver.wal.ProtobufLogReader`

`hbase.regionserver.hlog.writer.impl`

*描述*

WAL 文件编写器实现。

*默认*

`org.apache.hadoop.hbase.regionserver.wal.ProtobufLogWriter`

`hbase.regionserver.global.memstore.size`

*描述*

在阻止新更新并强制刷新之前，区域服务器中所有内存存储的最大大小。默认为堆的 40% (0.4)。更新被阻止并强制刷新，直到区域服务器中所有内存存储的大小达到 hbase.regionserver.global.memstore.size.lower.limit。此配置中的默认值有意留空，以尊重旧的 hbase.regionserver.global.memstore.upperLimit 属性（如果存在）。

*默认*

没有任何

`hbase.regionserver.global.memstore.size.lower.limit`

*描述*

强制刷新之前区域服务器中所有内存存储的最大大小。默认为 hbase.regionserver.global.memstore.size (0.95) 的 95%。当由于内存存储限制而阻止更新时，此值的 100% 值会导致发生最小可能的刷新。此配置中的默认值有意留空，以尊重旧的 hbase.regionserver.global.memstore.lowerLimit 属性（如果存在）。

*默认*

没有任何

`hbase.systemtables.compacting.memstore.type`

*描述*

确定用于系统表（如 META、命名空间表等）的 memstore 类型。默认情况下 NONE 是类型，因此我们对所有系统表使用默认 memstore。如果我们需要对系统表使用压缩内存存储，则将此属性设置为 BASIC/EAGER

*默认*

`NONE`

`hbase.regionserver.optionalcacheflushinterval`

*描述*

编辑在自动刷新之前在内存中存在的最长时间。默认 1 小时。将其设置为 0 以禁用自动刷新。

*默认*

`3600000`

`hbase.regionserver.dns.interface`

*描述*

区域服务器应从中报告其 IP 地址的网络接口的名称。

*默认*

`default`

`hbase.regionserver.dns.nameserver`

*描述*

区域服务器应使用名称服务器 (DNS) 的主机名或 IP 地址来确定主服务器用于通信和显示目的的主机名。

*默认*

`default`

`hbase.regionserver.region.split.policy`

*描述*

拆分策略确定何时应拆分区域。当前可用的各种其他拆分策略是 BusyRegionSplitPolicy、ConstantSizeRegionSplitPolicy、DisabledRegionSplitPolicy、DelimitedKeyPrefixRegionSplitPolicy、KeyPrefixRegionSplitPolicy 和 SteppingSplitPolicy。DisabledRegionSplitPolicy 阻止手动区域拆分。

*默认*

`org.apache.hadoop.hbase.regionserver.SteppingSplitPolicy`

`hbase.regionserver.regionSplitLimit`

*描述*

限制区域数量，在此之后不应再进行区域拆分。这不是区域数量的硬性限制，而是区域服务器在达到一定限制后停止拆分的准则。默认设置为 1000。

*默认*

`1000`

`zookeeper.session.timeout`

*描述*

ZooKeeper 会话超时（以毫秒为单位）。它以两种不同的方式使用。首先，该值用于 HBase 用于连接集成的 ZK 客户端。HBase 在启动 ZK 服务器时也会使用它，并将其作为“maxSessionTimeout”传递。见[ZooKeeper: Because Coordinating Distributed Systems is a Zoo][ZooKeeper_ Because Coordinating Distributed Systems is a Zoo]. 例如，如果 HBase 区域服务器连接到同样由 HBase 管理的 ZK 集成，则会话超时将是此配置指定的超时。但是，连接到使用不同配置管理的集合的区域服务器将受到该集合的 maxSessionTimeout 的影响。因此，即使 HBase 可能建议使用 90 秒，集成的最大超时时间也可以低于此值，并且它会优先。ZK 提供的当前默认 maxSessionTimeout 为 40 秒，低于 HBase 的。

*默认*

`90000`

`zookeeper.znode.parent`

*描述*

ZooKeeper 中 HBase 的根 ZNode。所有配置了相对路径的 HBase 的 ZooKeeper 文件都将位于该节点下。默认情况下，HBase 的所有 ZooKeeper 文件路径都配置了相对路径，因此除非更改，否则它们都将位于该目录下。

*默认*

`/hbase`

`zookeeper.znode.acl.parent`

*描述*

访问控制列表的根 ZNode。

*默认*

`acl`

`hbase.zookeeper.dns.interface`

*描述*

ZooKeeper 服务器应从中报告其 IP 地址的网络接口的名称。

*默认*

`default`

`hbase.zookeeper.dns.nameserver`

*描述*

名称服务器 (DNS) 的主机名或 IP 地址，ZooKeeper 服务器应该使用它来确定 master 用于通信和显示目的的主机名。

*默认*

`default`

`hbase.zookeeper.peerport`

*描述*

ZooKeeper 对等方用于相互通信的端口。有关更多信息，请参阅[ZooKeeper Getting Started Guide][]。

*默认*

`2888`

`hbase.zookeeper.leaderport`

*描述*

ZooKeeper 用于领导选举的端口。有关更多信息，请参阅[ZooKeeper Getting Started Guide][]。

*默认*

`3888`

`hbase.zookeeper.property.initLimit`

*描述*

来自 ZooKeeper 配置 zoo.cfg 的属性。初始同步阶段可以采取的滴答数。

*默认*

`10`

`hbase.zookeeper.property.syncLimit`

*描述*

来自 ZooKeeper 配置 zoo.cfg 的属性。在发送请求和获得确认之间可以经过的滴答数。

*默认*

`5`

`hbase.zookeeper.property.dataDir`

*描述*

来自 ZooKeeper 配置 zoo.cfg 的属性。存储快照的目录。

*默认*

`${hbase.tmp.dir}/zookeeper`

`hbase.zookeeper.property.clientPort`

*描述*

来自 ZooKeeper 配置 zoo.cfg 的属性。客户端将连接的端口。

*默认*

`2181`

`hbase.zookeeper.property.maxClientCnxns`

*描述*

来自 ZooKeeper 配置 zoo.cfg 的属性。由 IP 地址标识的单个客户端可以与 ZooKeeper 集合的单个成员建立的并发连接数（在套接字级别）限制。设置高以避免 zk 连接问题运行独立和伪分布式。

*默认*

`300`

`hbase.client.write.buffer`

*描述*

BufferedMutator 写入缓冲区的默认大小（以字节为单位）。更大的缓冲区需要更多的内存——在客户端和服务器端，因为服务器实例化传递的写入缓冲区来处理它——但更大的缓冲区大小会减少 RPC 的数量。对于服务器端内存使用的估计，评估 hbase.client.write.buffer \* hbase.regionserver.handler.count

*默认*

`2097152`

`hbase.client.pause`

*描述*

一般客户端暂停值。主要用作在运行失败的获取、区域查找等的重试之前等待的值。请参阅 hbase.client.retries.number 以了解我们如何从初始暂停量退避以及此暂停如何在重试时工作。

*默认*

`100`

`hbase.client.pause.cqtbe`

*描述*

是否对 CallQueueTooBigException (cqtbe) 使用特殊的客户端暂停。如果您观察到来自同一个 RegionServer 的频繁 CQTBE 并且那里的调用队列保持已满，请将此属性设置为比 hbase.client.pause 更高的值

*默认*

没有任何

`hbase.client.retries.number`

*描述*

最大重试次数。用作所有可重试操作的最大值，例如获取单元格的值、开始行更新等。重试间隔是基于 hbase.client.pause 的粗略函数。起初我们以这个时间间隔重试，但随着退避，我们很快就达到了每 10 秒重试一次。请参阅 HConstants\#RETRY\_BACKOFF 了解备份如何增加。更改此设置和 hbase.client.pause 以适合您的工作负载。

*默认*

`15`

`hbase.client.max.total.tasks`

*描述*

单个 HTable 实例将发送到集群的最大并发突变任务数。

*默认*

`100`

`hbase.client.max.perserver.tasks`

*描述*

单个 HTable 实例将发送到单个区域服务器的最大并发突变任务数。

*默认*

`2`

`hbase.client.max.perregion.tasks`

*描述*

客户端将维护到单个 Region 的最大并发突变任务数。也就是说，如果该区域已经有 hbase.client.max.perregion.tasks 正在进行写入，则在某些写入完成之前，不会将新的 put 发送到该区域。

*默认*

`1`

`hbase.client.perserver.requests.threshold`

*描述*

所有客户端线程（进程级别）中一台服务器的最大并发挂起请求数。超过请求会立即抛出ServerTooBusyException，防止用户线程只被一个慢域服务器占用和阻塞。如果您使用固定数量的线程以同步方式访问 HBase，请将其设置为与线程数量相关的合适值将对您有所帮助。有关详细信息，请参阅[\[HBASE-16388\] Prevent client threads being blocked by only one slow region server - ASF JIRA][HBASE-16388_ Prevent client threads being blocked by only one slow region server - ASF JIRA]。

*默认*

`2147483647`

`hbase.client.scanner.caching`

*描述*

如果扫描器不是从（本地、客户端）内存提供的，我们在扫描器上调用 next 时尝试获取的行数。此配置与 hbase.client.scanner.max.result.size 一起使用以尝试有效地使用网络。默认值为 Integer.MAX\_VALUE 以便网络将填充 hbase.client.scanner.max.result.size 定义的块大小，而不是受特定行数的限制，因为行的大小因表而异. 如果您提前知道一次扫描所需的行数不会超过一定数量，则应通过 Scan\#setCaching 将此配置设置为该行数限制。更高的缓存值将启用更快的扫描器，但会占用更多内存，并且当缓存为空时，一些 next 调用可能需要越来越长的时间。不要将此值设置为使调用之间的时间大于扫描仪超时；即 hbase.client.scanner.timeout.period

*默认*

`2147483647`

`hbase.client.keyvalue.maxsize`

*描述*

指定 KeyValue 实例的组合最大允许大小。这是为存储文件中保存的单个条目设置上限。由于它们无法拆分，因此有助于避免由于数据太大而无法进一步拆分区域。将其设置为最大区域大小的一小部分似乎是明智的。将其设置为零或更少会禁用检查。

*默认*

`10485760`

`hbase.server.keyvalue.maxsize`

*描述*

单个单元格的最大允许大小，包括值和所有关键组件。0 或更小的值将禁用检查。默认值为 10MB。这是保护服务器免受 OOM 情况的安全设置。

*默认*

`10485760`

`hbase.client.scanner.timeout.period`

*描述*

客户端扫描程序租用期（以毫秒为单位）。

*默认*

`60000`

`hbase.client.localityCheck.threadPoolSize`

*默认*

`2`

`hbase.bulkload.retries.number`

*描述*

最大重试次数。这是面对拆分操作时尝试对原子批量加载进行的最大迭代次数 0 表示永不放弃。

*默认*

`10`

`hbase.compaction.after.bulkload.enable`

*描述*

批量加载后立即请求压缩。如果bulkload是连续的，触发的compactions可能会增加负载，带来性能副作用。

*默认*

`false`

`hbase.master.balancer.maxRitPercent`

*描述*

平衡时过渡区域的最大百分比。默认值为 1.0。所以没有平衡器节流。如果将此配置设置为 0.01，则表示平衡时最多有 1% 的区域在转换。那么集群的可用性在平衡时至少为 99%。

*默认*

`1.0`

`hbase.balancer.period`

*描述*

区域平衡器在 Master 中运行的周期，以毫秒为单位。

*默认*

`300000`

`hbase.regions.slop`

*描述*

如果任何 regionserver 具有平均 + (average \* slop) 区域，则重新平衡。该参数在StochasticLoadBalancer（默认负载均衡器）中的默认值为0.001，而在其他负载均衡器（即SimpleLoadBalancer）中默认值为0.2。

*默认*

`0.001`

`hbase.normalizer.period`

*描述*

区域规范器在 Master 中运行的周期，以毫秒为单位。

*默认*

`300000`

`hbase.normalizer.split.enabled`

*描述*

是否将区域拆分为标准化的一部分。

*默认*

`true`

`hbase.normalizer.merge.enabled`

*描述*

是否合并一个区域作为规范化的一部分。

*默认*

`true`

`hbase.normalizer.merge.min.region.count`

*描述*

表中考虑合并规范化的最小区域数。

*默认*

`3`

`hbase.normalizer.merge.min_region_age.days`

*描述*

考虑合并的区域的最小年龄，以天为单位。

*默认*

`3`

`hbase.normalizer.merge.min_region_age.days`

*描述*

考虑合并的区域的最小年龄，以天为单位。

*默认*

`3`

`hbase.normalizer.merge.min_region_size.mb`

*描述*

要考虑进行合并的区域的最小大小，以整个 MB 为单位。

*默认*

`1`

`hbase.table.normalization.enabled`

*描述*

此配置用于在表级别设置规范化器的默认行为。要在表级别覆盖它，可以在表描述符级别设置 NORMALIZATION\_ENABLED 并且该属性将被遵守

*默认*

`false`

`hbase.server.thread.wakefrequency`

*描述*

在master端，这个配置是用于FS相关行为的周期：检查hdfs是否退出安全模式，设置或检查hbase.version文件，设置或检查hbase.id文件。使用默认值应该没问题。在 regionserver 端，这个配置用在几个地方：flush check interval、compaction check interval、wal rolling check interval。特别地，管理员可以通过 hbase.regionserver.flush.check.period 和 hbase.regionserver.compaction.check.period 调整刷新和压缩检查间隔。（以毫秒为单位）

*默认*

`10000`

`hbase.regionserver.flush.check.period`

*描述*

它决定了 regionserver 中 PeriodicFlusher 的刷新检查周期。如果未设置，则使用 hbase.server.thread.wakefrequency 作为默认值。（以毫秒为单位）

*默认*

`${hbase.server.thread.wakefrequency}`

`hbase.regionserver.compaction.check.period`

*描述*

它决定了 regionserver 中 CompactionChecker 的压缩检查周期。如果未设置，则使用 hbase.server.thread.wakefrequency 作为默认值。（以毫秒为单位）

*默认*

`${hbase.server.thread.wakefrequency}`

`hbase.server.versionfile.writeattempts`

*描述*

在中止之前重试尝试写入版本文件的次数。每次尝试都由 hbase.server.thread.wakefrequency 毫秒分隔。

*默认*

`3`

`hbase.hregion.memstore.flush.size`

*描述*

如果 memstore 的大小超过此字节数，则 Memstore 将刷新到磁盘。值由运行每个 hbase.server.thread.wakefrequency 的线程检查。

*默认*

`134217728`

`hbase.hregion.percolumnfamilyflush.size.lower.bound.min`

*描述*

如果使用 FlushLargeStoresPolicy 并且有多个列族，那么每次我们达到内存存储总数限制时，我们都会找出内存存储超过“下限”的所有列族，并且只刷新它们，同时将其他列族保留在内存中。默认情况下，“下限”将为“hbase.hregion.memstore.flush.size / column\_family\_number”，除非此属性的值大于该值。如果没有一个系列的内存存储大小超过下限，则所有内存存储都将被刷新（就像往常一样）。

*默认*

`16777216`

`hbase.hregion.preclose.flush.size`

*描述*

如果我们要关闭时某个区域中的 memstore 是这个大小或更大，请在我们设置区域关闭标志并使该区域脱机之前运行“预刷新”以清除 memstore。关闭时，在关闭标志下运行刷新以清空内存。在此期间，该区域处于离线状态，我们不会进行任何写入。如果 memstore 内容很大，则此刷新可能需要很长时间才能完成。preflush 旨在在设置关闭标志并使区域脱机之前清除大部分内存存储，因此在关闭标志下运行的刷新几乎没有任何作用。

*默认*

`5242880`

`hbase.hregion.memstore.block.multiplier`

*描述*

如果 memstore 具有 hbase.hregion.memstore.block.multiplier 乘以 hbase.hregion.memstore.flush.size 字节，则阻止更新。在更新流量高峰期间防止失控的 memstore 很有用。如果没有上限，memstore 会填充，这样当它刷新生成的刷新文件时，需要很长时间来压缩或拆分，或者更糟的是，我们 OOME。

*默认*

`4`

`hbase.hregion.memstore.mslab.enabled`

*描述*

启用 MemStore-Local 分配缓冲区，该功能可防止在大量写入负载下出现堆碎片。这可以减少大型堆上的 stop-the-world GC 暂停的频率。

*默认*

`true`

`hbase.hregion.memstore.mslab.chunksize`

*描述*

MemStoreLAB 中块的最大字节大小。单位：字节

*默认*

`2097152`

`hbase.regionserver.offheap.global.memstore.size`

*描述*

RegionServer 中所有 MemStore 可能使用的堆外内存量。值为 0 表示不使用堆外内存，MSLAB 中的所有块都将是 HeapByteBuffer，否则非零值表示 MSLAB 中的块和 MSLAB 中的所有块将使用多少兆字节的堆外内存将是 DirectByteBuffer。单位：兆字节。

*默认*

`0`

`hbase.hregion.memstore.mslab.max.allocation`

*描述*

MemStoreLAB 中一次分配的最大大小，如果所需的字节大小超过此阈值，则它将仅从 JVM 堆而不是 MemStoreLAB 中分配。

*默认*

`262144`

`hbase.hregion.max.filesize`

*描述*

最大文件大小。如果一个区域的 HFiles 的大小总和超过了这个值，这个区域就会被一分为二。该选项的工作方式有两种选择，第一种是当任意store的大小超过阈值时进行拆分，另一种是整个区域的大小超过阈值时进行拆分，可以通过hbase.hregion.split.overallfiles进行配置。

*默认*

`10737418240`

`hbase.hregion.split.overallfiles`

*描述*

如果我们应该在检查拆分时总结整个区域文件的大小。

*默认*

`true`

`hbase.hregion.majorcompaction`

*描述*

主要压缩之间的时间，以毫秒表示。设置为 0 以禁用基于时间的自动主要压缩。用户请求的和基于大小的主要压缩仍将运行。这个值乘以 hbase.hregion.majorcompaction.jitter 使压缩在给定的时间窗口内的某个随机时间开始。默认值为 7 天，以毫秒为单位。如果主要压缩导致您的环境中断，您可以将它们配置为在部署的非高峰时间运行，或者通过将此参数设置为 0 来禁用基于时间的主要压缩，并在 cron 作业中或由另一个运行主要压缩外部机制。

*默认*

`604800000`

`hbase.hregion.majorcompaction.jitter`

*描述*

应用于 hbase.hregion.majorcompaction 的乘数，使压缩在 hbase.hregion.majorcompaction 的任一侧发生给定的时间量。数字越小，压缩越接近 hbase.hregion.majorcompaction 间隔。

*默认*

`0.50`

`hbase.hstore.compactionThreshold`

*描述*

如果任何一个 Store 中存在超过此数量的 StoreFiles（每次刷新 MemStore 写入一个 StoreFile），则会运行压缩以将所有 StoreFiles 重写为单个 StoreFile。较大的值会延迟压缩，但是当压缩确实发生时，需要更长的时间才能完成。

*默认*

`3`

`hbase.regionserver.compaction.enabled`

*描述*

通过设置 true/false 启用/禁用压缩。我们可以使用 compaction\_switch shell 命令进一步动态切换压缩。

*默认*

`true`

`hbase.hstore.flusher.count`

*描述*

冲洗线程的数量。线程较少时，MemStore 刷新将排队。线程越多，刷新将并行执行，从而增加 HDFS 的负载，并可能导致更多的压缩。

*默认*

`2`

`hbase.hstore.blockingStoreFiles`

*描述*

如果任何一个 Store 中存在超过此数量的 StoreFiles（每次刷新 MemStore 写入一个 StoreFile），则该区域的更新将被阻止，直到压缩完成，或者直到超过 hbase.hstore.blockingWaitTime。

*默认*

`16`

`hbase.hstore.blockingWaitTime`

*描述*

在达到 hbase.hstore.blockingStoreFiles 定义的 StoreFile 限制后，区域将阻止更新的时间。这段时间过后，即使压缩尚未完成，该区域也将停止阻止更新。

*默认*

`90000`

`hbase.hstore.compaction.min`

*描述*

在压缩可以运行之前必须符合压缩条件的 StoreFiles 的最小数量。调整 hbase.hstore.compaction.min 的目标是避免以太多小的 StoreFiles 来压缩。每次在 Store 中有两个 StoreFiles 时，将此值设置为 2 会导致轻微压缩，这可能不合适。如果您将此值设置得太高，则需要相应地调整所有其他值。对于大多数情况，默认值是合适的（此处为空值，代码逻辑结果为 3）。在以前的 HBase 版本中，参数 hbase.hstore.compaction.min 被命名为 hbase.hstore.compactionThreshold。

*默认*

没有任何

`hbase.hstore.compaction.max`

*描述*

无论符合条件的 StoreFiles 的数量是多少，将为单个次要压缩选择的 StoreFiles 的最大数量。实际上， hbase.hstore.compaction.max 的值控制完成单个压缩所需的时间长度。将其设置得更大意味着压缩中包含更多 StoreFiles。对于大多数情况，默认值是合适的。

*默认*

`10`

`hbase.hstore.compaction.min.size`

*描述*

小于此大小的 StoreFile（或 StoreFiles 的选择，当使用 ExploringCompactionPolicy 时）将始终有资格进行轻微压缩。此大小或更大的 HFile 由 hbase.hstore.compaction.ratio 评估以确定它们是否符合条件。由于此限制代表所有小于此值的 StoreFiles 的“自动包含”限制，因此在大量写入的环境中可能需要减小此值，其中刷新 1-2 MB 范围内的许多 StoreFiles，因为每个 StoreFile 都将成为目标用于压缩，结果 StoreFiles 可能仍低于最小大小，需要进一步压缩。如果该参数降低，则比率检查会更快触发。这解决了在早期版本的 HBase 中看到的一些问题，但在大多数情况下不再需要更改此参数。

*默认*

`134217728`

`hbase.hstore.compaction.max.size`

*描述*

大于此大小的 StoreFile（或一系列 StoreFiles，当使用 ExploringCompactionPolicy 时）将被排除在压缩之外。提高 hbase.hstore.compaction.max.size 的效果更少，更大的 StoreFiles 不会经常被压缩。如果您觉得压缩发生得太频繁而没有太大好处，您可以尝试提高此值。默认值：LONG.MAX\_VALUE 的值，以字节表示。

*默认*

`9223372036854775807`

`hbase.hstore.compaction.ratio`

*描述*

对于小压缩，此比率用于确定大于 hbase.hstore.compaction.min.size 的给定 StoreFile 是否符合压缩条件。它的作用是限制大型 StoreFiles 的压缩。hbase.hstore.compaction.ratio 的值表示为浮点小数。较大的比率，例如 10，将产生单个巨大的 StoreFile。相反，一个较低的值，例如 0.25，将产生类似于 BigTable 压缩算法的行为，产生四个 StoreFiles。建议使用介于 1.0 和 1.4 之间的中等值。调整此值时，您是在平衡写入成本和读取成本。提高该值（例如 1.4）将有更多的写入成本，因为您将压缩更大的 StoreFiles。但是，在读取过程中，HBase 将需要通过更少的 StoreFiles 来完成读取。如果您无法利用布隆过滤器，请考虑这种方法。否则，您可以将此值降低到 1.0 之类的值以降低写入的后台成本，并使用 Bloom 过滤器来控制读取期间接触的 StoreFiles 的数量。对于大多数情况，默认值是合适的。

*默认*

`1.2F`

`hbase.hstore.compaction.ratio.offpeak`

*描述*

允许您设置不同的（默认情况下，更积极的）比率，以确定在非高峰时间压缩中是否包含较大的 StoreFiles。与 hbase.hstore.compaction.ratio 的工作方式相同。仅适用于同时启用 hbase.offpeak.start.hour 和 hbase.offpeak.end.hour 的情况。

*默认*

`5.0F`

`hbase.hstore.time.to.purge.deletes`

*描述*

延迟清除具有未来时间戳的删除标记的时间量。如果未设置或设置为 0，则在下一次主要压缩期间清除所有删除标记，包括具有未来时间戳的标记。否则，将保留删除标记，直到在标记的时间戳加上此设置的值（以毫秒为单位）之后发生的主要压缩。

*默认*

`0`

`hbase.offpeak.start.hour`

*描述*

非高峰时段的开始时间，表示为 0 到 23（含）之间的整数。设置为 -1 以禁用非高峰。

*默认*

`-1`

`hbase.offpeak.end.hour`

*描述*

非高峰时段的结束时间，表示为 0 到 23（含）之间的整数。设置为 -1 以禁用非高峰。

*默认*

`-1`

`hbase.regionserver.thread.compaction.throttle`

*描述*

压缩有两种不同的线程池，一种用于大压缩，另一种用于小压缩。这有助于快速压缩精益表（例如 hbase:meta）。如果压缩大于此阈值，则进入大型压缩池。大多数情况下，默认值是合适的。默认值：2 x hbase.hstore.compaction.max x hbase.hregion.memstore.flush.size（默认为 128MB）。value 字段假定 hbase.hregion.memstore.flush.size 的值与默认值保持不变。

*默认*

`2684354560`

`hbase.regionserver.majorcompaction.pagecache.drop`

*描述*

指定是否通过主要压缩删除读取/写入系统页面缓存的页面。将其设置为 true 有助于防止主要压缩污染页面缓存，这几乎总是需要的，特别是对于具有低/中等内存存储比的集群。

*默认*

`true`

`hbase.regionserver.minorcompaction.pagecache.drop`

*描述*

指定是否通过次要压缩删除读取/写入系统页面缓存的页面。将其设置为 true 有助于防止较小的压缩污染页面缓存，这对于内存与存储比低的集群或写入量很大的集群最有利。当大量读取发生在最近写入的数据上时，您可能希望在中等至低写入工作负载下将其设置为 false。

*默认*

`true`

`hbase.hstore.compaction.kv.max`

*描述*

刷新或压缩时批量读取然后写入的最大 KeyValue 数。如果您有大的 KeyValues 和 Out Of Memory Exceptions 问题，请将其设置得较低 如果您有宽而小的行，则将其设置得更高。

*默认*

`10`

`hbase.storescanner.parallel.seek.enable`

*描述*

在 StoreScanner 中启用 StoreFileScanner 并行搜索，该功能可以减少特殊条件下的响应延迟。

*默认*

`false`

`hbase.storescanner.parallel.seek.threads`

*描述*

如果启用并行搜索功能，则默认线程池大小。

*默认*

`10`

`hfile.block.cache.policy`

*描述*

L1 块缓存（LRU 或 TinyLFU）的驱逐策略。

*默认*

`LRU`

`hfile.block.cache.size`

*描述*

分配给 StoreFile 使用的块缓存的最大堆（-Xmx 设置）的百分比。默认值 0.4 表示分配 40%。设置为 0 以禁用但不推荐；您至少需要足够的缓存来保存 storefile 索引。

*默认*

`0.4`

`hfile.block.index.cacheonwrite`

*描述*

这允许在写入索引时将非根多级索引块放入块缓存中。

*默认*

`false`

`hfile.index.block.max.size`

*描述*

当多级块索引中的叶级、中级或根级索引块的大小增长到此大小时，将写出该块并启动新块。

*默认*

`131072`

`hbase.bucketcache.ioengine`

*描述*

存储桶缓存内容的位置。其中之一：offheap、file、files、mmap 或 pmem。如果是一个或多个文件，请将其设置为 file(s):PATH\_TO\_FILE。mmap 表示内容将在 mmaped 文件中。使用 mmap:PATH\_TO\_FILE。“pmem”是持久存储设备上文件的存储桶缓存。使用 pmem:PATH\_TO\_FILE。有关更多信息，请参阅[http://hbase.apache.org/book.html\#offheap.blockcache][http_hbase.apache.org_book.html_offheap.blockcache]。

*默认*

没有任何

`hbase.hstore.compaction.throughput.lower.bound`

*描述*

聚合压缩吞吐量的目标下限，以字节/秒为单位。允许您在 PressureAwareCompactionThroughputController 吞吐量控制器处于活动状态时调整最小可用压缩吞吐量。（默认情况下它处于活动状态。）

*默认*

`52428800`

`hbase.hstore.compaction.throughput.higher.bound`

*描述*

聚合压缩吞吐量的目标上限，以字节/秒为单位。允许您在 PressureAwareCompactionThroughputController 吞吐量控制器处于活动状态时控制聚合压缩吞吐量需求。（默认情况下处于活动状态。）当压实压力在 \[0.0, 1.0\] 范围内时，最大吞吐量将在上下限之间进行调整。如果压实压力为 1.0 或更大，则上限将被忽略，直到压力恢复到正常范围。

*默认*

`104857600`

`hbase.bucketcache.size`

*描述*

它是 BucketCache 的总容量（以兆字节为单位）。默认值：0.0

*默认*

没有任何

`hbase.bucketcache.bucket.sizes`

*描述*

存储桶缓存的存储桶大小的逗号分隔列表。可以有多种尺寸。按从小到大的顺序列出块大小。您使用的大小将取决于您的数据访问模式。必须是 256 的倍数，否则当您从缓存中读取时，您将遇到“java.io.IOException: Invalid HFile block magic”。如果您在此处未指定任何值，则您将选择在代码中设置的默认存储桶大小（请参阅 BucketAllocator\#DEFAULT\_BUCKET\_SIZES）。

*默认*

没有任何

`hfile.format.version`

*描述*

用于新文件的 HFile 格式版本。版本 3 添加了对 hfiles 中标签的支持（参见[http://hbase.apache.org/book.html\#hbase.tags][http_hbase.apache.org_book.html_hbase.tags]）。另请参阅配置“hbase.replication.rpc.codec”。

*默认*

`3`

`hfile.block.bloom.cacheonwrite`

*描述*

为复合布隆过滤器的内联块启用写时缓存。

*默认*

`false`

`io.storefile.bloom.block.size`

*描述*

复合布隆过滤器的单个块（“块”）的大小（以字节为单位）。这个大小是近似值，因为Bloom块只能插入数据块边界，每个数据块的key个数不同。

*默认*

`131072`

`hbase.rs.cacheblocksonwrite`

*描述*

块完成后是否应将 HFile 块添加到块缓存中。

*默认*

`false`

`hbase.rpc.timeout`

*描述*

这是用于 RPC 层定义远程调用超时的 HBase 客户端应用程序需要多长时间（毫秒）。它使用 ping 检查连接，但最终会抛出 TimeoutException。

*默认*

`60000`

`hbase.client.operation.timeout`

*描述*

操作超时是一个顶级限制（毫秒），它确保表中的阻塞操作不会被阻塞更多。在每次操作中，如果rpc请求由于超时或其他原因失败，它将重试直到成功或抛出RetriesExhaustedException。但是如果在重试用完之前被阻塞的总时间达到操作超时，它会提前中断并抛出SocketTimeoutException。

*默认*

`1200000`

`hbase.cells.scanned.per.heartbeat.check`

*描述*

在心跳检查之间扫描的单元格数。心跳检查发生在扫描处理期间，以确定服务器是否应停止扫描以便向客户端发回心跳消息。心跳消息用于在长时间运行的扫描期间保持客户端-服务器连接处于活动状态。小值意味着心跳检查将更频繁地发生，因此将对扫描的执行时间提供更严格的限制。较大的值意味着心跳检查发生的频率较低

*默认*

`10000`

`hbase.rpc.shortoperation.timeout`

*描述*

这是“hbase.rpc.timeout”的另一个版本。对于集群内的那些 RPC 操作，我们依靠这个配置来设置短操作的短超时限制。例如，区域服务器尝试向活动主服务器报告的短 rpc 超时可以使更快的主服务器故障转移过程受益。

*默认*

`10000`

`hbase.ipc.client.tcpnodelay`

*描述*

在 rpc 套接字连接上设置无延迟。请参阅[Socket (Java 2 Platform SE 5.0)][Socket _Java 2 Platform SE 5.0] )

*默认*

`true`

`hbase.unsafe.regionserver.hostname`

*描述*

这个配置是给专家的：除非你真的知道你在做什么，否则不要设置它的值。当设置为非空值时，这表示底层服务器的（面向外部的）主机名。有关详细信息，请参阅[\[HBASE-12954\] Ability impaired using HBase on multihomed hosts - ASF JIRA][HBASE-12954_ Ability impaired using HBase on multihomed hosts - ASF JIRA]。

*默认*

没有任何

`hbase.unsafe.regionserver.hostname.disable.master.reversedns`

*描述*

这个配置是给专家的：除非你真的知道你在做什么，否则不要设置它的值。当设置为 true 时，regionserver 将使用当前节点主机名作为服务器名，HMaster 将跳过反向 DNS 查找并使用 regionserver 发送的主机名。请注意，此配置和 hbase.unsafe.regionserver.hostname 是互斥的。有关更多详细信息，请参阅[\[HBASE-18226\] Disable reverse DNS lookup at HMaster and use the hostname provided by RegionServer - ASF JIRA][HBASE-18226_ Disable reverse DNS lookup at HMaster and use the hostname provided by RegionServer - ASF JIRA]。

*默认*

`false`

`hbase.master.keytab.file`

*描述*

用于登录配置的 HMaster 服务器主体的 kerberos 密钥表文件的完整路径。

*默认*

没有任何

`hbase.master.kerberos.principal`

*描述*

前任。“hbase/\_HOST@EXAMPLE.COM”。应该用于运行 HMaster 进程的 kerberos 主体名称。主体名称的格式应为：user/hostname@DOMAIN。如果“\_HOST”用作主机名部分，它将被替换为正在运行的实例的实际主机名。

*默认*

没有任何

`hbase.regionserver.keytab.file`

*描述*

用于登录配置的 HRegionServer 服务器主体的 kerberos 密钥表文件的完整路径。

*默认*

没有任何

`hbase.regionserver.kerberos.principal`

*描述*

前任。“hbase/\_HOST@EXAMPLE.COM”。应该用于运行 HRegionServer 进程的 kerberos 主体名称。主体名称的格式应为：user/hostname@DOMAIN。如果“\_HOST”用作主机名部分，它将被替换为正在运行的实例的实际主机名。此主体的条目必须存在于 hbase.regionserver.keytab.file 中指定的文件中

*默认*

没有任何

`hadoop.policy.file`

*描述*

RPC 服务器用于对客户端请求做出授权决策的策略配置文件。仅在启用 HBase 安全性时使用。

*默认*

`hbase-policy.xml`

`hbase.superuser`

*描述*

用户或组列表（逗号分隔），他们被允许在整个集群中拥有完全权限，而不管存储的 ACL 是什么。仅在启用 HBase 安全性时使用。

*默认*

没有任何

`hbase.auth.key.update.interval`

*描述*

服务器中身份验证令牌的主密钥的更新间隔（以毫秒为单位）。仅在启用 HBase 安全性时使用。

*默认*

`86400000`

`hbase.auth.token.max.lifetime`

*描述*

身份验证令牌到期后的最大生命周期（以毫秒为单位）。仅在启用 HBase 安全性时使用。

*默认*

`604800000`

`hbase.ipc.client.fallback-to-simple-auth-allowed`

*描述*

当客户端配置为尝试安全连接，但尝试连接到不安全的服务器时，该服务器可能会指示客户端切换到 SASL SIMPLE（不安全）身份验证。此设置控制客户端是否会接受来自服务器的此指令。如果为 false（默认值），客户端将不允许回退到 SIMPLE 身份验证，并将中止连接。

*默认*

`false`

`hbase.ipc.server.fallback-to-simple-auth-allowed`

*描述*

当服务器配置为需要安全连接时，它将拒绝来自使用 SASL SIMPLE（不安全）身份验证的客户端的连接尝试。此设置允许安全服务器在客户端请求时接受来自客户端的 SASL SIMPLE 连接。如果为 false（默认值），服务器将不允许回退到 SIMPLE 身份验证，并将拒绝连接。警告：此设置应仅用作将客户端转换为安全身份验证时的临时措施。为了安全操作，它必须被禁用。

*默认*

`false`

`hbase.unsafe.client.kerberos.hostname.disable.reversedns`

*描述*

这个配置是给专家的：除非你真的知道你在做什么，否则不要设置它的值。当设置为 true 时，使用 SASL Kerberos 的 HBase 客户端将跳过反向 DNS 查找并使用提供的目标主机名作为主体。有关更多详细信息，请参阅[\[HBASE-25665\] Disable reverse DNS lookup for SASL Kerberos client connection - ASF JIRA][HBASE-25665_ Disable reverse DNS lookup for SASL Kerberos client connection - ASF JIRA]。

*默认*

`false`

`hbase.display.keys`

*描述*

当它设置为 true 时，webUI 将显示所有开始/结束键作为表详细信息、区域名称等的一部分。当它设置为 false 时，键被隐藏。

*默认*

`true`

`hbase.coprocessor.enabled`

*描述*

启用或禁用协处理器加载。如果为“false”（禁用），则将忽略任何其他与协处理器相关的配置。

*默认*

`true`

`hbase.coprocessor.user.enabled`

*描述*

启用或禁用用户（又名表）协处理器加载。如果为“false”（禁用），将忽略表描述符中的任何表协处理器属性。如果“hbase.coprocessor.enabled”为“false”，则此设置无效。

*默认*

`true`

`hbase.coprocessor.region.classes`

*描述*

默认情况下在所有表上加载的区域观察者或端点协处理器的逗号分隔列表。对于任何覆盖协处理器方法，将按顺序调用这些类。实现自己的 Coprocessor 后，将其添加到 HBase 的类路径并在此处添加完全限定的类名。也可以通过设置 HTableDescriptor 或 HBase shell 按需加载协处理器。

*默认*

没有任何

`hbase.coprocessor.master.classes`

*描述*

默认情况下在活动 HMaster 进程上加载的 org.apache.hadoop.hbase.coprocessor.MasterObserver 协处理器的逗号分隔列表。对于任何已实现的协处理器方法，将按顺序调用列出的类。实现自己的 MasterObserver 后，只需将其放在 HBase 的类路径中，并在此处添加完全限定的类名。

*默认*

没有任何

`hbase.coprocessor.abortonerror`

*描述*

如果协处理器无法加载、无法初始化或抛出意外的 Throwable 对象，则设置为 true 以导致托管服务器（主服务器或区域服务器）中止。将此设置为 false 将允许服务器继续执行，但相关协处理器的系统范围状态将变得不一致，因为它将仅在服务器的子集中正确执行，因此这仅对调试最有用。

*默认*

`true`

`hbase.rest.port`

*描述*

HBase REST 服务器的端口。

*默认*

`8080`

`hbase.rest.readonly`

*描述*

定义 REST 服务器将启动的模式。可能的值有： false：允许所有 HTTP 方法 - GET/PUT/POST/DELETE。true：只允许使用 GET 方法。

*默认*

`false`

`hbase.rest.threads.max`

*描述*

REST 服务器线程池的最大线程数。池中的线程被重用来处理 REST 请求。这控制了并发处理的最大请求数。它可能有助于控制 REST 服务器使用的内存以避免 OOM 问题。如果线程池已满，传入的请求将排队等待一些空闲线程。

*默认*

`100`

`hbase.rest.threads.min`

*描述*

REST 服务器线程池的最小线程数。线程池始终至少具有这些线程数，因此 REST 服务器已准备好为传入的请求提供服务。

*默认*

`2`

`hbase.rest.support.proxyuser`

*描述*

启用运行 REST 服务器以支持代理用户模式。

*默认*

`false`

`hbase.defaults.for.version.skip`

*描述*

设置为 true 以跳过“hbase.defaults.for.version”检查。将此设置为 true 在 maven 生成的另一端以外的上下文中可能很有用；即在 IDE 中运行。您需要将此布尔值设置为 true 以避免看到 RuntimeException 投诉：“hbase-default.xml 文件似乎适用于旧版本的 HBase (\\$\{hbase.version\})，此版本是 XXX-SNAPSHOT”

*默认*

`false`

`hbase.table.lock.enable`

*描述*

设置为 true 以启用在 zookeeper 中锁定表以进行模式更改操作。来自 master 的表锁定可防止并发模式修改损坏表状态。

*默认*

`true`

`hbase.table.max.rowsize`

*描述*

未设置行内扫描标志的 Get'ting 或 Scan'ning 的最大单行大小（以字节为单位）（默认为 1 Gb）。如果行大小超过此限制，则向客户端抛出 RowTooBigException。

*默认*

`1073741824`

`hbase.thrift.minWorkerThreads`

*描述*

线程池的“核心大小”。在每个连接上创建新线程，直到创建这么多线程。

*默认*

`16`

`hbase.thrift.maxWorkerThreads`

*描述*

线程池的最大大小。当待处理的请求队列溢出时，将创建新线程，直到它们的数量达到此数量。之后，服务器开始断开连接。

*默认*

`1000`

`hbase.thrift.maxQueuedRequests`

*描述*

队列中等待的最大挂起 Thrift 连接数。如果池中没有空闲线程，服务器将请求排队。只有当队列溢出时，才会添加新线程，最多可达 hbase.thrift.maxQueuedRequests 个线程。

*默认*

`1000`

`hbase.regionserver.thrift.framed`

*描述*

在服务器端使用 Thrift TFramedTransport。这是 thrift 服务器的推荐传输方式，并且需要在客户端进行类似的设置。将此更改为 false 将选择默认传输，当由于 THRIFT-601 发出格式错误的请求时，容易受到 DoS 攻击。

*默认*

`false`

`hbase.regionserver.thrift.framed.max_frame_size_in_mb`

*描述*

使用帧传输时的默认帧大小，以 MB 为单位

*默认*

`2`

`hbase.regionserver.thrift.compact`

*描述*

使用 Thrift TCompactProtocol 二进制序列化协议。

*默认*

`false`

`hbase.rootdir.perms`

*描述*

安全（kerberos）设置中根数据子目录的 FS 权限。当 master 启动时，它会创建具有此权限的 rootdir，如果不匹配，则设置权限。

*默认*

`700`

`hbase.wal.dir.perms`

*描述*

安全（kerberos）设置中根 WAL 目录的 FS 权限。当 master 启动时，它会创建具有此权限的 WAL 目录，或者如果不匹配则设置权限。

*默认*

`700`

`hbase.data.umask.enable`

*描述*

启用，如果为 true，则应将文件权限分配给 regionserver 写入的文件

*默认*

`false`

`hbase.data.umask`

*描述*

当 hbase.data.umask.enable 为 true 时应该用于写入数据文件的文件权限

*默认*

`000`

`hbase.snapshot.enabled`

*描述*

设置为 true 以允许拍摄/恢复/克隆快照。

*默认*

`true`

`hbase.snapshot.restore.take.failsafe.snapshot`

*描述*

设置为 true 以在还原操作之前拍摄快照。发生故障时将使用拍摄的快照来恢复以前的状态。在还原操作结束时，此快照将被删除

*默认*

`true`

`hbase.snapshot.restore.failsafe.name`

*描述*

还原操作拍摄的故障安全快照的名称。您可以使用 \{snapshot.name\}、\{table.name\} 和 \{restore.timestamp\} 变量根据要恢复的内容创建名称。

*默认*

`hbase-failsafe-{snapshot.name}-{restore.timestamp}`

`hbase.snapshot.working.dir`

*描述*

将发生快照过程的位置。完成的快照的位置不会改变，但是快照过程发生的临时目录会被设置到这个位置。出于提高性能的目的，这可以是一个与根目录不同的文件系统。有关更多信息，请参阅 HBASE-21098

*默认*

没有任何

`hbase.server.compactchecker.interval.multiplier`

*描述*

决定我们扫描频率以查看是否需要压缩的数字。正常情况下，compaction是在一些事件（比如memstore flush）之后完成的，但是如果region在一段时间内没有收到大量的写入，或者由于不同的compaction策略，可能需要定期检查。检查之间的间隔是 hbase.server.compactchecker.interval.multiplier 乘以 hbase.server.thread.wakefrequency。

*默认*

`1000`

`hbase.lease.recovery.timeout`

*描述*

在放弃之前，我们总共等待 dfs 租约恢复的时间。

*默认*

`900000`

`hbase.lease.recovery.dfs.timeout`

*描述*

dfs 恢复租约调用之间的时间间隔。应该大于namenode作为datanode的一部分发出块恢复命令所需的时间总和；dfs.heartbeat.interval 以及主数据节点执行块恢复到死数据节点超时所需的时间；通常是 dfs.client.socket-timeout。有关更多信息，请参阅 HBASE-8389 的结尾。

*默认*

`64000`

`hbase.column.max.version`

*描述*

新的列族描述符将使用此值作为要保留的默认版本数。

*默认*

`1`

`dfs.client.read.shortcircuit`

*描述*

如果设置为 true，则此配置参数启用短路本地读取。

*默认*

没有任何

`dfs.domain.socket.path`

*描述*

如果 dfs.client.read.shortcircuit 设置为 true，则这是到 UNIX 域套接字的路径，该套接字将用于 DataNode 和本地 HDFS 客户端之间的通信。如果此路径中存在字符串“\_PORT”，它将被 DataNode 的 TCP 端口替换。注意托管共享域套接字的目录的权限；如果对 HBase 用户以外的其他用户开放，dfsclient 会抱怨。

*默认*

没有任何

`hbase.dfs.client.read.shortcircuit.buffer.size`

*描述*

如果 DFSClient 配置 dfs.client.read.shortcircuit.buffer.size 未设置，我们将使用这里配置的作为短路读取默认直接字节缓冲区大小。DFSClient 原生默认为 1MB；HBase 保持其 HDFS 文件打开，因此由于直接内存不足，文件块数 \* 1MB 很快开始增加并威胁到 OOME。因此，我们将其设置为默认值。使其 > HColumnDescriptor 中设置的默认 hbase 块大小，通常为 64k。

*默认*

`131072`

`hbase.regionserver.checksum.verify`

*描述*

如果设置为 true（默认值），HBase 会验证 hfile 块的校验和。HBase 在写出 hfile 时会写入与数据内联的校验和。HDFS（在撰写本文时）将校验和写入一个单独的文件，而不是需要额外查找的数据文件。设置这个标志可以节省一些 I/O。设置此标志时，HDFS 的校验和验证将在 hfile 流上内部禁用。如果 hbase-checksum 验证失败，我们将切换回使用 HDFS 校验和（所以不要禁用 HDFS 校验和！此外，此功能仅适用于 hfile，不适用于 WAL）。如果此参数设置为 false，则 hbase 将不会验证任何校验和，而是依赖于在 HDFS 客户端中进行的校验和验证。

*默认*

`true`

`hbase.hstore.bytes.per.checksum`

*描述*

hfile 块中 HBase 级别校验和的新创建校验和块中的字节数。

*默认*

`16384`

`hbase.hstore.checksum.algorithm`

*描述*

用于计算校验和的算法的名称。可能的值为 NULL、CRC32、CRC32C。

*默认*

`CRC32C`

`hbase.client.scanner.max.result.size`

*描述*

调用扫描器的 next 方法时返回的最大字节数。请注意，当单行大于此限制时，该行仍会完全返回。默认值为 2MB，适用于 1ge 网络。对于更快和/或高延迟的网络，该值应该增加。

*默认*

`2097152`

`hbase.server.scanner.max.result.size`

*描述*

调用扫描器的 next 方法时返回的最大字节数。请注意，当单行大于此限制时，该行仍会完全返回。默认值为 100MB。这是保护服务器免受 OOM 情况的安全设置。

*默认*

`104857600`

`hbase.status.published`

*描述*

此设置激活由 master 发布区域服务器的状态。当一个 region server 挂掉并且它的恢复开始时，master 会将此信息推送到客户端应用程序，让他们立即切断连接而不是等待超时。

*默认*

`false`

`hbase.status.publisher.class`

*描述*

使用多播消息实现状态发布。

*默认*

`org.apache.hadoop.hbase.master.ClusterStatusPublisher$MulticastPublisher`

`hbase.status.listener.class`

*描述*

使用多播消息实现状态侦听器。

*默认*

`org.apache.hadoop.hbase.client.ClusterStatusListener$MulticastListener`

`hbase.status.multicast.address.ip`

*描述*

用于通过多播进行状态发布的多播地址。

*默认*

`226.1.1.3`

`hbase.status.multicast.address.port`

*描述*

用于通过多播进行状态发布的多播端口。

*默认*

`16100`

`hbase.dynamic.jars.dir`

*描述*

区域服务器可以从中动态加载自定义过滤器 JAR 的目录，而无需重新启动。但是，不会卸载已经加载的过滤器/协处理器类。有关更多详细信息，请参阅 HBASE-1936。不适用于协处理器。

*默认*

`${hbase.rootdir}/lib`

`hbase.security.authentication`

*描述*

控制是否为 HBase 启用安全身份验证。可能的值为“简单”（无身份验证）和“kerberos”。

*默认*

`simple`

`hbase.rest.filter.classes`

*描述*

REST 服务的 Servlet 过滤器。

*默认*

`org.apache.hadoop.hbase.rest.filter.GzipFilter`

`hbase.master.loadbalancer.class`

*描述*

用于在期间发生时执行区域平衡的类。有关它如何工作的更多信息，请参阅类注释[StochasticLoadBalancer (Apache HBase 3.0.0-alpha-2-SNAPSHOT API)][StochasticLoadBalancer _Apache HBase 3.0.0-alpha-2-SNAPSHOT API]它取代 DefaultLoadBalancer 作为默认值（因为重命名为 SimpleLoadBalancer ）。

*默认*

`org.apache.hadoop.hbase.master.balancer.StochasticLoadBalancer`

`hbase.master.loadbalance.bytable`

*描述*

平衡器运行时的因子表名称。默认值：假。

*默认*

`false`

`hbase.master.normalizer.class`

*描述*

用于在周期发生时执行区域归一化的类。有关其工作原理的更多信息，请参阅课程评论[SimpleRegionNormalizer (Apache HBase 3.0.0-alpha-2-SNAPSHOT API)][SimpleRegionNormalizer _Apache HBase 3.0.0-alpha-2-SNAPSHOT API]

*默认*

`org.apache.hadoop.hbase.master.normalizer.SimpleRegionNormalizer`

`hbase.rest.csrf.enabled`

*描述*

设置为 true 以启用针对跨站点请求伪造 (CSRF) 的保护

*默认*

`false`

`hbase.rest-csrf.browser-useragents-regex`

*描述*

通过将 hbase.rest.csrf.enabled 设置为 true 为 REST 服务器启用跨站点请求伪造 (CSRF) 保护时，用于匹配 HTTP 请求的 User-Agent 标头的逗号分隔正则表达式列表。如果传入的 User-Agent 匹配这些正则表达式中的任何一个，则认为该请求是由浏览器发送的，因此会强制执行 CSRF 预防。如果请求的 User-Agent 与这些正则表达式中的任何一个都不匹配，则认为该请求是由浏览器以外的其他东西发送的，例如脚本自动化。在这种情况下，CSRF 不是潜在的攻击媒介，因此不会强制执行预防。这有助于实现与尚未更新以发送 CSRF 预防标头的现有自动化的向后兼容性。

*默认*

`Mozilla.,Opera.`

`hbase.security.exec.permission.checks`

*描述*

如果启用此设置并且基于 ACL 的访问控制处于活动状态（AccessController 协处理器作为系统协处理器安装或作为表协处理器安装在表上），那么您必须授予所有相关用户 EXEC 权限，如果他们需要执行协处理器端点的能力调用。与任何其他权限一样，EXEC 权限可以全局授予用户，或者基于每个表或每个命名空间授予用户。有关协处理器端点的更多信息，请参阅 HBase 在线手册的协处理器部分。有关使用 AccessController 授予或撤销权限的更多信息，请参阅 HBase 在线手册的安全部分。

*默认*

`false`

`hbase.procedure.regionserver.classes`

*描述*

默认情况下在活动 HRegionServer 进程上加载的 org.apache.hadoop.hbase.procedure.RegionServerProcedureManager 过程管理器的逗号分隔列表。生命周期方法（init/start/stop）将被活动的 HRegionServer 进程调用以执行特定的全局屏障过程。实现自己的RegionServerProcedureManager后，只需将其放在HBase的类路径中，并在此处添加完全限定的类名。

*默认*

没有任何

`hbase.procedure.master.classes`

*描述*

默认情况下在活动 HMaster 进程上加载的 org.apache.hadoop.hbase.procedure.MasterProcedureManager 过程管理器的逗号分隔列表。程序由其签名标识，用户可以使用签名和即时名称来触发全局屏障程序的执行。实现自己的 MasterProcedureManager 后，只需将其放在 HBase 的类路径中，并在此处添加完全限定的类名。

*默认*

没有任何

`hbase.coordinated.state.manager.class`

*描述*

实现协调状态管理器的类的完全限定名称。

*默认*

`org.apache.hadoop.hbase.coordination.ZkCoordinatedStateManager`

`hbase.regionserver.storefile.refresh.period`

*描述*

刷新次要区域的存储文件的周期（以毫秒为单位）。0 表示此功能已禁用。一旦次要区域刷新区域中的文件列表（没有通知机制），次要区域就会从主要区域看到新文件（来自刷新和压缩）。但是过于频繁的刷新可能会导致额外的 Namenode 压力。如果文件无法刷新的时间超过 HFile TTL (hbase.master.hfilecleaner.ttl)，则请求将被拒绝。还建议使用此设置将 HFile TTL 配置为更大的值。

*默认*

`0`

`hbase.region.replica.replication.enabled`

*描述*

是否启用到次要区域副本的异步 WAL 复制。如果启用此功能，将创建名为“region\_replica\_replication”的复制对等体，它将跟踪日志并将突变复制到区域复制 > 1 的表的区域副本。如果启用一次，禁用此复制还需要禁用复制使用 shell 或 Admin java 类的对等体。复制到辅助区域副本通过标准集群间复制工作。

*默认*

`false`

`hbase.http.filter.initializers`

*描述*

以逗号分隔的类名列表。列表中的每个类都必须扩展 org.apache.hadoop.hbase.http.FilterInitializer。相应的过滤器将被初始化。然后，过滤器将应用于所有面向用户的 jsp 和 servlet 网页。列表的顺序定义了过滤器的顺序。默认的 StaticUserWebFilter 添加由 hbase.http.staticuser.user 属性定义的用户主体。

*默认*

`org.apache.hadoop.hbase.http.lib.StaticUserWebFilter`

`hbase.security.visibility.mutations.checkauths`

*描述*

如果启用此属性，将检查可见性表达式中的标签是否与发出突变的用户相关联

*默认*

`false`

`hbase.http.max.threads`

*描述*

HTTP Server 将在其 ThreadPool 中创建的最大线程数。

*默认*

`16`

`hbase.replication.rpc.codec`

*描述*

启用复制时要使用的编解码器，以便也复制标记。这与支持标签的 HFileV3 一起使用。如果没有使用标签或者如果使用的 hfile 版本是 HFileV2，那么 KeyValueCodec 可以用作复制编解码器。请注意，在没有标签的情况下使用 KeyValueCodecWithTags 进行复制不会造成危害。

*默认*

`org.apache.hadoop.hbase.codec.KeyValueCodecWithTags`

`hbase.replication.source.maxthreads`

*描述*

任何复制源将用于将编辑并行传送到接收器的最大线程数。这也限制了每个复制批次被分成的块数。较大的值可以提高主从集群之间的复制吞吐量。默认值 10 很少需要更改。

*默认*

`10`

`hbase.http.staticuser.user`

*描述*

在呈现内容时在静态 Web 过滤器上过滤的用户名。一个示例用途是 HDFS Web UI（用于浏览文件的用户）。

*默认*

`dr.stack`

`hbase.regionserver.handler.abort.on.error.percent`

*描述*

区域服务器 RPC 线程未能中止 RS 的百分比。-1 禁用中止；0 即使一个处理程序已经死亡，也会中止；0.x 只有当这个百分比的处理程序死亡时才中止；1 Abort 只有所有的handers 都死了。

*默认*

`0.5`

`hbase.mob.file.cache.size`

*描述*

要缓存的打开文件处理程序的数量。通过为每个 mob 文件缓存提供更多的文件处理程序，更大的值将有利于读取，并减少频繁的文件打开和关闭。但是，如果此值设置得太高，则可能会导致“打开的文件处理程序过多”，默认值为 1000。

*默认*

`1000`

`hbase.mob.cache.evict.period`

*描述*

mob 缓存驱逐缓存的 mob 文件之前的时间量（以秒为单位）。默认值为 3600 秒。

*默认*

`3600`

`hbase.mob.cache.evict.remain.ratio`

*描述*

当缓存的 mob 文件数量超过 hbase.mob.file.cache.size 时，触发驱逐后仍然缓存的文件的比率（0.0 和 1.0 之间）。默认值为 0.5f。

*默认*

`0.5f`

`hbase.master.mob.cleaner.period`

*描述*

MobFileCleanerChore 运行的时间段。单位是第二。默认值为一天。MOB 文件名仅使用其中的文件创建时间的日期部分。我们使用这个时间来决定文件的 TTL 到期时间。因此，删除 TTL 过期文件可能会延迟。最大延迟可能是 24 小时。

*默认*

`86400`

`hbase.mob.major.compaction.region.batch.size`

*描述*

一批 mob 压缩中允许的最大 MOB 表区域数。通过将此数字设置为自定义值，用户可以控制大型 MOB 启用表的主要压缩的整体效果。默认为 0 - 表示没有限制 - MOB 表的所有区域将被一次压缩

*默认*

`0`

`hbase.mob.compaction.chore.period`

*描述*

MobCompactionChore 运行的时间段。单位是第二。默认值为一周。

*默认*

`604800`

`hbase.snapshot.master.timeout.millis`

*描述*

快照过程执行的 master 超时。

*默认*

`300000`

`hbase.snapshot.region.timeout`

*描述*

区域服务器使快照请求池中的线程保持等待的超时。

*默认*

`300000`

`hbase.rpc.rows.warning.threshold`

*描述*

批处理操作中将记录警告的行数。

*默认*

`5000`

`hbase.master.wait.on.service.seconds`

*描述*

默认为 5 分钟。测试时间为 30 秒。有关某些上下文，请参阅 HBASE-19794。

*默认*

`30`

`hbase.master.cleaner.snapshot.interval`

*描述*

快照清理杂务间隔（以毫秒为单位）。清理线程以这个时间间隔持续运行，以查找所有基于 TTL 过期的快照并删除它们。

*默认*

`1800000`

`hbase.master.snapshot.ttl`

*描述*

当用户在创建快照时未指定 TTL 时要考虑的默认快照 TTL。默认值 0 表示 FOREVERE - 快照在手动删除之前不应自动删除

*默认*

`0`

`hbase.master.regions.recovery.check.interval`

*描述*

区域恢复杂项间隔（以毫秒为单位）。此杂务会在此时间间隔内继续运行，以查找具有可配置最大存储文件引用计数的所有区域并重新打开它们。

*默认*

`1200000`

`hbase.regions.recovery.store.file.ref.count`

*描述*

压缩存储文件上的大量引用计数表明它是该对象（压缩存储文件）上的引用泄漏。此类文件在通过压缩无效后无法删除。在这种情况下恢复的唯一方法是重新打开可以释放所有资源的区域，如引用计数、租用等。此配置代表重新打开区域考虑的存储文件引用计数阈值。任何具有压缩存储文件引用计数 > 此值的区域都可以由 master 重新打开。在这里，我们获得了属于特定区域的所有压缩存储文件的所有 refCounts 中的最大 refCount。默认值 -1 表示此功能已关闭。仅应提供正整数值以启用此功能。

*默认*

`-1`

`hbase.regionserver.slowlog.ringbuffer.size`

*描述*

每个 RegionServer 维护的 ringbuffer 的默认大小，以存储在线慢日志响应。这是除了 responseTooSlow 日志记录之外被判断为太慢的请求的内存中环形缓冲区。内存中的表示将是完整的。有关更多详细信息，请查看文档部分：从 shell 获取慢响应日志

*默认*

`256`

`hbase.regionserver.slowlog.buffer.enabled`

*描述*

指示RegionServers 是否运行环形缓冲区，用于以有限条目的FIFO 方式存储Online Slow 日志。环形缓冲区的大小由 config 指示： hbase.regionserver.slowlog.ringbuffer.size 默认值为 false，打开此选项可获取最新的带有完整数据的慢日志响应。

*默认*

`false`

`hbase.regionserver.slowlog.systable.enabled`

*描述*

仅在启用 hbase.regionserver.slowlog.buffer.enabled 时才应启用。如果启用 (true)，所有慢/大 RPC 日志都将持久化到系统表 hbase:slowlog（除了每个 RegionServer 的内存环形缓冲区）。记录按时间递增的顺序存储。操作员可以使用 ColumnValueFilter 的各种组合来扫描表。文档部分提供了更多详细信息：“从系统表 hbase:slowlog 获取慢/大响应日志”

*默认*

`false`

`hbase.master.metafixer.max.merge.count`

*描述*

我们修复 CJ 一致性报告中指出的重叠时要合并的最大区域，但要避免一次性合并 100 个区域！

*默认*

`64`

`hbase.rpc.rows.size.threshold.reject`

*描述*

如果值为 true，RegionServer 将中止批量操作中的行数超过配置值定义的阈值的 Put/Delete 的批处理请求：hbase.rpc.rows.warning.threshold。默认值为 false，因此，默认情况下，只会记录警告。应该打开此配置以防止 RegionServer 提供非常大的批处理大小的行，这样我们可以通过丢弃过大的批处理请求来提高 CPU 使用率。

*默认*

`false`

`hbase.namedqueue.provider.classes`

*描述*

NamedQueueService 实现者的默认值。这个逗号分隔的完整类名代表我们希望由 LogEvent 处理程序服务调用的 NamedQueueService 的所有实现者。NamedQueue 服务的一个例子是 SlowLogQueueService，它用于在每个 RegionServer 的 ringbuffer 中存储慢/大 RPC 日志。NamedQueueService 的所有实现者都应该在包下找到：“org.apache.hadoop.hbase.namequeues.impl”

*默认*

`org.apache.hadoop.hbase.namequeues.impl.SlowLogQueueService,org.apache.hadoop.hbase.namequeues.impl.BalancerDecisionQueueService,org.apache.hadoop.hbase.namequeues.impl.BalancerRejectionQueueService`

`hbase.master.balancer.decision.buffer.enabled`

*描述*

指示活动 HMaster 是否运行环形缓冲区，用于以有限条目的 FIFO 方式存储平衡器决策。环形缓冲区的大小由配置指示：hbase.master.balancer.decision.queue.size

*默认*

`false`

`hbase.master.balancer.rejection.buffer.enabled`

*描述*

指示活动 HMaster 是否运行环形缓冲区，用于以有限条目的 FIFO 方式存储平衡器拒绝。环形缓冲区的大小由配置指示：hbase.master.balancer.rejection.queue.size

*默认*

`false`

### 7.3. *hbase-env.sh* ###

在此文件中设置 HBase 环境变量。示例包括在 HBase 守护程序启动时传递 JVM 的选项，例如堆大小和垃圾收集器配置。您还可以设置 HBase 配置、日志目录、niceness、ssh 选项、进程 pid 文件的位置等*配置*。打开*conf/hbase-env.sh 中*的文件并仔细阅读其内容。每个选项都有很好的文档记录。如果您希望 HBase 守护程序在启动时读取它们，请在此处添加您自己的环境变量。

此处的更改将需要重新启动集群以使 HBase 注意到更改。

### 7.4. *log4j2.xml* ###

从3.0.0版本开始，HBase升级到Log4j2，所以配置文件名和格式都发生了变化。在[Apache Log4j2 中][Apache Log4j2]阅读更多[内容][Apache Log4j2]。

编辑此文件以更改 HBase 文件的滚动速率并更改 HBase 记录消息的级别。

尽管可以通过 HBase UI 更改特定守护程序的日志级别，但此处的更改将需要重新启动集群以让 HBase 注意到更改。

### 7.5. 连接到 HBase 集群的客户端配置和依赖项 ###

如果你在独立模式下运行 HBase，你不需要为你的客户端配置任何东西，只要它们都在同一台机器上。

从 3.0.0 版开始，默认连接注册表已切换到基于主的实现。有关什么是连接注册表以及此更改的含义的更多详细信息，请参阅[主注册表（自 2.3.0 起新增）][2.3.0]。根据您的 HBase 版本，以下是预期的最小客户端配置。

7.5.1. 直到 2.xy 发布

在 2.xy 版本中，默认连接注册表基于 ZooKeeper 作为事实来源。这意味着客户端总是查找 ZooKeeper znodes 来获取所需的元数据。例如，如果一个活跃的 master 崩溃了，一个新的 master 被选举出来，客户端会查找 master znode 来获取活动的 master 地址（类似于元位置）。这意味着客户端需要有权访问 ZooKeeper 并且需要知道 ZooKeeper 集成信息，然后才能执行任何操作。这可以在客户端配置xml中配置如下：

7.5.2. 开始 3.0.0 版本

默认实现已切换到基于主节点的连接注册表。使用此实现，客户端始终联系活动或备用主 RPC 端点以获取连接注册表信息。这意味着客户端在做任何事情之前应该有权访问活动和主端点的列表。这可以在客户端配置xml中配置如下：

<?xml version="1.0"?>
 <?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
 <configuration>
 <property>
 <name>hbase.masters</name>
 <value>example1,example2,example3</value>
 <description>List of master rpc end points for the hbase cluster.</description>
 </property>
 </configuration>

*hbase.masters*的配置值是一个逗号分隔的*host:port*值列表。如果未指定端口值，则假定默认值为*16000*。

通常，此配置保留在*hbase-site.xml 中*，并由客户端从`CLASSPATH得到`.

如果您要配置 IDE 以运行 HBase 客户端，则应在类路径中包含*conf/*目录，以便可以找到*hbase-site.xml*设置（或添加*src/test/resources*以获取使用的 hbase-site.xml通过测试）。

对于使用 Maven 的 Java 应用程序，包括 hbase-shaded-client 模块是连接到集群时的推荐依赖项：

<dependency>
 <groupId>org.apache.hbase</groupId>
 <artifactId>hbase-shaded-client</artifactId>
 <version>2.0.0</version>
 </dependency>

7.5.3. Java客户端配置

Java 客户端使用的配置保存在 [HBaseConfiguration][] 实例中。

HBaseConfiguration  `HBaseConfiguration.create()`工厂方法，在调用时，将读取在客户端上找到的第一个*hbase-site.xml*的内容（`CLASSPATH`如果存在）（调用还将考虑找到的任何*hbase-default.xml*；一个*hbase-default .xml*包含在*hbase.XXXjar 中*）。也可以直接指定配置而无需从*hbase-site.xml 中*读取。

例如，要以编程方式为集群设置 ZooKeeper 集合，请执行以下操作：

<dependency>
 <groupId>org.apache.hbase</groupId>
 <artifactId>hbase-shaded-client</artifactId>
 <version>2.0.0</version>
 </dependency>

### 7.6. 超时设置 ###

HBase 提供了多种超时设置来限制各种远程操作的执行时间。

*  hbase.rpc.timeout
 *  hbase.rpc.read.timeout
 *  hbase.rpc.write.timeout
 *  hbase.client.operation.timeout
 *  hbase.client.meta.operation.timeout
 *  hbase.client.scanner.timeout.period

该`hbase.rpc.timeout`属性限制了单个 RPC 调用在超时之前可以运行的时间。微调读取或写入相关的 RPC 超时设置`hbase.rpc.read.timeout`和 `hbase.rpc.write.timeout`配置属性。在没有这些属性时 `hbase.rpc.timeout`将使用。

更高级别的超时`hbase.client.operation.timeout`对每个客户端调用都有效。当 RPC 调用因超时而失败时，`hbase.rpc.timeout`将重试直到`hbase.client.operation.timeout`达到。系统表的客户端操作超时可以通过设置`hbase.client.meta.operation.timeout`配置值进行微调。如果没有设置它的值将使用`hbase.client.operation.timeout`.

扫描操作的超时以不同方式控制。使用`hbase.client.scanner.timeout.period` 属性设置此超时。

## 8. 示例配置 ##

### 8.1. 基本分布式 HBase 安装 ###

下面是一个分布式10节点的群集的基本配置示例：\*的节点命名`example0`，`example1`等，通过节点`example9`在这个例子。\* HBase Master 和 HDFS NameNode 在节点上运行`example0`。\* RegionServers 在节点上运行`example1`\- `example9`. \*在A 3-节点动物园管理员合奏运行`example1`，`example2`以及`example3`在默认端口上。\* ZooKeeper 数据被持久化到目录*/export/zookeeper*。

下面我们展示 了 HBase *conf*目录中的主要配置文件——  *hbase-site.xml*、*regionservers*和 *hbase-env.sh*可能是什么样子。

8.1.1. *hbase-site.xml*

<?xml version="1.0"?>
 <?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
 <configuration>
 <property>
 <name>hbase.zookeeper.quorum</name>
 <value>example1,example2,example3</value>
 <description>The directory shared by RegionServers.
 </description>
 </property>
 <property>
 <name>hbase.zookeeper.property.dataDir</name>
 <value>/export/zookeeper</value>
 <description>Property from ZooKeeper config zoo.cfg.
 The directory where the snapshot is stored.
 </description>
 </property>
 <property>
 <name>hbase.rootdir</name>
 <value>hdfs://example0:8020/hbase</value>
 <description>The directory shared by RegionServers.
 </description>
 </property>
 <property>
 <name>hbase.cluster.distributed</name>
 <value>true</value>
 <description>The mode the cluster will be in. Possible values are
 false: standalone and pseudo-distributed setups with managed ZooKeeper
 true: fully-distributed with unmanaged ZooKeeper Quorum (see hbase-env.sh)
 </description>
 </property>
 </configuration>

8.1.2. *区域服务器*

在此文件中，您列出了将运行 RegionServers 的节点。在我们的例子中，这些节点是`example1`\- `example9`。

example1
    example2
    example3
    example4
    example5
    example6
    example7
    example8
    example9

8.1.3. *hbase-env.sh*

*hbase-env.sh*文件中的以下几行显示了如何设置`JAVA_HOME`环境变量（HBase 需要）并将堆设置为 4 GB（而不是默认值 1 GB）。如果您复制并粘贴此示例，请务必调整`JAVA_HOME`以适合您的环境。

# The java implementation to use.
    export JAVA_HOME=/usr/java/jdk1.8.0/
    
    # The maximum amount of heap to use. Default is left to JVM default.
    export HBASE_HEAPSIZE=4G

使用 rsync 将*conf*目录的内容复制到集群的所有节点。

## 9. 重要配置 ##

下面我们列出一些*重要的*配置。我们将本节分为必需配置和值得一看的推荐配置。

### 9.1. 所需配置 ###

查看[os][]和[hadoop][]部分。

9.1.1. 大集群配置

如果你有一个有很多区域的集群，可能有一个 Regionserver 在 Master 启动后短暂签入，而所有剩余的 RegionServers 都落后了。第一个要签入的服务器将被分配到所有不是最佳的区域。为防止上述情况发生，请将`hbase.master.wait.on.regionservers.mintostart`属性从其默认值 1调高。请参阅[HBASE-6389 修改条件以确保 Master 在开始区域分配之前等待足够数量的区域服务器][HBASE-6389 _ Master]以获取更多详细信息。

### 9.2. 推荐配置 ###

9.2.1. ZooKeeper 配置

`zookeeper.session.timeout`

默认超时为 90 秒（以毫秒为单位）。这意味着如果服务器崩溃，Master 会在 90 秒后注意到崩溃并开始恢复。您可能需要将超时调整到一分钟甚至更短，以便 Master 更快地注意到故障。在更改此值之前**，请确保您已控制 JVM 垃圾收集配置，否则，持续时间超过 ZooKeeper 会话超时的长时间垃圾收集将取消您的 RegionServer。（您可能对此没问题——如果 RegionServer 已在 GC 中长时间处于 GC 状态，您可能希望在服务器上开始恢复）。**

要更改此配置，请编辑*hbase-site.xml*，跨集群复制更改的文件并重新启动。

我们将此值设置得很高，以节省我们必须在邮件列表上提出问题，询问为什么在大规模导入期间 RegionServer 出现故障。通常的原因是他们的 JVM 未调整，并且他们遇到了长时间的 GC 暂停。我们的想法是，当用户熟悉 HBase 时，我们会让他们不必了解它的所有复杂性。后来当他们建立了一些信心时，他们就可以玩这样的配置。

ZooKeeper 实例数

见[动物园管理员 （zookeeper）][zookeeper]

9.2.2. HDFS 配置

`dfs.datanode.failed.volumes.tolerated`

这是*hdfs-default.xml*描述中的“......在 DataNode 停止提供服务之前允许发生故障的卷数。默认情况下，任何卷故障都会导致数据节点关闭” 。您可能希望将其设置为可用磁盘数量的一半左右。

`hbase.regionserver.handler.count`

此设置定义保持打开状态以应答对用户表的传入请求的线程数。经验法则是当每个请求的有效负载接近 MB（大放置，使用大缓存扫描）时保持这个数字低，当有效负载很小（获取，小放置，ICV，删除）时保持高。正在进行的查询的总大小受设置限制 `hbase.ipc.server.max.callqueue.size`。

**如果传入客户端的有效负载很小，则将该数字设置为传入客户端的最大数量是安全的，典型示例是为网站提供服务的集群，因为通常不会对 puts 进行缓冲并且大多数操作都是 get。**

**保持这个设置高的危险的原因是当前在regionserver中发生的所有 puts 的聚合大小可能对其内存施加太大的压力，甚至触发 OutOfMemoryError。运行在低内存上的 RegionServer 将触发其 JVM 的垃圾收集器更频繁地运行，直到 GC 暂停变得明显（原因是用于保存所有请求的有效负载的所有内存都不会被丢弃，无论多么困难）垃圾收集器尝试）。一段时间后，整个集群吞吐量会受到影响，因为每个到达该 RegionServer 的请求都会花费更长的时间，这进一步加剧了问题。**

您可以通过在单个 RegionServer 上的[rpc.logging][]然后[跟踪][rpc.logging]其日志（排队请求消耗内存）来[了解][rpc.logging]处理程序是太少还是太多 。

9.2.3. 大内存机器的配置

HBase 附带了一个合理的、保守的配置，几乎适用于人们可能想要测试的所有机器类型。如果你有更大的机器——HBase 有 8G 和更大的堆——你可能会发现以下配置选项很有帮助。去做。

9.2.4. 压缩

您应该考虑启用 ColumnFamily 压缩。有几个几乎无摩擦的选项，在大多数情况下，通过减小 StoreFiles 的大小从而减少 I/O 来提高性能。

有关详细信息，请参阅[压缩][Link 10]。

9.2.5. 配置 WAL 文件的大小和数量

HBase 使用[wal][]来恢复尚未刷新到磁盘的 memstore 数据，以防出现 RS 故障。这些 WAL 文件应配置为略小于 HDFS 块（默认情况下，HDFS 块为 64Mb，WAL 文件为 ~60Mb）。

HBase 还限制了 WAL 文件的数量，旨在确保在恢复期间不会有太多需要重放的数据。这个限制需要根据 memstore 配置来设置，以便所有必要的数据都适合。建议分配足够的 WAL 文件来存储至少那么多数据（当所有 memstore 都接近满时）。例如，对于 16Gb RS 堆、默认 memstore 设置 (0.4) 和默认 WAL 文件大小 (~60Mb)、16Gb\*0.4/60，WAL 文件计数的起点是 ~109。然而，由于所有的 memstore 不会一直都满，所以可以分配更少的 WAL 文件。

9.2.6. 管理拆分

HBase 通常根据*hbase-default.xml*和*hbase-site.xml*配置文件中的设置处理区域的拆分 。重要设置包括 `hbase.regionserver.region.split.policy`、`hbase.hregion.max.filesize`、 `hbase.regionserver.regionSplitLimit`。分裂的一个简单观点是，当一个区域增长到 时`hbase.hregion.max.filesize`，它就会分裂。对于大多数使用模式，您应该使用自动拆分。有关[手动区域拆分][Link 11]的更多信息，请参阅[手动区域拆分决策][Link 11]。

您可以选择自己管理拆分，而不是让 HBase 自动拆分您的区域。如果您非常了解您的键空间，手动管理拆分是可行的，否则让 HBase 为您确定拆分的位置。手动拆分可以减轻负载下的区域创建和移动。它还使区域边界已知且不变（如果您禁用区域拆分）。如果您使用手动拆分，则可以更轻松地进行交错的、基于时间的主要压缩以分散您的网络 IO 负载。

*禁用自动拆分*

要禁用自动拆分，您可以在集群配置或表配置中设置区域拆分策略为 `org.apache.hadoop.hbase.regionserver.DisabledRegionSplitPolicy`

*确定预拆分区region的最佳数量*

预拆分区域的最佳数量取决于您的应用程序和环境。一个好的经验法则是从每台服务器 10 个预拆分region开始，并观察数据随时间的增长。最好在太少的region出错，然后再进行滚动拆分。最佳区域数取决于您所在区域中最大的 StoreFile。如果数据量增加，最大的 StoreFile 的大小将随时间增加。目标是使最大区域足够大，以便压缩选择算法仅在定时主要压缩期间对其进行压缩。否则，集群可能容易发生压实风暴，同时有大量区域处于压实状态。重要的是要了解数据增长会导致压缩风暴而不是手动拆分决策。

如果region被拆分成太多大region，可以通过配置增加major compaction间隔`HConstants.MAJOR_COMPACTION_PERIOD`。该 `org.apache.hadoop.hbase.util.RegionSplitter`实用程序还提供所有区域的网络 IO 安全滚动拆分。

9.2.7. 管理压缩

默认情况下，大（Major Compaction）压缩计划在 7 天内运行一次。

如果您需要精确控制主要压缩运行的时间和频率，您可以禁用托管大压缩。请参阅条目`hbase.hregion.majorcompaction`中 [compaction.parameters][]表的详细信息。

<table> 
 <tbody> 
 <tr> 
 <td style="text-align:center;width:80px;"></td> 
 <td> 
 <div style="margin-left:.25em;text-align:left;"> 
 不要禁用大压缩 
 </div> 
 <div style="margin-left:0;"> 
 主要压缩对于 StoreFile 清理是绝对必要的。不要完全禁用它们。您可以通过 HBase shell 或通过<a href="https://hbase.apache.org/apidocs/org/apache/hadoop/hbase/client/Admin.html#majorCompact-org.apache.hadoop.hbase.TableName-" title="Admin API" rel="nofollow">Admin API</a>手动运行主要压缩&nbsp;。 
 </div> </td> 
 </tr> 
 </tbody> 
</table>

有关压缩和压缩文件选择过程的更多信息，请参阅 [压缩][Link 12]

9.2.8. 推测执行

MapReduce 任务的推测执行默认是打开的，对于 HBase 集群，通常建议在系统级别关闭推测执行，除非您在特定情况下需要它，可以为每个作业配置它。设置性能`mapreduce.map.speculative`和 `mapreduce.reduce.speculative`为false。

### 9.3. 其他配置 ###

9.3.1. 平衡器balancer

平衡器是一个周期性操作，它在主服务器上运行以重新分配集群上的区域**。它通过配置`hbase.balancer.period`并默认为 300000（5 分钟）。**

有关LoadBalancer 的更多信息，请参阅[master.processes.loadbalancer][]。

9.3.2. 禁用块缓存

不要关闭块缓存（您可以通过设置`hfile.block.cache.size`为零来完成）。目前，如果您这样做，我们做得不好，因为 RegionServer 将花费所有时间一遍又一遍地加载 HFile 索引。如果您的工作集是块缓存对您没有好处，至少调整块缓存的大小，以便 HFile 索引将保留在缓存中（您可以通过调查 RegionServer UI 大致了解所需的大小；您将请参阅网页顶部附近的索引块大小）。

9.3.3. [Nagle][]或小包装问题

如果在针对 HBase 的操作中偶尔会看到 40 毫秒左右的大延迟，请尝试 Nagles 的设置。例如，请参阅用户邮件列表线程， [缓存设置为 1 时扫描性能不一致][1] 以及其中引用的设置`notcpdelay`提高扫描速度的问题。您可能还会看到[HBASE-7008][]尾部的图表 [将扫描仪缓存设置为更好的默认值][HBASE-7008] ，其中我们的 Lars Hofhansl 尝试使用 Nagle 打开和关闭测量效果的各种数据大小。

9.3.4. 更好的平均恢复时间 (MTTR)

本节是关于使服务器在失败后更快恢复的配置。有关 简要介绍，请参阅 Deveraj Das 和 Nicolas Liochon 博客文章 [HBase 平均恢复时间 (MTTR)][HBase _ _MTTR]简介。

问题 [HBASE-8354 强制 Namenode 进入带有租约恢复请求的循环][HBASE-8354 _ Namenode] 是混乱的，但在接近尾声时有很多关于低超时以及如何导致更快恢复的很好的讨论，包括引用添加到 HDFS 的修复程序。阅读 Varun Sharma 的评论。以下建议的配置是 Varun 提炼和测试的建议。确保您运行在较新版本的 HDFS 上，以便您拥有他所引用的修复程序，并且他自己添加到 HDFS 以帮助 HBase MTTR（例如 HDFS-3703、HDFS-3712 和 HDFS-4791 — Hadoop 2 肯定有它们并且Hadoop 1 后期有一些）。在 RegionServer 中设置以下内容。

<property>
 <name>hbase.lease.recovery.dfs.timeout</name>
 <value>23000</value>
 <description>How much time we allow elapse between calls to recover lease.
 Should be larger than the dfs timeout.</description>
 </property>
 <property>
 <name>dfs.client.socket-timeout</name>
 <value>10000</value>
 <description>Down the DFS timeout from 60 to 10 seconds.</description>
 </property>

在 NameNode/DataNode 端，设置以下内容以启用 HDFS-3703、HDFS-3912 中引入的“staleness”。

<property>
 <name>dfs.client.socket-timeout</name>
 <value>10000</value>
 <description>Down the DFS timeout from 60 to 10 seconds.</description>
 </property>
 <property>
 <name>dfs.datanode.socket.write.timeout</name>
 <value>10000</value>
 <description>Down the DFS timeout from 8 * 60 to 10 seconds.</description>
 </property>
 <property>
 <name>ipc.client.connect.timeout</name>
 <value>3000</value>
 <description>Down from 60 seconds to 3.</description>
 </property>
 <property>
 <name>ipc.client.connect.max.retries.on.timeouts</name>
 <value>2</value>
 <description>Down from 45 seconds to 3 (2 == 3 retries).</description>
 </property>
 <property>
 <name>dfs.namenode.avoid.read.stale.datanode</name>
 <value>true</value>
 <description>Enable stale state in hdfs</description>
 </property>
 <property>
 <name>dfs.namenode.stale.datanode.interval</name>
 <value>20000</value>
 <description>Down from default 30 seconds</description>
 </property>
 <property>
 <name>dfs.namenode.avoid.write.stale.datanode</name>
 <value>true</value>
 <description>Enable stale state in hdfs</description>
 </property>

9.3.5. JMX

JMX（Java 管理扩展）提供了内置工具，使您能够监视和管理 Java VM。要从远程系统启用监视和管理，您需要`com.sun.management.jmxremote.port`在启动 Java VM 时设置系统属性（您希望通过其启用 JMX RMI 连接的端口号）。有关 更多信息，请参阅 [官方文档][Link 13]。历史上，除了上面提到的端口之外，JMX 还打开了两个额外的随机 TCP 侦听端口，这可能会导致端口冲突问题。（详见 [HBASE-10289][]）

作为替代方案，您可以使用 HBase 提供的基于协处理器的 JMX 实现。要启用它，请在*hbase-site.xml 中*添加以下属性：

<property>
 <name>hbase.coprocessor.regionserver.classes</name>
 <value>org.apache.hadoop.hbase.JMXListener</value>
 </property>

<table> 
 <tbody> 
 <tr> 
 <td>请勿同时<code>com.sun.management.jmxremote.port</code>为 Java VM设置。</td> 
 </tr> 
 </tbody> 
</table>

目前它支持 Master 和 RegionServer Java VM。默认情况下，JMX 侦听 TCP 端口 10102，您可以使用以下属性进一步配置端口：

<property>
 <name>regionserver.rmi.registry.port</name>
 <value>61130</value>
 </property>
 <property>
 <name>regionserver.rmi.connector.port</name>
 <value>61140</value>
 </property>

注册端口在大多数情况下可以与连接器端口共享，因此您只需要配置 `regionserver.rmi.registry.port`. 但是，如果要使用 SSL 通信，则必须将 2 个端口配置为不同的值。

默认情况下，密码验证和 SSL 通信是禁用的。要启用密码身份验证，您需要更新*hbase-env.sh，*如下所示：

export HBASE_JMX_BASE="-Dcom.sun.management.jmxremote.authenticate=true                  \
                           -Dcom.sun.management.jmxremote.password.file=your_password_file   \
                           -Dcom.sun.management.jmxremote.access.file=your_access_file"
    
    export HBASE_MASTER_OPTS="$HBASE_MASTER_OPTS $HBASE_JMX_BASE "
    export HBASE_REGIONSERVER_OPTS="$HBASE_REGIONSERVER_OPTS $HBASE_JMX_BASE "

请参阅*$JRE\_HOME/lib/management*下的示例密码/访问文件。

要使用密码身份验证启用 SSL 通信，请按照以下步骤操作：

#1. generate a key pair, stored in myKeyStore
    keytool -genkey -alias jconsole -keystore myKeyStore
    
    #2. export it to file jconsole.cert
    keytool -export -alias jconsole -keystore myKeyStore -file jconsole.cert
    
    #3. copy jconsole.cert to jconsole client machine, import it to jconsoleKeyStore
    keytool -import -alias jconsole -keystore jconsoleKeyStore -file jconsole.cert

然后像下面这样更新*hbase-env.sh*：

export HBASE_JMX_BASE="-Dcom.sun.management.jmxremote.ssl=true                         \
                           -Djavax.net.ssl.keyStore=/home/tianq/myKeyStore                 \
                           -Djavax.net.ssl.keyStorePassword=your_password_in_step_1        \
                           -Dcom.sun.management.jmxremote.authenticate=true                \
                           -Dcom.sun.management.jmxremote.password.file=your_password file \
                           -Dcom.sun.management.jmxremote.access.file=your_access_file"
    
    export HBASE_MASTER_OPTS="$HBASE_MASTER_OPTS $HBASE_JMX_BASE "
    export HBASE_REGIONSERVER_OPTS="$HBASE_REGIONSERVER_OPTS $HBASE_JMX_BASE "

最后`jconsole`使用密钥存储在客户端上启动：

jconsole -J-Djavax.net.ssl.trustStore=/home/tianq/jconsoleKeyStore

<table> 
 <tbody> 
 <tr> 
 <td style="text-align:center;width:80px;"></td> 
 <td>要在 Master 上启用 HBase JMX 实现，您还需要在hbase-site.xml 中添加以下属性&nbsp;：</td> 
 </tr> 
 </tbody> 
</table>

<property>
 <name>hbase.coprocessor.master.classes</name>
 <value>org.apache.hadoop.hbase.JMXListener</value>
 </property>

端口配置的对应属性是`master.rmi.registry.port`（默认为10101）和`master.rmi.connector.port`（默认与registry.port相同）

## 10. 动态配置 ##

**无需重新启动服务器即可更改配置的子集**。在 HBase shell 中，操作`update_config`、`update_all_config`和`update_rsgroup_config` 会提示一个服务器、所有服务器或 RSGroup 中的所有服务器重新加载配置。

当前只能在运行的服务器中更改所有配置的一个子集。以下是这些配置：

<table> 
 表 3. 配置支持动态更改(所谓动态更改不用重启服务即可生效) 
 <thead> 
 <tr> 
 <th style="border-color:#dedede;text-align:left;vertical-align:top;">钥匙</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.ipc.server.fallback-to-simple-auth-allowed </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.cleaner.scan.dir.concurrent.size </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.regionserver.thread.compaction.large </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.regionserver.thread.compaction.small </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.regionserver.thread.split </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.regionserver.throughput.controller </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.regionserver.thread.hfilecleaner.throttle </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.regionserver.hfilecleaner.large.queue.size </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.regionserver.hfilecleaner.small.queue.size </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.regionserver.hfilecleaner.large.thread.count </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.regionserver.hfilecleaner.small.thread.count </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.regionserver.hfilecleaner.thread.timeout.msec </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.regionserver.hfilecleaner.thread.check.interval.msec </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.regionserver.flush.throughput.controller </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.hstore.compaction.max.size </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.hstore.compaction.max.size.offpeak </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.hstore.compaction.min.size </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.hstore.compaction.min </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.hstore.compaction.max </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.hstore.compaction.ratio </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.hstore.compaction.ratio.offpeak </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.regionserver.thread.compaction.throttle </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.hregion.majorcompaction </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.hregion.majorcompaction.jitter </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.hstore.min.locality.to.skip.major.compact </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.hstore.compaction.date.tiered.max.storefile.age.millis </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.hstore.compaction.date.tiered.incoming.window.min </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.hstore.compaction.date.tiered.window.policy.class </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.hstore.compaction.date.tiered.single.output.for.minor.compaction </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.hstore.compaction.date.tiered.window.factory.class </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.offpeak.start.hour </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.offpeak.end.hour </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.oldwals.cleaner.thread.size </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.oldwals.cleaner.thread.timeout.msec </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.oldwals.cleaner.thread.check.interval.msec </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.procedure.worker.keep.alive.time.msec </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.procedure.worker.add.stuck.percentage </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.procedure.worker.monitor.interval.msec </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.procedure.worker.stuck.threshold.msec </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.regions.slop </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.regions.overallSlop </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.balancer.tablesOnMaster </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.balancer.tablesOnMaster.systemTablesOnly </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.util.ip.to.rack.determiner </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.ipc.server.max.callqueue.length </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.ipc.server.priority.max.callqueue.length </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.ipc.server.callqueue.type </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.ipc.server.callqueue.codel.target.delay </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.ipc.server.callqueue.codel.interval </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.ipc.server.callqueue.codel.lifo.threshold </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.maxSteps </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.stepsPerRegion </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.maxRunningTime </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.runMaxSteps </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.numRegionLoadsToRemember </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.loadbalance.bytable </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.minCostNeedBalance </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.localityCost </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.rackLocalityCost </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.readRequestCost </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.writeRequestCost </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.memstoreSizeCost </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.storefileSizeCost </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.regionReplicaHostCostKey </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.regionReplicaRackCostKey </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.regionCountCost </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.primaryRegionCountCost </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.moveCost </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.moveCost.offpeak </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.maxMovePercent </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.balancer.stochastic.tableSkewCost </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.master.regions.recovery.check.interval </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.regions.recovery.store.file.ref.count </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#dedede;text-align:left;vertical-align:top;"> hbase.rsgroup.fallback.enable </td> 
 </tr> 
 </tbody> 
</table>

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rak55Sf5omL6K6w_size_20_color_FFFFFF_t_70_g_se_x_16 2][]

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rak55Sf5omL6K6w_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/eb6e68bc093b4753b47eda5b6111a54b.png
[Link 1]: http://hbase.apache.org/book.html#_introduction
[2. _ - _ HBase]: http://hbase.apache.org/book.html#quickstart
[Apache HBase]: http://hbase.apache.org/book.html#configuration
[3.]: http://hbase.apache.org/book.html#_configuration_files
[4.]: http://hbase.apache.org/book.html#basic.prerequisites
[5. HBase _Standalone _ Distributed]: http://hbase.apache.org/book.html#standalone_dist
[6.]: http://hbase.apache.org/book.html#confirm
[7.]: http://hbase.apache.org/book.html#config.files
[8.]: http://hbase.apache.org/book.html#example_config
[9.]: http://hbase.apache.org/book.html#important_configurations
[10.]: http://hbase.apache.org/book.html#dyn_config
[Java]: http://hbase.apache.org/book.html#java
[Apache]: https://www.apache.org/dyn/closer.lua/hbase/
[http_localhost_16010]: http://localhost:16010/
[Pseudo-Distributed for Local Testing]: http://hbase.apache.org/book.html#quickstart_pseudo
[zookeeper]: http://hbase.apache.org/book.html#zookeeper
[Link 2]: http://hbase.apache.org/book.html#getting_started
[Link 3]: http://hbase.apache.org/book.html#hbase_supported_tested_definitions
[Hadoop Wiki]: https://cwiki.apache.org/confluence/display/HADOOP2/HADOOP-6728-MetricsV2
[Link 4]: http://hbase.apache.org/book.html#security
[SSH]: http://hbase.apache.org/book.html#passwordless.ssh.quickstart
[SSH 1]: https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=120730246#RunningHadoopOnOSX10.564-bit%28Single-NodeCluster%29-SSH:SettingupRemoteDesktopandEnablingSelf-Login
[NTP]: http://www.tldp.org/LDP/sag/html/basic-ntp-config.html
[Link 5]: http://hbase.apache.org/book.html#trouble.rs.runtime.filehandles
[GNU Bash]: http://www.gnu.org/software/bash
[Hadoop]: https://hadoop.apache.org/
[Hadoop 1]: https://cwiki.apache.org/confluence/display/HADOOP2/Distributions+and+Commercial+Support
[Link 6]: https://hadoop.apache.org/cve_list.html
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rak55Sf5omL6K6w_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/af6b38dbb06c474e8b37b8e9bcd1f0a3.png
[casetudies.max.transfer.threads]: http://hbase.apache.org/book.html#casestudies.max.transfer.threads
[Hadoop HDFS_Deceived by Xciever]: http://ccgtech.blogspot.com/2010/02/hadoop-hdfs-deceived-by-xciever.html
[HBASE-16598]: https://issues.apache.org/jira/browse/HBASE-16598
[Link 7]: http://hbase.apache.org/book.html#standalone
[Link 8]: http://hbase.apache.org/book.html#distributed
[Link 9]: https://hadoop.apache.org/docs/current/
[Hadoop YARN Installation_ The definitive guide _ Alex JF]: http://www.alexjf.net/blog/distributed-systems/hadoop-yarn-installation-definitive-guide
[quickstart-fully-distributed]: http://hbase.apache.org/book.html#quickstart_fully_distributed
[shell]: http://hbase.apache.org/book.html#shell_exercises
[hbase]: http://hbase.apache.org/book.html#hbase_default_configurations
[ZooKeeper_ Because Coordinating Distributed Systems is a Zoo]: https://zookeeper.apache.org/doc/current/zookeeperProgrammers.html#ch_zkSessions
[ZooKeeper Getting Started Guide]: https://zookeeper.apache.org/doc/r3.4.10/zookeeperStarted.html#sc_RunningReplicatedZooKeeper
[HBASE-16388_ Prevent client threads being blocked by only one slow region server - ASF JIRA]: https://issues.apache.org/jira/browse/HBASE-16388
[http_hbase.apache.org_book.html_offheap.blockcache]: http://hbase.apache.org/book.html#offheap.blockcache
[http_hbase.apache.org_book.html_hbase.tags]: http://hbase.apache.org/book.html#hbase.tags
[Socket _Java 2 Platform SE 5.0]: http://docs.oracle.com/javase/1.5.0/docs/api/java/net/Socket.html#getTcpNoDelay%28
[HBASE-12954_ Ability impaired using HBase on multihomed hosts - ASF JIRA]: https://issues.apache.org/jira/browse/HBASE-12954
[HBASE-18226_ Disable reverse DNS lookup at HMaster and use the hostname provided by RegionServer - ASF JIRA]: https://issues.apache.org/jira/browse/HBASE-18226
[HBASE-25665_ Disable reverse DNS lookup for SASL Kerberos client connection - ASF JIRA]: https://issues.apache.org/jira/browse/HBASE-25665
[StochasticLoadBalancer _Apache HBase 3.0.0-alpha-2-SNAPSHOT API]: http://hbase.apache.org/devapidocs/org/apache/hadoop/hbase/master/balancer/StochasticLoadBalancer.html
[SimpleRegionNormalizer _Apache HBase 3.0.0-alpha-2-SNAPSHOT API]: http://hbase.apache.org/devapidocs/org/apache/hadoop/hbase/master/normalizer/SimpleRegionNormalizer.html
[Apache Log4j2]: https://logging.apache.org/log4j/2.x/index.html
[2.3.0]: http://hbase.apache.org/book.html#client.masterregistry
[HBaseConfiguration]: https://hbase.apache.org/apidocs/org/apache/hadoop/hbase/HBaseConfiguration
[os]: http://hbase.apache.org/book.html#os
[hadoop]: http://hbase.apache.org/book.html#hadoop
[HBASE-6389 _ Master]: https://issues.apache.org/jira/browse/HBASE-6389
[rpc.logging]: http://hbase.apache.org/book.html#rpc.logging
[Link 10]: http://hbase.apache.org/book.html#compression
[wal]: http://hbase.apache.org/book.html#wal
[Link 11]: http://hbase.apache.org/book.html#manual_region_splitting_decisions
[compaction.parameters]: http://hbase.apache.org/book.html#compaction.parameters
[Link 12]: http://hbase.apache.org/book.html#compaction
[master.processes.loadbalancer]: http://hbase.apache.org/book.html#master.processes.loadbalancer
[Nagle]: http://en.wikipedia.org/wiki/Nagle%E2%80%99s_algorithm
[1]: https://lists.apache.org/thread.html/3d7ceb41c04a955b1b1c80480cdba95208ca3e97bf6895a40e0c1bbb%401346186127%40%3Cuser.hbase.apache.org%3E
[HBASE-7008]: https://issues.apache.org/jira/browse/HBASE-7008
[HBase _ _MTTR]: http://hortonworks.com/blog/introduction-to-hbase-mean-time-to-recover-mttr/
[HBASE-8354 _ Namenode]: https://issues.apache.org/jira/browse/HBASE-8389
[Link 13]: http://docs.oracle.com/javase/8/docs/technotes/guides/management/agent.html
[HBASE-10289]: https://issues.apache.org/jira/browse/HBASE-10289
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rak55Sf5omL6K6w_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220828/08a0e77f190f446093fdf19e0ff8753f.png