ClickHouse学习系列之四【副本&分片部署说明】

背景

  以前介绍过ClickHouse相关的系列文章,现在继续说明。本文开始说明ClickHouse的副本与分片,和其他数据库一样,ClickHouse也会出现单节点故障和单节点资源到达上限的情况。所以针对上面的2个问题,就出现了副本和分片。副本:能避免单节点故障的问题,类似于MySQL的Replicate和MongoDB的Replicate Set。分片:解决单节点瓶颈的问题,类似于MySQL的分库分表和MongoDB的Sharding。

部署说明

一:副本

特点:

1. 依赖ZooKeeper,通过其来协调多个副本之间的同步。

2. 表级别的副本,副本是在表级别定义的。

3. 多主架构,可以在任意副本上执行语句。

环境:(版本:21.6.3.14)

  实例A  实例B 
IP

12.16.20.12

12.16.20.17

Port 9000 9000

测试: 

需要配置ZooKeeper的地址,并且需要保证2个实例的IP、Port可以通讯(<listen_host>0.0.0.0</listen_host>)。副本模式只需要修改2个实例的配置文件(config.xml)中的ZooKeeper的信息:

    <zookeeper>
        <node index="1">   -- 单节点,可以配置成集群模式(3节点)
            <host>12.16.20.17</host>
            <port>2181</port>
        </node>
    </zookeeper>

建表引擎格式:

ENGINE = ReplicatedMergeTree('zk_path', 'replica_name')

zk_path:指定在ZooKeeper中创建数据表的路径,可以自定义。同一张表同一个分片的不同副本,定义相同路径。为了方便记录,可以约定为:

'/clickhouse/tables/{shard}/table_name'
  • shard:分片信息,如果只配置副本,分片信息保持一致即可。
  • replica_name:副本集名称,唯一。同一张表同一个分片的不同副本,定义不同名称。

实例A上执行:

CREATE TABLE repl_test
(
    `id` String,
    `price` Float64,
    `create_time` DateTime
)
ENGINE = ReplicatedMergeTree('/clickhouse/tables/01/repl_test','dba06')
PARTITION BY toYYYYMM(create_time)
ORDER BY id

实例B上执行:

CREATE TABLE repl_test
(
    `id` String,
    `price` Float64,
    `create_time` DateTime
)
ENGINE = ReplicatedMergeTree('/clickhouse/tables/01/repl_test','dba07')
PARTITION BY toYYYYMM(create_time)
ORDER BY id

2个实例上的副本表的zk_path一样,replica_name不一样。需要注意的是:和MySQL不一样,副本表需要在2个实例上分别手动建立。

现在在实例A上执行插入:

insert into repl_test values('A001',123,'2021-05-01 09:09:00');
insert into repl_test values('A002',123,'2021-06-01 09:09:00');
insert into repl_test values('B001',321,'2021-05-01 09:09:00');
insert into repl_test values('B002',321,'2021-06-01 09:09:00');

分别在2个实例上查询该表,都能显示数据,并且在实例B上执行插入,也能同步到实例A上,达到了多主的要求。

上面的建表语句中,shard、replica使用了硬编码的方式:01;dba06、dba07。这样维护起来比较麻烦,可以通过动态变量来替换,也可以把各个实例公有的参数ZooKeeper拎出来一起放到metrika.xml中(/etc/clickhouse-server/config.d/metrika.xml):

<yandex>
    <zookeeper-server>
        <node index="1">
            <host>12.16.20.17</host>
            <port>2181</port>
        </node>
    </zookeeper-server>
    <macros>
        <replica>dba06</replica>  -- 另一个实例设置dba07
        <shard>1</shard>
    </macros>
</yandex>

每个实例的配置文件(config.xml)一致,只有<macros>参数里的不一样。并且修改config.xml,把上面的配置文件include进去:

    <include_from>/etc/clickhouse-server/config.d/metrika.xml</include_from>
    <zookeeper incl="zookeeper-server" optional="false" />
    <macros incl="macros" optional="true" />

incl标签对应的值需要和metrika.xml文件中的选项组保持一致。配置完成之后,可以通过以下SQL查看各个实例的变量:

select * from system.macros;

完成之后,在新建副本表时只需要在2个实例上执行同样的SQL:

CREATE TABLE repl_test123
(
    `id` String,
    `price` Float64,
    `create_time` DateTime
)
ENGINE = ReplicatedMergeTree('/clickhouse/tables/{shard}/repl_test123','{replica}')
PARTITION BY toYYYYMM(create_time)
ORDER BY id

这样就保证了同一个语句不需要修改就在多个实例上执行,减少了手动修改导致的问题。

总结:

副本表的好处:增加了数据的可靠性,减少了单节点故障导致数据丢失的问题;副本表数据的同步是通过ZooKeeper进行协调的,不需要进行数据的传输;并且在各个副本表的各个实例上都可以执行SQL,提高了单点写入的性能问题,也分摊了查询,读写分离。

副本表的不足:需要在多个副本实例上建表,运维不方便;也无法解决单节点达到瓶颈的问题。

二:分片

 ClickHouse每个实例都可以成为一个分片(shard),在集群配置中用shard代表分片,用replica代表副本。分片是指将数据拆分,将其分散在不同的实例上的过程。将数据分散到不同的机器上,不需要功能强大的服务器就可以存储更多的数据和处理更大的负载。每个分片只负责总数据的一部分,通过一个名为Distributed的引擎进行操作。类似于MongoDB的Sharding。

分片表的引擎可以用任意引擎,但是如果使用非ReplicatedMergeTree引擎的话,副本的数据同步需要Distributed来负责(写分片和副本),加大了其压力。所以如果使用分片,并且需要副本,推荐使用ReplicatedMergeTree引擎,数据同步交由其处理,减轻Distributed压力(需要增加internal_replication参数:<internal_replication>true</internal_replication>)。

环境:

  实例A  实例B  实例C  实例D 
IP 12.16.20.12 12.16.20.17 12.16.20.12 12.16.20.17
Port 9000 9000 9010 9010


测试:

和副本一样,也一样需要配置ZooKeeper,也要保证2个实例的IP、Port可以通讯(<listen_host>0.0.0.0</listen_host>),因为ZooKeeper在各个节点上配置一致,便于维护,独立到/etc/clickhouse-server/config.d/metrika.xml 文件里。现在测试2种场景:2分片0副本、2分片1副本

因为各个副本配置的集群信息一致(同一个集群),所以集群配置信息也放到metrika.xml 文件里。

场景一:2分片0副本

config.xml 配置文件各个实例一样(默认即可),只需要修改include:

    <include_from>/etc/clickhouse-server/config.d/metrika.xml</include_from>
    <zookeeper incl="zookeeper-server" optional="false" />
    <macros incl="macros" optional="false" />
    <remote_servers incl="ck_remote_servers" />

metrika.xml信息:

<?xml version="1.0"?>
<yandex>

    <zookeeper-server>
        <node index="1">
            <host>12.16.20.17</host>
            <port>2181</port>
        </node>
    </zookeeper-server>

    <macros>
        <replica>dba06</replica>
        <shard>1</shard>
    </macros>

    <ck_remote_servers>
        <test_cluster_0_repl>
            <shard>
                <weight>1</weight>
                <replica>
                    <host>12.16.20.12</host>
                    <port>9000</port>
                    <priority>1</priority>
                </replica>
            </shard>
            <shard>
                <weight>1</weight>
                <replica>
                    <host>12.16.20.17</host>
                    <port>9000</port>
                    <priority>1</priority>
                </replica>
            </shard>
        </test_cluster_0_repl>
    </ck_remote_servers>

</yandex>

各个实例的配置都一样,除了标签<macros>各个实例不一样,区别是:

    <macros>
        <replica>dba07</replica> -- 可以配置各个节点的本地ip
        <shard>2</shard>
    </macros>

2分片[1、2]0副本的集群为[test_cluster_0_repl]已经配置完成,可以通过以下语句查看:

-- 查看集群
select * from system.clusters

-- 查看macros
select * from system.macros

注意,基于集群可以使用 on cluster cluster_name 语法,只需要在一个节点上执行SQL就可同步到所有节点。如新增表:

CREATE TABLE test_clsuter_a on cluster test_cluster_0_repl
(
    `id` String,
    `price` Float64,
    `create_time` DateTime
)
ENGINE = MergeTree()
PARTITION BY toYYYYMM(create_time)
ORDER BY id

表引擎可以为任意引擎,该集群下的所有节点都会创建该表(本地表)接着建立Distributed分布式表,语法:

Distributed('集群名','数据库名','表名', '分片键')

Distributed引擎表,其自身不存储数据,而是作为数据分片的代理,自动路由数据到集群中的各个节点,其中<分片键>参数要求返回整型类型的取值,即按照分片键的规则将数据分布到各个节点,如:

  • userid:按照用户id余数拆分
  • rand():按照随机数拆分
  • intHash64(userid):按照用户id散列值划分
CREATE TABLE test_clsuter_all on cluster test_cluster_0_repl
(
    `id` String,
    `price` Float64,
    `create_time` DateTime
)
ENGINE = Distributed('test_cluster_0_repl','default','test_clsuter_a', rand())

向分布式表test_clsuter_all写入数据: 

insert into test_clsuter_all values('X001',123,'2021-05-01 09:09:00');
insert into test_clsuter_all values('X002',123,'2021-06-01 09:09:00');
insert into test_clsuter_all values('W001',321,'2021-05-01 09:09:00');
insert into test_clsuter_all values('W002',321,'2021-06-01 09:09:00');
insert into test_clsuter_all values('K001',123,'2021-05-01 09:09:00');
insert into test_clsuter_all values('K002',123,'2021-06-01 09:09:00');
insert into test_clsuter_all values('M001',321,'2021-05-01 09:09:00');
insert into test_clsuter_all values('M002',321,'2021-06-01 09:09:00');
insert into test_clsuter_all values('S001',123,'2021-05-01 09:09:00');
insert into test_clsuter_all values('S002',123,'2021-06-01 09:09:00');
insert into test_clsuter_all values('G001',321,'2021-05-01 09:09:00');
insert into test_clsuter_all values('G002',321,'2021-06-01 09:09:00');
View Code

最后在集群中的任意节点查询该表,都能看到全量数据。本地表则可以看到节点自身的数据。

场景二:2分片1副本

场景一配置一样,唯一的差别就是,在metrika.xml中再添加一个副本:

<?xml version="1.0"?>
<yandex>

    <zookeeper-server>
        <node index="1">
            <host>12.16.20.17</host>
            <port>2181</port>
        </node>
    </zookeeper-server>

    <macros>
        <replica>dba06</replica>
        <shard>1</shard>
    </macros>

    <ck_remote_servers>
        <test_cluster_1_repl>
            <shard>
                <internal_replication>true</internal_replication>  -- 有复制表引擎自己分发同步数据,减少Distributed压力。
                <weight>1</weight>
                <replica>
                    <host>12.16.20.12</host>
                    <port>9000</port>
                    <priority>1</priority>
                </replica>
                <replica>
                    <host>12.16.20.12</host>
                    <port>9010</port>
                    <priority>1</priority>
                </replica>
            </shard>
            <shard>
                <internal_replication>true</internal_replication>
                <weight>1</weight>
                <replica>
                    <host>12.16.20.17</host>
                    <port>9000</port>
                    <priority>1</priority>
                </replica>
                <replica>
                    <host>12.16.20.17</host>
                    <port>9010</port>
                    <priority>1</priority>
                </replica>
            </shard>
        </test_cluster_1_repl>
    </ck_remote_servers>

</yandex>

各个节点的区别也是macros:

    <macros>
        <replica>dba06</replica> --可以写本机ip
        <shard>1</shard>    --分片1,分片2
    </macros>

完成之后,可以通过查询clusters表来了解各个节点的信息:

select * from system.clusters;
┌─cluster─────────────┬─shard_num─┬─shard_weight─┬─replica_num─┬─host_name──────┬─host_address───┬─port─┬─is_local─┬─user────┬─default_database─┬─errors_count─┬─slowdowns_count─┬─estimated_recovery_time─┐
│ test_cluster_1_repl │         111 │ 12.16.20.12 │ 12.16.20.12 │ 90001default │                  │            000 │
│ test_cluster_1_repl │         112 │ 12.16.20.12 │ 12.16.20.12 │ 90100default │                  │            000 │
│ test_cluster_1_repl │         211 │ 12.16.20.17   │ 12.16.20.17   │ 90000default │                  │            000 │
│ test_cluster_1_repl │         212 │ 12.16.20.17   │ 12.16.20.17   │ 90100default │                  │            000 │
└─────────────────────┴───────────┴──────────────┴─────────────┴────────────────┴────────────────┴──────┴──────────┴─────────┴──────────────────┴──────────────┴─────────────────┴─────────────────────────┘

注意,基于集群可以使用 on cluster cluster_name 语法,只需要在一个节点上执行SQL即可同步到所有节点。如新增表:

CREATE TABLE repl_abc on cluster test_cluster_1_repl
(
    `id` String,
    `price` Float64,
    `create_time` DateTime
)
ENGINE = ReplicatedMergeTree('/clickhouse/tables/{shard}/repl_abc','{replica}')
PARTITION BY toYYYYMM(create_time)
ORDER BY id

这样各个节点(分配和副本)都会新建该表(本地表),接着建立Distributed分布式表:

CREATE TABLE repl_abc_all on cluster test_cluster_1_repl
(
    `id` String,
    `price` Float64,
    `create_time` DateTime
)
ENGINE = Distributed('test_cluster_1_repl','testdb','repl_abc', rand())
insert into repl_abc_all values('X001',123,'2021-05-01 09:09:00');
insert into repl_abc_all values('X002',123,'2021-06-01 09:09:00');
insert into repl_abc_all values('W001',321,'2021-05-01 09:09:00');
insert into repl_abc_all values('W002',321,'2021-06-01 09:09:00');
insert into repl_abc_all values('K001',123,'2021-05-01 09:09:00');
insert into repl_abc_all values('K002',123,'2021-06-01 09:09:00');
insert into repl_abc_all values('M001',321,'2021-05-01 09:09:00');
insert into repl_abc_all values('M002',321,'2021-06-01 09:09:00');
insert into repl_abc_all values('S001',123,'2021-05-01 09:09:00');
insert into repl_abc_all values('S002',123,'2021-06-01 09:09:00');
insert into repl_abc_all values('G001',321,'2021-05-01 09:09:00');
insert into repl_abc_all values('G002',321,'2021-06-01 09:09:00');
View Code

场景一类似,在任意一节点向分布式表写入数据,最后在集群中的任意节点查询该表,都能看到全量数据。本地表则可以看到节点自身的数据。

注意:建立副本表(ReplicatedMergeTree)的时候,如果数据库的引擎是Atomic,则在删除表之后马上重建会遇到:

Code: 253. DB::Exception: Received from localhost:9000. DB::Exception: There was an error on [12.16.20.17:9000]: Code: 253, e.displayText() = DB::Exception: Replica /clickhouse/tables/2/repl_test123/replicas/dba07 already exists. (version 21.6.3.14 (official build)).

避免该问题的方法有2种:

  • 使用普通数据库而不是Atomic数据库(ENGINE = Atomic): CREATE DATABASE … Engine=Ordinary。
  • 修改参数 database_atomic_delay_before_drop_table_sec = 0 
    <database_atomic_delay_before_drop_table_sec>0</database_atomic_delay_before_drop_table_sec>

这样,在建立副本表(ReplicatedMergeTree)再删除马上重建,不会报错。

以上是没有用户认证的部署,线上环境如果有认证(user:default;password:123456)的话,需要在各个shard中添加参数(metrika.xml),各个参数的意义:

    <ck_remote_servers>
        <test_cluster_1_repl>
        <!-- 分片1 -->
            <shard>
                <!-- 有复制表直接负责数据分发同步 -->
                <internal_replication>true</internal_replication>
                <!-- 影响数据分布的倾斜,权重越大数据写入越多 -->
                <weight>1</weight>
                <!-- 分片、副本配置 -->
                <replica>
                    <host>12.16.20.12</host>
                    <port>9000</port>
                    <!-- 节点认证用户 -->
                    <user>default</user>
                    <!-- 节点用户密码 -->
                    <password>123456</password>
                    <!-- 节点权重,值越小优先级越高 -->
<priority>1</priority> </replica> <replica> <host>12.16.20.12</host> <port>9010</port> <user>default</user> <password>123456</password>
            <priority>1</priority> </replica> </shard> <!-- 分片2 --> <shard> <internal_replication>true</internal_replication> <weight>1</weight> <replica> <host>12.16.20.17</host> <port>9000</port> <user>default</user> <password>123456</password>
            <priority>1</priority>  </replica> <replica> <host>12.16.20.17</host> <port>9010</port> <user>default</user> <password>123456</password>
            <priority>1</priority> </replica> </shard> </test_cluster_1_repl> </ck_remote_servers>

这样,在设置好认证的数据库上也能正常的进行分片、复制的功能。

总结:

分片的好处:解决了单节点达到瓶颈的问题,和通过分布式表Distributed引擎能本身实现数据的路由和聚合。

分片分布式表的不足:Distributed表在写入时会在本地节点生成临时数据,会产生写放大,所以会对CPU及内存造成一些额外消耗,也会增加merge负担。

使用说明

一:ZooKeeper离线

不管是ClickHouse的副本还是分片都是通过ZooKeeper来进行协调的,如果ZooKeeper节点异常了,则会出现:

Code: 242. DB::Exception: Received from xxxx DB::Exception: Table is in readonly mode (zookeeper path: /xxx/xxx/xxx). 

表不能进行修改,能查询,变成了只读表。所以ZooKeeper线上也必须要开启集群模式。

二:副本离线

①:如果一个分片的节点出现异常宕机,如果有副本节点,则数据写入分布式表会直接写入到其副本节点,不影响数据库的可用性。当节点起来之后该节点会自动同步该数据。

②:如果一个分片的节点出现异常宕机,包括副本节点,则数据读取和写入分布式表只会对未异常的节点进行正常操作,异常节点报错。如果异常节点起来之后,会把报错期间的数据重新写入,保证数据的最终写入成功。

扩容&缩容

一:缩容

1:副本缩容

副本节点作为一个独立的节点,直接下线缩容即可。

2:分片缩容

按照上面的部署,把2分片缩容到1分片。具体的操作如下:

①:准备数据

-- 首先看看分片2上有多少个分区:
> select table,active,partition_id,name,database from system.parts where table='repl_abc';
确认有2个分区:202105202106

-- 查看分片1的本地表数据,保证缩容之后,数据写入的准确性
> select count(*) from repl_abc;
结果是17
-- 查看分片1的分布式表数据
>select count(*) from repl_abc_all; 结果是40

即需要把分片2的数据(23条)写入到分片1,再下线分片2。

②:导出数据,在分片1上执行:FETCH PARTITION

-- 备份分片2上的分区202105
clickhouse-client --port=9000 --password=123456 -m  --query  "ALTER TABLE testdb.repl_abc FETCH PARTITION 202105 FROM '/clickhouse/tables/2/repl_abc'"

-- 备份分片2上的分区202106
clickhouse-client --port=9000 --password=123456 -m  --query  "ALTER TABLE testdb.repl_abc FETCH PARTITION 202106 FROM '/clickhouse/tables/2/repl_abc'"

上面的导出文件会保存在data目录下的detached目录中,其中的FROM是zk_path的地址:即shard分区为2,表为repl_abc的数据。

③:导入数据,在分片1上执行:

-- 导入分区202105到表中
clickhouse-client --port=9000 --password=123456 -m  --query  "ALTER TABLE testdb.repl_abc ATTACH PARTITION 202105"

-- 导入分区202106到表中
clickhouse-client --port=9000 --password=123456 -m  --query  "ALTER TABLE testdb.repl_abc ATTACH PARTITION 202106"

④:验证数据

-- 查询分片1的本地表
select count(*) from repl_abc;
结果为40,说明数据迁移成功

⑤:删除源表&修改配置

验证没问题之后,删除分片2上的本地表,然后修改metrika.xml文件,删除分片2的信息,缩容配置持久化。最后通过下面SQL查询集群信息:

select * from system.clusters;

二:扩容

1. 副本扩容

 副本扩容比较简单,只需要在新实例上创建表,修改表结构中的{replica_name}{zk_path}不需要改变。数据会自动通过ZooKeeper来协调获取主信息,从主上下载数据到本地。

2. 分片扩容

增加分片节点,集群的分片数将增加,这样会让新的分片表和老的分片表的分片数量不一致。因为扩容需要用到新分片,所以需要先新增一个集群,让扩容的分片表可以使用到新的分片节点,然后将旧集群中的数据迁移至新集群,最后删除旧集群的数据与集群配置信息。具体的分片配置可以看上面的部署。大致的操作步骤:

-- 1. 修改配置,在原有的配置上,新增集群。
2. 让配置生效,重启所有节点。
3. 在新集群中新增分片表。
4. 使用分布式表迁移数据:
-- INSERT INTO TABLE db.tb_all SELECT * FROM db_1.tb_1_all
5. 迁移完成之后,删除旧的分片表。

三:配置模板 

1)实例:

  实例A  实例B  实例C  实例D 
IP 192.168.11.1 192.168.11.1 192.168.11.2 192.168.11.2
Port 9000 9000 9010 9010

2)配置:

config.xml 配置文件不需要修改,新增2个参数即可(参数优化暂时不考虑):

    <listen_host>0.0.0.0</listen_host>
...
...
    <include_from>/etc/clickhouse-server/config.d/metrika.xml</include_from>
    <zookeeper incl="zookeeper-server" optional="false" />
    <macros incl="macros" optional="true" />
    <remote_servers incl="ck_remote_servers" />

因为include了metrika.xml文件,所以只需要修改该文件即可。该文件包含了:ZooKeeper地址、集群信息、以及macros变量。

1分片1副本:类似一个主从

  • 主节点配置:
    <?xml version="1.0"?>
    <yandex>
     
        <zookeeper-server>
            <node index="1">
                <host>192.168.11.1</host>
                <port>2181</port>
            </node>
        </zookeeper-server>
     
        <macros>
            <replica>A</replica>
            <shard>1</shard>
        </macros>
     
        <ck_remote_servers>
            <cluster_1shard_1repl>
                <shard>
                    <weight>1</weight>
                    <replica>
                        <host>192.168.11.1</host>
                        <port>9000</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                    <replica>
                        <host>192.168.11.2</host>
                        <port>9000</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                </shard>
            </cluster_1shard_1repl>
        </ck_remote_servers>
     
     
    </yandex>
    View Code
  • 副本点配置:
    <?xml version="1.0"?>
    <yandex>
     
        <zookeeper-server>
            <node index="1">
                <host>192.168.11.1</host>
                <port>2181</port>
            </node>
        </zookeeper-server>
     
        <macros>
            <replica>B</replica>
            <shard>1</shard>
        </macros>
     
        <ck_remote_servers>
            <cluster_1shard_1repl>
                <shard>
                    <internal_replication>true</internal_replication>
                    <weight>1</weight>
                    <replica>
                        <host>192.168.11.1</host>
                        <port>9000</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                    <replica>
                        <host>192.168.11.2</host>
                        <port>9000</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                </shard>
            </cluster_1shard_1repl>
        </ck_remote_servers>
     
    </yandex>
    View Code

2分片0副本

  • 分片1配置:
    <?xml version="1.0"?>
    <yandex>
     
        <zookeeper-server>
            <node index="1">
                <host>192.168.11.1</host>
                <port>2181</port>
            </node>
        </zookeeper-server>
     
        <macros>
            <replica>A</replica>
            <shard>1</shard>
        </macros>
     
        <ck_remote_servers>
            <cluster_2shard_0repl>
                <shard>
                    <weight>1</weight>
                    <replica>
                        <host>192.168.11.1</host>
                        <port>9000</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                </shard>
                <shard>
                    <weight>1</weight>
                    <replica>
                        <host>192.168.11.2</host>
                        <port>9000</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                </shard>
            </cluster_2shard_0repl>
        </ck_remote_servers>
     
    </yandex>
    View Code
  • 分片1配置:
    <?xml version="1.0"?>
    <yandex>
     
        <zookeeper-server>
            <node index="1">
                <host>192.168.11.1</host>
                <port>2181</port>
            </node>
        </zookeeper-server>
     
        <macros>
            <replica>B</replica>
            <shard>2</shard>
        </macros>
     
        <ck_remote_servers>
            <cluster_2shard_0repl>
                <shard>
                    <weight>1</weight>
                    <replica>
                        <host>192.168.11.1</host>
                        <port>9000</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                </shard>
                <shard>
                    <weight>1</weight>
                    <replica>
                        <host>192.168.11.2</host>
                        <port>9000</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                </shard>
            </cluster_2shard_0repl>
        </ck_remote_servers>
     
    </yandex>
    View Code

2分片1副本

  • 分片1配置:
    <?xml version="1.0"?>
    <yandex>
     
        <zookeeper-server>
            <node index="1">
                <host>192.168.11.1</host>
                <port>2181</port>
            </node>
        </zookeeper-server>
     
        <macros>
            <replica>A</replica>
            <shard>1</shard>
        </macros>
     
        <ck_remote_servers>
            <cluster_2shard_1repl>
                <shard>
                    <internal_replication>true</internal_replication>
                    <weight>1</weight>
                    <replica>
                        <host>192.168.11.1</host>
                        <port>9000</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                    <replica>
                        <host>192.168.11.1</host>
                        <port>9010</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                </shard>
                <shard>
                    <internal_replication>true</internal_replication>
                    <weight>1</weight>
                    <replica>
                        <host>192.168.11.2</host>
                        <port>9000</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                    <replica>
                        <host>192.168.11.2</host>
                        <port>9010</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                </shard>
            </cluster_2shard_1repl>
        </ck_remote_servers>
     
    </yandex>
    View Code
  • 分片1副本配置:
    <?xml version="1.0"?>
    <yandex>
     
        <zookeeper-server>
            <node index="1">
                <host>192.168.11.1</host>
                <port>2181</port>
            </node>
        </zookeeper-server>
     
        <macros>
            <replica>AA</replica>
            <shard>1</shard>
        </macros>
     
        <ck_remote_servers>
            <cluster_2shard_1repl>
                <shard>
                    <internal_replication>true</internal_replication>
                    <weight>1</weight>
                    <replica>
                        <host>192.168.11.1</host>
                        <port>9000</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                    <replica>
                        <host>192.168.11.1</host>
                        <port>9010</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                </shard>
                <shard>
                    <internal_replication>true</internal_replication>
                    <weight>1</weight>
                    <replica>
                        <host>192.168.11.2</host>
                        <port>9000</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                    <replica>
                        <host>192.168.11.2</host>
                        <port>9010</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                </shard>
            </cluster_2shard_1repl>
        </ck_remote_servers>
     
    </yandex>
    View Code
  • 分片2配置:
    <?xml version="1.0"?>
    <yandex>
     
        <zookeeper-server>
            <node index="1">
                <host>192.168.11.1</host>
                <port>2181</port>
            </node>
        </zookeeper-server>
     
        <macros>
            <replica>B</replica>
            <shard>2</shard>
        </macros>
     
        <ck_remote_servers>
            <cluster_2shard_1repl>
                <shard>
                    <internal_replication>true</internal_replication>
                    <weight>1</weight>
                    <replica>
                        <host>192.168.11.1</host>
                        <port>9000</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                    <replica>
                        <host>192.168.11.1</host>
                        <port>9010</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                </shard>
                <shard>
                    <internal_replication>true</internal_replication>
                    <weight>1</weight>
                    <replica>
                        <host>192.168.11.2</host>
                        <port>9000</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                    <replica>
                        <host>192.168.11.2</host>
                        <port>9010</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                </shard>
            </cluster_2shard_1repl>
        </ck_remote_servers>
     
    </yandex>
    View Code
  • 分片2副本配置:
    <?xml version="1.0"?>
    <yandex>
     
        <zookeeper-server>
            <node index="1">
                <host>192.168.11.1</host>
                <port>2181</port>
            </node>
        </zookeeper-server>
     
        <macros>
            <replica>BB</replica>
            <shard>2</shard>
        </macros>
     
        <ck_remote_servers>
            <cluster_2shard_1repl>
                <shard>
                    <internal_replication>true</internal_replication>
                    <weight>1</weight>
                    <replica>
                        <host>192.168.11.1</host>
                        <port>9000</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                    <replica>
                        <host>192.168.11.1</host>
                        <port>9010</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                </shard>
                <shard>
                    <internal_replication>true</internal_replication>
                    <weight>1</weight>
                    <replica>
                        <host>192.168.11.2</host>
                        <port>9000</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                    <replica>
                        <host>192.168.11.2</host>
                        <port>9010</port>
                        <user>default</user>
                        <password>123456</password>
                    </replica>
                </shard>
            </cluster_2shard_1repl>
        </ck_remote_servers>
     
    </yandex>
    View Code

以上的配置区别:macros 参数定义

总结

ClickHouse是一个快速开源的列式数据库管理系统,在其高性能的前提下,通过副本表和分片来进一步保障了数据库的可用性和可靠性,关于更多的该方面的说明,后续会进一步说明和更新。

 

posted @ 2021-06-24 11:46  jyzhou  阅读(10377)  评论(4编辑  收藏  举报