redis sentinel哨兵的使用

哨兵模式是Redis集群管理的一种方式。

下面以Go语言为例介绍其使用方式。

使用举例

package main
import (
    "fmt"
	"strings"
	"github.com/garyburd/redigo/redis"

	"github.com/FZambia/sentinel"
)

var RedisConnPool *redis.Pool

func InitRedisSentinelConnPool() {
	redisAddr := "192.168.1.11:26378,192.168.1.22:26378"
	redisAddrs := strings.Split(redisAddr, ",")
	masterName := "master1" // 根据redis集群具体配置设置

	sntnl := &sentinel.Sentinel{
		Addrs:      redisAddrs,
		MasterName: masterName,
		Dial: func(addr string) (redis.Conn, error) {
			timeout := 500 * time.Millisecond
			c, err := redis.DialTimeout("tcp", addr, timeout, timeout, timeout)
			if err != nil {
				return nil, err
			}
			return c, nil
		},
	}

	RedisConnPool = &redis.Pool{
		MaxIdle:     redisConfig.MaxIdle,
		IdleTimeout: 240 * time.Second,
		Dial: func() (redis.Conn, error) {
			masterAddr, err := sntnl.MasterAddr()
			if err != nil {
				return nil, err
			}
			c, err := redis.Dial("tcp", masterAddr)
			if err != nil {
				return nil, err
			}
			return c, nil
		},
		TestOnBorrow: CheckRedisRole,
	}
}

func CheckRedisRole(c redis.Conn, t time.Time) error {
	if !sentinel.TestRole(c, "master") {
		return fmt.Errorf("Role check failed")
	} else {
		return nil
	}
}

func main(){
	rc := RedisConnPool.Get()
	defer rc.Close()

	for {
		reply, err := redis.String(rc.Do("RPOP", "/queue/cmd"))
		if err != nil {
			if err != redis.ErrNil {
				log.Println("Redis RPOP failed:", err)
			}

            fmt.Println("reply:", reply)
			break
		}// if

	}// for
}

哨兵方式client端的实现原理

client查询集群中的master节点。

client查询Master

其代码如下：

// MasterAddr returns an address of current Redis master instance.
func (s *Sentinel) MasterAddr() (string, error) {
	res, err := s.doUntilSuccess(func(c redis.Conn) (interface{}, error) {
		return queryForMaster(c, s.MasterName)
	})
	if err != nil {
		return "", err
	}
	return res.(string), nil
}

基本过程是：使用redis 服务器地址，创建连接，发送请求，返回Redis Master地址。

连接redis集群使用的是轮询方式(见doUntilSuccess函数)。

doUntilSuccess函数接收查询master的函数queryForMaster作为参数，queryForMaster的代码如下。

查询master节点

func queryForMaster(conn redis.Conn, masterName string) (string, error) {
	res, err := redis.Strings(conn.Do("SENTINEL", "get-master-addr-by-name", masterName))
	if err != nil {
		return "", err
	}
	if len(res) < 2 {
		return "", errors.New("redigo: malformed get-master-addr-by-name reply")
	}
	masterAddr := net.JoinHostPort(res[0], res[1])
	return masterAddr, nil
}

轮询方式连接服务器doUntilSuccess

基本过程如下：

从Redis服务器地址中选择一台机器，尝试连接，并执行查询操作。如果成功，则直接返回结果。并将这台机器地址活跃性权重提升。

如果第一个地址失败，把这个地址从连接池中去掉，并降低活跃性权重。接着，尝试下一个地址。

如果所有地址都失败，则返回错误。

具体代码如下：

func (s *Sentinel) doUntilSuccess(f func(redis.Conn) (interface{}, error)) (interface{}, error) {
	s.mu.RLock()
	addrs := s.Addrs
	s.mu.RUnlock()

	var lastErr error

	for _, addr := range addrs {
		conn := s.get(addr)
		reply, err := f(conn)
		conn.Close()
		if err != nil {
			lastErr = err
			s.mu.Lock()
			pool, ok := s.pools[addr]
			if ok {
				pool.Close()
				delete(s.pools, addr)
			}
			s.putToBottom(addr)
			s.mu.Unlock()
			continue
		}
		s.putToTop(addr)
		return reply, nil
	}

	return nil, NoSentinelsAvailable{lastError: lastErr}
}

参考

https://github.com/garyburd/redigo

https://github.com/FZambia/go-sentinel

https://godoc.org/github.com/FZambia/go-sentinel

https://redis.io/topics/sentinel-clients