各大中间件的集群搭建

最新推荐文章于 2024-07-24 20:38:08 发布
最新推荐文章于 2024-07-24 20:38:08 发布
阅读量666 收藏 3
点赞数
文章标签： linux docker 容器 服务器 kubernetes
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46126559/article/details/108262821
版权

文章目录

Docker创建集群

MySQL集群

Mysql的主从复制

master
# 主 Mysql
docker run -p 3307:3306 --name mysql \ 
-v /docker+mount/mysql/log:/var/log/mysql \
-v /docker+mount/mysql/data:/var/lib/mysql \
-v /docker+mount/mysql/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=root \ 
-d mysql:5.7

# 修改master基本配置

vi /docker+mount/mysql/conf/my.cnf
 
# 将内容复制进去 修改mysql编码

[client]
default-character-set=utf8
  
[mysql]
default-character-set=utf8
  
[mysqld]
init_connect='SET collation_connection = utf8_unicode_ci'
init_connect='SET NAMES utf8'
character-set-server=utf8
collation-server=utf8_unicode_ci
skip-character-set-client-handshake
skip-name-resolve

# 添加master主从复制部分配置
# 唯一ID
server_id=1
# 二进制日志名
log-bin=mysql-bin
# 是否只读 0 否
read-only=0
# 对那些数据库生产日志
binlog-do-db=gulimall_ums

#哪些表不生成日志
replicate-ignore-db=mysql
replicate-ignore-db=sys
replicate-ignore-db=information_schema
replicate-ignore-db=performance_shema



# 重启mysql
docker restart mysql
Slave从Mysql
# 从 Mysql
docker run -p 3317:3306 --name mysql \ 
-v /docker+mount/mysql/log:/var/log/mysql \
-v /docker+mount/mysql/data:/var/lib/mysql \
-v /docker+mount/mysql/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=root \ 
-d mysql:5.7

# 修改master基本配置

vi /docker+mount/mysql/conf/my.cnf
 
# 将内容复制进去 修改mysql编码

[client]
default-character-set=utf8
  
[mysql]
default-character-set=utf8
  
[mysqld]
init_connect='SET collation_connection = utf8_unicode_ci'
init_connect='SET NAMES utf8'
character-set-server=utf8
collation-server=utf8_unicode_ci
skip-character-set-client-handshake
skip-name-resolve

#添加master主从复制部分配置
# 唯一ID
server_id=2
# 二进制日志名
log-bin=mysql-bin
# 是否只读 0 否
read-only=1

# 需要同步主mysql的哪些数据库
binlog-do-db=gulimall_ums

#哪些表不生成日志
replicate-ignore-db=mysql
replicate-ignore-db=sys
replicate-ignore-db=information_schema
replicate-ignore-db=performance_shema



# 重启mysql
docker restart mysql

设置

为master授权用户来同步他的数据
# 在主mysql授权一个账号用来专门复制日志的
GRANT REPLICATION SLAVE ON *.* to 'backup'@'%' IDENTIFIED BY '123456';
# 查看用户
show grants for 'backup'@'%'
# 删除用户
drop user 'backup'@'%'

# 查看master状态
show master status;

# 可以授权root可以远程访问（主从无关，为了方便我们远程连接mysql）
grant all privileges on *.* to 'root'@'%' identified by 'root' with grant option;
Slave从mysql设置
# 设置从master获取日志
	# master_host主机地址
	# master_user用户名 master_password 密码 master授权的用户
	# master_log_file 二进制日志的名字，可以在主节点通过show master status;查询
	# master_log_pos 日志从什么位置复制
	# master_port mysql端口
change master to master_host='192.168.56.10',master_user='backup',master_password='123456',master_log_file='mysql-bin.000001',master_log_pos=0,master_port=3307;

# 启动从mysql同步
start slave;
# 停止同步
stop slave;
# 查看从mysql状态
show slave status;

利用ShardingSpher做代理

ShardingSphere做分库分表

二进制下载

Docker下载

⚠️如果后端连接MySQL数据库，需要下载MySQL Connector/J， 解压缩后，将mysql-connector-java-5.1.47.jar拷贝到${sharding-proxy}\lib目录。

配置

Sharding-Proxy支持多逻辑数据源，每个以config-前缀命名的yaml配置文件，即为一个逻辑数据源

配置文件说明

全局配置server.yaml

# 认证信息
authentication:
  users: # 配置用户，用户名叫root密码叫root
    root:
      password: root
    sharding: # 配置sharding用户，账号sharding，密码sharding
      password: sharding 
      authorizedSchemas: sharding_db # 配置权限sharding用户只能访问sharding_db数据库
props:
  executor.size: 16  # 线程数大小默认为无限
  sql.show: false # 是否在控制台打印sql

分库分表配置config-sharding.yaml

# sharding-Proxy映射的虚拟数据库，我们最后应该连的是这个数据库，而不应该连接真实数据库
schemaName: sharding_db
# 指定数据源
# 应该做两主，四从的方式，一个主维护一个数据库
dataSources:
  ds_0: # 第一个数据源
    url: jdbc:mysql://127.0.0.1:3306/demo_ds_0?serverTimezone=UTC&useSSL=false
    username: root
    password: root 
    connectionTimeoutMilliseconds: 30000 # 连接超时时间
    idleTimeoutMilliseconds: 60000 # 空闲回收的时间
    maxLifetimeMilliseconds: 1800000 # 最大生命时间
    maxPoolSize: 50 # 连接池大小
  ds_1: # 第二个数据源 
    url: jdbc:mysql://127.0.0.1:3306/demo_ds_1?serverTimezone=UTC&useSSL=false
    username: root
    password: root
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 50
# 分库分表规则
shardingRule:
  tables:
    t_order: # 表名
    	# 分表ds_0->|t_order_0、t_order_1|  和  ds_1->|t_order_0、t_order_1|
      actualDataNodes: ds_${0..1}.t_order_${0..1} 
      tableStrategy: # 分表策略
        inline: # 列
          shardingColumn: order_id # 根据订单ID进行分表
          algorithmExpression: t_order_${order_id % 2} #分表算法对ID对2求余
      keyGenerator: # 主键生成利用雪花算法
        type: SNOWFLAKE
        column: order_id
    t_order_item: # 订单项表
      actualDataNodes: ds_${0..1}.t_order_item_${0..1}
      tableStrategy: # 分表策略
        inline:
          shardingColumn: order_id # 根据订单ID进行分表
          algorithmExpression: t_order_item_${order_id % 2}
      keyGenerator: # 主键生成利用雪花算法
        type: SNOWFLAKE
        column: order_item_id
  bindingTables: # 绑定表（好处不用去做跨库join连查，不用做笛卡尔积）
    - t_order,t_order_item
  defaultDatabaseStrategy: # 数据分库策略
    inline:
      shardingColumn: user_id
      algorithmExpression: ds_${user_id % 2}
  defaultTableStrategy: # 分表策略
    none:

读写分离config-master_slave.yaml

这里的主从按照上面的主从先搭建好

schemaName: sharding_master_slave_db

dataSources:
  ds0: # 主数据源
    url: jdbc:mysql://127.0.0.1:3306/demo_ds_0?serverTimezone=UTC&useSSL=false
    username: root
    password: root
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 65
  ds0_slave0: # 从数据源
    url: jdbc:mysql://127.0.0.1:3307/demo_ds_0_1?serverTimezone=UTC&useSSL=false
    username: root
    password: root
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 65
  ds0_slave1: # 从数据源二
    url: jdbc:mysql://127.0.0.1:3307/demo_ds_0_1?serverTimezone=UTC&useSSL=false
    username: root
    password: root
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 65
  ds1: # 主数据源
    url: jdbc:mysql://127.0.0.1:3306/demo_ds_1?serverTimezone=UTC&useSSL=false
    username: root
    password: 
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 65
  ds1_slave0: # 从数据源
    url: jdbc:mysql://127.0.0.1:3307/demo_ds_1_0?serverTimezone=UTC&useSSL=false
    username: root
    password: 
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 65
  ds1_slave1: # 从数据源二
    url: jdbc:mysql://127.0.0.1:3307/demo_ds_1_1?serverTimezone=UTC&useSSL=false
    username: root
    password: 
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 65
 # 配置主从规则
  masterSlaveRules:
    ms_ds0:
      masterDataSourceName: ds0 # 主数据源的名字
      slaveDataSourceNames: # 从数据源名
        - ds0_slave0
        - ds0_slave1
      loadBalanceAlgorithmType: ROUND_ROBIN #负载均衡策略，轮询
    ms_ds1:
      masterDataSourceName: ds1 # 主数据源的名字
      slaveDataSourceNames: # 从数据源名
        - ds1_slave0
        - ds1_slave1
      loadBalanceAlgorithmType: ROUND_ROBIN # 负载均衡策略，轮询

进入bin启动

# 使用默认配置项
sh start.sh
# 配置端口
sh start.sh 3333

数据库连接3333端口的sharding-Proxy映射的虚拟数据库sharding_db，在server.config配置了用户名

redis-cluster做redis集群

简介

官网

官方推荐使用6个实例，其中三个为主节点，3个为从节点。一旦有主节点发生故障的时候，Redis Cluster可以选举出对应的从节点成为新的主节点，继续对完服务，从而保证服务的高可用性。那么对于客户端来说,知道知道对应的key是要路由到哪一个节点呢? Redis Cluster把所有的数据划分为16384个不同的槽位,可以根据机器的性能把不同的槽位分配给不同的 Redis实例,对于 Redis实例来说,他们只会存储部分的Reds数据,当然,槽的数据是可以迁移的,不同的实例之间,可以通过一定的协议,进行数据迁移。

Reds集群的功能限制;Reds集群相对单机在功能上存在一些限制,需要开发人员提前了解,在使用时做好规避。 JAVA CRO16校验算法

  • key批量操作，支持有限
    • 类似mset、mget操作,目前只支持对具有相同sot值的key执行批量操作。对于映射为不同sot值的key由于执行mget、mget等操作可能存在于多个节点上,因此不被支持。
  • key事务操作支持有限
    • 只支持多key在同一节点上的事务操作,当多个key分布在不同的节点上时无法使用事务功能。
  • key作为数据分区的最小粒度
  • 不能将一个大的键值对象如hash、list等映射到不同的节点。
  • 不支持多数据库空间
    • 单机下的 Redis可以支持16个数据库(db0~db15),集群模式下只能使用个数据库空间,即db0。
  • 复制结构只支持一层
    • 从节点只能复制主节点,不支持嵌套树状复制结构。
  • 命令大多会重定向,耗时多

虽然有很多弊端，但是依旧是现在主流的集群方式

脚本快速创建Docker镜像

for port in $(seq 7001 7006); \
do \
mkdir -p /docker+mount/redis/node-${port}/conf
touch /docker+mount/redis/node-${port}/conf/redis.conf
cat <<EOF>> /docker+mount/redis/node-${port}/conf/redis.conf
port ${port}
cluster-enabled yes
cluster-config-file nodes-6379.conf
cluster-node-timeout 5000
cluster-announce-ip xx.xx.xx.xx
cluster-announce-port ${port}
cluster-announce-bus-port 1${port}
appendonly yes
EOF
docker run -p ${port}:${port} -p 1${port}:1${port} --name redis-${port} --restart always \
-v /docker+mount/redis/node-${port}/data:/data \
-v /docker+mount/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \
-d redis redis-server /etc/redis/redis.conf; \
done

# ---------------------------------------
cluster-enabled yes 开启集群模式
cluster-config-file nodes-6379.conf  群集配置文件由redis自己管理
cluster-announce-ip 集群的ip
cluster-announce-port 集群的端口
cluster-announce-bus-port 
总线端口。 然后将信息发布在总线数据包的标题中，以便其他节点将能够正确映射该节点的地址发布信息。

批量操作

# 批量停止
docker stop $(docker ps -a | grep redis-700 | awk '{print$1}')
# 批量删除
docker rm -f $(docker ps -a | grep redis-700 | awk '{print $1}')

建立集群redis

# 随便选一个master节点进入redis容器
docker exec -it redis-7001 bash
# 创建集群 cluster-replicas 整个集群的副本数量，每一个主节点必须要有一个副本节点，会随机挑主节点和副节点
redis-cli --cluster create xx.xx.xx.xx:7001 xx.xx.xx.xx:7002 xx.xx.xx.xx:7003 xx.xx.xx.xx:7004 xx.xx.xx.xx:7005 xx.xx.xx.xx:7006 --cluster-replicas 1

执行结果

>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460 # 第一个主节点的槽位范围 0 - 5460
Master[1] -> Slots 5461 - 10922 # 第二个主节点的槽位范围 5461 - 10922
Master[2] -> Slots 10923 - 16383 # 第三个主节点的槽位范围 10923 - 16383
Adding replica xx.xx.xx.xx:7005 to xx.xx.xx.xx:7001
Adding replica xx.xx.xx.xx:7006 to xx.xx.xx.xx:7002
Adding replica xx.xx.xx.xx:7004 to xx.xx.xx.xx:7003
>>> Trying to optimize slaves allocation for anti-affinity
[WARNING] Some slaves are in the same host as their master
M: e326bc7885597a11275bcbfc78277bb804d41bc2 xx.xx.xx.xx:7001
   slots:[0-5460] (5461 slots) master # master节点
M: 9c110b4c3e50ec3372f05accc96d64146b9b5ec1 xx.xx.xx.xx:7002
   slots:[5461-10922] (5462 slots) master # master节点
M: d30a0268e927fe8a3bb350e9ffc891e0d6db3122 xx.xx.xx.xx:7003
   slots:[10923-16383] (5461 slots) master # master节点
S: a0cf2379da66cd5283e6a6fc1f42e638042d4970 xx.xx.xx.xx:7004
   replicates d30a0268e927fe8a3bb350e9ffc891e0d6db3122 # Slave节点对应的master节点的ID=7003
S: a861bd441bdb6c958e32abbb802bbd9e4ac2d2a7 xx.xx.xx.xx:7005
   replicates e326bc7885597a11275bcbfc78277bb804d41bc2# Slave节点是7001的副本
S: a5fce6dd21a5260329caa7ec3aa50e46a294e571 xx.xx.xx.xx:7006
   replicates 9c110b4c3e50ec3372f05accc96d64146b9b5ec1 # Slave节点是7002的副本
Can I set the above configuration? (type 'yes' to accept): # 是否接受以上配置

通过客户端连接集群

redis-cli -c -h xx.xx.xx.xx -p 7001

# 查看集群状态
cluster info
# 查看节点信息
cluster nodes

如果主节点宕机了，从节点会自动顶上来变成主节点

ElasticSearch集群

查看集群检查状况

Elasticsearch的集群监控信息中包含了许多的统计数据,其中最为重要的一项就是集群健康,它在 status字段中展示为 green、yelw或者red。

GET /_cluster/health

status字段指示着当前集群在总体上是否工作正常。它的三种颜色含义如下

  • green:所有的主分片和副本分片都正常运行
  • yellow:所有的主分片都正常运行,但不是所有的副本分片都正常运行
  • red:有主分片没能正常运行
分片
  • 一个分片是一个底层的工作单元,它仅保存了全部数据中的一部分。我们的文档被存储和索引到分片内,但是应用程序是直接与索引而不是与分片进行交互。分片就认为是一个数据区
  • 一个分片可以是主分片或者副本分片。索引内任意一个文档都归属于一个主分片,所以主分片的数目决定着索引能够保存的最大数据量。
  • 在索引建立的时候就已经确定了主分片数,但是副本分片数可以随时修改。
  • 让我们在包含一个空节点的集群内创建名为 blogs的索引。索引在默认情况下会被分配5个主分片,但是为了演示目的,我们将分配3个主分片和一份副本(每个主分片拥有一个副本分片)
PUT /blogs{
	"settings":{
	"number_of_shards":3, #分片为3
	"number_of_replicas":1 #副本为1
	}
}

搭建

前提

为了方式jvm启动es的时候报错先进行一下设置

max virtual memory areas vm.max_map_count [65530] is too low, increase to at least [262144]

问题翻译过来就是：elasticsearch用户拥有的内存权限太小，至少需要262144

# 测试临时修改
sysctl -w vm.max_map_count=262144
# 查看结果
sysctl -a | grep vm.max_map_count

永久设置

echo vm.max_map_count=262144 >> /etc/sysctl.conf
# 查看结果
sysctl -p

Docker网络模拟不同es在不同的ip

创建docker网络，来指定每个es不同的ip地址

# 查看docker默认网络
docker network ls
# 创建网络 bridge以桥接方式创建，subnet网段，gateway指定网关，mynet网络名
docker network create --driver bridge --subnet=10.1.9.0/24 --gateway=10.1.9.1 mynet
# 查看网络信息
docker network inspect mynet
# 移除指定的网络
docker network rm mynet

# 以后用这种方式指定ip
 --network=mynet --ip 10.1.9.x
3-Master节点创建
脚本快速创建
for port in $(seq 1 3); \
do \
mkdir -p /docker+mount/elasticsearch/master-${port}/config
mkdir -p /docker+mount/elasticsearch/master-${port}/data
chmod -R 777 /docker+mount/elasticsearch/master-${port}
cat <<EOF>> /docker+mount/elasticsearch/master-${port}/config/elasticsearch.yml
cluster.name: my-es # 集群名，同一个集群该值必须设置成相同的
node.name: es-master-${port} # 该节点名
node.master: true # 该节点有机会成为master节点
node.data: false # 该节点可以存储数据
network.host: 0.0.0.0
http.host: 0.0.0.0 # 开启远程访问
http.port: 920${port}
transport.tcp.port: 930${port}
# discovery.zen.minimum_master_nodes: 2
# 设置这个参数保证集群中的节点可以知道其它N个有master的资格节点，官方推荐(N/2)+1，防止脑裂
discovery.zen.ping_timeout: 10s # 设置集群中自动发现其他节点时ping连接的超时时间
discovery.seed_hosts: ["10.1.9.21:9301","10.1.9.22:9302","10.1.9.23:9303"]
# 设置集群中的master节点的初始列表，可以通过这些节点来自动发现其他新加入集群的家的，es7的新增配置
cluster.initial_master_nodes: ["10.1.9.21"] # 新集群初始时的候选主节点，es7的新增配置
EOF
docker run --name elasticsearch-node-${port} \
-p 920${port}:920${port} -p 930${port}:930${port} \
--network=mynet --ip 10.1.9.2${port} \
-e ES_JAVA_OPTS="-Xms300m -Xmx300m" \
-v /docker+mount/elasticsearch/master-${port}/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /docker+mount/elasticsearch/master-${port}/data:/usr/share/elasticsearch/data \
-v /docker+mount/elasticsearch/master-${port}/plugins:/usr/share/elasticsearch/plugins \
-d elasticsearch:7.8.1
done
3-node节点创建
for port in $(seq 4 6); \
do \
mkdir -p /docker+mount/elasticsearch/master-${port}/config
mkdir -p /docker+mount/elasticsearch/master-${port}/data
chmod -R 777 /docker+mount/elasticsearch/master-${port}
cat <<EOF>> /docker+mount/elasticsearch/master-${port}/config/elasticsearch.yml
cluster.name: my-es # 集群名，同一个集群该值必须设置成相同的
node.name: es-master-${port} # 该节点名
node.master: false # 该节点有机会成为master节点
node.data: true # 该节点可以存储数据
network.host: 0.0.0.0
http.host: 0.0.0.0 # 开启远程访问
http.port: 920${port}
transport.tcp.port: 930${port}
# discovery.zen.minimum_master_nodes: 2
# 设置这个参数保证集群中的节点可以知道其它N个有master的资格节点，官方推荐(N/2)+1，防止脑裂
discovery.zen.ping_timeout: 10s # 设置集群中自动发现其他节点时ping连接的超时时间
discovery.seed_hosts: ["10.1.9.21:9301","10.1.9.22:9302","10.1.9.23:9303"]
# 设置集群中的master节点的初始列表，可以通过这些节点来自动发现其他新加入集群的家的，es7的新增配置
cluster.initial_master_nodes: ["10.1.9.21"] # 新集群初始时的候选主节点，es7的新增配置
EOF
docker run --name elasticsearch-node-${port} \
-p 920${port}:920${port} -p 930${port}:930${port} \
--network=mynet --ip 10.1.9.2${port} \
-e ES_JAVA_OPTS="-Xms300m -Xmx300m" \
-v /docker+mount/elasticsearch/master-${port}/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /docker+mount/elasticsearch/master-${port}/data:/usr/share/elasticsearch/data \
-v /docker+mount/elasticsearch/master-${port}/plugins:/usr/share/elasticsearch/plugins \
-d elasticsearch:7.8.1
done

批量操作

# 批量停止
docker stop $(docker ps -a | grep elasticsearch-node- | awk '{print$1}')
# 批量删除
docker rm -f $(docker ps -a | grep elasticsearch-node- | awk '{print $1}')

# 查看节点状态
GET _cat/nodes
# 查看自己的健康信息
GET /_cluster/health
# 查看集群的状态
GET /_cluster/stats?pretty
# 查看集群的健康信息
GET /_cluster/health?pretty

RabbitMQ的集群

mkdir /docker+mount/rabbitmq
cd rabbitmq/
mkdir rabbitmq01 rabbitmq02 rabbitmq03

启动三个容器

第一个

docker run -d --hostname rabbitmq01 --name rabbitmq01 -v /docker+mount/rabbitmq/rabbitmq01:/var/lib/rabbitmq -p 5673:5672 -p 15673:15672 -e RABBITMQ_ERLANG_COOKIE='chnllc' rabbitmq:management

第二个

docker run -d --hostname rabbitmq02 --name rabbitmq02 -v /docker+mount/rabbitmq/rabbitmq02:/var/lib/rabbitmq -p 5674:5672 -p 15674:15672 -e RABBITMQ_ERLANG_COOKIE='chnllc' --link rabbitmq01:rabbitmq01 rabbitmq:management

# 多了个--link rabbitmq01:rabbitmq01，意思就是告诉他可以访问rabbitmq01然后起了个别名还叫rabbitmq01

第三个

docker run -d --hostname rabbitmq03 --name rabbitmq03 -v /docker+mount/rabbitmq/rabbitmq03:/var/lib/rabbitmq -p 5675:5672 -p 15675:15672 -e RABBITMQ_ERLANG_COOKIE='chnllc' --link rabbitmq01:rabbitmq01 --link rabbitmq02:rabbitmq02 rabbitmq:management

批量操作

# 批量停止
docker stop $(docker ps -a | grep rabbitmq0 | awk '{print$1}')
# 批量删除
docker rm -f $(docker ps -a | grep rabbitmq0 | awk '{print $1}')

配置集群

设置节点1
# 进入容器
docker exec -it rabbitmq01 /bin/bash
# 使用客户端暂停app
rabbitmqctl stop_app
# 初始化
rabbitmqctl reset
# 启动
rabbitmqctl start_app
设置节点2
docker exec -it rabbitmq02 /bin/bash
rabbitmqctl stop_app
rabbitmqctl reset
rabbitmqctl join_cluster --ram rabbit@rabbitmq01
rabbitmqctl start_app
exit

参数“–ram”表示设置为内存节点，忽略次参数默认为磁盘节点。

设置节点3，加入到集群：
docker exec -it rabbitmq03 /bin/bash
rabbitmqctl stop_app
rabbitmqctl reset
rabbitmqctl join_cluster --ram rabbit@rabbitmq01
rabbitmqctl start_app
exit

在普通集群的模式上升级为镜像集群解决单点故障

添加策略

官方文档

rabbitmqctl set_policy [-p <vhost>] [--priority <priority>] [--apply-to <apply-to>] <name> <pattern> <definition>
参数说明
-p vhost对指定的vhost进行设置
namepolicy的名称
patternqueue的匹配模式（正则表达式）
definition镜像定义：包含三个部分ha-mode,ha-params,ha-sync-mode
ha-mode:指明镜像队列的模式。all: 集群中所有节点进行镜像；exactly:在指定个数节点进行镜像，节点个数由ha-params指定;nodes:在指定节点进行镜像，节点名称由ha-params指定
ha-params: ha-mode模式需要用到的参数
ha-sync-mode: 消息的同步方式（automatic,manual）
prioritypolicy的优先级，当有多个策略指定同一个队列时，优先级高的策略生效
添加策略实例
docker exec -it rabbitmq01 bash

rabbitmqctl set_policy -p / ha '^' '{"ha-mode":"all","ha-sync-mode":"automatic"}'
# 策略模式all 即复制到所以节点，包含新增节点，策略正则表达式为“^”表示匹配所以

# 查看vhost/下面的所以策略
rabbitmqctl list_policies -p /

k8s搭建集群

等待跟新

卢立聪
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Kafka集群搭建
weixin_43339889的博客
01-01 437
Kafka集群搭建
各种中间件的集群搭建
m0_50725078的博客
10-24 864
中间件集群搭建
中间件系列——EMQX 的集群搭建
ITLWJ的博客
04-06 1万+
上节我们介绍了 EMQX 的快速上手，但是如果想要将 EMQX 投入生产环境，我们还要考虑非常多的东西。这节我们就来让 EMQX 高可用，也就是集群搭建和负载均衡配置
Redis集群搭建及原理详解
core815的专栏
06-18 1397
在redis3.0以前的版本要实现集群一般是借助哨兵sentinel工具来监控master节点的状态，如果master节点异常，则会做主从切换，将某一台slave作为master，哨兵的配置略微复杂，并且性能和高可用性等各方面表现一般，特别是在主从切换的瞬间存在访问瞬断的情况，而且哨兵模式只有一个主节点对外提供服务，没法支持很高的并发，且单个主节点内存也不宜设置得过大，否则会导致持久化文件过大，影响数据恢复或主从同步的效率。
中间件集群部署
Spider_Man06的博客
01-06 1588
一、安装jdk1.8 先卸载系统自带jdk #查找系统自带jdk rpm -qa | grep java #卸载jdk yum -y remove java* #卸载完成 解压安装jdk tar -zxvf jdk-8u221-linux-x64.tar.gz #删除tar包 rm -rf jdk-8u221-linux-x64.tar.gz 配置系统环境变量 vim /etc/profile #在尾部添加环境变量 export JAVA_HOME=/data/jdk1.8.0_221 ex
redis集群搭建（非常详细，适合新手）
热门推荐
橙子君的博客
10-01 36万+
redis集群搭建 在开始redis集群搭建之前，我们先简单回顾一下redis单机版的搭建过程 下载redis压缩包，然后解压压缩文件； 进入到解压缩后的redis文件目录（此时可以看到Makefile文件），编译redis源文件； 把编译好的redis源文件安装到/usr/local/redis目录下，如果/local目录下没有redis目录，会自动新建redis目录； 进入/usr/loca...
[docker-compose中间件集群系列] - 4 kafka的作用、原理以及集群搭建
HoZanDung的博客
03-31 1230
kafka的作用、原理以及集群搭建
Minio分布式集群搭建
qq_34861017的博客
11-22 1590
Minio实战，Minio集群搭建，Minio集群水平扩容（对等扩容和联邦扩容）
中间件 | Redis - [集群]
ZEUS00456的专栏
09-24 610
中间件 | Redis - [集群]
环境搭建大集合（Docker搭建各种中间件）
chandfy的博客
07-21 1033
1.docker部署Mysql8.0 docker部署Redis6 docker部署nacos2.x+持久化Mysql8 docker部署RabbitMQ
达梦读写分离集群搭建文档
06-19
在构建大型数据库系统时，...达梦数据库的读写分离集群搭建涉及到多个环节，每个环节都需要细致的操作和精心的规划。通过合理的配置和维护，可以构建出稳定、高效的数据库集群，为大规模的数据处理提供强有力的支持。
redis集群搭建手册.docx
02-18
**Redis集群搭建手册** Redis，全称Remote Dictionary Server，是一种高性能的键值对数据库，以其丰富的数据类型、高效的内存管理以及支持持久化等特性，在分布式系统中被广泛应用于缓存、消息中间件以及数据存储等...
Redis集群搭建资料大整合
01-18
在本资料包中，您将找到关于Redis集群搭建的详细步骤和教程。 首先，Redis集群的基本概念是将数据分散到多个节点上，每个节点存储一部分数据。它采用无中心架构，每个节点都可以接收客户端的请求，并通过哈希槽...
Kafka集群搭建.pdf
07-16
Kafka学习 小白必看 以免走错路 本人也是学习Java的 小白可以关注一下 以后在学习路上可以互相帮助
kafka集群搭建文档
05-31
本篇文档将详细介绍如何在Linux环境中搭建Kafka集群，同时结合Hadoop和Spark的分布式安装，构建一个完整的数据处理平台。 首先，搭建Kafka集群的基础条件包括： 1. 至少一台Linux服务器，但为了高可用性，推荐多台...
Linux：基础命令学习
qq_55038440的博客
07-20 1459
实例：-F根据文件类型在列出的文件名称后加一符号。实例： -R 递归显示目录中的所有文件和子目录。. 开头的隐藏文件也会列出。可执行文件则加 "*"，用于显示目录文件信息。
LINUX之MMC子系统分析
gy794627991的博客
07-23 1081
MMC子系统从协议到源码分析
【Linux】条件变量及生产者消费者模型
2301_78636079的博客
07-23 1107
条件变量与生产消费者模型
RK3568 Linux 平台开发系列讲解（内核入门篇）：从内核的角度看外设芯片的驱动
最新发布
小灰灰的博客
07-24 766
从内核的角度看外设芯片的驱动，需要理解驱动的基本结构、设备树的使用以及内核的 I/O 机制。通过掌握这些知识，您将能够有效地开发和管理外设驱动程序。希望本文为您在 RK3568 平台的驱动开发提供了有价值的参考，欢迎继续关注后续的内容！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值