非常好的redis主从高可用方案

最新推荐文章于 2024-10-18 14:27:26 发布
最新推荐文章于 2024-10-18 14:27:26 发布
阅读量483 收藏
点赞数
文章标签： redis php 高可用 
<?php
namespace think\cache\driver;

use think\Cache;
use think\Exception;
use think\Log;

/**
配置参数:
'cache' => [
    'type'       => 'Redisd'
    'host'       => 'A:6379,B:6379', //redis服务器ip，多台用逗号隔开；读写分离开启时，默认写A，当A主挂时，再尝试写B
    'slave'      => 'B:6379,C:6379', //redis服务器ip，多台用逗号隔开；读写分离开启时，所有IP随机读，其中一台挂时，尝试读其它节点，可以配置权重
    'port'       => 6379,    //默认的端口号
    'password'   => '',      //AUTH认证密码，当redis服务直接暴露在外网时推荐
    'timeout'    => 10,      //连接超时时间
    'expire'     => false,   //默认过期时间，默认为永不过期
    'prefix'     => '',      //缓存前缀，不宜过长
    'persistent' => false,   //是否长连接 false=短连接，推荐长连接
],

单例获取:
    $redis = \think\Cache::connect(Config::get('cache'));
    $redis->master(true)->setnx('key');
    $redis->master(false)->get('key');
 */

/**
 * ThinkPHP Redis简单主从实现的高可用方案
 *
 * 扩展依赖：https://github.com/phpredis/phpredis
 *
 * 一主一从的实践经验
 * 1, A、B为主从，正常情况下，A写，B读，通过异步同步到B（或者双写，性能有损失）
 * 2, B挂，则读写均落到A
 * 3, A挂，则尝试升级B为主，并断开主从尝试写入(要求开启slave-read-only no)
 * 4, 手工恢复A，并加入B的从
 *
 * 优化建议
 * 1，key不宜过长，value过大时请自行压缩
 * 2，gzcompress在php7下有兼容问题
 *
 * @todo
 * 1, 增加对redisCluster的兼容
 * 2, 增加tp5下的单元测试
 *
 * @author 尘缘 <130775@qq.com>
 */
class Redisd
{
    protected static $redis_rw_handler;
    protected static $redis_err_pool;
    protected $handler = null;

    protected $options = [
        'host'       => '127.0.0.1',
        'slave'      => '',
        'port'       => 6379,
        'password'   => '',
        'timeout'    => 10,
        'expire'     => false,
        'persistent' => false,
        'length'     => 0,
        'prefix'     => '',
        'serialize'  => \Redis::SERIALIZER_PHP,
    ];

    /**
     * 为了在单次php请求中复用redis连接，第一次获取的options会被缓存，第二次使用不同的$options，将会无效
     *
     * @param  array $options 缓存参数
     * @access public
     */
    public function __construct($options = [])
    {
        if (!extension_loaded('redis')) {
            throw new Exception('_NOT_SUPPERT_:redis');
        }

        $this->options         = $options         = array_merge($this->options, $options);
        $this->options['func'] = $options['persistent'] ? 'pconnect' : 'connect';

        $host  = explode(",", trim($this->options['host'], ","));
        $host  = array_map("trim", $host);
        $slave = explode(",", trim($this->options['slave'], ","));
        $slave = array_map("trim", $slave);

        $this->options["server_slave"]           = empty($slave) ? $host : $slave;
        $this->options["servers"]                = count($slave);
        $this->options["server_master"]          = array_shift($host);
        $this->options["server_master_failover"] = $host;
    }

    /**
     * 主从选择器，配置多个Host则自动启用读写分离，默认主写，随机从读
     * 随机从读的场景适合读频繁，且php与redis从位于单机的架构，这样可以减少网络IO
     * 一致Hash适合超高可用，跨网络读取，且从节点较多的情况，本业务不考虑该需求
     *
     * @access public
     * @param  bool $master true 默认主写
     * @return Redisd
     */
    public function master($master = true)
    {
        if (isset(self::$redis_rw_handler[$master])) {
            $this->handler = self::$redis_rw_handler[$master];
            return $this;
        }

        //如果不为主，则从配置的host剔除主，并随机读从，失败以后再随机选择从
        //另外一种方案是根据key的一致性hash选择不同的node，但读写频繁的业务中可能打开大量的文件句柄
        if (!$master && $this->options["servers"] > 1) {
            shuffle($this->options["server_slave"]);
            $host = array_shift($this->options["server_slave"]);
        } else {
            $host = $this->options["server_master"];
        }

        $this->handler = new \Redis();
        $func          = $this->options['func'];

        $parse = parse_url($host);
        $host  = isset($parse['host']) ? $parse['host'] : $host;
        $port  = isset($parse['host']) ? $parse['port'] : $this->options['port'];

        //发生错误则摘掉当前节点
        try {
            $result = $this->handler->$func($host, $port, $this->options['timeout']);
            if($result === false) {
                $this->handler->getLastError();
            }

            if (null != $this->options['password']) {
                $this->handler->auth($this->options['password']);
            }

            $this->handler->setOption(\Redis::OPT_SERIALIZER, $this->options['serialize']);
            if(strlen($this->options['prefix'])) {
                $this->handler->setOption(\Redis::OPT_PREFIX, $this->options['prefix']);
            }

            APP_DEBUG && Log::record("[ CACHE ] INIT Redisd : {$host}:{$port} master->" . var_export($master, true), Log::ALERT);
        } catch (\RedisException $e) {
            //phpredis throws a RedisException object if it can't reach the Redis server.
            //That can happen in case of connectivity issues, if the Redis service is down, or if the redis host is overloaded.
            //In any other problematic case that does not involve an unreachable server
            //(such as a key not existing, an invalid command, etc), phpredis will return FALSE.

            Log::record(sprintf("redisd->%s:%s:%s:%s", $master ? "master" : "salve", $host, $port, $e->getMessage()), Log::ALERT);

            //主节点挂了以后，尝试连接主备，断开主备的主从连接进行升主
            if ($master) {
                if (!count($this->options["server_master_failover"])) {
                    throw new Exception("redisd master: no more server_master_failover. {$host}:{$port} : " . $e->getMessage());
                    return false;
                }

                $this->options["server_master"] = array_shift($this->options["server_master_failover"]);
                $this->master();

                Log::record(sprintf("master is down, try server_master_failover : %s", $this->options["server_master"]), Log::ERROR);

                //如果是slave，断开主从升主，需要手工同步新主的数据到旧主上
                //目前这块的逻辑未经过严格测试
                //$this->handler->slaveof();
            } else {
                //尝试failover，如果有其它节点则进行其它节点的尝试
                foreach ($this->options["server_slave"] as $k => $v) {
                    if (trim($v) == trim($host)) {
                        unset($this->options["server_slave"][$k]);
                    }
                }

                //如果无可用节点，则抛出异常
                if (!count($this->options["server_slave"])) {
                    Log::record("已无可用Redis读节点", Log::ERROR);
                    throw new Exception("redisd slave: no more server_slave. {$host}:{$port} : " . $e->getMessage());
                    return false;
                } else {
                    Log::record("salve {$host}:{$port} is down, try another one.", Log::ALERT);
                    return $this->master(false);
                }
            }
        } catch (\Exception $e) {
            throw new Exception($e->getMessage(), $e->getCode());
        }

        self::$redis_rw_handler[$master] = $this->handler;
        return $this;
    }

    /**
     * 读取缓存
     *
     * @access public
     * @param  string $name 缓存key
     * @param  bool   $master 指定主从节点，可以从主节点获取结果
     * @return mixed
     */
    public function get($name, $master = false)
    {
        $this->master($master);

        try {
            $value = $this->handler->get($name);
        } catch (\RedisException $e) {
            unset(self::$redis_rw_handler[0]);

            $this->master();
            return $this->get($name);
        } catch (\Exception $e) {
            Log::record($e->getMessage(), Log::ERROR);
        }

        return isset($value) ? $value : null;
    }

    /**
     * 写入缓存
     *
     * @access public
     * @param  string  $name   缓存key
     * @param  mixed   $value  缓存value
     * @param  integer $expire 过期时间，单位秒
     * @return boolen
     */
    public function set($name, $value, $expire = null)
    {
        $this->master(true);

        if (is_null($expire)) {
            $expire = $this->options['expire'];
        }

        try {
            if (null === $value) {
                return $this->handler->delete($name);
            }

            if (is_int($expire) && $expire) {
                $result = $this->handler->setex($name, $expire, $value);
            } else {
                $result = $this->handler->set($name, $value);
            }
        } catch (\RedisException $e) {
            unset(self::$redis_rw_handler[1]);

            $this->master(true);
            return $this->set($name, $value, $expire);
        } catch (\Exception $e) {
            Log::record($e->getMessage());
        }

        return $result;
    }

    /**
     * 删除缓存
     *
     * @access public
     * @param  string $name 缓存变量名
     * @return boolen
     */
    public function rm($name)
    {
        $this->master(true);
        return $this->handler->delete($name);
    }

    /**
     * 清除缓存
     *
     * @access public
     * @return boolen
     */
    public function clear()
    {
        $this->master(true);
        return $this->handler->flushDB();
    }

    /**
     * 返回句柄对象，可执行其它高级方法
     * 需要先执行 $redis->master() 连接到 DB
     *
     * @access public
     * @param  bool   $master 指定主从节点，可以从主节点获取结果
     * @return \Redis
     */
    public function handler($master = true)
    {
        $this->master($master);
        return $this->handler;
    }

    /**
     * 析构释放连接
     *
     * @access public
     */
    public function __destruct()
    {
        //该方法仅在connect连接时有效
        //当使用pconnect时，连接会被重用，连接的生命周期是fpm进程的生命周期，而非一次php的执行。
        //如果代码中使用pconnect， close的作用仅是使当前php不能再进行redis请求，但无法真正关闭redis长连接，连接在后续请求中仍然会被重用，直至fpm进程生命周期结束。

        try {
            if (method_exists($this->handler, "close")) {
                $this->handler->close();
            }

        } catch (\Exception $e) {
        }
    }
}
Hacker_wtm
关注
Redis主从方案
Linvo's blog
11-06 3292
【综述】 目前官方没有提供HA集群解决方案，提供的是类似MySQL的主从同步方式，对于一般的规模和场景基本足够。 假设master为192.168.1.100:6000，slaver为192.168.1.101:6000，则slave的配置中打开 slaveof 192.168.1.100 6000 即可实现两者同步。  同步很简单，但怎样让同步更有效，集群更健壮，维护更简单呢？这些才是本文
Redis主从同步
April2nd
09-08 447
主从复制概述 主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点(master)，后者称为从节点(slave)；数据的复制是单向的，只能由主节点到从节点。 默认情况下，每台Redis服务器都是主节点；且一个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点。 主从复制的作用 主从复制的作用主要包括： 数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。 故障恢复：当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复；实际上是
使用keepalived 实现redis主从高可用
dbd379717的博客
04-14 158
　　keepalived官方有中文文档：LVS + Keepalived Chinese application doc- March 16, 2010。 　　keepalived 实现VRRP协议，从路由级别实现VIP切换，可以完全避免类似heartbeat 脑裂问题。可以很nice的实现主从、主备、互备方案，尤其是无状态业务，有状态业务就需要额外花些功夫了。 既然my...
redis 常识
qq_42496461的博客
11-05 292
Redis 管道技术 Redis 基于客户端-服务端模型以及请求/响应协议的TCP服务。客户端 发送查询请求 服务端，并监听Socket返回，通常以阻塞模式，等待服务端响应; 管道技术 在服务端未响应时，客户端可以继续向服务端发送请求，并最终一次性读取所有服务端的响应。(原理 java 处理并发请求的是排队队列) 优势，显著提高了redis服务的性能 Jedis jiedis = new Jedi...
Redis 高可用：从主从到集群的全面解析
最新发布
人心有反复，好在山水有重逢。
10-18 1108
本文详细介绍了 Redis 的主从复制、哨兵模式、集群模式以及分布式延时队列的原理、实现、优缺点及应用场景。这些机制共同构建了 Redis 高性能、高可用和高可靠性的基础，适用于各种复杂的业务场景。通过合理配置和优化这些机制，用户可以充分发挥 Redis 的优势，保障系统的稳定运行和数据的可靠性。
主从架构下的Redis高可用
lf1175914768的博客
03-23 263
什么是主从复制？ 主从复制是指将一台主服务器的数据，通过传输链路（网络或管道等）复制到其他从服务器的过程。前者称为主节点（master），后者称为从节点（slave）。 主从复制有什么好处？ 读写分离：这种架构下可以用来实现读写分离。主节点进行写操作，从节点进行读操作，可以提高服务器的负载能力，同时可以灵活应对需求的各种变化，在需要时添加或减少从节点，从而最大限度的充分利用资源。 负载均...
Redis详解（七）——Redis主从同步高可用架构
永远是少年
01-13 1151
今天继续给大家介绍Redis相关知识，本文主要内容是Redis的主从同步高可用架构。 一、Redis sentinel实现高可用原理 二、Redis sentinel实现高可用配置实战 下面，我就进行Redis哨兵sentinel实现高可用配置。 （一）实战环境 （二）Redis主从同步配置 （三）sentinel配置
5.redis主从高可用
小牛的成长史
03-02 508
在实际应用当中，为了防止redis宕机出现的单点故障，我们采用了主从高可用模式去实现，这种方式的好处是简单，轻量。     实现原理是redis服务器里面启动一个sentinel，sentinel去监听redis服务，里面有master  redis，也有多台slave  redis，当客户端调用sentinel获取master服务器，并且发送命令到master服务器，slave会去同步mast
redis-高可用-主从
菜鸡在路上找食吃
09-18 119
文章目录前言配置一、配置从服务二、修改配置启动用处主挂了怎么办 前言 主redis中的数据有两个副本（replication）即从redis-1和从redis-2，即使一台redis服务器宕机其它两台redis服务也可以继续提供服务。 主redis中的数据和从redis上的数据保持实时同步，当主redis写入数据时通过主从复制机制会复制到两个从redis服务上。 只有一个主redis，可以有多个从redis。 主从复制不会阻塞master，在同步数据时，master 可以继续处理client 请求 配置
docker-compose redis主从哨兵 redis多节点高可用 redis集群高可用
04-12
1. **Redis主从复制**：这是基础的高可用方案，通过将数据实时同步到一个或多个从节点，即使主节点故障，从节点也能无缝接管服务。在Docker Compose文件中，我们需要定义三个服务，一个为主节点，两个为从节点，并...
redis的主从高可用搭建
BrotherDong90的专栏
06-16 676
《Redis源码学习笔记》主从复制 博客分类：   Redis redisc  《Redis源码学习笔记》文章列表  由于图片较大，缩放较为模糊，请双击打开查看原图 ^_^  主从复制简单来说就是把一台redis数据库中的数据同步到另一台redis数据库，并且按照数据流向，数据的发送者我们称作master，数据的接受者我们称作slave（master/slave的划
Redis Sentinel主从高可用方案1
08-08
Redis Sentinel 提供了一种强大的高可用性解决方案，通过监控、通知和自动故障迁移功能，确保 Redis 集群在主节点故障时仍能保持服务，同时通过 Jedis SentinelPool 支持，使得客户端能轻松适应这种变化，实现平滑的...
redis 主从_Redis主从高可用解决方案哨兵模式
weixin_39957068的博客
12-08 156
Redis分布式基础主从同步Redis搭建主从同步读写分离实战通过主从和读写分离我们可以保证即使Redis服务器宕机后，我们依然是可以正常使用Redis，这里只是保证可用，但是离高可用还有一段距离。假如从服务器宕机了，还可以读另一台从服务器，那么要是主服务器挂了呢？通过读写分离，我们难以写入数据，当然我们可以重启主服务器，哈哈哈，但是，半夜三更主服务器宕机了呢？此时mango陷入深思。所...
Redis主从复制和高可用方案
leilecoffee的博客
03-06 602
Redis 安装 下载地址：https://redis.io/download tar xzf redis-5.0.3.tar.gz cd redis-5.0.3 make 启动脚本 src/redis-server 主从复制方案 从的配置文件修改 #replicaof &amp;amp;lt;masterip&amp;amp;gt; &amp;amp;lt;masterport&amp;amp;gt; replicaof 127.0.0.1 637...
【redis】主从的高可用
weixin_40660221的博客
08-26 940
Redis副本是如何保证高可用的 在redis副本的基础上，redis提供了简单易用的主从模式。从节点会精确的从主节点复制数据，并且在连接中断的时候自动重连，无论主节点发生什么都会尝试复制数据。 实现机制主要如下3种： 当主从节点连接良好时，如果主节点数据集发生改变（包括客户端写入，key过期或删除，或其他影响数据集的操作），主节点会向从节点发送一系列命令来保证从节点更新数据。 当主从之间的连接断开时，不论是网络问题还是主或从发生超时，从节点都会试图重连主节点并进行部分数据的重新同步，也就是在断开期间丢失
redis主从方案
简单-生活
12-10 752
一、主从简单配置 系统环境: CentOS Linux release 7.6.1810 (Core) redis版本: 4.1 主从配置明细 | IP | 端口 | 描述 | 配置文件 | | ------------ | ------------ | ------------ || | 127.0.0.1 | 6379 | 主redis | redisMaster.conf ...
Redis 主从复制高可用方案
preamble_1的博客
06-14 301
Redis 主从复制高可用方案   主节点：172.18.0.4 从节点：172.18.11.41  注意：所有从节点的配置都一样   停止防火墙（有可能还需要iptables加规则） systemctl stop firewalld.service    修改内核参数 vi /etc/sysctl.conf vm.overcommit_memory = 1   安装需要
Redis主从配置
01-20
Redis主从复制是一种高可用性解决方案，它允许数据在多个Redis实例之间进行同步，以防止单点故障导致的数据丢失。在主从架构中，有一个主要的Redis实例，被称为Master，负责处理所有写操作，而一个或多个辅助实例，...
浅谈Redis主从模式及集群模式的高可用
翱翔于知识的天空
10-09 235
浅谈Redis主从模式及集群模式的高可用 Redis 的高可用需要根据它的部署模式来看看，主要分为「主从模式」和「Cluster 分片模式」两种。
Redis数据库优化（主从模式，哨兵，集群）
weixin_53567573的博客
05-11 532
Redis数据库优化一、概述（一）集群介绍二、Redis主从复制的概念 一、概述 1.redis 集群有三种模式，分别是主从同步/复制、哨兵模式、Cluster，下面会介绍这三种模式的工作方式，以及搭建Cluster集群 2.在Redis中，实现高可用的技术主要包括持久化、主从复制、哨兵和集群，下面分别说明它们的作用，以及解决了什么样的问题。 持久化：持久化是最简单的高可用方法(有时甚至不被归为高可用的手段)，主要作用是数据备份，即将数据存储在硬盘，保证数据不会因进程退出而丢失。 主从复制：主从复制
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值