方案缺陷-HAProxy + Sentinel +redis

已于 2024-10-29 17:39:55 修改
阅读量1.4k 收藏 5
点赞数
分类专栏： redis 文章标签： redis spring
于 2021-07-21 15:41:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuxiaohua/article/details/118968125
版权

背景

接手了一个系统，该使用了HAProxy + Sentinel +redis方案，该方案在redis发生主从切换后，因为应用层启用了连接池，老连接连的仍然是redis的“老主节点”。当应用层获取到这些老连接进行写操作的时候，会抛出异常。
org.springframework.data.redis.RedisSystemException: Error in execution; nested exception is io.lettuce.core.RedisCommandExecutionException: READONLY You can’t write against a read only replica.

该方案如下

在这里插入图片描述

redis使用使用哨兵模式进行组网，哨兵负责主节点的故障转移。
HAProxy作为Redis集群的代理(HAProxy工作在TCP层)，屏蔽底层redis的组网细节，对上层应用来看就是单节点的redis。
从下面的配置可以看到，每次应用层创建新连接时，HAproxy会轮训所有节点，探测到主节点后，代应用层发起连接。

defaults
  mode tcp

frontend redis
bind *:16382 name redis
  default_backend redis
  
backend redis
option tcp-check
tcp-check connect
tcp-check send AUTH\ xxxxxxxxx\r\n
tcp-check expect string +OK
tcp-check send PING\r\n
tcp-check expect string +PONG
tcp-check send info\ replication\r\n
tcp-check expect string role:master
tcp-check send QUIT\r\n
tcp-check expect string +OK
server redis_6382_1 xx.xx.xx.xx:6382 check inter 1s
server redis_6382_2 xx.xx.xx.xx:6382 check inter 1s
server redis_6382_3 xx.xx.xx.xx:6382 check inter 1s
server redis_6382_4 xx.xx.xx.xx:6382 check inter 1s

该方案的问题

不像http协议连接被设计成无状态。redis的协议较简单，且是有状态的。在执行操作前得先认证（认证是可选的），认证完了后，可以长期保持连接，进行交互，除非服务端主动断开连接(不深究，可能服务端设置了tcp参数，长期无响应的连接会被服务端关闭)。
为了减少创建连接带来的消耗，jedis设计了连接池，创建出来的连接只要能够正常访问，连接每次用完后会被回收到连接池中进行复用。
哨兵模式通过心跳检测redis主节点是否发生故障，然后进行故障转移（主从切换）。发生主从切换时，并不一定是redis挂了，有时候可能redis的负债过重，无法及时响应哨兵的PING命令。
此时虽然哨兵认为redis挂了，但应用层之前建立的连接还是能够正常连通的，jedis认为该连接仍然可用回收的时候不会进行销毁。不过老连接进行写操作时会导致异常，因为老连接连的是“老主节点”，发生主从切换后，“老主节点”变成从节点且只读。

为什么主从切换后jedis没有销毁老的连接

一般连接池都会对连接进行有效性校验，防止应用层拿到了不可用的连接。
该校验可以在连接回收的时候，也可以在应用层获取连接前。
开启连接池后，获取连接的代码，可以追溯到redis.clients.jedis.JedisPool#getResource

  @Override
  public Jedis getResource() {
    Jedis jedis = super.getResource();
    jedis.setDataSource(this);
    return jedis;
  }

跟踪super.getResource（）最终可以定位到org.apache.commons.pool2.impl.GenericObjectPool#borrowObject()

    public T borrowObject(long borrowMaxWaitMillis) throws Exception {
         ... ...
         省略无关代码
                
                # 可以看到对连接进行有效性校验是个可选项，配置后开会开启
                if (p != null && this.getTestOnBorrow()) {
                    boolean validate = false;
                    Throwable validationThrowable = null;

                    try {
                        validate = this.factory.validateObject(p);
                    }
                ... ...
                }
                ... ...
    }

factory.validateObject()追溯到redis.clients.jedis.JedisFactory#validateObject
可以看到仅仅只是通过PONG命令探测连接是否连通，所以即使发生了主从切换，从jedis的角度来看连接仍然是有效的，这些连接不会被主动销毁。

  public boolean validateObject(PooledObject<Jedis> pooledJedis) {
    final BinaryJedis jedis = pooledJedis.getObject();
    try {
      HostAndPort hostAndPort = this.hostAndPort.get();

      String connectionHost = jedis.getClient().getHost();
      int connectionPort = jedis.getClient().getPort();

      return hostAndPort.getHost().equals(connectionHost)
          && hostAndPort.getPort() == connectionPort && jedis.isConnected()
          && jedis.ping().equals("PONG");
    } catch (final Exception e) {
      return false;
    }
  }

问题复现

人工模拟哨兵的主从切换。

  1. 去掉Sentinel的监控（kill掉Sentinel进程）
  2. 找一个从节点，执行slaveof no one
  3. 剩余的节点执行，slaveof 新节点

方案选型

Jedis目前支持哨兵模式了，不过我们系统无法容忍长时间的主备变更信息延时通知到应用层，因此需要审视jedis的源码，确认集群发生主从切换后，是否能够快速通知到应用层并清理老连接。
测试代码如下：

	public static void main(String[] args) throws JsonProcessingException {
		// SpringApplication.run(DemoApplication.class, args);
		RedisTemplate<String,String> redisTemplate = new RedisTemplate();
		Set<String> setRedisNode = new HashSet<>();
		# 哨兵的IP:Port
		setRedisNode.add("xx.xx.xx.xx:26379");
		setRedisNode.add("xx.xx.xx.xx:26381");
		setRedisNode.add("xx.xx.xx.xx:26382");
		setRedisNode.add("xx.xx.xx.xx:26383");
		# "mymaster" 对应sentinel.conf中"sentinel monitor mymaster xx.xx.xx.xx 6383 2"
		# 一组哨兵是可以同时监控N组redis集群的，"mymaster"代表的某一组集群主节点的别名,
		# RedisTemplate只能操作单组集群，所以RedisSentinelConfiguration需要指定"mymaster"
		RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration("mymaster", setRedisNode);
		JedisPoolConfig config = new JedisPoolConfig();
		JedisConnectionFactory connectionFactory = new JedisConnectionFactory(redisSentinelConfiguration,config);
		connectionFactory.afterPropertiesSet();
		redisTemplate.setConnectionFactory(connectionFactory);
		redisTemplate.afterPropertiesSet();
		redisTemplate.opsForValue().set("aaa","bbb");
		while(true){}
	}

跟踪调用链，发现JedisConnectionFactory (afterPropertiesSet方法)在初始化的过程中会做以下动作：

  1. 向哨兵进程查询当前主节点
  2. 使用异步线程监听哨兵发过来的事件，如果是主从切换事件，则立马更新主节点，并清理连接池。
 # 代码有删减
  public JedisSentinelPool(String masterName, Set<HostAndPort> sentinels,
      final GenericObjectPoolConfig<Jedis> poolConfig, final JedisFactory factory,
      final JedisClientConfig sentinelClientConfig) {
    # 查询当前主节点
    HostAndPort master = initSentinels(sentinels, masterName);
    # 设置当前主节点
    initMaster(master);
  }

JedisSentinelPool#initSentinels方法详解，代码有删减

  private HostAndPort initSentinels(Set<HostAndPort> sentinels, final String masterName) {
    HostAndPort master = null;
    boolean sentinelAvailable = false;
    
    # 防止部分哨兵不可用
    for (HostAndPort sentinel : sentinels) {
      Jedis jedis = new Jedis(sentinel, sentinelClientConfig)) 
      # 连接哨兵进程并通过"SENTINEL get-master-addr-by-name mymaster"命令查询当前主节点
      List<String> masterAddr = jedis.sentinelGetMasterAddrByName(masterName);
      sentinelAvailable = true;
      if (masterAddr == null || masterAddr.size() != 2) {
          continue;
      }
      master = toHostAndPort(masterAddr);
      break;
    }
    # MasterListener是Thread的子类
    # 是通过异步线程去检测主从切换事件，然后及时更新主节点，清理连接池
    for (HostAndPort sentinel : sentinels) {
      MasterListener masterListener = new MasterListener(masterName, sentinel.getHost(), sentinel.getPort());
      masterListener.setDaemon(true);
      masterListeners.add(masterListener);
      masterListener.start();
    }
    return master;
  }

MasterListener 的run方法，代码有删减

MasterListener是JedisSentinelPool内部类，因此能够操作JedisSentinelPool的变量(masterName)和方法(initMaster)
感兴趣的同学可以继续深入JedisPubSub代码，可以发现如下：

  • 主从切换事件是哨兵进程主动推送过来的，所以能够保证实时性
    因为redis协议是双工的，所以服务端可以主动推数据给客户端。
    监听事件的过程就是，创建socket连接，然后读取数据进行解析。
    不发生主从切换事件时，没有数据推送过来，线程会阻塞在read操作上面。所以虽然run方法是死循环，但是并不会占用cpu时间。
    public void run() {
      while (running.get()) {
          final HostAndPort hostPort = new HostAndPort(host, port);
          # 连接本MasterListener关注的哨兵进程
          j = new Jedis(hostPort, sentinelClientConfig);
          
          # 监听+switch-master事件
          j.subscribe(new JedisPubSub() {
            @Override
            public void onMessage(String channel, String message) {
              String[] switchMasterMsg = message.split(" ");
              if (masterName.equals(switchMasterMsg[0])) {
                initMaster(toHostAndPort(Arrays.asList(switchMasterMsg[3], switchMasterMsg[4]))); 
              } 
            }
          }, "+switch-master");

  }

JedisSentinelPool#initMaster

如果和当前主节点信息不一致，这更新主节点信息，并清理连接池

  private void initMaster(HostAndPort master) {
    synchronized (initPoolLock) {
      if (!master.equals(currentHostMaster)) {
        currentHostMaster = master;
        factory.setHostAndPort(currentHostMaster);
        clearInternalPool();
      }
    }
  }

jedis的哨兵模式并没有实现读写分离，仅仅只与主节点建立连接。所以没办法完全挖掘集群的性能。

可以通过redisTemplate.opsForValue().set(“aaa”,“bbb”);去跟踪新连接的创建过程（非复用连接池中的连接）。
最终会追踪到JedisConnectionFactory#fetchJedisConnector方法

	protected Jedis fetchJedisConnector() {
	# jedis会开启连接池
	    if (getUsePool() && pool != null) {
			return pool.getResource();
		}
		Jedis jedis = createJedis();
		jedis.connect();
		return jedis;
	}

JedisSentinelPool负责连接的创建，JedisSentinelPool持有主节点信息

  public Jedis getResource() {
    while (true) {
      Jedis jedis = super.getResource();
      jedis.setDataSource(this);
      final HostAndPort master = currentHostMaster;
      final HostAndPort connection = new HostAndPort(jedis.getClient().getHost(), jedis.getClient()
          .getPort());

      if (master.equals(connection)) {
        return jedis;
      } else {
        returnBrokenResource(jedis);
      }
    }
  }
shuxiaohua
关注
专栏目录
HaProxy 配置Redis高可用集群
houzhe_adore的博客
09-07 4220
目标是做一个高可用的redis集群供 sensu使用。redis集群采用Sentinel + Redis 配置三节点。 配置详情可参考之前一篇博文Redis集群配置Sentinel可以做到当master挂掉后，自动选举出新的master，然后它并不是一个proxy。因此我们需要一个proxy提供一个ip给client使用，本文使用HaProxy做代理。考虑到HaProxy单节点故障问题，使用Kee
Redis Sentinel + HAProxy代理主节点（一主一备）
gallonyin的博客
06-09 943
Redis是现今最常用的缓存数据库之一，高可用一直是我们对软件服务的要求。常见的 Redis 高可用是主从+哨兵配置，在主节点挂掉后哨兵监控程序进行主从切换将从节点升级。本文采用 Redis 哨兵模式加 HAProxy 代理层实现 Redis 对后台服务的隐藏，后台服务只需要像连接单机 Redis 服务一样连接到代理程序即可。HAProxy是一款自由、快速、可靠的、开源的TCP和HTTP应用程序负载均衡器和代理服务器软件。
深入理解haproxy *.*.**.*：负载均衡实践指南
最新发布
weixin_42576410的博客
10-09 1305
本文还有配套的精品资源，点击获取 简介：haproxy是一款专注于提升网络应用可用性和性能的开源负载均衡器，尤其适用于Linux环境下的服务器集群。本文介绍haproxy . . . 版本的核心功能，包括负载均衡、高可用性、SSL/TLS终止、会话持久化、健康检查和监控报告等。文章还将指导如何在Linux环境下安装和配置haproxy ...
综合项目：Keepalived+Redis+Haproxy 实现主从热备、负载均衡、秒级切换
愿许浪尽天涯的博客
01-02 4798
Keepalived+Redis+Haproxy 群集一、部署 Redis 群集1.编译安装 Redis1）创建群集目录2）编辑配置文件3）复制配置文件到每个实例4）启动 Redis 实例2.配置 Ruby 环境1）安装 Ruby 工具2）使用脚本安装 Redis 群集3）查看群集状态二、部署 Keepalived 实现主从热备、秒级切换1.主调度器配置2.备调度器配置3.编写 Haproxy 状态检测脚本4.开启服务，验证 VIP三、部署 Haproxy 实现负载均衡1.编译安装 Haproxy2.配置
haproxy对redis进行负载均衡
weixin_33709364的博客
11-13 139
实现思路： 将两个redis-server作为后端，然后通过haproxy做为负载均衡器，每个redis-server的机器上配置配置一个用于健康检查的shell，并通过xinetd将这个shell设置为服务监听9981端口并进行管理。 haproxy通过redis-server机器上的9981端口进行健康检查，如果检查失败，就直接移除该redis-server，恢复后又自动添加   ha...
Linux下Haproxy+Redis高可用集群搭建
weixin_30730151的博客
03-16 257
高可用集群搭建分为以下步骤，请分别访问以下链接进行操作： 一、redis多实例搭建 　　http://www.cnblogs.com/bazingafraser/p/8579490.html 二、redis集群搭建 　　http://www.cnblogs.com/bazingafraser/p/8579497.html 三、Haproxy的Tcp代理搭建 　　http://www.c...
用haproxy+redis实现分布式redis服务器
热门推荐
无效的博客
09-18 1万+
redis是一个非常强大的nosql服务，不仅能替代
HAProxy代理mysql集群 和 redis
wasd986523的博客
09-09 274
#拉取镜像 docker pull haproxy:2.2 #创建目录，用于存放配置文件 mkdir /home/haproxy #创建容器 docker create --name haproxy --net host -v /home/haproxy:/usr/local/etc/haproxy haproxy:2.2 global log 127.0.0.1 local2 maxconn 4000 daemon defaults .
HAProxy对redis和mysql服务实现四层负载
y_zilong的博客
06-23 341
haproxy的配置 注意：如果使用frontend和backend，一定在frontend和backend段中都指定mode tcp [root@cen7_27 ~]# cat /etc/haproxy/conf.d/test.cfg listen web_port_80 bind 10.0.0.27:80 mode http balance roundrobin cookie WEBSRV insert nocache indirect server 10.0.0.
redis sentinel &集群+haproxy+keepalived
m0_37749659的博客
07-19 440
为什么使用nosql？
vagrant-redis-sentinel:Redis和哨兵的游乐场
05-17
要运行haproxy，请安装haproxy软件包，启用haproxy绑定任何TCP端口（ setsebool -P haproxy_connect_any 1 ）并设置haproxy.cfg defaults REDIS mode tcp timeout connect 4s timeout server 30s timeout ...
第四十六章：Redis sentinel哨兵集群1
08-08
Redis Sentinel是一种高可用性解决方案，它是Redis官方提供的一种分布式系统，专门用于监控Redis集群中的Master主服务器状态。在Master出现故障时，Sentinel能够自动进行故障转移，将健康的Slave提升为新的Master，...
利用Docker搭建你的第一个应用栈以及部署监控：Haproxy+Django+Redis+Cadvisor+Consul+Prometheus+Grafana
beast_l的博客
01-21 796
在拜读浙江大学SEL实验室著作的《Docker容器与容器云》第二版时，自己按照书中在自己的虚拟机中搭建了一个由docker容器构建的应用栈以及部署了对其的监控。由于docker hub中镜像版本的的更迭，按照书中的步骤进行部署，不免会遇到一些问题，在此记录下部署过程也分享下部署过程中踩过的坑。 搭建的环境是： 1：虚拟机工具是VMware Workstations 2：操作系统是CentOS...
redis实现HA（High Available）的两种实现方式-Sentinel与Keepalived
路漫漫，水迢迢
05-03 4159
Sentinel先来说说Sentinel，Sentinel是redis自带的一种实现HA的方式，如果在实际应用中这种方式用的比较少，比较流行的还是KeepAlived。 Redis 的 Sentinel 系统用于管理多个 Redis 服务器（instance）， 该系统执行以下三个任务： ● 监控（Monitoring）： Sentinel 会不断地检查你的主服务器和从服务器是否运作正常。
Redis + Twemproxy（五）之 HAProxy
傲然君
03-11 345
Twemproxy 主要功能在于数据分片和代理，当大并发访问 Redis 时，性能瓶颈必定在于 Twemproxy，因为所有请求最先访问 Twemproxy，然后分片到后台不同 Redis 集群。 HAProxy 优点： 最高可以同时维护40000~50000个并发连接，单位时间内处理最大的请求数为20000，最大数据处理能力可达10GBPS； 支持多余8种负载均衡算法，同时也支持 sess...
haproxy redis mysql_05.haproxy+mysql负载均衡 整合 redis集群+ssm
weixin_30909873的博客
01-26 187
本篇重点讲解haproxy+mysql负载均衡，搭建完成后与之前搭建的redis+ssm进行整合(注：这里用到了两台mysql数据库，分别安装两台虚拟机上，已经成功实现主主复制，如果有需要，请查看我另外一篇博客：http://www.cnblogs.com/cuijiale/p/8039421.html)1、首先下载最新的的haproxy安装包：haproxy-1.7.9.tar.gz下载完成后c...
推荐：Redis HA - Sentinel + HAProxy：高效且可靠的分布式数据存储解决方案
gitblog_00022的博客
06-25 356
推荐：Redis HA - Sentinel + HAProxy：高效且可靠的分布式数据存储解决方案 去发现同类优质开源项目:https://gitcode.com/ 1、项目介绍 Redis HA 是一个经过精心设计的开源解决方案，它结合了 Sentinel 和 HAProxy 的优点，为你的 Redis 集群提供高可用性和故障切换功能。通过 Sentinel 实现主从节点的自动切换，而 HAP...
keepalived+haproxy+redis-cluster 高可用负载均衡redis集群搭建
drhrht的博客
03-21 1859
搭建高可用redis-cluster集群 KeepAlived+Redis+Haproxy实现主从热备、负载均衡、秒级切换实战 Redis+Keepalived+Haproxy 的集群架构，分别用六个端口，实现多路复用，最终实现主从热备、负载均衡、秒级切换。 一、部署Redis集群 1、环境 一台虚拟机模拟6个节点，创建出3 master、3 salve 环境 redis1: 192.168.182.120:（6001~6006） 2、安装 redis 实例 （6节点） 配置截图 [root@red
haproxy配置监控redis主备切换
The magic of fingertips
10-16 4116
环境前提：     redis sentinel配置，三台主机，且配置运行良好      配置文件中添加： frontend ft_redis  bind 0.0.0.0:6379 name redis  default_backend bk_redis backend bk_redis  option tcp-che
低成本架构：HAProxy+PHP+Redis+MySQL支撑10亿周请求
"使用HAProxy、PHP、Redis和MySQL支撑10亿请求每周架构细节" 本文主要探讨了一种针对创业公司的高效且经济的应用程序架构，该架构由HAProxy、PHP、Redis和MySQL组成，能够处理每周10亿级别的请求。这种架构在确保...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值